include/wine/unicode.h

   1 /*
   2  * Wine internal Unicode definitions
   3  *
   4  * Copyright 2000 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifndef __WINE_WINE_UNICODE_H
  22 #define __WINE_WINE_UNICODE_H
  23
  24 #include <stdarg.h>
  25
  26 #include <windef.h>
  27 #include <winbase.h>
  28 #include <winnls.h>
  29 #include <winternl.h>
  30
  31 #ifdef __WINE_USE_MSVCRT
  32 #error This file should not be used with msvcrt headers
  33 #endif
  34
  35 #ifndef WINE_UNICODE_INLINE
  36 #define WINE_UNICODE_INLINE static FORCEINLINE
  37 #endif
  38
  39 WINE_UNICODE_INLINE WCHAR tolowerW( WCHAR ch )
  40 {
  41     return RtlDowncaseUnicodeChar( ch );
  42 }
  43
  44 WINE_UNICODE_INLINE WCHAR toupperW( WCHAR ch )
  45 {
  46     return RtlUpcaseUnicodeChar( ch );
  47 }
  48
  49 WINE_UNICODE_INLINE int isspaceW( WCHAR wc )
  50 {
  51     unsigned short type;
  52     GetStringTypeW( CT_CTYPE1, &wc, 1, &type );
  53     return type & C1_SPACE;
  54 }
  55
  56 WINE_UNICODE_INLINE unsigned int strlenW( const WCHAR *str )
  57 {
  58     const WCHAR *s = str;
  59     while (*s) s++;
  60     return s - str;
  61 }
  62
  63 WINE_UNICODE_INLINE WCHAR *strcpyW( WCHAR *dst, const WCHAR *src )
  64 {
  65     WCHAR *p = dst;
  66     while ((*p++ = *src++));
  67     return dst;
  68 }
  69
  70 WINE_UNICODE_INLINE int strcmpW( const WCHAR *str1, const WCHAR *str2 )
  71 {
  72     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
  73     return *str1 - *str2;
  74 }
  75
  76 WINE_UNICODE_INLINE int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
  77 {
  78     if (n <= 0) return 0;
  79     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
  80     return *str1 - *str2;
  81 }
  82
  83 WINE_UNICODE_INLINE WCHAR *strcatW( WCHAR *dst, const WCHAR *src )
  84 {
  85     strcpyW( dst + strlenW(dst), src );
  86     return dst;
  87 }
  88
  89 WINE_UNICODE_INLINE WCHAR *strchrW( const WCHAR *str, WCHAR ch )
  90 {
  91     do { if (*str == ch) return (WCHAR *)(ULONG_PTR)str; } while (*str++);
  92     return NULL;
  93 }
  94
  95 WINE_UNICODE_INLINE WCHAR *strrchrW( const WCHAR *str, WCHAR ch )
  96 {
  97     WCHAR *ret = NULL;
  98     do { if (*str == ch) ret = (WCHAR *)(ULONG_PTR)str; } while (*str++);
  99     return ret;
 100 }
 101
 102 WINE_UNICODE_INLINE WCHAR *strpbrkW( const WCHAR *str, const WCHAR *accept )
 103 {
 104     for ( ; *str; str++) if (strchrW( accept, *str )) return (WCHAR *)(ULONG_PTR)str;
 105     return NULL;
 106 }
 107
 108 WINE_UNICODE_INLINE WCHAR *strlwrW( WCHAR *str )
 109 {
 110     WCHAR *ret;
 111     for (ret = str; *str; str++) *str = tolowerW(*str);
 112     return ret;
 113 }
 114
 115 WINE_UNICODE_INLINE WCHAR *memchrW( const WCHAR *ptr, WCHAR ch, size_t n )
 116 {
 117     const WCHAR *end;
 118     for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) return (WCHAR *)(ULONG_PTR)ptr;
 119     return NULL;
 120 }
 121
 122 WINE_UNICODE_INLINE int strcmpiW( const WCHAR *str1, const WCHAR *str2 )
 123 {
 124     for (;;)
 125     {
 126         int ret = tolowerW(*str1) - tolowerW(*str2);
 127         if (ret || !*str1) return ret;
 128         str1++;
 129         str2++;
 130     }
 131 }
 132
 133 WINE_UNICODE_INLINE int strncmpiW( const WCHAR *str1, const WCHAR *str2, int n )
 134 {
 135     int ret = 0;
 136     for ( ; n > 0; n--, str1++, str2++)
 137         if ((ret = tolowerW(*str1) - tolowerW(*str2)) || !*str1) break;
 138     return ret;
 139 }
 140
 141 WINE_UNICODE_INLINE WCHAR *strstrW( const WCHAR *str, const WCHAR *sub )
 142 {
 143     while (*str)
 144     {
 145         const WCHAR *p1 = str, *p2 = sub;
 146         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
 147         if (!*p2) return (WCHAR *)str;
 148         str++;
 149     }
 150     return NULL;
 151 }
 152
 153 WINE_UNICODE_INLINE LONG strtolW( LPCWSTR s, LPWSTR *end, INT base )
 154 {
 155     BOOL negative = FALSE, empty = TRUE;
 156     LONG ret = 0;
 157
 158     if (base < 0 || base == 1 || base > 36) return 0;
 159     if (end) *end = (WCHAR *)s;
 160     while (isspaceW(*s)) s++;
 161
 162     if (*s == '-')
 163     {
 164         negative = TRUE;
 165         s++;
 166     }
 167     else if (*s == '+') s++;
 168
 169     if ((base == 0 || base == 16) && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
 170     {
 171         base = 16;
 172         s += 2;
 173     }
 174     if (base == 0) base = s[0] != '0' ? 10 : 8;
 175
 176     while (*s)
 177     {
 178         int v;
 179
 180         if ('0' <= *s && *s <= '9') v = *s - '0';
 181         else if ('A' <= *s && *s <= 'Z') v = *s - 'A' + 10;
 182         else if ('a' <= *s && *s <= 'z') v = *s - 'a' + 10;
 183         else break;
 184         if (v >= base) break;
 185         if (negative) v = -v;
 186         s++;
 187         empty = FALSE;
 188
 189         if (!negative && (ret > MAXLONG / base || ret * base > MAXLONG - v))
 190             ret = MAXLONG;
 191         else if (negative && (ret < (LONG)MINLONG / base || ret * base < (LONG)(MINLONG - v)))
 192             ret = MINLONG;
 193         else
 194             ret = ret * base + v;
 195     }
 196
 197     if (end && !empty) *end = (WCHAR *)s;
 198     return ret;
 199 }
 200
 201 WINE_UNICODE_INLINE ULONG strtoulW( LPCWSTR s, LPWSTR *end, INT base )
 202 {
 203     BOOL negative = FALSE, empty = TRUE;
 204     ULONG ret = 0;
 205
 206     if (base < 0 || base == 1 || base > 36) return 0;
 207     if (end) *end = (WCHAR *)s;
 208     while (isspaceW(*s)) s++;
 209
 210     if (*s == '-')
 211     {
 212         negative = TRUE;
 213         s++;
 214     }
 215     else if (*s == '+') s++;
 216
 217     if ((base == 0 || base == 16) && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
 218     {
 219         base = 16;
 220         s += 2;
 221     }
 222     if (base == 0) base = s[0] != '0' ? 10 : 8;
 223
 224     while (*s)
 225     {
 226         int v;
 227
 228         if ('0' <= *s && *s <= '9') v = *s - '0';
 229         else if ('A' <= *s && *s <= 'Z') v = *s - 'A' + 10;
 230         else if ('a' <= *s && *s <= 'z') v = *s - 'a' + 10;
 231         else break;
 232         if (v >= base) break;
 233         s++;
 234         empty = FALSE;
 235
 236         if (ret > MAXDWORD / base || ret * base > MAXDWORD - v)
 237             ret = MAXDWORD;
 238         else
 239             ret = ret * base + v;
 240     }
 241
 242     if (end && !empty) *end = (WCHAR *)s;
 243     return negative ? -ret : ret;
 244 }
 245
 246 WINE_UNICODE_INLINE int atoiW( const WCHAR *str )
 247 {
 248     return (int)strtolW( str, (WCHAR **)0, 10 );
 249 }
 250
 251 NTSYSAPI int __cdecl _vsnwprintf(WCHAR*,size_t,const WCHAR*,__ms_va_list);
 252
 253 static inline int WINAPIV snprintfW( WCHAR *str, size_t len, const WCHAR *format, ...)
 254 {
 255     int retval;
 256     __ms_va_list valist;
 257     __ms_va_start(valist, format);
 258     retval = _vsnwprintf(str, len, format, valist);
 259     __ms_va_end(valist);
 260     return retval;
 261 }
 262
 263 static inline int WINAPIV sprintfW( WCHAR *str, const WCHAR *format, ...)
 264 {
 265     int retval;
 266     __ms_va_list valist;
 267     __ms_va_start(valist, format);
 268     retval = _vsnwprintf(str, MAXLONG, format, valist);
 269     __ms_va_end(valist);
 270     return retval;
 271 }
 272
 273 #undef WINE_UNICODE_INLINE
 274
 275 #endif  /* __WINE_WINE_UNICODE_H */