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