OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [resbin.c] - Blame information for rev 847

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.