update many old style function definitions
[external/binutils.git] / binutils / resres.c
1 /* resres.c: read_res_file and write_res_file implementation for windres.
2    Copyright (C) 1998-2016 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 (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 }