git.oblomov.eu Git - wine/blob - dlls/kernel/format_msg.c

   1 /*
   2  * FormatMessage implementation
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  */
   6
   7 #include "config.h"
   8
   9 #include <stdio.h>
  10 #include <string.h>
  11
  12 #include "windef.h"
  13 #include "winbase.h"
  14 #include "winerror.h"
  15 #include "winnls.h"
  16 #include "wine/unicode.h"
  17
  18 #include "heap.h"
  19 #include "debugtools.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(resource);
  22
  23
  24 /* Messages...used by FormatMessage32* (KERNEL32.something)
  25  *
  26  * They can be specified either directly or using a message ID and
  27  * loading them from the resource.
  28  *
  29  * The resourcedata has following format:
  30  * start:
  31  * 0: DWORD nrofentries
  32  * nrofentries * subentry:
  33  *      0: DWORD firstentry
  34  *      4: DWORD lastentry
  35  *      8: DWORD offset from start to the stringentries
  36  *
  37  * (lastentry-firstentry) * stringentry:
  38  * 0: WORD len (0 marks end)    [ includes the 4 byte header length ]
  39  * 2: WORD flags
  40  * 4: CHAR[len-4]
  41  *      (stringentry i of a subentry refers to the ID 'firstentry+i')
  42  *
  43  * Yes, ANSI strings in win32 resources. Go figure.
  44  */
  45
  46 /**********************************************************************
  47  *      load_messageA           (internal)
  48  */
  49 static INT load_messageA( HMODULE instance, UINT id, WORD lang,
  50                           LPSTR buffer, INT buflen )
  51 {
  52     HGLOBAL     hmem;
  53     HRSRC       hrsrc;
  54     PMESSAGE_RESOURCE_DATA      mrd;
  55     PMESSAGE_RESOURCE_BLOCK     mrb;
  56     PMESSAGE_RESOURCE_ENTRY     mre;
  57     int         i,slen;
  58
  59     TRACE("instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
  60
  61     /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
  62     hrsrc = FindResourceExW(instance,RT_MESSAGELISTW,(LPWSTR)1,lang);
  63     if (!hrsrc) return 0;
  64     hmem = LoadResource( instance, hrsrc );
  65     if (!hmem) return 0;
  66
  67     mrd = (PMESSAGE_RESOURCE_DATA)LockResource(hmem);
  68     mre = NULL;
  69     mrb = &(mrd->Blocks[0]);
  70     for (i=mrd->NumberOfBlocks;i--;) {
  71         if ((id>=mrb->LowId) && (id<=mrb->HighId)) {
  72             mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mrd)+mrb->OffsetToEntries);
  73             id  -= mrb->LowId;
  74             break;
  75         }
  76         mrb++;
  77     }
  78     if (!mre)
  79         return 0;
  80     for (i=id;i--;) {
  81         if (!mre->Length)
  82                 return 0;
  83         mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mre)+mre->Length);
  84     }
  85     slen=mre->Length;
  86     TRACE("     - strlen=%d\n",slen);
  87     i = min(buflen - 1, slen);
  88     if (buffer == NULL)
  89         return slen;
  90     if (i>0) {
  91         if (mre->Flags & MESSAGE_RESOURCE_UNICODE)
  92             WideCharToMultiByte( CP_ACP, 0, (LPWSTR)mre->Text, -1, buffer, i, NULL, NULL );
  93         else
  94             lstrcpynA(buffer, (LPSTR)mre->Text, i);
  95         buffer[i]=0;
  96     } else {
  97         if (buflen>1) {
  98             buffer[0]=0;
  99             return 0;
 100         }
 101     }
 102     if (buffer)
 103             TRACE("'%s' copied !\n", buffer);
 104     return i;
 105 }
 106
 107 #if 0  /* FIXME */
 108 /**********************************************************************
 109  *      load_messageW   (internal)
 110  */
 111 static INT load_messageW( HMODULE instance, UINT id, WORD lang,
 112                           LPWSTR buffer, INT buflen )
 113 {
 114     INT retval;
 115     LPSTR buffer2 = NULL;
 116     if (buffer && buflen)
 117         buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
 118     retval = load_messageA(instance,id,lang,buffer2,buflen);
 119     if (buffer)
 120     {
 121         if (retval) {
 122             lstrcpynAtoW( buffer, buffer2, buflen );
 123             retval = strlenW( buffer );
 124         }
 125         HeapFree( GetProcessHeap(), 0, buffer2 );
 126     }
 127     return retval;
 128 }
 129 #endif
 130
 131
 132 /***********************************************************************
 133  *           FormatMessageA   (KERNEL32.265)
 134  * FIXME: missing wrap,
 135  */
 136 DWORD WINAPI FormatMessageA(
 137         DWORD   dwFlags,
 138         LPCVOID lpSource,
 139         DWORD   dwMessageId,
 140         DWORD   dwLanguageId,
 141         LPSTR   lpBuffer,
 142         DWORD   nSize,
 143         va_list* _args
 144 ) {
 145   LPDWORD args=(LPDWORD)_args;
 146 #ifdef __i386__
 147 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 148         LPSTR   target,t;
 149         DWORD   talloced;
 150         LPSTR   from,f;
 151         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 152         BOOL    eos = FALSE;
 153         INT     bufsize;
 154         HMODULE hmodule = (HMODULE)lpSource;
 155         CHAR    ch;
 156
 157         TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 158                      dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 159         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 160                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
 161         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
 162                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 163                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
 164
 165         if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 166                 FIXME("line wrapping (%lu) not supported.\n", width);
 167         from = NULL;
 168         if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
 169                 from = HEAP_strdupA( GetProcessHeap(), 0, (LPSTR)lpSource);
 170         }
 171         else {
 172                 if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 173                         hmodule = GetModuleHandleA("kernel32");
 174                 bufsize=load_messageA(hmodule,dwMessageId,dwLanguageId,NULL,100);
 175                 if (!bufsize) {
 176                         if (dwLanguageId) {
 177                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 178                                 return 0;
 179                         }
 180                         bufsize=load_messageA(hmodule,dwMessageId,
 181                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),NULL,100);
 182                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 183                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),NULL,100);
 184                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 185                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 186                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 187                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 188                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 189                                 MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),NULL,100);
 190                         if (!bufsize) {
 191                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 192                                 return 0;
 193                         }
 194                 }
 195                 from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 196                 load_messageA(hmodule,dwMessageId,dwLanguageId,from,bufsize+1);
 197         }
 198         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 199         t       = target;
 200         talloced= 100;
 201
 202 #define ADD_TO_T(c) do { \
 203         *t++=c;\
 204         if (t-target == talloced) {\
 205                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 206                 t       = target+talloced;\
 207                 talloced*=2;\
 208         }\
 209 } while (0)
 210
 211         if (from) {
 212                 f=from;
 213                 while (*f && !eos) {
 214                         if (*f=='%') {
 215                                 int     insertnr;
 216                                 char    *fmtstr,*x,*lastf;
 217                                 DWORD   *argliststart;
 218
 219                                 fmtstr = NULL;
 220                                 lastf = f;
 221                                 f++;
 222                                 if (!*f) {
 223                                         ADD_TO_T('%');
 224                                         continue;
 225                                 }
 226                                 switch (*f) {
 227                                 case '1':case '2':case '3':case '4':case '5':
 228                                 case '6':case '7':case '8':case '9':
 229                                         insertnr=*f-'0';
 230                                         switch (f[1]) {
 231                                         case '0':case '1':case '2':case '3':
 232                                         case '4':case '5':case '6':case '7':
 233                                         case '8':case '9':
 234                                                 f++;
 235                                                 insertnr=insertnr*10+*f-'0';
 236                                                 f++;
 237                                                 break;
 238                                         default:
 239                                                 f++;
 240                                                 break;
 241                                         }
 242                                         if (*f=='!') {
 243                                                 f++;
 244                                                 if (NULL!=(x=strchr(f,'!'))) {
 245                                                         *x='\0';
 246                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 247                                                         sprintf(fmtstr,"%%%s",f);
 248                                                         f=x+1;
 249                                                 } else {
 250                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 251                                                         sprintf(fmtstr,"%%%s",f);
 252                                                         f+=strlen(f); /*at \0*/
 253                                                 }
 254                                         } else
 255                                                 if(!args)
 256                                                   break;
 257                                         else
 258                                                 fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
 259                                         if (args) {
 260                                                 int     sz;
 261                                                 LPSTR   b;
 262
 263                                                 if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 264                                                         argliststart=args+insertnr-1;
 265                                                 else
 266                                                         argliststart=(*(DWORD**)args)+insertnr-1;
 267
 268                                                 /* FIXME: precision and width components are not handled correctly */
 269                                                 if (strcmp(fmtstr, "%ls") == 0) {
 270                                                    sz = WideCharToMultiByte( CP_ACP, 0, *(WCHAR**)argliststart, -1, NULL, 0, NULL, NULL);
 271                                                    b = HeapAlloc(GetProcessHeap(), 0, sz);
 272                                                    WideCharToMultiByte( CP_ACP, 0, *(WCHAR**)argliststart, -1, b, sz, NULL, NULL);
 273                                                 } else {
 274                                                    b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
 275                                                    /* CMF - This makes a BIG assumption about va_list */
 276                                                    while (vsnprintf(b, sz, fmtstr, (va_list) argliststart) < 0) {
 277                                                       b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz += 100);
 278                                                    }
 279                                                 }
 280                                                 for (x=b; *x; x++) ADD_TO_T(*x);
 281
 282                                                 HeapFree(GetProcessHeap(),0,b);
 283                                         } else {
 284                                                 /* NULL args - copy formatstr
 285                                                  * (probably wrong)
 286                                                  */
 287                                                 while ((lastf<f)&&(*lastf)) {
 288                                                         ADD_TO_T(*lastf++);
 289                                                 }
 290                                         }
 291                                         HeapFree(GetProcessHeap(),0,fmtstr);
 292                                         break;
 293                                 case 'n':
 294                                         ADD_TO_T('\r');
 295                                         ADD_TO_T('\n');
 296                                         f++;
 297                                         break;
 298                                 case '0':
 299                                         eos = TRUE;
 300                                         f++;
 301                                         break;
 302                                 default:
 303                                         ADD_TO_T(*f++);
 304                                         break;
 305                                 }
 306                         } else {
 307                             ch = *f;
 308                             f++;
 309                             if (ch == '\r')
 310                             {
 311                                 if (*f == '\n')
 312                                     f++;
 313                                 ADD_TO_T(' ');
 314                             }
 315                             else
 316                             if (ch == '\n')
 317                             {
 318                                 ADD_TO_T('\r');
 319                                 ADD_TO_T('\n');
 320                             }
 321                             else
 322                                 ADD_TO_T(ch);
 323                         }
 324                 }
 325                 *t='\0';
 326         }
 327         talloced = strlen(target)+1;
 328         if (nSize && talloced<nSize) {
 329                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 330         }
 331         TRACE("-- %s\n",debugstr_a(target));
 332         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 333                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,max(nSize, talloced));
 334                 memcpy(*(LPSTR*)lpBuffer,target,talloced);
 335         } else {
 336                 lstrcpynA(lpBuffer,target,nSize);
 337         }
 338         HeapFree(GetProcessHeap(),0,target);
 339         if (from) HeapFree(GetProcessHeap(),0,from);
 340         TRACE("-- returning %d\n", (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?  strlen(*(LPSTR*)lpBuffer):strlen(lpBuffer));
 341         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 342                         strlen(*(LPSTR*)lpBuffer):
 343                         strlen(lpBuffer);
 344 #else
 345         return 0;
 346 #endif /* __i386__ */
 347 }
 348 #undef ADD_TO_T
 349
 350
 351 /***********************************************************************
 352  *           FormatMessageW   (KERNEL32.266)
 353  */
 354 DWORD WINAPI FormatMessageW(
 355         DWORD   dwFlags,
 356         LPCVOID lpSource,
 357         DWORD   dwMessageId,
 358         DWORD   dwLanguageId,
 359         LPWSTR  lpBuffer,
 360         DWORD   nSize,
 361         va_list* _args
 362 ) {
 363   LPDWORD args=(LPDWORD)_args;
 364 #ifdef __i386__
 365 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 366         LPSTR   target,t;
 367         DWORD   talloced;
 368         LPSTR   from,f;
 369         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 370         BOOL    eos = FALSE;
 371         INT     bufsize;
 372         HMODULE hmodule = (HMODULE)lpSource;
 373         CHAR    ch;
 374
 375         TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 376                      dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 377         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 378                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
 379         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
 380                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 381                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
 382
 383         if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 384                 FIXME("line wrapping not supported.\n");
 385         from = NULL;
 386         if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
 387                 from = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lpSource);
 388         }
 389         else {
 390                 if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 391                         hmodule = GetModuleHandleA("kernel32");
 392                 bufsize=load_messageA(hmodule,dwMessageId,dwLanguageId,NULL,100);
 393                 if (!bufsize) {
 394                         if (dwLanguageId) {
 395                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 396                                 return 0;
 397                         }
 398                         bufsize=load_messageA(hmodule,dwMessageId,
 399                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),NULL,100);
 400                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 401                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),NULL,100);
 402                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 403                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 404                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 405                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 406                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 407                                 MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),NULL,100);
 408                         if (!bufsize) {
 409                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 410                                 return 0;
 411                         }
 412                 }
 413                 from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 414                 load_messageA(hmodule,dwMessageId,dwLanguageId,from,bufsize+1);
 415         }
 416         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 );
 417         t       = target;
 418         talloced= 100;
 419
 420 #define ADD_TO_T(c)  do {\
 421         *t++=c;\
 422         if (t-target == talloced) {\
 423                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 424                 t       = target+talloced;\
 425                 talloced*=2;\
 426         } \
 427 } while (0)
 428
 429         if (from) {
 430                 f=from;
 431                 while (*f && !eos) {
 432                         if (*f=='%') {
 433                                 int     insertnr;
 434                                 char    *fmtstr,*sprintfbuf,*x;
 435                                 DWORD   *argliststart;
 436
 437                                 fmtstr = NULL;
 438                                 f++;
 439                                 if (!*f) {
 440                                         ADD_TO_T('%');
 441                                         continue;
 442                                 }
 443                                 switch (*f) {
 444                                 case '1':case '2':case '3':case '4':case '5':
 445                                 case '6':case '7':case '8':case '9':
 446                                         insertnr=*f-'0';
 447                                         switch (f[1]) {
 448                                         case '0':case '1':case '2':case '3':
 449                                         case '4':case '5':case '6':case '7':
 450                                         case '8':case '9':
 451                                                 f++;
 452                                                 insertnr=insertnr*10+*f-'0';
 453                                                 f++;
 454                                                 break;
 455                                         default:
 456                                                 f++;
 457                                                 break;
 458                                         }
 459                                         if (*f=='!') {
 460                                                 f++;
 461                                                 if (NULL!=(x=strchr(f,'!')))
 462                                                 {
 463                                                     *x='\0';
 464                                                     fmtstr=HeapAlloc( GetProcessHeap(), 0, strlen(f)+2);
 465                                                         sprintf(fmtstr,"%%%s",f);
 466                                                         f=x+1;
 467                                                 } else {
 468                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 469                                                         sprintf(fmtstr,"%%%s",f);
 470                                                         f+=strlen(f); /*at \0*/
 471                                                 }
 472                                         } else
 473                                                 if(!args)
 474                                                   break;
 475                                         else
 476                                                 fmtstr=HEAP_strdupA( GetProcessHeap(),0,"%s");
 477                                         if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 478                                                 argliststart=args+insertnr-1;
 479                                         else
 480                                                 argliststart=(*(DWORD**)args)+insertnr-1;
 481
 482                                         if (fmtstr[strlen(fmtstr)-1]=='s' && argliststart[0]) {
 483                                                 DWORD   xarr[3];
 484
 485                                                 xarr[0]=(DWORD)HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)(*(argliststart+0)));
 486                                                 /* possible invalid pointers */
 487                                                 xarr[1]=*(argliststart+1);
 488                                                 xarr[2]=*(argliststart+2);
 489                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,strlenW((LPWSTR)argliststart[0])*2+1);
 490
 491                                                 /* CMF - This makes a BIG assumption about va_list */
 492                                                 vsprintf(sprintfbuf, fmtstr, (va_list) xarr);
 493                                         } else {
 494                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 495
 496                                                 /* CMF - This makes a BIG assumption about va_list */
 497                                                 vsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
 498                                         }
 499                                         x=sprintfbuf;
 500                                         while (*x) {
 501                                                 ADD_TO_T(*x++);
 502                                         }
 503                                         HeapFree(GetProcessHeap(),0,sprintfbuf);
 504                                         HeapFree(GetProcessHeap(),0,fmtstr);
 505                                         break;
 506                                 case 'n':
 507                                         ADD_TO_T('\r');
 508                                         ADD_TO_T('\n');
 509                                         f++;
 510                                         break;
 511                                 case '0':
 512                                         eos = TRUE;
 513                                         f++;
 514                                         break;
 515                                 default:
 516                                         ADD_TO_T(*f++);
 517                                         break;
 518                                 }
 519                         } else {
 520                             ch = *f;
 521                             f++;
 522                             if (ch == '\r')
 523                             {
 524                                 if (*f == '\n')
 525                                     f++;
 526                                 ADD_TO_T(' ');
 527                             }
 528                             else
 529                             if (ch == '\n')
 530                             {
 531                                 ADD_TO_T('\r');
 532                                 ADD_TO_T('\n');
 533                             }
 534                             else
 535                                 ADD_TO_T(ch);
 536                         }
 537                 }
 538                 *t='\0';
 539         }
 540         talloced = strlen(target)+1;
 541         if (nSize && talloced<nSize)
 542                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 543         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 544                 /* nSize is the MINIMUM size */
 545             DWORD len = MultiByteToWideChar( CP_ACP, 0, target, -1, NULL, 0 );
 546             *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,len*sizeof(WCHAR));
 547             MultiByteToWideChar( CP_ACP, 0, target, -1, *(LPWSTR*)lpBuffer, len );
 548         }
 549         else
 550         {
 551             if (nSize > 0 && !MultiByteToWideChar( CP_ACP, 0, target, -1, lpBuffer, nSize ))
 552                 lpBuffer[nSize-1] = 0;
 553         }
 554         HeapFree(GetProcessHeap(),0,target);
 555         if (from) HeapFree(GetProcessHeap(),0,from);
 556         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 557                         strlenW(*(LPWSTR*)lpBuffer):
 558                         strlenW(lpBuffer);
 559 #else
 560         return 0;
 561 #endif /* __i386__ */
 562 }
 563 #undef ADD_TO_T