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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [resbin.c] - Blame information for rev 265

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

Line No. Rev Author Line
1 15 khays 
/* resbin.c -- manipulate the Windows binary resource format.
2 163 khays 
   Copyright 1997, 1998, 1999, 2002, 2003, 2005, 2006, 2007, 2009, 2010, 2011
3 15 khays 
   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, got;
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, &got);
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), &got);
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 *got)
274 
{
275 
  rc_menuitem *first, **pp;
276 
 
277 
  first = NULL;
278 
  pp = &first;
279 
 
280 
  *got = 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 
      *got += 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 *got)
351 
{
352 
  rc_menuitem *first, **pp;
353 
 
354 
  first = NULL;
355 
  pp = &first;
356 
 
357 
  *got = 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 
      *got += 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 163 khays 
          rc_ver_stringtable **ppvst;
1031 15 khays 
 
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 
          /* It's convenient to round verlen to a 4 byte alignment,
1045 
             since we round the subvariables in the loop.  */
1046 163 khays 
 
1047 15 khays 
          verlen = (verlen + 3) &~ 3;
1048 
 
1049 163 khays 
          vi->u.string.stringtables = NULL;
1050 
          ppvst = &vi->u.string.stringtables;
1051 
 
1052 15 khays 
          while (verlen > 0)
1053 
            {
1054 163 khays 
              rc_ver_stringtable *vst;
1055 
              rc_uint_type stverlen;
1056 
              rc_ver_stringinfo **ppvs;
1057 
 
1058 
              if (length < 8)
1059 
                toosmall (_("version stringtable"));
1060 
 
1061 
              vst = (rc_ver_stringtable *) res_alloc (sizeof (rc_ver_stringtable));
1062 
 
1063 
              get_version_header (wrbfd, data, length, (const char *) NULL,
1064 
                                  &vst->language, &stverlen, &vallen, &type, &off);
1065 
 
1066 
              if (vallen != 0)
1067 
                fatal (_("unexpected version stringtable value length %ld"), (long) vallen);
1068 
 
1069 
              data += off;
1070 
              length -= off;
1071 
              verlen -= off;
1072 
 
1073 
          stverlen = (stverlen + 3) &~ 3;
1074 
 
1075 
          vst->strings = NULL;
1076 
          ppvs = &vst->strings;
1077 
 
1078 
          while (stverlen > 0)
1079 
            {
1080 15 khays 
              rc_ver_stringinfo *vs;
1081 163 khays 
              rc_uint_type sverlen, vslen, valoff;
1082 15 khays 
 
1083 163 khays 
              if (length < 8)
1084 
                toosmall (_("version string"));
1085 15 khays 
 
1086 163 khays 
              vs = (rc_ver_stringinfo *) res_alloc (sizeof (rc_ver_stringinfo));
1087 15 khays 
 
1088 163 khays 
              get_version_header (wrbfd, data, length, (const char *) NULL,
1089 
                                  &vs->key, &sverlen, &vallen, &type, &off);
1090 15 khays 
 
1091 163 khays 
              sverlen = (sverlen + 3) &~ 3;
1092 
 
1093 15 khays 
              data += off;
1094 
              length -= off;
1095 
 
1096 
              vs->value = get_unicode (wrbfd, data, length, &vslen);
1097 
              valoff = vslen * 2 + 2;
1098 
              valoff = (valoff + 3) &~ 3;
1099 
 
1100 163 khays 
              if (off + valoff != sverlen)
1101 15 khays 
                fatal (_("unexpected version string length %ld != %ld + %ld"),
1102 163 khays 
                       (long) sverlen, (long) off, (long) valoff);
1103 15 khays 
 
1104 
              data += valoff;
1105 
              length -= valoff;
1106 
 
1107 163 khays 
              if (stverlen < sverlen)
1108 15 khays 
                fatal (_("unexpected version string length %ld < %ld"),
1109 163 khays 
                       (long) verlen, (long) sverlen);
1110 
              stverlen -= sverlen;
1111 15 khays 
 
1112 163 khays 
              vs->next = NULL;
1113 
              *ppvs = vs;
1114 
              ppvs = &vs->next;
1115 15 khays 
            }
1116 163 khays 
 
1117 
          vst->next = NULL;
1118 
          *ppvst = vst;
1119 
          ppvst = &vst->next;
1120 
            }
