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