Changeset 9986 for trunk/src/NTDLL/rtlstr.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/rtlstr.c (modified) (8 diffs)

trunk/src/NTDLL/rtlstr.c

@@ -30 +30 @@
 #include "wine/unicode.h"
 #include "wine/debug.h"
+#include "winnt.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
@@ -155 +156 @@
     memcpy( target->Buffer, src, len );
     target->MaximumLength = len;
-    target->Length = len - 2;
+    target->Length = len - sizeof(WCHAR);
     return TRUE;
 }
@@ -336 +337 @@
 }
 
+/**************************************************************************
+ *      RtlEqualComputerName   (NTDLL.@)
+ *
+ * Determine if two computer names are the same.
+ *
+ * PARAMS
+ *  left  [I] First computer name
+ *  right [I] Second computer name
+ *
+ * RETURNS
+ *  0 if the names are equal, non-zero otherwise.
+ *
+ * NOTES
+ *  The comparason is case insensitive.
+ */
+NTSTATUS WINAPI RtlEqualComputerName(const UNICODE_STRING *left,
+                                     const UNICODE_STRING *right)
+{
+    NTSTATUS ret;
+    STRING upLeft, upRight;
+
+    if (!(ret = RtlUpcaseUnicodeStringToOemString( &upLeft, left, TRUE )))
+    {
+       if (!(ret = RtlUpcaseUnicodeStringToOemString( &upRight, right, TRUE )))
+       {
+         ret = RtlEqualString( &upLeft, &upRight, FALSE );
+         RtlFreeOemString( &upRight );
+       }
+       RtlFreeOemString( &upLeft );
+    }
+    return ret;
+}
+
+/**************************************************************************
+ *      RtlEqualDomainName   (NTDLL.@)
+ *
+ * Determine if two domain names are the same.
+ *
+ * PARAMS
+ *  left  [I] First domain name
+ *  right [I] Second domain name
+ *
+ * RETURNS
+ *  0 if the names are equal, non-zero otherwise.
+ *
+ * NOTES
+ *  The comparason is case insensitive.
+ */
+NTSTATUS WINAPI RtlEqualDomainName(const UNICODE_STRING *left,
+                                   const UNICODE_STRING *right)
+{
+    return RtlEqualComputerName(left, right);
+}
+
 
 /*
@@ -527 +582 @@
 
 /**************************************************************************
+ *      RtlUpperChar   (NTDLL.@)
+ *
+ * Converts an Ascii character to uppercase.
+ *
+ * PARAMS
+ *  ch [I] Character to convert
+ *
+ * RETURNS
+ *  The uppercase character value.
+ *
+ * NOTES
+ *  For the input characters from 'a' .. 'z' it returns 'A' .. 'Z'.
+ *  All other input characters are returned unchanged. The locale and
+ *  multibyte characters are not taken into account (as native DLL).
+ */
+CHAR WINAPI RtlUpperChar( CHAR ch )
+{
+    if (ch >= 'a' && ch <= 'z') {
+        return ch - 'a' + 'A';
+    } else {
+        return ch;
+    } /* if */
+}
+
+/**************************************************************************
  *      RtlUpperString   (NTDLL.@)
+ *
+ * Converts an Ascii string to uppercase.
+ *
+ * PARAMS
+ *  dst [O] Destination for converted string
+ *  src [I] Source string to convert
+ *
+ * RETURNS
+ *  Nothing.
+ *
+ * NOTES
+ *  For the src characters from 'a' .. 'z' it assigns 'A' .. 'Z' to dst.
+ *  All other src characters are copied unchanged to dst. The locale and
+ *  multibyte characters are not taken into account (as native DLL).
+ *  The number of character copied is the minimum of src->Length and
+ *  the dst->MaximumLength.
  */
 void WINAPI RtlUpperString( STRING *dst, const STRING *src )
@@ -533 +629 @@
     unsigned int i, len = min(src->Length, dst->MaximumLength);
 
-    for (i = 0; i < len; i++) dst->Buffer[i] = toupper(src->Buffer[i]);
+    for (i = 0; i < len; i++) dst->Buffer[i] = RtlUpperChar(src->Buffer[i]);
     dst->Length = len;
 }
 
