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 "ntddk.h"
  30 #include "wine/winbase16.h"
  31 #include "wine/winuser16.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  * FIXME: handle current locale
 287  */
 288 DWORD WINAPI CharLowerBuffW(LPWSTR x,DWORD buflen)
 289 {
 290     DWORD done=0;
 291
 292     if (!x) return 0; /* YES */
 293     while (*x && (buflen--))
 294     {
 295         *x=NTDLL_towlower(*x);
 296         x++;
 297         done++;
 298     }
 299     return done;
 300 }
 301
 302 /***********************************************************************
 303  *           CharLowerW   (USER32.28)
 304  * FIXME: handle current locale
 305  */
 306 LPWSTR WINAPI CharLowerW(LPWSTR x)
 307 {
 308     if (HIWORD(x))
 309     {
 310         LPWSTR s = x;
 311         while (*s)
 312         {
 313             *s=NTDLL_towlower(*s);
 314             s++;
 315         }
 316         return x;
 317     }
 318     else return (LPWSTR)((UINT)NTDLL_towlower(LOWORD(x)));
 319 }
 320
 321 /***********************************************************************
 322  *           CharUpperA   (USER32.41)
 323  * FIXME: handle current locale
 324  */
 325 LPSTR WINAPI CharUpperA(LPSTR x)
 326 {
 327     if (HIWORD(x))
 328     {
 329         LPSTR s = x;
 330         while (*s)
 331         {
 332             *s=toupper(*s);
 333             s++;
 334         }
 335         return x;
 336     }
 337     return (LPSTR)toupper((char)(int)x);
 338 }
 339
 340 /***********************************************************************
 341  *           CharUpperBuffA   (USER32.42)
 342  * FIXME: handle current locale
 343  */
 344 DWORD WINAPI CharUpperBuffA(LPSTR x,DWORD buflen)
 345 {
 346     DWORD done=0;
 347
 348     if (!x) return 0; /* YES */
 349     while (*x && (buflen--))
 350     {
 351         *x=toupper(*x);
 352         x++;
 353         done++;
 354     }
 355     return done;
 356 }
 357
 358 /***********************************************************************
 359  *           CharUpperBuffW   (USER32.43)
 360  * FIXME: handle current locale
 361  */
 362 DWORD WINAPI CharUpperBuffW(LPWSTR x,DWORD buflen)
 363 {
 364     DWORD done=0;
 365
 366     if (!x) return 0; /* YES */
 367     while (*x && (buflen--))
 368     {
 369         *x=NTDLL_towupper(*x);
 370         x++;
 371         done++;
 372     }
 373     return done;
 374 }
 375
 376 /***********************************************************************
 377  *           CharUpperW   (USER32.44)
 378  * FIXME: handle current locale
 379  */
 380 LPWSTR WINAPI CharUpperW(LPWSTR x)
 381 {
 382     if (HIWORD(x))
 383     {
 384         LPWSTR s = x;
 385         while (*s)
 386         {
 387             *s=NTDLL_towupper(*s);
 388             s++;
 389         }
 390         return x;
 391     }
 392     else return (LPWSTR)((UINT)NTDLL_towupper(LOWORD(x)));
 393 }
 394
 395 /***********************************************************************
 396  *           IsCharAlphaA   (USER32.331)
 397  * FIXME: handle current locale
 398  */
 399 BOOL WINAPI IsCharAlphaA(CHAR x)
 400 {
 401     return (OLE2NLS_CT_CType3_LUT[(unsigned char)x] & C3_ALPHA);
 402 }
 403
 404 /***********************************************************************
 405  *           IsCharAlphaNumericA   (USER32.332)
 406  * FIXME: handle current locale
 407  */
 408 BOOL WINAPI IsCharAlphaNumericA(CHAR x)
 409 {
 410     return IsCharAlphaA(x) || isdigit(x) ;
 411 }
 412
 413 /***********************************************************************
 414  *           IsCharAlphaNumericW   (USER32.333)
 415  * FIXME: handle current locale
 416  */
 417 BOOL WINAPI IsCharAlphaNumericW(WCHAR x)
 418 {
 419     return iswalnum(x);
 420 }
 421
 422 /***********************************************************************
 423  *           IsCharAlphaW   (USER32.334)
 424  * FIXME: handle current locale
 425  */
 426 BOOL WINAPI IsCharAlphaW(WCHAR x)
 427 {
 428     return iswalpha(x);
 429 }
 430
 431 /***********************************************************************
 432  *           IsCharLowerA   (USER32.335)
 433  * FIXME: handle current locale
 434  */
 435 BOOL WINAPI IsCharLowerA(CHAR x)
 436 {
 437     return islower(x);
 438 }
 439
 440 /***********************************************************************
 441  *           IsCharLowerW   (USER32.336)
 442  * FIXME: handle current locale
 443  */
 444 BOOL WINAPI IsCharLowerW(WCHAR x)
 445 {
 446     return iswlower(x);
 447 }
 448
 449 /***********************************************************************
 450  *           IsCharUpperA   (USER32.337)
 451  * FIXME: handle current locale
 452  */
 453 BOOL WINAPI IsCharUpperA(CHAR x)
 454 {
 455     return isupper(x);
 456 }
 457
 458 /***********************************************************************
 459  *           IsCharUpperW   (USER32.338)
 460  * FIXME: handle current locale
 461  */
 462 BOOL WINAPI IsCharUpperW(WCHAR x)
 463 {
 464     return iswupper(x);
 465 }
 466
 467 /***********************************************************************
 468  *           FormatMessage16   (USER.606)
 469  */
 470 DWORD WINAPI FormatMessage16(
 471     DWORD   dwFlags,
 472     SEGPTR lpSource, /*not always a valid pointer*/
 473     WORD   dwMessageId,
 474     WORD   dwLanguageId,
 475     LPSTR  lpBuffer, /* *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
 476     WORD   nSize,
 477     LPDWORD args /* va_list *args */
 478 ) {
 479 #ifdef __i386__
 480 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 481     LPSTR       target,t;
 482     DWORD       talloced;
 483     LPSTR       from,f;
 484     DWORD       width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 485     BOOL        eos = FALSE;
 486     LPSTR       allocstring = NULL;
 487
 488     TRACE("(0x%lx,%lx,%d,0x%x,%p,%d,%p)\n",
 489           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 490     if (width)
 491         FIXME("line wrapping not supported.\n");
 492     from = NULL;
 493     if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 494         from = HEAP_strdupA( GetProcessHeap(), 0, PTR_SEG_TO_LIN(lpSource));
 495     if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 496         from = HeapAlloc( GetProcessHeap(),0,200 );
 497         sprintf(from,"Systemmessage, messageid = 0x%08x\n",dwMessageId);
 498     }
 499     if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 500         INT16   bufsize;
 501         HINSTANCE16 hinst16 = ((HMODULE)lpSource & 0xffff);
 502
 503         dwMessageId &= 0xFFFF;
 504         bufsize=LoadString16(hinst16,dwMessageId,NULL,0);
 505         if (bufsize) {
 506             from = HeapAlloc( GetProcessHeap(), 0, bufsize +1);
 507             LoadString16(hinst16,dwMessageId,from,bufsize+1);
 508         }
 509     }
 510     target      = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 511     t   = target;
 512     talloced= 100;
 513
 514 #define ADD_TO_T(c) \
 515         *t++=c;\
 516         if (t-target == talloced) {\
 517                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 518                 t       = target+talloced;\
 519                 talloced*=2;\
 520         }
 521
 522     if (from) {
 523         f=from;
 524         while (*f && !eos) {
 525             if (*f=='%') {
 526                 int     insertnr;
 527                 char    *fmtstr,*sprintfbuf,*x,*lastf;
 528                 DWORD   *argliststart;
 529
 530                 fmtstr = NULL;
 531                 lastf = f;
 532                 f++;
 533                 if (!*f) {
 534                     ADD_TO_T('%');
 535                     continue;
 536                 }
 537                 switch (*f) {
 538                 case '1':case '2':case '3':case '4':case '5':
 539                 case '6':case '7':case '8':case '9':
 540                     insertnr=*f-'0';
 541                     switch (f[1]) {
 542                     case '0':case '1':case '2':case '3':
 543                     case '4':case '5':case '6':case '7':
 544                     case '8':case '9':
 545                         f++;
 546                         insertnr=insertnr*10+*f-'0';
 547                         f++;
 548                         break;
 549                     default:
 550                         f++;
 551                         break;
 552                     }
 553                     if (*f=='!') {
 554                         f++;
 555                         if (NULL!=(x=strchr(f,'!'))) {
 556                             *x='\0';
 557                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 558                             sprintf(fmtstr,"%%%s",f);
 559                             f=x+1;
 560                         } else {
 561                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 562                             sprintf(fmtstr,"%%%s",f);
 563                             f+=strlen(f); /*at \0*/
 564                         }
 565                     } else
 566                         if(!args)
 567                             break;
 568                         else
 569                           fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
 570                     if (args) {
 571                         argliststart=args+insertnr-1;
 572                         if (fmtstr[strlen(fmtstr)-1]=='s')
 573                             sprintfbuf=HeapAlloc(GetProcessHeap(),0,
 574                                  strlen(PTR_SEG_TO_LIN(argliststart[0]))+1);
 575                         else
 576                             sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 577
 578                         /* CMF - This makes a BIG assumption about va_list */
 579                         wvsprintf16(sprintfbuf, fmtstr, (va_list) argliststart);
 580                         x=sprintfbuf;
 581                         while (*x) {
 582                             ADD_TO_T(*x++);
 583                         }
 584                         HeapFree(GetProcessHeap(),0,sprintfbuf);
 585                     } else {
 586                         /* NULL args - copy formatstr
 587                          * (probably wrong)
 588                          */
 589                         while ((lastf<f)&&(*lastf)) {
 590                             ADD_TO_T(*lastf++);
 591                         }
 592                     }
 593                     HeapFree(GetProcessHeap(),0,fmtstr);
 594                     break;
 595                 case '0': /* Just stop processing format string */
 596                     eos = TRUE;
 597                     f++;
 598                     break;
 599                 case 'n': /* 16 bit version just outputs 'n' */
 600                 default:
 601                     ADD_TO_T(*f++);
 602                     break;
 603                 }
 604             } else { /* '\n' or '\r' gets mapped to "\r\n" */
 605                 if(*f == '\n' || *f == '\r') {
 606                     ADD_TO_T('\r');
 607                     ADD_TO_T('\n');
 608                     if(*f++ == '\r' && *f == '\n')
 609                         f++;
 610                 } else {
 611                     ADD_TO_T(*f++);
 612                 }
 613             }
 614         }
 615         *t='\0';
 616     }
 617     talloced = strlen(target)+1;
 618     if (nSize && talloced<nSize) {
 619         target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 620     }
 621     TRACE("-- %s\n",debugstr_a(target));
 622     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 623         /* nSize is the MINIMUM size */
 624         *((HLOCAL16*)lpBuffer)=  LocalAlloc16(LPTR,talloced);
 625         allocstring=PTR_SEG_OFF_TO_LIN(CURRENT_DS,*((HLOCAL16*)lpBuffer));
 626         memcpy( allocstring,target,talloced);
 627     } else
 628         lstrcpynA(lpBuffer,target,nSize);
 629     HeapFree(GetProcessHeap(),0,target);
 630     if (from) HeapFree(GetProcessHeap(),0,from);
 631     return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 632         strlen(allocstring):
 633         strlen(lpBuffer);
 634 #else
 635         return 0;
 636 #endif /* __i386__ */
 637 }
 638 #undef ADD_TO_T
 639
 640 /***********************************************************************
 641  *           FormatMessageA   (KERNEL32.138)
 642  * FIXME: missing wrap,FROM_SYSTEM message-loading,
 643  */
 644 DWORD WINAPI FormatMessageA(
 645         DWORD   dwFlags,
 646         LPCVOID lpSource,
 647         DWORD   dwMessageId,
 648         DWORD   dwLanguageId,
 649         LPSTR   lpBuffer,
 650         DWORD   nSize,
 651         LPDWORD args /* va_list *args */
 652 ) {
 653 #ifdef __i386__
 654 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 655         LPSTR   target,t;
 656         DWORD   talloced;
 657         LPSTR   from,f;
 658         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 659         BOOL    eos = FALSE;
 660
 661         TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 662                      dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 663         if (width)
 664                 FIXME("line wrapping not supported.\n");
 665         from = NULL;
 666         if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 667                 from = HEAP_strdupA( GetProcessHeap(), 0, (LPSTR)lpSource);
 668         if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 669                 from = HeapAlloc( GetProcessHeap(),0,200 );
 670                 sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
 671         }
 672         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 673                 INT     bufsize;
 674
 675                 dwMessageId &= 0xFFFF;
 676                 bufsize=LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,NULL,100);
 677                 if (bufsize) {
 678                         from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 679                         LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,from,bufsize+1);
 680                 }
 681         }
 682         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 683         t       = target;
 684         talloced= 100;
 685
 686 #define ADD_TO_T(c) \
 687         *t++=c;\
 688         if (t-target == talloced) {\
 689                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 690                 t       = target+talloced;\
 691                 talloced*=2;\
 692         }
 693
 694         if (from) {
 695                 f=from;
 696                 while (*f && !eos) {
 697                         if (*f=='%') {
 698                                 int     insertnr;
 699                                 char    *fmtstr,*sprintfbuf,*x,*lastf;
 700                                 DWORD   *argliststart;
 701
 702                                 fmtstr = NULL;
 703                                 lastf = f;
 704                                 f++;
 705                                 if (!*f) {
 706                                         ADD_TO_T('%');
 707                                         continue;
 708                                 }
 709                                 switch (*f) {
 710                                 case '1':case '2':case '3':case '4':case '5':
 711                                 case '6':case '7':case '8':case '9':
 712                                         insertnr=*f-'0';
 713                                         switch (f[1]) {
 714                                         case '0':case '1':case '2':case '3':
 715                                         case '4':case '5':case '6':case '7':
 716                                         case '8':case '9':
 717                                                 f++;
 718                                                 insertnr=insertnr*10+*f-'0';
 719                                                 f++;
 720                                                 break;
 721                                         default:
 722                                                 f++;
 723                                                 break;
 724                                         }
 725                                         if (*f=='!') {
 726                                                 f++;
 727                                                 if (NULL!=(x=strchr(f,'!'))) {
 728                                                         *x='\0';
 729                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 730                                                         sprintf(fmtstr,"%%%s",f);
 731                                                         f=x+1;
 732                                                 } else {
 733                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 734                                                         sprintf(fmtstr,"%%%s",f);
 735                                                         f+=strlen(f); /*at \0*/
 736                                                 }
 737                                         } else
 738                                                 if(!args)
 739                                                   break;
 740                                         else
 741                                                 fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
 742                                         if (args) {
 743                                                 if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 744                                                         argliststart=args+insertnr-1;
 745                                                 else
 746                                                     argliststart=(*(DWORD**)args)+insertnr-1;
 747
 748                                                 if (fmtstr[strlen(fmtstr)-1]=='s' && argliststart[0])
 749                                                         sprintfbuf=HeapAlloc(GetProcessHeap(),0,strlen((LPSTR)argliststart[0])+1);
 750                                                 else
 751                                                         sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 752
 753                                                 /* CMF - This makes a BIG assumption about va_list */
 754                                                 wvsprintfA(sprintfbuf, fmtstr, (va_list) argliststart);
 755                                                 x=sprintfbuf;
 756                                                 while (*x) {
 757                                                         ADD_TO_T(*x++);
 758                                                 }
 759                                                 HeapFree(GetProcessHeap(),0,sprintfbuf);
 760                                         } else {
 761                                                 /* NULL args - copy formatstr
 762                                                  * (probably wrong)
 763                                                  */
 764                                                 while ((lastf<f)&&(*lastf)) {
 765                                                         ADD_TO_T(*lastf++);
 766                                                 }
 767                                         }
 768                                         HeapFree(GetProcessHeap(),0,fmtstr);
 769                                         break;
 770                                 case 'n':
 771                                         ADD_TO_T('\r');
 772                                         ADD_TO_T('\n');
 773                                         f++;
 774                                         break;
 775                                 case '0':
 776                                         eos = TRUE;
 777                                         f++;
 778                                         break;
 779                                 default:
 780                                         ADD_TO_T(*f++)
 781                                         break;
 782                                 }
 783                         } else { /* '\n' or '\r' gets mapped to "\r\n" */
 784                             if(*f == '\n' || *f == '\r') {
 785                                 ADD_TO_T('\r');
 786                                 ADD_TO_T('\n');
 787                                 if(*f++ == '\r' && *f == '\n')
 788                                     f++;
 789                             } else {
 790                                 ADD_TO_T(*f++);
 791                             }
 792                         }
 793                 }
 794                 *t='\0';
 795         }
 796         talloced = strlen(target)+1;
 797         if (nSize && talloced<nSize) {
 798                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 799         }
 800     TRACE("-- %s\n",debugstr_a(target));
 801         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 802                 /* nSize is the MINIMUM size */
 803                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,talloced);
 804                 memcpy(*(LPSTR*)lpBuffer,target,talloced);
 805     } else {
 806                 lstrcpynA(lpBuffer,target,nSize);
 807     }
 808         HeapFree(GetProcessHeap(),0,target);
 809         if (from) HeapFree(GetProcessHeap(),0,from);
 810         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 811                         strlen(*(LPSTR*)lpBuffer):
 812                         strlen(lpBuffer);
 813 #else
 814         return 0;
 815 #endif /* __i386__ */
 816 }
 817 #undef ADD_TO_T
 818
 819
 820 /***********************************************************************
 821  *           FormatMessageW   (KERNEL32.138)
 822  */
 823 DWORD WINAPI FormatMessageW(
 824         DWORD   dwFlags,
 825         LPCVOID lpSource,
 826         DWORD   dwMessageId,
 827         DWORD   dwLanguageId,
 828         LPWSTR  lpBuffer,
 829         DWORD   nSize,
 830         LPDWORD args /* va_list *args */
 831 ) {
 832 #ifdef __i386__
 833 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 834         LPSTR   target,t;
 835         DWORD   talloced;
 836         LPSTR   from,f;
 837         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 838         BOOL    eos = FALSE;
 839
 840         TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 841                      dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 842         if (width)
 843                 FIXME("line wrapping not supported.\n");
 844         from = NULL;
 845         if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 846                 from = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lpSource);
 847         if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 848                 /* gather information from system message tables ... */
 849                 from = HeapAlloc( GetProcessHeap(),0,200 );
 850                 sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
 851         }
 852         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 853                 INT     bufsize;
 854
 855                 dwMessageId &= 0xFFFF;
 856                 bufsize=LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,NULL,100);
 857                 if (bufsize)
 858                 {
 859                     from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 860                     LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,from,bufsize+1);
 861                 }
 862         }
 863         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 );
 864         t       = target;
 865         talloced= 100;
 866
 867 #define ADD_TO_T(c) \
 868         *t++=c;\
 869         if (t-target == talloced) {\
 870                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 871                 t       = target+talloced;\
 872                 talloced*=2;\
 873         }
 874
 875         if (from) {
 876                 f=from;
 877                 while (*f && !eos) {
 878                         if (*f=='%') {
 879                                 int     insertnr;
 880                                 char    *fmtstr,*sprintfbuf,*x;
 881                                 DWORD   *argliststart;
 882
 883                                 fmtstr = NULL;
 884                                 f++;
 885                                 if (!*f) {
 886                                         ADD_TO_T('%');
 887                                         continue;
 888                                 }
 889                                 switch (*f) {
 890                                 case '1':case '2':case '3':case '4':case '5':
 891                                 case '6':case '7':case '8':case '9':
 892                                         insertnr=*f-'0';
 893                                         switch (f[1]) {
 894                                         case '0':case '1':case '2':case '3':
 895                                         case '4':case '5':case '6':case '7':
 896                                         case '8':case '9':
 897                                                 f++;
 898                                                 insertnr=insertnr*10+*f-'0';
 899                                                 f++;
 900                                                 break;
 901                                         default:
 902                                                 f++;
 903                                                 break;
 904                                         }
 905                                         if (*f=='!') {
 906                                                 f++;
 907                                                 if (NULL!=(x=strchr(f,'!')))
 908                                                 {
 909                                                     *x='\0';
 910                                                     fmtstr=HeapAlloc( GetProcessHeap(), 0, strlen(f)+2);
 911                                                         sprintf(fmtstr,"%%%s",f);
 912                                                         f=x+1;
 913                                                 } else {
 914                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 915                                                         sprintf(fmtstr,"%%%s",f);
 916                                                         f+=strlen(f); /*at \0*/
 917                                                 }
 918                                         } else
 919                                                 if(!args)
 920                                                   break;
 921                                         else
 922                                                 fmtstr=HEAP_strdupA( GetProcessHeap(),0,"%s");
 923                                         if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 924                                                 argliststart=args+insertnr-1;
 925                                         else
 926                                                 argliststart=(*(DWORD**)args)+insertnr-1;
 927
 928                                         if (fmtstr[strlen(fmtstr)-1]=='s' && argliststart[0]) {
 929                                                 DWORD   xarr[3];
 930
 931                                                 xarr[0]=(DWORD)HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)(*(argliststart+0)));
 932                                                 /* possible invalid pointers */
 933                                                 xarr[1]=*(argliststart+1);
 934                                                 xarr[2]=*(argliststart+2);
 935                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,lstrlenW((LPWSTR)argliststart[0])*2+1);
 936
 937                                                 /* CMF - This makes a BIG assumption about va_list */
 938                                                 vsprintf(sprintfbuf, fmtstr, (va_list) xarr);
 939                                         } else {
 940                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 941
 942                                                 /* CMF - This makes a BIG assumption about va_list */
 943                                                 wvsprintfA(sprintfbuf, fmtstr, (va_list) argliststart);
 944                                         }
 945                                         x=sprintfbuf;
 946                                         while (*x) {
 947                                                 ADD_TO_T(*x++);
 948                                         }
 949                                         HeapFree(GetProcessHeap(),0,sprintfbuf);
 950                                         HeapFree(GetProcessHeap(),0,fmtstr);
 951                                         break;
 952                                 case 'n':
 953                                         ADD_TO_T('\r');
 954                                         ADD_TO_T('\n');
 955                                         f++;
 956                                         break;
 957                                 case '0':
 958                                         eos = TRUE;
 959                                         f++;
 960                                         break;
 961                                 default:
 962                                         ADD_TO_T(*f++)
 963                                         break;
 964                                 }
 965                         } else { /* '\n' or '\r' gets mapped to "\r\n" */
 966                             if(*f == '\n' || *f == '\r') {
 967                                 ADD_TO_T('\r');
 968                                 ADD_TO_T('\n');
 969                                 if(*f++ == '\r' && *f == '\n')
 970                                     f++;
 971                             } else {
 972                                 ADD_TO_T(*f++);
 973                             }
 974                         }
 975                 }
 976                 *t='\0';
 977         }
 978         talloced = strlen(target)+1;
 979         if (nSize && talloced<nSize)
 980                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 981         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 982                 /* nSize is the MINIMUM size */
 983                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,talloced*2+2);
 984                 lstrcpynAtoW(*(LPWSTR*)lpBuffer,target,talloced);
 985         } else
 986                 lstrcpynAtoW(lpBuffer,target,nSize);
 987         HeapFree(GetProcessHeap(),0,target);
 988         if (from) HeapFree(GetProcessHeap(),0,from);
 989         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 990                         lstrlenW(*(LPWSTR*)lpBuffer):
 991                         lstrlenW(lpBuffer);
 992 #else
 993         return 0;
 994 #endif /* __i386__ */
 995 }
 996 #undef ADD_TO_T