1121 15 khays 
        }
1122 
      else if (ch == 'V')
1123 
        {
1124 
          rc_ver_varinfo **ppvv;
1125 
 
1126 
          vi->type = VERINFO_VAR;
1127 
 
1128 
          get_version_header (wrbfd, data, length, "VarFileInfo",
1129 
                              (unichar **) NULL, &verlen, &vallen, &type,
1130 
                              &off);
1131 
 
1132 
          if (vallen != 0)
1133 
            fatal (_("unexpected varfileinfo value length %ld"), (long) vallen);
1134 
 
1135 
          data += off;
1136 
          length -= off;
1137 
 
1138 
          get_version_header (wrbfd, data, length, (const char *) NULL,
1139 
                              &vi->u.var.key, &verlen, &vallen, &type, &off);
1140 
 
1141 
          data += off;
1142 
          length -= off;
1143 
 
1144 
          vi->u.var.var = NULL;
1145 
          ppvv = &vi->u.var.var;
1146 
 
1147 
          while (vallen > 0)
1148 
            {
1149 
              rc_ver_varinfo *vv;
1150 
 
1151 
              if (length < 4)
1152 
                toosmall (_("version varfileinfo"));
1153 
 
1154 
              vv = (rc_ver_varinfo *) res_alloc (sizeof (rc_ver_varinfo));
1155 
 
1156 
              vv->language = windres_get_16 (wrbfd, data, 2);
1157 
              vv->charset = windres_get_16 (wrbfd, data + 2, 2);
1158 
 
1159 
              vv->next = NULL;
1160 
              *ppvv = vv;
1161 
              ppvv = &vv->next;
1162 
 
1163 
              data += 4;
1164 
              length -= 4;
1165 
 
1166 
              if (vallen < 4)
1167 
                fatal (_("unexpected version value length %ld"), (long) vallen);
1168 
 
1169 
              vallen -= 4;
1170 
            }
1171 
        }
1172 
      else
1173 
        fatal (_("unexpected version string"));
1174 
 
1175 
      vi->next = NULL;
1176 
      *pp = vi;
1177 
      pp = &vi->next;
1178 
    }
1179 
 
1180 
  v = (rc_versioninfo *) res_alloc (sizeof (rc_versioninfo));
1181 
  v->fixed = fi;
1182 
  v->var = first;
1183 
 
1184 
  r = (rc_res_resource *) res_alloc (sizeof *r);
1185 
  r->type = RES_TYPE_VERSIONINFO;
1186 
  r->u.versioninfo = v;
1187 
 
1188 
  return r;
1189 
}
1190 
 
1191 
/* Convert an arbitrary user defined resource from binary.  */
1192 
 
1193 
static rc_res_resource *
1194 
bin_to_res_userdata (windres_bfd *wrbfd ATTRIBUTE_UNUSED, const bfd_byte *data,
1195 
                     rc_uint_type length)
1196 
{
1197 
  rc_rcdata_item *ri;
1198 
  rc_res_resource *r;
1199 
 
1200 
  ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
1201 
 
1202 
  ri->next = NULL;
1203 
  ri->type = RCDATA_BUFFER;
1204 
  ri->u.buffer.length = length;
1205 
  ri->u.buffer.data = data;
1206 
 
1207 
  r = (rc_res_resource *) res_alloc (sizeof *r);
1208 
  r->type = RES_TYPE_USERDATA;
1209 
  r->u.rcdata = ri;
1210 
 
1211 
  return r;
1212 
}
1213 
 