+
+/**************************************************************************
+ *      RtlUpcaseUnicodeChar   (NTDLL.@)
+ *
+ * Converts an Unicode character to uppercase.
+ *
+ * PARAMS
+ *  wch [I] Character to convert
+ *
+ * RETURNS
+ *  The uppercase character value.
+ */
+WCHAR WINAPI RtlUpcaseUnicodeChar( WCHAR wch )
+{
+    return toupperW(wch);
+}
+
+/**************************************************************************
+ *      RtlDowncaseUnicodeChar   (NTDLL.@)
+ *
+ * Converts an Unicode character to lowercase.
+ *
+ * PARAMS
+ *  wch [I] Character to convert
+ *
+ * RETURNS
+ *  The lowercase character value.
+ */
+WCHAR WINAPI RtlDowncaseUnicodeChar(WCHAR wch)
+{
+    return tolowerW(wch);
+}
 
 /**************************************************************************
@@ -564 +692 @@
 }
 
+
+/**************************************************************************
+ *      RtlDowncaseUnicodeString   (NTDLL.@)
+ *
+ * Converts an Unicode string to lowercase.
+ *
+ * PARAMS
+ *  dest    [O] Destination for converted string
+ *  src     [I] Source string to convert
+ *  doalloc [I] TRUE=Allocate a buffer for dest if it doesn't have one
+ *
+ * RETURNS
+ *  Success: STATUS_SUCCESS. dest contains the converted string.
+ *  Failure: STATUS_NO_MEMORY, if doalloc is TRUE and memory allocation fails, or
+ *           STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and dest is too small.
+ *
+ * NOTES
+ *  dest is never NUL terminated because it may be equal to src, and src
+ *  might not be NUL terminated. dest->Length is only set upon success.
+ */
+NTSTATUS WINAPI RtlDowncaseUnicodeString(
+        UNICODE_STRING *dest,
+        const UNICODE_STRING *src,
+        BOOLEAN doalloc)
+{
+    DWORD i;
+    DWORD len = src->Length;
+
+    if (doalloc) {
+        dest->MaximumLength = len;
+        if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) {
+            return STATUS_NO_MEMORY;
+        } /* if */
+    } else if (len > dest->MaximumLength) {
+        return STATUS_BUFFER_OVERFLOW;
+    } /* if */
+
+    for (i = 0; i < len/sizeof(WCHAR); i++) {
+        dest->Buffer[i] = tolowerW(src->Buffer[i]);
+    } /* for */
+    dest->Length = len;
+    return STATUS_SUCCESS;
+}
 
 /**************************************************************************
@@ -788 +959 @@
 {
     unsigned int len = src->Length + dst->Length;
+    if (src->Length == 0) return STATUS_SUCCESS;
     if (len > dst->MaximumLength) return STATUS_BUFFER_TOO_SMALL;
     memcpy( dst->Buffer + dst->Length/sizeof(WCHAR), src->Buffer, src->Length );
@@ -848 +1020 @@
 
 /**************************************************************************
- *      RtlUnicodeStringToInteger (NTDLL.@)
- *
- *      Convert a text buffer into its integer form
+ *      RtlCharToInteger   (NTDLL.@)
+ *
+ * Converts a character string into its integer equivalent.
+ *
+ * RETURNS
+ *  Success: STATUS_SUCCESS. value contains the converted number
+ *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
+ *           STATUS_ACCESS_VIOLATION, if value is NULL.
+ *
+ * NOTES
+ *  For base 0 it uses 10 as base and the string should be in the format
+ *      "{whitespace} [+|-] [0[x|o|b]] {digits}".
+ *  For other bases the string should be in the format
+ *      "{whitespace} [+|-] {digits}".
+ *  No check is made for value overflow, only the lower 32 bits are assigned.
+ *  If str is NULL it crashes, as the native function does.
+ *
+ * DIFFERENCES
+ *  This function does not read garbage behind '\0' as the native version does.
+ */
+NTSTATUS WINAPI RtlCharToInteger(
+    PCSZ str,      /* [I] '\0' terminated single-byte string containing a number */
+    ULONG base,    /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
+    ULONG *value)  /* [O] Destination for the converted value */
+{
+    CHAR chCurrent;
+    int digit;
+    ULONG RunningTotal = 0;
+    char bMinus = 0;
+
+    while (*str != '\0' && *str <= ' ') {
+        str++;
+    } /* while */
+
+    if (*str == '+') {
+        str++;
+    } else if (*str == '-') {
+        bMinus = 1;
+        str++;
+    } /* if */
+
+    if (base == 0) {
+        base = 10;
+        if (str[0] == '0') {
+            if (str[1] == 'b') {
+                str += 2;
+                base = 2;
+            } else if (str[1] == 'o') {
+                str += 2;
+                base = 8;
+            } else if (str[1] == 'x') {
+                str += 2;
+                base = 16;
+            } /* if */
+        } /* if */
+    } else if (base != 2 && base != 8 && base != 10 && base != 16) {
+        return STATUS_INVALID_PARAMETER;
+    } /* if */
+
+    if (value == NULL) {
+        return STATUS_ACCESS_VIOLATION;
+    } /* if */
+
+    while (*str != '\0') {
+        chCurrent = *str;
+        if (chCurrent >= '0' && chCurrent <= '9') {
+            digit = chCurrent - '0';
+        } else if (chCurrent >= 'A' && chCurrent <= 'Z') {
+            digit = chCurrent - 'A' + 10;
+        } else if (chCurrent >= 'a' && chCurrent <= 'z') {
+            digit = chCurrent - 'a' + 10;
+        } else {
+            digit = -1;
+        } /* if */
+        if (digit < 0 || digit >= base) {
+            *value = bMinus ? -RunningTotal : RunningTotal;
+            return STATUS_SUCCESS;
+        } /* if */
+
+        RunningTotal = RunningTotal * base + digit;
+        str++;
+    } /* while */
+
+    *value = bMinus ? -RunningTotal : RunningTotal;
+    return STATUS_SUCCESS;
+}
+
+/**************************************************************************
+ *      RtlIntegerToChar   (NTDLL.@)
+ *
+ * Converts an unsigned 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.
+ */
+NTSTATUS WINAPI RtlIntegerToChar(
+    ULONG value,   /* [I] 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 */
+{
+    CHAR buffer[33];
+    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[32];
+    *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[32] - 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;
+}
+
+/**************************************************************************
+ *      RtlUnicodeStringToInteger (NTDLL.@)
+ *
+ * Converts an unicode string into its integer equivalent.
+ *
+ * RETURNS
+ *  Success: STATUS_SUCCESS. value contains the converted number
+ *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
+ *           STATUS_ACCESS_VIOLATION, if value is NULL.
+ *
+ * NOTES
+ *  For base 0 it uses 10 as base and the string should be in the format
+ *      "{whitespace} [+|-] [0[x|o|b]] {digits}".
+ *  For other bases the string should be in the format
+ *      "{whitespace} [+|-] {digits}".
+ *  No check is made for value overflow, only the lower 32 bits are assigned.
+ *  If str is NULL it crashes, as the native function does.
+ *
+ * DIFFERENCES
+ *  This function does not read garbage on string length 0 as the native
+ *  version does.
  */
 NTSTATUS WINAPI RtlUnicodeStringToInteger(
-        const UNICODE_STRING *str,
-        int base,
-        int * pdest)
-{
-        LPWSTR lpwstr = str->Buffer;
-        WCHAR wchCurrent = 0;
-        int CharsParsed = 0;
-        int RunningTotal = 0;
-        char bMinus = 0;
-
-        /* no checking done on UNICODE_STRING and int* in native DLL either */
-        TRACE("(%p, %d, %p)", str, base, pdest);
-
-        switch (base)
-        {
-                case 0:
-                        base = 10;
-                        break;
-                case 2:
-                case 8:
-                case 10:
-                case 16:
-                        break;
-                default:
-                        return STATUS_INVALID_PARAMETER;
-        }
-
-        if ((str->Length) >= 4 && (base == 10) && (*lpwstr == '0') && (*(lpwstr+1) == 'x'))
-        {
-                lpwstr+=2;
+    const UNICODE_STRING *str, /* [I] Unicode string to be converted */
+    ULONG base,                /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
+    ULONG *value)              /* [O] Destination for the converted value */
+{
+    LPWSTR lpwstr = str->Buffer;
+    USHORT CharsRemaining = str->Length / sizeof(WCHAR);
+    WCHAR wchCurrent;
+    int digit;
+    ULONG RunningTotal = 0;
+    char bMinus = 0;
+
+    while (CharsRemaining >= 1 && *lpwstr <= ' ') {
+        lpwstr++;
+        CharsRemaining--;
+    } /* while */
+
+    if (CharsRemaining >= 1) {
+        if (*lpwstr == '+') {
+            lpwstr++;
+            CharsRemaining--;
+        } else if (*lpwstr == '-') {
+            bMinus = 1;
+            lpwstr++;
+            CharsRemaining--;
+        } /* if */
+    } /* if */
+
+    if (base == 0) {
+        base = 10;
+        if (CharsRemaining >= 2 && lpwstr[0] == '0') {
+            if (lpwstr[1] == 'b') {
+                lpwstr += 2;
+                CharsRemaining -= 2;
+                base = 2;
+            } else if (lpwstr[1] == 'o') {
+                lpwstr += 2;
+                CharsRemaining -= 2;
+                base = 8;
+            } else if (lpwstr[1] == 'x') {
+                lpwstr += 2;
+                CharsRemaining -= 2;
                 base = 16;
-        }
-
-        *pdest = 0;
-        for (; (CharsParsed*sizeof(WCHAR) < str->Length) && (*lpwstr <= ' '); lpwstr++)
-                CharsParsed++;
-
-        if (*lpwstr == '+')
-                lpwstr++;
-        else if (*lpwstr == '-')
-        {
-                bMinus = 1;
-                lpwstr++;
-        }
-
-        for (; (CharsParsed*sizeof(WCHAR) < str->Length) && (*lpwstr != '\0'); lpwstr++)
-        {
-                CharsParsed++;
-                wchCurrent = *lpwstr;
-                if (wchCurrent >= 'A')
-                        wchCurrent = '0' + 10 + wchCurrent - 'A';
-                if ((wchCurrent - '0') >= base || wchCurrent < '0')
-                {
-                        *pdest = bMinus ? -RunningTotal: RunningTotal;
-                        return STATUS_SUCCESS;
-                }
-                /*
-                 * increase significance of previous digits each time
-                 * we find another valid one and add on this valid one
-                 */
-                RunningTotal = wchCurrent - '0' + RunningTotal * base;
-        }
-
-        *pdest = bMinus ? -RunningTotal : RunningTotal;
-        return STATUS_SUCCESS;
-}
+            } /* if */
+        } /* if */
+    } else if (base != 2 && base != 8 && base != 10 && base != 16) {
+        return STATUS_INVALID_PARAMETER;
+    } /* if */
+
+    if (value == NULL) {
+        return STATUS_ACCESS_VIOLATION;
+    } /* if */
+
+    while (CharsRemaining >= 1) {
+        wchCurrent = *lpwstr;
+        if (wchCurrent >= '0' && wchCurrent <= '9') {
+            digit = wchCurrent - '0';
+        } else if (wchCurrent >= 'A' && wchCurrent <= 'Z') {
+            digit = wchCurrent - 'A' + 10;
+        } else if (wchCurrent >= 'a' && wchCurrent <= 'z') {
+            digit = wchCurrent - 'a' + 10;
+        } else {
+            digit = -1;
+        } /* if */
+        if (digit < 0 || digit >= base) {
+            *value = bMinus ? -RunningTotal : RunningTotal;
+            return STATUS_SUCCESS;
+        } /* if */
+
+        RunningTotal = RunningTotal * base + digit;
+        lpwstr++;
+        CharsRemaining--;
+    } /* while */
+
+    *value = bMinus ? -RunningTotal : RunningTotal;
+    return STATUS_SUCCESS;
+}
+
+/**************************************************************************
+ *      RtlIntegerToUnicodeString (NTDLL.@)
+ *
+ * Converts an 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
+ *  Do not return STATUS_BUFFER_OVERFLOW when the string is long enough.
+ *  The native function does this when the string would be longer than 16
+ *  characters even when the string parameter is long enough.
+ */
+NTSTATUS WINAPI RtlIntegerToUnicodeString(
+    ULONG 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[33];
+    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[32];
+    *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[32] - 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;
+}