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