1214 
static rc_res_resource *
1215 
bin_to_res_toolbar (windres_bfd *wrbfd, const bfd_byte *data, rc_uint_type length)
1216 
{
1217 
  rc_toolbar *ri;
1218 
  rc_res_resource *r;
1219 
  rc_uint_type i;
1220 
 
1221 
  ri = (rc_toolbar *) res_alloc (sizeof (rc_toolbar));
1222 
  ri->button_width = windres_get_32 (wrbfd, data, 4);
1223 
  ri->button_height = windres_get_32 (wrbfd, data + 4, 4);
1224 
  ri->nitems = windres_get_32 (wrbfd, data + 8, 4);
1225 
  ri->items = NULL;
1226 
 
1227 
  data += 12;
1228 
  length -= 12;
1229 
  for (i=0 ; i < ri->nitems; i++)
1230 
  {
1231 
    rc_toolbar_item *it;
1232 
    it = (rc_toolbar_item *) res_alloc (sizeof (rc_toolbar_item));
1233 
    it->id.named = 0;
1234 
    it->id.u.id = (int) windres_get_32 (wrbfd, data, 4);
1235 
    it->prev = it->next = NULL;
1236 
    data += 4;
1237 
    length -= 4;
1238 
    if(ri->items) {
1239 
      rc_toolbar_item *ii = ri->items;
1240 
      while (ii->next != NULL)
1241 
        ii = ii->next;
1242 
      it->prev = ii;
1243 
      ii->next = it;
1244 
    }
1245 
    else
1246 
      ri->items = it;
1247 
  }
1248 
  r = (rc_res_resource *) res_alloc (sizeof *r);
1249 
  r->type = RES_TYPE_TOOLBAR;
1250 
  r->u.toolbar = ri;
1251 
  return r;
1252 
}
1253 
 
1254 
 
1255 
/* Local functions used to convert resources to binary format.  */
1256 
 
1257 
static rc_uint_type resid_to_bin (windres_bfd *, rc_uint_type, rc_res_id);
1258 
static rc_uint_type unicode_to_bin (windres_bfd *, rc_uint_type, const unichar *);
1259 
static rc_uint_type res_to_bin_accelerator (windres_bfd *, rc_uint_type, const rc_accelerator *);
1260 
static rc_uint_type res_to_bin_cursor (windres_bfd *, rc_uint_type, const rc_cursor *);
1261 
static rc_uint_type res_to_bin_group_cursor (windres_bfd *, rc_uint_type, const rc_group_cursor *);
1262 
static rc_uint_type res_to_bin_dialog (windres_bfd *, rc_uint_type, const rc_dialog *);
1263 
static rc_uint_type res_to_bin_fontdir (windres_bfd *, rc_uint_type, const rc_fontdir *);
1264 
static rc_uint_type res_to_bin_group_icon (windres_bfd *, rc_uint_type, const rc_group_icon *);
1265 
static rc_uint_type res_to_bin_menu (windres_bfd *, rc_uint_type, const rc_menu *);
1266 
static rc_uint_type res_to_bin_menuitems (windres_bfd *, rc_uint_type, const rc_menuitem *);
1267 
static rc_uint_type res_to_bin_menuexitems (windres_bfd *, rc_uint_type, const rc_menuitem *);
1268 
static rc_uint_type res_to_bin_rcdata (windres_bfd *, rc_uint_type, const rc_rcdata_item *);
1269 
static rc_uint_type res_to_bin_stringtable (windres_bfd *, rc_uint_type, const rc_stringtable *);
1270 
static rc_uint_type string_to_unicode_bin (windres_bfd *, rc_uint_type, const char *);
1271 
static rc_uint_type res_to_bin_toolbar (windres_bfd *, rc_uint_type, rc_toolbar *tb);
1272 
static rc_uint_type res_to_bin_versioninfo (windres_bfd *, rc_uint_type, const rc_versioninfo *);
1273 
static rc_uint_type res_to_bin_generic (windres_bfd *, rc_uint_type, rc_uint_type,
1274 
                                        const bfd_byte *);
1275 
 
1276 
/* Convert a resource to binary.  */
1277 
 
