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