]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - binutils/resbin.c
Update year range in copyright notice of binutils files
[thirdparty/binutils-gdb.git] / binutils / resbin.c
1 /* resbin.c -- manipulate the Windows binary resource format.
2 Copyright (C) 1997-2018 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4 Rewritten by Kai Tietz, Onevision.
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23
24 /* This file contains functions to convert between the binary resource
25 format and the internal structures that we want to use. The same
26 binary resource format is used in both res and COFF files. */
27
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "bucomm.h"
31 #include "libiberty.h"
32 #include "windres.h"
33
34 /* Local functions. */
35
36 static void toosmall (const char *);
37
38 static unichar *get_unicode (windres_bfd *, const bfd_byte *, rc_uint_type, rc_uint_type *);
39 static int get_resid (windres_bfd *, rc_res_id *, const bfd_byte *, rc_uint_type);
40 static rc_res_resource *bin_to_res_generic (windres_bfd *, enum rc_res_type,
41 const bfd_byte *, rc_uint_type);
42 static rc_res_resource *bin_to_res_cursor (windres_bfd *, const bfd_byte *, rc_uint_type);
43 static rc_res_resource *bin_to_res_menu (windres_bfd *,const bfd_byte *, rc_uint_type);
44 static rc_menuitem *bin_to_res_menuitems (windres_bfd *, const bfd_byte *, rc_uint_type,
45 rc_uint_type *);
46 static rc_menuitem *bin_to_res_menuexitems (windres_bfd *, const bfd_byte *, rc_uint_type,
47 rc_uint_type *);
48 static rc_res_resource *bin_to_res_dialog (windres_bfd *, const bfd_byte *, rc_uint_type);
49 static rc_res_resource *bin_to_res_string (windres_bfd *,const bfd_byte *, rc_uint_type);
50 static rc_res_resource *bin_to_res_fontdir (windres_bfd *, const bfd_byte *, rc_uint_type);
51 static rc_res_resource *bin_to_res_accelerators (windres_bfd *, const bfd_byte *, rc_uint_type);
52 static rc_res_resource *bin_to_res_rcdata (windres_bfd *, const bfd_byte *, rc_uint_type, int);
53 static rc_res_resource *bin_to_res_group_cursor (windres_bfd *, const bfd_byte *, rc_uint_type);
54 static rc_res_resource *bin_to_res_group_icon (windres_bfd *, const bfd_byte *, rc_uint_type);
55 static rc_res_resource *bin_to_res_version (windres_bfd *, const bfd_byte *, rc_uint_type);
56 static rc_res_resource *bin_to_res_userdata (windres_bfd *, const bfd_byte *, rc_uint_type);
57 static rc_res_resource *bin_to_res_toolbar (windres_bfd *, const bfd_byte *, rc_uint_type);
58 static void get_version_header (windres_bfd *, const bfd_byte *, rc_uint_type, const char *,
59 unichar **, rc_uint_type *, rc_uint_type *, rc_uint_type *,
60 rc_uint_type *);
61
62 /* Given a resource type ID, a pointer to data, a length, return a
63 rc_res_resource structure which represents that resource. The caller
64 is responsible for initializing the res_info and coff_info fields
65 of the returned structure. */
66
67 rc_res_resource *
68 bin_to_res (windres_bfd *wrbfd, rc_res_id type, const bfd_byte *data,
69 rc_uint_type length)
70 {
71 if (type.named)
72 return bin_to_res_userdata (wrbfd, data, length);
73 else
74 {
75 switch (type.u.id)
76 {
77 default:
78 return bin_to_res_userdata (wrbfd, data, length);
79 case RT_CURSOR:
80 return bin_to_res_cursor (wrbfd, data, length);
81 case RT_BITMAP:
82 return bin_to_res_generic (wrbfd, RES_TYPE_BITMAP, data, length);
83 case RT_ICON:
84 return bin_to_res_generic (wrbfd, RES_TYPE_ICON, data, length);
85 case RT_MENU:
86 return bin_to_res_menu (wrbfd, data, length);
87 case RT_DIALOG:
88 return bin_to_res_dialog (wrbfd, data, length);
89 case RT_STRING:
90 return bin_to_res_string (wrbfd, data, length);
91 case RT_FONTDIR:
92 return bin_to_res_fontdir (wrbfd, data, length);
93 case RT_FONT:
94 return bin_to_res_generic (wrbfd, RES_TYPE_FONT, data, length);
95 case RT_ACCELERATOR:
96 return bin_to_res_accelerators (wrbfd, data, length);
97 case RT_RCDATA:
98 return bin_to_res_rcdata (wrbfd, data, length, RES_TYPE_RCDATA);
99 case RT_MESSAGETABLE:
100 return bin_to_res_generic (wrbfd, RES_TYPE_MESSAGETABLE, data, length);
101 case RT_GROUP_CURSOR:
102 return bin_to_res_group_cursor (wrbfd, data, length);
103 case RT_GROUP_ICON:
104 return bin_to_res_group_icon (wrbfd, data, length);
105 case RT_VERSION:
106 return bin_to_res_version (wrbfd, data, length);
107 case RT_TOOLBAR:
108 return bin_to_res_toolbar (wrbfd, data, length);
109
110 }
111 }
112 }
113
114 /* Give an error if the binary data is too small. */
115
116 static void
117 toosmall (const char *msg)
118 {
119 fatal (_("%s: not enough binary data"), msg);
120 }
121
122 /* Swap in a NULL terminated unicode string. */
123
124 static unichar *
125 get_unicode (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length,
126 rc_uint_type *retlen)
127 {
128 rc_uint_type c, i;
129 unichar *ret;
130
131 c = 0;
132 while (1)
133 {
134 if (length < c * 2 + 2)
135 toosmall (_("null terminated unicode string"));
136 if (windres_get_16 (wrbfd, data + c * 2, 2) == 0)
137 break;
138 ++c;
139 }
140
141 ret = (unichar *) res_alloc ((c + 1) * sizeof (unichar));
142
143 for (i = 0; i < c; i++)
144 ret[i] = windres_get_16 (wrbfd, data + i * 2, 2);
145 ret[i] = 0;
146
147 if (retlen != NULL)
148 *retlen = c;
149
150 return ret;
151 }
152
153 /* Get a resource identifier. This returns the number of bytes used. */
154
155 static int
156 get_resid (windres_bfd *wrbfd, rc_res_id *id, const bfd_byte *data,
157 rc_uint_type length)
158 {
159 rc_uint_type first;
160
161 if (length < 2)
162 toosmall (_("resource ID"));
163
164 first = windres_get_16 (wrbfd, data, 2);
165 if (first == 0xffff)
166 {
167 if (length < 4)
168 toosmall (_("resource ID"));
169 id->named = 0;
170 id->u.id = windres_get_16 (wrbfd, data + 2, 2);
171 return 4;
172 }
173 else
174 {
175 id->named = 1;
176 id->u.n.name = get_unicode (wrbfd, data, length, &id->u.n.length);
177 return id->u.n.length * 2 + 2;
178 }
179 }
180
181 /* Convert a resource which just stores uninterpreted data from
182 binary. */
183
184 rc_res_resource *
185 bin_to_res_generic (windres_bfd *wrbfd ATTRIBUTE_UNUSED, enum rc_res_type type,
186 const bfd_byte *data, rc_uint_type length)
187 {
188 rc_res_resource *r;
189
190 r = (rc_res_resource *) res_alloc (sizeof (rc_res_resource));
191 r->type = type;
192 r->u.data.data = data;
193 r->u.data.length = length;
194
195 return r;
196 }
197
198 /* Convert a cursor resource from binary. */
199
200 rc_res_resource *
201 bin_to_res_cursor (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
202 {
203 rc_cursor *c;
204 rc_res_resource *r;
205
206 if (length < 4)
207 toosmall (_("cursor"));
208
209 c = (rc_cursor *) res_alloc (sizeof (rc_cursor));
210 c->xhotspot = windres_get_16 (wrbfd, data, 2);
211 c->yhotspot = windres_get_16 (wrbfd, data + 2, 2);
212 c->length = length - 4;
213 c->data = data + 4;
214
215 r = (rc_res_resource *) res_alloc (sizeof *r);
216 r->type = RES_TYPE_CURSOR;
217 r->u.cursor = c;
218
219 return r;
220 }
221
222 /* Convert a menu resource from binary. */
223
224 rc_res_resource *
225 bin_to_res_menu (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
226 {
227 rc_res_resource *r;
228 rc_menu *m;
229 rc_uint_type version, got;
230
231 r = (rc_res_resource *) res_alloc (sizeof *r);
232 r->type = RES_TYPE_MENU;
233
234 m = (rc_menu *) res_alloc (sizeof (rc_menu));
235 r->u.menu = m;
236
237 if (length < 2)
238 toosmall (_("menu header"));
239
240 version = windres_get_16 (wrbfd, data, 2);
241
242 if (version == 0)
243 {
244 if (length < 4)
245 toosmall (_("menu header"));
246 m->help = 0;
247 m->items = bin_to_res_menuitems (wrbfd, data + 4, length - 4, &got);
248 }
249 else if (version == 1)
250 {
251 rc_uint_type offset;
252
253 if (length < 8)
254 toosmall (_("menuex header"));
255 m->help = windres_get_32 (wrbfd, data + 4, 4);
256 offset = windres_get_16 (wrbfd, data + 2, 2);
257 if (offset + 4 >= length)
258 toosmall (_("menuex offset"));
259 m->items = bin_to_res_menuexitems (wrbfd, data + 4 + offset,
260 length - (4 + offset), &got);
261 }
262 else
263 fatal (_("unsupported menu version %d"), (int) version);
264
265 return r;
266 }
267
268 /* Convert menu items from binary. */
269
270 static rc_menuitem *
271 bin_to_res_menuitems (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length,
272 rc_uint_type *got)
273 {
274 rc_menuitem *first, **pp;
275
276 first = NULL;
277 pp = &first;
278
279 *got = 0;
280
281 while (length > 0)
282 {
283 rc_uint_type flags, slen, itemlen;
284 rc_uint_type stroff;
285 rc_menuitem *mi;
286
287 if (length < 4)
288 toosmall (_("menuitem header"));
289
290 mi = (rc_menuitem *) res_alloc (sizeof *mi);
291 mi->state = 0;
292 mi->help = 0;
293
294 flags = windres_get_16 (wrbfd, data, 2);
295 mi->type = flags &~ (MENUITEM_POPUP | MENUITEM_ENDMENU);
296
297 if ((flags & MENUITEM_POPUP) == 0)
298 stroff = 4;
299 else
300 stroff = 2;
301
302 if (length < stroff + 2)
303 toosmall (_("menuitem header"));
304
305 if (windres_get_16 (wrbfd, data + stroff, 2) == 0)
306 {
307 slen = 0;
308 mi->text = NULL;
309 }
310 else
311 mi->text = get_unicode (wrbfd, data + stroff, length - stroff, &slen);
312
313 itemlen = stroff + slen * 2 + 2;
314
315 if ((flags & MENUITEM_POPUP) == 0)
316 {
317 mi->popup = NULL;
318 mi->id = windres_get_16 (wrbfd, data + 2, 2);
319 }
320 else
321 {
322 rc_uint_type subread;
323
324 mi->id = 0;
325 mi->popup = bin_to_res_menuitems (wrbfd, data + itemlen, length - itemlen,
326 &subread);
327 itemlen += subread;
328 }
329
330 mi->next = NULL;
331 *pp = mi;
332 pp = &mi->next;
333
334 data += itemlen;
335 length -= itemlen;
336 *got += itemlen;
337
338 if ((flags & MENUITEM_ENDMENU) != 0)
339 return first;
340 }
341
342 return first;
343 }
344
345 /* Convert menuex items from binary. */
346
347 static rc_menuitem *
348 bin_to_res_menuexitems (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length,
349 rc_uint_type *got)
350 {
351 rc_menuitem *first, **pp;
352
353 first = NULL;
354 pp = &first;
355
356 *got = 0;
357
358 while (length > 0)
359 {
360 rc_uint_type flags, slen;
361 rc_uint_type itemlen;
362 rc_menuitem *mi;
363
364 if (length < 16)
365 toosmall (_("menuitem header"));
366
367 mi = (rc_menuitem *) res_alloc (sizeof (rc_menuitem));
368 mi->type = windres_get_32 (wrbfd, data, 4);
369 mi->state = windres_get_32 (wrbfd, data + 4, 4);
370 mi->id = windres_get_32 (wrbfd, data + 8, 4);
371
372 flags = windres_get_16 (wrbfd, data + 12, 2);
373
374 if (windres_get_16 (wrbfd, data + 14, 2) == 0)
375 {
376 slen = 0;
377 mi->text = NULL;
378 }
379 else
380 mi->text = get_unicode (wrbfd, data + 14, length - 14, &slen);
381
382 itemlen = 14 + slen * 2 + 2;
383 itemlen = (itemlen + 3) &~ 3;
384
385 if ((flags & 1) == 0)
386 {
387 mi->popup = NULL;
388 mi->help = 0;
389 }
390 else
391 {
392 rc_uint_type subread;
393
394 if (length < itemlen + 4)
395 toosmall (_("menuitem"));
396 mi->help = windres_get_32 (wrbfd, data + itemlen, 4);
397 itemlen += 4;
398
399 mi->popup = bin_to_res_menuexitems (wrbfd, data + itemlen,
400 length - itemlen, &subread);
401 itemlen += subread;
402 }
403
404 mi->next = NULL;
405 *pp = mi;
406 pp = &mi->next;
407
408 data += itemlen;
409 length -= itemlen;
410 *got += itemlen;
411
412 if ((flags & 0x80) != 0)
413 return first;
414 }
415
416 return first;
417 }
418
419 /* Convert a dialog resource from binary. */
420
421 static rc_res_resource *
422 bin_to_res_dialog (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
423 {
424 rc_uint_type signature;
425 rc_dialog *d;
426 rc_uint_type c, sublen, i;
427 rc_uint_type off;
428 rc_dialog_control **pp;
429 rc_res_resource *r;
430
431 if (length < 18)
432 toosmall (_("dialog header"));
433
434 d = (rc_dialog *) res_alloc (sizeof (rc_dialog));
435
436 signature = windres_get_16 (wrbfd, data + 2, 2);
437 if (signature != 0xffff)
438 {
439 d->ex = NULL;
440 d->style = windres_get_32 (wrbfd, data, 4);
441 d->exstyle = windres_get_32 (wrbfd, data + 4, 4);
442 off = 8;
443 }
444 else
445 {
446 int version;
447
448 version = windres_get_16 (wrbfd, data, 2);
449 if (version != 1)
450 fatal (_("unexpected DIALOGEX version %d"), version);
451
452 d->ex = (rc_dialog_ex *) res_alloc (sizeof (rc_dialog_ex));
453 d->ex->help = windres_get_32 (wrbfd, data + 4, 4);
454 d->exstyle = windres_get_32 (wrbfd, data + 8, 4);
455 d->style = windres_get_32 (wrbfd, data + 12, 4);
456 off = 16;
457 }
458
459 if (length < off + 10)
460 toosmall (_("dialog header"));
461
462 c = windres_get_16 (wrbfd, data + off, 2);
463 d->x = windres_get_16 (wrbfd, data + off + 2, 2);
464 d->y = windres_get_16 (wrbfd, data + off + 4, 2);
465 d->width = windres_get_16 (wrbfd, data + off + 6, 2);
466 d->height = windres_get_16 (wrbfd, data + off + 8, 2);
467
468 off += 10;
469
470 sublen = get_resid (wrbfd, &d->menu, data + off, length - off);
471 off += sublen;
472
473 sublen = get_resid (wrbfd, &d->class, data + off, length - off);
474 off += sublen;
475
476 d->caption = get_unicode (wrbfd, data + off, length - off, &sublen);
477 off += sublen * 2 + 2;
478 if (sublen == 0)
479 d->caption = NULL;
480
481 if ((d->style & DS_SETFONT) == 0)
482 {
483 d->pointsize = 0;
484 d->font = NULL;
485 if (d->ex != NULL)
486 {
487 d->ex->weight = 0;
488 d->ex->italic = 0;
489 d->ex->charset = 1; /* Default charset. */
490 }
491 }
492 else
493 {
494 if (length < off + 2)
495 toosmall (_("dialog font point size"));
496
497 d->pointsize = windres_get_16 (wrbfd, data + off, 2);
498 off += 2;
499
500 if (d->ex != NULL)
501 {
502 if (length < off + 4)
503 toosmall (_("dialogex font information"));
504 d->ex->weight = windres_get_16 (wrbfd, data + off, 2);
505 d->ex->italic = windres_get_8 (wrbfd, data + off + 2, 1);
506 d->ex->charset = windres_get_8 (wrbfd, data + off + 3, 1);
507 off += 4;
508 }
509
510 d->font = get_unicode (wrbfd, data + off, length - off, &sublen);
511 off += sublen * 2 + 2;
512 }
513
514 d->controls = NULL;
515 pp = &d->controls;
516
517 for (i = 0; i < c; i++)
518 {
519 rc_dialog_control *dc;
520 int datalen;
521
522 off = (off + 3) &~ 3;
523
524 dc = (rc_dialog_control *) res_alloc (sizeof (rc_dialog_control));
525
526 if (d->ex == NULL)
527 {
528 if (length < off + 8)
529 toosmall (_("dialog control"));
530
531 dc->style = windres_get_32 (wrbfd, data + off, 4);
532 dc->exstyle = windres_get_32 (wrbfd, data + off + 4, 4);
533 dc->help = 0;
534 off += 8;
535 }
536 else
537 {
538 if (length < off + 12)
539 toosmall (_("dialogex control"));
540 dc->help = windres_get_32 (wrbfd, data + off, 4);
541 dc->exstyle = windres_get_32 (wrbfd, data + off + 4, 4);
542 dc->style = windres_get_32 (wrbfd, data + off + 8, 4);
543 off += 12;
544 }
545
546 if (length < off + (d->ex != NULL ? 2 : 0) + 10)
547 toosmall (_("dialog control"));
548
549 dc->x = windres_get_16 (wrbfd, data + off, 2);
550 dc->y = windres_get_16 (wrbfd, data + off + 2, 2);
551 dc->width = windres_get_16 (wrbfd, data + off + 4, 2);
552 dc->height = windres_get_16 (wrbfd, data + off + 6, 2);
553
554 if (d->ex != NULL)
555 dc->id = windres_get_32 (wrbfd, data + off + 8, 4);
556 else
557 dc->id = windres_get_16 (wrbfd, data + off + 8, 2);
558
559 off += 10 + (d->ex != NULL ? 2 : 0);
560
561 sublen = get_resid (wrbfd, &dc->class, data + off, length - off);
562 off += sublen;
563
564 sublen = get_resid (wrbfd, &dc->text, data + off, length - off);
565 off += sublen;
566
567 if (length < off + 2)
568 toosmall (_("dialog control end"));
569
570 datalen = windres_get_16 (wrbfd, data + off, 2);
571 off += 2;
572
573 if (datalen == 0)
574 dc->data = NULL;
575 else
576 {
577 if (length < off + datalen)
578 toosmall (_("dialog control data"));
579
580 dc->data = ((rc_rcdata_item *)
581 res_alloc (sizeof (rc_rcdata_item)));
582 dc->data->next = NULL;
583 dc->data->type = RCDATA_BUFFER;
584 dc->data->u.buffer.length = datalen;
585 dc->data->u.buffer.data = data + off;
586
587 off += datalen;
588 }
589
590 dc->next = NULL;
591 *pp = dc;
592 pp = &dc->next;
593 }
594
595 r = (rc_res_resource *) res_alloc (sizeof *r);
596 r->type = RES_TYPE_DIALOG;
597 r->u.dialog = d;
598
599 return r;
600 }
601
602 /* Convert a stringtable resource from binary. */
603
604 static rc_res_resource *
605 bin_to_res_string (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
606 {
607 rc_stringtable *st;
608 int i;
609 rc_res_resource *r;
610
611 st = (rc_stringtable *) res_alloc (sizeof (rc_stringtable));
612
613 for (i = 0; i < 16; i++)
614 {
615 unsigned int slen;
616
617 if (length < 2)
618 toosmall (_("stringtable string length"));
619 slen = windres_get_16 (wrbfd, data, 2);
620 st->strings[i].length = slen;
621
622 if (slen > 0)
623 {
624 unichar *s;
625 unsigned int j;
626
627 if (length < 2 + 2 * slen)
628 toosmall (_("stringtable string"));
629
630 s = (unichar *) res_alloc (slen * sizeof (unichar));
631 st->strings[i].string = s;
632
633 for (j = 0; j < slen; j++)
634 s[j] = windres_get_16 (wrbfd, data + 2 + j * 2, 2);
635 }
636
637 data += 2 + 2 * slen;
638 length -= 2 + 2 * slen;
639 }
640
641 r = (rc_res_resource *) res_alloc (sizeof *r);
642 r->type = RES_TYPE_STRINGTABLE;
643 r->u.stringtable = st;
644
645 return r;
646 }
647
648 /* Convert a fontdir resource from binary. */
649
650 static rc_res_resource *
651 bin_to_res_fontdir (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
652 {
653 rc_uint_type c, i;
654 rc_fontdir *first, **pp;
655 rc_res_resource *r;
656
657 if (length < 2)
658 toosmall (_("fontdir header"));
659
660 c = windres_get_16 (wrbfd, data, 2);
661
662 first = NULL;
663 pp = &first;
664
665 for (i = 0; i < c; i++)
666 {
667 const struct bin_fontdir_item *bfi;
668 rc_fontdir *fd;
669 unsigned int off;
670
671 if (length < 56)
672 toosmall (_("fontdir"));
673
674 bfi = (const struct bin_fontdir_item *) data;
675 fd = (rc_fontdir *) res_alloc (sizeof *fd);
676 fd->index = windres_get_16 (wrbfd, bfi->index, 2);
677
678 /* To work out the length of the fontdir data, we must get the
679 length of the device name and face name strings, even though
680 we don't store them in the rc_fontdir. The
681 documentation says that these are NULL terminated char
682 strings, not Unicode strings. */
683
684 off = 56;
685
686 while (off < length && data[off] != '\0')
687 ++off;
688 if (off >= length)
689 toosmall (_("fontdir device name"));
690 ++off;
691
692 while (off < length && data[off] != '\0')
693 ++off;
694 if (off >= length)
695 toosmall (_("fontdir face name"));
696 ++off;
697
698 fd->length = off;
699 fd->data = data;
700
701 fd->next = NULL;
702 *pp = fd;
703 pp = &fd->next;
704
705 /* The documentation does not indicate that any rounding is
706 required. */
707
708 data += off;
709 length -= off;
710 }
711
712 r = (rc_res_resource *) res_alloc (sizeof *r);
713 r->type = RES_TYPE_FONTDIR;
714 r->u.fontdir = first;
715
716 return r;
717 }
718
719 /* Convert an accelerators resource from binary. */
720
721 static rc_res_resource *
722 bin_to_res_accelerators (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
723 {
724 rc_accelerator *first, **pp;
725 rc_res_resource *r;
726
727 first = NULL;
728 pp = &first;
729
730 while (1)
731 {
732 rc_accelerator *a;
733
734 if (length < 8)
735 toosmall (_("accelerator"));
736
737 a = (rc_accelerator *) res_alloc (sizeof (rc_accelerator));
738
739 a->flags = windres_get_16 (wrbfd, data, 2);
740 a->key = windres_get_16 (wrbfd, data + 2, 2);
741 a->id = windres_get_16 (wrbfd, data + 4, 2);
742
743 a->next = NULL;
744 *pp = a;
745 pp = &a->next;
746
747 if ((a->flags & ACC_LAST) != 0)
748 break;
749
750 data += 8;
751 length -= 8;
752 }
753
754 r = (rc_res_resource *) res_alloc (sizeof (rc_res_resource));
755 r->type = RES_TYPE_ACCELERATOR;
756 r->u.acc = first;
757
758 return r;
759 }
760
761 /* Convert an rcdata resource from binary. */
762
763 static rc_res_resource *
764 bin_to_res_rcdata (windres_bfd *wrbfd ATTRIBUTE_UNUSED, const bfd_byte *data,
765 rc_uint_type length, int rctyp)
766 {
767 rc_rcdata_item *ri;
768 rc_res_resource *r;
769
770 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
771
772 ri->next = NULL;
773 ri->type = RCDATA_BUFFER;
774 ri->u.buffer.length = length;
775 ri->u.buffer.data = data;
776
777 r = (rc_res_resource *) res_alloc (sizeof *r);
778 r->type = rctyp;
779 r->u.rcdata = ri;
780
781 return r;
782 }
783
784 /* Convert a group cursor resource from binary. */
785
786 static rc_res_resource *
787 bin_to_res_group_cursor (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
788 {
789 int type, c, i;
790 rc_group_cursor *first, **pp;
791 rc_res_resource *r;
792
793 if (length < 6)
794 toosmall (_("group cursor header"));
795
796 type = windres_get_16 (wrbfd, data + 2, 2);
797 if (type != 2)
798 fatal (_("unexpected group cursor type %d"), type);
799
800 c = windres_get_16 (wrbfd, data + 4, 2);
801
802 data += 6;
803 length -= 6;
804
805 first = NULL;
806 pp = &first;
807
808 for (i = 0; i < c; i++)
809 {
810 rc_group_cursor *gc;
811
812 if (length < 14)
813 toosmall (_("group cursor"));
814
815 gc = (rc_group_cursor *) res_alloc (sizeof *gc);
816
817 gc->width = windres_get_16 (wrbfd, data, 2);
818 gc->height = windres_get_16 (wrbfd, data + 2, 2);
819 gc->planes = windres_get_16 (wrbfd, data + 4, 2);
820 gc->bits = windres_get_16 (wrbfd, data + 6, 2);
821 gc->bytes = windres_get_32 (wrbfd, data + 8, 4);
822 gc->index = windres_get_16 (wrbfd, data + 12, 2);
823
824 gc->next = NULL;
825 *pp = gc;
826 pp = &gc->next;
827
828 data += 14;
829 length -= 14;
830 }
831
832 r = (rc_res_resource *) res_alloc (sizeof (rc_res_resource));
833 r->type = RES_TYPE_GROUP_CURSOR;
834 r->u.group_cursor = first;
835
836 return r;
837 }
838
839 /* Convert a group icon resource from binary. */
840
841 static rc_res_resource *
842 bin_to_res_group_icon (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
843 {
844 int type, c, i;
845 rc_group_icon *first, **pp;
846 rc_res_resource *r;
847
848 if (length < 6)
849 toosmall (_("group icon header"));
850
851 type = windres_get_16 (wrbfd, data + 2, 2);
852 if (type != 1)
853 fatal (_("unexpected group icon type %d"), type);
854
855 c = windres_get_16 (wrbfd, data + 4, 2);
856
857 data += 6;
858 length -= 6;
859
860 first = NULL;
861 pp = &first;
862
863 for (i = 0; i < c; i++)
864 {
865 rc_group_icon *gi;
866
867 if (length < 14)
868 toosmall (_("group icon"));
869
870 gi = (rc_group_icon *) res_alloc (sizeof (rc_group_icon));
871
872 gi->width = windres_get_8 (wrbfd, data, 1);
873 gi->height = windres_get_8 (wrbfd, data + 1, 1);
874 gi->colors = windres_get_8 (wrbfd, data + 2, 1);
875 gi->planes = windres_get_16 (wrbfd, data + 4, 2);
876 gi->bits = windres_get_16 (wrbfd, data + 6, 2);
877 gi->bytes = windres_get_32 (wrbfd, data + 8, 4);
878 gi->index = windres_get_16 (wrbfd, data + 12, 2);
879
880 gi->next = NULL;
881 *pp = gi;
882 pp = &gi->next;
883
884 data += 14;
885 length -= 14;
886 }
887
888 r = (rc_res_resource *) res_alloc (sizeof *r);
889 r->type = RES_TYPE_GROUP_ICON;
890 r->u.group_icon = first;
891
892 return r;
893 }
894
895 /* Extract data from a version header. If KEY is not NULL, then the
896 key must be KEY; otherwise, the key is returned in *PKEY. This
897 sets *LEN to the total length, *VALLEN to the value length, *TYPE
898 to the type, and *OFF to the offset to the children. */
899
900 static void
901 get_version_header (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length,
902 const char *key, unichar **pkey,
903 rc_uint_type *len, rc_uint_type *vallen, rc_uint_type *type,
904 rc_uint_type *off)
905 {
906 if (length < 8)
907 toosmall (key);
908
909 *len = (windres_get_16 (wrbfd, data, 2) + 3) & ~3;
910 *vallen = windres_get_16 (wrbfd, data + 2, 2);
911 *type = windres_get_16 (wrbfd, data + 4, 2);
912
913 *off = 6;
914
915 length -= 6;
916 data += 6;
917
918 if (key == NULL)
919 {
920 rc_uint_type sublen;
921
922 *pkey = get_unicode (wrbfd, data, length, &sublen);
923 *off += (sublen + 1) * sizeof (unichar);
924 }
925 else
926 {
927 while (1)
928 {
929 if (length < 2)
930 toosmall (key);
931 if (windres_get_16 (wrbfd, data, 2) != (bfd_byte) *key)
932 fatal (_("unexpected version string"));
933
934 *off += 2;
935 length -= 2;
936 data += 2;
937
938 if (*key == '\0')
939 break;
940
941 ++key;
942 }
943 }
944
945 *off = (*off + 3) &~ 3;
946 }
947
948 /* Convert a version resource from binary. */
949
950 static rc_res_resource *
951 bin_to_res_version (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
952 {
953 rc_uint_type verlen, vallen, type, off;
954 rc_fixed_versioninfo *fi;
955 rc_ver_info *first, **pp;
956 rc_versioninfo *v;
957 rc_res_resource *r;
958
959 get_version_header (wrbfd, data, length, "VS_VERSION_INFO",
960 (unichar **) NULL, &verlen, &vallen, &type, &off);
961
962 /* PR 17512: The verlen field does not include padding length. */
963 if (verlen > length)
964 fatal (_("version length %lu greater than resource length %lu"),
965 (unsigned long) verlen, (unsigned long) length);
966
967 if (type != 0)
968 fatal (_("unexpected version type %d"), (int) type);
969
970 data += off;
971 length -= off;
972
973 if (vallen == 0)
974 fi = NULL;
975 else
976 {
977 unsigned long signature, fiv;
978
979 if (vallen != 52)
980 fatal (_("unexpected fixed version information length %ld"), (long) vallen);
981
982 if (length < 52)
983 toosmall (_("fixed version info"));
984
985 signature = windres_get_32 (wrbfd, data, 4);
986 if (signature != 0xfeef04bd)
987 fatal (_("unexpected fixed version signature %lu"), signature);
988
989 fiv = windres_get_32 (wrbfd, data + 4, 4);
990 if (fiv != 0 && fiv != 0x10000)
991 fatal (_("unexpected fixed version info version %lu"), fiv);
992
993 fi = (rc_fixed_versioninfo *) res_alloc (sizeof (rc_fixed_versioninfo));
994
995 fi->file_version_ms = windres_get_32 (wrbfd, data + 8, 4);
996 fi->file_version_ls = windres_get_32 (wrbfd, data + 12, 4);
997 fi->product_version_ms = windres_get_32 (wrbfd, data + 16, 4);
998 fi->product_version_ls = windres_get_32 (wrbfd, data + 20, 4);
999 fi->file_flags_mask = windres_get_32 (wrbfd, data + 24, 4);
1000 fi->file_flags = windres_get_32 (wrbfd, data + 28, 4);
1001 fi->file_os = windres_get_32 (wrbfd, data + 32, 4);
1002 fi->file_type = windres_get_32 (wrbfd, data + 36, 4);
1003 fi->file_subtype = windres_get_32 (wrbfd, data + 40, 4);
1004 fi->file_date_ms = windres_get_32 (wrbfd, data + 44, 4);
1005 fi->file_date_ls = windres_get_32 (wrbfd, data + 48, 4);
1006
1007 data += 52;
1008 length -= 52;
1009 }
1010
1011 first = NULL;
1012 pp = &first;
1013
1014 while (length > 0)
1015 {
1016 rc_ver_info *vi;
1017 int ch;
1018
1019 if (length < 8)
1020 toosmall (_("version var info"));
1021
1022 vi = (rc_ver_info *) res_alloc (sizeof (rc_ver_info));
1023
1024 ch = windres_get_16 (wrbfd, data + 6, 2);
1025
1026 if (ch == 'S')
1027 {
1028 rc_ver_stringtable **ppvst;
1029
1030 vi->type = VERINFO_STRING;
1031
1032 get_version_header (wrbfd, data, length, "StringFileInfo",
1033 (unichar **) NULL, &verlen, &vallen, &type,
1034 &off);
1035
1036 if (vallen != 0)
1037 fatal (_("unexpected stringfileinfo value length %ld"), (long) vallen);
1038
1039 data += off;
1040 length -= off;
1041
1042 verlen -= off;
1043
1044 vi->u.string.stringtables = NULL;
1045 ppvst = &vi->u.string.stringtables;
1046
1047 while (verlen > 0)
1048 {
1049 rc_ver_stringtable *vst;
1050 rc_uint_type stverlen;
1051 rc_ver_stringinfo **ppvs;
1052
1053 if (length < 8)
1054 toosmall (_("version stringtable"));
1055
1056 vst = (rc_ver_stringtable *) res_alloc (sizeof (rc_ver_stringtable));
1057
1058 get_version_header (wrbfd, data, length, (const char *) NULL,
1059 &vst->language, &stverlen, &vallen, &type, &off);
1060
1061 if (vallen != 0)
1062 fatal (_("unexpected version stringtable value length %ld"), (long) vallen);
1063
1064 data += off;
1065 length -= off;
1066 verlen -= off;
1067
1068 stverlen -= off;
1069
1070 vst->strings = NULL;
1071 ppvs = &vst->strings;
1072
1073 while (stverlen > 0)
1074 {
1075 rc_ver_stringinfo *vs;
1076 rc_uint_type sverlen, vslen, valoff;
1077
1078 if (length < 8)
1079 toosmall (_("version string"));
1080
1081 vs = (rc_ver_stringinfo *) res_alloc (sizeof (rc_ver_stringinfo));
1082
1083 get_version_header (wrbfd, data, length, (const char *) NULL,
1084 &vs->key, &sverlen, &vallen, &type, &off);
1085
1086 data += off;
1087 length -= off;
1088
1089 vs->value = get_unicode (wrbfd, data, length, &vslen);
1090 valoff = vslen * 2 + 2;
1091 valoff = (valoff + 3) & ~3;
1092
1093 if (off + valoff != sverlen)
1094 fatal (_("unexpected version string length %ld != %ld + %ld"),
1095 (long) sverlen, (long) off, (long) valoff);
1096
1097 data += valoff;
1098 length -= valoff;
1099
1100 if (stverlen < sverlen)
1101 fatal (_("unexpected version string length %ld < %ld"),
1102 (long) verlen, (long) sverlen);
1103 stverlen -= sverlen;
1104 verlen -= sverlen;
1105
1106 vs->next = NULL;
1107 *ppvs = vs;
1108 ppvs = &vs->next;
1109 }
1110
1111 vst->next = NULL;
1112 *ppvst = vst;
1113 ppvst = &vst->next;
1114 }
1115 }
1116 else if (ch == 'V')
1117 {
1118 rc_ver_varinfo **ppvv;
1119
1120 vi->type = VERINFO_VAR;
1121
1122 get_version_header (wrbfd, data, length, "VarFileInfo",
1123 (unichar **) NULL, &verlen, &vallen, &type,
1124 &off);
1125
1126 if (vallen != 0)
1127 fatal (_("unexpected varfileinfo value length %ld"), (long) vallen);
1128
1129 data += off;
1130 length -= off;
1131
1132 get_version_header (wrbfd, data, length, (const char *) NULL,
1133 &vi->u.var.key, &verlen, &vallen, &type, &off);
1134
1135 data += off;
1136 length -= off;
1137
1138 vi->u.var.var = NULL;
1139 ppvv = &vi->u.var.var;
1140
1141 while (vallen > 0)
1142 {
1143 rc_ver_varinfo *vv;
1144
1145 if (length < 4)
1146 toosmall (_("version varfileinfo"));
1147
1148 vv = (rc_ver_varinfo *) res_alloc (sizeof (rc_ver_varinfo));
1149
1150 vv->language = windres_get_16 (wrbfd, data, 2);
1151 vv->charset = windres_get_16 (wrbfd, data + 2, 2);
1152
1153 vv->next = NULL;
1154 *ppvv = vv;
1155 ppvv = &vv->next;
1156
1157 data += 4;
1158 length -= 4;
1159
1160 if (vallen < 4)
1161 fatal (_("unexpected version value length %ld"), (long) vallen);
1162
1163 vallen -= 4;
1164 }
1165 }
1166 else if (ch == 0)
1167 {
1168 if (length == 8)
1169 /* Padding - skip. */
1170 break;
1171 fatal (_("nul bytes found in version string"));
1172 }
1173 else
1174 fatal (_("unexpected version string character: %x"), ch);
1175
1176 vi->next = NULL;
1177 *pp = vi;
1178 pp = &vi->next;
1179 }
1180
1181 v = (rc_versioninfo *) res_alloc (sizeof (rc_versioninfo));
1182 v->fixed = fi;
1183 v->var = first;
1184
1185 r = (rc_res_resource *) res_alloc (sizeof *r);
1186 r->type = RES_TYPE_VERSIONINFO;
1187 r->u.versioninfo = v;
1188
1189 return r;
1190 }
1191
1192 /* Convert an arbitrary user defined resource from binary. */
1193
1194 static rc_res_resource *
1195 bin_to_res_userdata (windres_bfd *wrbfd ATTRIBUTE_UNUSED, const bfd_byte *data,
1196 rc_uint_type length)
1197 {
1198 rc_rcdata_item *ri;
1199 rc_res_resource *r;
1200
1201 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
1202
1203 ri->next = NULL;
1204 ri->type = RCDATA_BUFFER;
1205 ri->u.buffer.length = length;
1206 ri->u.buffer.data = data;
1207
1208 r = (rc_res_resource *) res_alloc (sizeof *r);
1209 r->type = RES_TYPE_USERDATA;
1210 r->u.rcdata = ri;
1211
1212 return r;
1213 }
1214 \f
1215 static rc_res_resource *
1216 bin_to_res_toolbar (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
1217 {
1218 rc_toolbar *ri;
1219 rc_res_resource *r;
1220 rc_uint_type i;
1221
1222 ri = (rc_toolbar *) res_alloc (sizeof (rc_toolbar));
1223 ri->button_width = windres_get_32 (wrbfd, data, 4);
1224 ri->button_height = windres_get_32 (wrbfd, data + 4, 4);
1225 ri->nitems = windres_get_32 (wrbfd, data + 8, 4);
1226 ri->items = NULL;
1227
1228 data += 12;
1229 length -= 12;
1230 for (i=0 ; i < ri->nitems; i++)
1231 {
1232 rc_toolbar_item *it;
1233 it = (rc_toolbar_item *) res_alloc (sizeof (rc_toolbar_item));
1234 it->id.named = 0;
1235 it->id.u.id = (int) windres_get_32 (wrbfd, data, 4);
1236 it->prev = it->next = NULL;
1237 data += 4;
1238 length -= 4;
1239 if(ri->items) {
1240 rc_toolbar_item *ii = ri->items;
1241 while (ii->next != NULL)
1242 ii = ii->next;
1243 it->prev = ii;
1244 ii->next = it;
1245 }
1246 else
1247 ri->items = it;
1248 }
1249 r = (rc_res_resource *) res_alloc (sizeof *r);
1250 r->type = RES_TYPE_TOOLBAR;
1251 r->u.toolbar = ri;
1252 return r;
1253 }
1254
1255
1256 /* Local functions used to convert resources to binary format. */
1257
1258 static rc_uint_type resid_to_bin (windres_bfd *, rc_uint_type, rc_res_id);
1259 static rc_uint_type unicode_to_bin (windres_bfd *, rc_uint_type, const unichar *);
1260 static rc_uint_type res_to_bin_accelerator (windres_bfd *, rc_uint_type, const rc_accelerator *);
1261 static rc_uint_type res_to_bin_cursor (windres_bfd *, rc_uint_type, const rc_cursor *);
1262 static rc_uint_type res_to_bin_group_cursor (windres_bfd *, rc_uint_type, const rc_group_cursor *);
1263 static rc_uint_type res_to_bin_dialog (windres_bfd *, rc_uint_type, const rc_dialog *);
1264 static rc_uint_type res_to_bin_fontdir (windres_bfd *, rc_uint_type, const rc_fontdir *);
1265 static rc_uint_type res_to_bin_group_icon (windres_bfd *, rc_uint_type, const rc_group_icon *);
1266 static rc_uint_type res_to_bin_menu (windres_bfd *, rc_uint_type, const rc_menu *);
1267 static rc_uint_type res_to_bin_menuitems (windres_bfd *, rc_uint_type, const rc_menuitem *);
1268 static rc_uint_type res_to_bin_menuexitems (windres_bfd *, rc_uint_type, const rc_menuitem *);
1269 static rc_uint_type res_to_bin_rcdata (windres_bfd *, rc_uint_type, const rc_rcdata_item *);
1270 static rc_uint_type res_to_bin_stringtable (windres_bfd *, rc_uint_type, const rc_stringtable *);
1271 static rc_uint_type string_to_unicode_bin (windres_bfd *, rc_uint_type, const char *);
1272 static rc_uint_type res_to_bin_toolbar (windres_bfd *, rc_uint_type, rc_toolbar *tb);
1273 static rc_uint_type res_to_bin_versioninfo (windres_bfd *, rc_uint_type, const rc_versioninfo *);
1274 static rc_uint_type res_to_bin_generic (windres_bfd *, rc_uint_type, rc_uint_type,
1275 const bfd_byte *);
1276
1277 /* Convert a resource to binary. */
1278
1279 rc_uint_type
1280 res_to_bin (windres_bfd *wrbfd, rc_uint_type off, const rc_res_resource *res)
1281 {
1282 switch (res->type)
1283 {
1284 case RES_TYPE_BITMAP:
1285 case RES_TYPE_FONT:
1286 case RES_TYPE_ICON:
1287 case RES_TYPE_MESSAGETABLE:
1288 return res_to_bin_generic (wrbfd, off, res->u.data.length, res->u.data.data);
1289 case RES_TYPE_ACCELERATOR:
1290 return res_to_bin_accelerator (wrbfd, off, res->u.acc);
1291 case RES_TYPE_CURSOR:
1292 return res_to_bin_cursor (wrbfd, off, res->u.cursor);
1293 case RES_TYPE_GROUP_CURSOR:
1294 return res_to_bin_group_cursor (wrbfd, off, res->u.group_cursor);
1295 case RES_TYPE_DIALOG:
1296 return res_to_bin_dialog (wrbfd, off, res->u.dialog);
1297 case RES_TYPE_FONTDIR:
1298 return res_to_bin_fontdir (wrbfd, off, res->u.fontdir);
1299 case RES_TYPE_GROUP_ICON:
1300 return res_to_bin_group_icon (wrbfd, off, res->u.group_icon);
1301 case RES_TYPE_MENU:
1302 return res_to_bin_menu (wrbfd, off, res->u.menu);
1303 case RES_TYPE_STRINGTABLE:
1304 return res_to_bin_stringtable (wrbfd, off, res->u.stringtable);
1305 case RES_TYPE_VERSIONINFO:
1306 return res_to_bin_versioninfo (wrbfd, off, res->u.versioninfo);
1307 case RES_TYPE_TOOLBAR:
1308 return res_to_bin_toolbar (wrbfd, off, res->u.toolbar);
1309 case RES_TYPE_USERDATA:
1310 case RES_TYPE_RCDATA:
1311 default:
1312 return res_to_bin_rcdata (wrbfd, off, res->u.rcdata);
1313 }
1314 }
1315
1316 /* Convert a resource ID to binary. This always returns exactly one
1317 bindata structure. */
1318
1319 static rc_uint_type
1320 resid_to_bin (windres_bfd *wrbfd, rc_uint_type off, rc_res_id id)
1321 {
1322 if (! id.named)
1323 {
1324 if (wrbfd)
1325 {
1326 struct bin_res_id bri;
1327
1328 windres_put_16 (wrbfd, bri.sig, 0xffff);
1329 windres_put_16 (wrbfd, bri.id, id.u.id);
1330 set_windres_bfd_content (wrbfd, &bri, off, BIN_RES_ID);
1331 }
1332 off += BIN_RES_ID;
1333 }
1334 else
1335 {
1336 rc_uint_type len = (id.u.n.name ? unichar_len (id.u.n.name) : 0);
1337 if (wrbfd)
1338 {
1339 bfd_byte *d = (bfd_byte *) reswr_alloc ((len + 1) * sizeof (unichar));
1340 rc_uint_type i;
1341 for (i = 0; i < len; i++)
1342 windres_put_16 (wrbfd, d + (i * sizeof (unichar)), id.u.n.name[i]);
1343 windres_put_16 (wrbfd, d + (len * sizeof (unichar)), 0);
1344 set_windres_bfd_content (wrbfd, d, off, (len + 1) * sizeof (unichar));
1345 }
1346 off += (rc_uint_type) ((len + 1) * sizeof (unichar));
1347 }
1348 return off;
1349 }
1350
1351 /* Convert a null terminated unicode string to binary. This always
1352 returns exactly one bindata structure. */
1353
1354 static rc_uint_type
1355 unicode_to_bin (windres_bfd *wrbfd, rc_uint_type off, const unichar *str)
1356 {
1357 rc_uint_type len = 0;
1358
1359 if (str != NULL)
1360 len = unichar_len (str);
1361
1362 if (wrbfd)
1363 {
1364 bfd_byte *d;
1365 rc_uint_type i;
1366 d = (bfd_byte *) reswr_alloc ( (len + 1) * sizeof (unichar));
1367 for (i = 0; i < len; i++)
1368 windres_put_16 (wrbfd, d + (i * sizeof (unichar)), str[i]);
1369 windres_put_16 (wrbfd, d + (len * sizeof (unichar)), 0);
1370 set_windres_bfd_content (wrbfd, d, off, (len + 1) * sizeof (unichar));
1371 }
1372 off += (rc_uint_type) ((len + 1) * sizeof (unichar));
1373
1374 return off;
1375 }
1376
1377 /* Convert an accelerator resource to binary. */
1378
1379 static rc_uint_type
1380 res_to_bin_accelerator (windres_bfd *wrbfd, rc_uint_type off,
1381 const rc_accelerator *accelerators)
1382 {
1383 const rc_accelerator *a;
1384
1385 for (a = accelerators; a != NULL; a = a->next)
1386 {
1387 if (wrbfd)
1388 {
1389 struct bin_accelerator ba;
1390
1391 windres_put_16 (wrbfd, ba.flags, a->flags | (a->next != NULL ? 0 : ACC_LAST));
1392 windres_put_16 (wrbfd, ba.key, a->key);
1393 windres_put_16 (wrbfd, ba.id, a->id);
1394 windres_put_16 (wrbfd, ba.pad, 0);
1395 set_windres_bfd_content (wrbfd, &ba, off, BIN_ACCELERATOR_SIZE);
1396 }
1397 off += BIN_ACCELERATOR_SIZE;
1398 }
1399 return off;
1400 }
1401
1402 /* Convert a cursor resource to binary. */
1403
1404 static rc_uint_type
1405 res_to_bin_cursor (windres_bfd *wrbfd, rc_uint_type off, const rc_cursor *c)
1406 {
1407 if (wrbfd)
1408 {
1409 struct bin_cursor bc;
1410
1411 windres_put_16 (wrbfd, bc.xhotspot, c->xhotspot);
1412 windres_put_16 (wrbfd, bc.yhotspot, c->yhotspot);
1413 set_windres_bfd_content (wrbfd, &bc, off, BIN_CURSOR_SIZE);
1414 if (c->length)
1415 set_windres_bfd_content (wrbfd, c->data, off + BIN_CURSOR_SIZE, c->length);
1416 }
1417 off = (off + BIN_CURSOR_SIZE + (rc_uint_type) c->length);
1418 return off;
1419 }
1420
1421 /* Convert a group cursor resource to binary. */
1422
1423 static rc_uint_type
1424 res_to_bin_group_cursor (windres_bfd *wrbfd, rc_uint_type off,
1425 const rc_group_cursor *group_cursors)
1426 {
1427 int c = 0;
1428 const rc_group_cursor *gc;
1429 struct bin_group_cursor bgc;
1430 struct bin_group_cursor_item bgci;
1431 rc_uint_type start = off;
1432
1433 off += BIN_GROUP_CURSOR_SIZE;
1434
1435 for (c = 0, gc = group_cursors; gc != NULL; gc = gc->next, c++)
1436 {
1437 if (wrbfd)
1438 {
1439 windres_put_16 (wrbfd, bgci.width, gc->width);
1440 windres_put_16 (wrbfd, bgci.height, gc->height);
1441 windres_put_16 (wrbfd, bgci.planes, gc->planes);
1442 windres_put_16 (wrbfd, bgci.bits, gc->bits);
1443 windres_put_32 (wrbfd, bgci.bytes, gc->bytes);
1444 windres_put_16 (wrbfd, bgci.index, gc->index);
1445 set_windres_bfd_content (wrbfd, &bgci, off, BIN_GROUP_CURSOR_ITEM_SIZE);
1446 }
1447
1448 off += BIN_GROUP_CURSOR_ITEM_SIZE;
1449 }
1450 if (wrbfd)
1451 {
1452 windres_put_16 (wrbfd, bgc.sig1, 0);
1453 windres_put_16 (wrbfd, bgc.sig2, 2);
1454 windres_put_16 (wrbfd, bgc.nitems, c);
1455 set_windres_bfd_content (wrbfd, &bgc, start, BIN_GROUP_CURSOR_SIZE);
1456 }
1457 return off;
1458 }
1459
1460 /* Convert a dialog resource to binary. */
1461
1462 static rc_uint_type
1463 res_to_bin_dialog (windres_bfd *wrbfd, rc_uint_type off, const rc_dialog *dialog)
1464 {
1465 rc_uint_type off_delta;
1466 rc_uint_type start, marker;
1467 int dialogex;
1468 int c;
1469 rc_dialog_control *dc;
1470 struct bin_dialogex bdx;
1471 struct bin_dialog bd;
1472
1473 off_delta = off;
1474 start = off;
1475 dialogex = extended_dialog (dialog);
1476
1477 if (wrbfd)
1478 {
1479 if (! dialogex)
1480 {
1481 windres_put_32 (wrbfd, bd.style, dialog->style);
1482 windres_put_32 (wrbfd, bd.exstyle, dialog->exstyle);
1483 windres_put_16 (wrbfd, bd.x, dialog->x);
1484 windres_put_16 (wrbfd, bd.y, dialog->y);
1485 windres_put_16 (wrbfd, bd.width, dialog->width);
1486 windres_put_16 (wrbfd, bd.height, dialog->height);
1487 }
1488 else
1489 {
1490 windres_put_16 (wrbfd, bdx.sig1, 1);
1491 windres_put_16 (wrbfd, bdx.sig2, 0xffff);
1492 windres_put_32 (wrbfd, bdx.help, (dialog->ex ? dialog->ex->help : 0));
1493 windres_put_32 (wrbfd, bdx.exstyle, dialog->exstyle);
1494 windres_put_32 (wrbfd, bdx.style, dialog->style);
1495 windres_put_16 (wrbfd, bdx.x, dialog->x);
1496 windres_put_16 (wrbfd, bdx.y, dialog->y);
1497 windres_put_16 (wrbfd, bdx.width, dialog->width);
1498 windres_put_16 (wrbfd, bdx.height, dialog->height);
1499 }
1500 }
1501
1502 off += (dialogex != 0 ? BIN_DIALOGEX_SIZE : BIN_DIALOG_SIZE);
1503
1504 off = resid_to_bin (wrbfd, off, dialog->menu);
1505 off = resid_to_bin (wrbfd, off, dialog->class);
1506 off = unicode_to_bin (wrbfd, off, dialog->caption);
1507
1508 if ((dialog->style & DS_SETFONT) != 0)
1509 {
1510 if (wrbfd)
1511 {
1512 if (! dialogex)
1513 {
1514 struct bin_dialogfont bdf;
1515 windres_put_16 (wrbfd, bdf.pointsize, dialog->pointsize);
1516 set_windres_bfd_content (wrbfd, &bdf, off, BIN_DIALOGFONT_SIZE);
1517 }
1518 else
1519 {
1520 struct bin_dialogexfont bdxf;
1521 windres_put_16 (wrbfd, bdxf.pointsize, dialog->pointsize);
1522 windres_put_16 (wrbfd, bdxf.weight, (dialog->ex == NULL ? 0 : dialog->ex->weight));
1523 windres_put_8 (wrbfd, bdxf.italic, (dialog->ex == NULL ? 0 : dialog->ex->italic));
1524 windres_put_8 (wrbfd, bdxf.charset, (dialog->ex == NULL ? 1 : dialog->ex->charset));
1525 set_windres_bfd_content (wrbfd, &bdxf, off, BIN_DIALOGEXFONT_SIZE);
1526 }
1527 }
1528 off += (dialogex ? BIN_DIALOGEXFONT_SIZE : BIN_DIALOGFONT_SIZE);
1529 off = unicode_to_bin (wrbfd, off, dialog->font);
1530 }
1531 for (c = 0, dc = dialog->controls; dc != NULL; dc = dc->next, c++)
1532 {
1533 bfd_byte dc_rclen[2];
1534
1535 off += (4 - ((off - off_delta) & 3)) & 3;
1536 if (wrbfd)
1537 {
1538 if (! dialogex)
1539 {
1540 struct bin_dialog_control bdc;
1541
1542 windres_put_32 (wrbfd, bdc.style, dc->style);
1543 windres_put_32 (wrbfd, bdc.exstyle, dc->exstyle);
1544 windres_put_16 (wrbfd, bdc.x, dc->x);
1545 windres_put_16 (wrbfd, bdc.y, dc->y);
1546 windres_put_16 (wrbfd, bdc.width, dc->width);
1547 windres_put_16 (wrbfd, bdc.height, dc->height);
1548 windres_put_16 (wrbfd, bdc.id, dc->id);
1549 set_windres_bfd_content (wrbfd, &bdc, off, BIN_DIALOG_CONTROL_SIZE);
1550 }
1551 else
1552 {
1553 struct bin_dialogex_control bdc;
1554
1555 windres_put_32 (wrbfd, bdc.help, dc->help);
1556 windres_put_32 (wrbfd, bdc.exstyle, dc->exstyle);
1557 windres_put_32 (wrbfd, bdc.style, dc->style);
1558 windres_put_16 (wrbfd, bdc.x, dc->x);
1559 windres_put_16 (wrbfd, bdc.y, dc->y);
1560 windres_put_16 (wrbfd, bdc.width, dc->width);
1561 windres_put_16 (wrbfd, bdc.height, dc->height);
1562 windres_put_32 (wrbfd, bdc.id, dc->id);
1563 set_windres_bfd_content (wrbfd, &bdc, off, BIN_DIALOGEX_CONTROL_SIZE);
1564 }
1565 }
1566 off += (dialogex != 0 ? BIN_DIALOGEX_CONTROL_SIZE : BIN_DIALOG_CONTROL_SIZE);
1567
1568 off = resid_to_bin (wrbfd, off, dc->class);
1569 off = resid_to_bin (wrbfd, off, dc->text);
1570
1571 marker = off; /* Save two bytes for size of optional data. */
1572 off += 2;
1573
1574 if (dc->data == NULL)
1575 {
1576 if (wrbfd)
1577 windres_put_16 (wrbfd, dc_rclen, 0);
1578 }
1579 else
1580 {
1581 rc_uint_type saved_off = off;
1582 rc_uint_type old_off;
1583
1584 old_off = off;
1585 off = res_to_bin_rcdata (wrbfd, off, dc->data);
1586 if ((off - old_off) == 0)
1587 old_off = off = saved_off;
1588 if (wrbfd)
1589 windres_put_16 (wrbfd, dc_rclen, off - old_off);
1590 }
1591 if (wrbfd)
1592 set_windres_bfd_content (wrbfd, dc_rclen, marker, 2);
1593 }
1594
1595 if (wrbfd)
1596 {
1597 windres_put_16 (wrbfd, (dialogex != 0 ? bdx.off : bd.off), c);
1598 if (! dialogex)
1599 set_windres_bfd_content (wrbfd, &bd, start, BIN_DIALOG_SIZE);
1600 else
1601 set_windres_bfd_content (wrbfd, &bdx, start, BIN_DIALOGEX_SIZE);
1602 }
1603
1604 return off;
1605 }
1606
1607 /* Convert a fontdir resource to binary. */
1608 static rc_uint_type
1609 res_to_bin_fontdir (windres_bfd *wrbfd, rc_uint_type off, const rc_fontdir *fontdirs)
1610 {
1611 rc_uint_type start;
1612 int c;
1613 const rc_fontdir *fd;
1614
1615 start = off;
1616 off += 2;
1617
1618 for (c = 0, fd = fontdirs; fd != NULL; fd = fd->next, c++)
1619 {
1620 if (wrbfd)
1621 {
1622 bfd_byte d[2];
1623 windres_put_16 (wrbfd, d, fd->index);
1624 set_windres_bfd_content (wrbfd, d, off, 2);
1625 if (fd->length)
1626 set_windres_bfd_content (wrbfd, fd->data, off + 2, fd->length);
1627 }
1628 off += (rc_uint_type) fd->length + 2;
1629 }
1630
1631 if (wrbfd)
1632 {
1633 bfd_byte d[2];
1634 windres_put_16 (wrbfd, d, c);
1635 set_windres_bfd_content (wrbfd, d, start, 2);
1636 }
1637 return off;
1638 }
1639
1640 /* Convert a group icon resource to binary. */
1641
1642 static rc_uint_type
1643 res_to_bin_group_icon (windres_bfd *wrbfd, rc_uint_type off, const rc_group_icon *group_icons)
1644 {
1645 rc_uint_type start;
1646 struct bin_group_icon bgi;
1647 int c;
1648 const rc_group_icon *gi;
1649
1650 start = off;
1651 off += BIN_GROUP_ICON_SIZE;
1652
1653 for (c = 0, gi = group_icons; gi != NULL; gi = gi->next, c++)
1654 {
1655 struct bin_group_icon_item bgii;
1656
1657 if (wrbfd)
1658 {
1659 windres_put_8 (wrbfd, bgii.width, gi->width);
1660 windres_put_8 (wrbfd, bgii.height, gi->height);
1661 windres_put_8 (wrbfd, bgii.colors, gi->colors);
1662 windres_put_8 (wrbfd, bgii.pad, 0);
1663 windres_put_16 (wrbfd, bgii.planes, gi->planes);
1664 windres_put_16 (wrbfd, bgii.bits, gi->bits);
1665 windres_put_32 (wrbfd, bgii.bytes, gi->bytes);
1666 windres_put_16 (wrbfd, bgii.index, gi->index);
1667 set_windres_bfd_content (wrbfd, &bgii, off, BIN_GROUP_ICON_ITEM_SIZE);
1668 }
1669 off += BIN_GROUP_ICON_ITEM_SIZE;
1670 }
1671
1672 if (wrbfd)
1673 {
1674 windres_put_16 (wrbfd, bgi.sig1, 0);
1675 windres_put_16 (wrbfd, bgi.sig2, 1);
1676 windres_put_16 (wrbfd, bgi.count, c);
1677 set_windres_bfd_content (wrbfd, &bgi, start, BIN_GROUP_ICON_SIZE);
1678 }
1679 return off;
1680 }
1681
1682 /* Convert a menu resource to binary. */
1683
1684 static rc_uint_type
1685 res_to_bin_menu (windres_bfd *wrbfd, rc_uint_type off, const rc_menu *menu)
1686 {
1687 int menuex;
1688
1689 menuex = extended_menu (menu);
1690
1691 if (wrbfd)
1692 {
1693 if (! menuex)
1694 {
1695 struct bin_menu bm;
1696 windres_put_16 (wrbfd, bm.sig1, 0);
1697 windres_put_16 (wrbfd, bm.sig2, 0);
1698 set_windres_bfd_content (wrbfd, &bm, off, BIN_MENU_SIZE);
1699 }
1700 else
1701 {
1702 struct bin_menuex bm;
1703 windres_put_16 (wrbfd, bm.sig1, 1);
1704 windres_put_16 (wrbfd, bm.sig2, 4);
1705 windres_put_32 (wrbfd, bm.help, menu->help);
1706 set_windres_bfd_content (wrbfd, &bm, off, BIN_MENUEX_SIZE);
1707 }
1708 }
1709 off += (menuex != 0 ? BIN_MENUEX_SIZE : BIN_MENU_SIZE);
1710 if (! menuex)
1711 {
1712 off = res_to_bin_menuitems (wrbfd, off, menu->items);
1713 }
1714 else
1715 {
1716 off = res_to_bin_menuexitems (wrbfd, off, menu->items);
1717 }
1718 return off;
1719 }
1720
1721 /* Convert menu items to binary. */
1722
1723 static rc_uint_type
1724 res_to_bin_menuitems (windres_bfd *wrbfd, rc_uint_type off, const rc_menuitem *items)
1725 {
1726 const rc_menuitem *mi;
1727
1728 for (mi = items; mi != NULL; mi = mi->next)
1729 {
1730 struct bin_menuitem bmi;
1731 int flags;
1732
1733 flags = mi->type;
1734 if (mi->next == NULL)
1735 flags |= MENUITEM_ENDMENU;
1736 if (mi->popup != NULL)
1737 flags |= MENUITEM_POPUP;
1738
1739 if (wrbfd)
1740 {
1741 windres_put_16 (wrbfd, bmi.flags, flags);
1742 if (mi->popup == NULL)
1743 windres_put_16 (wrbfd, bmi.id, mi->id);
1744 set_windres_bfd_content (wrbfd, &bmi, off,
1745 mi->popup == NULL ? BIN_MENUITEM_SIZE
1746 : BIN_MENUITEM_POPUP_SIZE);
1747 }
1748 off += (mi->popup == NULL ? BIN_MENUITEM_SIZE : BIN_MENUITEM_POPUP_SIZE);
1749
1750 off = unicode_to_bin (wrbfd, off, mi->text);
1751
1752 if (mi->popup != NULL)
1753 {
1754 off = res_to_bin_menuitems (wrbfd, off, mi->popup);
1755 }
1756 }
1757 return off;
1758 }
1759
1760 /* Convert menuex items to binary. */
1761
1762 static rc_uint_type
1763 res_to_bin_menuexitems (windres_bfd *wrbfd, rc_uint_type off, const rc_menuitem *items)
1764 {
1765 rc_uint_type off_delta = off;
1766 const rc_menuitem *mi;
1767
1768 for (mi = items; mi != NULL; mi = mi->next)
1769 {
1770 struct bin_menuitemex bmi;
1771 int flags;
1772
1773 off += (4 - ((off - off_delta) & 3)) & 3;
1774
1775 flags = 0;
1776 if (mi->next == NULL)
1777 flags |= 0x80;
1778 if (mi->popup != NULL)
1779 flags |= 1;
1780
1781 if (wrbfd)
1782 {
1783 windres_put_32 (wrbfd, bmi.type, mi->type);
1784 windres_put_32 (wrbfd, bmi.state, mi->state);
1785 windres_put_32 (wrbfd, bmi.id, mi->id);
1786 windres_put_16 (wrbfd, bmi.flags, flags);
1787 set_windres_bfd_content (wrbfd, &bmi, off, BIN_MENUITEMEX_SIZE);
1788 }
1789 off += BIN_MENUITEMEX_SIZE;
1790
1791 off = unicode_to_bin (wrbfd, off, mi->text);
1792
1793 if (mi->popup != NULL)
1794 {
1795 bfd_byte help[4];
1796
1797 off += (4 - ((off - off_delta) & 3)) & 3;
1798
1799 if (wrbfd)
1800 {
1801 windres_put_32 (wrbfd, help, mi->help);
1802 set_windres_bfd_content (wrbfd, help, off, 4);
1803 }
1804 off += 4;
1805 off = res_to_bin_menuexitems (wrbfd, off, mi->popup);
1806 }
1807 }
1808 return off;
1809 }
1810
1811 /* Convert an rcdata resource to binary. This is also used to convert
1812 other information which happens to be stored in rc_rcdata_item lists
1813 to binary. */
1814
1815 static rc_uint_type
1816 res_to_bin_rcdata (windres_bfd *wrbfd, rc_uint_type off, const rc_rcdata_item *items)
1817 {
1818 const rc_rcdata_item *ri;
1819
1820 for (ri = items; ri != NULL; ri = ri->next)
1821 {
1822 rc_uint_type len;
1823 switch (ri->type)
1824 {
1825 default:
1826 abort ();
1827 case RCDATA_WORD:
1828 len = 2;
1829 break;
1830 case RCDATA_DWORD:
1831 len = 4;
1832 break;
1833 case RCDATA_STRING:
1834 len = ri->u.string.length;
1835 break;
1836 case RCDATA_WSTRING:
1837 len = ri->u.wstring.length * sizeof (unichar);
1838 break;
1839 case RCDATA_BUFFER:
1840 len = ri->u.buffer.length;
1841 break;
1842 }
1843 if (wrbfd)
1844 {
1845 bfd_byte h[4];
1846 bfd_byte *hp = &h[0];
1847 switch (ri->type)
1848 {
1849 case RCDATA_WORD:
1850 windres_put_16 (wrbfd, hp, ri->u.word);
1851 break;
1852 case RCDATA_DWORD:
1853 windres_put_32 (wrbfd, hp, ri->u.dword);
1854 break;
1855 case RCDATA_STRING:
1856 hp = (bfd_byte *) ri->u.string.s;
1857 break;
1858 case RCDATA_WSTRING:
1859 {
1860 rc_uint_type i;
1861
1862 hp = (bfd_byte *) reswr_alloc (len);
1863 for (i = 0; i < ri->u.wstring.length; i++)
1864 windres_put_16 (wrbfd, hp + i * sizeof (unichar), ri->u.wstring.w[i]);
1865 }
1866 break;
1867 case RCDATA_BUFFER:
1868 hp = (bfd_byte *) ri->u.buffer.data;
1869 break;
1870 }
1871 set_windres_bfd_content (wrbfd, hp, off, len);
1872 }
1873 off += len;
1874 }
1875 return off;
1876 }
1877
1878 /* Convert a stringtable resource to binary. */
1879
1880 static rc_uint_type
1881 res_to_bin_stringtable (windres_bfd *wrbfd, rc_uint_type off,
1882 const rc_stringtable *st)
1883 {
1884 int i;
1885
1886 for (i = 0; i < 16; i++)
1887 {
1888 rc_uint_type slen, length;
1889 unichar *s;
1890
1891 slen = (rc_uint_type) st->strings[i].length;
1892 if (slen == 0xffffffff) slen = 0;
1893 s = st->strings[i].string;
1894
1895 length = 2 + slen * 2;
1896 if (wrbfd)
1897 {
1898 bfd_byte *hp;
1899 rc_uint_type j;
1900
1901 hp = (bfd_byte *) reswr_alloc (length);
1902 windres_put_16 (wrbfd, hp, slen);
1903
1904 for (j = 0; j < slen; j++)
1905 windres_put_16 (wrbfd, hp + 2 + j * 2, s[j]);
1906 set_windres_bfd_content (wrbfd, hp, off, length);
1907 }
1908 off += length;
1909 }
1910 return off;
1911 }
1912
1913 /* Convert an ASCII string to a unicode binary string. This always
1914 returns exactly one bindata structure. */
1915
1916 static rc_uint_type
1917 string_to_unicode_bin (windres_bfd *wrbfd, rc_uint_type off, const char *s)
1918 {
1919 rc_uint_type len;
1920
1921 len = (rc_uint_type) strlen (s);
1922
1923 if (wrbfd)
1924 {
1925 rc_uint_type i;
1926 bfd_byte *hp;
1927
1928 hp = (bfd_byte *) reswr_alloc ((len + 1) * sizeof (unichar));
1929
1930 for (i = 0; i < len; i++)
1931 windres_put_16 (wrbfd, hp + i * 2, s[i]);
1932 windres_put_16 (wrbfd, hp + i * 2, 0);
1933 set_windres_bfd_content (wrbfd, hp, off, (len + 1) * sizeof (unichar));
1934 }
1935 off += (rc_uint_type) ((len + 1) * sizeof (unichar));
1936 return off;
1937 }
1938
1939 static rc_uint_type
1940 res_to_bin_toolbar (windres_bfd *wrbfd, rc_uint_type off, rc_toolbar *tb)
1941 {
1942 if (wrbfd)
1943 {
1944 struct bin_toolbar bt;
1945 windres_put_32 (wrbfd, bt.button_width, tb->button_width);
1946 windres_put_32 (wrbfd, bt.button_height, tb->button_height);
1947 windres_put_32 (wrbfd, bt.nitems, tb->nitems);
1948 set_windres_bfd_content (wrbfd, &bt, off, BIN_TOOLBAR_SIZE);
1949 if (tb->nitems > 0)
1950 {
1951 rc_toolbar_item *it;
1952 bfd_byte *ids;
1953 rc_uint_type i = 0;
1954
1955 ids = (bfd_byte *) reswr_alloc (tb->nitems * 4);
1956 it=tb->items;
1957 while(it != NULL)
1958 {
1959 windres_put_32 (wrbfd, ids + i, it->id.u.id);
1960 i += 4;
1961 it = it->next;
1962 }
1963 set_windres_bfd_content (wrbfd, ids, off + BIN_TOOLBAR_SIZE, i);
1964 }
1965 }
1966 off += BIN_TOOLBAR_SIZE + tb->nitems * 4;
1967
1968 return off;
1969 }
1970
1971 /* Convert a versioninfo resource to binary. */
1972
1973 static rc_uint_type
1974 res_to_bin_versioninfo (windres_bfd *wrbfd, rc_uint_type off,
1975 const rc_versioninfo *versioninfo)
1976 {
1977 rc_uint_type off_delta = off;
1978 rc_uint_type start;
1979 struct bin_versioninfo bvi;
1980 rc_ver_info *vi;
1981
1982 start = off;
1983 off += BIN_VERSIONINFO_SIZE;
1984 off = string_to_unicode_bin (wrbfd, off, "VS_VERSION_INFO");
1985 off += (4 - ((off - off_delta) & 3)) & 3;
1986
1987 if (versioninfo->fixed != NULL)
1988 {
1989 if (wrbfd)
1990 {
1991 struct bin_fixed_versioninfo bfv;
1992 const rc_fixed_versioninfo *fi;
1993
1994 fi = versioninfo->fixed;
1995 windres_put_32 (wrbfd, bfv.sig1, 0xfeef04bd);
1996 windres_put_32 (wrbfd, bfv.sig2, 0x10000);
1997 windres_put_32 (wrbfd, bfv.file_version, fi->file_version_ms);
1998 windres_put_32 (wrbfd, bfv.file_version_ls, fi->file_version_ls);
1999 windres_put_32 (wrbfd, bfv.product_version_ms, fi->product_version_ms);
2000 windres_put_32 (wrbfd, bfv.product_version_ls, fi->product_version_ls);
2001 windres_put_32 (wrbfd, bfv.file_flags_mask, fi->file_flags_mask);
2002 windres_put_32 (wrbfd, bfv.file_flags, fi->file_flags);
2003 windres_put_32 (wrbfd, bfv.file_os, fi->file_os);
2004 windres_put_32 (wrbfd, bfv.file_type, fi->file_type);
2005 windres_put_32 (wrbfd, bfv.file_subtype, fi->file_subtype);
2006 windres_put_32 (wrbfd, bfv.file_date_ms, fi->file_date_ms);
2007 windres_put_32 (wrbfd, bfv.file_date_ls, fi->file_date_ls);
2008 set_windres_bfd_content (wrbfd, &bfv, off, BIN_FIXED_VERSIONINFO_SIZE);
2009 }
2010 off += BIN_FIXED_VERSIONINFO_SIZE;
2011 }
2012
2013 for (vi = versioninfo->var; vi != NULL; vi = vi->next)
2014 {
2015 struct bin_ver_info bv;
2016 rc_uint_type bv_off;
2017
2018 off += (4 - ((off - off_delta) & 3)) & 3;
2019
2020 bv_off = off;
2021
2022 off += BIN_VER_INFO_SIZE;
2023
2024 switch (vi->type)
2025 {
2026 default:
2027 abort ();
2028 case VERINFO_STRING:
2029 {
2030 const rc_ver_stringtable *vst;
2031
2032 off = string_to_unicode_bin (wrbfd, off, "StringFileInfo");
2033
2034 if (!vi->u.string.stringtables)
2035 off += (4 - ((off - off_delta) & 3)) & 3;
2036
2037 for (vst = vi->u.string.stringtables; vst != NULL; vst = vst->next)
2038 {
2039 struct bin_ver_info bvst;
2040 rc_uint_type vst_off;
2041 const rc_ver_stringinfo *vs;
2042
2043 off += (4 - ((off - off_delta) & 3)) & 3;
2044
2045 vst_off = off;
2046 off += BIN_VER_INFO_SIZE;
2047
2048 off = unicode_to_bin (wrbfd, off, vst->language);
2049
2050 for (vs = vst->strings; vs != NULL; vs = vs->next)
2051 {
2052 struct bin_ver_info bvs;
2053 rc_uint_type vs_off, str_off;
2054
2055 off += (4 - ((off - off_delta) & 3)) & 3;
2056
2057 vs_off = off;
2058 off += BIN_VER_INFO_SIZE;
2059
2060 off = unicode_to_bin (wrbfd, off, vs->key);
2061
2062 off += (4 - ((off - off_delta) & 3)) & 3;
2063
2064 str_off = off;
2065 off = unicode_to_bin (wrbfd, off, vs->value);
2066
2067 if (wrbfd)
2068 {
2069 windres_put_16 (wrbfd, bvs.size, off - vs_off);
2070 windres_put_16 (wrbfd, bvs.sig1, (off - str_off) / 2);
2071 windres_put_16 (wrbfd, bvs.sig2, 1);
2072 set_windres_bfd_content (wrbfd, &bvs, vs_off,
2073 BIN_VER_INFO_SIZE);
2074 }
2075 }
2076
2077 if (wrbfd)
2078 {
2079 windres_put_16 (wrbfd, bvst.size, off - vst_off);
2080 windres_put_16 (wrbfd, bvst.sig1, 0);
2081 windres_put_16 (wrbfd, bvst.sig2, 1);
2082 set_windres_bfd_content (wrbfd, &bvst, vst_off,
2083 BIN_VER_INFO_SIZE);
2084 }
2085 }
2086 break;
2087 }
2088
2089 case VERINFO_VAR:
2090 {
2091 rc_uint_type vvd_off, vvvd_off;
2092 struct bin_ver_info bvvd;
2093 const rc_ver_varinfo *vv;
2094
2095 off = string_to_unicode_bin (wrbfd, off, "VarFileInfo");
2096
2097 off += (4 - ((off - off_delta) & 3)) & 3;
2098
2099 vvd_off = off;
2100 off += BIN_VER_INFO_SIZE;
2101
2102 off = unicode_to_bin (wrbfd, off, vi->u.var.key);
2103
2104 off += (4 - ((off - off_delta) & 3)) & 3;
2105
2106 vvvd_off = off;
2107
2108 for (vv = vi->u.var.var; vv != NULL; vv = vv->next)
2109 {
2110 if (wrbfd)
2111 {
2112 bfd_byte vvsd[4];
2113
2114 windres_put_16 (wrbfd, &vvsd[0], vv->language);
2115 windres_put_16 (wrbfd, &vvsd[2], vv->charset);
2116 set_windres_bfd_content (wrbfd, vvsd, off, 4);
2117 }
2118 off += 4;
2119 }
2120 if (wrbfd)
2121 {
2122 windres_put_16 (wrbfd, bvvd.size, off - vvd_off);
2123 windres_put_16 (wrbfd, bvvd.sig1, off - vvvd_off);
2124 windres_put_16 (wrbfd, bvvd.sig2, 0);
2125 set_windres_bfd_content (wrbfd, &bvvd, vvd_off,
2126 BIN_VER_INFO_SIZE);
2127 }
2128
2129 break;
2130 }
2131 }
2132
2133 if (wrbfd)
2134 {
2135 windres_put_16 (wrbfd, bv.size, off - bv_off);
2136 windres_put_16 (wrbfd, bv.sig1, 0);
2137 windres_put_16 (wrbfd, bv.sig2, 1);
2138 set_windres_bfd_content (wrbfd, &bv, bv_off,
2139 BIN_VER_INFO_SIZE);
2140 }
2141 }
2142
2143 if (wrbfd)
2144 {
2145 windres_put_16 (wrbfd, bvi.size, off - start);
2146 windres_put_16 (wrbfd, bvi.fixed_size,
2147 versioninfo->fixed == NULL ? 0
2148 : BIN_FIXED_VERSIONINFO_SIZE);
2149 windres_put_16 (wrbfd, bvi.sig2, 0);
2150 set_windres_bfd_content (wrbfd, &bvi, start, BIN_VER_INFO_SIZE);
2151 }
2152 return off;
2153 }
2154
2155 /* Convert a generic resource to binary. */
2156
2157 static rc_uint_type
2158 res_to_bin_generic (windres_bfd *wrbfd, rc_uint_type off, rc_uint_type length,
2159 const bfd_byte *data)
2160 {
2161 if (wrbfd && length != 0)
2162 set_windres_bfd_content (wrbfd, data, off, length);
2163 return off + (rc_uint_type) length;
2164 }