1278 
rc_uint_type
1279 
res_to_bin (windres_bfd *wrbfd, rc_uint_type off, const rc_res_resource *res)
1280 
{
1281 
  switch (res->type)
1282 
    {
1283 
    case RES_TYPE_BITMAP:
1284 
    case RES_TYPE_FONT:
1285 
    case RES_TYPE_ICON:
1286 
    case RES_TYPE_MESSAGETABLE:
1287 
      return res_to_bin_generic (wrbfd, off, res->u.data.length, res->u.data.data);
1288 
    case RES_TYPE_ACCELERATOR:
1289 
      return res_to_bin_accelerator (wrbfd, off, res->u.acc);
1290 
    case RES_TYPE_CURSOR:
1291 
      return res_to_bin_cursor (wrbfd, off, res->u.cursor);
1292 
    case RES_TYPE_GROUP_CURSOR:
1293 
      return res_to_bin_group_cursor (wrbfd, off, res->u.group_cursor);
1294 
    case RES_TYPE_DIALOG:
1295 
      return res_to_bin_dialog (wrbfd, off, res->u.dialog);
1296 
    case RES_TYPE_FONTDIR:
1297 
      return res_to_bin_fontdir (wrbfd, off, res->u.fontdir);
1298 
    case RES_TYPE_GROUP_ICON:
1299 
      return res_to_bin_group_icon (wrbfd, off, res->u.group_icon);
1300 
    case RES_TYPE_MENU:
1301 
      return res_to_bin_menu (wrbfd, off, res->u.menu);
1302 
    case RES_TYPE_STRINGTABLE:
1303 
      return res_to_bin_stringtable (wrbfd, off, res->u.stringtable);
1304 
    case RES_TYPE_VERSIONINFO:
1305 
      return res_to_bin_versioninfo (wrbfd, off, res->u.versioninfo);
1306 
    case RES_TYPE_TOOLBAR:
1307 
      return res_to_bin_toolbar (wrbfd, off, res->u.toolbar);
1308 
    case RES_TYPE_USERDATA:
1309 
    case RES_TYPE_RCDATA:
1310 
    default:
1311 
      return res_to_bin_rcdata (wrbfd, off, res->u.rcdata);
1312 
    }
1313 
}
1314 
 
1315 
/* Convert a resource ID to binary.  This always returns exactly one
1316 
   bindata structure.  */
1317 
 
1318 
static rc_uint_type
1319 
resid_to_bin (windres_bfd *wrbfd, rc_uint_type off, rc_res_id id)
1320 
{
1321 
  if (! id.named)
1322 
    {
1323 
      if (wrbfd)
1324 
        {
1325 
          struct bin_res_id bri;
1326 
 
1327 
          windres_put_16 (wrbfd, bri.sig, 0xffff);
1328 
          windres_put_16 (wrbfd, bri.id, id.u.id);
1329 
          set_windres_bfd_content (wrbfd, &bri, off, BIN_RES_ID);
1330 
        }
1331 
      off += BIN_RES_ID;
1332 
    }
1333 
  else
1334 
    {
1335 
      rc_uint_type len = (id.u.n.name ? unichar_len (id.u.n.name) : 0);
1336 
      if (wrbfd)
1337 
        {
1338 
          bfd_byte *d = (bfd_byte *) reswr_alloc ((len + 1) * sizeof (unichar));
1339 
          rc_uint_type i;
1340 
          for (i = 0; i < len; i++)
1341 
            windres_put_16 (wrbfd, d + (i * sizeof (unichar)), id.u.n.name[i]);
1342 
          windres_put_16 (wrbfd, d + (len * sizeof (unichar)), 0);
1343 
          set_windres_bfd_content (wrbfd, d, off, (len + 1) * sizeof (unichar));
1344 
    }
1345 
      off += (rc_uint_type) ((len + 1) * sizeof (unichar));
1346 
    }
1347 
  return off;
1348 
}
1349 
 
1350 
/* Convert a null terminated unicode string to binary.  This always
1351 
   returns exactly one bindata structure.  */
1352 
 
1353 
static rc_uint_type
1354 
unicode_to_bin (windres_bfd *wrbfd, rc_uint_type off, const unichar *str)
1355 
{
1356 
  rc_uint_type len = 0;
1357 
 
1358 
  if (str != NULL)
1359 
    len = unichar_len (str);
1360 
 
1361 
  if (wrbfd)
1362 
    {
1363 
      bfd_byte *d;
1364 
      rc_uint_type i;
1365 
      d = (bfd_byte *) reswr_alloc ( (len + 1) * sizeof (unichar));
1366 
      for (i = 0; i < len; i++)
1367 
        windres_put_16 (wrbfd, d + (i * sizeof (unichar)), str[i]);
1368 
      windres_put_16 (wrbfd, d + (len * sizeof (unichar)), 0);
1369 
      set_windres_bfd_content (wrbfd, d, off, (len + 1) * sizeof (unichar));
1370 
    }
1371 
  off += (rc_uint_type) ((len + 1) * sizeof (unichar));
1372 
 
1373 
  return off;
1374 
}
1375 
 
