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