dlls/user32/lstr.c

   1 /*
   2  * USER string functions
   3  *
   4  * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
   5  * Copyright 1996 Alexandre Julliard
   6  * Copyright 1996 Marcus Meissner
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <ctype.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winnls.h"
  35 #include "winuser.h"
  36 #include "winerror.h"
  37
  38 #include "wine/exception.h"
  39
  40
  41 /***********************************************************************
  42  *           CharNextA   (USER32.@)
  43  */
  44 LPSTR WINAPI CharNextA( LPCSTR ptr )
  45 {
  46     if (!*ptr) return (LPSTR)ptr;
  47     if (IsDBCSLeadByte( ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
  48     return (LPSTR)(ptr + 1);
  49 }
  50
  51
  52 /***********************************************************************
  53  *           CharNextExA   (USER32.@)
  54  */
  55 LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
  56 {
  57     if (!*ptr) return (LPSTR)ptr;
  58     if (IsDBCSLeadByteEx( codepage, ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
  59     return (LPSTR)(ptr + 1);
  60 }
  61
  62
  63 /***********************************************************************
  64  *           CharNextExW   (USER32.@)
  65  */
  66 LPWSTR WINAPI CharNextExW( WORD codepage, LPCWSTR ptr, DWORD flags )
  67 {
  68     /* doesn't make sense, there are no codepages for Unicode */
  69     return NULL;
  70 }
  71
  72
  73 /***********************************************************************
  74  *           CharNextW   (USER32.@)
  75  */
  76 LPWSTR WINAPI CharNextW(LPCWSTR x)
  77 {
  78     if (*x) x++;
  79
  80     return (LPWSTR)x;
  81 }
  82
  83
  84 /***********************************************************************
  85  *           CharPrevA   (USER32.@)
  86  */
  87 LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
  88 {
  89     while (*start && (start < ptr))
  90     {
  91         LPCSTR next = CharNextA( start );
  92         if (next >= ptr) break;
  93         start = next;
  94     }
  95     return (LPSTR)start;
  96 }
  97
  98
  99 /***********************************************************************
 100  *           CharPrevExA   (USER32.@)
 101  */
 102 LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
 103 {
 104     while (*start && (start < ptr))
 105     {
 106         LPCSTR next = CharNextExA( codepage, start, flags );
 107         if (next >= ptr) break;
 108         start = next;
 109     }
 110     return (LPSTR)start;
 111 }
 112
 113
 114 /***********************************************************************
 115  *           CharPrevExW   (USER32.@)
 116  */
 117 LPSTR WINAPI CharPrevExW( WORD codepage, LPCWSTR start, LPCWSTR ptr, DWORD flags )
 118 {
 119     /* doesn't make sense, there are no codepages for Unicode */
 120     return NULL;
 121 }
 122
 123
 124 /***********************************************************************
 125  *           CharPrevW   (USER32.@)
 126  */
 127 LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
 128 {
 129     if (x>start) return (LPWSTR)(x-1);
 130     else return (LPWSTR)x;
 131 }
 132
 133
 134 /***********************************************************************
 135  *           CharToOemA   (USER32.@)
 136  */
 137 BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
 138 {
 139     if (!s || !d) return FALSE;
 140     return CharToOemBuffA( s, d, strlen( s ) + 1 );
 141 }
 142
 143
 144 /***********************************************************************
 145  *           CharToOemBuffA   (USER32.@)
 146  */
 147 BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
 148 {
 149     WCHAR *bufW;
 150
 151     if (!s || !d) return FALSE;
 152
 153     bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 154     if( bufW )
 155     {
 156         MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
 157         WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
 158         HeapFree( GetProcessHeap(), 0, bufW );
 159     }
 160     return TRUE;
 161 }
 162
 163
 164 /***********************************************************************
 165  *           CharToOemBuffW   (USER32.@)
 166  */
 167 BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
 168 {
 169     if (!s || !d) return FALSE;
 170     WideCharToMultiByte( CP_OEMCP, 0, s, len, d, len, NULL, NULL );
 171     return TRUE;
 172 }
 173
 174
 175 /***********************************************************************
 176  *           CharToOemW   (USER32.@)
 177  */
 178 BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
 179 {
 180     if (!s || !d) return FALSE;
 181     return CharToOemBuffW( s, d, lstrlenW( s ) + 1 );
 182 }
 183
 184
 185 /***********************************************************************
 186  *           OemToCharA   (USER32.@)
 187  */
 188 BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
 189 {
 190     if (!s || !d) return FALSE;
 191     return OemToCharBuffA( s, d, strlen( s ) + 1 );
 192 }
 193
 194
 195 /***********************************************************************
 196  *           OemToCharBuffA   (USER32.@)
 197  */
 198 BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
 199 {
 200     WCHAR *bufW;
 201
 202     if (!s || !d) return FALSE;
 203
 204     bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 205     if( bufW )
 206     {
 207         MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
 208         WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
 209         HeapFree( GetProcessHeap(), 0, bufW );
 210     }
 211     return TRUE;
 212 }
 213
 214
 215 /***********************************************************************
 216  *           OemToCharBuffW   (USER32.@)
 217  */
 218 BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
 219 {
 220     if (!s || !d) return FALSE;
 221     MultiByteToWideChar( CP_OEMCP, MB_PRECOMPOSED | MB_USEGLYPHCHARS, s, len, d, len );
 222     return TRUE;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           OemToCharW   (USER32.@)
 228  */
 229 BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
 230 {
 231     if (!s || !d) return FALSE;
 232     return OemToCharBuffW( s, d, strlen( s ) + 1 );
 233 }
 234
 235
 236 /***********************************************************************
 237  *           CharLowerA   (USER32.@)
 238  */
 239 LPSTR WINAPI CharLowerA(LPSTR str)
 240 {
 241     if (IS_INTRESOURCE(str))
 242     {
 243         char ch = LOWORD(str);
 244         CharLowerBuffA( &ch, 1 );
 245         return (LPSTR)(UINT_PTR)(BYTE)ch;
 246     }
 247
 248     __TRY
 249     {
 250         CharLowerBuffA( str, strlen(str) );
 251     }
 252     __EXCEPT_PAGE_FAULT
 253     {
 254         SetLastError( ERROR_INVALID_PARAMETER );
 255         return NULL;
 256     }
 257     __ENDTRY
 258     return str;
 259 }
 260
 261
 262 /***********************************************************************
 263  *           CharUpperA   (USER32.@)
 264  */
 265 LPSTR WINAPI CharUpperA(LPSTR str)
 266 {
 267     if (IS_INTRESOURCE(str))
 268     {
 269         char ch = LOWORD(str);
 270         CharUpperBuffA( &ch, 1 );
 271         return (LPSTR)(UINT_PTR)(BYTE)ch;
 272     }
 273
 274     __TRY
 275     {
 276         CharUpperBuffA( str, strlen(str) );
 277     }
 278     __EXCEPT_PAGE_FAULT
 279     {
 280         SetLastError( ERROR_INVALID_PARAMETER );
 281         return NULL;
 282     }
 283     __ENDTRY
 284     return str;
 285 }
 286
 287
 288 /***********************************************************************
 289  *           CharLowerW   (USER32.@)
 290  */
 291 LPWSTR WINAPI CharLowerW( LPWSTR str )
 292 {
 293     if (!IS_INTRESOURCE( str ))
 294     {
 295         CharLowerBuffW( str, lstrlenW( str ));
 296         return str;
 297     }
 298     else
 299     {
 300         WCHAR ch = LOWORD( str );
 301         CharLowerBuffW( &ch, 1 );
 302         return (LPWSTR)(UINT_PTR)ch;
 303     }
 304 }
 305
 306
 307 /***********************************************************************
 308  *           CharUpperW   (USER32.@)
 309  */
 310 LPWSTR WINAPI CharUpperW( LPWSTR str )
 311 {
 312     if (!IS_INTRESOURCE( str ))
 313     {
 314         CharUpperBuffW( str, lstrlenW( str ));
 315         return str;
 316     }
 317     else
 318     {
 319         WCHAR ch = LOWORD( str );
 320         CharUpperBuffW( &ch, 1 );
 321         return (LPWSTR)(UINT_PTR)ch;
 322     }
 323 }
 324
 325
 326 /***********************************************************************
 327  *           CharLowerBuffA   (USER32.@)
 328  */
 329 DWORD WINAPI CharLowerBuffA( LPSTR str, DWORD len )
 330 {
 331     DWORD lenW;
 332     WCHAR buffer[32];
 333     WCHAR *strW = buffer;
 334
 335     if (!str) return 0; /* YES */
 336
 337     lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
 338     if (lenW > sizeof(buffer)/sizeof(WCHAR))
 339     {
 340         strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
 341         if (!strW) return 0;
 342     }
 343     MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
 344     CharLowerBuffW(strW, lenW);
 345     len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
 346     if (strW != buffer) HeapFree(GetProcessHeap(), 0, strW);
 347     return len;
 348 }
 349
 350
 351 /***********************************************************************
 352  *           CharLowerBuffW   (USER32.@)
 353  */
 354 DWORD WINAPI CharLowerBuffW( LPWSTR str, DWORD len )
 355 {
 356     if (!str) return 0; /* YES */
 357     return LCMapStringW( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, str, len, str, len );
 358 }
 359
 360
 361 /***********************************************************************
 362  *           CharUpperBuffA   (USER32.@)
 363  */
 364 DWORD WINAPI CharUpperBuffA( LPSTR str, DWORD len )
 365 {
 366     DWORD lenW;
 367     WCHAR buffer[32];
 368     WCHAR *strW = buffer;
 369
 370     if (!str) return 0; /* YES */
 371
 372     lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
 373     if (lenW > sizeof(buffer)/sizeof(WCHAR))
 374     {
 375         strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
 376         if (!strW) return 0;
 377     }
 378     MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
 379     CharUpperBuffW(strW, lenW);
 380     len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
 381     if (strW != buffer) HeapFree(GetProcessHeap(), 0, strW);
 382     return len;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           CharUpperBuffW   (USER32.@)
 388  */
 389 DWORD WINAPI CharUpperBuffW( LPWSTR str, DWORD len )
 390 {
 391     if (!str) return 0; /* YES */
 392     return LCMapStringW( LOCALE_USER_DEFAULT, LCMAP_UPPERCASE, str, len, str, len );
 393 }
 394
 395
 396 /***********************************************************************
 397  *           IsCharLower    (USER.436)
 398  *           IsCharLowerA   (USER32.@)
 399  */
 400 BOOL WINAPI IsCharLowerA(CHAR x)
 401 {
 402     WCHAR wch;
 403     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 404     return IsCharLowerW(wch);
 405 }
 406
 407
 408 /***********************************************************************
 409  *           IsCharLowerW   (USER32.@)
 410  */
 411 BOOL WINAPI IsCharLowerW( WCHAR ch )
 412 {
 413     WORD type;
 414     return GetStringTypeW( CT_CTYPE1, &ch, 1, &type ) && (type & C1_LOWER);
 415 }
 416
 417
 418 /***********************************************************************
 419  *           IsCharUpper    (USER.435)
 420  *           IsCharUpperA   (USER32.@)
 421  */
 422 BOOL WINAPI IsCharUpperA(CHAR x)
 423 {
 424     WCHAR wch;
 425     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 426     return IsCharUpperW(wch);
 427 }
 428
 429
 430 /***********************************************************************
 431  *           IsCharUpperW   (USER32.@)
 432  */
 433 BOOL WINAPI IsCharUpperW( WCHAR ch )
 434 {
 435     WORD type;
 436     return GetStringTypeW( CT_CTYPE1, &ch, 1, &type ) && (type & C1_UPPER);
 437 }
 438
 439
 440 /***********************************************************************
 441  *           IsCharAlphaNumeric    (USER.434)
 442  *           IsCharAlphaNumericA   (USER32.@)
 443  */
 444 BOOL WINAPI IsCharAlphaNumericA(CHAR x)
 445 {
 446     WCHAR wch;
 447     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 448     return IsCharAlphaNumericW(wch);
 449 }
 450
 451
 452 /***********************************************************************
 453  *           IsCharAlphaNumericW   (USER32.@)
 454  */
 455 BOOL WINAPI IsCharAlphaNumericW( WCHAR ch )
 456 {
 457     WORD type;
 458     return GetStringTypeW( CT_CTYPE1, &ch, 1, &type ) && (type & (C1_ALPHA|C1_DIGIT));
 459 }
 460
 461
 462 /***********************************************************************
 463  *           IsCharAlpha    (USER.433)
 464  *           IsCharAlphaA   (USER32.@)
 465  */
 466 BOOL WINAPI IsCharAlphaA(CHAR x)
 467 {
 468     WCHAR wch;
 469     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 470     return IsCharAlphaW(wch);
 471 }
 472
 473
 474 /***********************************************************************
 475  *           IsCharAlphaW   (USER32.@)
 476  */
 477 BOOL WINAPI IsCharAlphaW( WCHAR ch )
 478 {
 479     WORD type;
 480     return GetStringTypeW( CT_CTYPE1, &ch, 1, &type ) && (type & C1_ALPHA);
 481 }