1376 
/* Convert an accelerator resource to binary.  */
1377 
 
1378 
static rc_uint_type
1379 
res_to_bin_accelerator (windres_bfd *wrbfd, rc_uint_type off,
1380 
                        const rc_accelerator *accelerators)
1381 
{
1382 
  const rc_accelerator *a;
1383 
 
1384 
  for (a = accelerators; a != NULL; a = a->next)
1385 
    {
1386 
      if (wrbfd)
1387 
        {
1388 
          struct bin_accelerator ba;
1389 
 
1390 
          windres_put_16 (wrbfd, ba.flags, a->flags | (a->next != NULL ? 0 : ACC_LAST));
1391 
          windres_put_16 (wrbfd, ba.key, a->key);
1392 
          windres_put_16 (wrbfd, ba.id, a->id);
1393 
          windres_put_16 (wrbfd, ba.pad, 0);
1394 
          set_windres_bfd_content (wrbfd, &ba, off, BIN_ACCELERATOR_SIZE);
1395 
    }
1396 
      off += BIN_ACCELERATOR_SIZE;
1397 
    }
1398 
  return off;
1399 
}
1400 
 
1401 
/* Convert a cursor resource to binary.  */
1402 
 
1403 
static rc_uint_type
1404 
res_to_bin_cursor (windres_bfd *wrbfd, rc_uint_type off, const rc_cursor *c)
1405 
{
1406 
  if (wrbfd)
1407 
    {
1408 
      struct bin_cursor bc;
1409 
 
1410 
      windres_put_16 (wrbfd, bc.xhotspot, c->xhotspot);
1411 
      windres_put_16 (wrbfd, bc.yhotspot, c->yhotspot);
1412 
      set_windres_bfd_content (wrbfd, &bc, off, BIN_CURSOR_SIZE);
1413 
      if (c->length)
1414 
        set_windres_bfd_content (wrbfd, c->data, off + BIN_CURSOR_SIZE, c->length);
1415 
    }
1416 
  off = (off + BIN_CURSOR_SIZE + (rc_uint_type) c->length);
1417 
  return off;
1418 
}
1419 
 
1420 
/* Convert a group cursor resource to binary.  */
1421 
 
1422 
static rc_uint_type
1423 
res_to_bin_group_cursor (windres_bfd *wrbfd, rc_uint_type off,
1424 
                         const rc_group_cursor *group_cursors)
1425 
{
1426 
  int c = 0;
1427 
  const rc_group_cursor *gc;
1428 
  struct bin_group_cursor bgc;
1429 
  struct bin_group_cursor_item bgci;
1430 
  rc_uint_type start = off;
1431 
 
1432 
  off += BIN_GROUP_CURSOR_SIZE;
1433 
 
1434 
  for (c = 0, gc = group_cursors; gc != NULL; gc = gc->next, c++)
1435 
    {
1436 
      if (wrbfd)
1437 
        {
1438 
          windres_put_16 (wrbfd, bgci.width, gc->width);
1439 
          windres_put_16 (wrbfd, bgci.height, gc->height);
1440 
          windres_put_16 (wrbfd, bgci.planes, gc->planes);
1441 
          windres_put_16 (wrbfd, bgci.bits, gc->bits);
1442 
          windres_put_32 (wrbfd, bgci.bytes, gc->bytes);
1443 
          windres_put_16 (wrbfd, bgci.index, gc->index);
1444 
          set_windres_bfd_content (wrbfd, &bgci, off, BIN_GROUP_CURSOR_ITEM_SIZE);
1445 
    }
1446 
 
1447 
      off += BIN_GROUP_CURSOR_ITEM_SIZE;
1448 
    }
1449 
  if (wrbfd)
1450 
    {
1451 
      windres_put_16 (wrbfd, bgc.sig1, 0);
1452 
      windres_put_16 (wrbfd, bgc.sig2, 2);
1453 
      windres_put_16 (wrbfd, bgc.nitems, c);
1454 
      set_windres_bfd_content (wrbfd, &bgc, start, BIN_GROUP_CURSOR_SIZE);
1455 
    }
1456 
  return off;
1457 
}
1458 
 
