dlls/user/lstr.c

   1 /*
   2  * USER string functions
   3  *
   4  * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
   5  * Copyright 1996 Alexandre Julliard
   6  * Copyright 1996 Marcus Meissner
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <ctype.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winerror.h"
  35
  36 #include "wine/exception.h"
  37 #include "wine/unicode.h"
  38 #include "wine/winbase16.h"
  39 #include "wine/winuser16.h"
  40
  41 #include "excpt.h"
  42
  43 #include "wine/debug.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(resource);
  46
  47 /* filter for page-fault exceptions */
  48 static WINE_EXCEPTION_FILTER(page_fault)
  49 {
  50     if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ||
  51         GetExceptionCode() == EXCEPTION_PRIV_INSTRUCTION)
  52         return EXCEPTION_EXECUTE_HANDLER;
  53     return EXCEPTION_CONTINUE_SEARCH;
  54 }
  55
  56 /***********************************************************************
  57  *           AnsiToOem   (KEYBOARD.5)
  58  */
  59 INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
  60 {
  61     CharToOemA( s, d );
  62     return -1;
  63 }
  64
  65
  66 /***********************************************************************
  67  *           OemToAnsi   (KEYBOARD.6)
  68  */
  69 INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
  70 {
  71     OemToCharA( s, d );
  72     return -1;
  73 }
  74
  75
  76 /***********************************************************************
  77  *           AnsiToOemBuff   (KEYBOARD.134)
  78  */
  79 void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
  80 {
  81     if (len != 0) CharToOemBuffA( s, d, len );
  82 }
  83
  84
  85 /***********************************************************************
  86  *           OemToAnsiBuff   (KEYBOARD.135)
  87  */
  88 void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
  89 {
  90     if (len != 0) OemToCharBuffA( s, d, len );
  91 }
  92
  93
  94 /***********************************************************************
  95  *           lstrcmp   (USER.430)
  96  */
  97 INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
  98 {
  99     return (INT16)strcmp( str1, str2 );
 100 }
 101
 102
 103 /***********************************************************************
 104  *           AnsiUpper   (USER.431)
 105  */
 106 SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
 107 {
 108     /* uppercase only one char if strOrChar < 0x10000 */
 109     if (HIWORD(strOrChar))
 110     {
 111         CharUpperA( MapSL(strOrChar) );
 112         return strOrChar;
 113     }
 114     else return (SEGPTR)CharUpperA( (LPSTR)strOrChar );
 115 }
 116
 117
 118 /***********************************************************************
 119  *           AnsiLower   (USER.432)
 120  */
 121 SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
 122 {
 123     /* lowercase only one char if strOrChar < 0x10000 */
 124     if (HIWORD(strOrChar))
 125     {
 126         CharLowerA( MapSL(strOrChar) );
 127         return strOrChar;
 128     }
 129     else return (SEGPTR)CharLowerA( (LPSTR)strOrChar );
 130 }
 131
 132
 133 /***********************************************************************
 134  *           AnsiUpperBuff   (USER.437)
 135  */
 136 UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
 137 {
 138     CharUpperBuffA( str, len ? len : 65536 );
 139     return len;
 140 }
 141
 142
 143 /***********************************************************************
 144  *           AnsiLowerBuff   (USER.438)
 145  */
 146 UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
 147 {
 148     CharLowerBuffA( str, len ? len : 65536 );
 149     return len;
 150 }
 151
 152
 153 /***********************************************************************
 154  *           AnsiNext   (USER.472)
 155  */
 156 SEGPTR WINAPI AnsiNext16(SEGPTR current)
 157 {
 158     char *ptr = MapSL(current);
 159     return current + (CharNextA(ptr) - ptr);
 160 }
 161
 162
 163 /***********************************************************************
 164  *           AnsiPrev   (USER.473)
 165  */
 166 SEGPTR WINAPI AnsiPrev16( LPCSTR start, SEGPTR current )
 167 {
 168     char *ptr = MapSL(current);
 169     return current - (ptr - CharPrevA( start, ptr ));
 170 }
 171
 172
 173 /***********************************************************************
 174  *           CharNextA   (USER32.@)
 175  */
 176 LPSTR WINAPI CharNextA( LPCSTR ptr )
 177 {
 178     if (!*ptr) return (LPSTR)ptr;
 179     if (IsDBCSLeadByte( ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
 180     return (LPSTR)(ptr + 1);
 181 }
 182
 183
 184 /***********************************************************************
 185  *           CharNextExA   (USER32.@)
 186  */
 187 LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
 188 {
 189     if (!*ptr) return (LPSTR)ptr;
 190     if (IsDBCSLeadByteEx( codepage, ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
 191     return (LPSTR)(ptr + 1);
 192 }
 193
 194
 195 /***********************************************************************
 196  *           CharNextExW   (USER32.@)
 197  */
 198 LPWSTR WINAPI CharNextExW( WORD codepage, LPCWSTR ptr, DWORD flags )
 199 {
 200     /* doesn't make sense, there are no codepages for Unicode */
 201     return NULL;
 202 }
 203
 204
 205 /***********************************************************************
 206  *           CharNextW   (USER32.@)
 207  */
 208 LPWSTR WINAPI CharNextW(LPCWSTR x)
 209 {
 210     if (*x) x++;
 211
 212     return (LPWSTR)x;
 213 }
 214
 215
 216 /***********************************************************************
 217  *           CharPrevA   (USER32.@)
 218  */
 219 LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
 220 {
 221     while (*start && (start < ptr))
 222     {
 223         LPCSTR next = CharNextA( start );
 224         if (next >= ptr) break;
 225         start = next;
 226     }
 227     return (LPSTR)start;
 228 }
 229
 230
 231 /***********************************************************************
 232  *           CharPrevExA   (USER32.@)
 233  */
 234 LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
 235 {
 236     while (*start && (start < ptr))
 237     {
 238         LPCSTR next = CharNextExA( codepage, start, flags );
 239         if (next > ptr) break;
 240         start = next;
 241     }
 242     return (LPSTR)start;
 243 }
 244
 245
 246 /***********************************************************************
 247  *           CharPrevExW   (USER32.@)
 248  */
 249 LPSTR WINAPI CharPrevExW( WORD codepage, LPCWSTR start, LPCWSTR ptr, DWORD flags )
 250 {
 251     /* doesn't make sense, there are no codepages for Unicode */
 252     return NULL;
 253 }
 254
 255
 256 /***********************************************************************
 257  *           CharPrevW   (USER32.@)
 258  */
 259 LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
 260 {
 261     if (x>start) return (LPWSTR)(x-1);
 262     else return (LPWSTR)x;
 263 }
 264
 265
 266 /***********************************************************************
 267  *           CharToOemA   (USER32.@)
 268  */
 269 BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
 270 {
 271     if ( !s || !d ) return TRUE;
 272     return CharToOemBuffA( s, d, strlen( s ) + 1 );
 273 }
 274
 275
 276 /***********************************************************************
 277  *           CharToOemBuffA   (USER32.@)
 278  */
 279 BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
 280 {
 281     WCHAR *bufW;
 282
 283     bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 284     if( bufW )
 285     {
 286         MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
 287         WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
 288         HeapFree( GetProcessHeap(), 0, bufW );
 289     }
 290     return TRUE;
 291 }
 292
 293
 294 /***********************************************************************
 295  *           CharToOemBuffW   (USER32.@)
 296  */
 297 BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
 298 {
 299    if ( !s || !d ) return TRUE;
 300     WideCharToMultiByte( CP_OEMCP, 0, s, len, d, len, NULL, NULL );
 301     return TRUE;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           CharToOemW   (USER32.@)
 307  */
 308 BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
 309 {
 310     return CharToOemBuffW( s, d, strlenW( s ) + 1 );
 311 }
 312
 313
 314 /***********************************************************************
 315  *           OemToCharA   (USER32.@)
 316  */
 317 BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
 318 {
 319     return OemToCharBuffA( s, d, strlen( s ) + 1 );
 320 }
 321
 322
 323 /***********************************************************************
 324  *           OemToCharBuffA   (USER32.@)
 325  */
 326 BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
 327 {
 328     WCHAR *bufW;
 329
 330     bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 331     if( bufW )
 332     {
 333         MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
 334         WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
 335         HeapFree( GetProcessHeap(), 0, bufW );
 336     }
 337     return TRUE;
 338 }
 339
 340
 341 /***********************************************************************
 342  *           OemToCharBuffW   (USER32.@)
 343  */
 344 BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
 345 {
 346     MultiByteToWideChar( CP_OEMCP, 0, s, len, d, len );
 347     return TRUE;
 348 }
 349
 350
 351 /***********************************************************************
 352  *           OemToCharW   (USER32.@)
 353  */
 354 BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
 355 {
 356     return OemToCharBuffW( s, d, strlen( s ) + 1 );
 357 }
 358
 359
 360 /***********************************************************************
 361  *           CharLowerA   (USER32.@)
 362  */
 363 LPSTR WINAPI CharLowerA(LPSTR str)
 364 {
 365     if (!HIWORD(str))
 366     {
 367         char ch = LOWORD(str);
 368         CharLowerBuffA( &ch, 1 );
 369         return (LPSTR)(UINT_PTR)(BYTE)ch;
 370     }
 371
 372     __TRY
 373     {
 374         CharLowerBuffA( str, strlen(str) );
 375     }
 376     __EXCEPT(page_fault)
 377     {
 378         SetLastError( ERROR_INVALID_PARAMETER );
 379         return NULL;
 380     }
 381     __ENDTRY
 382     return str;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           CharUpperA   (USER32.@)
 388  */
 389 LPSTR WINAPI CharUpperA(LPSTR str)
 390 {
 391     if (!HIWORD(str))
 392     {
 393         char ch = LOWORD(str);
 394         CharUpperBuffA( &ch, 1 );
 395         return (LPSTR)(UINT_PTR)(BYTE)ch;
 396     }
 397
 398     __TRY
 399     {
 400         CharUpperBuffA( str, strlen(str) );
 401     }
 402     __EXCEPT(page_fault)
 403     {
 404         SetLastError( ERROR_INVALID_PARAMETER );
 405         return NULL;
 406     }
 407     __ENDTRY
 408     return str;
 409 }
 410
 411
 412 /***********************************************************************
 413  *           CharLowerW   (USER32.@)
 414  */
 415 LPWSTR WINAPI CharLowerW(LPWSTR x)
 416 {
 417     if (HIWORD(x)) return strlwrW(x);
 418     else return (LPWSTR)((UINT)tolowerW(LOWORD(x)));
 419 }
 420
 421
 422 /***********************************************************************
 423  *           CharUpperW   (USER32.@)
 424  */
 425 LPWSTR WINAPI CharUpperW(LPWSTR x)
 426 {
 427     if (HIWORD(x)) return struprW(x);
 428     else return (LPWSTR)((UINT)toupperW(LOWORD(x)));
 429 }
 430
 431
 432 /***********************************************************************
 433  *           CharLowerBuffA   (USER32.@)
 434  */
 435 DWORD WINAPI CharLowerBuffA( LPSTR str, DWORD len )
 436 {
 437     DWORD lenW;
 438     WCHAR buffer[32];
 439     WCHAR *strW = buffer;
 440
 441     if (!str) return 0; /* YES */
 442
 443     lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
 444     if (lenW > sizeof(buffer)/sizeof(WCHAR))
 445     {
 446         strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
 447         if (!strW) return 0;
 448     }
 449     MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
 450     CharLowerBuffW(strW, lenW);
 451     len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
 452     if (strW != buffer) HeapFree(GetProcessHeap(), 0, strW);
 453     return len;
 454 }
 455
 456
 457 /***********************************************************************
 458  *           CharLowerBuffW   (USER32.@)
 459  */
 460 DWORD WINAPI CharLowerBuffW( LPWSTR str, DWORD len )
 461 {
 462     DWORD ret = len;
 463     if (!str) return 0; /* YES */
 464     for (; len; len--, str++) *str = tolowerW(*str);
 465     return ret;
 466 }
 467
 468
 469 /***********************************************************************
 470  *           CharUpperBuffA   (USER32.@)
 471  */
 472 DWORD WINAPI CharUpperBuffA( LPSTR str, DWORD len )
 473 {
 474     DWORD lenW;
 475     WCHAR buffer[32];
 476     WCHAR *strW = buffer;
 477
 478     if (!str) return 0; /* YES */
 479
 480     lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
 481     if (lenW > sizeof(buffer)/sizeof(WCHAR))
 482     {
 483         strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
 484         if (!strW) return 0;
 485     }
 486     MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
 487     CharUpperBuffW(strW, lenW);
 488     len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
 489     if (strW != buffer) HeapFree(GetProcessHeap(), 0, strW);
 490     return len;
 491 }
 492
 493
 494 /***********************************************************************
 495  *           CharUpperBuffW   (USER32.@)
 496  */
 497 DWORD WINAPI CharUpperBuffW( LPWSTR str, DWORD len )
 498 {
 499     DWORD ret = len;
 500     if (!str) return 0; /* YES */
 501     for (; len; len--, str++) *str = toupperW(*str);
 502     return ret;
 503 }
 504
 505
 506 /***********************************************************************
 507  *           IsCharLower    (USER.436)
 508  *           IsCharLowerA   (USER32.@)
 509  */
 510 BOOL WINAPI IsCharLowerA(CHAR x)
 511 {
 512     WCHAR wch;
 513     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 514     return IsCharLowerW(wch);
 515 }
 516
 517
 518 /***********************************************************************
 519  *           IsCharLowerW   (USER32.@)
 520  */
 521 BOOL WINAPI IsCharLowerW(WCHAR x)
 522 {
 523     return (get_char_typeW(x) & C1_LOWER) != 0;
 524 }
 525
 526
 527 /***********************************************************************
 528  *           IsCharUpper    (USER.435)
 529  *           IsCharUpperA   (USER32.@)
 530  */
 531 BOOL WINAPI IsCharUpperA(CHAR x)
 532 {
 533     WCHAR wch;
 534     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 535     return IsCharUpperW(wch);
 536 }
 537
 538
 539 /***********************************************************************
 540  *           IsCharUpperW   (USER32.@)
 541  */
 542 BOOL WINAPI IsCharUpperW(WCHAR x)
 543 {
 544     return (get_char_typeW(x) & C1_UPPER) != 0;
 545 }
 546
 547
 548 /***********************************************************************
 549  *           IsCharAlphaNumeric    (USER.434)
 550  *           IsCharAlphaNumericA   (USER32.@)
 551  */
 552 BOOL WINAPI IsCharAlphaNumericA(CHAR x)
 553 {
 554     WCHAR wch;
 555     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 556     return IsCharAlphaNumericW(wch);
 557 }
 558
 559
 560 /***********************************************************************
 561  *           IsCharAlphaNumericW   (USER32.@)
 562  */
 563 BOOL WINAPI IsCharAlphaNumericW(WCHAR x)
 564 {
 565     return (get_char_typeW(x) & (C1_ALPHA|C1_DIGIT)) != 0;
 566 }
 567
 568
 569 /***********************************************************************
 570  *           IsCharAlpha    (USER.433)
 571  *           IsCharAlphaA   (USER32.@)
 572  */
 573 BOOL WINAPI IsCharAlphaA(CHAR x)
 574 {
 575     WCHAR wch;
 576     MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
 577     return IsCharAlphaW(wch);
 578 }
 579
 580
 581 /***********************************************************************
 582  *           IsCharAlphaW   (USER32.@)
 583  */
 584 BOOL WINAPI IsCharAlphaW(WCHAR x)
 585 {
 586     return (get_char_typeW(x) & C1_ALPHA) != 0;
 587 }
 588
 589
 590 /***********************************************************************
 591  *           FormatMessage   (USER.606)
 592  */
 593 DWORD WINAPI FormatMessage16(
 594     DWORD   dwFlags,
 595     SEGPTR lpSource,     /* [in] NOTE: not always a valid pointer */
 596     WORD   dwMessageId,
 597     WORD   dwLanguageId,
 598     LPSTR  lpBuffer,     /* [out] NOTE: *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
 599     WORD   nSize,
 600     LPDWORD args         /* [in] NOTE: va_list *args */
 601 ) {
 602 #ifdef __i386__
 603 /* This implementation is completely dependent on the format of the va_list on x86 CPUs */
 604     LPSTR       target,t;
 605     DWORD       talloced;
 606     LPSTR       from,f;
 607     DWORD       width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 608     BOOL        eos = FALSE;
 609     LPSTR       allocstring = NULL;
 610
 611     TRACE("(0x%lx,%lx,%d,0x%x,%p,%d,%p)\n",
 612           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 613         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 614                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
 615         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
 616                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 617                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
 618
 619     if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 620         FIXME("line wrapping (%lu) not supported.\n", width);
 621     from = NULL;
 622     if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 623     {
 624         char *source = MapSL(lpSource);
 625         from = HeapAlloc( GetProcessHeap(), 0, strlen(source)+1 );
 626         strcpy( from, source );
 627     }
 628     if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
 629         from = HeapAlloc( GetProcessHeap(),0,200 );
 630         sprintf(from,"Systemmessage, messageid = 0x%08x\n",dwMessageId);
 631     }
 632     if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
 633         INT16   bufsize;
 634         HINSTANCE16 hinst16 = ((HINSTANCE16)lpSource & 0xffff);
 635
 636         dwMessageId &= 0xFFFF;
 637         bufsize=LoadString16(hinst16,dwMessageId,NULL,0);
 638         if (bufsize) {
 639             from = HeapAlloc( GetProcessHeap(), 0, bufsize +1);
 640             LoadString16(hinst16,dwMessageId,from,bufsize+1);
 641         }
 642     }
 643     target      = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 644     t   = target;
 645     talloced= 100;
 646
 647 #define ADD_TO_T(c) \
 648         *t++=c;\
 649         if (t-target == talloced) {\
 650                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 651                 t       = target+talloced;\
 652                 talloced*=2;\
 653         }
 654
 655     if (from) {
 656         f=from;
 657         while (*f && !eos) {
 658             if (*f=='%') {
 659                 int     insertnr;
 660                 char    *fmtstr,*x,*lastf;
 661                 DWORD   *argliststart;
 662
 663                 fmtstr = NULL;
 664                 lastf = f;
 665                 f++;
 666                 if (!*f) {
 667                     ADD_TO_T('%');
 668                     continue;
 669                 }
 670                 switch (*f) {
 671                 case '1':case '2':case '3':case '4':case '5':
 672                 case '6':case '7':case '8':case '9':
 673                     insertnr=*f-'0';
 674                     switch (f[1]) {
 675                     case '0':case '1':case '2':case '3':
 676                     case '4':case '5':case '6':case '7':
 677                     case '8':case '9':
 678                         f++;
 679                         insertnr=insertnr*10+*f-'0';
 680                         f++;
 681                         break;
 682                     default:
 683                         f++;
 684                         break;
 685                     }
 686                     if (*f=='!') {
 687                         f++;
 688                         if (NULL!=(x=strchr(f,'!'))) {
 689                             *x='\0';
 690                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 691                             sprintf(fmtstr,"%%%s",f);
 692                             f=x+1;
 693                         } else {
 694                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 695                             sprintf(fmtstr,"%%%s",f);
 696                             f+=strlen(f); /*at \0*/
 697                         }
 698                     }
 699                     else
 700                     {
 701                         if(!args) break;
 702                         fmtstr=HeapAlloc( GetProcessHeap(), 0, 3 );
 703                         strcpy( fmtstr, "%s" );
 704                     }
 705                     if (args) {
 706                         int     ret;
 707                         int     sz;
 708                         LPSTR   b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
 709
 710                         argliststart=args+insertnr-1;
 711
 712                         /* CMF - This makes a BIG assumption about va_list */
 713                         while ((ret = vsnprintf(b, sz, fmtstr, (va_list) argliststart) < 0) || (ret >= sz)) {
 714                             sz = (ret == -1 ? sz + 100 : ret + 1);
 715                             b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz);
 716                         }
 717                         for (x=b; *x; x++) ADD_TO_T(*x);
 718                         HeapFree(GetProcessHeap(), 0, b);
 719                     } else {
 720                         /* NULL args - copy formatstr
 721                          * (probably wrong)
 722                          */
 723                         while ((lastf<f)&&(*lastf)) {
 724                             ADD_TO_T(*lastf++);
 725                         }
 726                     }
 727                     HeapFree(GetProcessHeap(),0,fmtstr);
 728                     break;
 729                 case '0': /* Just stop processing format string */
 730                     eos = TRUE;
 731                     f++;
 732                     break;
 733                 case 'n': /* 16 bit version just outputs 'n' */
 734                 default:
 735                     ADD_TO_T(*f++);
 736                     break;
 737                 }
 738             } else { /* '\n' or '\r' gets mapped to "\r\n" */
 739                 if(*f == '\n' || *f == '\r') {
 740                     if (width == 0) {
 741                         ADD_TO_T('\r');
 742                         ADD_TO_T('\n');
 743                         if(*f++ == '\r' && *f == '\n')
 744                             f++;
 745                     }
 746                 } else {
 747                     ADD_TO_T(*f++);
 748                 }
 749             }
 750         }
 751         *t='\0';
 752     }
 753     talloced = strlen(target)+1;
 754     if (nSize && talloced<nSize) {
 755         target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 756     }
 757     TRACE("-- %s\n",debugstr_a(target));
 758     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 759         /* nSize is the MINIMUM size */
 760         HLOCAL16 h = LocalAlloc16(LPTR,talloced);
 761         SEGPTR ptr = LocalLock16(h);
 762         allocstring = MapSL( ptr );
 763         memcpy( allocstring,target,talloced);
 764         LocalUnlock16( h );
 765         *((HLOCAL16*)lpBuffer) = h;
 766     } else
 767         lstrcpynA(lpBuffer,target,nSize);
 768     HeapFree(GetProcessHeap(),0,target);
 769     HeapFree(GetProcessHeap(),0,from);
 770     return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 771         strlen(allocstring):
 772         strlen(lpBuffer);
 773 #else
 774         return 0;
 775 #endif /* __i386__ */
 776 }
 777 #undef ADD_TO_T