misc/lstr.c

   1 /*
   2  * String functions
   3  *
   4  * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
   5  * Copyright 1996 Marcus Meissner
   6  */
   7
   8 #include "config.h"
   9
  10 #include <stdarg.h>
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <ctype.h>
  15
  16 #ifdef HAVE_WCTYPE_H
  17 # include <wctype.h>
  18 #else
  19 # define iswalnum(c) isalnum(c)
  20 # define iswalpha(c) isalpha(c)
  21 # define iswupper(c) isupper(c)
  22 # define iswlower(c) islower(c)
  23 #endif  /* HAVE_WCTYPE_H */
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "wine/winbase16.h"
  30 #include "wine/winuser16.h"
  31 #include "wine/unicode.h"
  32 #include "winnls.h"
  33 #include "task.h"
  34 #include "heap.h"
  35 #include "ldt.h"
  36 #include "stackframe.h"
  37 #include "module.h"
  38 #include "debugtools.h"
  39
  40 DEFAULT_DEBUG_CHANNEL(resource);
  41
  42 extern const WORD OLE2NLS_CT_CType3_LUT[]; /* FIXME: does not belong here */
  43
  44 /* Funny to divide them between user and kernel. */
  45
  46 /***********************************************************************
  47  *              IsCharAlpha (USER.433)
  48  */
  49 BOOL16 WINAPI IsCharAlpha16(CHAR ch)
  50 {
  51   return isalpha(ch);   /* This is probably not right for NLS */
  52 }
  53
  54 /***********************************************************************
  55  *              IsCharAlphaNumeric (USER.434)
  56  */
  57 BOOL16 WINAPI IsCharAlphaNumeric16(CHAR ch)
  58 {
  59     return isalnum(ch);
  60 }
  61
  62 /***********************************************************************
  63  *              IsCharUpper (USER.435)
  64  */
  65 BOOL16 WINAPI IsCharUpper16(CHAR ch)
  66 {
  67   return isupper(ch);
  68 }
  69
  70 /***********************************************************************
  71  *              IsCharLower (USER.436)
  72  */
  73 BOOL16 WINAPI IsCharLower16(CHAR ch)
  74 {
  75   return islower(ch);
  76 }
  77
  78 /***********************************************************************
  79  *           AnsiUpper16   (USER.431)
  80  */
  81 SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
  82 {
  83   /* I am not sure if the locale stuff works with toupper, but then again
  84      I am not sure if the Linux libc locale stuffs works at all */
  85
  86     /* uppercase only one char if strOrChar < 0x10000 */
  87     if (HIWORD(strOrChar))
  88     {
  89         char *s;
  90         for (s = PTR_SEG_TO_LIN(strOrChar); *s; s++) *s = toupper(*s);
  91         return strOrChar;
  92     }
  93     else return toupper((char)strOrChar);
  94 }
  95
  96
  97 /***********************************************************************
  98  *           AnsiUpperBuff16   (USER.437)
  99  */
 100 UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
 101 {
 102     UINT count = len ? len : 65536;
 103     for (; count; count--, str++) *str = toupper(*str);
 104     return len;
 105 }
 106
 107 /***********************************************************************
 108  *           AnsiLower16   (USER.432)
 109  */
 110 SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
 111 {
 112   /* I am not sure if the locale stuff works with toupper, but then again
 113      I am not sure if the Linux libc locale stuffs works at all */
 114
 115     /* lowercase only one char if strOrChar < 0x10000 */
 116     if (HIWORD(strOrChar))
 117     {
 118         char *s;
 119         for (s = PTR_SEG_TO_LIN( strOrChar ); *s; s++) *s = tolower( *s );
 120         return strOrChar;
 121     }
 122     else return tolower((char)strOrChar);
 123 }
 124
 125
 126 /***********************************************************************
 127  *           AnsiLowerBuff16   (USER.438)
 128  */
 129 UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
 130 {
 131     UINT count = len ? len : 65536;
 132     for (; count; count--, str++) *str = tolower(*str);
 133     return len;
 134 }
 135
 136
 137 /***********************************************************************
 138  *           AnsiNext16   (USER.472)
 139  */
 140 SEGPTR WINAPI AnsiNext16(SEGPTR current)
 141 {
 142     return (*(char *)PTR_SEG_TO_LIN(current)) ? current + 1 : current;
 143 }
 144
 145
 146 /***********************************************************************
 147  *           AnsiPrev16   (USER.473)
 148  */
 149 SEGPTR WINAPI AnsiPrev16( SEGPTR start, SEGPTR current )
 150 {
 151     return (current == start) ? start : current - 1;
 152 }
 153
 154
 155 /***********************************************************************
 156  *           CharNextA   (USER32.29)
 157  */
 158 LPSTR WINAPI CharNextA( LPCSTR ptr )
 159 {
 160     if (!*ptr) return (LPSTR)ptr;
 161     if (IsDBCSLeadByte( *ptr ) && (*(ptr+1) != 0) ) return (LPSTR)(ptr + 2);
 162     return (LPSTR)(ptr + 1);
 163 }
 164
 165
 166 /***********************************************************************
 167  *           CharNextExA   (USER32.30)
 168  */
 169 LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
 170 {
 171     if (!*ptr) return (LPSTR)ptr;
 172     if (IsDBCSLeadByteEx( codepage, *ptr ) && (*(ptr+1) != 0) ) return (LPSTR)(ptr + 2);
 173     return (LPSTR)(ptr + 1);
 174 }
 175
 176
 177 /***********************************************************************
 178  *           CharNextExW   (USER32.31)
 179  */
 180 LPWSTR WINAPI CharNextExW(WORD codepage,LPCWSTR x,DWORD flags)
 181 {
 182     /* FIXME: add DBCS / codepage stuff */
 183     if (*x) return (LPWSTR)(x+1);
 184     else return (LPWSTR)x;
 185 }
 186
 187 /***********************************************************************
 188  *           CharNextW   (USER32.32)
 189  */
 190 LPWSTR WINAPI CharNextW(LPCWSTR x)
 191 {
 192     if (*x) return (LPWSTR)(x+1);
 193     else return (LPWSTR)x;
 194 }
 195
 196 /***********************************************************************
 197  *           CharPrevA   (USER32.33)
 198  */
 199 LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
 200 {
 201     while (*start && (start < ptr))
 202     {
 203         LPCSTR next = CharNextA( start );
 204         if (next >= ptr) break;
 205         start = next;
 206     }
 207     return (LPSTR)start;
 208 }
 209
 210
 211 /***********************************************************************
 212  *           CharPrevExA   (USER32.34)
 213  */
 214 LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
 215 {
 216     while (*start && (start < ptr))
 217     {
 218         LPCSTR next = CharNextExA( codepage, start, flags );
 219         if (next > ptr) break;
 220         start = next;
 221     }
 222     return (LPSTR)start;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           CharPrevExW   (USER32.35)
 228  */
 229 LPWSTR WINAPI CharPrevExW(WORD codepage,LPCWSTR start,LPCWSTR x,DWORD flags)
 230 {
 231     /* FIXME: add DBCS / codepage stuff */
 232     if (x>start) return (LPWSTR)(x-1);
 233     else return (LPWSTR)x;
 234 }
 235
 236 /***********************************************************************
 237  *           CharPrevW   (USER32.36)
 238  */
 239 LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
 240 {
 241     if (x>start) return (LPWSTR)(x-1);
 242     else return (LPWSTR)x;
 243 }
 244
 245 /***********************************************************************
 246  *           CharLowerA   (USER32.25)
 247  * FIXME: handle current locale
 248  */
 249 LPSTR WINAPI CharLowerA(LPSTR x)
 250 {
 251     LPSTR       s;
 252
 253     if (HIWORD(x))
 254     {
 255         s=x;
 256         while (*s)
 257         {
 258             *s=tolower(*s);
 259             s++;
 260         }
 261         return x;
 262     }
 263     else return (LPSTR)tolower((char)(int)x);
 264 }
 265
 266 /***********************************************************************
 267  *           CharLowerBuffA   (USER32.26)
 268  * FIXME: handle current locale
 269  */
 270 DWORD WINAPI CharLowerBuffA(LPSTR x,DWORD buflen)
 271 {
 272     DWORD done=0;
 273
 274     if (!x) return 0; /* YES */
 275     while (*x && (buflen--))
 276     {
 277         *x=tolower(*x);
 278         x++;
 279         done++;
 280     }
 281     return done;
 282 }
 283
 284 /***********************************************************************
 285  *           CharLowerBuffW   (USER32.27)
 286  */
 287 DWORD WINAPI CharLowerBuffW(LPWSTR x,DWORD buflen)
 288 {
 289     DWORD done=0;
 290
 291     if (!x) return 0; /* YES */
 292     while (*x && (buflen--))
 293     {
 294         *x=tolowerW(*x);
 295         x++;
 296         done++;
 297     }
 298     return done;
 299 }
 300
 301 /***********************************************************************
 302  *           CharLowerW   (USER32.28)
 303  * FIXME: handle current locale
 304  */
 305 LPWSTR WINAPI CharLowerW(LPWSTR x)
 306 {
 307     if (HIWORD(x))
 308     {
 309         LPWSTR s = x;
 310         while (*s)
 311         {
 312             *s = tolowerW(*s);
 313             s++;
 314         }
 315         return x;
 316     }
 317     else return (LPWSTR)((UINT)tolowerW(LOWORD(x)));
 318 }
 319
 320 /***********************************************************************
 321  *           CharUpperA   (USER32.41)
 322  * FIXME: handle current locale
 323  */
 324 LPSTR WINAPI CharUpperA(LPSTR x)
 325 {
 326     if (HIWORD(x))
 327     {
 328         LPSTR s = x;
 329         while (*s)
 330         {
 331             *s=toupper(*s);
 332             s++;
 333         }
 334         return x;
 335     }
 336     return (LPSTR)toupper((char)(int)x);
 337 }
 338
 339 /***********************************************************************
 340  *           CharUpperBuffA   (USER32.42)
 341  * FIXME: handle current locale
 342  */
 343 DWORD WINAPI CharUpperBuffA(LPSTR x,DWORD buflen)
 344 {
 345     DWORD done=0;
 346
 347     if (!x) return 0; /* YES */
 348     while (*x && (buflen--))
 349     {
 350         *x=toupper(*x);
 351         x++;
 352         done++;
 353     }
 354     return done;
 355 }
 356
 357 /***********************************************************************
 358  *           CharUpperBuffW   (USER32.43)
 359  * FIXME: handle current locale
 360  */
 361 DWORD WINAPI CharUpperBuffW(LPWSTR x,DWORD buflen)
 362 {
 363     DWORD done=0;
 364
 365     if (!x) return 0; /* YES */
 366     while (*x && (buflen--))
 367     {
 368         *x=toupperW(*x);
 369         x++;
 370         done++;
 371     }
 372     return done;
 373 }
 374
 375 /***********************************************************************
 376  *           CharUpperW   (USER32.44)
 377  * FIXME: handle current locale
 378  */
 379 LPWSTR WINAPI CharUpperW(LPWSTR x)
 380 {
 381     if (HIWORD(x))
 382     {
 383         LPWSTR s = x;
 384         while (*s)
 385         {
 386             *s = toupperW(*s);
 387             s++;
 388         }
 389         return x;
 390     }
 391     else return (LPWSTR)((UINT)toupperW(LOWORD(x)));
 392 }
 393
 394 /***********************************************************************
 395  *           IsCharAlphaA   (USER32.331)
 396  * FIXME: handle current locale
 397  */
 398 BOOL WINAPI IsCharAlphaA(CHAR x)
 399 {
 400     return (OLE2NLS_CT_CType3_LUT[(unsigned char)x] & C3_ALPHA);
 401 }
 402
 403 /***********************************************************************
 404  *           IsCharAlphaNumericA   (USER32.332)
 405  * FIXME: handle current locale
 406  */
 407 BOOL WINAPI IsCharAlphaNumericA(CHAR x)
 408 {
 409     return IsCharAlphaA(x) || isdigit(x) ;
 410 }
 411
 412 /***********************************************************************
 413  *           IsCharAlphaNumericW   (USER32.333)
 414  * FIXME: handle current locale
 415  */
 416 BOOL WINAPI IsCharAlphaNumericW(WCHAR x)
 417 {
 418     return iswalnum(x);
 419 }
 420
 421 /***********************************************************************
 422  *           IsCharAlphaW   (USER32.334)
 423  * FIXME: handle current locale
 424  */
 425 BOOL WINAPI IsCharAlphaW(WCHAR x)
 426 {
 427     return iswalpha(x);
 428 }
 429
 430 /***********************************************************************
 431  *           IsCharLowerA   (USER32.335)
 432  * FIXME: handle current locale
 433  */
 434 BOOL WINAPI IsCharLowerA(CHAR x)
 435 {
 436     return islower(x);
 437 }
 438
 439 /***********************************************************************
 440  *           IsCharLowerW   (USER32.336)
 441  * FIXME: handle current locale
 442  */
 443 BOOL WINAPI IsCharLowerW(WCHAR x)
 444 {
 445     return iswlower(x);
 446 }
 447
 448 /***********************************************************************
 449  *           IsCharUpperA   (USER32.337)
 450  * FIXME: handle current locale
 451  */
 452 BOOL WINAPI IsCharUpperA(CHAR x)
 453 {
 454     return isupper(x);
 455 }
 456
 457 /***********************************************************************
 458  *           IsCharUpperW   (USER32.338)
 459  * FIXME: handle current locale
 460  */
 461 BOOL WINAPI IsCharUpperW(WCHAR x)
 462 {
 463     return iswupper(x);
 464 }
 465
 466 /***********************************************************************
 467  *           FormatMessage16   (USER.606)
 468  */
 469 DWORD WINAPI FormatMessage16(
 470     DWORD   dwFlags,
 471     SEGPTR lpSource, /*not always a valid pointer*/
 472     WORD   dwMessageId,
 473     WORD   dwLanguageId,
 474     LPSTR  lpBuffer, /* *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
 475     WORD   nSize,
 476     LPDWORD args /* va_list *args */
 477 ) {
 478 #ifdef __i386__
 479 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 480     LPSTR       target,t;
 481     DWORD       talloced;
 482     LPSTR       from,f;
 483     DWORD       width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 484     BOOL        eos = FALSE;
 485     LPSTR       allocstring = NULL;
 486
 487     TRACE("(0x%lx,%lx,%d,0x%x,%p,%d,%p)\n",
 488           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 489         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 490                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
 491         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
 492                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 493                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
 494
 495     if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 496         FIXME("line wrapping (%lu) not supported.\n", width);
 497     from = NULL;
 498     if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 499         from = HEAP_strdupA( GetProcessHeap(), 0, PTR_SEG_TO_LIN(lpSource));
 500     if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 501         from = HeapAlloc( GetProcessHeap(),0,200 );
 502         sprintf(from,"Systemmessage, messageid = 0x%08x\n",dwMessageId);
 503     }
 504     if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 505         INT16   bufsize;
 506         HINSTANCE16 hinst16 = ((HMODULE)lpSource & 0xffff);
 507
 508         dwMessageId &= 0xFFFF;
 509         bufsize=LoadString16(hinst16,dwMessageId,NULL,0);
 510         if (bufsize) {
 511             from = HeapAlloc( GetProcessHeap(), 0, bufsize +1);
 512             LoadString16(hinst16,dwMessageId,from,bufsize+1);
 513         }
 514     }
 515     target      = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 516     t   = target;
 517     talloced= 100;
 518
 519 #define ADD_TO_T(c) \
 520         *t++=c;\
 521         if (t-target == talloced) {\
 522                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 523                 t       = target+talloced;\
 524                 talloced*=2;\
 525         }
 526
 527     if (from) {
 528         f=from;
 529         while (*f && !eos) {
 530             if (*f=='%') {
 531                 int     insertnr;
 532                 char    *fmtstr,*x,*lastf;
 533                 DWORD   *argliststart;
 534
 535                 fmtstr = NULL;
 536                 lastf = f;
 537                 f++;
 538                 if (!*f) {
 539                     ADD_TO_T('%');
 540                     continue;
 541                 }
 542                 switch (*f) {
 543                 case '1':case '2':case '3':case '4':case '5':
 544                 case '6':case '7':case '8':case '9':
 545                     insertnr=*f-'0';
 546                     switch (f[1]) {
 547                     case '0':case '1':case '2':case '3':
 548                     case '4':case '5':case '6':case '7':
 549                     case '8':case '9':
 550                         f++;
 551                         insertnr=insertnr*10+*f-'0';
 552                         f++;
 553                         break;
 554                     default:
 555                         f++;
 556                         break;
 557                     }
 558                     if (*f=='!') {
 559                         f++;
 560                         if (NULL!=(x=strchr(f,'!'))) {
 561                             *x='\0';
 562                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 563                             sprintf(fmtstr,"%%%s",f);
 564                             f=x+1;
 565                         } else {
 566                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 567                             sprintf(fmtstr,"%%%s",f);
 568                             f+=strlen(f); /*at \0*/
 569                         }
 570                     } else
 571                         if(!args)
 572                             break;
 573                         else
 574                           fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
 575                     if (args) {
 576                         int     sz;
 577                         LPSTR   b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
 578
 579                         argliststart=args+insertnr-1;
 580
 581                         /* CMF - This makes a BIG assumption about va_list */
 582                         while (vsnprintf(b, sz, fmtstr, (va_list) argliststart) < 0) {
 583                             b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz += 100);
 584                         }
 585                         for (x=b; *x; x++) ADD_TO_T(*x);
 586                     } else {
 587                         /* NULL args - copy formatstr
 588                          * (probably wrong)
 589                          */
 590                         while ((lastf<f)&&(*lastf)) {
 591                             ADD_TO_T(*lastf++);
 592                         }
 593                     }
 594                     HeapFree(GetProcessHeap(),0,fmtstr);
 595                     break;
 596                 case '0': /* Just stop processing format string */
 597                     eos = TRUE;
 598                     f++;
 599                     break;
 600                 case 'n': /* 16 bit version just outputs 'n' */
 601                 default:
 602                     ADD_TO_T(*f++);
 603                     break;
 604                 }
 605             } else { /* '\n' or '\r' gets mapped to "\r\n" */
 606                 if(*f == '\n' || *f == '\r') {
 607                     if (width == 0) {
 608                         ADD_TO_T('\r');
 609                         ADD_TO_T('\n');
 610                         if(*f++ == '\r' && *f == '\n')
 611                             f++;
 612                     }
 613                 } else {
 614                     ADD_TO_T(*f++);
 615                 }
 616             }
 617         }
 618         *t='\0';
 619     }
 620     talloced = strlen(target)+1;
 621     if (nSize && talloced<nSize) {
 622         target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 623     }
 624     TRACE("-- %s\n",debugstr_a(target));
 625     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 626         /* nSize is the MINIMUM size */
 627         *((HLOCAL16*)lpBuffer)=  LocalAlloc16(LPTR,talloced);
 628         allocstring=PTR_SEG_OFF_TO_LIN(CURRENT_DS,*((HLOCAL16*)lpBuffer));
 629         memcpy( allocstring,target,talloced);
 630     } else
 631         lstrcpynA(lpBuffer,target,nSize);
 632     HeapFree(GetProcessHeap(),0,target);
 633     if (from) HeapFree(GetProcessHeap(),0,from);
 634     return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 635         strlen(allocstring):
 636         strlen(lpBuffer);
 637 #else
 638         return 0;
 639 #endif /* __i386__ */
 640 }
 641 #undef ADD_TO_T