binutils/resres.c

   1 /* resres.c: read_res_file and write_res_file implementation for windres.
   2    Copyright (C) 1998-2014 Free Software Foundation, Inc.
   3    Written by Anders Norlander <anorland@hem2.passagen.se>.
   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 /* FIXME: This file does not work correctly in a cross configuration.
  24    It assumes that it can use fread and fwrite to read and write
  25    integers.  It does no swapping.  */
  26
  27 #include "sysdep.h"
  28 #include "bfd.h"
  29 #include "bucomm.h"
  30 #include "libiberty.h"
  31 #include "windres.h"
  32
  33 #include <assert.h>
  34
  35 static rc_uint_type write_res_directory (windres_bfd *, rc_uint_type,
  36                                          const rc_res_directory *, const rc_res_id *,
  37                                          const rc_res_id *, rc_uint_type *, int);
  38 static rc_uint_type write_res_resource (windres_bfd *, rc_uint_type,const rc_res_id *,
  39                                         const rc_res_id *, const rc_res_resource *,
  40                                         rc_uint_type *);
  41 static rc_uint_type write_res_bin (windres_bfd *, rc_uint_type, const rc_res_resource *,
  42                                    const rc_res_id *, const rc_res_id *,
  43                                    const rc_res_res_info *);
  44
  45 static rc_uint_type write_res_id (windres_bfd *, rc_uint_type, const rc_res_id *);
  46 static rc_uint_type write_res_info (windres_bfd *, rc_uint_type, const rc_res_res_info *);
  47 static rc_uint_type write_res_data_hdr (windres_bfd *, rc_uint_type, res_hdr *);
  48
  49 static rc_uint_type write_res_header (windres_bfd *, rc_uint_type, rc_uint_type,
  50                                       const rc_res_id *, const rc_res_id *,
  51                                       const rc_res_res_info *);
  52
  53 static int read_resource_entry (windres_bfd *, rc_uint_type *, rc_uint_type);
  54 static void read_res_data (windres_bfd *, rc_uint_type *, rc_uint_type, void *,
  55                            rc_uint_type);
  56 static void read_res_data_hdr (windres_bfd *, rc_uint_type *, rc_uint_type, res_hdr *);
  57 static void read_res_id (windres_bfd *, rc_uint_type *, rc_uint_type, rc_res_id *);
  58 static unichar *read_unistring (windres_bfd *, rc_uint_type *, rc_uint_type, rc_uint_type *);
  59 static void skip_null_resource (windres_bfd *, rc_uint_type *, rc_uint_type);
  60 static int probe_binary (windres_bfd *wrbfd, rc_uint_type);
  61
  62 static unsigned long get_id_size (const rc_res_id *);
  63
  64 static void res_add_resource (rc_res_resource *, const rc_res_id *,
  65                               const rc_res_id *, rc_uint_type, int);
  66
  67 static void res_append_resource (rc_res_directory **, rc_res_resource *,
  68                                  int, const rc_res_id *, int);
  69
  70 static rc_res_directory *resources = NULL;
  71
  72 static const char *filename;
  73
  74 extern char *program_name;
  75
  76 /* Read resource file */
  77 rc_res_directory *
  78 read_res_file (const char *fn)
  79 {
  80   rc_uint_type off, flen;
  81   windres_bfd wrbfd;
  82   bfd *abfd;
  83   asection *sec;
  84   filename = fn;
  85
  86   flen = (rc_uint_type) get_file_size (filename);
  87   if (! flen)
  88     fatal ("can't open '%s' for input.", filename);
  89   abfd = windres_open_as_binary (filename, 1);
  90   sec = bfd_get_section_by_name (abfd, ".data");
  91   if (sec == NULL)
  92     bfd_fatal ("bfd_get_section_by_name");
  93   set_windres_bfd (&wrbfd, abfd, sec,
  94                    (target_is_bigendian ? WR_KIND_BFD_BIN_B
  95                                         : WR_KIND_BFD_BIN_L));
  96   off = 0;
  97
  98   if (! probe_binary (&wrbfd, flen))
  99     set_windres_bfd_endianness (&wrbfd, ! target_is_bigendian);
 100
 101   skip_null_resource (&wrbfd, &off, flen);
 102
 103   while (read_resource_entry (&wrbfd, &off, flen))
 104     ;
 105
 106   bfd_close (abfd);
 107
 108   return resources;
 109 }
 110
 111 /* Write resource file */
 112 void
 113 write_res_file (const char *fn,const rc_res_directory *resdir)
 114 {
 115   asection *sec;
 116   rc_uint_type language;
 117   bfd *abfd;
 118   windres_bfd wrbfd;
 119   unsigned long sec_length = 0,sec_length_wrote;
 120   static const bfd_byte sign[] =
 121   {0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
 122    0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
 123    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 124    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 125
 126   filename = fn;
 127
 128   abfd = windres_open_as_binary (filename, 0);
 129   sec = bfd_make_section_with_flags (abfd, ".data",
 130                                      (SEC_HAS_CONTENTS | SEC_ALLOC
 131                                       | SEC_LOAD | SEC_DATA));
 132   if (sec == NULL)
 133     bfd_fatal ("bfd_make_section");
 134   /* Requiring this is probably a bug in BFD.  */
 135   sec->output_section = sec;
 136
 137   set_windres_bfd (&wrbfd, abfd, sec,
 138                    (target_is_bigendian ? WR_KIND_BFD_BIN_B
 139                                         : WR_KIND_BFD_BIN_L));
 140
 141   language = -1;
 142   sec_length = write_res_directory ((windres_bfd *) NULL, 0x20UL, resdir,
 143                                     (const rc_res_id *) NULL,
 144                                     (const rc_res_id *) NULL, &language, 1);
 145   if (! bfd_set_section_size (abfd, sec, (sec_length + 3) & ~3))
 146     bfd_fatal ("bfd_set_section_size");
 147   if ((sec_length & 3) != 0)
 148     set_windres_bfd_content (&wrbfd, sign, sec_length, 4-(sec_length & 3));
 149   set_windres_bfd_content (&wrbfd, sign, 0, sizeof (sign));
 150   language = -1;
 151   sec_length_wrote = write_res_directory (&wrbfd, 0x20UL, resdir,
 152                                           (const rc_res_id *) NULL,
 153                                           (const rc_res_id *) NULL,
 154                                           &language, 1);
 155   if (sec_length != sec_length_wrote)
 156     fatal ("res write failed with different sizes (%lu/%lu).",
 157            (unsigned long) sec_length, (unsigned long) sec_length_wrote);
 158
 159   bfd_close (abfd);
 160   return;
 161 }
 162
 163 /* Read a resource entry, returns 0 when all resources are read */
 164 static int
 165 read_resource_entry (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax)
 166 {
 167   rc_res_id type;
 168   rc_res_id name;
 169   rc_res_res_info resinfo;
 170   res_hdr reshdr;
 171   void *buff;
 172
 173   rc_res_resource *r;
 174   struct bin_res_info l;
 175
 176   off[0] = (off[0] + 3) & ~3;
 177
 178   /* Read header */
 179   if ((off[0] + 8) > omax)
 180     return 0;
 181   read_res_data_hdr (wrbfd, off, omax, &reshdr);
 182
 183   /* read resource type */
 184   read_res_id (wrbfd, off, omax, &type);
 185   /* read resource id */
 186   read_res_id (wrbfd, off, omax, &name);
 187
 188   off[0] = (off[0] + 3) & ~3;
 189
 190   /* Read additional resource header */
 191   read_res_data (wrbfd, off, omax, &l, BIN_RES_INFO_SIZE);
 192   resinfo.version = windres_get_32 (wrbfd, l.version, 4);
 193   resinfo.memflags = windres_get_16 (wrbfd, l.memflags, 2);
 194   resinfo.language = windres_get_16 (wrbfd, l.language, 2);
 195   /* resinfo.version2 = windres_get_32 (wrbfd, l.version2, 4); */
 196   resinfo.characteristics = windres_get_32 (wrbfd, l.characteristics, 4);
 197
 198   off[0] = (off[0] + 3) & ~3;
 199
 200   /* Allocate buffer for data */
 201   buff = res_alloc (reshdr.data_size);
 202   /* Read data */
 203   read_res_data (wrbfd, off, omax, buff, reshdr.data_size);
 204   /* Convert binary data to resource */
 205   r = bin_to_res (wrbfd, type, buff, reshdr.data_size);
 206   r->res_info = resinfo;
 207   /* Add resource to resource directory */
 208   res_add_resource (r, &type, &name, resinfo.language, 0);
 209
 210   return 1;
 211 }
 212
 213 /* write resource directory to binary resource file */
 214 static rc_uint_type
 215 write_res_directory (windres_bfd *wrbfd, rc_uint_type off, const rc_res_directory *rd,
 216                      const rc_res_id *type, const rc_res_id *name, rc_uint_type *language,
 217                      int level)
 218 {
 219   const rc_res_entry *re;
 220
 221   for (re = rd->entries; re != NULL; re = re->next)
 222     {
 223       switch (level)
 224         {
 225         case 1:
 226           /* If we're at level 1, the key of this resource is the
 227              type.  This normally duplicates the information we have
 228              stored with the resource itself, but we need to remember
 229              the type if this is a user define resource type.  */
 230           type = &re->id;
 231           break;
 232
 233         case 2:
 234           /* If we're at level 2, the key of this resource is the name
 235              we are going to use in the rc printout.  */
 236           name = &re->id;
 237           break;
 238
 239         case 3:
 240           /* If we're at level 3, then this key represents a language.
 241              Use it to update the current language.  */
 242           if (! re->id.named
 243               && re->id.u.id != (unsigned long) *language
 244               && (re->id.u.id & 0xffff) == re->id.u.id)
 245             {
 246               *language = re->id.u.id;
 247             }
 248           break;
 249
 250         default:
 251           break;
 252         }
 253
 254       if (re->subdir)
 255         off = write_res_directory (wrbfd, off, re->u.dir, type, name, language,
 256                                    level + 1);
 257       else
 258         {
 259           if (level == 3)
 260             {
 261               /* This is the normal case: the three levels are
 262                  TYPE/NAME/LANGUAGE.  NAME will have been set at level
 263                  2, and represents the name to use.  We probably just
 264                  set LANGUAGE, and it will probably match what the
 265                  resource itself records if anything.  */
 266               off = write_res_resource (wrbfd, off, type, name, re->u.res,
 267                                         language);
 268             }
 269           else
 270             {
 271               fprintf (stderr, "// Resource at unexpected level %d\n", level);
 272               off = write_res_resource (wrbfd, off, type, (rc_res_id *) NULL,
 273                                         re->u.res, language);
 274             }
 275         }
 276     }
 277
 278   return off;
 279 }
 280
 281 static rc_uint_type
 282 write_res_resource (windres_bfd *wrbfd, rc_uint_type off, const rc_res_id *type,
 283                     const rc_res_id *name, const rc_res_resource *res,
 284                     rc_uint_type *language ATTRIBUTE_UNUSED)
 285 {
 286   int rt;
 287
 288   switch (res->type)
 289     {
 290     default:
 291       abort ();
 292
 293     case RES_TYPE_ACCELERATOR:
 294       rt = RT_ACCELERATOR;
 295       break;
 296
 297     case RES_TYPE_BITMAP:
 298       rt = RT_BITMAP;
 299       break;
 300
 301     case RES_TYPE_CURSOR:
 302       rt = RT_CURSOR;
 303       break;
 304
 305     case RES_TYPE_GROUP_CURSOR:
 306       rt = RT_GROUP_CURSOR;
 307       break;
 308
 309     case RES_TYPE_DIALOG:
 310       rt = RT_DIALOG;
 311       break;
 312
 313     case RES_TYPE_FONT:
 314       rt = RT_FONT;
 315       break;
 316
 317     case RES_TYPE_FONTDIR:
 318       rt = RT_FONTDIR;
 319       break;
 320
 321     case RES_TYPE_ICON:
 322       rt = RT_ICON;
 323       break;
 324
 325     case RES_TYPE_GROUP_ICON:
 326       rt = RT_GROUP_ICON;
 327       break;
 328
 329     case RES_TYPE_MENU:
 330       rt = RT_MENU;
 331       break;
 332
 333     case RES_TYPE_MESSAGETABLE:
 334       rt = RT_MESSAGETABLE;
 335       break;
 336
 337     case RES_TYPE_RCDATA:
 338       rt = RT_RCDATA;
 339       break;
 340
 341     case RES_TYPE_STRINGTABLE:
 342       rt = RT_STRING;
 343       break;
 344
 345     case RES_TYPE_USERDATA:
 346       rt = 0;
 347       break;
 348
 349     case RES_TYPE_VERSIONINFO:
 350       rt = RT_VERSION;
 351       break;
 352
 353     case RES_TYPE_TOOLBAR:
 354       rt = RT_TOOLBAR;
 355       break;
 356     }
 357
 358   if (rt != 0
 359       && type != NULL
 360       && (type->named || type->u.id != (unsigned long) rt))
 361     {
 362       fprintf (stderr, "// Unexpected resource type mismatch: ");
 363       res_id_print (stderr, *type, 1);
 364       fprintf (stderr, " != %d", rt);
 365       abort ();
 366     }
 367
 368   return write_res_bin (wrbfd, off, res, type, name, &res->res_info);
 369 }
 370
 371 /* Write a resource in binary resource format */
 372 static rc_uint_type
 373 write_res_bin (windres_bfd *wrbfd, rc_uint_type off, const rc_res_resource *res,
 374                const rc_res_id *type, const rc_res_id *name,
 375                const rc_res_res_info *resinfo)
 376 {
 377   rc_uint_type noff;
 378   rc_uint_type datasize = 0;
 379
 380   noff = res_to_bin ((windres_bfd *) NULL, off, res);
 381   datasize = noff - off;
 382
 383   off = write_res_header (wrbfd, off, datasize, type, name, resinfo);
 384   return res_to_bin (wrbfd, off, res);
 385 }
 386
 387 /* Get number of bytes needed to store an id in binary format */
 388 static unsigned long
 389 get_id_size (id)
 390      const rc_res_id *id;
 391 {
 392   if (id->named)
 393     return sizeof (unichar) * (id->u.n.length + 1);
 394   else
 395     return sizeof (unichar) * 2;
 396 }
 397
 398 /* Write a resource header */
 399 static rc_uint_type
 400 write_res_header (windres_bfd *wrbfd, rc_uint_type off, rc_uint_type datasize,
 401                   const rc_res_id *type, const rc_res_id *name,
 402                   const rc_res_res_info *resinfo)
 403 {
 404   res_hdr reshdr;
 405   reshdr.data_size = datasize;
 406   reshdr.header_size = 24 + get_id_size (type) + get_id_size (name);
 407
 408   reshdr.header_size = (reshdr.header_size + 3) & ~3;
 409
 410   off = (off + 3) & ~3;
 411
 412   off = write_res_data_hdr (wrbfd, off, &reshdr);
 413   off = write_res_id (wrbfd, off, type);
 414   off = write_res_id (wrbfd, off, name);
 415
 416   off = (off + 3) & ~3;
 417
 418   off = write_res_info (wrbfd, off, resinfo);
 419   off = (off + 3) & ~3;
 420   return off;
 421 }
 422
 423 static rc_uint_type
 424 write_res_data_hdr (windres_bfd *wrbfd, rc_uint_type off, res_hdr *hdr)
 425 {
 426   if (wrbfd)
 427     {
 428       struct bin_res_hdr brh;
 429       windres_put_32 (wrbfd, brh.data_size, hdr->data_size);
 430       windres_put_32 (wrbfd, brh.header_size, hdr->header_size);
 431       set_windres_bfd_content (wrbfd, &brh, off, BIN_RES_HDR_SIZE);
 432     }
 433   return off + BIN_RES_HDR_SIZE;
 434 }
 435
 436 static void
 437 read_res_data_hdr (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax,
 438                    res_hdr *reshdr)
 439 {
 440   struct bin_res_hdr brh;
 441
 442   if ((off[0] + BIN_RES_HDR_SIZE) > omax)
 443     fatal ("%s: unexpected end of file %ld/%ld", filename,(long) off[0], (long) omax);
 444
 445   get_windres_bfd_content (wrbfd, &brh, off[0], BIN_RES_HDR_SIZE);
 446   reshdr->data_size = windres_get_32 (wrbfd, brh.data_size, 4);
 447   reshdr->header_size = windres_get_32 (wrbfd, brh.header_size, 4);
 448   off[0] += BIN_RES_HDR_SIZE;
 449 }
 450
 451 /* Read data from file, abort on failure */
 452 static void
 453 read_res_data (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax, void *data,
 454                rc_uint_type size)
 455 {
 456   if ((off[0] + size) > omax)
 457     fatal ("%s: unexpected end of file %ld/%ld %ld", filename,(long) off[0],
 458            (long) omax, (long) size);
 459   get_windres_bfd_content (wrbfd, data, off[0], size);
 460   off[0] += size;
 461 }
 462
 463 /* Write a resource id */
 464 static rc_uint_type
 465 write_res_id (windres_bfd *wrbfd, rc_uint_type off, const rc_res_id *id)
 466 {
 467   if (id->named)
 468     {
 469       rc_uint_type len = (((bfd_signed_vma) id->u.n.length < 0 ? 0 : id->u.n.length) + 1);
 470       if (wrbfd)
 471         {
 472           rc_uint_type i;
 473           bfd_byte *d = (bfd_byte *) xmalloc (len * sizeof (unichar));
 474           for (i = 0; i < (len - 1); i++)
 475             windres_put_16 (wrbfd, d + (i * sizeof (unichar)), id->u.n.name[i]);
 476           windres_put_16 (wrbfd, d + (i * sizeof (unichar)), 0);
 477           set_windres_bfd_content (wrbfd, d, off, (len * sizeof (unichar)));
 478         }
 479       off += (len * sizeof (unichar));
 480     }
 481   else
 482     {
 483       if (wrbfd)
 484         {
 485           struct bin_res_id bid;
 486           windres_put_16 (wrbfd, bid.sig, 0xffff);
 487           windres_put_16 (wrbfd, bid.id, id->u.id);
 488           set_windres_bfd_content (wrbfd, &bid, off, BIN_RES_ID);
 489         }
 490       off += BIN_RES_ID;
 491     }
 492   return off;
 493 }
 494
 495 /* Write resource info */
 496 static rc_uint_type
 497 write_res_info (windres_bfd *wrbfd, rc_uint_type off, const rc_res_res_info *info)
 498 {
 499   if (wrbfd)
 500     {
 501       struct bin_res_info l;
 502
 503       windres_put_32 (wrbfd, l.version, info->version);
 504       windres_put_16 (wrbfd, l.memflags, info->memflags);
 505       windres_put_16 (wrbfd, l.language, info->language);
 506       windres_put_32 (wrbfd, l.version2, info->version);
 507       windres_put_32 (wrbfd, l.characteristics, info->characteristics);
 508       set_windres_bfd_content (wrbfd, &l, off, BIN_RES_INFO_SIZE);
 509     }
 510   return off + BIN_RES_INFO_SIZE;
 511 }
 512
 513 /* read a resource identifier */
 514 static void
 515 read_res_id (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax, rc_res_id *id)
 516 {
 517   struct bin_res_id bid;
 518   unsigned short ord;
 519   unichar *id_s = NULL;
 520   rc_uint_type len;
 521
 522   read_res_data (wrbfd, off, omax, &bid, BIN_RES_ID - 2);
 523   ord = (unsigned short) windres_get_16 (wrbfd, bid.sig, 2);
 524   if (ord == 0xFFFF)            /* an ordinal id */
 525     {
 526       read_res_data (wrbfd, off, omax, bid.id, BIN_RES_ID - 2);
 527       id->named = 0;
 528       id->u.id = windres_get_16 (wrbfd, bid.id, 2);
 529     }
 530   else
 531     /* named id */
 532     {
 533       off[0] -= 2;
 534       id_s = read_unistring (wrbfd, off, omax, &len);
 535       id->named = 1;
 536       id->u.n.length = len;
 537       id->u.n.name = id_s;
 538     }
 539 }
 540
 541 /* Read a null terminated UNICODE string */
 542 static unichar *
 543 read_unistring (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax,
 544                 rc_uint_type *len)
 545 {
 546   unichar *s;
 547   bfd_byte d[2];
 548   unichar c;
 549   unichar *p;
 550   rc_uint_type l;
 551   rc_uint_type soff = off[0];
 552
 553   do
 554     {
 555       read_res_data (wrbfd, &soff, omax, d, sizeof (unichar));
 556       c = windres_get_16 (wrbfd, d, 2);
 557     }
 558   while (c != 0);
 559   l = ((soff - off[0]) / sizeof (unichar));
 560
 561   /* there are hardly any names longer than 256 characters, but anyway. */
 562   p = s = (unichar *) xmalloc (sizeof (unichar) * l);
 563   do
 564     {
 565       read_res_data (wrbfd, off, omax, d, sizeof (unichar));
 566       c = windres_get_16 (wrbfd, d, 2);
 567       *p++ = c;
 568     }
 569   while (c != 0);
 570   *len = l - 1;
 571   return s;
 572 }
 573
 574 static int
 575 probe_binary (windres_bfd *wrbfd, rc_uint_type omax)
 576 {
 577   rc_uint_type off;
 578   res_hdr reshdr;
 579
 580   off = 0;
 581   read_res_data_hdr (wrbfd, &off, omax, &reshdr);
 582   if (reshdr.data_size != 0)
 583     return 1;
 584   if ((reshdr.header_size != 0x20 && ! target_is_bigendian)
 585       || (reshdr.header_size != 0x20000000 && target_is_bigendian))
 586     return 1;
 587
 588   /* Subtract size of HeaderSize. DataSize has to be zero. */
 589   off += 0x20 - BIN_RES_HDR_SIZE;
 590   if ((off + BIN_RES_HDR_SIZE) >= omax)
 591     return 1;
 592   read_res_data_hdr (wrbfd, &off, omax, &reshdr);
 593   /* off is advanced by BIN_RES_HDR_SIZE in read_res_data_hdr()
 594      which is part of reshdr.header_size. We shouldn't take it
 595      into account twice.  */
 596   if ((off - BIN_RES_HDR_SIZE + reshdr.data_size + reshdr.header_size) > omax)
 597     return 0;
 598   return 1;
 599 }
 600
 601 /* Check if file is a win32 binary resource file, if so
 602    skip past the null resource. Returns 0 if successful, -1 on
 603    error.
 604  */
 605 static void
 606 skip_null_resource (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax)
 607 {
 608   res_hdr reshdr;
 609   read_res_data_hdr (wrbfd, off, omax, &reshdr);
 610   if (reshdr.data_size != 0)
 611     goto skip_err;
 612   if ((reshdr.header_size != 0x20 && ! target_is_bigendian)
 613     || (reshdr.header_size != 0x20000000 && target_is_bigendian))
 614     goto skip_err;
 615
 616   /* Subtract size of HeaderSize. DataSize has to be zero. */
 617   off[0] += 0x20 - BIN_RES_HDR_SIZE;
 618   if (off[0] >= omax)
 619     goto skip_err;
 620
 621   return;
 622
 623 skip_err:
 624   fprintf (stderr, "%s: %s: Not a valid WIN32 resource file\n", program_name,
 625            filename);
 626   xexit (1);
 627 }
 628
 629 /* Add a resource to resource directory */
 630 static void
 631 res_add_resource (rc_res_resource *r, const rc_res_id *type, const rc_res_id *id,
 632                   rc_uint_type language, int dupok)
 633 {
 634   rc_res_id a[3];
 635
 636   a[0] = *type;
 637   a[1] = *id;
 638   a[2].named = 0;
 639   a[2].u.id = language;
 640   res_append_resource (&resources, r, 3, a, dupok);
 641 }
 642
 643 /* Append a resource to resource directory.
 644    This is just copied from define_resource
 645    and modified to add an existing resource.
 646  */
 647 static void
 648 res_append_resource (rc_res_directory **res_dirs, rc_res_resource *resource,
 649                      int cids, const rc_res_id *ids, int dupok)
 650 {
 651   rc_res_entry *re = NULL;
 652   int i;
 653
 654   assert (cids > 0);
 655   for (i = 0; i < cids; i++)
 656     {
 657       rc_res_entry **pp;
 658
 659       if (*res_dirs == NULL)
 660         {
 661           *res_dirs = ((rc_res_directory *)
 662                         res_alloc (sizeof (rc_res_directory)));
 663
 664           (*res_dirs)->characteristics = 0;
 665           /* Using a real timestamp only serves to create non-deterministic
 666              results.  Use zero instead.  */
 667           (*res_dirs)->time = 0;
 668           (*res_dirs)->major = 0;
 669           (*res_dirs)->minor = 0;
 670           (*res_dirs)->entries = NULL;
 671         }
 672
 673       for (pp = &(*res_dirs)->entries; *pp != NULL; pp = &(*pp)->next)
 674         if (res_id_cmp ((*pp)->id, ids[i]) == 0)
 675           break;
 676
 677       if (*pp != NULL)
 678         re = *pp;
 679       else
 680         {
 681           re = (rc_res_entry *) res_alloc (sizeof (rc_res_entry));
 682           re->next = NULL;
 683           re->id = ids[i];
 684           if ((i + 1) < cids)
 685             {
 686               re->subdir = 1;
 687               re->u.dir = NULL;
 688             }
 689           else
 690             {
 691               re->subdir = 0;
 692               re->u.res = NULL;
 693             }
 694
 695           *pp = re;
 696         }
 697
 698       if ((i + 1) < cids)
 699         {
 700           if (! re->subdir)
 701             {
 702               fprintf (stderr, "%s: ", program_name);
 703               res_ids_print (stderr, i, ids);
 704               fprintf (stderr, ": expected to be a directory\n");
 705               xexit (1);
 706             }
 707
 708           res_dirs = &re->u.dir;
 709         }
 710     }
 711
 712   if (re->subdir)
 713     {
 714       fprintf (stderr, "%s: ", program_name);
 715       res_ids_print (stderr, cids, ids);
 716       fprintf (stderr, ": expected to be a leaf\n");
 717       xexit (1);
 718     }
 719
 720   if (re->u.res != NULL)
 721     {
 722       if (dupok)
 723         return;
 724
 725       fprintf (stderr, "%s: warning: ", program_name);
 726       res_ids_print (stderr, cids, ids);
 727       fprintf (stderr, ": duplicate value\n");
 728     }
 729
 730   re->u.res = resource;
 731 }