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