binutils/resbin.c

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