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

trunk/src/NTDLL/wcstring.c

@@ -4 +4 @@
  * Copyright 2000 Alexandre Julliard
  * Copyright 2000 Jon Griffiths
+ * Copyright 2003 Thomas Mertes
  *
  * This library is free software; you can redistribute it and/or
@@ -23 +24 @@
 
 #include <ctype.h>
-#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-
-#include "ntddk.h"
+#include <limits.h>
+
+#include "winternl.h"
 #include "wine/unicode.h"
 #include "wine/debug.h"
@@ -304 +305 @@
 /*********************************************************************
  *                  wcstol  (NTDLL.@)
- * Like strtol, but for wide character strings.
- */
-INT __cdecl NTDLL_wcstol(LPCWSTR s,LPWSTR *end,INT base)
-{
-    UNICODE_STRING uni;
-    ANSI_STRING ansi;
-    INT ret;
-    LPSTR endA;
-
-    RtlInitUnicodeString( &uni, s );
-    RtlUnicodeStringToAnsiString( &ansi, &uni, TRUE );
-    ret = strtol( ansi.Buffer, &endA, base );
-    if (end)
-    {
-        DWORD len;
-        RtlMultiByteToUnicodeSize( &len, ansi.Buffer, endA - ansi.Buffer );
-        *end = (LPWSTR)s + len/sizeof(WCHAR);
-    }
-    RtlFreeAnsiString( &ansi );
-    return ret;
+ */
+long __cdecl NTDLL_wcstol(LPCWSTR s,LPWSTR *end,INT base)
+{
+    return strtolW( s, end, base );
 }
 
@@ -329 +314 @@
 /*********************************************************************
  *                  wcstoul  (NTDLL.@)
- * Like strtoul, but for wide character strings.
- */
-INT __cdecl NTDLL_wcstoul(LPCWSTR s,LPWSTR *end,INT base)
-{
-    UNICODE_STRING uni;
-    ANSI_STRING ansi;
-    INT ret;
-    LPSTR endA;
-
-    RtlInitUnicodeString( &uni, s );
-    RtlUnicodeStringToAnsiString( &ansi, &uni, TRUE );
-    ret = strtoul( ansi.Buffer, &endA, base );
-    if (end)
-    {
-        DWORD len;
-        RtlMultiByteToUnicodeSize( &len, ansi.Buffer, endA - ansi.Buffer );
-        *end = (LPWSTR)s + len/sizeof(WCHAR);
-    }
-    RtlFreeAnsiString( &ansi );
-    return ret;
+ */
+unsigned long __cdecl NTDLL_wcstoul(LPCWSTR s,LPWSTR *end,INT base)
+{
+    return strtoulW( s, end, base );
 }
 
@@ -369 +338 @@
 }
 
-
-/*********************************************************************
- *           _ultow    (NTDLL.@)
- * Like _ultoa, but for wide character strings.
- */
-LPWSTR __cdecl _ultow(ULONG value, LPWSTR string, INT radix)
-{
-    WCHAR tmp[33];
-    LPWSTR tp = tmp;
-    LPWSTR sp;
-    LONG i;
-    ULONG v = value;
-
-    if (radix > 36 || radix <= 1)
-        return 0;
-
-    while (v || tp == tmp)
-    {
-        i = v % radix;
-        v = v / radix;
-        if (i < 10)
-            *tp++ = i + '0';
-        else
-            *tp++ = i + 'a' - 10;
-    }
-
-    sp = string;
-    while (tp > tmp)
-        *sp++ = *--tp;
-    *sp = 0;
-    return string;
-}
-
-/*********************************************************************
- *           _wtol    (NTDLL.@)
- * Like atol, but for wide character strings.
- */
-LONG __cdecl _wtol(LPWSTR string)
-{
-    char buffer[30];
-    NTDLL_wcstombs( buffer, string, sizeof(buffer) );
-    return atol( buffer );
-}
-
-/*********************************************************************
- *           _wtoi    (NTDLL.@)
- */
-INT __cdecl _wtoi(LPWSTR string)
+/*********************************************************************
+ *              iswdigit (NTDLL.@)
+ *
+ * Checks if an unicode char wc is a digit
+ *
+ * RETURNS
+ *  TRUE: The unicode char wc is a digit.
+ *  FALSE: Otherwise
+ */
+INT __cdecl NTDLL_iswdigit( WCHAR wc )
+{
+    return isdigitW(wc);
+}
+
+
+/*********************************************************************
+ *              iswlower (NTDLL.@)
+ *
+ * Checks if an unicode char wc is a lower case letter
+ *
+ * RETURNS
+ *  TRUE: The unicode char wc is a lower case letter.
+ *  FALSE: Otherwise
+ */
+INT __cdecl NTDLL_iswlower( WCHAR wc )
+{
+    return islowerW(wc);
+}
+
+
+/*********************************************************************
+ *              iswspace (NTDLL.@)
+ *
+ * Checks if an unicode char wc is a white space character
+ *
+ * RETURNS
+ *  TRUE: The unicode char wc is a white space character.
+ *  FALSE: Otherwise
+ */
+INT __cdecl NTDLL_iswspace( WCHAR wc )
+{
+    return isspaceW(wc);
+}
+
+
+/*********************************************************************
+ *              iswxdigit (NTDLL.@)
+ *
+ * Checks if an unicode char wc is an extended digit
+ *
+ * RETURNS
+ *  TRUE: The unicode char wc is an extended digit.
+ *  FALSE: Otherwise
+ */
+INT __cdecl NTDLL_iswxdigit( WCHAR wc )
+{
+    return isxdigitW(wc);
+}
+
+
+/*********************************************************************
+ *      _ultow   (NTDLL.@)
+ *
+ * Converts an unsigned long integer to an unicode string.
+ *
+ * Assigns a '\0' terminated string to str and returns str.
+ * Does not check if radix is in the range of 2 to 36 (as native DLL).
+ * For str == NULL just returns NULL (as native DLL).
+ */
+LPWSTR __cdecl _ultow( unsigned long value, LPWSTR str, INT radix )
+{
+    WCHAR buffer[33];
+    PWCHAR pos;
+    WCHAR digit;
+
+    pos = &buffer[32];
+    *pos = '\0';
+
+    do {
+        digit = value % radix;
+        value = value / radix;
+        if (digit < 10) {
+            *--pos = '0' + digit;
+        } else {
+            *--pos = 'a' + digit - 10;
+        } /* if */
+    } while (value != 0L);
+
+    if (str != NULL) {
+        memcpy(str, pos, (&buffer[32] - pos + 1) * sizeof(WCHAR));
+    } /* if */
+    return str;
+}
+
+
+/*********************************************************************
+ *      _ltow   (NTDLL.@)
+ *
+ * Converts a long integer to an unicode string.
+ *
+ * RETURNS
+ *  Always returns str.
+ *
+ * NOTES
+ *  Converts value to a '\0' terminated wstring which is copied to str.
+ *  The maximum length of the copied str is 33 bytes. If radix
+ *  is 10 and value is negative, the value is converted with sign.
+ *  Does not check if radix is in the range of 2 to 36.
+ *  If str is NULL it just returns NULL.
+ */
+LPWSTR __cdecl _ltow(
+    long value, /* [I] Value to be converted */
+    LPWSTR str, /* [O] Destination for the converted value */
+    INT radix)  /* [I] Number base for conversion */
+{
+    unsigned long val;
+    int negative;
+    WCHAR buffer[33];
+    PWCHAR pos;
+    WCHAR digit;
+
+    if (value < 0 && radix == 10) {
+        negative = 1;
+        val = -value;
+    } else {
+        negative = 0;
+        val = value;
+    } /* if */
+
+    pos = &buffer[32];
+    *pos = '\0';
+
+    do {
+        digit = val % radix;
+        val = val / radix;
+        if (digit < 10) {
+            *--pos = '0' + digit;
+        } else {
+            *--pos = 'a' + digit - 10;
+        } /* if */
+    } while (val != 0L);
+
+    if (negative) {
+        *--pos = '-';
+    } /* if */
+
+    if (str != NULL) {
+        memcpy(str, pos, (&buffer[32] - pos + 1) * sizeof(WCHAR));
+    } /* if */
+    return str;
+}
+
+
+
+/*********************************************************************
+ *      _itow    (NTDLL.@)
+ *
+ * Converts an integer to an unicode string.
+ *
+ * RETURNS
+ *  Always returns str.
+ *
+ * NOTES
+ *  Converts value to a '\0' terminated wstring which is copied to str.
+ *  The maximum length of the copied str is 33 bytes. If radix
+ *  is 10 and value is negative, the value is converted with sign.
+ *  Does not check if radix is in the range of 2 to 36.
+ *  If str is NULL it just returns NULL.
+ *
+ * DIFFERENCES
+ * - The native function crashes when the string is longer than 19 chars.
+ *   This function does not have this bug.
+ */
+LPWSTR __cdecl _itow(
+    int value,  /* [I] Value to be converted */
+    LPWSTR str, /* [O] Destination for the converted value */
+    INT radix)  /* [I] Number base for conversion */
+{
+    return _ltow(value, str, radix);
+}
+
+
+/*********************************************************************
+ *      _ui64tow   (NTDLL.@)
+ *
+ * Converts a large unsigned integer to an unicode string.
+ *
+ * Assigns a '\0' terminated wstring to str and returns str.
+ * Does not check if radix is in the range of 2 to 36 (as native DLL).
+ * For str == NULL just returns NULL (as native DLL).
+ *
+ * Difference:
+ * - This function does not exist in the native DLL (but in msvcrt).
+ *   But since the maintenance of all these functions is better done
+ *   in one place we implement it here.
+ */
+LPWSTR __cdecl _ui64tow( ULONGLONG value, LPWSTR str, INT radix )
+{
+    WCHAR buffer[65];
+    PWCHAR pos;
+    WCHAR digit;
+
+    pos = &buffer[64];
+    *pos = '\0';
+
+    do {
+        digit = value % radix;
+        value = value / radix;
+        if (digit < 10) {
+            *--pos = '0' + digit;
+        } else {
+            *--pos = 'a' + digit - 10;
+        } /* if */
+    } while (value != 0L);
+
+    if (str != NULL) {
+        memcpy(str, pos, (&buffer[64] - pos + 1) * sizeof(WCHAR));
+    } /* if */
+    return str;
+}
+
+
+/*********************************************************************
+ *      _i64tow   (NTDLL.@)
+ *
+ * Converts a large integer to an unicode string.
+ *
+ * Assigns a '\0' terminated wstring to str and returns str. If radix
+ * is 10 and value is negative, the value is converted with sign.
+ * Does not check if radix is in the range of 2 to 36 (as native DLL).
+ * For str == NULL just returns NULL (as native DLL).
+ *
+ * Difference:
+ * - The native DLL converts negative values (for base 10) wrong:
+ *                     -1 is converted to -18446744073709551615
+ *                     -2 is converted to -18446744073709551614
+ *   -9223372036854775807 is converted to  -9223372036854775809
+ *   -9223372036854775808 is converted to  -9223372036854775808
+ *   The native msvcrt _i64tow function and our ntdll function do
+ *   not have this bug.
+ */
+LPWSTR __cdecl _i64tow( LONGLONG value, LPWSTR str, INT radix )
+{
+    ULONGLONG val;
+    int negative;
+    WCHAR buffer[65];
+    PWCHAR pos;
+    WCHAR digit;
+
+    if (value < 0 && radix == 10) {
+        negative = 1;
+        val = -value;
+    } else {
+        negative = 0;
+        val = value;
+    } /* if */
+
+    pos = &buffer[64];
+    *pos = '\0';
+
+    do {
+        digit = val % radix;
+        val = val / radix;
+        if (digit < 10) {
+            *--pos = '0' + digit;
+        } else {
+            *--pos = 'a' + digit - 10;
+        } /* if */
+    } while (val != 0L);
+
+    if (negative) {
+        *--pos = '-';
+    } /* if */
+
+    if (str != NULL) {
+        memcpy(str, pos, (&buffer[64] - pos + 1) * sizeof(WCHAR));
+    } /* if */
+    return str;
+}
+
+
+/*********************************************************************
+ *      _wtol    (NTDLL.@)
+ *
+ * Converts an unicode string to a long integer.
+ *
+ * On success it returns the integer value otherwise it returns 0.
+ * Accepts: {whitespace} [+|-] {digits}
+ * No check of overflow: Just assigns lower 32 bits (as native DLL).
+ * Does not check for str != NULL (as native DLL).
+ */
+LONG __cdecl _wtol( LPWSTR str )
+{
+    ULONG RunningTotal = 0;
+    char bMinus = 0;
+
+    while (isspaceW(*str)) {
+        str++;
+    } /* while */
+
+    if (*str == '+') {
+        str++;
+    } else if (*str == '-') {
+        bMinus = 1;
+        str++;
+    } /* if */
+
+    while (*str >= '0' && *str <= '9') {
+        RunningTotal = RunningTotal * 10 + *str - '0';
+        str++;
+    } /* while */
+
+    return bMinus ? -RunningTotal : RunningTotal;
+}
+
+
+/*********************************************************************
+ *      _wtoi    (NTDLL.@)
+ *
+ * Converts an unicode string to an integer.
+ *
+ * On success it returns the integer value otherwise it returns 0.
+ * Accepts: {whitespace} [+|-] {digits}
+ * No check of overflow: Just assigns lower 32 bits (as native DLL).
+ * Does not check for str != NULL (as native DLL).
+ */
+int __cdecl _wtoi( LPWSTR string )
 {
     return _wtol(string);
 }
 
-/* INTERNAL: Wide char snprintf
- * If you fix a bug in this function, fix it in msvcrt/wcs.c also!
- */
-static int __cdecl NTDLL_vsnwprintf(WCHAR *str, unsigned int len,
-                                    const WCHAR *format, va_list valist)
-{
-  unsigned int written = 0;
-  const WCHAR *iter = format;
-  char bufa[256], fmtbufa[64], *fmta;
-
-  TRACE("(%d,%s)\n",len,debugstr_w(format));
-
-  while (*iter)
-  {
-    while (*iter && *iter != (WCHAR)L'%')
-    {
-     if (written++ >= len)
-       return -1;
-     *str++ = *iter++;
-    }
-    if (*iter == (WCHAR)L'%')
-    {
-      fmta = fmtbufa;
-      *fmta++ = *iter++;
-      while (*iter == (WCHAR)L'0' ||
-             *iter == (WCHAR)L'+' ||
-             *iter == (WCHAR)L'-' ||
-             *iter == (WCHAR)L' ' ||
-             *iter == (WCHAR)L'0' ||
-             *iter == (WCHAR)L'*' ||
-             *iter == (WCHAR)L'#')
-      {
-        if (*iter == (WCHAR)L'*')
-        {
-          char *buffiter = bufa;
-          int fieldlen = va_arg(valist, int);
-          sprintf(buffiter, "%d", fieldlen);
-          while (*buffiter)
-            *fmta++ = *buffiter++;
-        }
-        else
-          *fmta++ = *iter;
-        iter++;
-      }
-
-      while (isdigit(*iter))
-        *fmta++ = *iter++;
-
-      if (*iter == (WCHAR)L'.')
-      {
-        *fmta++ = *iter++;
-        if (*iter == (WCHAR)L'*')
-        {
-          char *buffiter = bufa;
-          int fieldlen = va_arg(valist, int);
-          sprintf(buffiter, "%d", fieldlen);
-          while (*buffiter)
-            *fmta++ = *buffiter++;
-        }
-        else
-          while (isdigit(*iter))
-            *fmta++ = *iter++;
-      }
-      if (*iter == (WCHAR)L'h' ||
-          *iter == (WCHAR)L'l')
-      {
-          *fmta++ = *iter++;
-          *fmta++ = *iter++;
-      }
-
-      switch (*iter)
-      {
-      case (WCHAR)L's':
-        {
-          static const WCHAR none[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
-          const WCHAR *wstr = va_arg(valist, const WCHAR *);
-          const WCHAR *striter = wstr ? wstr : none;
-          while (*striter)
-          {
-            if (written++ >= len)
-              return -1;
-            *str++ = *striter++;
-          }
-          iter++;
-          break;
-        }
-
-      case (WCHAR)L'c':
-        if (written++ >= len)
-          return -1;
-        *str++ = (WCHAR)va_arg(valist, int);
-        iter++;
-        break;
-
-      default:
-        {
-          /* For non wc types, use system sprintf and append to wide char output */
-          /* FIXME: for unrecognised types, should ignore % when printing */
-          char *bufaiter = bufa;
-          if (*iter == (WCHAR)L'p')
-            sprintf(bufaiter, "%08lX", va_arg(valist, long));
-          else
-          {
-            *fmta++ = *iter;
-            *fmta = '\0';
-            if (*iter == (WCHAR)L'f')
-              sprintf(bufaiter, fmtbufa, va_arg(valist, double));
-            else
-              sprintf(bufaiter, fmtbufa, va_arg(valist, void *));
-          }
-          while (*bufaiter)
-          {
-            if (written++ >= len)
-              return -1;
-            *str++ = *bufaiter++;
-          }
-          iter++;
-          break;
-        }
-      }
-    }
-  }
-  if (written >= len)
-    return -1;
-  *str++ = (WCHAR)L'\0';
-  return (int)written;
-}
+
+/*********************************************************************
+ *      _wtoi64   (NTDLL.@)
+ *
+ * Converts an unicode string to a large integer.
+ *
+ * On success it returns the integer value otherwise it returns 0.
+ * Accepts: {whitespace} [+|-] {digits}
+ * No check of overflow: Just assigns lower 64 bits (as native DLL).
+ * Does not check for str != NULL (as native DLL).
+ */
+LONGLONG  __cdecl _wtoi64( LPWSTR str )
+{
+    ULONGLONG RunningTotal = 0;
+    char bMinus = 0;
+
+    while (isspaceW(*str)) {
+        str++;
+    } /* while */
+
+    if (*str == '+') {
+        str++;
+    } else if (*str == '-') {
+        bMinus = 1;
+        str++;
+    } /* if */
+
+    while (*str >= '0' && *str <= '9') {
+        RunningTotal = RunningTotal * 10 + *str - '0';
+        str++;
+    } /* while */
+
+    return bMinus ? -RunningTotal : RunningTotal;
+}
+
 
 
@@ -558 +714 @@
   va_list valist;
   va_start(valist, format);
-  retval = NTDLL_vsnwprintf(str, len, format, valist);
+  retval = vsnprintfW(str, len, format, valist);
   va_end(valist);
   return retval;
@@ -572 +728 @@
   va_list valist;
   va_start(valist, format);
-  retval = NTDLL_vsnwprintf(str, INT_MAX, format, valist);
+  retval = vsnprintfW(str, INT_MAX, format, valist);
   va_end(valist);
   return retval;