mlang/tests: Remove unused assignment (LLVM/Clang).
[wine] / dlls / kernel32 / format_msg.c
1 /*
2  * FormatMessage implementation
3  *
4  * Copyright 1996 Marcus Meissner
5  * Copyright 2009 Alexandre Julliard
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "ntstatus.h"
29 #define WIN32_NO_STATUS
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winerror.h"
33 #include "winternl.h"
34 #include "winuser.h"
35 #include "winnls.h"
36 #include "wine/unicode.h"
37 #include "kernel_private.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(resource);
41
42 struct format_args
43 {
44     ULONG_PTR    *args;
45     __ms_va_list *list;
46     int           last;
47 };
48
49 /* Messages used by FormatMessage
50  *
51  * They can be specified either directly or using a message ID and
52  * loading them from the resource.
53  *
54  * The resourcedata has following format:
55  * start:
56  * 0: DWORD nrofentries
57  * nrofentries * subentry:
58  *      0: DWORD firstentry
59  *      4: DWORD lastentry
60  *      8: DWORD offset from start to the stringentries
61  *
62  * (lastentry-firstentry) * stringentry:
63  * 0: WORD len (0 marks end)    [ includes the 4 byte header length ]
64  * 2: WORD flags
65  * 4: CHAR[len-4]
66  *      (stringentry i of a subentry refers to the ID 'firstentry+i')
67  *
68  * Yes, ANSI strings in win32 resources. Go figure.
69  */
70
71 static const WCHAR PCNTFMTWSTR[] = { '%','%','%','s',0 };
72 static const WCHAR FMTWSTR[] = { '%','s',0 };
73
74 /**********************************************************************
75  *      load_message    (internal)
76  */
77 static LPWSTR load_message( HMODULE module, UINT id, WORD lang )
78 {
79     const MESSAGE_RESOURCE_ENTRY *mre;
80     WCHAR *buffer;
81     NTSTATUS status;
82
83     TRACE("module = %p, id = %08x\n", module, id );
84
85     if (!module) module = GetModuleHandleW( NULL );
86     if ((status = RtlFindMessage( module, RT_MESSAGETABLE, lang, id, &mre )) != STATUS_SUCCESS)
87     {
88         SetLastError( RtlNtStatusToDosError(status) );
89         return NULL;
90     }
91
92     if (mre->Flags & MESSAGE_RESOURCE_UNICODE)
93     {
94         int len = (strlenW( (const WCHAR *)mre->Text ) + 1) * sizeof(WCHAR);
95         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len ))) return NULL;
96         memcpy( buffer, mre->Text, len );
97     }
98     else
99     {
100         int len = MultiByteToWideChar( CP_ACP, 0, (const char *)mre->Text, -1, NULL, 0 );
101         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
102         MultiByteToWideChar( CP_ACP, 0, (const char*)mre->Text, -1, buffer, len );
103     }
104     TRACE("returning %s\n", wine_dbgstr_w(buffer));
105     return buffer;
106 }
107
108 /**********************************************************************
109  *      get_arg    (internal)
110  */
111 static ULONG_PTR get_arg( int nr, DWORD flags, struct format_args *args )
112 {
113     if (nr == -1) nr = args->last + 1;
114     if (args->list)
115     {
116         if (!args->args) args->args = HeapAlloc( GetProcessHeap(), 0, 99 * sizeof(ULONG_PTR) );
117         while (nr > args->last)
118             args->args[args->last++] = va_arg( *args->list, ULONG_PTR );
119     }
120     if (nr > args->last) args->last = nr;
121     return args->args[nr - 1];
122 }
123
124 /**********************************************************************
125  *      format_insert    (internal)
126  */
127 static LPCWSTR format_insert( BOOL unicode_caller, int insert, LPCWSTR format,
128                               DWORD flags, struct format_args *args,
129                               LPWSTR *result )
130 {
131     static const WCHAR fmt_lu[] = {'%','l','u',0};
132     WCHAR *wstring = NULL, *p, fmt[256];
133     ULONG_PTR arg;
134     int size;
135
136     if (*format != '!')  /* simple string */
137     {
138         arg = get_arg( insert, flags, args );
139         if (unicode_caller)
140         {
141             WCHAR *str = (WCHAR *)arg;
142             *result = HeapAlloc( GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR) );
143             strcpyW( *result, str );
144         }
145         else
146         {
147             char *str = (char *)arg;
148             DWORD length = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
149             *result = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
150             MultiByteToWideChar( CP_ACP, 0, str, -1, *result, length );
151         }
152         return format;
153     }
154
155     format++;
156     p = fmt;
157     *p++ = '%';
158
159     while (*format == '0' ||
160            *format == '+' ||
161            *format == '-' ||
162            *format == ' ' ||
163            *format == '*' ||
164            *format == '#')
165     {
166         if (*format == '*')
167         {
168             p += sprintfW( p, fmt_lu, get_arg( insert, flags, args ));
169             insert = -1;
170             format++;
171         }
172         else *p++ = *format++;
173     }
174     while (isdigitW(*format)) *p++ = *format++;
175
176     if (*format == '.')
177     {
178         *p++ = *format++;
179         if (*format == '*')
180         {
181             p += sprintfW( p, fmt_lu, get_arg( insert, flags, args ));
182             insert = -1;
183             format++;
184         }
185         else
186             while (isdigitW(*format)) *p++ = *format++;
187     }
188
189     /* replicate MS bug: drop an argument when using va_list with width/precision */
190     if (insert == -1 && args->list) args->last--;
191     arg = get_arg( insert, flags, args );
192
193     /* check for ascii string format */
194     if ((format[0] == 'h' && format[1] == 's') ||
195         (format[0] == 'h' && format[1] == 'S') ||
196         (unicode_caller && format[0] == 'S') ||
197         (!unicode_caller && format[0] == 's'))
198     {
199         DWORD len = MultiByteToWideChar( CP_ACP, 0, (char *)arg, -1, NULL, 0 );
200         wstring = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
201         MultiByteToWideChar( CP_ACP, 0, (char *)arg, -1, wstring, len );
202         arg = (ULONG_PTR)wstring;
203         *p++ = 's';
204     }
205     /* check for ascii character format */
206     else if ((format[0] == 'h' && format[1] == 'c') ||
207              (format[0] == 'h' && format[1] == 'C') ||
208              (unicode_caller && format[0] == 'C') ||
209              (!unicode_caller && format[0] == 'c'))
210     {
211         char ch = arg;
212         wstring = HeapAlloc( GetProcessHeap(), 0, 2 * sizeof(WCHAR) );
213         MultiByteToWideChar( CP_ACP, 0, &ch, 1, wstring, 1 );
214         wstring[1] = 0;
215         arg = (ULONG_PTR)wstring;
216         *p++ = 's';
217     }
218     /* check for wide string format */
219     else if ((format[0] == 'l' && format[1] == 's') ||
220              (format[0] == 'l' && format[1] == 'S') ||
221              (format[0] == 'w' && format[1] == 's') ||
222              (!unicode_caller && format[0] == 'S'))
223     {
224         *p++ = 's';
225     }
226     /* check for wide character format */
227     else if ((format[0] == 'l' && format[1] == 'c') ||
228              (format[0] == 'l' && format[1] == 'C') ||
229              (format[0] == 'w' && format[1] == 'c') ||
230              (!unicode_caller && format[0] == 'C'))
231     {
232         *p++ = 'c';
233     }
234     /* FIXME: handle I64 etc. */
235     else while (*format && *format != '!') *p++ = *format++;
236
237     *p = 0;
238     size = 256;
239     for (;;)
240     {
241         WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
242         int needed = snprintfW( ret, size, fmt, arg );
243         if (needed == -1 || needed >= size)
244         {
245             HeapFree( GetProcessHeap(), 0, ret );
246             size = max( needed + 1, size * 2 );
247         }
248         else
249         {
250             *result = ret;
251             break;
252         }
253     }
254
255     while (*format && *format != '!') format++;
256     if (*format == '!') format++;
257
258     HeapFree( GetProcessHeap(), 0, wstring );
259     return format;
260 }
261
262 /**********************************************************************
263  *      format_message    (internal)
264  */
265 static LPWSTR format_message( BOOL unicode_caller, DWORD dwFlags, LPCWSTR fmtstr,
266                               struct format_args *format_args )
267 {
268     LPWSTR target,t;
269     DWORD talloced;
270     LPCWSTR f;
271     DWORD width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
272     BOOL eos = FALSE;
273     WCHAR ch;
274
275     target = t = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100 * sizeof(WCHAR) );
276     talloced = 100;
277
278 #define ADD_TO_T(c)  do {\
279     *t++=c;\
280     if ((DWORD)(t-target) == talloced) {\
281         target = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2*sizeof(WCHAR));\
282         t = target+talloced;\
283         talloced*=2;\
284     } \
285 } while (0)
286
287     f = fmtstr;
288     while (*f && !eos) {
289         if (*f=='%') {
290             int insertnr;
291             WCHAR *str,*x;
292
293             f++;
294             switch (*f) {
295             case '1':case '2':case '3':case '4':case '5':
296             case '6':case '7':case '8':case '9':
297                 if (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)
298                     goto ignore_inserts;
299                 else if (((dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) && !format_args->args) ||
300                         (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) && !format_args->list))
301                 {
302                     SetLastError(ERROR_INVALID_PARAMETER);
303                     HeapFree(GetProcessHeap(), 0, target);
304                     return NULL;
305                 }
306                 insertnr = *f-'0';
307                 switch (f[1]) {
308                 case '0':case '1':case '2':case '3':
309                 case '4':case '5':case '6':case '7':
310                 case '8':case '9':
311                     f++;
312                     insertnr = insertnr*10 + *f-'0';
313                     f++;
314                     break;
315                 default:
316                     f++;
317                     break;
318                 }
319                 f = format_insert( unicode_caller, insertnr, f, dwFlags, format_args, &str );
320                 for (x = str; *x; x++) ADD_TO_T(*x);
321                 HeapFree( GetProcessHeap(), 0, str );
322                 break;
323             case 'n':
324                 ADD_TO_T('\r');
325                 ADD_TO_T('\n');
326                 f++;
327                 break;
328             case 'r':
329                 ADD_TO_T('\r');
330                 f++;
331                 break;
332             case 't':
333                 ADD_TO_T('\t');
334                 f++;
335                 break;
336             case '0':
337                 eos = TRUE;
338                 f++;
339                 break;
340             case '\0':
341                 SetLastError(ERROR_INVALID_PARAMETER);
342                 HeapFree(GetProcessHeap(), 0, target);
343                 return NULL;
344             ignore_inserts:
345             default:
346                 if (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)
347                     ADD_TO_T('%');
348                 ADD_TO_T(*f++);
349                 break;
350             }
351         } else {
352             ch = *f;
353             f++;
354             if (ch == '\r') {
355                 if (*f == '\n')
356                     f++;
357                 if(width)
358                     ADD_TO_T(' ');
359                 else
360                 {
361                     ADD_TO_T('\r');
362                     ADD_TO_T('\n');
363                 }
364             } else {
365                 if (ch == '\n')
366                 {
367                     if(width)
368                         ADD_TO_T(' ');
369                     else
370                     {
371                         ADD_TO_T('\r');
372                         ADD_TO_T('\n');
373                     }
374                 }
375                 else
376                     ADD_TO_T(ch);
377             }
378         }
379     }
380     *t = '\0';
381
382     return target;
383 }
384 #undef ADD_TO_T
385
386 /***********************************************************************
387  *           FormatMessageA   (KERNEL32.@)
388  * FIXME: missing wrap,
389  */
390 DWORD WINAPI FormatMessageA(
391         DWORD   dwFlags,
392         LPCVOID lpSource,
393         DWORD   dwMessageId,
394         DWORD   dwLanguageId,
395         LPSTR   lpBuffer,
396         DWORD   nSize,
397         __ms_va_list* args )
398 {
399     struct format_args format_args;
400     DWORD ret = 0;
401     LPWSTR      target;
402     DWORD       destlength;
403     LPWSTR      from;
404     DWORD       width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
405
406     TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
407           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
408
409     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
410     {
411         if (!lpBuffer)
412         {
413             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
414             return 0;
415         }
416         else
417             *(LPSTR *)lpBuffer = NULL;
418     }
419
420     if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
421     {
422         format_args.args = (ULONG_PTR *)args;
423         format_args.list = NULL;
424         format_args.last = 0;
425     }
426     else
427     {
428         format_args.args = NULL;
429         format_args.list = args;
430         format_args.last = 0;
431     }
432
433     if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
434         FIXME("line wrapping (%u) not supported.\n", width);
435     from = NULL;
436     if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
437     {
438         DWORD length = MultiByteToWideChar(CP_ACP, 0, lpSource, -1, NULL, 0);
439         from = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
440         MultiByteToWideChar(CP_ACP, 0, lpSource, -1, from, length);
441     }
442     else if (dwFlags & (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM))
443     {
444         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)
445             from = load_message( (HMODULE)lpSource, dwMessageId, dwLanguageId );
446         if (!from && (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM))
447             from = load_message( kernel32_handle, dwMessageId, dwLanguageId );
448         if (!from) return 0;
449     }
450     else
451     {
452         SetLastError(ERROR_INVALID_PARAMETER);
453         return 0;
454     }
455
456     target = format_message( FALSE, dwFlags, from, &format_args );
457     if (!target)
458         goto failure;
459
460     TRACE("-- %s\n", debugstr_w(target));
461
462     /* Only try writing to an output buffer if there are processed characters
463      * in the temporary output buffer. */
464     if (*target)
465     {
466         destlength = WideCharToMultiByte(CP_ACP, 0, target, -1, NULL, 0, NULL, NULL);
467         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
468         {
469             LPSTR buf = LocalAlloc(LMEM_ZEROINIT, max(nSize, destlength));
470             WideCharToMultiByte(CP_ACP, 0, target, -1, buf, destlength, NULL, NULL);
471             *((LPSTR*)lpBuffer) = buf;
472         }
473         else
474         {
475             if (nSize < destlength)
476             {
477                 SetLastError(ERROR_INSUFFICIENT_BUFFER);
478                 goto failure;
479             }
480             WideCharToMultiByte(CP_ACP, 0, target, -1, lpBuffer, destlength, NULL, NULL);
481         }
482         ret = destlength - 1; /* null terminator */
483     }
484
485 failure:
486     HeapFree(GetProcessHeap(),0,target);
487     HeapFree(GetProcessHeap(),0,from);
488     if (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)) HeapFree( GetProcessHeap(), 0, format_args.args );
489     TRACE("-- returning %u\n", ret);
490     return ret;
491 }
492
493 /***********************************************************************
494  *           FormatMessageW   (KERNEL32.@)
495  */
496 DWORD WINAPI FormatMessageW(
497         DWORD   dwFlags,
498         LPCVOID lpSource,
499         DWORD   dwMessageId,
500         DWORD   dwLanguageId,
501         LPWSTR  lpBuffer,
502         DWORD   nSize,
503         __ms_va_list* args )
504 {
505     struct format_args format_args;
506     DWORD ret = 0;
507     LPWSTR target;
508     DWORD talloced;
509     LPWSTR from;
510     DWORD width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
511
512     TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
513           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
514
515     if (!lpBuffer)
516     {
517         SetLastError(ERROR_INVALID_PARAMETER);
518         return 0;
519     }
520
521     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
522         *(LPWSTR *)lpBuffer = NULL;
523
524     if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
525     {
526         format_args.args = (ULONG_PTR *)args;
527         format_args.list = NULL;
528         format_args.last = 0;
529     }
530     else
531     {
532         format_args.args = NULL;
533         format_args.list = args;
534         format_args.last = 0;
535     }
536
537     if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
538         FIXME("line wrapping not supported.\n");
539     from = NULL;
540     if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
541         from = HeapAlloc( GetProcessHeap(), 0, (strlenW(lpSource) + 1) *
542             sizeof(WCHAR) );
543         strcpyW( from, lpSource );
544     }
545     else if (dwFlags & (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM))
546     {
547         if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)
548             from = load_message( (HMODULE)lpSource, dwMessageId, dwLanguageId );
549         if (!from && (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM))
550             from = load_message( kernel32_handle, dwMessageId, dwLanguageId );
551         if (!from) return 0;
552     }
553     else
554     {
555         SetLastError(ERROR_INVALID_PARAMETER);
556         return 0;
557     }
558
559     target = format_message( TRUE, dwFlags, from, &format_args );
560     if (!target)
561         goto failure;
562
563     talloced = strlenW(target)+1;
564     TRACE("-- %s\n",debugstr_w(target));
565
566     /* Only allocate a buffer if there are processed characters in the
567      * temporary output buffer. If a caller supplies the buffer, then
568      * a null terminator will be written to it. */
569     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
570     {
571         if (*target)
572         {
573             /* nSize is the MINIMUM size */
574             *((LPVOID*)lpBuffer) = LocalAlloc(LMEM_ZEROINIT, max(nSize, talloced)*sizeof(WCHAR));
575             strcpyW(*(LPWSTR*)lpBuffer, target);
576         }
577     }
578     else
579     {
580         if (nSize < talloced)
581         {
582             SetLastError(ERROR_INSUFFICIENT_BUFFER);
583             goto failure;
584         }
585         strcpyW(lpBuffer, target);
586     }
587
588     ret = talloced - 1; /* null terminator */
589 failure:
590     HeapFree(GetProcessHeap(),0,target);
591     HeapFree(GetProcessHeap(),0,from);
592     if (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)) HeapFree( GetProcessHeap(), 0, format_args.args );
593     TRACE("-- returning %u\n", ret);
594     return ret;
595 }