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