dlls/ntdll/large_int.c

   1 /*
   2  * Large integer functions
   3  *
   4  * Copyright 2000 Alexandre Julliard
   5  * Copyright 2003 Thomas Mertes
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "ntstatus.h"
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winreg.h"
  28 #include "winternl.h"
  29
  30 /*
  31  * Note: we use LONGLONG instead of LARGE_INTEGER, because
  32  * the latter is a structure and the calling convention for
  33  * returning a structure would not be binary-compatible.
  34  *
  35  * FIXME: for platforms that don't have a native LONGLONG type,
  36  * we should define LONGLONG as a structure similar to LARGE_INTEGER
  37  * and do everything by hand. You are welcome to do it...
  38  */
  39
  40 /******************************************************************************
  41  *        RtlLargeIntegerAdd   (NTDLL.@)
  42  *
  43  * Add two 64 bit integers.
  44  *
  45  * PARAMS
  46  *  a [I] Initial number.
  47  *  b [I] Number to add to a.
  48  *
  49  * RETURNS
  50  *  The sum of a and b.
  51  */
  52 LONGLONG WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b )
  53 {
  54     return a + b;
  55 }
  56
  57
  58 /******************************************************************************
  59  *        RtlLargeIntegerSubtract   (NTDLL.@)
  60  *
  61  * Subtract two 64 bit integers.
  62  *
  63  * PARAMS
  64  *  a [I] Initial number.
  65  *  b [I] Number to subtract from a.
  66  *
  67  * RETURNS
  68  *  The difference of a and b.
  69  */
  70 LONGLONG WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b )
  71 {
  72     return a - b;
  73 }
  74
  75
  76 /******************************************************************************
  77  *        RtlLargeIntegerNegate   (NTDLL.@)
  78  *
  79  * Negate a 64 bit integer.
  80  *
  81  * PARAMS
  82  *  a     [I] Initial number.
  83  *
  84  * RETURNS
  85  *  The value of a negated.
  86  */
  87 LONGLONG WINAPI RtlLargeIntegerNegate( LONGLONG a )
  88 {
  89     return -a;
  90 }
  91
  92
  93 /******************************************************************************
  94  *        RtlLargeIntegerShiftLeft   (NTDLL.@)
  95  *
  96  * Perform a shift left on a 64 bit integer.
  97  *
  98  * PARAMS
  99  *  a     [I] Initial number.
 100  *  count [I] Number of bits to shift by
 101  *
 102  * RETURNS
 103  *  The value of a following the shift.
 104  */
 105 LONGLONG WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count )
 106 {
 107     return a << count;
 108 }
 109
 110
 111 /******************************************************************************
 112  *        RtlLargeIntegerShiftRight   (NTDLL.@)
 113  *
 114  * Perform a shift right on a 64 bit integer.
 115  *
 116  * PARAMS
 117  *  a     [I] Initial number.
 118  *  count [I] Number of bits to shift by
 119  *
 120  * RETURNS
 121  *  The value of a following the shift.
 122  */
 123 LONGLONG WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count )
 124 {
 125     return (ULONGLONG)a >> count;
 126 }
 127
 128
 129 /******************************************************************************
 130  *        RtlLargeIntegerArithmeticShift   (NTDLL.@)
 131  *
 132  * Perform an arithmetic shift right on a 64 bit integer.
 133  *
 134  * PARAMS
 135  *  a     [I] Initial number.
 136  *  count [I] Number of bits to shift by
 137  *
 138  * RETURNS
 139  *  The value of a following the shift.
 140  */
 141 LONGLONG WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count )
 142 {
 143     /* FIXME: gcc does arithmetic shift here, but it may not be true on all platforms */
 144     return a >> count;
 145 }
 146
 147
 148 /******************************************************************************
 149  *        RtlLargeIntegerDivide   (NTDLL.@)
 150  *
 151  * Divide one 64 bit unsigned integer by another, with remainder.
 152  *
 153  * PARAMS
 154  *  a   [I] Initial number.
 155  *  b   [I] Number to divide a by
 156  *  rem [O] Destination for remainder
 157  *
 158  * RETURNS
 159  *  The dividend of a and b. If rem is non-NULL it is set to the remainder.
 160  *
 161  * FIXME
 162  *  Should it be signed division instead?
 163  */
 164 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem )
 165 {
 166     ULONGLONG ret = a / b;
 167     if (rem) *rem = a - ret * b;
 168     return ret;
 169 }
 170
 171
 172 /******************************************************************************
 173  *        RtlConvertLongToLargeInteger   (NTDLL.@)
 174  *
 175  * Convert a 32 bit integer into 64 bits.
 176  *
 177  * PARAMS
 178  *  a [I] Number to convert
 179  *
 180  * RETURNS
 181  *  a.
 182  */
 183 LONGLONG WINAPI RtlConvertLongToLargeInteger( LONG a )
 184 {
 185     return a;
 186 }
 187
 188
 189 /******************************************************************************
 190  *        RtlConvertUlongToLargeInteger   (NTDLL.@)
 191  *
 192  * Convert a 32 bit unsigned integer into 64 bits.
 193  *
 194  * PARAMS
 195  *  a [I] Number to convert
 196  *
 197  * RETURNS
 198  *  a.
 199  */
 200 ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a )
 201 {
 202     return a;
 203 }
 204
 205
 206 /******************************************************************************
 207  *        RtlEnlargedIntegerMultiply   (NTDLL.@)
 208  *
 209  * Multiply two integers giving a 64 bit integer result.
 210  *
 211  * PARAMS
 212  *  a [I] Initial number.
 213  *  b [I] Number to multiply a by.
 214  *
 215  * RETURNS
 216  *  The product of a and b.
 217  */
 218 LONGLONG WINAPI RtlEnlargedIntegerMultiply( INT a, INT b )
 219 {
 220     return (LONGLONG)a * b;
 221 }
 222
 223
 224 /******************************************************************************
 225  *        RtlEnlargedUnsignedMultiply   (NTDLL.@)
 226  *
 227  * Multiply two unsigned integers giving a 64 bit unsigned integer result.
 228  *
 229  * PARAMS
 230  *  a [I] Initial number.
 231  *  b [I] Number to multiply a by.
 232  *
 233  * RETURNS
 234  *  The product of a and b.
 235  */
 236 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b )
 237 {
 238     return (ULONGLONG)a * b;
 239 }
 240
 241
 242 /******************************************************************************
 243  *        RtlEnlargedUnsignedDivide   (NTDLL.@)
 244  *
 245  * Divide one 64 bit unsigned integer by a 32 bit unsigned integer, with remainder.
 246  *
 247  * PARAMS
 248  *  a      [I] Initial number.
 249  *  b      [I] Number to divide a by
 250  *  remptr [O] Destination for remainder
 251  *
 252  * RETURNS
 253  *  The dividend of a and b. If remptr is non-NULL it is set to the remainder.
 254  */
 255 UINT WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr )
 256 {
 257 #if defined(__i386__) && defined(__GNUC__)
 258     UINT ret, rem, p1, p2;
 259
 260     p1 = a >> 32;
 261     p2 = a &  0xffffffffLL;
 262
 263     __asm__("div %4,%%eax"
 264             : "=a" (ret), "=d" (rem)
 265             : "0" (p2), "1" (p1), "g" (b) );
 266     if (remptr) *remptr = rem;
 267     return ret;
 268 #else
 269     UINT ret = a / b;
 270     if (remptr) *remptr = a % b;
 271     return ret;
 272 #endif
 273 }
 274
 275
 276 /******************************************************************************
 277  *        RtlExtendedLargeIntegerDivide   (NTDLL.@)
 278  *
 279  * Divide one 64 bit integer by a 32 bit integer, with remainder.
 280  *
 281  * PARAMS
 282  *  a   [I] Initial number.
 283  *  b   [I] Number to divide a by
 284  *  rem [O] Destination for remainder
 285  *
 286  * RETURNS
 287  *  The dividend of a and b. If rem is non-NULL it is set to the remainder.
 288  */
 289 LONGLONG WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem )
 290 {
 291     LONGLONG ret = a / b;
 292     if (rem) *rem = a - b * ret;
 293     return ret;
 294 }
 295
 296
 297 /******************************************************************************
 298  *        RtlExtendedIntegerMultiply   (NTDLL.@)
 299  *
 300  * Multiply one 64 bit integer by another 32 bit integer.
 301  *
 302  * PARAMS
 303  *  a [I] Initial number.
 304  *  b [I] Number to multiply a by.
 305  *
 306  * RETURNS
 307  *  The product of a and b.
 308  */
 309 LONGLONG WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b )
 310 {
 311     return a * b;
 312 }
 313
 314
 315 /******************************************************************************
 316  *        RtlExtendedMagicDivide   (NTDLL.@)
 317  *
 318  * Allows replacing a division by a longlong constant with a multiplication by
 319  * the inverse constant.
 320  *
 321  * RETURNS
 322  *  (dividend * inverse_divisor) >> (64 + shift)
 323  *
 324  * NOTES
 325  *  If the divisor of a division is constant, the constants inverse_divisor and
 326  *  shift must be chosen such that inverse_divisor = 2^(64 + shift) / divisor.
 327  *  Then we have RtlExtendedMagicDivide(dividend,inverse_divisor,shift) ==
 328  *  dividend * inverse_divisor / 2^(64 + shift) == dividend / divisor.
 329  *
 330  *  The Parameter inverse_divisor although defined as LONGLONG is used as
 331  *  ULONGLONG.
 332  */
 333 #define LOWER_32(A) ((A) & 0xffffffff)
 334 #define UPPER_32(A) ((A) >> 32)
 335 LONGLONG WINAPI RtlExtendedMagicDivide(
 336     LONGLONG dividend,        /* [I] Dividend to be divided by the constant divisor */
 337     LONGLONG inverse_divisor, /* [I] Constant computed manually as 2^(64+shift) / divisor */
 338     INT shift)                /* [I] Constant shift chosen to make inverse_divisor as big as possible for 64 bits */
 339 {
 340     ULONGLONG dividend_high;
 341     ULONGLONG dividend_low;
 342     ULONGLONG inverse_divisor_high;
 343     ULONGLONG inverse_divisor_low;
 344     ULONGLONG ah_bl;
 345     ULONGLONG al_bh;
 346     LONGLONG result;
 347     int positive;
 348
 349     if (dividend < 0) {
 350         dividend_high = UPPER_32((ULONGLONG) -dividend);
 351         dividend_low =  LOWER_32((ULONGLONG) -dividend);
 352         positive = 0;
 353     } else {
 354         dividend_high = UPPER_32((ULONGLONG) dividend);
 355         dividend_low =  LOWER_32((ULONGLONG) dividend);
 356         positive = 1;
 357     } /* if */
 358     inverse_divisor_high = UPPER_32((ULONGLONG) inverse_divisor);
 359     inverse_divisor_low =  LOWER_32((ULONGLONG) inverse_divisor);
 360
 361     ah_bl = dividend_high * inverse_divisor_low;
 362     al_bh = dividend_low * inverse_divisor_high;
 363
 364     result = (LONGLONG) ((dividend_high * inverse_divisor_high +
 365             UPPER_32(ah_bl) +
 366             UPPER_32(al_bh) +
 367             UPPER_32(LOWER_32(ah_bl) + LOWER_32(al_bh) +
 368                      UPPER_32(dividend_low * inverse_divisor_low))) >> shift);
 369
 370     if (positive) {
 371         return result;
 372     } else {
 373         return -result;
 374     } /* if */
 375 }
 376
 377
 378 /******************************************************************************
 379  *      RtlLargeIntegerToChar   [NTDLL.@]
 380  *
 381  * Convert an unsigned large integer to a character string.
 382  *
 383  * RETURNS
 384  *  Success: STATUS_SUCCESS. str contains the converted number
 385  *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
 386  *           STATUS_BUFFER_OVERFLOW, if str would be larger than length.
 387  *           STATUS_ACCESS_VIOLATION, if str is NULL.
 388  *
 389  * NOTES
 390  *  Instead of base 0 it uses 10 as base.
 391  *  Writes at most length characters to the string str.
 392  *  Str is '\0' terminated when length allowes it.
 393  *  When str fits exactly in length characters the '\0' is ommitted.
 394  *  If value_ptr is NULL it crashes, as the native function does.
 395  *
 396  * DIFFERENCES
 397  * - Accept base 0 as 10 instead of crashing as native function does.
 398  * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
 399  *   base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
 400  */
 401 NTSTATUS WINAPI RtlLargeIntegerToChar(
 402     const ULONGLONG *value_ptr, /* [I] Pointer to the value to be converted */
 403     ULONG base,                 /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
 404     ULONG length,               /* [I] Length of the str buffer in bytes */
 405     PCHAR str)                  /* [O] Destination for the converted value */
 406 {
 407     ULONGLONG value = *value_ptr;
 408     CHAR buffer[65];
 409     PCHAR pos;
 410     CHAR digit;
 411     ULONG len;
 412
 413     if (base == 0) {
 414         base = 10;
 415     } else if (base != 2 && base != 8 && base != 10 && base != 16) {
 416         return STATUS_INVALID_PARAMETER;
 417     } /* if */
 418
 419     pos = &buffer[64];
 420     *pos = '\0';
 421
 422     do {
 423         pos--;
 424         digit = value % base;
 425         value = value / base;
 426         if (digit < 10) {
 427             *pos = '0' + digit;
 428         } else {
 429             *pos = 'A' + digit - 10;
 430         } /* if */
 431     } while (value != 0L);
 432
 433     len = &buffer[64] - pos;
 434     if (len > length) {
 435         return STATUS_BUFFER_OVERFLOW;
 436     } else if (str == NULL) {
 437         return STATUS_ACCESS_VIOLATION;
 438     } else if (len == length) {
 439         memcpy(str, pos, len);
 440     } else {
 441         memcpy(str, pos, len + 1);
 442     } /* if */
 443     return STATUS_SUCCESS;
 444 }
 445
 446
 447 /**************************************************************************
 448  *      RtlInt64ToUnicodeString (NTDLL.@)
 449  *
 450  * Convert a large unsigned integer to a '\0' terminated unicode string.
 451  *
 452  * RETURNS
 453  *  Success: STATUS_SUCCESS. str contains the converted number
 454  *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
 455  *           STATUS_BUFFER_OVERFLOW, if str is too small to hold the string
 456  *                  (with the '\0' termination). In this case str->Length
 457  *                  is set to the length, the string would have (which can
 458  *                  be larger than the MaximumLength).
 459  *
 460  * NOTES
 461  *  Instead of base 0 it uses 10 as base.
 462  *  If str is NULL it crashes, as the native function does.
 463  *
 464  * DIFFERENCES
 465  * - Accept base 0 as 10 instead of crashing as native function does.
 466  * - Do not return STATUS_BUFFER_OVERFLOW when the string is long enough.
 467  *   The native function does this when the string would be longer than 31
 468  *   characters even when the string parameter is long enough.
 469  * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
 470  *   base 2, 8 and 16 when the value is larger than 0xFFFFFFFF.
 471  */
 472 NTSTATUS WINAPI RtlInt64ToUnicodeString(
 473     ULONGLONG value,     /* [I] Value to be converted */
 474     ULONG base,          /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
 475     UNICODE_STRING *str) /* [O] Destination for the converted value */
 476 {
 477     WCHAR buffer[65];
 478     PWCHAR pos;
 479     WCHAR digit;
 480
 481     if (base == 0) {
 482         base = 10;
 483     } else if (base != 2 && base != 8 && base != 10 && base != 16) {
 484         return STATUS_INVALID_PARAMETER;
 485     } /* if */
 486
 487     pos = &buffer[64];
 488     *pos = '\0';
 489
 490     do {
 491         pos--;
 492         digit = value % base;
 493         value = value / base;
 494         if (digit < 10) {
 495             *pos = '0' + digit;
 496         } else {
 497             *pos = 'A' + digit - 10;
 498         } /* if */
 499     } while (value != 0L);
 500
 501     str->Length = (&buffer[64] - pos) * sizeof(WCHAR);
 502     if (str->Length >= str->MaximumLength) {
 503         return STATUS_BUFFER_OVERFLOW;
 504     } else {
 505         memcpy(str->Buffer, pos, str->Length + sizeof(WCHAR));
 506     } /* if */
 507     return STATUS_SUCCESS;
 508 }
 509
 510
 511 /******************************************************************************
 512  *        _alldiv   (NTDLL.@)
 513  *
 514  * Divide two 64 bit unsigned integers.
 515  *
 516  * PARAMS
 517  *  a [I] Initial number.
 518  *  b [I] Number to multiply a by.
 519  *
 520  * RETURNS
 521  *  The dividend of a and b.
 522  */
 523 LONGLONG WINAPI _alldiv( LONGLONG a, LONGLONG b )
 524 {
 525     return a / b;
 526 }
 527
 528
 529 /******************************************************************************
 530  *        _allmul   (NTDLL.@)
 531  *
 532  * Multiply two 64 bit integers.
 533  *
 534  * PARAMS
 535  *  a [I] Initial number.
 536  *  b [I] Number to multiply a by.
 537  *
 538  * RETURNS
 539  *  The product of a and b.
 540  */
 541 LONGLONG WINAPI _allmul( LONGLONG a, LONGLONG b )
 542 {
 543     return a * b;
 544 }
 545
 546
 547 /******************************************************************************
 548  *        _allrem   (NTDLL.@)
 549  *
 550  * Calculate the remainder after dividing two 64 bit integers.
 551  *
 552  * PARAMS
 553  *  a [I] Initial number.
 554  *  b [I] Number to divide a by.
 555  *
 556  * RETURNS
 557  *  The remainder of a divided by b.
 558  */
 559 LONGLONG WINAPI _allrem( LONGLONG a, LONGLONG b )
 560 {
 561     return a % b;
 562 }
 563
 564
 565 /******************************************************************************
 566  *        _aulldiv   (NTDLL.@)
 567  *
 568  * Divide two 64 bit unsigned integers.
 569  *
 570  * PARAMS
 571  *  a [I] Initial number.
 572  *  b [I] Number to multiply a by.
 573  *
 574  * RETURNS
 575  *  The dividend of a and b.
 576  */
 577 ULONGLONG WINAPI _aulldiv( ULONGLONG a, ULONGLONG b )
 578 {
 579     return a / b;
 580 }
 581
 582
 583 /******************************************************************************
 584  *        _aullrem   (NTDLL.@)
 585  *
 586  * Calculate the remainder after dividing two 64 bit unsigned integers.
 587  *
 588  * PARAMS
 589  *  a [I] Initial number.
 590  *  b [I] Number to divide a by.
 591  *
 592  * RETURNS
 593  *  The remainder of a divided by b.
 594  */
 595 ULONGLONG WINAPI _aullrem( ULONGLONG a, ULONGLONG b )
 596 {
 597     return a % b;
 598 }