lib/ntdll/rtl/largeint.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            lib/ntdll/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 <ntdll/ntdll.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         UNIMPLEMENTED;
 129 }
 130
 131 LARGE_INTEGER
 132 STDCALL
 133 RtlLargeIntegerAdd (
 134         LARGE_INTEGER   Addend1,
 135         LARGE_INTEGER   Addend2
 136         )
 137 {
 138         LARGE_INTEGER RC;
 139
 140         RC.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
 141
 142         return RC;
 143 }
 144
 145 LARGE_INTEGER
 146 STDCALL
 147 RtlLargeIntegerArithmeticShift (
 148         LARGE_INTEGER   LargeInteger,
 149         CCHAR           ShiftCount
 150         )
 151 {
 152         LARGE_INTEGER RC;
 153         CHAR Shift;
 154
 155         Shift = ShiftCount % 64;
 156
 157         if (Shift < 32)
 158         {
 159                 RC.QuadPart = LargeInteger.QuadPart >> Shift;
 160         }
 161         else
 162         {
 163                 /* copy the sign bit */
 164                 RC.u.HighPart |= (LargeInteger.u.HighPart & 0x80000000);
 165                 RC.u.LowPart = LargeInteger.u.HighPart >> Shift;
 166         }
 167
 168         return RC;
 169 }
 170
 171 LARGE_INTEGER
 172 STDCALL
 173 RtlLargeIntegerDivide (
 174         LARGE_INTEGER   Dividend,
 175         LARGE_INTEGER   Divisor,
 176         PLARGE_INTEGER  Remainder
 177         )
 178 {
 179         LARGE_INTEGER RC;
 180
 181         if (Remainder)
 182                 Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
 183
 184         RC.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
 185
 186         return RC;
 187 }
 188
 189 LARGE_INTEGER
 190 STDCALL
 191 RtlLargeIntegerNegate (
 192         LARGE_INTEGER   Subtrahend
 193         )
 194 {
 195         LARGE_INTEGER RC;
 196
 197         RC.QuadPart = - Subtrahend.QuadPart;
 198
 199         return RC;
 200 }
 201
 202 LARGE_INTEGER
 203 STDCALL
 204 RtlLargeIntegerShiftLeft (
 205         LARGE_INTEGER   LargeInteger,
 206         CCHAR           ShiftCount
 207         )
 208 {
 209         LARGE_INTEGER RC;
 210         CCHAR Shift;
 211
 212         Shift = ShiftCount % 64;
 213         RC.QuadPart = LargeInteger.QuadPart << Shift;
 214
 215         return RC;
 216 }
 217
 218 LARGE_INTEGER
 219 STDCALL
 220 RtlLargeIntegerShiftRight (
 221         LARGE_INTEGER   LargeInteger,
 222         CCHAR           ShiftCount
 223         )
 224 {
 225         LARGE_INTEGER RC;
 226         CCHAR Shift;
 227
 228         Shift = ShiftCount % 64;
 229         RC.QuadPart = LargeInteger.QuadPart >> Shift;
 230
 231         return RC;
 232 }
 233
 234 LARGE_INTEGER
 235 STDCALL
 236 RtlLargeIntegerSubtract (
 237         LARGE_INTEGER   Minuend,
 238         LARGE_INTEGER   Subtrahend
 239         )
 240 {
 241         LARGE_INTEGER RC;
 242
 243         RC.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
 244
 245         return RC;
 246 }
 247
 248 /* EOF */