Changeset 424 for trunk/src


Ignore:
Timestamp:
Aug 5, 1999, 9:45:25 PM (26 years ago)
Author:
phaller
Message:

Fix: FormatMessageAW fixed. Do not mix ODIN's heap functions with VAC heap functions ...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/message.cpp

    r157 r424  
    1 /* $Id: message.cpp,v 1.5 1999-06-22 17:25:28 phaller Exp $ */
     1/* $Id: message.cpp,v 1.6 1999-08-05 19:45:25 phaller Exp $ */
    22
    33/*
    … …  
    2424#include <stdarg.h>
    2525#include "unicode.h"
     26#include "heap.h"
     27#include "heapstring.h"
     28
    2629
    2730//******************************************************************************
    … …  
    105108}
    106109
    107 #if 1
     110
    108111/***********************************************************************
    109112 *           FormatMessage32A   (KERNEL32.138)
    110113 * FIXME: missing wrap,FROM_SYSTEM message-loading,
    111114 */
    112 DWORD WIN32API FormatMessageA(
    113         DWORD   dwFlags,
    114         LPCVOID lpSource,
    115         DWORD   dwMessageId,
    116         DWORD   dwLanguageId,
    117         LPSTR   lpBuffer,
    118         DWORD   nSize,
    119         LPDWORD args /* va_list *args */
    120 ) {
    121         LPSTR   target,t;
    122         DWORD   talloced;
    123         LPSTR   from,f;
    124         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
    125         DWORD   nolinefeed = 0;
    126 
    127         dprintf(("KERNEL32: FormatMessageA (%08xh,%s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    128                  dwFlags,
    129                  lpSource,
    130                  dwMessageId,
    131                  dwLanguageId,
    132                  lpBuffer,
    133                  nSize,
    134                  args));
    135 
    136         from = NULL;
    137 
    138   if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
     115DWORD WIN32API FormatMessageA(DWORD   dwFlags,
     116                              LPCVOID lpSource,
     117                              DWORD   dwMessageId,
     118                              DWORD   dwLanguageId,
     119                              LPSTR   lpBuffer,
     120                              DWORD   nSize,
     121                              LPDWORD args /* va_list *args */)
     122{
     123/* This implementation is completely dependant on the format of the va_list on x86 CPUs */
     124   LPSTR target,
     125         t;
     126   DWORD talloced;
     127   LPSTR from,
     128         f;
     129   DWORD width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
     130   DWORD nolinefeed = 0;
     131
     132   dprintf(("KERNEL32: FormatMessageA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     133            dwFlags,
     134            lpSource,
     135            dwMessageId,
     136            dwLanguageId,
     137            lpBuffer,
     138            nSize,
     139            args));
     140
     141   if (width)
     142      dprintf(("KERNEL32: FormatMessageA - line wrapping not supported.\n"));
     143
     144   from = NULL;
     145   if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
     146      from = HEAP_strdupA( GetProcessHeap(), 0, (LPSTR)lpSource);
     147
     148   if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
     149   {
     150      from = (char*)HeapAlloc( GetProcessHeap(),0,200 );
     151      sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
     152   }
     153
     154   if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)
     155   {
     156     INT   bufsize;
     157
     158     dwMessageId &= 0xFFFF;
     159     bufsize=LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,NULL,100);
     160     if (bufsize)
     161     {
     162       from = (char*)HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
     163       LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,from,bufsize+1);
     164     }
     165   }
     166
     167   target   = (char*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
     168   t  = target;
     169   talloced= 100;
     170
     171#define ADD_TO_T(c) \
     172   *t++=c;\
     173   if (t-target == talloced) {\
     174      target   = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
     175      t  = target+talloced;\
     176      talloced*=2;\
     177   }
     178
     179   if (from)
     180   {
     181     f=from;
     182
     183     while (*f && !nolinefeed)
     184     {
     185       if (*f=='%')
     186       {
     187         int   insertnr;
     188         char  *fmtstr,
     189               *sprintfbuf,
     190               *x,
     191               *lastf;
     192         DWORD *argliststart;
     193
     194         fmtstr = NULL;
     195         lastf  = f;
     196         f++;
     197
     198         if (!*f)
     199         {
     200           ADD_TO_T('%');
     201           continue;
     202         }
     203
     204         switch (*f)
     205         {
     206           case '1': case '2': case '3': case '4': case '5':
     207           case '6': case '7': case '8': case '9':
     208             insertnr=*f-'0';
     209             switch (f[1])
     210             {
     211               case '0':case '1':case '2':case '3':
     212               case '4':case '5':case '6':case '7':
     213               case '8':case '9':
     214                 f++;
     215                 insertnr=insertnr*10+*f-'0';
     216                 f++;
     217                 break;
     218
     219               default:
     220                  f++;
     221                  break;
     222             }
     223
     224             if (*f=='!')
     225             {
     226               f++;
     227               if (NULL!=(x=strchr(f,'!')))
     228               {
     229                 *x='\0';
     230                 fmtstr = (char*)HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
     231                 sprintf(fmtstr,"%%%s",f);
     232                 f=x+1;
     233               }
     234               else
     235               {
     236                 fmtstr = (char*)HeapAlloc(GetProcessHeap(),0,strlen(f));
     237                 sprintf(fmtstr,"%%%s",f);
     238                 f+=strlen(f); /*at \0*/
     239               }
     240             }
     241             else
     242               if(!args)
     243                 break;
     244               else
     245                  fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
     246
     247             if (args)
     248             {
     249               if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
     250                 argliststart=args+insertnr-1;
     251               else
     252                 argliststart=(*(DWORD**)args)+insertnr-1;
     253
     254               if (fmtstr[strlen(fmtstr)-1]=='s')
     255                 sprintfbuf = (char*)HeapAlloc(GetProcessHeap(),0,strlen((LPSTR)argliststart[0])+1);
     256               else
     257                 sprintfbuf = (char*)HeapAlloc(GetProcessHeap(),0,100);
     258
     259               /* CMF - This makes a BIG assumption about va_list */
     260               O32_wvsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
     261               x=sprintfbuf;
     262               while (*x)
     263               {
     264                 ADD_TO_T(*x++);
     265               }
     266
     267               HeapFree(GetProcessHeap(),0,sprintfbuf);
     268             }
     269             else
     270             {
     271               /* NULL args - copy formatstr
     272                * (probably wrong)
     273                */
     274               while ((lastf<f)&&(*lastf))
     275               {
     276                 ADD_TO_T(*lastf++);
     277               }
     278             }
     279
     280             HeapFree(GetProcessHeap(),0,fmtstr);
     281             break;
     282
     283           case 'n':
     284             /* FIXME: perhaps add \r too? */
     285             ADD_TO_T('\n');
     286             f++;
     287             break;
     288
     289           case '0':
     290             nolinefeed=1;
     291             f++;
     292             break;
     293
     294           default:ADD_TO_T(*f++)
     295             break;
     296         }
     297       }
     298       else
     299       {
     300         ADD_TO_T(*f++)
     301       }
     302     }
     303     *t='\0';
     304  }
     305
     306  if (!nolinefeed)
    139307  {
    140     from = (char *)HeapAlloc(GetProcessHeap(),
    141                              0,
    142                              strlen((char*)lpSource) + 1);
    143     strcpy (from,
    144             (char*)lpSource);
     308    /* add linefeed */
     309    if(t==target || t[-1]!='\n')
     310      ADD_TO_T('\n'); /* FIXME: perhaps add \r too? */
    145311  }
    146   else
    147     if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
    148     {
    149       from = (char *)HeapAlloc(GetProcessHeap(), 0, 200 );
    150       sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
    151     }
    152     else
    153     if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)
    154     {
    155       int bufsize;
    156 
    157       dwMessageId &= 0xFFFF;
    158       bufsize=LoadMessageA(0,dwMessageId,dwLanguageId,NULL,100);
    159       if (bufsize)
    160       {
    161         from = (char *)HeapAlloc(GetProcessHeap(), 0, bufsize + 1 );
    162         LoadMessageA(0,dwMessageId,dwLanguageId,from,bufsize+1);
    163       }
    164     }
    165 
    166   target  = (char *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
    167   t       = target;
    168   talloced= 100;
    169 
    170 #define ADD_TO_T(c) \
    171         *t++=c;\
    172         if (t-target == talloced) {\
    173                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
    174                 t       = target+talloced;\
    175                 talloced*=2;\
    176         }
    177 
    178         if (from) {
    179                 f=from;
    180                 while (*f) {
    181                         if (*f=='%') {
    182                                 int     insertnr;
    183                                 char    *fmtstr,*sprintfbuf,*x,*lastf;
    184                                 DWORD   *argliststart;
    185 
    186                                 fmtstr = NULL;
    187                                 lastf = f;
    188                                 f++;
    189                                 if (!*f) {
    190                                         ADD_TO_T('%');
    191                                         continue;
    192                                 }
    193                                 switch (*f) {
    194                                 case '1':case '2':case '3':case '4':case '5':
    195                                 case '6':case '7':case '8':case '9':
    196                                         insertnr=*f-'0';
    197                                         switch (f[1]) {
    198                                         case '0':case '1':case '2':case '3':
    199                                         case '4':case '5':case '6':case '7':
    200                                         case '8':case '9':
    201                                                 f++;
    202                                                 insertnr=insertnr*10+*f-'0';
    203                                                 f++;
    204                                                 break;
    205                                         default:
    206                                                 f++;
    207                                                 break;
    208                                         }
    209                                         if (*f=='!') {
    210                                                 f++;
    211                                                 if (NULL!=(x=strchr(f,'!'))) {
    212                                                         *x='\0';
    213                                                         fmtstr=(char *)HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
    214                                                         sprintf(fmtstr,"%%%s",f);
    215                                                         f=x+1;
    216                                                 } else {
    217                                                         fmtstr=(char *)HeapAlloc(GetProcessHeap(),0,strlen(f));
    218                                                         sprintf(fmtstr,"%%%s",f);
    219                                                         f+=strlen(f); /*at \0*/
    220                                                 }
    221                                         } else
    222                                                 fmtstr=strdup("%s");
    223                                         if (args) {
    224                                                 if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
    225                                                         argliststart=args+insertnr-1;
    226                                                 else
    227                                                     argliststart=(*(DWORD**)args)+insertnr-1;
    228 
    229                                                 if (fmtstr[strlen(fmtstr)]=='s')
    230                                                         sprintfbuf=(char *)HeapAlloc(GetProcessHeap(),0,strlen((LPSTR)argliststart[0])+1);
    231                                                 else
    232                                                         sprintfbuf=(char *)HeapAlloc(GetProcessHeap(),0,100);
    233 
    234                                                 /* CMF - This makes a BIG assumption about va_list */
    235                                                 vsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
    236                                                 x=sprintfbuf;
    237                                                 while (*x) {
    238                                                         ADD_TO_T(*x++);
    239                                                 }
    240                                                 HeapFree(GetProcessHeap(),0,sprintfbuf);
    241                                         } else {
    242                                                 /* NULL args - copy formatstr
    243                                                  * (probably wrong)
    244                                                  */
    245                                                 while (lastf<f) {
    246                                                         ADD_TO_T(*lastf++);
    247                                                 }
    248                                         }
    249                                         HeapFree(GetProcessHeap(),0,fmtstr);
    250                                         break;
    251                                 case 'n':
    252                                         /* FIXME: perhaps add \r too? */
    253                                         ADD_TO_T('\n');
    254                                         f++;
    255                                         break;
    256                                 case '0':
    257                                         nolinefeed=1;
    258                                         f++;
    259                                         break;
    260                                 default:ADD_TO_T(*f++)
    261                                         break;
    262 
    263                                 }
    264                         } else {
    265                                 ADD_TO_T(*f++)
    266                         }
    267                 }
    268                 *t='\0';
    269         }
    270 
    271   if (!nolinefeed && t[-1]!='\n')
    272     ADD_TO_T('\n');
    273312
    274313  talloced = strlen(target)+1;
    … …  
    277316    target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
    278317  }
     318
     319  //TRACE("-- %s\n",debugstr_a(target));
    279320
    280321  if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
    … …  
    288329
    289330  HeapFree(GetProcessHeap(),0,target);
    290 
    291   if (from) HeapFree(GetProcessHeap(),0,from);
    292 
    293   dprintf(("KERNEL32: FormatMessageA returned %s\n",
    294            (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
    295             *(LPSTR*)lpBuffer:
    296             lpBuffer));
     331  if (from)
     332    HeapFree(GetProcessHeap(),0,from);
    297333
    298334  return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
    299             strlen(*(LPSTR*)lpBuffer):
    300             strlen(lpBuffer);
     335         strlen(*(LPSTR*)lpBuffer):
     336         strlen(lpBuffer);
    301337}
    302338#undef ADD_TO_T
     339
    303340
    304341/***********************************************************************
    305342 *           FormatMessage32W   (KERNEL32.138)
    306343 */
    307 DWORD WIN32API FormatMessageW(
    308         DWORD   dwFlags,
    309         LPCVOID lpSource,
    310         DWORD   dwMessageId,
    311         DWORD   dwLanguageId,
    312         LPWSTR  lpBuffer,
    313         DWORD   nSize,
    314         LPDWORD args /* va_list *args */
    315 ) {
    316         LPSTR   target,t;
    317         DWORD   talloced;
    318         LPSTR   from,f;
    319         DWORD   width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
    320         DWORD   nolinefeed = 0;
    321 
    322         dprintf(("KERNEL32: FormatMessageW\n"));
    323 
    324         from = NULL;
    325         if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
    326                 from = (char *)HeapAlloc(GetProcessHeap(),0, UniStrlen((UniChar*)lpSource)+1);
    327                 UnicodeToAscii((LPWSTR)lpSource, from);
    328         }
    329         else
    330         if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
    331                 /* gather information from system message tables ... */
    332                 from = (char *)HeapAlloc( GetProcessHeap(),0,200 );
    333                 sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
    334         }
    335         else
    336         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
    337                 int bufsize;
    338 
    339                 dwMessageId &= 0xFFFF;
    340                 bufsize=LoadMessageW(0,dwMessageId,dwLanguageId,NULL,100);
    341                 if (bufsize)
    342                 {
    343                     from = (char *)HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
    344                     LoadMessageW(0,dwMessageId,dwLanguageId,(LPWSTR)from,bufsize+1);
    345                 }
    346         }
    347 
    348         target  = (char *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 );
    349         t       = target;
    350         talloced= 100;
     344DWORD WINAPI FormatMessageW(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/* This implementation is completely dependant on the format of the va_list on x86 CPUs */
     353   LPSTR target,t;
     354   DWORD talloced;
     355   LPSTR from,f;
     356   DWORD width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
     357   DWORD nolinefeed = 0;
     358
     359   dprintf(("KERNEL32: FormatMessageW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     360            dwFlags,
     361            lpSource,
     362            dwMessageId,
     363            dwLanguageId,
     364            lpBuffer,
     365            nSize,
     366            args));
     367
     368   if (width)
     369     dprintf(("KERNEL32: FormatMessageW - line wrapping not supported.\n"));
     370
     371   from = NULL;
     372   if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
     373      from = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lpSource);
     374
     375   if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
     376   {
     377      /* gather information from system message tables ... */
     378      from = (char*)HeapAlloc( GetProcessHeap(),0,200 );
     379      sprintf(from,"Systemmessage, messageid = 0x%08lx\n",dwMessageId);
     380   }
     381
     382   if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)
     383   {
     384      INT   bufsize;
     385
     386      dwMessageId &= 0xFFFF;
     387      bufsize=LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,NULL,100);
     388      if (bufsize)
     389      {
     390        from = (char*)HeapAlloc( GetProcessHeap(), 0, bufsize + 1 );
     391        LoadMessageA((HMODULE)lpSource,dwMessageId,dwLanguageId,from,bufsize+1);
     392      }
     393   }
     394
     395   target   = (char*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 );
     396   t  = target;
     397   talloced= 100;
    351398
    352399#define ADD_TO_T(c) \
    353         *t++=c;\
    354         if (t-target == talloced) {\
    355                 target  = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
    356                 t       = target+talloced;\
    357                 talloced*=2;\
    358         }
    359 
    360         if (from) {
    361                 f=from;
    362                 while (*f) {
    363                         if (*f=='%') {
    364                                 int     insertnr;
    365                                 char    *fmtstr,*sprintfbuf,*x;
    366                                 DWORD  *argliststart;
    367 
    368                                 fmtstr = NULL;
    369                                 f++;
    370                                 if (!*f) {
    371                                         ADD_TO_T('%');
    372                                         continue;
    373                                 }
    374                                 switch (*f) {
    375                                 case '1':case '2':case '3':case '4':case '5':
    376                                 case '6':case '7':case '8':case '9':
    377                                         insertnr=*f-'0';
    378                                         switch (f[1]) {
    379                                         case '0':case '1':case '2':case '3':
    380                                         case '4':case '5':case '6':case '7':
    381                                         case '8':case '9':
    382                                                 f++;
    383                                                 insertnr=insertnr*10+*f-'0';
    384                                                 f++;
    385                                                 break;
    386                                         default:
    387                                                 f++;
    388                                                 break;
    389                                         }
    390                                         if (*f=='!') {
    391                                                 f++;
    392                                                 if (NULL!=(x=strchr(f,'!')))
     400   *t++=c;\
     401   if (t-target == talloced) {\
     402      target   = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
     403      t  = target+talloced;\
     404      talloced*=2;\
     405   }
     406
     407   if (from) {
     408      f=from;
     409      while (*f && !nolinefeed) {
     410         if (*f=='%') {
     411            int   insertnr;
     412            char  *fmtstr,*sprintfbuf,*x;
     413            DWORD *argliststart;
     414
     415            fmtstr = NULL;
     416            f++;
     417            if (!*f) {
     418               ADD_TO_T('%');
     419               continue;
     420            }
     421            switch (*f) {
     422            case '1':case '2':case '3':case '4':case '5':
     423            case '6':case '7':case '8':case '9':
     424               insertnr=*f-'0';
     425               switch (f[1]) {
     426               case '0':case '1':case '2':case '3':
     427               case '4':case '5':case '6':case '7':
     428               case '8':case '9':
     429                  f++;
     430                  insertnr=insertnr*10+*f-'0';
     431                  f++;
     432                  break;
     433               default:
     434                  f++;
     435                  break;
     436               }
     437               if (*f=='!') {
     438                  f++;
     439                  if (NULL!=(x=strchr(f,'!')))
    393440                                                {
    394441                                                    *x='\0';
    395                                                     fmtstr=(char *)HeapAlloc( GetProcessHeap(), 0, strlen(f)+2);
    396                                                         sprintf(fmtstr,"%%%s",f);
    397                                                         f=x+1;
    398                                                 } else {
    399                                                         fmtstr=(char *)HeapAlloc(GetProcessHeap(),0,strlen(f));
    400                                                         sprintf(fmtstr,"%%%s",f);
    401                                                         f+=strlen(f); /*at \0*/
    402                                                 }
    403                                         } else
    404                                                 fmtstr=strdup("%s");
    405                                         if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
    406                                                 argliststart=args+insertnr-1;
    407                                         else
    408                                                 argliststart=(*(DWORD**)args)+insertnr-1;
    409 
    410                                         if (fmtstr[strlen(fmtstr)]=='s') {
    411                                                 DWORD   xarr[3];
    412 
    413                                                 xarr[0]=(DWORD)strdup((char *)(*(argliststart+0)));
    414                                                 /* possible invalid pointers */
    415                                                 xarr[1]=*(argliststart+1);
    416                                                 xarr[2]=*(argliststart+2);
    417                                                 sprintfbuf = (char *)(char *)HeapAlloc(GetProcessHeap(),0,UniStrlen((UniChar*)argliststart[0])*2+1);
    418 
    419                                                 /* CMF - This makes a BIG assumption about va_list */
    420                                                 vsprintf(sprintfbuf, fmtstr, (va_list) xarr);
    421                                         } else {
    422                                                 sprintfbuf = (char *)HeapAlloc(GetProcessHeap(),0,100);
    423 
    424                                                 /* CMF - This makes a BIG assumption about va_list */
    425                                                 vsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
    426                                         }
    427                                         x=sprintfbuf;
    428                                         while (*x) {
    429                                                 ADD_TO_T(*x++);
    430                                         }
    431                                         HeapFree(GetProcessHeap(),0,sprintfbuf);
    432                                         HeapFree(GetProcessHeap(),0,fmtstr);
    433                                         break;
    434                                 case 'n':
    435                                         /* FIXME: perhaps add \r too? */
    436                                         ADD_TO_T('\n');
    437                                         f++;
    438                                         break;
    439                                 case '0':
    440                                         nolinefeed=1;
    441                                         f++;
    442                                         break;
    443                                 default:ADD_TO_T(*f++)
    444                                         break;
    445 
    446                                 }
    447                         } else {
    448                                 ADD_TO_T(*f++)
    449                         }
    450                 }
    451                 *t='\0';
    452         }
    453         if (!nolinefeed && t[-1]!='\n')
    454                 ADD_TO_T('\n');
    455         talloced = strlen(target)+1;
    456         if (nSize && talloced<nSize)
    457                 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
    458         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
    459                 /* nSize is the MINIMUM size */
    460                 *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,talloced*2+2);
    461                 AsciiToUnicode(target, *(LPWSTR*)lpBuffer);
    462         }
    463         else    AsciiToUnicode(target, lpBuffer);
    464 
    465         dprintf(("KERNEL32: FormatMessageW returned %s\n", target));
    466 
    467         HeapFree(GetProcessHeap(),0,target);
    468         if (from) HeapFree(GetProcessHeap(),0,from);
    469         return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
    470                         UniStrlen((UniChar*)*lpBuffer):
    471                         UniStrlen((UniChar*)lpBuffer);
     442                                                    fmtstr=(char*)HeapAlloc( GetProcessHeap(), 0, strlen(f)+2);
     443                                         sprintf(fmtstr,"%%%s",f);
     444                                         f=x+1;
     445                  } else {
     446                                         fmtstr=(char*)HeapAlloc(GetProcessHeap(),0,strlen(f));
     447                                         sprintf(fmtstr,"%%%s",f);
     448                                         f+=strlen(f); /*at \0*/
     449                  }
     450               } else
     451                       if(!args)
     452                    break;
     453               else
     454                  fmtstr=HEAP_strdupA( GetProcessHeap(),0,"%s");
     455               if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
     456                  argliststart=args+insertnr-1;
     457               else
     458                  argliststart=(*(DWORD**)args)+insertnr-1;
     459
     460               if (fmtstr[strlen(fmtstr)-1]=='s') {
     461                  DWORD                  xarr[3];
     462
     463                  xarr[0]=(DWORD)HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)(*(argliststart+0)));
     464                  /* possible invalid pointers */
     465                  xarr[1]=*(argliststart+1);
     466                  xarr[2]=*(argliststart+2);
     467                  sprintfbuf=(char*)HeapAlloc(GetProcessHeap(),0,lstrlenW((LPWSTR)argliststart[0])*2+1);
     468
     469                  /* CMF - This makes a BIG assumption about va_list */
     470                  vsprintf(sprintfbuf, fmtstr, (va_list) xarr);
     471               } else {
     472                  sprintfbuf=(char*)HeapAlloc(GetProcessHeap(),0,100);
     473
     474                  /* CMF - This makes a BIG assumption about va_list */
     475                  O32_wvsprintf(sprintfbuf, fmtstr, (va_list) argliststart);
     476               }
     477               x=sprintfbuf;
     478               while (*x) {
     479                  ADD_TO_T(*x++);
     480               }
     481               HeapFree(GetProcessHeap(),0,sprintfbuf);
     482               HeapFree(GetProcessHeap(),0,fmtstr);
     483               break;
     484            case 'n':
     485               /* FIXME: perhaps add \r too? */
     486               ADD_TO_T('\n');
     487               f++;
     488               break;
     489            case '0':
     490               nolinefeed=1;
     491               f++;
     492               break;
     493            default:ADD_TO_T(*f++)
     494               break;
     495
     496            }
     497         } else {
     498            ADD_TO_T(*f++)
     499         }
     500      }
     501      *t='\0';
     502   }
     503   if (!nolinefeed) {
     504       /* add linefeed */
     505       if(t==target || t[-1]!='\n')
     506      ADD_TO_T('\n'); /* FIXME: perhaps add \r too? */
     507   }
     508   talloced = strlen(target)+1;
     509   if (nSize && talloced<nSize)
     510      target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
     511   if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
     512      /* nSize is the MINIMUM size */
     513      *((LPVOID*)lpBuffer) = (LPVOID)LocalAlloc(GMEM_ZEROINIT,talloced*2+2);
     514      lstrcpynAtoW(*(LPWSTR*)lpBuffer,target,talloced);
     515   } else
     516      lstrcpynAtoW(lpBuffer,target,nSize);
     517   HeapFree(GetProcessHeap(),0,target);
     518   if (from) HeapFree(GetProcessHeap(),0,from);
     519   return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
     520         lstrlenW(*(LPWSTR*)lpBuffer):
     521         lstrlenW(lpBuffer);
    472522}
    473 #else
    474 //******************************************************************************
    475 //DWORD dwFlags;        /* source and processing options        */
    476 //LPCVOID lpSource;     /* address of message source    */
    477 //DWORD dwMessageId;    /* requested message identifier */
    478 //DWORD dwLanguageId;   /* language identifier for requested message    */
    479 //LPTSTR lpBuffer;      /* address of message buffer    */
    480 //DWORD nSize;          /* maximum size of message buffer       */
    481 //va_list * Arguments;  /* address of array of message inserts  */
    482 //******************************************************************************
    483 DWORD WIN32API FormatMessageA(DWORD  dwFlags, LPCVOID lpSource,
    484                                  DWORD  dwMessageId, DWORD dwLanguageId,
    485                                  LPTSTR lpBuffer, DWORD nSize, va_list *Arguments)
    486 {
    487  char *msgBuffer;
    488 
    489   dprintf(("KERNEL32: FormatMessageA Not Implemented\n"));
    490 
    491   if(dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
    492         msgBuffer          = (char *)LocalAlloc(LMEM_FIXED, nSize);
    493         *(DWORD *)lpBuffer = (DWORD)msgBuffer;
    494   }
    495   else  msgBuffer = lpBuffer;
    496 
    497   if(nSize >= 40) {
    498         //SvL: I always wanted to do this :)
    499         strncpy(msgBuffer, "Windows Error 666: Reserved for future mistakes\n", 40);
    500   }
    501   else  *msgBuffer = 0;
    502   return(strlen(msgBuffer));
    503 }
    504 //******************************************************************************
    505 //******************************************************************************
    506 DWORD WIN32API FormatMessageW(DWORD  dwFlags, LPCVOID lpSource,
    507                                  DWORD  dwMessageId, DWORD dwLanguageId,
    508                                  LPWSTR lpBuffer, DWORD nSize, va_list *Arguments)
    509 {
    510  WCHAR *msgBuffer;
    511 
    512   dprintf(("KERNEL32: FormatMessageW Not Implemented\n"));
    513 
    514   if(dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
    515         msgBuffer          = (WCHAR *)LocalAlloc(LMEM_FIXED, nSize*sizeof(USHORT));
    516         *(DWORD *)lpBuffer = (DWORD)msgBuffer;
    517   }
    518   else  msgBuffer = lpBuffer;
    519 
    520   if(nSize >= 40) {
    521         //SvL: I always wanted to do this :)
    522         AsciiToUnicode("Windows Error 666: Reserved for future mistakes\n", msgBuffer);
    523   }
    524   else  *msgBuffer = 0;
    525   return(UniStrlen((UniChar*)msgBuffer));
    526 }
    527 //******************************************************************************
    528 //******************************************************************************
    529 #endif
     523#undef ADD_TO_T
     524
Note: See TracChangeset for help on using the changeset viewer.