?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed some issues found by winapi_check.
[wine/hacks.git] / dlls / kernel / format_msg.c
blob95389273bb288c7515d9ebb5e4cc0a2d3e8d1e18
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
useful hacks and other patches not (yet) suitable for mainline