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 <stdio.h>
   9 #include <stdarg.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13
  14 #include "windows.h"
  15 #include "winnt.h"      /* HEAP_ macros */
  16 #include "heap.h"
  17 #include "ldt.h"
  18 #include "module.h"
  19 #include "stddebug.h"
  20 #include "debug.h"
  21
  22 #define ToUpper(c)      toupper(c)
  23 #define ToLower(c)      tolower(c)
  24
  25
  26 /* Funny to divide them between user and kernel. */
  27
  28 /* IsCharAlpha USER 433 */
  29 BOOL16 WINAPI IsCharAlpha16(CHAR ch)
  30 {
  31   return isalpha(ch);   /* This is probably not right for NLS */
  32 }
  33
  34 /* IsCharAlphanumeric USER 434 */
  35 BOOL16 WINAPI IsCharAlphaNumeric16(CHAR ch)
  36 {
  37     return isalnum(ch);
  38 }
  39
  40 /* IsCharUpper USER 435 */
  41 BOOL16 WINAPI IsCharUpper16(CHAR ch)
  42 {
  43   return isupper(ch);
  44 }
  45
  46 /* IsCharLower USER 436 */
  47 BOOL16 WINAPI IsCharLower16(CHAR ch)
  48 {
  49   return islower(ch);
  50 }
  51
  52 /***********************************************************************
  53  *           AnsiUpper16   (USER.431)
  54  */
  55 SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
  56 {
  57   /* I am not sure if the locale stuff works with toupper, but then again
  58      I am not sure if the Linux libc locale stuffs works at all */
  59
  60     /* uppercase only one char if strOrChar < 0x10000 */
  61     if (HIWORD(strOrChar))
  62     {
  63         char *s;
  64         for (s = PTR_SEG_TO_LIN(strOrChar); *s; s++) *s = toupper(*s);
  65         return strOrChar;
  66     }
  67     else return (SEGPTR)ToUpper( (int)strOrChar );
  68 }
  69
  70
  71 /***********************************************************************
  72  *           AnsiUpperBuff16   (USER.437)
  73  */
  74 UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
  75 {
  76     UINT32 count = len ? len : 65536;
  77     for (; count; count--, str++) *str = toupper(*str);
  78     return len;
  79 }
  80
  81 /***********************************************************************
  82  *           AnsiLower16   (USER.432)
  83  */
  84 SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
  85 {
  86   /* I am not sure if the locale stuff works with toupper, but then again
  87      I am not sure if the Linux libc locale stuffs works at all */
  88
  89     /* lowercase only one char if strOrChar < 0x10000 */
  90     if (HIWORD(strOrChar))
  91     {
  92         char *s;
  93         for (s = PTR_SEG_TO_LIN( strOrChar ); *s; s++) *s = tolower( *s );
  94         return strOrChar;
  95     }
  96     else return (SEGPTR)tolower( (int)strOrChar );
  97 }
  98
  99
 100 /***********************************************************************
 101  *           AnsiLowerBuff16   (USER.438)
 102  */
 103 UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
 104 {
 105     UINT32 count = len ? len : 65536;
 106     for (; count; count--, str++) *str = tolower(*str);
 107     return len;
 108 }
 109
 110
 111 /***********************************************************************
 112  *           AnsiNext16   (USER.472)
 113  */
 114 SEGPTR WINAPI AnsiNext16(SEGPTR current)
 115 {
 116     return (*(char *)PTR_SEG_TO_LIN(current)) ? current + 1 : current;
 117 }
 118
 119
 120 /***********************************************************************
 121  *           AnsiPrev16   (USER.473)
 122  */
 123 SEGPTR WINAPI AnsiPrev16( SEGPTR start, SEGPTR current )
 124 {
 125     return (current == start) ? start : current - 1;
 126 }
 127
 128
 129 /***********************************************************************
 130  *           OutputDebugString16   (KERNEL.115)
 131  */
 132 void WINAPI OutputDebugString16( LPCSTR str )
 133 {
 134     char *module;
 135     char *p, *buffer = HeapAlloc( GetProcessHeap(), 0, strlen(str)+2 );
 136     /* Remove CRs */
 137     for (p = buffer; *str; str++) if (*str != '\r') *p++ = *str;
 138     *p = '\0';
 139     if ((p > buffer) && (p[-1] == '\n')) p[1] = '\0'; /* Remove trailing \n */
 140     module = MODULE_GetModuleName( GetCurrentTask() );
 141     fprintf( stderr, "OutputDebugString: %s says '%s'\n",
 142              module ? module : "???", buffer );
 143     HeapFree( GetProcessHeap(), 0, buffer );
 144 }
 145
 146
 147 /***********************************************************************
 148  *           OutputDebugString32A   (KERNEL32
 149  */
 150 void WINAPI OutputDebugString32A( LPCSTR str )
 151 {
 152     OutputDebugString16( str );
 153 }
 154
 155
 156
 157 /***********************************************************************
 158  *           OutputDebugString32W   (KERNEL32
 159  */
 160 void WINAPI OutputDebugString32W( LPCWSTR str )
 161 {
 162     LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
 163     OutputDebugString32A( p );
 164     HeapFree( GetProcessHeap(), 0, p );
 165 }
 166
 167
 168
 169 /***********************************************************************
 170  *           CharNext32A   (USER32.28)
 171  */
 172 LPSTR WINAPI CharNext32A( LPCSTR ptr )
 173 {
 174     if (!*ptr) return (LPSTR)ptr;
 175     if (IsDBCSLeadByte32( *ptr )) return (LPSTR)(ptr + 2);
 176     return (LPSTR)(ptr + 1);
 177 }
 178
 179
 180 /***********************************************************************
 181  *           CharNextEx32A   (USER32.29)
 182  */
 183 LPSTR WINAPI CharNextEx32A( WORD codepage, LPCSTR ptr, DWORD flags )
 184 {
 185     if (!*ptr) return (LPSTR)ptr;
 186     if (IsDBCSLeadByteEx( codepage, *ptr )) return (LPSTR)(ptr + 2);
 187     return (LPSTR)(ptr + 1);
 188 }
 189
 190
 191 /***********************************************************************
 192  *           CharNextExW   (USER32.30)
 193  */
 194 LPWSTR WINAPI CharNextEx32W(WORD codepage,LPCWSTR x,DWORD flags)
 195 {
 196     /* FIXME: add DBCS / codepage stuff */
 197     if (*x) return (LPWSTR)(x+1);
 198     else return (LPWSTR)x;
 199 }
 200
 201 /***********************************************************************
 202  *           CharNextW   (USER32.31)
 203  */
 204 LPWSTR WINAPI CharNext32W(LPCWSTR x)
 205 {
 206     if (*x) return (LPWSTR)(x+1);
 207     else return (LPWSTR)x;
 208 }
 209
 210 /***********************************************************************
 211  *           CharPrev32A   (USER32.32)
 212  */
 213 LPSTR WINAPI CharPrev32A( LPCSTR start, LPCSTR ptr )
 214 {
 215     while (*start && (start < ptr))
 216     {
 217         LPCSTR next = CharNext32A( start );
 218         if (next >= ptr) break;
 219         start = next;
 220     }
 221     return (LPSTR)start;
 222 }
 223
 224
 225 /***********************************************************************
 226  *           CharPrevEx32A   (USER32.33)
 227  */
 228 LPSTR WINAPI CharPrevEx32A( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
 229 {
 230     while (*start && (start < ptr))
 231     {
 232         LPCSTR next = CharNextEx32A( codepage, start, flags );
 233         if (next > ptr) break;
 234         start = next;
 235     }
 236     return (LPSTR)start;
 237 }
 238
 239
 240 /***********************************************************************
 241  *           CharPrevExW   (USER32.34)
 242  */
 243 LPWSTR WINAPI CharPrevEx32W(WORD codepage,LPCWSTR start,LPCWSTR x,DWORD flags)
 244 {
 245     /* FIXME: add DBCS / codepage stuff */
 246     if (x>start) return (LPWSTR)(x-1);
 247     else return (LPWSTR)x;
 248 }
 249
 250 /***********************************************************************
 251  *           CharPrevW   (USER32.35)
 252  */
 253 LPWSTR WINAPI CharPrev32W(LPCWSTR start,LPCWSTR x)
 254 {
 255     if (x>start) return (LPWSTR)(x-1);
 256     else return (LPWSTR)x;
 257 }
 258
 259 /***********************************************************************
 260  *           CharLowerA   (USER32.24)
 261  * FIXME: handle current locale
 262  */
 263 LPSTR WINAPI CharLower32A(LPSTR x)
 264 {
 265     LPSTR       s;
 266
 267     if (HIWORD(x))
 268     {
 269         s=x;
 270         while (*s)
 271         {
 272             *s=tolower(*s);
 273             s++;
 274         }
 275         return x;
 276     }
 277     else return (LPSTR)tolower(LOWORD(x));
 278 }
 279
 280 /***********************************************************************
 281  *           CharLowerBuffA   (USER32.25)
 282  * FIXME: handle current locale
 283  */
 284 DWORD WINAPI CharLowerBuff32A(LPSTR x,DWORD buflen)
 285 {
 286     DWORD done=0;
 287
 288     while (*x && (buflen--))
 289     {
 290         *x=tolower(*x);
 291         x++;
 292         done++;
 293     }
 294     return done;
 295 }
 296
 297 /***********************************************************************
 298  *           CharLowerBuffW   (USER32.26)
 299  * FIXME: handle current locale
 300  */
 301 DWORD WINAPI CharLowerBuff32W(LPWSTR x,DWORD buflen)
 302 {
 303     DWORD done=0;
 304
 305     while (*x && (buflen--))
 306     {
 307         *x=tolower(*x);
 308         x++;
 309         done++;
 310     }
 311     return done;
 312 }
 313
 314 /***********************************************************************
 315  *           CharLowerW   (USER32.27)
 316  * FIXME: handle current locale
 317  */
 318 LPWSTR WINAPI CharLower32W(LPWSTR x)
 319 {
 320     if (HIWORD(x))
 321     {
 322         LPWSTR s = x;
 323         while (*s)
 324         {
 325             *s=tolower(*s);
 326             s++;
 327         }
 328         return x;
 329     }
 330     else return (LPWSTR)tolower(LOWORD(x));
 331 }
 332
 333 /***********************************************************************
 334  *           CharUpper32A   (USER32.40)
 335  * FIXME: handle current locale
 336  */
 337 LPSTR WINAPI CharUpper32A(LPSTR x)
 338 {
 339     if (HIWORD(x))
 340     {
 341         LPSTR s = x;
 342         while (*s)
 343         {
 344             *s=toupper(*s);
 345             s++;
 346         }
 347         return x;
 348     }
 349     else return (LPSTR)toupper(LOWORD(x));
 350 }
 351
 352 /***********************************************************************
 353  *           CharUpperBuffA   (USER32.41)
 354  * FIXME: handle current locale
 355  */
 356 DWORD WINAPI CharUpperBuff32A(LPSTR x,DWORD buflen)
 357 {
 358     DWORD done=0;
 359
 360     while (*x && (buflen--))
 361     {
 362         *x=toupper(*x);
 363         x++;
 364         done++;
 365     }
 366     return done;
 367 }
 368
 369 /***********************************************************************
 370  *           CharUpperBuffW   (USER32.42)
 371  * FIXME: handle current locale
 372  */
 373 DWORD WINAPI CharUpperBuff32W(LPWSTR x,DWORD buflen)
 374 {
 375     DWORD done=0;
 376
 377     while (*x && (buflen--))
 378     {
 379         *x=toupper(*x);
 380         x++;
 381         done++;
 382     }
 383     return done;
 384 }
 385
 386 /***********************************************************************
 387  *           CharUpperW   (USER32.43)
 388  * FIXME: handle current locale
 389  */
 390 LPWSTR WINAPI CharUpper32W(LPWSTR x)
 391 {
 392     if (HIWORD(x))
 393     {
 394         LPWSTR s = x;
 395         while (*s)
 396         {
 397             *s=toupper(*s);
 398             s++;
 399         }
 400         return x;
 401     }
 402     else return (LPWSTR)toupper(LOWORD(x));
 403 }
 404
 405 /***********************************************************************
 406  *           IsCharAlphaA   (USER32.330)
 407  * FIXME: handle current locale
 408  */
 409 BOOL32 WINAPI IsCharAlpha32A(CHAR x)
 410 {
 411     return isalpha(x);
 412 }
 413
 414 /***********************************************************************
 415  *           IsCharAlphaNumericA   (USER32.331)
 416  * FIXME: handle current locale
 417  */
 418 BOOL32 WINAPI IsCharAlphaNumeric32A(CHAR x)
 419 {
 420     return isalnum(x);
 421 }
 422
 423 /***********************************************************************
 424  *           IsCharAlphaNumericW   (USER32.332)
 425  * FIXME: handle current locale
 426  */
 427 BOOL32 WINAPI IsCharAlphaNumeric32W(WCHAR x)
 428 {
 429     return isalnum(x);
 430 }
 431
 432 /***********************************************************************
 433  *           IsCharAlphaW   (USER32.333)
 434  * FIXME: handle current locale
 435  */
 436 BOOL32 WINAPI IsCharAlpha32W(WCHAR x)
 437 {
 438     return isalpha(x);
 439 }
 440
 441 /***********************************************************************
 442  *           IsCharLower32A   (USER32.334)
 443  * FIXME: handle current locale
 444  */
 445 BOOL32 WINAPI IsCharLower32A(CHAR x)
 446 {
 447     return islower(x);
 448 }
 449
 450 /***********************************************************************
 451  *           IsCharLower32W   (USER32.335)
 452  * FIXME: handle current locale
 453  */
 454 BOOL32 WINAPI IsCharLower32W(WCHAR x)
 455 {
 456     return islower(x);
 457 }
 458
 459 /***********************************************************************
 460  *           IsCharUpper32A   (USER32.336)
 461  * FIXME: handle current locale
 462  */
 463 BOOL32 WINAPI IsCharUpper32A(CHAR x)
 464 {
 465     return isupper(x);
 466 }
 467
 468 /***********************************************************************
 469  *           IsCharUpper32W   (USER32.337)
 470  * FIXME: handle current locale
 471  */
 472 BOOL32 WINAPI IsCharUpper32W(WCHAR x)
 473 {
 474     return isupper(x);
 475 }
 476
 477 /***********************************************************************
 478  *           FormatMessage32A   (KERNEL32.138)
 479  * FIXME: missing wrap,FROM_SYSTEM message-loading,
 480  */
 481 DWORD WINAPI FormatMessage32A(
 482         DWORD   dwFlags,
 483         LPCVOID lpSource,
 484         DWORD   dwMessageId,
 485         DWORD   dwLanguageId,
 486         LPSTR   lpBuffer,
 487         DWORD   nSize,
 488         LPDWORD args /* va_list *args */
 489 ) {
 490         LPSTR   target,t;
 491         DWORD   talloced;
 492         LPSTR   from,f;
 493         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 494         DWORD   nolinefeed = 0;
 495
 496         dprintf_resource(stddeb,
 497                 "FormatMessage32A(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 498                 dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args
 499         );
 500         if (width)
 501                 fprintf(stdnimp,"       - line wrapping not supported.\n");
 502         from = NULL;
 503         if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 504                 from = HEAP_strdupA( GetProcessHeap(), 0, (LPSTR)lpSource);
 505         if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 506                 from = HeapAlloc( GetProcessHeap(),0,200 );
 507                 sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
 508         }
 509         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 510                 INT32   bufsize;
 511
 512                 dwMessageId &= 0xFFFF;
 513                 bufsize=LoadMessage32A(0,dwMessageId,dwLanguageId,NULL,100);
 514                 if (bufsize) {
 515                         from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 516                         LoadMessage32A(0,dwMessageId,dwLanguageId,from,bufsize+1);
 517                 }
 518         }
 519         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 520         t       = target;
 521         talloced= 100;
 522
 523 #define ADD_TO_T(c) \
 524         *t++=c;\
 525         if (t-target == talloced) {\
 526                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 527                 t       = target+talloced;\
 528                 talloced*=2;\
 529         }
 530
 531         if (from) {
 532                 f=from;
 533                 while (*f) {
 534                         if (*f=='%') {
 535                                 int     insertnr;
 536                                 char    *fmtstr,*sprintfbuf,*x,*lastf;
 537                                 DWORD   *argliststart;
 538
 539                                 fmtstr = NULL;
 540                                 lastf = f;
 541                                 f++;
 542                                 if (!*f) {
 543                                         ADD_TO_T('%');
 544                                         continue;
 545                                 }
 546                                 switch (*f) {
 547                                 case '1':case '2':case '3':case '4':case '5':
 548                                 case '6':case '7':case '8':case '9':
 549                                         insertnr=*f-'0';
 550                                         switch (f[1]) {
 551                                         case '0':case '1':case '2':case '3':
 552                                         case '4':case '5':case '6':case '7':
 553                                         case '8':case '9':
 554                                                 f++;
 555                                                 insertnr=insertnr*10+*f-'0';
 556                                                 f++;
 557                                                 break;
 558                                         default:
 559                                                 f++;
 560                                                 break;
 561                                         }
 562                                         if (*f=='!') {
 563                                                 f++;
 564                                                 if (NULL!=(x=strchr(f,'!'))) {
 565                                                         *x='\0';
 566                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 567                                                         sprintf(fmtstr,"%%%s",f);
 568                                                         f=x+1;
 569                                                 } else {
 570                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 571                                                         sprintf(fmtstr,"%%%s",f);
 572                                                         f+=strlen(f); /*at \0*/
 573                                                 }
 574                                         } else
 575                                                 fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
 576                                         if (args) {
 577                                                 if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 578                                                         argliststart=args+insertnr-1;
 579                                                 else
 580                                                     argliststart=(*(DWORD**)args)+insertnr-1;
 581
 582                                                 if (fmtstr[strlen(fmtstr)]=='s')
 583                                                         sprintfbuf=HeapAlloc(GetProcessHeap(),0,strlen((LPSTR)argliststart[0])+1);
 584                                                 else
 585                                                         sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 586
 587                                                 /* CMF - This makes a BIG assumption about va_list */
 588                                                 vsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
 589                                                 x=sprintfbuf;
 590                                                 while (*x) {
 591                                                         ADD_TO_T(*x++);
 592                                                 }
 593                                                 HeapFree(GetProcessHeap(),0,sprintfbuf);
 594                                         } else {
 595                                                 /* NULL args - copy formatstr
 596                                                  * (probably wrong)
 597                                                  */
 598                                                 while (lastf<f) {
 599                                                         ADD_TO_T(*lastf++);
 600                                                 }
 601                                         }
 602                                         HeapFree(GetProcessHeap(),0,fmtstr);
 603                                         break;
 604                                 case 'n':
 605                                         /* FIXME: perhaps add \r too? */
 606                                         ADD_TO_T('\n');
 607                                         f++;
 608                                         break;
 609                                 case '0':
 610                                         nolinefeed=1;
 611                                         f++;
 612                                         break;
 613                                 default:ADD_TO_T(*f++)
 614                                         break;
 615
 616                                 }
 617                         } else {
 618                                 ADD_TO_T(*f++)
 619                         }
 620                 }
 621                 *t='\0';
 622         }
 623         if (!nolinefeed && t[-1]!='\n')
 624                 ADD_TO_T('\n');
 625         talloced = strlen(target)+1;
 626         if (nSize && talloced<nSize) {
 627                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 628         }
 629         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 630                 /* nSize is the MINIMUM size */
 631                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc32(GMEM_ZEROINIT,talloced);
 632                 memcpy(*(LPSTR*)lpBuffer,target,talloced);
 633         } else
 634                 strncpy(lpBuffer,target,nSize);
 635         HeapFree(GetProcessHeap(),0,target);
 636         if (from) HeapFree(GetProcessHeap(),0,from);
 637         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 638                         strlen(*(LPSTR*)lpBuffer):
 639                         strlen(lpBuffer);
 640 }
 641 #undef ADD_TO_T
 642
 643
 644 /***********************************************************************
 645  *           FormatMessage32W   (KERNEL32.138)
 646  */
 647 DWORD WINAPI FormatMessage32W(
 648         DWORD   dwFlags,
 649         LPCVOID lpSource,
 650         DWORD   dwMessageId,
 651         DWORD   dwLanguageId,
 652         LPWSTR  lpBuffer,
 653         DWORD   nSize,
 654         LPDWORD args /* va_list *args */
 655 ) {
 656         LPSTR   target,t;
 657         DWORD   talloced;
 658         LPSTR   from,f;
 659         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 660         DWORD   nolinefeed = 0;
 661
 662         dprintf_resource(stddeb,
 663                 "FormatMessage32A(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 664                 dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args
 665         );
 666         if (width)
 667                 fprintf(stdnimp,"       - line wrapping not supported.\n");
 668         from = NULL;
 669         if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 670                 from = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lpSource);
 671         if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 672                 /* gather information from system message tables ... */
 673                 from = HeapAlloc( GetProcessHeap(),0,200 );
 674                 sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
 675         }
 676         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 677                 INT32   bufsize;
 678
 679                 dwMessageId &= 0xFFFF;
 680                 bufsize=LoadMessage32A(0,dwMessageId,dwLanguageId,NULL,100);
 681                 if (bufsize)
 682                 {
 683                     from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 684                     LoadMessage32A(0,dwMessageId,dwLanguageId,from,bufsize+1);
 685                 }
 686         }
 687         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 );
 688         t       = target;
 689         talloced= 100;
 690
 691 #define ADD_TO_T(c) \
 692         *t++=c;\
 693         if (t-target == talloced) {\
 694                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 695                 t       = target+talloced;\
 696                 talloced*=2;\
 697         }
 698
 699         if (from) {
 700                 f=from;
 701                 while (*f) {
 702                         if (*f=='%') {
 703                                 int     insertnr;
 704                                 char    *fmtstr,*sprintfbuf,*x;
 705                                 DWORD   *argliststart;
 706
 707                                 fmtstr = NULL;
 708                                 f++;
 709                                 if (!*f) {
 710                                         ADD_TO_T('%');
 711                                         continue;
 712                                 }
 713                                 switch (*f) {
 714                                 case '1':case '2':case '3':case '4':case '5':
 715                                 case '6':case '7':case '8':case '9':
 716                                         insertnr=*f-'0';
 717                                         switch (f[1]) {
 718                                         case '0':case '1':case '2':case '3':
 719                                         case '4':case '5':case '6':case '7':
 720                                         case '8':case '9':
 721                                                 f++;
 722                                                 insertnr=insertnr*10+*f-'0';
 723                                                 f++;
 724                                                 break;
 725                                         default:
 726                                                 f++;
 727                                                 break;
 728                                         }
 729                                         if (*f=='!') {
 730                                                 f++;
 731                                                 if (NULL!=(x=strchr(f,'!')))
 732                                                 {
 733                                                     *x='\0';
 734                                                     fmtstr=HeapAlloc( GetProcessHeap(), 0, strlen(f)+2);
 735                                                         sprintf(fmtstr,"%%%s",f);
 736                                                         f=x+1;
 737                                                 } else {
 738                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 739                                                         sprintf(fmtstr,"%%%s",f);
 740                                                         f+=strlen(f); /*at \0*/
 741                                                 }
 742                                         } else
 743                                                 fmtstr=HEAP_strdupA( GetProcessHeap(),0,"%s");
 744                                         if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 745                                                 argliststart=args+insertnr-1;
 746                                         else
 747                                                 argliststart=(*(DWORD**)args)+insertnr-1;
 748
 749                                         if (fmtstr[strlen(fmtstr)]=='s') {
 750                                                 DWORD   xarr[3];
 751
 752                                                 xarr[0]=(DWORD)HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)(*(argliststart+0)));
 753                                                 /* possible invalid pointers */
 754                                                 xarr[1]=*(argliststart+1);
 755                                                 xarr[2]=*(argliststart+2);
 756                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,lstrlen32W((LPWSTR)argliststart[0])*2+1);
 757
 758                                                 /* CMF - This makes a BIG assumption about va_list */
 759                                                 vsprintf(sprintfbuf, fmtstr, (va_list) xarr);
 760                                         } else {
 761                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 762
 763                                                 /* CMF - This makes a BIG assumption about va_list */
 764                                                 vsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
 765                                         }
 766                                         x=sprintfbuf;
 767                                         while (*x) {
 768                                                 ADD_TO_T(*x++);
 769                                         }
 770                                         HeapFree(GetProcessHeap(),0,sprintfbuf);
 771                                         HeapFree(GetProcessHeap(),0,fmtstr);
 772                                         break;
 773                                 case 'n':
 774                                         /* FIXME: perhaps add \r too? */
 775                                         ADD_TO_T('\n');
 776                                         f++;
 777                                         break;
 778                                 case '0':
 779                                         nolinefeed=1;
 780                                         f++;
 781                                         break;
 782                                 default:ADD_TO_T(*f++)
 783                                         break;
 784
 785                                 }
 786                         } else {
 787                                 ADD_TO_T(*f++)
 788                         }
 789                 }
 790                 *t='\0';
 791         }
 792         if (!nolinefeed && t[-1]!='\n')
 793                 ADD_TO_T('\n');
 794         talloced = strlen(target)+1;
 795         if (nSize && talloced<nSize)
 796                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 797         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 798                 /* nSize is the MINIMUM size */
 799                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc32(GMEM_ZEROINIT,talloced*2+2);
 800                 lstrcpynAtoW(*(LPWSTR*)lpBuffer,target,talloced);
 801         } else
 802                 lstrcpynAtoW(lpBuffer,target,nSize);
 803         HeapFree(GetProcessHeap(),0,target);
 804         if (from) HeapFree(GetProcessHeap(),0,from);
 805         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 806                         lstrlen32W(*(LPWSTR*)lpBuffer):
 807                         lstrlen32W(lpBuffer);
 808 }
 809 #undef ADD_TO_T