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         lstrcpynA(buffer,(char*)mre->Text,i);
  92         buffer[i]=0;
  93     } else {
  94         if (buflen>1) {
  95             buffer[0]=0;
  96             return 0;
  97         }
  98     }
  99     if (buffer)
 100             TRACE("'%s' copied !\n", buffer);
 101     return i;
 102 }
 103
 104 #if 0  /* FIXME */
 105 /**********************************************************************
 106  *      load_messageW   (internal)
 107  */
 108 static INT load_messageW( HMODULE instance, UINT id, WORD lang,
 109                           LPWSTR buffer, INT buflen )
 110 {
 111     INT retval;
 112     LPSTR buffer2 = NULL;
 113     if (buffer && buflen)
 114         buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
 115     retval = load_messageA(instance,id,lang,buffer2,buflen);
 116     if (buffer)
 117     {
 118         if (retval) {
 119             lstrcpynAtoW( buffer, buffer2, buflen );
 120             retval = strlenW( buffer );
 121         }
 122         HeapFree( GetProcessHeap(), 0, buffer2 );
 123     }
 124     return retval;
 125 }
 126 #endif
 127
 128
 129 /***********************************************************************
 130  *           FormatMessageA   (KERNEL32.138)
 131  * FIXME: missing wrap,
 132  */
 133 DWORD WINAPI FormatMessageA(
 134         DWORD   dwFlags,
 135         LPCVOID lpSource,
 136         DWORD   dwMessageId,
 137         DWORD   dwLanguageId,
 138         LPSTR   lpBuffer,
 139         DWORD   nSize,
 140         LPDWORD args /* va_list *args */
 141 ) {
 142 #ifdef __i386__
 143 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 144         LPSTR   target,t;
 145         DWORD   talloced;
 146         LPSTR   from,f;
 147         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 148         BOOL    eos = FALSE;
 149         INT     bufsize;
 150         HMODULE hmodule = (HMODULE)lpSource;
 151         CHAR    ch;
 152
 153         TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 154                      dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 155         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 156                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
 157         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
 158                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 159                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
 160
 161         if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 162                 FIXME("line wrapping (%lu) not supported.\n", width);
 163         from = NULL;
 164         if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
 165                 from = HEAP_strdupA( GetProcessHeap(), 0, (LPSTR)lpSource);
 166         }
 167         else {
 168                 dwMessageId &= 0xFFFF;
 169                 if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 170                         hmodule = GetModuleHandleA("kernel32");
 171                 bufsize=load_messageA(hmodule,dwMessageId,dwLanguageId,NULL,100);
 172                 if (!bufsize) {
 173                         if (dwLanguageId) {
 174                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 175                                 return 0;
 176                         }
 177                         bufsize=load_messageA(hmodule,dwMessageId,
 178                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),NULL,100);
 179                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 180                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),NULL,100);
 181                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 182                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 183                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 184                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 185                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 186                                 MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),NULL,100);
 187                         if (!bufsize) {
 188                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 189                                 return 0;
 190                         }
 191                 }
 192                 from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 193                 load_messageA(hmodule,dwMessageId,dwLanguageId,from,bufsize+1);
 194         }
 195         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
 196         t       = target;
 197         talloced= 100;
 198
 199 #define ADD_TO_T(c) do { \
 200         *t++=c;\
 201         if (t-target == talloced) {\
 202                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 203                 t       = target+talloced;\
 204                 talloced*=2;\
 205         }\
 206 } while (0)
 207
 208         if (from) {
 209                 f=from;
 210                 while (*f && !eos) {
 211                         if (*f=='%') {
 212                                 int     insertnr;
 213                                 char    *fmtstr,*x,*lastf;
 214                                 DWORD   *argliststart;
 215
 216                                 fmtstr = NULL;
 217                                 lastf = f;
 218                                 f++;
 219                                 if (!*f) {
 220                                         ADD_TO_T('%');
 221                                         continue;
 222                                 }
 223                                 switch (*f) {
 224                                 case '1':case '2':case '3':case '4':case '5':
 225                                 case '6':case '7':case '8':case '9':
 226                                         insertnr=*f-'0';
 227                                         switch (f[1]) {
 228                                         case '0':case '1':case '2':case '3':
 229                                         case '4':case '5':case '6':case '7':
 230                                         case '8':case '9':
 231                                                 f++;
 232                                                 insertnr=insertnr*10+*f-'0';
 233                                                 f++;
 234                                                 break;
 235                                         default:
 236                                                 f++;
 237                                                 break;
 238                                         }
 239                                         if (*f=='!') {
 240                                                 f++;
 241                                                 if (NULL!=(x=strchr(f,'!'))) {
 242                                                         *x='\0';
 243                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 244                                                         sprintf(fmtstr,"%%%s",f);
 245                                                         f=x+1;
 246                                                 } else {
 247                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
 248                                                         sprintf(fmtstr,"%%%s",f);
 249                                                         f+=strlen(f); /*at \0*/
 250                                                 }
 251                                         } else
 252                                                 if(!args)
 253                                                   break;
 254                                         else
 255                                                 fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
 256                                         if (args) {
 257                                                 int     sz;
 258                                                 LPSTR   b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
 259
 260                                                 if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 261                                                         argliststart=args+insertnr-1;
 262                                                 else
 263                                                         argliststart=(*(DWORD**)args)+insertnr-1;
 264
 265                                                 /* CMF - This makes a BIG assumption about va_list */
 266                                                 while (vsnprintf(b, sz, fmtstr, (va_list) argliststart) < 0) {
 267                                                         b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz += 100);
 268                                                 }
 269                                                 for (x=b; *x; x++) ADD_TO_T(*x);
 270
 271                                                 HeapFree(GetProcessHeap(),0,b);
 272                                         } else {
 273                                                 /* NULL args - copy formatstr
 274                                                  * (probably wrong)
 275                                                  */
 276                                                 while ((lastf<f)&&(*lastf)) {
 277                                                         ADD_TO_T(*lastf++);
 278                                                 }
 279                                         }
 280                                         HeapFree(GetProcessHeap(),0,fmtstr);
 281                                         break;
 282                                 case 'n':
 283                                         ADD_TO_T('\r');
 284                                         ADD_TO_T('\n');
 285                                         f++;
 286                                         break;
 287                                 case '0':
 288                                         eos = TRUE;
 289                                         f++;
 290                                         break;
 291                                 default:
 292                                         ADD_TO_T(*f++);
 293                                         break;
 294                                 }
 295                         } else {
 296                             ch = *f;
 297                             f++;
 298                             if (ch == '\r')
 299                             {
 300                                 if (*f == '\n')
 301                                     f++;
 302                                 ADD_TO_T(' ');
 303                             }
 304                             else
 305                             if (ch == '\n')
 306                             {
 307                                 ADD_TO_T('\r');
 308                                 ADD_TO_T('\n');
 309                             }
 310                             else
 311                                 ADD_TO_T(ch);
 312                         }
 313                 }
 314                 *t='\0';
 315         }
 316         talloced = strlen(target)+1;
 317         if (nSize && talloced<nSize) {
 318                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 319         }
 320         TRACE("-- %s\n",debugstr_a(target));
 321         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 322                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,max(nSize, talloced));
 323                 memcpy(*(LPSTR*)lpBuffer,target,talloced);
 324         } else {
 325                 lstrcpynA(lpBuffer,target,nSize);
 326         }
 327         HeapFree(GetProcessHeap(),0,target);
 328         if (from) HeapFree(GetProcessHeap(),0,from);
 329         TRACE("-- returning %d\n", (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?  strlen(*(LPSTR*)lpBuffer):strlen(lpBuffer));
 330         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 331                         strlen(*(LPSTR*)lpBuffer):
 332                         strlen(lpBuffer);
 333 #else
 334         return 0;
 335 #endif /* __i386__ */
 336 }
 337 #undef ADD_TO_T
 338
 339
 340 /***********************************************************************
 341  *           FormatMessageW   (KERNEL32.138)
 342  */
 343 DWORD WINAPI FormatMessageW(
 344         DWORD   dwFlags,
 345         LPCVOID lpSource,
 346         DWORD   dwMessageId,
 347         DWORD   dwLanguageId,
 348         LPWSTR  lpBuffer,
 349         DWORD   nSize,
 350         LPDWORD args /* va_list *args */
 351 ) {
 352 #ifdef __i386__
 353 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
 354         LPSTR   target,t;
 355         DWORD   talloced;
 356         LPSTR   from,f;
 357         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 358         BOOL    eos = FALSE;
 359         INT     bufsize;
 360         HMODULE hmodule = (HMODULE)lpSource;
 361         CHAR    ch;
 362
 363         TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
 364                      dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 365         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 366                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
 367         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
 368                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 369                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
 370
 371         if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 372                 FIXME("line wrapping not supported.\n");
 373         from = NULL;
 374         if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
 375                 from = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lpSource);
 376         }
 377         else {
 378                 dwMessageId &= 0xFFFF;
 379                 if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
 380                         hmodule = GetModuleHandleA("kernel32");
 381                 bufsize=load_messageA(hmodule,dwMessageId,dwLanguageId,NULL,100);
 382                 if (!bufsize) {
 383                         if (dwLanguageId) {
 384                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 385                                 return 0;
 386                         }
 387                         bufsize=load_messageA(hmodule,dwMessageId,
 388                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_NEUTRAL),NULL,100);
 389                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 390                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),NULL,100);
 391                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 392                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 393                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 394                                 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT),NULL,100);
 395                         if (!bufsize) bufsize=load_messageA(hmodule,dwMessageId,
 396                                 MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),NULL,100);
 397                         if (!bufsize) {
 398                                 SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
 399                                 return 0;
 400                         }
 401                 }
 402                 from = HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
 403                 load_messageA(hmodule,dwMessageId,dwLanguageId,from,bufsize+1);
 404         }
 405         target  = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 );
 406         t       = target;
 407         talloced= 100;
 408
 409 #define ADD_TO_T(c)  do {\
 410         *t++=c;\
 411         if (t-target == talloced) {\
 412                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
 413                 t       = target+talloced;\
 414                 talloced*=2;\
 415         } \
 416 } while (0)
 417
 418         if (from) {
 419                 f=from;
 420                 while (*f && !eos) {
 421                         if (*f=='%') {
 422                                 int     insertnr;
 423                                 char    *fmtstr,*sprintfbuf,*x;
 424                                 DWORD   *argliststart;
 425
 426                                 fmtstr = NULL;
 427                                 f++;
 428                                 if (!*f) {
 429                                         ADD_TO_T('%');
 430                                         continue;
 431                                 }
 432                                 switch (*f) {
 433                                 case '1':case '2':case '3':case '4':case '5':
 434                                 case '6':case '7':case '8':case '9':
 435                                         insertnr=*f-'0';
 436                                         switch (f[1]) {
 437                                         case '0':case '1':case '2':case '3':
 438                                         case '4':case '5':case '6':case '7':
 439                                         case '8':case '9':
 440                                                 f++;
 441                                                 insertnr=insertnr*10+*f-'0';
 442                                                 f++;
 443                                                 break;
 444                                         default:
 445                                                 f++;
 446                                                 break;
 447                                         }
 448                                         if (*f=='!') {
 449                                                 f++;
 450                                                 if (NULL!=(x=strchr(f,'!')))
 451                                                 {
 452                                                     *x='\0';
 453                                                     fmtstr=HeapAlloc( GetProcessHeap(), 0, strlen(f)+2);
 454                                                         sprintf(fmtstr,"%%%s",f);
 455                                                         f=x+1;
 456                                                 } else {
 457                                                         fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f));
 458                                                         sprintf(fmtstr,"%%%s",f);
 459                                                         f+=strlen(f); /*at \0*/
 460                                                 }
 461                                         } else
 462                                                 if(!args)
 463                                                   break;
 464                                         else
 465                                                 fmtstr=HEAP_strdupA( GetProcessHeap(),0,"%s");
 466                                         if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 467                                                 argliststart=args+insertnr-1;
 468                                         else
 469                                                 argliststart=(*(DWORD**)args)+insertnr-1;
 470
 471                                         if (fmtstr[strlen(fmtstr)-1]=='s' && argliststart[0]) {
 472                                                 DWORD   xarr[3];
 473
 474                                                 xarr[0]=(DWORD)HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)(*(argliststart+0)));
 475                                                 /* possible invalid pointers */
 476                                                 xarr[1]=*(argliststart+1);
 477                                                 xarr[2]=*(argliststart+2);
 478                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,strlenW((LPWSTR)argliststart[0])*2+1);
 479
 480                                                 /* CMF - This makes a BIG assumption about va_list */
 481                                                 vsprintf(sprintfbuf, fmtstr, (va_list) xarr);
 482                                         } else {
 483                                                 sprintfbuf=HeapAlloc(GetProcessHeap(),0,100);
 484
 485                                                 /* CMF - This makes a BIG assumption about va_list */
 486                                                 vsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
 487                                         }
 488                                         x=sprintfbuf;
 489                                         while (*x) {
 490                                                 ADD_TO_T(*x++);
 491                                         }
 492                                         HeapFree(GetProcessHeap(),0,sprintfbuf);
 493                                         HeapFree(GetProcessHeap(),0,fmtstr);
 494                                         break;
 495                                 case 'n':
 496                                         ADD_TO_T('\r');
 497                                         ADD_TO_T('\n');
 498                                         f++;
 499                                         break;
 500                                 case '0':
 501                                         eos = TRUE;
 502                                         f++;
 503                                         break;
 504                                 default:
 505                                         ADD_TO_T(*f++);
 506                                         break;
 507                                 }
 508                         } else {
 509                             ch = *f;
 510                             f++;
 511                             if (ch == '\r')
 512                             {
 513                                 if (*f == '\n')
 514                                     f++;
 515                                 ADD_TO_T(' ');
 516                             }
 517                             else
 518                             if (ch == '\n')
 519                             {
 520                                 ADD_TO_T('\r');
 521                                 ADD_TO_T('\n');
 522                             }
 523                             else
 524                                 ADD_TO_T(ch);
 525                         }
 526                 }
 527                 *t='\0';
 528         }
 529         talloced = strlen(target)+1;
 530         if (nSize && talloced<nSize)
 531                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
 532         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
 533                 /* nSize is the MINIMUM size */
 534                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,talloced*2+2);
 535                 lstrcpynAtoW(*(LPWSTR*)lpBuffer,target,talloced);
 536         } else
 537                 lstrcpynAtoW(lpBuffer,target,nSize);
 538         HeapFree(GetProcessHeap(),0,target);
 539         if (from) HeapFree(GetProcessHeap(),0,from);
 540         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
 541                         strlenW(*(LPWSTR*)lpBuffer):
 542                         strlenW(lpBuffer);
 543 #else
 544         return 0;
 545 #endif /* __i386__ */
 546 }
 547 #undef ADD_TO_T