ntoskrnl/rtl/largeint.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            kernel/rtl/largeint.c
   6  * PURPOSE:         Large integer operations
   7  * UPDATE HISTORY:
   8  *                  Created 22/05/98
   9  *   08/30/98  RJJ  Implemented several functions
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <ddk/ntddk.h>
  15
  16 #define NDEBUG
  17 #include <internal/debug.h>
  18
  19
  20 /* FUNCTIONS *****************************************************************/
  21
  22 #ifndef LIBCAPTIVE
  23
  24 LARGE_INTEGER
  25 STDCALL
  26 RtlConvertLongToLargeInteger (
  27         LONG    SignedInteger
  28         )
  29 {
  30         LARGE_INTEGER RC;
  31
  32         RC.QuadPart = SignedInteger;
  33
  34         return RC;
  35 }
  36
  37 LARGE_INTEGER
  38 STDCALL
  39 RtlConvertUlongToLargeInteger (
  40         ULONG   UnsignedInteger
  41         )
  42 {
  43         LARGE_INTEGER RC;
  44
  45         RC.QuadPart = UnsignedInteger;
  46
  47         return RC;
  48 }
  49
  50 LARGE_INTEGER
  51 STDCALL
  52 RtlEnlargedIntegerMultiply (
  53         LONG    Multiplicand,
  54         LONG    Multiplier
  55         )
  56 {
  57         LARGE_INTEGER RC;
  58
  59         RC.QuadPart = (LONGLONG) Multiplicand * Multiplier;
  60
  61         return RC;
  62 }
  63
  64 ULONG
  65 STDCALL
  66 RtlEnlargedUnsignedDivide (
  67         ULARGE_INTEGER  Dividend,
  68         ULONG           Divisor,
  69         PULONG          Remainder
  70         )
  71 {
  72         if (Remainder)
  73                 *Remainder = Dividend.QuadPart % Divisor;
  74
  75         return (ULONG)(Dividend.QuadPart / Divisor);
  76 }
  77
  78 LARGE_INTEGER
  79 STDCALL
  80 RtlEnlargedUnsignedMultiply (
  81         ULONG   Multiplicand,
  82         ULONG   Multiplier
  83         )
  84 {
  85         LARGE_INTEGER RC;
  86
  87         RC.QuadPart = (ULONGLONG) Multiplicand * Multiplier;
  88
  89         return RC;
  90 }
  91
  92 LARGE_INTEGER
  93 STDCALL
  94 RtlExtendedIntegerMultiply (
  95         LARGE_INTEGER   Multiplicand,
  96         LONG            Multiplier
  97         )
  98 {
  99         LARGE_INTEGER RC;
 100
 101         RC.QuadPart = Multiplicand.QuadPart * Multiplier;
 102
 103         return RC;
 104 }
 105
 106 LARGE_INTEGER
 107 STDCALL
 108 RtlExtendedLargeIntegerDivide (
 109         LARGE_INTEGER   Dividend,
 110         ULONG           Divisor,
 111         PULONG          Remainder
 112         )
 113 {
 114         LARGE_INTEGER RC;
 115
 116         if (Remainder)
 117                 *Remainder = Dividend.QuadPart % Divisor;
 118
 119         RC.QuadPart = Dividend.QuadPart / Divisor;
 120
 121         return RC;
 122 }
 123
 124 LARGE_INTEGER
 125 STDCALL
 126 RtlExtendedMagicDivide (LARGE_INTEGER   Dividend,
 127                         LARGE_INTEGER   MagicDivisor,
 128                         CCHAR           ShiftCount)
 129 {
 130   LARGE_INTEGER Result;
 131
 132   Result.QuadPart = (Dividend.QuadPart * MagicDivisor.QuadPart) >> ShiftCount;
 133   return(Result);
 134 }
 135
 136 #endif /* LIBCAPTIVE */
 137
 138 LARGE_INTEGER
 139 STDCALL
 140 RtlLargeIntegerAdd (
 141         LARGE_INTEGER   Addend1,
 142         LARGE_INTEGER   Addend2
 143         )
 144 {
 145         LARGE_INTEGER RC;
 146
 147         RC.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
 148
 149         return RC;
 150 }
 151
 152 #ifndef LIBCAPTIVE
 153
 154 LARGE_INTEGER
 155 STDCALL
 156 RtlLargeIntegerArithmeticShift (
 157         LARGE_INTEGER   LargeInteger,
 158         CCHAR           ShiftCount
 159         )
 160 {
 161         LARGE_INTEGER RC;
 162         CHAR Shift;
 163
 164         Shift = ShiftCount % 64;
 165
 166         if (Shift < 32)
 167         {
 168                 RC.QuadPart = LargeInteger.QuadPart >> Shift;
 169         }
 170         else
 171         {
 172                 /* copy the sign bit */
 173                 RC.u.HighPart |= (LargeInteger.u.HighPart & 0x80000000);
 174                 RC.u.LowPart = LargeInteger.u.HighPart >> Shift;
 175         }
 176
 177         return RC;
 178 }
 179
 180 LARGE_INTEGER
 181 STDCALL
 182 RtlLargeIntegerDivide (
 183         LARGE_INTEGER   Dividend,
 184         LARGE_INTEGER   Divisor,
 185         PLARGE_INTEGER  Remainder
 186         )
 187 {
 188         LARGE_INTEGER RC;
 189
 190         if (Remainder)
 191                 Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
 192
 193         RC.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
 194
 195         return RC;
 196 }
 197
 198 LARGE_INTEGER
 199 STDCALL
 200 RtlLargeIntegerNegate (
 201         LARGE_INTEGER   Subtrahend
 202         )
 203 {
 204         LARGE_INTEGER RC;
 205
 206         RC.QuadPart = - Subtrahend.QuadPart;
 207
 208         return RC;
 209 }
 210
 211 LARGE_INTEGER
 212 STDCALL
 213 RtlLargeIntegerShiftLeft (
 214         LARGE_INTEGER   LargeInteger,
 215         CCHAR           ShiftCount
 216         )
 217 {
 218         LARGE_INTEGER RC;
 219         CHAR Shift;
 220
 221         Shift = ShiftCount % 64;
 222         RC.QuadPart = LargeInteger.QuadPart << Shift;
 223
 224         return RC;
 225 }
 226
 227 LARGE_INTEGER
 228 STDCALL
 229 RtlLargeIntegerShiftRight (
 230         LARGE_INTEGER   LargeInteger,
 231         CCHAR           ShiftCount
 232         )
 233 {
 234         LARGE_INTEGER RC;
 235         CHAR Shift;
 236
 237         Shift = ShiftCount % 64;
 238         RC.QuadPart = LargeInteger.QuadPart >> ShiftCount;
 239
 240         return RC;
 241 }
 242
 243 LARGE_INTEGER
 244 STDCALL
 245 RtlLargeIntegerSubtract (
 246         LARGE_INTEGER   Minuend,
 247         LARGE_INTEGER   Subtrahend
 248         )
 249 {
 250         LARGE_INTEGER RC;
 251
 252         RC.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
 253
 254         return RC;
 255 }
 256
 257 #endif /* LIBCAPTIVE */
 258
 259 /* EOF */