binutils/resres.c

   1 /* resres.c: read_res_file and write_res_file implementation for windres.
   2    Copyright (C) 1998-2020 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 (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 (const rc_res_id *id)
 390 {
 391   if (id->named)
 392     return sizeof (unichar) * (id->u.n.length + 1);
 393   else
 394     return sizeof (unichar) * 2;
 395 }
 396
 397 /* Write a resource header */
 398 static rc_uint_type
 399 write_res_header (windres_bfd *wrbfd, rc_uint_type off, rc_uint_type datasize,
 400                   const rc_res_id *type, const rc_res_id *name,
 401                   const rc_res_res_info *resinfo)
 402 {
 403   res_hdr reshdr;
 404   reshdr.data_size = datasize;
 405   reshdr.header_size = 24 + get_id_size (type) + get_id_size (name);
 406
 407   reshdr.header_size = (reshdr.header_size + 3) & ~3;
 408
 409   off = (off + 3) & ~3;
 410
 411   off = write_res_data_hdr (wrbfd, off, &reshdr);
 412   off = write_res_id (wrbfd, off, type);
 413   off = write_res_id (wrbfd, off, name);
 414
 415   off = (off + 3) & ~3;
 416
 417   off = write_res_info (wrbfd, off, resinfo);
 418   off = (off + 3) & ~3;
 419   return off;
 420 }
 421
 422 static rc_uint_type
 423 write_res_data_hdr (windres_bfd *wrbfd, rc_uint_type off, res_hdr *hdr)
 424 {
 425   if (wrbfd)
 426     {
 427       struct bin_res_hdr brh;
 428       windres_put_32 (wrbfd, brh.data_size, hdr->data_size);
 429       windres_put_32 (wrbfd, brh.header_size, hdr->header_size);
 430       set_windres_bfd_content (wrbfd, &brh, off, BIN_RES_HDR_SIZE);
 431     }
 432   return off + BIN_RES_HDR_SIZE;
 433 }
 434
 435 static void
 436 read_res_data_hdr (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax,
 437                    res_hdr *reshdr)
 438 {
 439   struct bin_res_hdr brh;
 440
 441   if ((off[0] + BIN_RES_HDR_SIZE) > omax)
 442     fatal ("%s: unexpected end of file %ld/%ld", filename,(long) off[0], (long) omax);
 443
 444   get_windres_bfd_content (wrbfd, &brh, off[0], BIN_RES_HDR_SIZE);
 445   reshdr->data_size = windres_get_32 (wrbfd, brh.data_size, 4);
 446   reshdr->header_size = windres_get_32 (wrbfd, brh.header_size, 4);
 447   off[0] += BIN_RES_HDR_SIZE;
 448 }
 449
 450 /* Read data from file, abort on failure */
 451 static void
 452 read_res_data (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax, void *data,
 453                rc_uint_type size)
 454 {
 455   if ((off[0] + size) > omax)
 456     fatal ("%s: unexpected end of file %ld/%ld %ld", filename,(long) off[0],
 457            (long) omax, (long) size);
 458   get_windres_bfd_content (wrbfd, data, off[0], size);
 459   off[0] += size;
 460 }
 461
 462 /* Write a resource id */
 463 static rc_uint_type
 464 write_res_id (windres_bfd *wrbfd, rc_uint_type off, const rc_res_id *id)
 465 {
 466   if (id->named)
 467     {
 468       rc_uint_type len = (((bfd_signed_vma) id->u.n.length < 0 ? 0 : id->u.n.length) + 1);
 469       if (wrbfd)
 470         {
 471           rc_uint_type i;
 472           bfd_byte *d = (bfd_byte *) xmalloc (len * sizeof (unichar));
 473           for (i = 0; i < (len - 1); i++)
 474             windres_put_16 (wrbfd, d + (i * sizeof (unichar)), id->u.n.name[i]);
 475           windres_put_16 (wrbfd, d + (i * sizeof (unichar)), 0);
 476           set_windres_bfd_content (wrbfd, d, off, (len * sizeof (unichar)));
 477         }
 478       off += (len * sizeof (unichar));
 479     }
 480   else
 481     {
 482       if (wrbfd)
 483         {
 484           struct bin_res_id bid;
 485           windres_put_16 (wrbfd, bid.sig, 0xffff);
 486           windres_put_16 (wrbfd, bid.id, id->u.id);
 487           set_windres_bfd_content (wrbfd, &bid, off, BIN_RES_ID);
 488         }
 489       off += BIN_RES_ID;
 490     }
 491   return off;
 492 }
 493
 494 /* Write resource info */
 495 static rc_uint_type
 496 write_res_info (windres_bfd *wrbfd, rc_uint_type off, const rc_res_res_info *info)
 497 {
 498   if (wrbfd)
 499     {
 500       struct bin_res_info l;
 501
 502       windres_put_32 (wrbfd, l.version, info->version);
 503       windres_put_16 (wrbfd, l.memflags, info->memflags);
 504       windres_put_16 (wrbfd, l.language, info->language);
 505       windres_put_32 (wrbfd, l.version2, info->version);
 506       windres_put_32 (wrbfd, l.characteristics, info->characteristics);
 507       set_windres_bfd_content (wrbfd, &l, off, BIN_RES_INFO_SIZE);
 508     }
 509   return off + BIN_RES_INFO_SIZE;
 510 }
 511
 512 /* read a resource identifier */
 513 static void
 514 read_res_id (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax, rc_res_id *id)
 515 {
 516   struct bin_res_id bid;
 517   unsigned short ord;
 518   unichar *id_s = NULL;
 519   rc_uint_type len;
 520
 521   read_res_data (wrbfd, off, omax, &bid, BIN_RES_ID - 2);
 522   ord = (unsigned short) windres_get_16 (wrbfd, bid.sig, 2);
 523   if (ord == 0xFFFF)            /* an ordinal id */
 524     {
 525       read_res_data (wrbfd, off, omax, bid.id, BIN_RES_ID - 2);
 526       id->named = 0;
 527       id->u.id = windres_get_16 (wrbfd, bid.id, 2);
 528     }
 529   else
 530     /* named id */
 531     {
 532       off[0] -= 2;
 533       id_s = read_unistring (wrbfd, off, omax, &len);
 534       id->named = 1;
 535       id->u.n.length = len;
 536       id->u.n.name = id_s;
 537     }
 538 }
 539
 540 /* Read a null terminated UNICODE string */
 541 static unichar *
 542 read_unistring (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax,
 543                 rc_uint_type *len)
 544 {
 545   unichar *s;
 546   bfd_byte d[2];
 547   unichar c;
 548   unichar *p;
 549   rc_uint_type l;
 550   rc_uint_type soff = off[0];
 551
 552   do
 553     {
 554       read_res_data (wrbfd, &soff, omax, d, sizeof (unichar));
 555       c = windres_get_16 (wrbfd, d, 2);
 556     }
 557   while (c != 0);
 558   l = ((soff - off[0]) / sizeof (unichar));
 559
 560   /* there are hardly any names longer than 256 characters, but anyway. */
 561   p = s = (unichar *) xmalloc (sizeof (unichar) * l);
 562   do
 563     {
 564       read_res_data (wrbfd, off, omax, d, sizeof (unichar));
 565       c = windres_get_16 (wrbfd, d, 2);
 566       *p++ = c;
 567     }
 568   while (c != 0);
 569   *len = l - 1;
 570   return s;
 571 }
 572
 573 static int
 574 probe_binary (windres_bfd *wrbfd, rc_uint_type omax)
 575 {
 576   rc_uint_type off;
 577   res_hdr reshdr;
 578
 579   off = 0;
 580   read_res_data_hdr (wrbfd, &off, omax, &reshdr);
 581   if (reshdr.data_size != 0)
 582     return 1;
 583   if ((reshdr.header_size != 0x20 && ! target_is_bigendian)
 584       || (reshdr.header_size != 0x20000000 && target_is_bigendian))
 585     return 1;
 586
 587   /* Subtract size of HeaderSize. DataSize has to be zero. */
 588   off += 0x20 - BIN_RES_HDR_SIZE;
 589   if ((off + BIN_RES_HDR_SIZE) >= omax)
 590     return 1;
 591   read_res_data_hdr (wrbfd, &off, omax, &reshdr);
 592   /* off is advanced by BIN_RES_HDR_SIZE in read_res_data_hdr()
 593      which is part of reshdr.header_size. We shouldn't take it
 594      into account twice.  */
 595   if ((off - BIN_RES_HDR_SIZE + reshdr.data_size + reshdr.header_size) > omax)
 596     return 0;
 597   return 1;
 598 }
 599
 600 /* Check if file is a win32 binary resource file, if so
 601    skip past the null resource. Returns 0 if successful, -1 on
 602    error.
 603  */
 604 static void
 605 skip_null_resource (windres_bfd *wrbfd, rc_uint_type *off, rc_uint_type omax)
 606 {
 607   res_hdr reshdr;
 608   read_res_data_hdr (wrbfd, off, omax, &reshdr);
 609   if (reshdr.data_size != 0)
 610     goto skip_err;
 611   if ((reshdr.header_size != 0x20 && ! target_is_bigendian)
 612     || (reshdr.header_size != 0x20000000 && target_is_bigendian))
 613     goto skip_err;
 614
 615   /* Subtract size of HeaderSize. DataSize has to be zero. */
 616   off[0] += 0x20 - BIN_RES_HDR_SIZE;
 617   if (off[0] >= omax)
 618     goto skip_err;
 619
 620   return;
 621
 622 skip_err:
 623   fprintf (stderr, "%s: %s: Not a valid WIN32 resource file\n", program_name,
 624            filename);
 625   xexit (1);
 626 }
 627
 628 /* Add a resource to resource directory */
 629 static void
 630 res_add_resource (rc_res_resource *r, const rc_res_id *type, const rc_res_id *id,
 631                   rc_uint_type language, int dupok)
 632 {
 633   rc_res_id a[3];
 634
 635   a[0] = *type;
 636   a[1] = *id;
 637   a[2].named = 0;
 638   a[2].u.id = language;
 639   res_append_resource (&resources, r, 3, a, dupok);
 640 }
 641
 642 /* Append a resource to resource directory.
 643    This is just copied from define_resource
 644    and modified to add an existing resource.
 645  */
 646 static void
 647 res_append_resource (rc_res_directory **res_dirs, rc_res_resource *resource,
 648                      int cids, const rc_res_id *ids, int dupok)
 649 {
 650   rc_res_entry *re = NULL;
 651   int i;
 652
 653   assert (cids > 0);
 654   for (i = 0; i < cids; i++)
 655     {
 656       rc_res_entry **pp;
 657
 658       if (*res_dirs == NULL)
 659         {
 660           *res_dirs = ((rc_res_directory *)
 661                         res_alloc (sizeof (rc_res_directory)));
 662
 663           (*res_dirs)->characteristics = 0;
 664           /* Using a real timestamp only serves to create non-deterministic
 665              results.  Use zero instead.  */
 666           (*res_dirs)->time = 0;
 667           (*res_dirs)->major = 0;
 668           (*res_dirs)->minor = 0;
 669           (*res_dirs)->entries = NULL;
 670         }
 671
 672       for (pp = &(*res_dirs)->entries; *pp != NULL; pp = &(*pp)->next)
 673         if (res_id_cmp ((*pp)->id, ids[i]) == 0)
 674           break;
 675
 676       if (*pp != NULL)
 677         re = *pp;
 678       else
 679         {
 680           re = (rc_res_entry *) res_alloc (sizeof (rc_res_entry));
 681           re->next = NULL;
 682           re->id = ids[i];
 683           if ((i + 1) < cids)
 684             {
 685               re->subdir = 1;
 686               re->u.dir = NULL;
 687             }
 688           else
 689             {
 690               re->subdir = 0;
 691               re->u.res = NULL;
 692             }
 693
 694           *pp = re;
 695         }
 696
 697       if ((i + 1) < cids)
 698         {
 699           if (! re->subdir)
 700             {
 701               fprintf (stderr, "%s: ", program_name);
 702               res_ids_print (stderr, i, ids);
 703               fprintf (stderr, ": expected to be a directory\n");
 704               xexit (1);
 705             }
 706
 707           res_dirs = &re->u.dir;
 708         }
 709     }
 710
 711   if (re->subdir)
 712     {
 713       fprintf (stderr, "%s: ", program_name);
 714       res_ids_print (stderr, cids, ids);
 715       fprintf (stderr, ": expected to be a leaf\n");
 716       xexit (1);
 717     }
 718
 719   if (re->u.res != NULL)
 720     {
 721       if (dupok)
 722         return;
 723
 724       fprintf (stderr, "%s: warning: ", program_name);
 725       res_ids_print (stderr, cids, ids);
 726       fprintf (stderr, ": duplicate value\n");
 727     }
 728
 729   re->u.res = resource;
 730 }