source: trunk/tools/wrc/genres.c@ 22016

Last change on this file since 22016 was 5522, checked in by sandervl, 25 years ago

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