?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Bugfix: Macro expansion of strings would assert an internal error
[wine.git] / tools / wrc / genres.c
blob58f01ff9600a007b1022b59d44f92d02bceeb280
1 /*
2 * Generate .res format from a resource-tree
3 *
4 * Copyright 1998 Bertho A. Stultiens
5 *
6 * 05-May-2000 BS - Added code to support endian conversions. The
7 * extra functions also aid unaligned access, but
8 * this is not yet implemented.
9 * 25-May-1998 BS - Added simple unicode -> char conversion for resource
10 * names in .s and .h files.
11 */
12
13 #include "config.h"
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <assert.h>
19 #include <ctype.h>
20
21 #include "wrc.h"
22 #include "genres.h"
23 #include "utils.h"
24 #include "windef.h"
25 #include "wingdi.h"
26 #include "winuser.h"
27
28 #define SetResSize(res, tag) set_dword((res), (tag), (res)->size - get_dword((res), (tag)))
29
30 res_t *new_res(void)
31 {
32 res_t *r;
33 r = (res_t *)xmalloc(sizeof(res_t));
34 r->allocsize = RES_BLOCKSIZE;
35 r->size = 0;
36 r->data = (char *)xmalloc(RES_BLOCKSIZE);
37 return r;
38 }
39
40 res_t *grow_res(res_t *r, int add)
41 {
42 r->allocsize += add;
43 r->data = (char *)xrealloc(r->data, r->allocsize);
44 return r;
45 }
46
47 /*
48 *****************************************************************************
49 * Function : put_byte
50 * put_word
51 * put_dword
52 * Syntax : void put_byte(res_t *res, unsigned c)
53 * void put_word(res_t *res, unsigned w)
54 * void put_dword(res_t *res, unsigned d)
55 * Input :
56 * res - Binary resource to put the data in
57 * c, w, d - Data to put
58 * Output : nop
59 * Description : Put primitives that put an item in the binary resource.
60 * The data array grows automatically.
61 * Remarks :
62 *****************************************************************************
63 */
64 void put_byte(res_t *res, unsigned c)
65 {
66 if(res->allocsize - res->size < sizeof(char))
67 grow_res(res, RES_BLOCKSIZE);
68 *(char *)&(res->data[res->size]) = (char)c;
69 res->size += sizeof(char);
70 }
71
72 void put_word(res_t *res, unsigned w)
73 {
74 if(res->allocsize - res->size < sizeof(WORD))
75 grow_res(res, RES_BLOCKSIZE);
76 switch(byteorder)
77 {
78 #ifndef WORDS_BIGENDIAN
79 case WRC_BO_BIG:
80 #else
81 case WRC_BO_LITTLE:
82 #endif
83 *(WORD *)&(res->data[res->size]) = BYTESWAP_WORD((WORD)w);
84 break;
85 default:
86 *(WORD *)&(res->data[res->size]) = (WORD)w;
87 break;
88 }
89 res->size += sizeof(WORD);
90 }
91
92 void put_dword(res_t *res, unsigned d)
93 {
94 if(res->allocsize - res->size < sizeof(DWORD))
95 grow_res(res, RES_BLOCKSIZE);
96 switch(byteorder)
97 {
98 #ifndef WORDS_BIGENDIAN
99 case WRC_BO_BIG:
100 #else
101 case WRC_BO_LITTLE:
102 #endif
103 *(DWORD *)&(res->data[res->size]) = BYTESWAP_DWORD((DWORD)d);
104 break;
105 default:
106 *(DWORD *)&(res->data[res->size]) = (DWORD)d;
107 break;
108 }
109 res->size += sizeof(DWORD);
110 }
111
112 void put_pad(res_t *res)
113 {
114 while(res->size & 0x3)
115 put_byte(res, 0);
116 }
117
118 /*
119 *****************************************************************************
120 * Function : set_word
121 * set_dword
122 * Syntax : void set_word(res_t *res, int ofs, unsigned w)
123 * void set_dword(res_t *res, int ofs, unsigned d)
124 * Input :
125 * res - Binary resource to put the data in
126 * ofs - Byte offset in data-array
127 * w, d - Data to put
128 * Output : nop
129 * Description : Set the value of a binary resource data array to a
130 * specific value.
131 * Remarks :
132 *****************************************************************************
133 */
134 void set_word(res_t *res, int ofs, unsigned w)
135 {
136 switch(byteorder)
137 {
138 #ifndef WORDS_BIGENDIAN
139 case WRC_BO_BIG:
140 #else
141 case WRC_BO_LITTLE:
142 #endif
143 *(WORD *)&(res->data[ofs]) = BYTESWAP_WORD((WORD)w);
144 break;
145 default:
146 *(WORD *)&(res->data[ofs]) = (WORD)w;
147 break;
148 }
149 }
150
151 void set_dword(res_t *res, int ofs, unsigned d)
152 {
153 switch(byteorder)
154 {
155 #ifndef WORDS_BIGENDIAN
156 case WRC_BO_BIG:
157 #else
158 case WRC_BO_LITTLE:
159 #endif
160 *(DWORD *)&(res->data[ofs]) = BYTESWAP_DWORD((DWORD)d);
161 break;
162 default:
163 *(DWORD *)&(res->data[ofs]) = (DWORD)d;
164 break;
165 }
166 }
167
168 /*
169 *****************************************************************************
170 * Function : get_word
171 * get_dword
172 * Syntax : WORD get_word(res_t *res, int ofs)
173 * DWORD get_dword(res_t *res, int ofs)
174 * Input :
175 * res - Binary resource to put the data in
176 * ofs - Byte offset in data-array
177 * Output : The data in native endian
178 * Description : Get the value of a binary resource data array in native
179 * endian.
180 * Remarks :
181 *****************************************************************************
182 */
183 WORD get_word(res_t *res, int ofs)
184 {
185 switch(byteorder)
186 {
187 #ifndef WORDS_BIGENDIAN
188 case WRC_BO_BIG:
189 #else
190 case WRC_BO_LITTLE:
191 #endif
192 return BYTESWAP_WORD(*(WORD *)&(res->data[ofs]));
193 default:
194 return *(WORD *)&(res->data[ofs]);
195 }
196 }
197
198 DWORD get_dword(res_t *res, int ofs)
199 {
200 switch(byteorder)
201 {
202 #ifndef WORDS_BIGENDIAN
203 case WRC_BO_BIG:
204 #else
205 case WRC_BO_LITTLE:
206 #endif
207 return BYTESWAP_DWORD(*(DWORD *)&(res->data[ofs]));
208 default:
209 return *(DWORD *)&(res->data[ofs]);
210 }
211 }
212
213 /*
214 *****************************************************************************
215 * Function : string_to_upper
216 * Syntax : void string_to_upper(string_t *str)
217 * Input :
218 * Output :
219 * Description :
220 * Remarks : FIXME: codepages...
221 *****************************************************************************
222 */
223 void string_to_upper(string_t *str)
224 {
225 if(str->type == str_char)
226 {
227 char *cptr = str->str.cstr;
228 for(; *cptr; cptr++)
229 *cptr = (char)toupper(*cptr);
230 }
231 else if(str->type == str_unicode)
232 {
233 short *sptr = str->str.wstr;
234 for(; *sptr; sptr++)
235 if(isalpha(*sptr))
236 *sptr = (short)toupper(*sptr);
237 }
238 else
239 {
240 internal_error(__FILE__, __LINE__, "Invalid string type %d", str->type);
241 }
242 }
243
244 /*
245 *****************************************************************************
246 * Function : put_string
247 * Syntax : void put_string(res_t *res, string_t *str, enum str_e type,
248 * int isterm)
249 * Input :
250 * res - Binary resource to put the data in
251 * str - String to put
252 * type - Data has to be written in either str_char or str_unicode
253 * isterm - The string is '\0' terminated (disregard the string's
254 * size member)
255 * Output : nop
256 * Description :
257 * Remarks :
258 *****************************************************************************
259 */
260 void put_string(res_t *res, string_t *str, enum str_e type, int isterm)
261 {
262 int cnt;
263 int c = !0;
264 assert(res != NULL);
265 assert(str != NULL);
266 if(!isterm && str->size == 0)
267 {
268 warning("String length is zero, not written");
269 return;
270 }
271
272 if(str->type == str_unicode && type == str_unicode)
273 {
274 for(cnt = 0; cnt < str->size; cnt++)
275 {
276 c = str->str.wstr[cnt];
277 put_word(res, c);
278 if(isterm && !c)
279 break;
280 }
281 if(isterm && (str->size == 0 || (cnt == str->size && c)))
282 put_word(res, 0);
283 }
284 else if(str->type == str_char && type == str_char)
285 {
286 for(cnt = 0; cnt < str->size; cnt++)
287 {
288 c = str->str.cstr[cnt];
289 put_byte(res, c);
290 if(isterm && !c)
291 break;
292 }
293 if(isterm && (str->size == 0 || (cnt == str->size && c)))
294 put_byte(res, 0);
295 }
296 else if(str->type == str_unicode && type == str_char)
297 {
298 for(cnt = 0; cnt < str->size; cnt++)
299 {
300 c = str->str.wstr[cnt];
301 put_byte(res, c);
302 if(isterm && !c)
303 break;
304 }
305 if(isterm && (str->size == 0 || (cnt == str->size && c)))
306 put_byte(res, 0);
307 }
308 else /* str->type == str_char && type == str_unicode */
309 {
310 for(cnt = 0; cnt < str->size; cnt++)
311 {
312 c = str->str.cstr[cnt];
313 put_word(res, c & 0xff);
314 if(isterm && !c)
315 break;
316 }
317 if(isterm && (str->size == 0 || (cnt == str->size && c)))
318 put_word(res, 0);
319 }
320 }
321
322 /*
323 *****************************************************************************
324 * Function : put_name_id
325 * Syntax : void put_name_id(res_t *res, name_id_t *nid, int upcase)
326 * Input :
327 * Output :
328 * Description :
329 * Remarks :
330 *****************************************************************************
331 */
332 void put_name_id(res_t *res, name_id_t *nid, int upcase)
333 {
334 if(nid->type == name_ord)
335 {
336 if(win32)
337 put_word(res, 0xffff);
338 else
339 put_byte(res, 0xff);
340 put_word(res, (WORD)nid->name.i_name);
341 }
342 else if(nid->type == name_str)
343 {
344 if(upcase)
345 string_to_upper(nid->name.s_name);
346 put_string(res, nid->name.s_name, win32 ? str_unicode : str_char, TRUE);
347 }
348 else
349 {
350 internal_error(__FILE__, __LINE__, "Invalid name_id type %d", nid->type);
351 }
352 }
353
354 /*
355 *****************************************************************************
356 * Function : put_lvc
357 * Syntax : void put_lvc(res_t *res, lvc_t *lvc)
358 * Input :
359 * Output :
360 * Description :
361 * Remarks :
362 *****************************************************************************
363 */
364 void put_lvc(res_t *res, lvc_t *lvc)
365 {
366 if(lvc && lvc->language)
367 put_word(res, MAKELANGID(lvc->language->id, lvc->language->sub));
368 else
369 put_word(res, 0); /* Neutral */
370 if(lvc && lvc->version)
371 put_dword(res, *(lvc->version));
372 else
373 put_dword(res, 0);
374 if(lvc && lvc->characts)
375 put_dword(res, *(lvc->characts));
376 else
377 put_dword(res, 0);
378 }
379
380 /*
381 *****************************************************************************
382 * Function : put_raw_data
383 * Syntax : void put_raw_data(res_t *res, raw_data_t *raw, int offset)
384 * Input :
385 * Output :
386 * Description :
387 * Remarks :
388 *****************************************************************************
389 */
390 void put_raw_data(res_t *res, raw_data_t *raw, int offset)
391 {
392 int wsize = raw->size - offset;
393 if(res->allocsize - res->size < wsize)
394 grow_res(res, wsize);
395 memcpy(&(res->data[res->size]), raw->data + offset, wsize);
396 res->size += wsize;
397 }
398
399 /*
400 *****************************************************************************
401 * Function : put_res_header
402 * Syntax : intput_res_header(res_t *res, int type, name_id_t *ntype,
403 * name_id_t *name, DWORD memopt, lvc_t *lvc)
404 *
405 * Input :
406 * res - Binary resource descriptor to write to
407 * type - Resource identifier (if ntype == NULL)
408 * ntype - Name id of type
409 * name - Resource's name
410 * memopt - Resource's memory options to write
411 * lvc - Language, version and characteristics (win32 only)
412 * Output : An index to the resource size field. The resource size field
413 * contains the header size upon exit.
414 * Description :
415 * Remarks :
416 *****************************************************************************
417 */
418 int put_res_header(res_t *res, int type, name_id_t *ntype, name_id_t *name,
419 DWORD memopt, lvc_t *lvc)
420 {
421 if(win32)
422 {
423 put_dword(res, 0); /* We will overwrite these later */
424 put_dword(res, 0);
425 if(!ntype)
426 {
427 put_word(res, 0xffff); /* ResType */
428 put_word(res, type);
429 }
430 else
431 put_name_id(res, ntype, TRUE);
432 put_name_id(res, name, TRUE); /* ResName */
433 put_pad(res);
434 put_dword(res, 0); /* DataVersion */
435 put_word(res, memopt); /* Memory options */
436 put_lvc(res, lvc); /* Language, version and characts */
437 set_dword(res, 0*sizeof(DWORD), res->size); /* Set preliminary resource */
438 set_dword(res, 1*sizeof(DWORD), res->size); /* Set HeaderSize */
439 res->dataidx = res->size;
440 return 0;
441 }
442 else /* win16 */
443 {
444 int tag;
445 if(!ntype)
446 {
447 put_byte(res, 0xff); /* ResType */
448 put_word(res, type);
449 }
450 else
451 put_name_id(res, ntype, TRUE);
452 put_name_id(res, name, TRUE); /* ResName */
453 put_word(res, memopt); /* Memory options */
454 tag = res->size;
455 put_dword(res, 0); /* ResSize overwritten later*/
456 set_dword(res, tag, res->size);
457 res->dataidx = res->size;
458 return tag;
459 }
460 }
461
462 /*
463 *****************************************************************************
464 * Function : accelerator2res
465 * Syntax : res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
466 * Input :
467 * name - Name/ordinal of the resource
468 * acc - The accelerator descriptor
469 * Output : New .res format structure
470 * Description :
471 * Remarks :
472 *****************************************************************************
473 */
474 static res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
475 {
476 int restag;
477 res_t *res;
478 event_t *ev;
479 assert(name != NULL);
480 assert(acc != NULL);
481
482 ev = acc->events;
483 res = new_res();
484 if(win32)
485 {
486 restag = put_res_header(res, WRC_RT_ACCELERATOR, NULL, name, acc->memopt, &(acc->lvc));
487 while(ev)
488 {
489 put_word(res, ev->flags | (ev->next ? 0 : 0x80));
490 put_word(res, ev->key);
491 put_word(res, ev->id);
492 put_word(res, 0); /* Padding */
493 ev = ev->next;
494 }
495 put_pad(res);
496 }
497 else /* win16 */
498 {
499 restag = put_res_header(res, WRC_RT_ACCELERATOR, NULL, name, acc->memopt, NULL);
500 while(ev)
501 {
502 put_byte(res, ev->flags | (ev->next ? 0 : 0x80));
503 put_word(res, ev->key);
504 put_word(res, ev->id);
505 ev = ev->next;
506 }
507 }
508 /* Set ResourceSize */
509 SetResSize(res, restag);
510 return res;
511 }
512
513 /*
514 *****************************************************************************
515 * Function : dialog2res
516 * Syntax : res_t *dialog2res(name_id_t *name, dialog_t *dlg)
517 * Input :
518 * name - Name/ordinal of the resource
519 * dlg - The dialog descriptor
520 * Output : New .res format structure
521 * Description :
522 * Remarks :
523 *****************************************************************************
524 */
525 static res_t *dialog2res(name_id_t *name, dialog_t *dlg)
526 {
527 int restag;
528 res_t *res;
529 control_t *ctrl;
530 int tag_nctrl;
531 int nctrl = 0;
532 assert(name != NULL);
533 assert(dlg != NULL);
534
535 ctrl = dlg->controls;
536 res = new_res();
537 if(win32)
538 {
539 restag = put_res_header(res, WRC_RT_DIALOG, NULL, name, dlg->memopt, &(dlg->lvc));
540
541 put_dword(res, dlg->style->or_mask);
542 put_dword(res, dlg->gotexstyle ? dlg->exstyle->or_mask : 0);
543 tag_nctrl = res->size;
544 put_word(res, 0); /* Number of controls */
545 put_word(res, dlg->x);
546 put_word(res, dlg->y);
547 put_word(res, dlg->width);
548 put_word(res, dlg->height);
549 if(dlg->menu)
550 put_name_id(res, dlg->menu, TRUE);
551 else
552 put_word(res, 0);
553 if(dlg->dlgclass)
554 put_name_id(res, dlg->dlgclass, TRUE);
555 else
556 put_word(res, 0);
557 if(dlg->title)
558 put_string(res, dlg->title, str_unicode, TRUE);
559 else
560 put_word(res, 0);
561 if(dlg->font)
562 {
563 put_word(res, dlg->font->size);
564 put_string(res, dlg->font->name, str_unicode, TRUE);
565 }
566
567 put_pad(res);
568 while(ctrl)
569 {
570 /* FIXME: what is default control style? */
571 put_dword(res, ctrl->gotstyle ? ctrl->style->or_mask: WS_CHILD);
572 put_dword(res, ctrl->gotexstyle ? ctrl->exstyle->or_mask : 0);
573 put_word(res, ctrl->x);
574 put_word(res, ctrl->y);
575 put_word(res, ctrl->width);
576 put_word(res, ctrl->height);
577 put_word(res, ctrl->id);
578 if(ctrl->ctlclass)
579 put_name_id(res, ctrl->ctlclass, TRUE);
580 else
581 internal_error(__FILE__, __LINE__, "Control has no control-class");
582 if(ctrl->title)
583 put_name_id(res, ctrl->title, FALSE);
584 else
585 put_word(res, 0);
586 if(ctrl->extra)
587 {
588 put_word(res, ctrl->extra->size+2);
589 put_pad(res);
590 put_raw_data(res, ctrl->extra, 0);
591 }
592 else
593 put_word(res, 0);
594
595 if(ctrl->next)
596 put_pad(res);
597 nctrl++;
598 ctrl = ctrl->next;
599 }
600 /* Set number of controls */
601 set_word(res, tag_nctrl, (WORD)nctrl);
602 }
603 else /* win16 */
604 {
605 restag = put_res_header(res, WRC_RT_DIALOG, NULL, name, dlg->memopt, NULL);
606
607 put_dword(res, dlg->gotstyle ? dlg->style->or_mask : WS_POPUPWINDOW);
608 tag_nctrl = res->size;
609 put_byte(res, 0); /* Number of controls */
610 put_word(res, dlg->x);
611 put_word(res, dlg->y);
612 put_word(res, dlg->width);
613 put_word(res, dlg->height);
614 if(dlg->menu)
615 put_name_id(res, dlg->menu, TRUE);
616 else
617 put_byte(res, 0);
618 if(dlg->dlgclass)
619 put_name_id(res, dlg->dlgclass, TRUE);
620 else
621 put_byte(res, 0);
622 if(dlg->title)
623 put_string(res, dlg->title, str_char, TRUE);
624 else
625 put_byte(res, 0);
626 if(dlg->font)
627 {
628 put_word(res, dlg->font->size);
629 put_string(res, dlg->font->name, str_char, TRUE);
630 }
631
632 while(ctrl)
633 {
634 put_word(res, ctrl->x);
635 put_word(res, ctrl->y);
636 put_word(res, ctrl->width);
637 put_word(res, ctrl->height);
638 put_word(res, ctrl->id);
639 put_dword(res, ctrl->gotstyle ? ctrl->style->or_mask: WS_CHILD);
640 if(ctrl->ctlclass)
641 {
642 if(ctrl->ctlclass->type == name_ord
643 && ctrl->ctlclass->name.i_name >= 0x80
644 && ctrl->ctlclass->name.i_name <= 0x85)
645 put_byte(res, ctrl->ctlclass->name.i_name);
646 else if(ctrl->ctlclass->type == name_str)
647 put_name_id(res, ctrl->ctlclass, FALSE);
648 else
649 error("Unknown control-class %04x", ctrl->ctlclass->name.i_name);
650 }
651 else
652 internal_error(__FILE__, __LINE__, "Control has no control-class");
653 if(ctrl->title)
654 put_name_id(res, ctrl->title, FALSE);
655 else
656 put_byte(res, 0);
657
658 /* FIXME: What is this extra byte doing here? */
659 put_byte(res, 0);
660
661 nctrl++;
662 ctrl = ctrl->next;
663 }
664 /* Set number of controls */
665 ((char *)res->data)[tag_nctrl] = (char)nctrl;
666 }
667 /* Set ResourceSize */
668 SetResSize(res, restag);
669 return res;
670 }
671
672 /*
673 *****************************************************************************
674 * Function : dialogex2res
675 * Syntax : res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
676 * Input :
677 * name - Name/ordinal of the resource
678 * dlgex - The dialogex descriptor
679 * Output : New .res format structure
680 * Description :
681 * Remarks :
682 *****************************************************************************
683 */
684 static res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
685 {
686 int restag;
687 res_t *res;
688 control_t *ctrl;
689 int tag_nctrl;
690 int nctrl = 0;
691 assert(name != NULL);
692 assert(dlgex != NULL);
693
694 ctrl = dlgex->controls;
695 res = new_res();
696 if(win32)
697 {
698 restag = put_res_header(res, WRC_RT_DIALOG, NULL, name, dlgex->memopt, &(dlgex->lvc));
699
700 /* FIXME: MS doc says thet the first word must contain 0xffff
701 * and the second 0x0001 to signal a DLGTEMPLATEEX. Borland's
702 * compiler reverses the two words.
703 * I don't know which one to choose, but I write it as Mr. B
704 * writes it.
705 */
706 put_word(res, 1); /* Signature */
707 put_word(res, 0xffff); /* DlgVer */
708 put_dword(res, dlgex->gothelpid ? dlgex->helpid : 0);
709 put_dword(res, dlgex->gotexstyle ? dlgex->exstyle->or_mask : 0);
710 put_dword(res, dlgex->gotstyle ? dlgex->style->or_mask : WS_POPUPWINDOW);
711 tag_nctrl = res->size;
712 put_word(res, 0); /* Number of controls */
713 put_word(res, dlgex->x);
714 put_word(res, dlgex->y);
715 put_word(res, dlgex->width);
716 put_word(res, dlgex->height);
717 if(dlgex->menu)
718 put_name_id(res, dlgex->menu, TRUE);
719 else
720 put_word(res, 0);
721 if(dlgex->dlgclass)
722 put_name_id(res, dlgex->dlgclass, TRUE);
723 else
724 put_word(res, 0);
725 if(dlgex->title)
726 put_string(res, dlgex->title, str_unicode, TRUE);
727 else
728 put_word(res, 0);
729 if(dlgex->font)
730 {
731 put_word(res, dlgex->font->size);
732 put_word(res, dlgex->font->weight);
733 /* FIXME: ? TRUE should be sufficient to say that its
734 * italic, but Borland's compiler says its 0x0101.
735 * I just copy it here, and hope for the best.
736 */
737 put_word(res, dlgex->font->italic ? 0x0101 : 0);
738 put_string(res, dlgex->font->name, str_unicode, TRUE);
739 }
740
741 put_pad(res);
742 while(ctrl)
743 {
744 put_dword(res, ctrl->gothelpid ? ctrl->helpid : 0);
745 put_dword(res, ctrl->gotexstyle ? ctrl->exstyle->or_mask : 0);
746 /* FIXME: what is default control style? */
747 put_dword(res, ctrl->gotstyle ? ctrl->style->or_mask : WS_CHILD | WS_VISIBLE);
748 put_word(res, ctrl->x);
749 put_word(res, ctrl->y);
750 put_word(res, ctrl->width);
751 put_word(res, ctrl->height);
752 put_word(res, ctrl->id);
753 /* FIXME: Pad is _NOT_ documented!?! */
754 put_pad(res);
755 if(ctrl->ctlclass)
756 put_name_id(res, ctrl->ctlclass, TRUE);
757 else
758 internal_error(__FILE__, __LINE__, "Control has no control-class");
759 if(ctrl->title)
760 put_name_id(res, ctrl->title, FALSE);
761 else
762 put_word(res, 0);
763 if(ctrl->extra)
764 {
765 put_pad(res);
766 put_word(res, ctrl->extra->size);
767 put_raw_data(res, ctrl->extra, 0);
768 }
769 else
770 put_word(res, 0);
771
772 put_pad(res);
773 nctrl++;
774 ctrl = ctrl->next;
775 }
776 /* Set number of controls */
777 set_word(res, tag_nctrl, (WORD)nctrl);
778 /* Set ResourceSize */
779 SetResSize(res, restag);
780 put_pad(res);
781 }
782 else /* win16 */
783 {
784 /* Do not generate anything in 16-bit mode */
785 free(res->data);
786 free(res);
787 return NULL;
788 }
789 return res;
790 }
791
792 /*
793 *****************************************************************************
794 * Function : menuitem2res
795 * Syntax : void menuitem2res(res_t *res, menu_item_t *item)
796 * Input :
797 * Output :
798 * Description :
799 * Remarks : Self recursive
800 *****************************************************************************
801 */
802 static void menuitem2res(res_t *res, menu_item_t *menitem)
803 {
804 menu_item_t *itm = menitem;
805 if(win32)
806 {
807 while(itm)
808 {
809 put_word(res, itm->state | (itm->popup ? MF_POPUP : 0) | (!itm->next ? MF_END : 0));
810 if(!itm->popup)
811 put_word(res, itm->id);
812 if(itm->name)
813 put_string(res, itm->name, str_unicode, TRUE);
814 else
815 put_word(res, 0);
816 if(itm->popup)
817 menuitem2res(res, itm->popup);
818 itm = itm->next;
819 }
820 }
821 else /* win16 */
822 {
823 while(itm)
824 {
825 put_word(res, itm->state | (itm->popup ? MF_POPUP : 0) | (!itm->next ? MF_END : 0));
826 if(!itm->popup)
827 put_word(res, itm->id);
828 if(itm->name)
829 put_string(res, itm->name, str_char, TRUE);
830 else
831 put_byte(res, 0);
832 if(itm->popup)
833 menuitem2res(res, itm->popup);
834 itm = itm->next;
835 }
836 }
837
838 }
839
840 /*
841 *****************************************************************************
842 * Function : menu2res
843 * Syntax : res_t *menu2res(name_id_t *name, menu_t *men)
844 * Input :
845 * name - Name/ordinal of the resource
846 * men - The menu descriptor
847 * Output : New .res format structure
848 * Description :
849 * Remarks :
850 *****************************************************************************
851 */
852 static res_t *menu2res(name_id_t *name, menu_t *men)
853 {
854 int restag;
855 res_t *res;
856 assert(name != NULL);
857 assert(men != NULL);
858
859 res = new_res();
860 restag = put_res_header(res, WRC_RT_MENU, NULL, name, men->memopt, win32 ? &(men->lvc) : NULL);
861
862 put_dword(res, 0); /* Menuheader: Version and HeaderSize */
863 menuitem2res(res, men->items);
864 /* Set ResourceSize */
865 SetResSize(res, restag);
866 if(win32)
867 put_pad(res);
868 return res;
869 }
870
871 /*
872 *****************************************************************************
873 * Function : menuexitem2res
874 * Syntax : void menuexitem2res(res_t *res, menuex_item_t *item)
875 * Input :
876 * Output : nop
877 * Description :
878 * Remarks : Self recursive
879 *****************************************************************************
880 */
881 static void menuexitem2res(res_t *res, menuex_item_t *menitem)
882 {
883 menuex_item_t *itm = menitem;
884 assert(win32 != 0);
885 while(itm)
886 {
887 put_dword(res, itm->gottype ? itm->type : 0);
888 put_dword(res, itm->gotstate ? itm->state : 0);
889 put_dword(res, itm->gotid ? itm->id : 0); /* FIXME: Docu. says word */
890 put_word(res, (itm->popup ? 0x01 : 0) | (!itm->next ? MF_END : 0));
891 if(itm->name)
892 put_string(res, itm->name, str_unicode, TRUE);
893 else
894 put_word(res, 0);
895 put_pad(res);
896 if(itm->popup)
897 {
898 put_dword(res, itm->gothelpid ? itm->helpid : 0);
899 menuexitem2res(res, itm->popup);
900 }
901 itm = itm->next;
902 }
903
904 }
905
906 /*
907 *****************************************************************************
908 * Function : menuex2res
909 * Syntax : res_t *menuex2res(name_id_t *name, menuex_t *menex)
910 * Input :
911 * name - Name/ordinal of the resource
912 * menex - The menuex descriptor
913 * Output : New .res format structure
914 * Description :
915 * Remarks :
916 *****************************************************************************
917 */
918 static res_t *menuex2res(name_id_t *name, menuex_t *menex)
919 {
920 int restag;
921 res_t *res;
922 assert(name != NULL);
923 assert(menex != NULL);
924
925 res = new_res();
926 if(win32)
927 {
928 restag = put_res_header(res, WRC_RT_MENU, NULL, name, menex->memopt, &(menex->lvc));
929
930 put_word(res, 1); /* Menuheader: Version */
931 put_word(res, 4); /* Offset */
932 put_dword(res, 0); /* HelpId */
933 put_pad(res);
934 menuexitem2res(res, menex->items);
935 /* Set ResourceSize */
936 SetResSize(res, restag);
937 put_pad(res);
938 }
939 else /* win16 */
940 {
941 /* Do not generate anything in 16-bit mode */
942 free(res->data);
943 free(res);
944 return NULL;
945 }
946 return res;
947 }
948
949 /*
950 *****************************************************************************
951 * Function : cursorgroup2res
952 * Syntax : res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
953 * Input :
954 * name - Name/ordinal of the resource
955 * curg - The cursor descriptor
956 * Output : New .res format structure
957 * Description :
958 * Remarks :
959 *****************************************************************************
960 */
961 static res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
962 {
963 int restag;
964 res_t *res;
965 cursor_t *cur;
966 assert(name != NULL);
967 assert(curg != NULL);
968
969 res = new_res();
970 restag = put_res_header(res, WRC_RT_GROUP_CURSOR, NULL, name, curg->memopt, &(curg->lvc));
971 if(win32)
972 {
973 put_word(res, 0); /* Reserved */
974 /* FIXME: The ResType in the NEWHEADER structure should
975 * contain 14 according to the MS win32 doc. This is
976 * not the case with the BRC compiler and I really doubt
977 * the latter. Putting one here is compliant to win16 spec,
978 * but who knows the true value?
979 */
980 put_word(res, 2); /* ResType */
981 put_word(res, curg->ncursor);
982 #if 0
983 for(cur = curg->cursorlist; cur; cur = cur->next)
984 #else
985 cur = curg->cursorlist;
986 while(cur->next)
987 cur = cur->next;
988 for(; cur; cur = cur->prev)
989 #endif
990 {
991 put_word(res, cur->width);
992 /* FIXME: The height of a cursor is half the size of
993 * the bitmap's height. BRC puts the height from the
994 * BITMAPINFOHEADER here instead of the cursorfile's
995 * height. MS doesn't seem to care...
996 */
997 put_word(res, cur->height);
998 /* FIXME: The next two are reversed in BRC and I don't
999 * know why. Probably a bug. But, we can safely ignore
1000 * it because win16 does not support color cursors.
1001 * A warning should have been generated by the parser.
1002 */
1003 put_word(res, cur->planes);
1004 put_word(res, cur->bits);
1005 /* FIXME: The +4 is the hotspot in the cursor resource.
1006 * However, I cound not find this in the documentation.
1007 * The hotspot bytes must either be included or MS
1008 * doesn't care.
1009 */
1010 put_dword(res, cur->data->size +4);
1011 put_word(res, cur->id);
1012 }
1013 }
1014 else /* win16 */
1015 {
1016 put_word(res, 0); /* Reserved */
1017 put_word(res, 2); /* ResType */
1018 put_word(res, curg->ncursor);
1019 #if 0
1020 for(cur = curg->cursorlist; cur; cur = cur->next)
1021 #else
1022 cur = curg->cursorlist;
1023 while(cur->next)
1024 cur = cur->next;
1025 for(; cur; cur = cur->prev)
1026 #endif
1027 {
1028 put_word(res, cur->width);
1029 /* FIXME: The height of a cursor is half the size of
1030 * the bitmap's height. BRC puts the height from the
1031 * BITMAPINFOHEADER here instead of the cursorfile's
1032 * height. MS doesn't seem to care...
1033 */
1034 put_word(res, cur->height);
1035 /* FIXME: The next two are reversed in BRC and I don't
1036 * know why. Probably a bug. But, we can safely ignore
1037 * it because win16 does not support color cursors.
1038 * A warning should have been generated by the parser.
1039 */
1040 put_word(res, cur->planes);
1041 put_word(res, cur->bits);
1042 /* FIXME: The +4 is the hotspot in the cursor resource.
1043 * However, I cound not find this in the documentation.
1044 * The hotspot bytes must either be included or MS
1045 * doesn't care.
1046 */
1047 put_dword(res, cur->data->size +4);
1048 put_word(res, cur->id);
1049 }
1050 }
1051 SetResSize(res, restag); /* Set ResourceSize */
1052 if(win32)
1053 put_pad(res);
1054
1055 return res;
1056 }
1057
1058 /*
1059 *****************************************************************************
1060 * Function : cursor2res
1061 * Syntax : res_t *cursor2res(cursor_t *cur)
1062 * Input :
1063 * cur - The cursor descriptor
1064 * Output : New .res format structure
1065 * Description :
1066 * Remarks :
1067 *****************************************************************************
1068 */
1069 static res_t *cursor2res(cursor_t *cur)
1070 {
1071 int restag;
1072 res_t *res;
1073 name_id_t name;
1074
1075 assert(cur != NULL);
1076
1077 res = new_res();
1078 name.type = name_ord;
1079 name.name.i_name = cur->id;
1080 restag = put_res_header(res, WRC_RT_CURSOR, NULL, &name, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, &(cur->lvc));
1081 put_word(res, cur->xhot);
1082 put_word(res, cur->yhot);
1083 put_raw_data(res, cur->data, 0);
1084
1085 SetResSize(res, restag); /* Set ResourceSize */
1086 if(win32)
1087 put_pad(res);
1088
1089 return res;
1090 }
1091
1092 /*
1093 *****************************************************************************
1094 * Function : icongroup2res
1095 * Syntax : res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
1096 * Input :
1097 * name - Name/ordinal of the resource
1098 * icog - The icon group descriptor
1099 * Output : New .res format structure
1100 * Description :
1101 * Remarks :
1102 *****************************************************************************
1103 */
1104 static res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
1105 {
1106 int restag;
1107 res_t *res;
1108 icon_t *ico;
1109 assert(name != NULL);
1110 assert(icog != NULL);
1111
1112 res = new_res();
1113 restag = put_res_header(res, WRC_RT_GROUP_ICON, NULL, name, icog->memopt, &(icog->lvc));
1114 if(win32)
1115 {
1116 put_word(res, 0); /* Reserved */
1117 /* FIXME: The ResType in the NEWHEADER structure should
1118 * contain 14 according to the MS win32 doc. This is
1119 * not the case with the BRC compiler and I really doubt
1120 * the latter. Putting one here is compliant to win16 spec,
1121 * but who knows the true value?
1122 */
1123 put_word(res, 1); /* ResType */
1124 put_word(res, icog->nicon);
1125 for(ico = icog->iconlist; ico; ico = ico->next)
1126 {
1127 put_byte(res, ico->width);
1128 put_byte(res, ico->height);
1129 put_byte(res, ico->nclr);
1130 put_byte(res, 0); /* Reserved */
1131 put_word(res, ico->planes);
1132 put_word(res, ico->bits);
1133 put_dword(res, ico->data->size);
1134 put_word(res, ico->id);
1135 }
1136 }
1137 else /* win16 */
1138 {
1139 put_word(res, 0); /* Reserved */
1140 put_word(res, 1); /* ResType */
1141 put_word(res, icog->nicon);
1142 for(ico = icog->iconlist; ico; ico = ico->next)
1143 {
1144 put_byte(res, ico->width);
1145 put_byte(res, ico->height);
1146 put_byte(res, ico->nclr);
1147 put_byte(res, 0); /* Reserved */
1148 put_word(res, ico->planes);
1149 put_word(res, ico->bits);
1150 put_dword(res, ico->data->size);
1151 put_word(res, ico->id);
1152 }
1153 }
1154 SetResSize(res, restag); /* Set ResourceSize */
1155 if(win32)
1156 put_pad(res);
1157
1158 return res;
1159 }
1160
1161 /*
1162 *****************************************************************************
1163 * Function : icon2res
1164 * Syntax : res_t *icon2res(icon_t *ico)
1165 * Input :
1166 * ico - The icon descriptor
1167 * Output : New .res format structure
1168 * Description :
1169 * Remarks :
1170 *****************************************************************************
1171 */
1172 static res_t *icon2res(icon_t *ico)
1173 {
1174 int restag;
1175 res_t *res;
1176 name_id_t name;
1177
1178 assert(ico != NULL);
1179
1180 res = new_res();
1181 name.type = name_ord;
1182 name.name.i_name = ico->id;
1183 restag = put_res_header(res, WRC_RT_ICON, NULL, &name, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, &(ico->lvc));
1184 put_raw_data(res, ico->data, 0);
1185
1186 SetResSize(res, restag); /* Set ResourceSize */
1187 if(win32)
1188 put_pad(res);
1189
1190 return res;
1191 }
1192
1193 /*
1194 *****************************************************************************
1195 * Function : anicurico2res
1196 * Syntax : res_t *anicurico2res(name_id_t *name, ani_curico_t *ani)
1197 * Input :
1198 * name - Name/ordinal of the resource
1199 * ani - The animated object descriptor
1200 * Output : New .res format structure
1201 * Description :
1202 * Remarks : The endian of the object's structures have been converted
1203 * by the loader.
1204 * There are rumors that win311 could handle animated stuff.
1205 * That is why they are generated for both win16 and win32
1206 * compile.
1207 *****************************************************************************
1208 */
1209 static res_t *anicurico2res(name_id_t *name, ani_curico_t *ani, enum res_e type)
1210 {
1211 int restag;
1212 res_t *res;
1213 assert(name != NULL);
1214 assert(ani != NULL);
1215
1216 res = new_res();
1217 restag = put_res_header(res, type == res_anicur ? WRC_RT_ANICURSOR : WRC_RT_ANIICON,
1218 NULL, name, ani->memopt, NULL);
1219 put_raw_data(res, ani->data, 0);
1220 /* Set ResourceSize */
1221 SetResSize(res, restag);
1222 if(win32)
1223 put_pad(res);
1224 return res;
1225 }
1226
1227 /*
1228 *****************************************************************************
1229 * Function : bitmap2res
1230 * Syntax : res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
1231 * Input :
1232 * name - Name/ordinal of the resource
1233 * bmp - The bitmap descriptor
1234 * Output : New .res format structure
1235 * Description :
1236 * Remarks : The endian of the bitmap structures have been converted
1237 * by the loader.
1238 *****************************************************************************
1239 */
1240 static res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
1241 {
1242 int restag;
1243 res_t *res;
1244 assert(name != NULL);
1245 assert(bmp != NULL);
1246
1247 res = new_res();
1248 restag = put_res_header(res, WRC_RT_BITMAP, NULL, name, bmp->memopt, &(bmp->data->lvc));
1249 if(bmp->data->data[0] == 'B'
1250 && bmp->data->data[1] == 'M'
1251 && ((BITMAPFILEHEADER *)bmp->data->data)->bfSize == bmp->data->size
1252 && bmp->data->size >= sizeof(BITMAPFILEHEADER))
1253 {
1254 /* The File header is still attached, don't write it */
1255 put_raw_data(res, bmp->data, sizeof(BITMAPFILEHEADER));
1256 }
1257 else
1258 {
1259 put_raw_data(res, bmp->data, 0);
1260 }
1261 /* Set ResourceSize */
1262 SetResSize(res, restag);
1263 if(win32)
1264 put_pad(res);
1265 return res;
1266 }
1267
1268 /*
1269 *****************************************************************************
1270 * Function : font2res
1271 * Syntax : res_t *font2res(name_id_t *name, font_t *fnt)
1272 * Input :
1273 * name - Name/ordinal of the resource
1274 * fnt - The font descriptor
1275 * Output : New .res format structure
1276 * Description :
1277 * Remarks : The data has been prepared just after parsing.
1278 *****************************************************************************
1279 */
1280 static res_t *font2res(name_id_t *name, font_t *fnt)
1281 {
1282 int restag;
1283 res_t *res;
1284 assert(name != NULL);
1285 assert(fnt != NULL);
1286
1287 res = new_res();
1288 restag = put_res_header(res, WRC_RT_FONT, NULL, name, fnt->memopt, &(fnt->data->lvc));
1289 put_raw_data(res, fnt->data, 0);
1290 /* Set ResourceSize */
1291 SetResSize(res, restag);
1292 if(win32)
1293 put_pad(res);
1294 return res;
1295 }
1296
1297 /*
1298 *****************************************************************************
1299 * Function : fontdir2res
1300 * Syntax : res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
1301 * Input :
1302 * name - Name/ordinal of the resource
1303 * fntdir - The fontdir descriptor
1304 * Output : New .res format structure
1305 * Description :
1306 * Remarks : The data has been prepared just after parsing.
1307 *****************************************************************************
1308 */
1309 static res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
1310 {
1311 int restag;
1312 res_t *res;
1313 assert(name != NULL);
1314 assert(fnd != NULL);
1315
1316 res = new_res();
1317 restag = put_res_header(res, WRC_RT_FONTDIR, NULL, name, fnd->memopt, &(fnd->data->lvc));
1318 put_raw_data(res, fnd->data, 0);
1319 /* Set ResourceSize */
1320 SetResSize(res, restag);
1321 if(win32)
1322 put_pad(res);
1323 return res;
1324 }
1325
1326 /*
1327 *****************************************************************************
1328 * Function : rcdata2res
1329 * Syntax : res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
1330 * Input :
1331 * name - Name/ordinal of the resource
1332 * rdt - The rcdata descriptor
1333 * Output : New .res format structure
1334 * Description :
1335 * Remarks :
1336 *****************************************************************************
1337 */
1338 static res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
1339 {
1340 int restag;
1341 res_t *res;
1342 assert(name != NULL);
1343 assert(rdt != NULL);
1344
1345 res = new_res();
1346 restag = put_res_header(res, WRC_RT_RCDATA, NULL, name, rdt->memopt, &(rdt->data->lvc));
1347 put_raw_data(res, rdt->data, 0);
1348 /* Set ResourceSize */
1349 SetResSize(res, restag);
1350 if(win32)
1351 put_pad(res);
1352 return res;
1353 }
1354
1355 /*
1356 *****************************************************************************
1357 * Function : messagetable2res
1358 * Syntax : res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
1359 * Input :
1360 * name - Name/ordinal of the resource
1361 * msg - The messagetable descriptor
1362 * Output : New .res format structure
1363 * Description :
1364 * Remarks : The data has been converted to the appropriate endian
1365 * after is was parsed.
1366 *****************************************************************************
1367 */
1368 static res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
1369 {
1370 int restag;
1371 res_t *res;
1372 assert(name != NULL);
1373 assert(msg != NULL);
1374
1375 res = new_res();
1376 restag = put_res_header(res, WRC_RT_MESSAGETABLE, NULL, name, msg->memopt, &(msg->data->lvc));
1377 put_raw_data(res, msg->data, 0);
1378 /* Set ResourceSize */
1379 SetResSize(res, restag);
1380 if(win32)
1381 put_pad(res);
1382 return res;
1383 }
1384
1385 /*
1386 *****************************************************************************
1387 * Function : stringtable2res
1388 * Syntax : res_t *stringtable2res(stringtable_t *stt)
1389 * Input :
1390 * stt - The stringtable descriptor
1391 * Output : New .res format structure
1392 * Description :
1393 * Remarks :
1394 *****************************************************************************
1395 */
1396 static res_t *stringtable2res(stringtable_t *stt)
1397 {
1398 res_t *res;
1399 name_id_t name;
1400 int i;
1401 int restag;
1402 DWORD lastsize = 0;
1403
1404 assert(stt != NULL);
1405 res = new_res();
1406
1407 for(; stt; stt = stt->next)
1408 {
1409 if(!stt->nentries)
1410 {
1411 warning("Empty internal stringtable");
1412 continue;
1413 }
1414 name.type = name_ord;
1415 name.name.i_name = (stt->idbase >> 4) + 1;
1416 restag = put_res_header(res, WRC_RT_STRING, NULL, &name, stt->memopt, win32 ? &(stt->lvc) : NULL);
1417 for(i = 0; i < stt->nentries; i++)
1418 {
1419 if(stt->entries[i].str && stt->entries[i].str->size)
1420 {
1421 if(win32)
1422 put_word(res, stt->entries[i].str->size);
1423 else
1424 put_byte(res, stt->entries[i].str->size);
1425 put_string(res, stt->entries[i].str, win32 ? str_unicode : str_char, FALSE);
1426 }
1427 else
1428 {
1429 if(win32)
1430 put_word(res, 0);
1431 else
1432 put_byte(res, 0);
1433 }
1434 }
1435 /* Set ResourceSize */
1436 SetResSize(res, restag - lastsize);
1437 if(win32)
1438 put_pad(res);
1439 lastsize = res->size;
1440 }
1441 return res;
1442 }
1443
1444 /*
1445 *****************************************************************************
1446 * Function : user2res
1447 * Syntax : res_t *user2res(name_id_t *name, user_t *usr)
1448 * Input :
1449 * name - Name/ordinal of the resource
1450 * usr - The userresource descriptor
1451 * Output : New .res format structure
1452 * Description :
1453 * Remarks :
1454 *****************************************************************************
1455 */
1456 static res_t *user2res(name_id_t *name, user_t *usr)
1457 {
1458 int restag;
1459 res_t *res;
1460 assert(name != NULL);
1461 assert(usr != NULL);
1462
1463 res = new_res();
1464 restag = put_res_header(res, 0, usr->type, name, usr->memopt, &(usr->data->lvc));
1465 put_raw_data(res, usr->data, 0);
1466 /* Set ResourceSize */
1467 SetResSize(res, restag);
1468 if(win32)
1469 put_pad(res);
1470 return res;
1471 }
1472
1473 /*
1474 *****************************************************************************
1475 * Function : versionblock2res
1476 * Syntax : void versionblock2res(res_t *res, ver_block_t *blk)
1477 * Input :
1478 * res - Binary resource to write to
1479 * blk - The version block to be written
1480 * Output :
1481 * Description :
1482 * Remarks : Self recursive
1483 *****************************************************************************
1484 */
1485 static void versionblock2res(res_t *res, ver_block_t *blk, int level)
1486 {
1487 ver_value_t *val;
1488 int blksizetag;
1489 int valblksizetag;
1490 int valvalsizetag;
1491 int tag;
1492 int i;
1493
1494 blksizetag = res->size;
1495 put_word(res, 0); /* Will be overwritten later */
1496 put_word(res, 0);
1497 if(win32)
1498 put_word(res, 0); /* level ? */
1499 put_string(res, blk->name, win32 ? str_unicode : str_char, TRUE);
1500 put_pad(res);
1501 for(val = blk->values; val; val = val->next)
1502 {
1503 if(val->type == val_str)
1504 {
1505 valblksizetag = res->size;
1506 put_word(res, 0); /* Will be overwritten later */
1507 valvalsizetag = res->size;
1508 put_word(res, 0); /* Will be overwritten later */
1509 if(win32)
1510 {
1511 put_word(res, level);
1512 }
1513 put_string(res, val->key, win32 ? str_unicode : str_char, TRUE);
1514 put_pad(res);
1515 tag = res->size;
1516 put_string(res, val->value.str, win32 ? str_unicode : str_char, TRUE);
1517 if(win32)
1518 set_word(res, valvalsizetag, (WORD)((res->size - tag) >> 1));
1519 else
1520 set_word(res, valvalsizetag, (WORD)(res->size - tag));
1521 set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
1522 put_pad(res);
1523 }
1524 else if(val->type == val_words)
1525 {
1526 valblksizetag = res->size;
1527 put_word(res, 0); /* Will be overwritten later */
1528 valvalsizetag = res->size;
1529 put_word(res, 0); /* Will be overwritten later */
1530 if(win32)
1531 {
1532 put_word(res, level);
1533 }
1534 put_string(res, val->key, win32 ? str_unicode : str_char, TRUE);
1535 put_pad(res);
1536 tag = res->size;
1537 for(i = 0; i < val->value.words->nwords; i++)
1538 {
1539 put_word(res, val->value.words->words[i]);
1540 }
1541 set_word(res, valvalsizetag, (WORD)(res->size - tag));
1542 set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
1543 put_pad(res);
1544 }
1545 else if(val->type == val_block)
1546 {
1547 versionblock2res(res, val->value.block, level+1);
1548 }
1549 else
1550 {
1551 internal_error(__FILE__, __LINE__, "Invalid value indicator %d in VERSIONINFO", val->type);
1552 }
1553 }
1554
1555 /* Set blocksize */
1556 set_word(res, blksizetag, (WORD)(res->size - blksizetag));
1557 }
1558
1559 /*
1560 *****************************************************************************
1561 * Function : versioninfo2res
1562 * Syntax : res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
1563 * Input :
1564 * name - Name/ordinal of the resource
1565 * ver - The versioninfo descriptor
1566 * Output : New .res format structure
1567 * Description :
1568 * Remarks :
1569 *****************************************************************************
1570 */
1571 static res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
1572 {
1573 int restag;
1574 int rootblocksizetag;
1575 int valsizetag;
1576 int tag;
1577 res_t *res;
1578 string_t vsvi;
1579 ver_block_t *blk;
1580
1581 assert(name != NULL);
1582 assert(ver != NULL);
1583
1584 vsvi.type = str_char;
1585 vsvi.str.cstr = "VS_VERSION_INFO";
1586 vsvi.size = 15; /* Excl. termination */
1587
1588 res = new_res();
1589 restag = put_res_header(res, WRC_RT_VERSION, NULL, name, ver->memopt, &(ver->lvc));
1590 rootblocksizetag = res->size;
1591 put_word(res, 0); /* BlockSize filled in later */
1592 valsizetag = res->size;
1593 put_word(res, 0); /* ValueSize filled in later*/
1594 if(win32)
1595 put_word(res, 0); /* Tree-level ? */
1596 put_string(res, &vsvi, win32 ? str_unicode : str_char, TRUE);
1597 if(win32)
1598 put_pad(res);
1599 tag = res->size;
1600 put_dword(res, VS_FFI_SIGNATURE);
1601 put_dword(res, VS_FFI_STRUCVERSION);
1602 put_dword(res, (ver->filever_maj1 << 16) + (ver->filever_maj2 & 0xffff));
1603 put_dword(res, (ver->filever_min1 << 16) + (ver->filever_min2 & 0xffff));
1604 put_dword(res, (ver->prodver_maj1 << 16) + (ver->prodver_maj2 & 0xffff));
1605 put_dword(res, (ver->prodver_min1 << 16) + (ver->prodver_min2 & 0xffff));
1606 put_dword(res, ver->fileflagsmask);
1607 put_dword(res, ver->fileflags);
1608 put_dword(res, ver->fileos);
1609 put_dword(res, ver->filetype);
1610 put_dword(res, ver->filesubtype);
1611 put_dword(res, 0); /* FileDateMS */
1612 put_dword(res, 0); /* FileDateLS */
1613 /* Set ValueSize */
1614 set_word(res, valsizetag, (WORD)(res->size - tag));
1615 /* Descend into the blocks */
1616 for(blk = ver->blocks; blk; blk = blk->next)
1617 versionblock2res(res, blk, 0);
1618 /* Set root block's size */
1619 set_word(res, rootblocksizetag, (WORD)(res->size - rootblocksizetag));
1620
1621 SetResSize(res, restag);
1622 if(win32)
1623 put_pad(res);
1624
1625 return res;
1626 }
1627
1628 /*
1629 *****************************************************************************
1630 * Function : toolbaritem2res
1631 * Syntax : void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
1632 * Input :
1633 * Output : nop
1634 * Description :
1635 * Remarks : Self recursive
1636 *****************************************************************************
1637 */
1638 static void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
1639 {
1640 toolbar_item_t *itm = tbitem;
1641 assert(win32 != 0);
1642 while(itm)
1643 {
1644 put_word(res, itm->id);
1645 itm = itm->next;
1646 }
1647
1648 }
1649
1650 /*
1651 *****************************************************************************
1652 * Function : toolbar2res
1653 * Syntax : res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
1654 * Input :
1655 * name - Name/ordinal of the resource
1656 * toolbar - The toolbar descriptor
1657 * Output : New .res format structure
1658 * Description :
1659 * Remarks :
1660 *****************************************************************************
1661 */
1662 static res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
1663 {
1664 int restag;
1665 res_t *res;
1666 assert(name != NULL);
1667 assert(toolbar != NULL);
1668
1669 res = new_res();
1670 if(win32)
1671 {
1672 restag = put_res_header(res, WRC_RT_TOOLBAR, NULL, name, toolbar->memopt, &(toolbar->lvc));
1673
1674 put_word(res, 1); /* Menuheader: Version */
1675 put_word(res, toolbar->button_width); /* (in pixels?) */
1676 put_word(res, toolbar->button_height); /* (in pixels?) */
1677 put_word(res, toolbar->nitems);
1678 put_pad(res);
1679 toolbaritem2res(res, toolbar->items);
1680 /* Set ResourceSize */
1681 SetResSize(res, restag);
1682 put_pad(res);
1683 }
1684 else /* win16 */
1685 {
1686 /* Do not generate anything in 16-bit mode */
1687 free(res->data);
1688 free(res);
1689 return NULL;
1690 }
1691 return res;
1692 }
1693
1694 /*
1695 *****************************************************************************
1696 * Function : dlginit2res
1697 * Syntax : res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
1698 * Input :
1699 * name - Name/ordinal of the resource
1700 * rdt - The dlginit descriptor
1701 * Output : New .res format structure
1702 * Description :
1703 * Remarks :
1704 *****************************************************************************
1705 */
1706 static res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
1707 {
1708 int restag;
1709 res_t *res;
1710 assert(name != NULL);
1711 assert(dit != NULL);
1712
1713 res = new_res();
1714 restag = put_res_header(res, WRC_RT_DLGINIT, NULL, name, dit->memopt, &(dit->data->lvc));
1715 put_raw_data(res, dit->data, 0);
1716 /* Set ResourceSize */
1717 SetResSize(res, restag);
1718 if(win32)
1719 put_pad(res);
1720 return res;
1721 }
1722
1723 /*
1724 *****************************************************************************
1725 * Function : prep_nid_for_label
1726 * Syntax : char *prep_nid_for_label(name_id_t *nid)
1727 * Input :
1728 * Output :
1729 * Description : Converts a resource name into the first 32 (or less)
1730 * characters of the name with conversions.
1731 * Remarks :
1732 *****************************************************************************
1733 */
1734 #define MAXNAMELEN 32
1735 char *prep_nid_for_label(name_id_t *nid)
1736 {
1737 static char buf[MAXNAMELEN+1];
1738
1739 assert(nid != NULL);
1740
1741 if(nid->type == name_str && nid->name.s_name->type == str_unicode)
1742 {
1743 short *sptr;
1744 int i;
1745 sptr = nid->name.s_name->str.wstr;
1746 buf[0] = '\0';
1747 for(i = 0; *sptr && i < MAXNAMELEN; i++)
1748 {
1749 if((unsigned)*sptr < 0x80 && isprint(*sptr & 0xff))
1750 buf[i] = *sptr++;
1751 else
1752 warning("Resourcename (str_unicode) contain unprintable characters or invalid translation, ignored");
1753 }
1754 buf[i] = '\0';
1755 }
1756 else if(nid->type == name_str && nid->name.s_name->type == str_char)
1757 {
1758 char *cptr;
1759 int i;
1760 cptr = nid->name.s_name->str.cstr;
1761 buf[0] = '\0';
1762 for(i = 0; *cptr && i < MAXNAMELEN; i++)
1763 {
1764 if((unsigned)*cptr < 0x80 && isprint(*cptr & 0xff))
1765 buf[i] = *cptr++;
1766 else
1767 warning("Resourcename (str_char) contain unprintable characters, ignored");
1768 }
1769 buf[i] = '\0';
1770 }
1771 else if(nid->type == name_ord)
1772 {
1773 sprintf(buf, "%u", nid->name.i_name);
1774 }
1775 else
1776 {
1777 internal_error(__FILE__, __LINE__, "Resource name_id with invalid type %d", nid->type);
1778 }
1779 return buf;
1780 }
1781 #undef MAXNAMELEN
1782
1783 /*
1784 *****************************************************************************
1785 * Function : make_c_name
1786 * Syntax : char *make_c_name(char *base, name_id_t *nid, language_t *lan)
1787 * Input :
1788 * Output :
1789 * Description : Converts a resource name into a valid c-identifier in the
1790 * form "_base_nid".
1791 * Remarks :
1792 *****************************************************************************
1793 */
1794 char *make_c_name(char *base, name_id_t *nid, language_t *lan)
1795 {
1796 int nlen;
1797 char *buf;
1798 char *ret;
1799 char lanbuf[6];
1800
1801 sprintf(lanbuf, "%d", lan ? MAKELANGID(lan->id, lan->sub) : 0);
1802 buf = prep_nid_for_label(nid);
1803 nlen = strlen(buf) + strlen(lanbuf);
1804 nlen += strlen(base) + 4; /* three time '_' and '\0' */
1805 ret = (char *)xmalloc(nlen);
1806 strcpy(ret, "_");
1807 strcat(ret, base);
1808 strcat(ret, "_");
1809 strcat(ret, buf);
1810 strcat(ret, "_");
1811 strcat(ret, lanbuf);
1812 return ret;
1813 }
1814
1815 /*
1816 *****************************************************************************
1817 * Function : get_c_typename
1818 * Syntax : char *get_c_typename(enum res_e type)
1819 * Input :
1820 * Output :
1821 * Description : Convert resource enum to char string to be used in c-name
1822 * creation.
1823 * Remarks :
1824 *****************************************************************************
1825 */
1826 char *get_c_typename(enum res_e type)
1827 {
1828 switch(type)
1829 {
1830 case res_acc: return "Acc";
1831 case res_anicur:return "AniCur";
1832 case res_aniico:return "AniIco";
1833 case res_bmp: return "Bmp";
1834 case res_cur: return "Cur";
1835 case res_curg: return "CurGrp";
1836 case res_dlg:
1837 case res_dlgex: return "Dlg";
1838 case res_fnt: return "Fnt";
1839 case res_fntdir:return "FntDir";
1840 case res_ico: return "Ico";
1841 case res_icog: return "IcoGrp";
1842 case res_men:
1843 case res_menex: return "Men";
1844 case res_rdt: return "RCDat";
1845 case res_stt: return "StrTab";
1846 case res_usr: return "Usr";
1847 case res_msg: return "MsgTab";
1848 case res_ver: return "VerInf";
1849 case res_toolbar: return "TlBr";
1850 case res_dlginit: return "DlgInit";
1851 default: return "Oops";
1852 }
1853 }
1854
1855 /*
1856 *****************************************************************************
1857 * Function : resources2res
1858 * Syntax : void resources2res(resource_t *top)
1859 * Input :
1860 * top - The resource-tree to convert
1861 * Output :
1862 * Description : Convert logical resource descriptors into binary data
1863 * Remarks :
1864 *****************************************************************************
1865 */
1866 void resources2res(resource_t *top)
1867 {
1868 while(top)
1869 {
1870 switch(top->type)
1871 {
1872 case res_acc:
1873 if(!top->binres)
1874 top->binres = accelerator2res(top->name, top->res.acc);
1875 break;
1876 case res_bmp:
1877 if(!top->binres)
1878 top->binres = bitmap2res(top->name, top->res.bmp);
1879 break;
1880 case res_cur:
1881 if(!top->binres)
1882 top->binres = cursor2res(top->res.cur);
1883 break;
1884 case res_curg:
1885 if(!top->binres)
1886 top->binres = cursorgroup2res(top->name, top->res.curg);
1887 break;
1888 case res_dlg:
1889 if(!top->binres)
1890 top->binres = dialog2res(top->name, top->res.dlg);
1891 break;
1892 case res_dlgex:
1893 if(!top->binres)
1894 top->binres = dialogex2res(top->name, top->res.dlgex);
1895 break;
1896 case res_fnt:
1897 if(!top->binres)
1898 top->binres = font2res(top->name, top->res.fnt);
1899 break;
1900 case res_fntdir:
1901 if(!top->binres)
1902 top->binres = fontdir2res(top->name, top->res.fnd);
1903 break;
1904 case res_ico:
1905 if(!top->binres)
1906 top->binres = icon2res(top->res.ico);
1907 break;
1908 case res_icog:
1909 if(!top->binres)
1910 top->binres = icongroup2res(top->name, top->res.icog);
1911 break;
1912 case res_men:
1913 if(!top->binres)
1914 top->binres = menu2res(top->name, top->res.men);
1915 break;
1916 case res_menex:
1917 if(!top->binres)
1918 top->binres = menuex2res(top->name, top->res.menex);
1919 break;
1920 case res_rdt:
1921 if(!top->binres)
1922 top->binres = rcdata2res(top->name, top->res.rdt);
1923 break;
1924 case res_stt:
1925 if(!top->binres)
1926 top->binres = stringtable2res(top->res.stt);
1927 break;
1928 case res_usr:
1929 if(!top->binres)
1930 top->binres = user2res(top->name, top->res.usr);
1931 break;
1932 case res_msg:
1933 if(!top->binres)
1934 top->binres = messagetable2res(top->name, top->res.msg);
1935 break;
1936 case res_ver:
1937 if(!top->binres)
1938 top->binres = versioninfo2res(top->name, top->res.ver);
1939 break;
1940 case res_toolbar:
1941 if(!top->binres)
1942 top->binres = toolbar2res(top->name, top->res.tbt);
1943 break;
1944 case res_dlginit:
1945 if(!top->binres)
1946 top->binres = dlginit2res(top->name, top->res.dlgi);
1947 break;
1948 case res_anicur:
1949 case res_aniico:
1950 if(!top->binres)
1951 top->binres = anicurico2res(top->name, top->res.ani, top->type);
1952 break;
1953 default:
1954 internal_error(__FILE__, __LINE__, "Unknown resource type encountered %d in binary res generation", top->type);
1955 }
1956 top->c_name = make_c_name(get_c_typename(top->type), top->name, top->lan);
1957 top = top->next;
1958 }
1959 }
1960
Windows API implementation