Improve windres's handling of pathnames containing special characters on Windows...
[binutils-gdb.git] / binutils / windres.c
1 /* windres.c -- a program to manipulate Windows resources
2 Copyright (C) 1997-2021 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 /* This program can read and write Windows resources in various
24 formats. In particular, it can act like the rc resource compiler
25 program, and it can act like the cvtres res to COFF conversion
26 program.
27
28 It is based on information taken from the following sources:
29
30 * Microsoft documentation.
31
32 * The rcl program, written by Gunther Ebert
33 <gunther.ebert@ixos-leipzig.de>.
34
35 * The res2coff program, written by Pedro A. Aranda <paag@tid.es>. */
36
37 #include "sysdep.h"
38 #include <assert.h>
39 #include "bfd.h"
40 #include "getopt.h"
41 #include "bucomm.h"
42 #include "libiberty.h"
43 #include "safe-ctype.h"
44 #include "obstack.h"
45 #include "windres.h"
46
47 /* Used by resrc.c at least. */
48
49 int verbose = 0;
50
51 int target_is_bigendian = 0;
52 const char *def_target_arch;
53
54 static void set_endianness (bfd *, const char *);
55
56 /* An enumeration of format types. */
57
58 enum res_format
59 {
60 /* Unknown format. */
61 RES_FORMAT_UNKNOWN,
62 /* Textual RC file. */
63 RES_FORMAT_RC,
64 /* Binary RES file. */
65 RES_FORMAT_RES,
66 /* COFF file. */
67 RES_FORMAT_COFF
68 };
69
70 /* A structure used to map between format types and strings. */
71
72 struct format_map
73 {
74 const char *name;
75 enum res_format format;
76 };
77
78 /* A mapping between names and format types. */
79
80 static const struct format_map format_names[] =
81 {
82 { "rc", RES_FORMAT_RC },
83 { "res", RES_FORMAT_RES },
84 { "coff", RES_FORMAT_COFF },
85 { NULL, RES_FORMAT_UNKNOWN }
86 };
87
88 /* A mapping from file extensions to format types. */
89
90 static const struct format_map format_fileexts[] =
91 {
92 { "rc", RES_FORMAT_RC },
93 { "res", RES_FORMAT_RES },
94 { "exe", RES_FORMAT_COFF },
95 { "obj", RES_FORMAT_COFF },
96 { "o", RES_FORMAT_COFF },
97 { NULL, RES_FORMAT_UNKNOWN }
98 };
99
100 /* A list of include directories. */
101
102 struct include_dir
103 {
104 struct include_dir *next;
105 char *dir;
106 };
107
108 static struct include_dir *include_dirs;
109
110 /* Static functions. */
111
112 static void res_init (void);
113 static int extended_menuitems (const rc_menuitem *);
114 static enum res_format format_from_name (const char *, int);
115 static enum res_format format_from_filename (const char *, int);
116 static void usage (FILE *, int);
117 static int cmp_res_entry (const void *, const void *);
118 static rc_res_directory *sort_resources (rc_res_directory *);
119 static void reswr_init (void);
120 static const char * quot (const char *);
121 \f
122 static rc_uint_type target_get_8 (const void *, rc_uint_type);
123 static void target_put_8 (void *, rc_uint_type);
124 static rc_uint_type target_get_16 (const void *, rc_uint_type);
125 static void target_put_16 (void *, rc_uint_type);
126 static rc_uint_type target_get_32 (const void *, rc_uint_type);
127 static void target_put_32 (void *, rc_uint_type);
128
129 \f
130 /* When we are building a resource tree, we allocate everything onto
131 an obstack, so that we can free it all at once if we want. */
132
133 #define obstack_chunk_alloc xmalloc
134 #define obstack_chunk_free free
135
136 /* The resource building obstack. */
137
138 static struct obstack res_obstack;
139
140 /* Initialize the resource building obstack. */
141
142 static void
143 res_init (void)
144 {
145 obstack_init (&res_obstack);
146 }
147
148 /* Allocate space on the resource building obstack. */
149
150 void *
151 res_alloc (rc_uint_type bytes)
152 {
153 return obstack_alloc (&res_obstack, (size_t) bytes);
154 }
155
156 /* We also use an obstack to save memory used while writing out a set
157 of resources. */
158
159 static struct obstack reswr_obstack;
160
161 /* Initialize the resource writing obstack. */
162
163 static void
164 reswr_init (void)
165 {
166 obstack_init (&reswr_obstack);
167 }
168
169 /* Allocate space on the resource writing obstack. */
170
171 void *
172 reswr_alloc (rc_uint_type bytes)
173 {
174 return obstack_alloc (&reswr_obstack, (size_t) bytes);
175 }
176 \f
177 /* Open a file using the include directory search list. */
178
179 FILE *
180 open_file_search (const char *filename, const char *mode, const char *errmsg,
181 char **real_filename)
182 {
183 FILE *e;
184 struct include_dir *d;
185
186 e = fopen (filename, mode);
187 if (e != NULL)
188 {
189 *real_filename = xstrdup (filename);
190 return e;
191 }
192
193 if (errno == ENOENT)
194 {
195 for (d = include_dirs; d != NULL; d = d->next)
196 {
197 char *n;
198
199 n = (char *) xmalloc (strlen (d->dir) + strlen (filename) + 2);
200 sprintf (n, "%s/%s", d->dir, filename);
201 e = fopen (n, mode);
202 if (e != NULL)
203 {
204 *real_filename = n;
205 return e;
206 }
207 free (n);
208
209 if (errno != ENOENT)
210 break;
211 }
212 }
213
214 fatal (_("can't open %s `%s': %s"), errmsg, filename, strerror (errno));
215
216 /* Return a value to avoid a compiler warning. */
217 return NULL;
218 }
219 \f
220 /* Compare two resource ID's. We consider name entries to come before
221 numeric entries, because that is how they appear in the COFF .rsrc
222 section. */
223
224 int
225 res_id_cmp (rc_res_id a, rc_res_id b)
226 {
227 if (! a.named)
228 {
229 if (b.named)
230 return 1;
231 if (a.u.id > b.u.id)
232 return 1;
233 else if (a.u.id < b.u.id)
234 return -1;
235 else
236 return 0;
237 }
238 else
239 {
240 unichar *as, *ase, *bs, *bse;
241
242 if (! b.named)
243 return -1;
244
245 as = a.u.n.name;
246 ase = as + a.u.n.length;
247 bs = b.u.n.name;
248 bse = bs + b.u.n.length;
249
250 while (as < ase)
251 {
252 int i;
253
254 if (bs >= bse)
255 return 1;
256 i = (int) *as - (int) *bs;
257 if (i != 0)
258 return i;
259 ++as;
260 ++bs;
261 }
262
263 if (bs < bse)
264 return -1;
265
266 return 0;
267 }
268 }
269
270 /* Print a resource ID. */
271
272 void
273 res_id_print (FILE *stream, rc_res_id id, int quote)
274 {
275 if (! id.named)
276 fprintf (stream, "%u", (int) id.u.id);
277 else
278 {
279 if (quote)
280 unicode_print_quoted (stream, id.u.n.name, id.u.n.length);
281 else
282 unicode_print (stream, id.u.n.name, id.u.n.length);
283 }
284 }
285
286 /* Print a list of resource ID's. */
287
288 void
289 res_ids_print (FILE *stream, int cids, const rc_res_id *ids)
290 {
291 int i;
292
293 for (i = 0; i < cids; i++)
294 {
295 res_id_print (stream, ids[i], 1);
296 if (i + 1 < cids)
297 fprintf (stream, ": ");
298 }
299 }
300
301 /* Convert an ASCII string to a resource ID. */
302
303 void
304 res_string_to_id (rc_res_id *res_id, const char *string)
305 {
306 res_id->named = 1;
307 unicode_from_ascii (&res_id->u.n.length, &res_id->u.n.name, string);
308 }
309
310 /* Convert an unicode string to a resource ID. */
311 void
312 res_unistring_to_id (rc_res_id *res_id, const unichar *u)
313 {
314 res_id->named = 1;
315 res_id->u.n.length = unichar_len (u);
316 res_id->u.n.name = unichar_dup_uppercase (u);
317 }
318
319 /* Define a resource. The arguments are the resource tree, RESOURCES,
320 and the location at which to put it in the tree, CIDS and IDS.
321 This returns a newly allocated rc_res_resource structure, which the
322 caller is expected to initialize. If DUPOK is non-zero, then if a
323 resource with this ID exists, it is returned. Otherwise, a warning
324 is issued, and a new resource is created replacing the existing
325 one. */
326
327 rc_res_resource *
328 define_resource (rc_res_directory **resources, int cids,
329 const rc_res_id *ids, int dupok)
330 {
331 rc_res_entry *re = NULL;
332 int i;
333
334 assert (cids > 0);
335 for (i = 0; i < cids; i++)
336 {
337 rc_res_entry **pp;
338
339 if (*resources == NULL)
340 {
341 *resources = ((rc_res_directory *)
342 res_alloc (sizeof (rc_res_directory)));
343 (*resources)->characteristics = 0;
344 /* Using a real timestamp only serves to create non-deterministic
345 results. Use zero instead. */
346 (*resources)->time = 0;
347 (*resources)->major = 0;
348 (*resources)->minor = 0;
349 (*resources)->entries = NULL;
350 }
351
352 for (pp = &(*resources)->entries; *pp != NULL; pp = &(*pp)->next)
353 if (res_id_cmp ((*pp)->id, ids[i]) == 0)
354 break;
355
356 if (*pp != NULL)
357 re = *pp;
358 else
359 {
360 re = (rc_res_entry *) res_alloc (sizeof (rc_res_entry));
361 re->next = NULL;
362 re->id = ids[i];
363 if ((i + 1) < cids)
364 {
365 re->subdir = 1;
366 re->u.dir = NULL;
367 }
368 else
369 {
370 re->subdir = 0;
371 re->u.res = NULL;
372 }
373
374 *pp = re;
375 }
376
377 if ((i + 1) < cids)
378 {
379 if (! re->subdir)
380 {
381 fprintf (stderr, "%s: ", program_name);
382 res_ids_print (stderr, i, ids);
383 fprintf (stderr, _(": expected to be a directory\n"));
384 xexit (1);
385 }
386
387 resources = &re->u.dir;
388 }
389 }
390
391 if (re->subdir)
392 {
393 fprintf (stderr, "%s: ", program_name);
394 res_ids_print (stderr, cids, ids);
395 fprintf (stderr, _(": expected to be a leaf\n"));
396 xexit (1);
397 }
398
399 if (re->u.res != NULL)
400 {
401 if (dupok)
402 return re->u.res;
403
404 fprintf (stderr, _("%s: warning: "), program_name);
405 res_ids_print (stderr, cids, ids);
406 fprintf (stderr, _(": duplicate value\n"));
407 }
408
409 re->u.res = ((rc_res_resource *)
410 res_alloc (sizeof (rc_res_resource)));
411 memset (re->u.res, 0, sizeof (rc_res_resource));
412
413 re->u.res->type = RES_TYPE_UNINITIALIZED;
414 return re->u.res;
415 }
416
417 /* Define a standard resource. This is a version of define_resource
418 that just takes type, name, and language arguments. */
419
420 rc_res_resource *
421 define_standard_resource (rc_res_directory **resources, int type,
422 rc_res_id name, rc_uint_type language, int dupok)
423 {
424 rc_res_id a[3];
425
426 a[0].named = 0;
427 a[0].u.id = type;
428 a[1] = name;
429 a[2].named = 0;
430 a[2].u.id = language;
431 return define_resource (resources, 3, a, dupok);
432 }
433
434 /* Comparison routine for resource sorting. */
435
436 static int
437 cmp_res_entry (const void *p1, const void *p2)
438 {
439 const rc_res_entry **re1, **re2;
440
441 re1 = (const rc_res_entry **) p1;
442 re2 = (const rc_res_entry **) p2;
443 return res_id_cmp ((*re1)->id, (*re2)->id);
444 }
445
446 /* Sort the resources. */
447
448 static rc_res_directory *
449 sort_resources (rc_res_directory *resdir)
450 {
451 int c, i;
452 rc_res_entry *re;
453 rc_res_entry **a;
454
455 if (resdir->entries == NULL)
456 return resdir;
457
458 c = 0;
459 for (re = resdir->entries; re != NULL; re = re->next)
460 ++c;
461
462 /* This is a recursive routine, so using xmalloc is probably better
463 than alloca. */
464 a = (rc_res_entry **) xmalloc (c * sizeof (rc_res_entry *));
465
466 for (i = 0, re = resdir->entries; re != NULL; re = re->next, i++)
467 a[i] = re;
468
469 qsort (a, c, sizeof (rc_res_entry *), cmp_res_entry);
470
471 resdir->entries = a[0];
472 for (i = 0; i < c - 1; i++)
473 a[i]->next = a[i + 1];
474 a[i]->next = NULL;
475
476 free (a);
477
478 /* Now sort the subdirectories. */
479
480 for (re = resdir->entries; re != NULL; re = re->next)
481 if (re->subdir)
482 re->u.dir = sort_resources (re->u.dir);
483
484 return resdir;
485 }
486 \f
487 /* Return whether the dialog resource DIALOG is a DIALOG or a
488 DIALOGEX. */
489
490 int
491 extended_dialog (const rc_dialog *dialog)
492 {
493 const rc_dialog_control *c;
494
495 if (dialog->ex != NULL)
496 return 1;
497
498 for (c = dialog->controls; c != NULL; c = c->next)
499 if (c->data != NULL || c->help != 0)
500 return 1;
501
502 return 0;
503 }
504
505 /* Return whether MENUITEMS are a MENU or a MENUEX. */
506
507 int
508 extended_menu (const rc_menu *menu)
509 {
510 return extended_menuitems (menu->items);
511 }
512
513 static int
514 extended_menuitems (const rc_menuitem *menuitems)
515 {
516 const rc_menuitem *mi;
517
518 for (mi = menuitems; mi != NULL; mi = mi->next)
519 {
520 if (mi->help != 0 || mi->state != 0)
521 return 1;
522 if (mi->popup != NULL && mi->id != 0)
523 return 1;
524 if ((mi->type
525 & ~ (MENUITEM_CHECKED
526 | MENUITEM_GRAYED
527 | MENUITEM_HELP
528 | MENUITEM_INACTIVE
529 | MENUITEM_MENUBARBREAK
530 | MENUITEM_BITMAP
531 | MENUITEM_OWNERDRAW
532 | MENUITEM_MENUBREAK))
533 != 0)
534 return 1;
535 if (mi->popup != NULL)
536 {
537 if (extended_menuitems (mi->popup))
538 return 1;
539 }
540 }
541
542 return 0;
543 }
544 \f
545 /* Convert a string to a format type, or exit if it can't be done. */
546
547 static enum res_format
548 format_from_name (const char *name, int exit_on_error)
549 {
550 const struct format_map *m;
551
552 for (m = format_names; m->name != NULL; m++)
553 if (strcasecmp (m->name, name) == 0)
554 break;
555
556 if (m->name == NULL && exit_on_error)
557 {
558 non_fatal (_("unknown format type `%s'"), name);
559 fprintf (stderr, _("%s: supported formats:"), program_name);
560 for (m = format_names; m->name != NULL; m++)
561 fprintf (stderr, " %s", m->name);
562 fprintf (stderr, "\n");
563 xexit (1);
564 }
565
566 return m->format;
567 }
568
569 /* Work out a format type given a file name. If INPUT is non-zero,
570 it's OK to look at the file itself. */
571
572 static enum res_format
573 format_from_filename (const char *filename, int input)
574 {
575 const char *ext;
576 FILE *e;
577 bfd_byte b1, b2, b3, b4, b5;
578 int magic;
579
580 /* If we have an extension, see if we recognize it as implying a
581 particular format. */
582 ext = strrchr (filename, '.');
583 if (ext != NULL)
584 {
585 const struct format_map *m;
586
587 ++ext;
588 for (m = format_fileexts; m->name != NULL; m++)
589 if (strcasecmp (m->name, ext) == 0)
590 return m->format;
591 }
592
593 /* If we don't recognize the name of an output file, assume it's a
594 COFF file. */
595 if (! input)
596 return RES_FORMAT_COFF;
597
598 /* Read the first few bytes of the file to see if we can guess what
599 it is. */
600 e = fopen (filename, FOPEN_RB);
601 if (e == NULL)
602 fatal ("%s: %s", filename, strerror (errno));
603
604 b1 = getc (e);
605 b2 = getc (e);
606 b3 = getc (e);
607 b4 = getc (e);
608 b5 = getc (e);
609
610 fclose (e);
611
612 /* A PE executable starts with 0x4d 0x5a. */
613 if (b1 == 0x4d && b2 == 0x5a)
614 return RES_FORMAT_COFF;
615
616 /* A COFF .o file starts with a COFF magic number. */
617 magic = (b2 << 8) | b1;
618 switch (magic)
619 {
620 case 0x14c: /* i386 */
621 case 0x166: /* MIPS */
622 case 0x184: /* Alpha */
623 case 0x268: /* 68k */
624 case 0x1f0: /* PowerPC */
625 case 0x290: /* PA */
626 return RES_FORMAT_COFF;
627 }
628
629 /* A RES file starts with 0x0 0x0 0x0 0x0 0x20 0x0 0x0 0x0. */
630 if (b1 == 0 && b2 == 0 && b3 == 0 && b4 == 0 && b5 == 0x20)
631 return RES_FORMAT_RES;
632
633 /* If every character is printable or space, assume it's an RC file. */
634 if ((ISPRINT (b1) || ISSPACE (b1))
635 && (ISPRINT (b2) || ISSPACE (b2))
636 && (ISPRINT (b3) || ISSPACE (b3))
637 && (ISPRINT (b4) || ISSPACE (b4))
638 && (ISPRINT (b5) || ISSPACE (b5)))
639 return RES_FORMAT_RC;
640
641 /* Otherwise, we give up. */
642 fatal (_("can not determine type of file `%s'; use the -J option"),
643 filename);
644
645 /* Return something to silence the compiler warning. */
646 return RES_FORMAT_UNKNOWN;
647 }
648
649 /* Print a usage message and exit. */
650
651 static void
652 usage (FILE *stream, int status)
653 {
654 fprintf (stream, _("Usage: %s [option(s)] [input-file] [output-file]\n"),
655 program_name);
656 fprintf (stream, _(" The options are:\n\
657 -i --input=<file> Name input file\n\
658 -o --output=<file> Name output file\n\
659 -J --input-format=<format> Specify input format\n\
660 -O --output-format=<format> Specify output format\n\
661 -F --target=<target> Specify COFF target\n\
662 --preprocessor=<program> Program to use to preprocess rc file\n\
663 --preprocessor-arg=<arg> Additional preprocessor argument\n\
664 -I --include-dir=<dir> Include directory when preprocessing rc file\n\
665 -D --define <sym>[=<val>] Define SYM when preprocessing rc file\n\
666 -U --undefine <sym> Undefine SYM when preprocessing rc file\n\
667 -v --verbose Verbose - tells you what it's doing\n\
668 -c --codepage=<codepage> Specify default codepage\n\
669 -l --language=<val> Set language when reading rc file\n\
670 --use-temp-file Use a temporary file instead of popen to read\n\
671 the preprocessor output\n\
672 --no-use-temp-file Use popen (default)\n"));
673 #ifdef YYDEBUG
674 fprintf (stream, _("\
675 --yydebug Turn on parser debugging\n"));
676 #endif
677 fprintf (stream, _("\
678 -r Ignored for compatibility with rc\n\
679 @<file> Read options from <file>\n\
680 -h --help Print this help message\n\
681 -V --version Print version information\n"));
682 fprintf (stream, _("\
683 FORMAT is one of rc, res, or coff, and is deduced from the file name\n\
684 extension if not specified. A single file name is an input file.\n\
685 No input-file is stdin, default rc. No output-file is stdout, default rc.\n"));
686
687 list_supported_targets (program_name, stream);
688
689 if (REPORT_BUGS_TO[0] && status == 0)
690 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
691
692 exit (status);
693 }
694
695 /* Quote characters that will confuse the shell when we run the preprocessor. */
696
697 static const char *
698 quot (const char *string)
699 {
700 static char *buf = 0;
701 static int buflen = 0;
702 int slen = strlen (string);
703 const char *src;
704 char *dest;
705
706 if ((buflen < slen * 2 + 3) || ! buf)
707 {
708 buflen = slen * 2 + 3;
709 free (buf);
710 buf = (char *) xmalloc (buflen);
711 }
712
713 #if defined (_WIN32) && !defined (__CYGWIN__)
714 /* For Windows shells, quote "like this". */
715 {
716 bfd_boolean quoted = FALSE;
717
718 dest = buf;
719 if (strchr (string, ' '))
720 {
721 quoted = TRUE;
722 *dest++ = '"';
723 }
724
725 for (src = string; *src; src++, dest++)
726 {
727 /* Escape-protect embedded double quotes. */
728 if (quoted && *src == '"')
729 *dest++ = '\\';
730 *dest = *src;
731 }
732
733 if (quoted)
734 *dest++ = '"';
735 }
736 #else
737 for (src = string, dest = buf; *src; src++, dest++)
738 {
739 if (*src == '(' || *src == ')' || *src == ' ')
740 *dest++ = '\\';
741 *dest = *src;
742 }
743 #endif
744 *dest = 0;
745 return buf;
746 }
747
748 /* Long options. */
749
750 enum option_values
751 {
752 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
753 OPTION_PREPROCESSOR = 150,
754 OPTION_USE_TEMP_FILE,
755 OPTION_NO_USE_TEMP_FILE,
756 OPTION_YYDEBUG,
757 OPTION_INCLUDE_DIR,
758 OPTION_PREPROCESSOR_ARG
759 };
760
761 static const struct option long_options[] =
762 {
763 {"input", required_argument, 0, 'i'},
764 {"output", required_argument, 0, 'o'},
765 {"input-format", required_argument, 0, 'J'},
766 {"output-format", required_argument, 0, 'O'},
767 {"target", required_argument, 0, 'F'},
768 {"preprocessor", required_argument, 0, OPTION_PREPROCESSOR},
769 {"preprocessor-arg", required_argument, 0, OPTION_PREPROCESSOR_ARG},
770 {"include-dir", required_argument, 0, OPTION_INCLUDE_DIR},
771 {"define", required_argument, 0, 'D'},
772 {"undefine", required_argument, 0, 'U'},
773 {"verbose", no_argument, 0, 'v'},
774 {"codepage", required_argument, 0, 'c'},
775 {"language", required_argument, 0, 'l'},
776 {"use-temp-file", no_argument, 0, OPTION_USE_TEMP_FILE},
777 {"no-use-temp-file", no_argument, 0, OPTION_NO_USE_TEMP_FILE},
778 {"yydebug", no_argument, 0, OPTION_YYDEBUG},
779 {"version", no_argument, 0, 'V'},
780 {"help", no_argument, 0, 'h'},
781 {0, no_argument, 0, 0}
782 };
783
784 void
785 windres_add_include_dir (const char *p)
786 {
787 struct include_dir *n, **pp;
788
789 /* Computing paths is often complicated and error prone.
790 The easiest way to check for mistakes is at the time
791 we add them to include_dirs. */
792 assert (p != NULL);
793 assert (*p != '\0');
794
795 n = xmalloc (sizeof *n);
796 n->next = NULL;
797 n->dir = (char * ) p;
798
799 for (pp = &include_dirs; *pp != NULL; pp = &(*pp)->next)
800 ;
801 *pp = n;
802 }
803
804 /* This keeps gcc happy when using -Wmissing-prototypes -Wstrict-prototypes. */
805 int main (int, char **);
806
807 /* The main function. */
808
809 int
810 main (int argc, char **argv)
811 {
812 int c;
813 char *input_filename;
814 char *output_filename;
815 enum res_format input_format;
816 enum res_format input_format_tmp;
817 enum res_format output_format;
818 char *target;
819 char *preprocessor;
820 char *preprocargs;
821 const char *quotedarg;
822 int language;
823 rc_res_directory *resources;
824 int use_temp_file;
825
826 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
827 setlocale (LC_MESSAGES, "");
828 #endif
829 #if defined (HAVE_SETLOCALE)
830 setlocale (LC_CTYPE, "");
831 #endif
832 bindtextdomain (PACKAGE, LOCALEDIR);
833 textdomain (PACKAGE);
834
835 program_name = argv[0];
836 xmalloc_set_program_name (program_name);
837 bfd_set_error_program_name (program_name);
838
839 expandargv (&argc, &argv);
840
841 if (bfd_init () != BFD_INIT_MAGIC)
842 fatal (_("fatal error: libbfd ABI mismatch"));
843 set_default_bfd_target ();
844
845 res_init ();
846
847 input_filename = NULL;
848 output_filename = NULL;
849 input_format = RES_FORMAT_UNKNOWN;
850 output_format = RES_FORMAT_UNKNOWN;
851 target = NULL;
852 preprocessor = NULL;
853 preprocargs = NULL;
854 language = 0x409; /* LANG_ENGLISH, SUBLANG_ENGLISH_US. */
855 use_temp_file = 0;
856
857 while ((c = getopt_long (argc, argv, "c:f:i:l:o:I:J:O:F:D:U:rhHvV", long_options,
858 (int *) 0)) != EOF)
859 {
860 switch (c)
861 {
862 case 'c':
863 {
864 rc_uint_type ncp;
865
866 if (optarg[0] == '0' && (optarg[1] == 'x' || optarg[1] == 'X'))
867 ncp = (rc_uint_type) strtol (optarg + 2, NULL, 16);
868 else
869 ncp = (rc_uint_type) strtol (optarg, NULL, 10);
870 if (ncp == CP_UTF16 || ! unicode_is_valid_codepage (ncp))
871 fatal (_("invalid codepage specified.\n"));
872 wind_default_codepage = wind_current_codepage = ncp;
873 }
874 break;
875
876 case 'i':
877 input_filename = optarg;
878 break;
879
880 case 'f':
881 /* For compatibility with rc we accept "-fo <name>" as being the
882 equivalent of "-o <name>". We do not advertise this fact
883 though, as we do not want users to use non-GNU like command
884 line switches. */
885 if (*optarg != 'o')
886 fatal (_("invalid option -f\n"));
887 optarg++;
888 if (* optarg == 0)
889 {
890 if (optind == argc)
891 fatal (_("No filename following the -fo option.\n"));
892 optarg = argv [optind++];
893 }
894 /* Fall through. */
895
896 case 'o':
897 output_filename = optarg;
898 break;
899
900 case 'J':
901 input_format = format_from_name (optarg, 1);
902 break;
903
904 case 'O':
905 output_format = format_from_name (optarg, 1);
906 break;
907
908 case 'F':
909 target = optarg;
910 break;
911
912 case OPTION_PREPROCESSOR:
913 if (strchr (optarg, ' '))
914 {
915 if (asprintf (& preprocessor, "\"%s\"", optarg) == -1)
916 preprocessor = optarg;
917 }
918 else
919 preprocessor = optarg;
920 break;
921
922 case OPTION_PREPROCESSOR_ARG:
923 if (preprocargs == NULL)
924 {
925 quotedarg = quot (optarg);
926 preprocargs = xstrdup (quotedarg);
927 }
928 else
929 {
930 char *n;
931
932 quotedarg = quot (optarg);
933 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 2);
934 sprintf (n, "%s %s", preprocargs, quotedarg);
935 free (preprocargs);
936 preprocargs = n;
937 }
938 break;
939
940 case 'D':
941 case 'U':
942 if (preprocargs == NULL)
943 {
944 quotedarg = quot (optarg);
945 preprocargs = xmalloc (strlen (quotedarg) + 3);
946 sprintf (preprocargs, "-%c%s", c, quotedarg);
947 }
948 else
949 {
950 char *n;
951
952 quotedarg = quot (optarg);
953 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
954 sprintf (n, "%s -%c%s", preprocargs, c, quotedarg);
955 free (preprocargs);
956 preprocargs = n;
957 }
958 break;
959
960 case 'r':
961 /* Ignored for compatibility with rc. */
962 break;
963
964 case 'v':
965 verbose ++;
966 break;
967
968 case 'I':
969 /* For backward compatibility, should be removed in the future. */
970 input_format_tmp = format_from_name (optarg, 0);
971 if (input_format_tmp != RES_FORMAT_UNKNOWN)
972 {
973 struct stat statbuf;
974 char modebuf[11];
975
976 if (stat (optarg, & statbuf) == 0
977 /* Coded this way to avoid importing knowledge of S_ISDIR into this file. */
978 && (mode_string (statbuf.st_mode, modebuf), modebuf[0] == 'd'))
979 /* We have a -I option with a directory name that just happens
980 to match a format name as well. eg: -I res Assume that the
981 user knows what they are doing and do not complain. */
982 ;
983 else
984 {
985 fprintf (stderr,
986 _("Option -I is deprecated for setting the input format, please use -J instead.\n"));
987 input_format = input_format_tmp;
988 break;
989 }
990 }
991 /* Fall through. */
992
993 case OPTION_INCLUDE_DIR:
994 if (preprocargs == NULL)
995 {
996 quotedarg = quot (optarg);
997 preprocargs = xmalloc (strlen (quotedarg) + 3);
998 sprintf (preprocargs, "-I%s", quotedarg);
999 }
1000 else
1001 {
1002 char *n;
1003
1004 quotedarg = quot (optarg);
1005 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
1006 sprintf (n, "%s -I%s", preprocargs, quotedarg);
1007 free (preprocargs);
1008 preprocargs = n;
1009 }
1010
1011 windres_add_include_dir (optarg);
1012
1013 break;
1014
1015 case 'l':
1016 language = strtol (optarg, (char **) NULL, 16);
1017 break;
1018
1019 case OPTION_USE_TEMP_FILE:
1020 use_temp_file = 1;
1021 break;
1022
1023 case OPTION_NO_USE_TEMP_FILE:
1024 use_temp_file = 0;
1025 break;
1026
1027 #ifdef YYDEBUG
1028 case OPTION_YYDEBUG:
1029 yydebug = 1;
1030 break;
1031 #endif
1032
1033 case 'h':
1034 case 'H':
1035 usage (stdout, 0);
1036 break;
1037
1038 case 'V':
1039 print_version ("windres");
1040 break;
1041
1042 default:
1043 usage (stderr, 1);
1044 break;
1045 }
1046 }
1047
1048 if (input_filename == NULL && optind < argc)
1049 {
1050 input_filename = argv[optind];
1051 ++optind;
1052 }
1053
1054 if (output_filename == NULL && optind < argc)
1055 {
1056 output_filename = argv[optind];
1057 ++optind;
1058 }
1059
1060 if (argc != optind)
1061 usage (stderr, 1);
1062
1063 if (input_format == RES_FORMAT_UNKNOWN)
1064 {
1065 if (input_filename == NULL)
1066 input_format = RES_FORMAT_RC;
1067 else
1068 input_format = format_from_filename (input_filename, 1);
1069 }
1070
1071 if (output_format == RES_FORMAT_UNKNOWN)
1072 {
1073 if (output_filename == NULL)
1074 output_format = RES_FORMAT_RC;
1075 else
1076 output_format = format_from_filename (output_filename, 0);
1077 }
1078
1079 set_endianness (NULL, target);
1080
1081 /* Read the input file. */
1082 switch (input_format)
1083 {
1084 default:
1085 abort ();
1086 case RES_FORMAT_RC:
1087 resources = read_rc_file (input_filename, preprocessor, preprocargs,
1088 language, use_temp_file);
1089 break;
1090 case RES_FORMAT_RES:
1091 resources = read_res_file (input_filename);
1092 break;
1093 case RES_FORMAT_COFF:
1094 resources = read_coff_rsrc (input_filename, target);
1095 break;
1096 }
1097
1098 if (resources == NULL)
1099 fatal (_("no resources"));
1100
1101 /* Sort the resources. This is required for COFF, convenient for
1102 rc, and unimportant for res. */
1103 resources = sort_resources (resources);
1104
1105 /* Write the output file. */
1106 reswr_init ();
1107
1108 switch (output_format)
1109 {
1110 default:
1111 abort ();
1112 case RES_FORMAT_RC:
1113 write_rc_file (output_filename, resources);
1114 break;
1115 case RES_FORMAT_RES:
1116 write_res_file (output_filename, resources);
1117 break;
1118 case RES_FORMAT_COFF:
1119 write_coff_file (output_filename, target, resources);
1120 break;
1121 }
1122
1123 xexit (0);
1124 return 0;
1125 }
1126
1127 static void
1128 set_endianness (bfd *abfd, const char *target)
1129 {
1130 const bfd_target *target_vec;
1131
1132 def_target_arch = NULL;
1133 target_vec = bfd_get_target_info (target, abfd, &target_is_bigendian, NULL,
1134 &def_target_arch);
1135 if (! target_vec)
1136 fatal ("Can't detect target endianness and architecture.");
1137 if (! def_target_arch)
1138 fatal ("Can't detect architecture.");
1139 }
1140
1141 bfd *
1142 windres_open_as_binary (const char *filename, int rdmode)
1143 {
1144 bfd *abfd;
1145
1146 abfd = (rdmode ? bfd_openr (filename, "binary") : bfd_openw (filename, "binary"));
1147 if (! abfd)
1148 fatal ("can't open `%s' for %s", filename, (rdmode ? "input" : "output"));
1149
1150 if (rdmode && ! bfd_check_format (abfd, bfd_object))
1151 fatal ("can't open `%s' for input.", filename);
1152
1153 return abfd;
1154 }
1155
1156 void
1157 set_windres_bfd_endianness (windres_bfd *wrbfd, int is_bigendian)
1158 {
1159 assert (!! wrbfd);
1160 switch (WR_KIND(wrbfd))
1161 {
1162 case WR_KIND_BFD_BIN_L:
1163 if (is_bigendian)
1164 WR_KIND(wrbfd) = WR_KIND_BFD_BIN_B;
1165 break;
1166 case WR_KIND_BFD_BIN_B:
1167 if (! is_bigendian)
1168 WR_KIND(wrbfd) = WR_KIND_BFD_BIN_L;
1169 break;
1170 default:
1171 /* only binary bfd can be overriden. */
1172 abort ();
1173 }
1174 }
1175
1176 void
1177 set_windres_bfd (windres_bfd *wrbfd, bfd *abfd, asection *sec, rc_uint_type kind)
1178 {
1179 assert (!! wrbfd);
1180 switch (kind)
1181 {
1182 case WR_KIND_TARGET:
1183 abfd = NULL;
1184 sec = NULL;
1185 break;
1186 case WR_KIND_BFD:
1187 case WR_KIND_BFD_BIN_L:
1188 case WR_KIND_BFD_BIN_B:
1189 assert (!! abfd);
1190 assert (!!sec);
1191 break;
1192 default:
1193 abort ();
1194 }
1195 WR_KIND(wrbfd) = kind;
1196 WR_BFD(wrbfd) = abfd;
1197 WR_SECTION(wrbfd) = sec;
1198 }
1199
1200 void
1201 set_windres_bfd_content (windres_bfd *wrbfd, const void *data, rc_uint_type off,
1202 rc_uint_type length)
1203 {
1204 if (WR_KIND(wrbfd) != WR_KIND_TARGET)
1205 {
1206 if (! bfd_set_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length))
1207 bfd_fatal ("bfd_set_section_contents");
1208 }
1209 else
1210 abort ();
1211 }
1212
1213 void
1214 get_windres_bfd_content (windres_bfd *wrbfd, void *data, rc_uint_type off,
1215 rc_uint_type length)
1216 {
1217 if (WR_KIND(wrbfd) != WR_KIND_TARGET)
1218 {
1219 if (! bfd_get_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length))
1220 bfd_fatal ("bfd_get_section_contents");
1221 }
1222 else
1223 abort ();
1224 }
1225
1226 void
1227 windres_put_8 (windres_bfd *wrbfd, void *p, rc_uint_type value)
1228 {
1229 switch (WR_KIND(wrbfd))
1230 {
1231 case WR_KIND_TARGET:
1232 target_put_8 (p, value);
1233 break;
1234 case WR_KIND_BFD:
1235 case WR_KIND_BFD_BIN_L:
1236 case WR_KIND_BFD_BIN_B:
1237 bfd_put_8 (WR_BFD(wrbfd), value, p);
1238 break;
1239 default:
1240 abort ();
1241 }
1242 }
1243
1244 void
1245 windres_put_16 (windres_bfd *wrbfd, void *data, rc_uint_type value)
1246 {
1247 switch (WR_KIND(wrbfd))
1248 {
1249 case WR_KIND_TARGET:
1250 target_put_16 (data, value);
1251 break;
1252 case WR_KIND_BFD:
1253 case WR_KIND_BFD_BIN_B:
1254 bfd_put_16 (WR_BFD(wrbfd), value, data);
1255 break;
1256 case WR_KIND_BFD_BIN_L:
1257 bfd_putl16 (value, data);
1258 break;
1259 default:
1260 abort ();
1261 }
1262 }
1263
1264 void
1265 windres_put_32 (windres_bfd *wrbfd, void *data, rc_uint_type value)
1266 {
1267 switch (WR_KIND(wrbfd))
1268 {
1269 case WR_KIND_TARGET:
1270 target_put_32 (data, value);
1271 break;
1272 case WR_KIND_BFD:
1273 case WR_KIND_BFD_BIN_B:
1274 bfd_put_32 (WR_BFD(wrbfd), value, data);
1275 break;
1276 case WR_KIND_BFD_BIN_L:
1277 bfd_putl32 (value, data);
1278 break;
1279 default:
1280 abort ();
1281 }
1282 }
1283
1284 rc_uint_type
1285 windres_get_8 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1286 {
1287 if (length < 1)
1288 fatal ("windres_get_8: unexpected eob.");
1289 switch (WR_KIND(wrbfd))
1290 {
1291 case WR_KIND_TARGET:
1292 return target_get_8 (data, length);
1293 case WR_KIND_BFD:
1294 case WR_KIND_BFD_BIN_B:
1295 case WR_KIND_BFD_BIN_L:
1296 return bfd_get_8 (WR_BFD(wrbfd), data);
1297 default:
1298 abort ();
1299 }
1300 return 0;
1301 }
1302
1303 rc_uint_type
1304 windres_get_16 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1305 {
1306 if (length < 2)
1307 fatal ("windres_get_16: unexpected eob.");
1308 switch (WR_KIND(wrbfd))
1309 {
1310 case WR_KIND_TARGET:
1311 return target_get_16 (data, length);
1312 case WR_KIND_BFD:
1313 case WR_KIND_BFD_BIN_B:
1314 return bfd_get_16 (WR_BFD(wrbfd), data);
1315 case WR_KIND_BFD_BIN_L:
1316 return bfd_getl16 (data);
1317 default:
1318 abort ();
1319 }
1320 return 0;
1321 }
1322
1323 rc_uint_type
1324 windres_get_32 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1325 {
1326 if (length < 4)
1327 fatal ("windres_get_32: unexpected eob.");
1328 switch (WR_KIND(wrbfd))
1329 {
1330 case WR_KIND_TARGET:
1331 return target_get_32 (data, length);
1332 case WR_KIND_BFD:
1333 case WR_KIND_BFD_BIN_B:
1334 return bfd_get_32 (WR_BFD(wrbfd), data);
1335 case WR_KIND_BFD_BIN_L:
1336 return bfd_getl32 (data);
1337 default:
1338 abort ();
1339 }
1340 return 0;
1341 }
1342
1343 static rc_uint_type
1344 target_get_8 (const void *p, rc_uint_type length)
1345 {
1346 rc_uint_type ret;
1347
1348 if (length < 1)
1349 fatal ("Resource too small for getting 8-bit value.");
1350
1351 ret = (rc_uint_type) *((const bfd_byte *) p);
1352 return ret & 0xff;
1353 }
1354
1355 static rc_uint_type
1356 target_get_16 (const void *p, rc_uint_type length)
1357 {
1358 if (length < 2)
1359 fatal ("Resource too small for getting 16-bit value.");
1360
1361 if (target_is_bigendian)
1362 return bfd_getb16 (p);
1363 else
1364 return bfd_getl16 (p);
1365 }
1366
1367 static rc_uint_type
1368 target_get_32 (const void *p, rc_uint_type length)
1369 {
1370 if (length < 4)
1371 fatal ("Resource too small for getting 32-bit value.");
1372
1373 if (target_is_bigendian)
1374 return bfd_getb32 (p);
1375 else
1376 return bfd_getl32 (p);
1377 }
1378
1379 static void
1380 target_put_8 (void *p, rc_uint_type value)
1381 {
1382 assert (!! p);
1383 *((bfd_byte *) p)=(bfd_byte) value;
1384 }
1385
1386 static void
1387 target_put_16 (void *p, rc_uint_type value)
1388 {
1389 assert (!! p);
1390
1391 if (target_is_bigendian)
1392 bfd_putb16 (value, p);
1393 else
1394 bfd_putl16 (value, p);
1395 }
1396
1397 static void
1398 target_put_32 (void *p, rc_uint_type value)
1399 {
1400 assert (!! p);
1401
1402 if (target_is_bigendian)
1403 bfd_putb32 (value, p);
1404 else
1405 bfd_putl32 (value, p);
1406 }
1407
1408 static int isInComment = 0;
1409
1410 int wr_printcomment (FILE *e, const char *fmt, ...)
1411 {
1412 va_list arg;
1413 int r = 0;
1414
1415 if (isInComment)
1416 r += fprintf (e, "\n ");
1417 else
1418 fprintf (e, "/* ");
1419 isInComment = 1;
1420 if (fmt == NULL)
1421 return r;
1422 va_start (arg, fmt);
1423 r += vfprintf (e, fmt, arg);
1424 va_end (arg);
1425 return r;
1426 }
1427
1428 int wr_print (FILE *e, const char *fmt, ...)
1429 {
1430 va_list arg;
1431 int r = 0;
1432 if (isInComment)
1433 r += fprintf (e, ". */\n");
1434 isInComment = 0;
1435 if (! fmt)
1436 return r;
1437 va_start (arg, fmt);
1438 r += vfprintf (e, fmt, arg);
1439 va_end (arg);
1440 return r;
1441 }