Changeset 9986 for trunk/src/NTDLL/large_int.c

Timestamp:

Apr 7, 2003, 8:40:53 PM (22 years ago)

Author:

sandervl

Message:

PF: NTDLL update for GCC 3.2.1 + resync with Wine

File:

• trunk/src/NTDLL/large_int.c (modified) (3 diffs)

trunk/src/NTDLL/large_int.c

@@ -3 +3 @@
  *
  * Copyright 2000 Alexandre Julliard
+ * Copyright 2003 Thomas Mertes
  *
  * This library is free software; you can redistribute it and/or
@@ -185 +186 @@
  * This function computes (a * b) >> (64 + shift)
  *
- * This allows replacing a division by a longlong constant
- * by a multiplication by the inverse constant.
- *
- * If 'c' is the constant divisor, the constants 'b' and 'shift'
- * must be chosen such that b = 2^(64+shift) / c.
- * Then we have RtlExtendedMagicDivide(a,b,shift) == a * b / 2^(64+shift) == a / c.
- *
- * I'm too lazy to implement it right now...
- */
-/* LONGLONG WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift )
- * {
- *     return 0;
- * }
- */
+ * RETURNS
+ *  (a * b) >> (64 + shift)
+ *
+ * NOTES
+ *  This allows replacing a division by a longlong constant
+ *  by a multiplication by the inverse constant.
+ *
+ *  If 'c' is the constant divisor, the constants 'b' and 'shift'
+ *  must be chosen such that b = 2^(64+shift) / c.
+ *  Then we have RtlExtendedMagicDivide(a,b,shift) == a * b / 2^(64+shift) == a / c.
+ *
+ *  The Parameter b although defined as LONGLONG is used as ULONGLONG.
+ */
+#define LOWER_32(A) ((A) & 0xffffffff)
+#define UPPER_32(A) ((A) >> 32)
+LONGLONG WINAPI RtlExtendedMagicDivide(
+    LONGLONG a, /* [I] Dividend to be divided by the constant divisor */
+    LONGLONG b, /* [I] Constant computed manually as 2^(64+shift) / divisor */
+    INT shift)  /* [I] Constant shift chosen to make b as big as possible for 64 bits */
+{
+    ULONGLONG a_high;
+    ULONGLONG a_low;
+    ULONGLONG b_high;
+    ULONGLONG b_low;
+    ULONGLONG ah_bl;
+    ULONGLONG al_bh;
+    LONGLONG result;
+    int positive;
+
+    if (a < 0) {
+        a_high = UPPER_32((ULONGLONG) -a);
+        a_low =  LOWER_32((ULONGLONG) -a);
+        positive = 0;
+    } else {
+        a_high = UPPER_32((ULONGLONG) a);
+        a_low =  LOWER_32((ULONGLONG) a);
+        positive = 1;
+    } /* if */
+    b_high = UPPER_32((ULONGLONG) b);
+    b_low =  LOWER_32((ULONGLONG) b);
+
+    ah_bl = a_high * b_low;
+    al_bh = a_low * b_high;
+
+    result = (LONGLONG) ((a_high * b_high +
+            UPPER_32(ah_bl) +
+            UPPER_32(al_bh) +
+            UPPER_32(LOWER_32(ah_bl) + LOWER_32(al_bh) + UPPER_32(a_low * b_low))) >> shift);
+
+    if (positive) {
+        return result;
+    } else {
+        return -result;
+    } /* if */
+}
+
+
+/******************************************************************************
+ *      RtlLargeIntegerToChar   [NTDLL.@]
+ *
+ * Convert an unsigned large integer to a character string.
+ *
+ * RETURNS
+ *  Success: STATUS_SUCCESS. str contains the converted number
+ *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
+ *           STATUS_BUFFER_OVERFLOW, if str would be larger than length.
+ *           STATUS_ACCESS_VIOLATION, if str is NULL.
+ *
+ * NOTES
+ *  Instead of base 0 it uses 10 as base.
+ *  Writes at most length characters to the string str.
+ *  Str is '\0' terminated when length allowes it.
+ *  When str fits exactly in length characters the '\0' is ommitted.
+ *  If value_ptr is NULL it crashes, as the native function does.
+ *
+ * DIFFERENCES
+ * - Accept base 0 as 10 instead of crashing as native function does.
+ * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
+ *   base 2, 8 and 16 when the value is larger than 0xFFFFFFFF. 
+ */
+NTSTATUS WINAPI RtlLargeIntegerToChar(
+    const ULONGLONG *value_ptr, /* [I] Pointer to the value to be converted */
+    ULONG base,                 /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
+    ULONG length,               /* [I] Length of the str buffer in bytes */
+    PCHAR str)                  /* [O] Destination for the converted value */
+{
+    ULONGLONG value = *value_ptr;
+    CHAR buffer[65];
+    PCHAR pos;
+    CHAR digit;
+    ULONG len;
+
+    if (base == 0) {
+        base = 10;
+    } else if (base != 2 && base != 8 && base != 10 && base != 16) {
+        return STATUS_INVALID_PARAMETER;
+    } /* if */
+
+    pos = &buffer[64];
+    *pos = '\0';
+
+    do {
+        pos--;
+        digit = value % base;
+        value = value / base;
+        if (digit < 10) {
+            *pos = '0' + digit;
+        } else {
+            *pos = 'A' + digit - 10;
+        } /* if */
+    } while (value != 0L);
+
+    len = &buffer[64] - pos;
+    if (len > length) {
+        return STATUS_BUFFER_OVERFLOW;
+    } else if (str == NULL) {
+        return STATUS_ACCESS_VIOLATION;
+    } else if (len == length) {
+        memcpy(str, pos, len);
+    } else {
+        memcpy(str, pos, len + 1);
+    } /* if */
+    return STATUS_SUCCESS;
+}
+
+
+/**************************************************************************
+ *      RtlInt64ToUnicodeString (NTDLL.@)
+ *
+ * Convert a large unsigned integer to a '\0' terminated unicode string.
+ *
+ * RETURNS
+ *  Success: STATUS_SUCCESS. str contains the converted number
+ *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
+ *           STATUS_BUFFER_OVERFLOW, if str is too small to hold the string
+ *                  (with the '\0' termination). In this case str->Length
+ *                  is set to the length, the string would have (which can
+ *                  be larger than the MaximumLength).
+ *
+ * NOTES
+ *  Instead of base 0 it uses 10 as base.
+ *  If str is NULL it crashes, as the native function does.
+ *
+ * DIFFERENCES
+ * - Accept base 0 as 10 instead of crashing as native function does.
+ * - Do not return STATUS_BUFFER_OVERFLOW when the string is long enough.
+ *   The native function does this when the string would be longer than 31
+ *   characters even when the string parameter is long enough.
+ * - The native function does produce garbage or STATUS_BUFFER_OVERFLOW for
+ *   base 2, 8 and 16 when the value is larger than 0xFFFFFFFF. 
+ */
+NTSTATUS WINAPI RtlInt64ToUnicodeString(
+    ULONGLONG value,     /* [I] Value to be converted */
+    ULONG base,          /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
+    UNICODE_STRING *str) /* [O] Destination for the converted value */
+{
+    WCHAR buffer[65];
+    PWCHAR pos;
+    WCHAR digit;
+
+    if (base == 0) {
+        base = 10;
+    } else if (base != 2 && base != 8 && base != 10 && base != 16) {
+        return STATUS_INVALID_PARAMETER;
+    } /* if */
+
+    pos = &buffer[64];
+    *pos = '\0';
+
+    do {
+        pos--;
+        digit = value % base;
+        value = value / base;
+        if (digit < 10) {
+            *pos = '0' + digit;
+        } else {
+            *pos = 'A' + digit - 10;
+        } /* if */
+    } while (value != 0L);
+
+    str->Length = (&buffer[64] - pos) * sizeof(WCHAR);
+    if (str->Length >= str->MaximumLength) {
+        return STATUS_BUFFER_OVERFLOW;
+    } else {
+        memcpy(str->Buffer, pos, str->Length + sizeof(WCHAR));
+    } /* if */
+    return STATUS_SUCCESS;
+}
 
 
@@ -244 +419 @@
     return a % b;
 }
-