1459 
/* Convert a dialog resource to binary.  */
1460 
 
1461 
static rc_uint_type
1462 
res_to_bin_dialog (windres_bfd *wrbfd, rc_uint_type off, const rc_dialog *dialog)
1463 
{
1464 
  rc_uint_type off_delta;
1465 
  rc_uint_type start, marker;
1466 
  int dialogex;
1467 
  int c;
1468 
  rc_dialog_control *dc;
1469 
  struct bin_dialogex bdx;
1470 
  struct bin_dialog bd;
1471 
 
1472 
  off_delta = off;
1473 
  start = off;
1474 
  dialogex = extended_dialog (dialog);
1475 
 
1476 
  if (wrbfd)
1477 
    {
1478 
  if (! dialogex)
1479 
    {
1480 
          windres_put_32 (wrbfd, bd.style, dialog->style);
1481 
          windres_put_32 (wrbfd, bd.exstyle, dialog->exstyle);
1482 
          windres_put_16 (wrbfd, bd.x, dialog->x);
1483 
          windres_put_16 (wrbfd, bd.y, dialog->y);
1484 
          windres_put_16 (wrbfd, bd.width, dialog->width);
1485 
          windres_put_16 (wrbfd, bd.height, dialog->height);
1486 
    }
1487 
  else
1488 
    {
1489 
          windres_put_16 (wrbfd, bdx.sig1, 1);
1490 
          windres_put_16 (wrbfd, bdx.sig2, 0xffff);
1491 
          windres_put_32 (wrbfd, bdx.help, (dialog->ex ? dialog->ex->help : 0));
1492 
          windres_put_32 (wrbfd, bdx.exstyle, dialog->exstyle);
1493 
          windres_put_32 (wrbfd, bdx.style, dialog->style);
1494 
          windres_put_16 (wrbfd, bdx.x, dialog->x);
1495 
          windres_put_16 (wrbfd, bdx.y, dialog->y);
1496 
          windres_put_16 (wrbfd, bdx.width, dialog->width);
1497 
          windres_put_16 (wrbfd, bdx.height, dialog->height);
1498 
        }
1499 
    }
1500 
 
1501 
  off += (dialogex != 0 ? BIN_DIALOGEX_SIZE : BIN_DIALOG_SIZE);
1502 
 
1503 
  off = resid_to_bin (wrbfd, off, dialog->menu);
1504 
  off = resid_to_bin (wrbfd, off, dialog->class);
1505 
  off = unicode_to_bin (wrbfd, off, dialog->caption);
1506 
 
1507 
  if ((dialog->style & DS_SETFONT) != 0)
1508 
    {
1509 
      if (wrbfd)
1510 
        {
1511 
          if (! dialogex)
1512 
            {
1513 
              struct bin_dialogfont bdf;
1514 
              windres_put_16 (wrbfd, bdf.pointsize, dialog->pointsize);
1515 
              set_windres_bfd_content (wrbfd, &bdf, off, BIN_DIALOGFONT_SIZE);
1516 
            }
1517 
          else
1518 
            {
1519 
              struct bin_dialogexfont bdxf;
1520 
              windres_put_16 (wrbfd, bdxf.pointsize, dialog->pointsize);
1521 
              windres_put_16 (wrbfd, bdxf.weight, (dialog->ex == NULL ? 0 : dialog->ex->weight));
1522 
              windres_put_8 (wrbfd, bdxf.italic, (dialog->ex == NULL ? 0 : dialog->ex->italic));
1523 
              windres_put_8 (wrbfd, bdxf.charset, (dialog->ex == NULL ? 1 : dialog->ex->charset));
1524 
              set_windres_bfd_content (wrbfd, &bdxf, off, BIN_DIALOGEXFONT_SIZE);
1525 
            }
1526 
        }
1527 
      off += (dialogex ? BIN_DIALOGEXFONT_SIZE : BIN_DIALOGFONT_SIZE);
1528 
      off = unicode_to_bin (wrbfd, off, dialog->font);
1529 
    }
1530 
  for (c = 0, dc = dialog->controls; dc != NULL; dc = dc->next, c++)
1531 
    {
1532 
      bfd_byte dc_rclen[2];
1533 
 
1534 
      off += (4 - ((off - off_delta) & 3)) & 3;
1535 
      if (wrbfd)
1536 
        {
1537 
      if (! dialogex)
1538 
        {
1539 
              struct bin_dialog_control bdc;
1540 
 
1541 
              windres_put_32 (wrbfd, bdc.style, dc->style);
1542 
              windres_put_32 (wrbfd, bdc.exstyle, dc->exstyle);
1543 
              windres_put_16 (wrbfd, bdc.x, dc->x);
1544 
              windres_put_16 (wrbfd, bdc.y, dc->y);
1545 
              windres_put_16 (wrbfd, bdc.width, dc->width);
1546 
              windres_put_16 (wrbfd, bdc.height, dc->height);
1547 
              windres_put_16 (wrbfd, bdc.id, dc->id);
1548 
              set_windres_bfd_content (wrbfd, &bdc, off, BIN_DIALOG_CONTROL_SIZE);
1549 
        }
1550 
      else
1551 
        {
1552 
              struct bin_dialogex_control bdc;
1553 
 
1554 
              windres_put_32 (wrbfd, bdc.help, dc->help);
1555 
              windres_put_32 (wrbfd, bdc.exstyle, dc->exstyle);
1556 
              windres_put_32 (wrbfd, bdc.style, dc->style);
1557 
              windres_put_16 (wrbfd, bdc.x, dc->x);
1558 
              windres_put_16 (wrbfd, bdc.y, dc->y);
1559 
              windres_put_16 (wrbfd, bdc.width, dc->width);
1560 
              windres_put_16 (wrbfd, bdc.height, dc->height);
1561 
              windres_put_32 (wrbfd, bdc.id, dc->id);
1562 
              set_windres_bfd_content (wrbfd, &bdc, off, BIN_DIALOGEX_CONTROL_SIZE);
1563 
            }
1564 
        }
1565 
      off += (dialogex != 0 ? BIN_DIALOGEX_CONTROL_SIZE : BIN_DIALOG_CONTROL_SIZE);
1566 
 
1567 
      off = resid_to_bin (wrbfd, off, dc->class);
1568 
      off = resid_to_bin (wrbfd, off, dc->text);
1569 
 
1570 
      marker = off; /* Save two bytes for size of optional data.  */
1571 
      off += 2;
1572 
 
1573 
      if (dc->data == NULL)
1574 
        {
1575 
          if (wrbfd)
1576 
            windres_put_16 (wrbfd, dc_rclen, 0);
1577 
        }
1578 
      else
1579 
        {
1580 
          rc_uint_type saved_off = off;
1581 
          rc_uint_type old_off;
1582 
          off += (4 - ((off - off_delta) & 3)) & 3;
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 163 khays 
            const rc_ver_stringtable *vst;
2031 15 khays 
 
2032 
            off = string_to_unicode_bin (wrbfd, off, "StringFileInfo");
2033 
 
2034 163 khays 
            if (!vi->u.string.stringtables)
2035 
              off += (4 - ((off - off_delta) & 3)) & 3;
2036 15 khays 
 
2037 163 khays 
            for (vst = vi->u.string.stringtables; vst != NULL; vst = vst->next)
2038 15 khays 
              {
2039 163 khays 
                struct bin_ver_info bvst;
2040 
                rc_uint_type vst_off;
2041 
                const rc_ver_stringinfo *vs;
2042 15 khays 
 
2043 
                off += (4 - ((off - off_delta) & 3)) & 3;
2044 
 
2045 163 khays 
                vst_off = off;
2046 15 khays 
                off += BIN_VER_INFO_SIZE;
2047 
 
2048 163 khays 
                off = unicode_to_bin (wrbfd, off, vst->language);
2049 15 khays 
 
2050 163 khays 
                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 15 khays 
 
2055 163 khays 
                    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 15 khays 
                if (wrbfd)
2078 
                  {
2079 163 khays 
                    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 15 khays 
                  }
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 163 khays 
          windres_put_16 (wrbfd, bv.size, off - bv_off);
2136 15 khays 
          windres_put_16 (wrbfd, bv.sig1, 0);
2137 163 khays 
          windres_put_16 (wrbfd, bv.sig2, 1);
2138 15 khays 
          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 
}

powered by: WebSVN 2.1.0

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