Add global parameters.
[binutils.git] / binutils / windres.c
blobac643ad59a01eeed8633951c3a7ee0ae6fbf0e9f
1 /* windres.c -- a program to manipulate Windows resources
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5 Rewritten by Kai Tietz, Onevision.
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
24 /* This program can read and write Windows resources in various
25 formats. In particular, it can act like the rc resource compiler
26 program, and it can act like the cvtres res to COFF conversion
27 program.
29 It is based on information taken from the following sources:
31 * Microsoft documentation.
33 * The rcl program, written by Gunther Ebert
34 <gunther.ebert@ixos-leipzig.de>.
36 * The res2coff program, written by Pedro A. Aranda <paag@tid.es>. */
38 #include "sysdep.h"
39 #include <assert.h>
40 #include <time.h>
41 #include "bfd.h"
42 #include "getopt.h"
43 #include "bucomm.h"
44 #include "libiberty.h"
45 #include "safe-ctype.h"
46 #include "obstack.h"
47 #include "windres.h"
49 /* Defined in bfd/binary.c. Used to set architecture and machine of input
50 binary files. */
51 extern enum bfd_architecture bfd_external_binary_architecture;
52 extern unsigned long bfd_external_machine;
54 /* Used by resrc.c at least. */
56 int verbose = 0;
58 int target_is_bigendian = 0;
59 const char *def_target_arch;
61 static void set_endianess (bfd *, const char *);
63 /* An enumeration of format types. */
65 enum res_format
67 /* Unknown format. */
68 RES_FORMAT_UNKNOWN,
69 /* Textual RC file. */
70 RES_FORMAT_RC,
71 /* Binary RES file. */
72 RES_FORMAT_RES,
73 /* COFF file. */
74 RES_FORMAT_COFF
77 /* A structure used to map between format types and strings. */
79 struct format_map
81 const char *name;
82 enum res_format format;
85 /* A mapping between names and format types. */
87 static const struct format_map format_names[] =
89 { "rc", RES_FORMAT_RC },
90 { "res", RES_FORMAT_RES },
91 { "coff", RES_FORMAT_COFF },
92 { NULL, RES_FORMAT_UNKNOWN }
95 /* A mapping from file extensions to format types. */
97 static const struct format_map format_fileexts[] =
99 { "rc", RES_FORMAT_RC },
100 { "res", RES_FORMAT_RES },
101 { "exe", RES_FORMAT_COFF },
102 { "obj", RES_FORMAT_COFF },
103 { "o", RES_FORMAT_COFF },
104 { NULL, RES_FORMAT_UNKNOWN }
107 /* A list of include directories. */
109 struct include_dir
111 struct include_dir *next;
112 char *dir;
115 static struct include_dir *include_dirs;
117 /* Static functions. */
119 static void res_init (void);
120 static int extended_menuitems (const rc_menuitem *);
121 static enum res_format format_from_name (const char *, int);
122 static enum res_format format_from_filename (const char *, int);
123 static void usage (FILE *, int);
124 static int cmp_res_entry (const void *, const void *);
125 static rc_res_directory *sort_resources (rc_res_directory *);
126 static void reswr_init (void);
127 static const char * quot (const char *);
129 static rc_uint_type target_get_8 (const void *, rc_uint_type);
130 static void target_put_8 (void *, rc_uint_type);
131 static rc_uint_type target_get_16 (const void *, rc_uint_type);
132 static void target_put_16 (void *, rc_uint_type);
133 static rc_uint_type target_get_32 (const void *, rc_uint_type);
134 static void target_put_32 (void *, rc_uint_type);
137 /* When we are building a resource tree, we allocate everything onto
138 an obstack, so that we can free it all at once if we want. */
140 #define obstack_chunk_alloc xmalloc
141 #define obstack_chunk_free free
143 /* The resource building obstack. */
145 static struct obstack res_obstack;
147 /* Initialize the resource building obstack. */
149 static void
150 res_init (void)
152 obstack_init (&res_obstack);
155 /* Allocate space on the resource building obstack. */
157 void *
158 res_alloc (rc_uint_type bytes)
160 return (void *) obstack_alloc (&res_obstack, (size_t) bytes);
163 /* We also use an obstack to save memory used while writing out a set
164 of resources. */
166 static struct obstack reswr_obstack;
168 /* Initialize the resource writing obstack. */
170 static void
171 reswr_init (void)
173 obstack_init (&reswr_obstack);
176 /* Allocate space on the resource writing obstack. */
178 void *
179 reswr_alloc (rc_uint_type bytes)
181 return (void *) obstack_alloc (&reswr_obstack, (size_t) bytes);
184 /* Open a file using the include directory search list. */
186 FILE *
187 open_file_search (const char *filename, const char *mode, const char *errmsg,
188 char **real_filename)
190 FILE *e;
191 struct include_dir *d;
193 e = fopen (filename, mode);
194 if (e != NULL)
196 *real_filename = xstrdup (filename);
197 return e;
200 if (errno == ENOENT)
202 for (d = include_dirs; d != NULL; d = d->next)
204 char *n;
206 n = (char *) xmalloc (strlen (d->dir) + strlen (filename) + 2);
207 sprintf (n, "%s/%s", d->dir, filename);
208 e = fopen (n, mode);
209 if (e != NULL)
211 *real_filename = n;
212 return e;
215 if (errno != ENOENT)
216 break;
220 fatal (_("can't open %s `%s': %s"), errmsg, filename, strerror (errno));
222 /* Return a value to avoid a compiler warning. */
223 return NULL;
226 /* Compare two resource ID's. We consider name entries to come before
227 numeric entries, because that is how they appear in the COFF .rsrc
228 section. */
231 res_id_cmp (rc_res_id a, rc_res_id b)
233 if (! a.named)
235 if (b.named)
236 return 1;
237 if (a.u.id > b.u.id)
238 return 1;
239 else if (a.u.id < b.u.id)
240 return -1;
241 else
242 return 0;
244 else
246 unichar *as, *ase, *bs, *bse;
248 if (! b.named)
249 return -1;
251 as = a.u.n.name;
252 ase = as + a.u.n.length;
253 bs = b.u.n.name;
254 bse = bs + b.u.n.length;
256 while (as < ase)
258 int i;
260 if (bs >= bse)
261 return 1;
262 i = (int) *as - (int) *bs;
263 if (i != 0)
264 return i;
265 ++as;
266 ++bs;
269 if (bs < bse)
270 return -1;
272 return 0;
276 /* Print a resource ID. */
278 void
279 res_id_print (FILE *stream, rc_res_id id, int quote)
281 if (! id.named)
282 fprintf (stream, "%u", (int) id.u.id);
283 else
285 if (quote)
286 unicode_print_quoted (stream, id.u.n.name, id.u.n.length);
287 else
288 unicode_print (stream, id.u.n.name, id.u.n.length);
292 /* Print a list of resource ID's. */
294 void
295 res_ids_print (FILE *stream, int cids, const rc_res_id *ids)
297 int i;
299 for (i = 0; i < cids; i++)
301 res_id_print (stream, ids[i], 1);
302 if (i + 1 < cids)
303 fprintf (stream, ": ");
307 /* Convert an ASCII string to a resource ID. */
309 void
310 res_string_to_id (rc_res_id *res_id, const char *string)
312 res_id->named = 1;
313 unicode_from_ascii (&res_id->u.n.length, &res_id->u.n.name, string);
316 /* Convert an unicode string to a resource ID. */
317 void
318 res_unistring_to_id (rc_res_id *res_id, const unichar *u)
320 res_id->named = 1;
321 res_id->u.n.length = unichar_len (u);
322 res_id->u.n.name = unichar_dup_uppercase (u);
325 /* Define a resource. The arguments are the resource tree, RESOURCES,
326 and the location at which to put it in the tree, CIDS and IDS.
327 This returns a newly allocated rc_res_resource structure, which the
328 caller is expected to initialize. If DUPOK is non-zero, then if a
329 resource with this ID exists, it is returned. Otherwise, a warning
330 is issued, and a new resource is created replacing the existing
331 one. */
333 rc_res_resource *
334 define_resource (rc_res_directory **resources, int cids,
335 const rc_res_id *ids, int dupok)
337 rc_res_entry *re = NULL;
338 int i;
340 assert (cids > 0);
341 for (i = 0; i < cids; i++)
343 rc_res_entry **pp;
345 if (*resources == NULL)
347 static unsigned int timeval;
349 /* Use the same timestamp for every resource created in a
350 single run. */
351 if (timeval == 0)
352 timeval = time (NULL);
354 *resources = ((rc_res_directory *)
355 res_alloc (sizeof (rc_res_directory)));
356 (*resources)->characteristics = 0;
357 (*resources)->time = timeval;
358 (*resources)->major = 0;
359 (*resources)->minor = 0;
360 (*resources)->entries = NULL;
363 for (pp = &(*resources)->entries; *pp != NULL; pp = &(*pp)->next)
364 if (res_id_cmp ((*pp)->id, ids[i]) == 0)
365 break;
367 if (*pp != NULL)
368 re = *pp;
369 else
371 re = (rc_res_entry *) res_alloc (sizeof (rc_res_entry));
372 re->next = NULL;
373 re->id = ids[i];
374 if ((i + 1) < cids)
376 re->subdir = 1;
377 re->u.dir = NULL;
379 else
381 re->subdir = 0;
382 re->u.res = NULL;
385 *pp = re;
388 if ((i + 1) < cids)
390 if (! re->subdir)
392 fprintf (stderr, "%s: ", program_name);
393 res_ids_print (stderr, i, ids);
394 fprintf (stderr, _(": expected to be a directory\n"));
395 xexit (1);
398 resources = &re->u.dir;
402 if (re->subdir)
404 fprintf (stderr, "%s: ", program_name);
405 res_ids_print (stderr, cids, ids);
406 fprintf (stderr, _(": expected to be a leaf\n"));
407 xexit (1);
410 if (re->u.res != NULL)
412 if (dupok)
413 return re->u.res;
415 fprintf (stderr, _("%s: warning: "), program_name);
416 res_ids_print (stderr, cids, ids);
417 fprintf (stderr, _(": duplicate value\n"));
420 re->u.res = ((rc_res_resource *)
421 res_alloc (sizeof (rc_res_resource)));
422 memset (re->u.res, 0, sizeof (rc_res_resource));
424 re->u.res->type = RES_TYPE_UNINITIALIZED;
425 return re->u.res;
428 /* Define a standard resource. This is a version of define_resource
429 that just takes type, name, and language arguments. */
431 rc_res_resource *
432 define_standard_resource (rc_res_directory **resources, int type,
433 rc_res_id name, rc_uint_type language, int dupok)
435 rc_res_id a[3];
437 a[0].named = 0;
438 a[0].u.id = type;
439 a[1] = name;
440 a[2].named = 0;
441 a[2].u.id = language;
442 return define_resource (resources, 3, a, dupok);
445 /* Comparison routine for resource sorting. */
447 static int
448 cmp_res_entry (const void *p1, const void *p2)
450 const rc_res_entry **re1, **re2;
452 re1 = (const rc_res_entry **) p1;
453 re2 = (const rc_res_entry **) p2;
454 return res_id_cmp ((*re1)->id, (*re2)->id);
457 /* Sort the resources. */
459 static rc_res_directory *
460 sort_resources (rc_res_directory *resdir)
462 int c, i;
463 rc_res_entry *re;
464 rc_res_entry **a;
466 if (resdir->entries == NULL)
467 return resdir;
469 c = 0;
470 for (re = resdir->entries; re != NULL; re = re->next)
471 ++c;
473 /* This is a recursive routine, so using xmalloc is probably better
474 than alloca. */
475 a = (rc_res_entry **) xmalloc (c * sizeof (rc_res_entry *));
477 for (i = 0, re = resdir->entries; re != NULL; re = re->next, i++)
478 a[i] = re;
480 qsort (a, c, sizeof (rc_res_entry *), cmp_res_entry);
482 resdir->entries = a[0];
483 for (i = 0; i < c - 1; i++)
484 a[i]->next = a[i + 1];
485 a[i]->next = NULL;
487 free (a);
489 /* Now sort the subdirectories. */
491 for (re = resdir->entries; re != NULL; re = re->next)
492 if (re->subdir)
493 re->u.dir = sort_resources (re->u.dir);
495 return resdir;
498 /* Return whether the dialog resource DIALOG is a DIALOG or a
499 DIALOGEX. */
502 extended_dialog (const rc_dialog *dialog)
504 const rc_dialog_control *c;
506 if (dialog->ex != NULL)
507 return 1;
509 for (c = dialog->controls; c != NULL; c = c->next)
510 if (c->data != NULL || c->help != 0)
511 return 1;
513 return 0;
516 /* Return whether MENUITEMS are a MENU or a MENUEX. */
519 extended_menu (const rc_menu *menu)
521 return extended_menuitems (menu->items);
524 static int
525 extended_menuitems (const rc_menuitem *menuitems)
527 const rc_menuitem *mi;
529 for (mi = menuitems; mi != NULL; mi = mi->next)
531 if (mi->help != 0 || mi->state != 0)
532 return 1;
533 if (mi->popup != NULL && mi->id != 0)
534 return 1;
535 if ((mi->type
536 & ~ (MENUITEM_CHECKED
537 | MENUITEM_GRAYED
538 | MENUITEM_HELP
539 | MENUITEM_INACTIVE
540 | MENUITEM_MENUBARBREAK
541 | MENUITEM_MENUBREAK))
542 != 0)
543 return 1;
544 if (mi->popup != NULL)
546 if (extended_menuitems (mi->popup))
547 return 1;
551 return 0;
554 /* Convert a string to a format type, or exit if it can't be done. */
556 static enum res_format
557 format_from_name (const char *name, int exit_on_error)
559 const struct format_map *m;
561 for (m = format_names; m->name != NULL; m++)
562 if (strcasecmp (m->name, name) == 0)
563 break;
565 if (m->name == NULL && exit_on_error)
567 non_fatal (_("unknown format type `%s'"), name);
568 fprintf (stderr, _("%s: supported formats:"), program_name);
569 for (m = format_names; m->name != NULL; m++)
570 fprintf (stderr, " %s", m->name);
571 fprintf (stderr, "\n");
572 xexit (1);
575 return m->format;
578 /* Work out a format type given a file name. If INPUT is non-zero,
579 it's OK to look at the file itself. */
581 static enum res_format
582 format_from_filename (const char *filename, int input)
584 const char *ext;
585 FILE *e;
586 bfd_byte b1, b2, b3, b4, b5;
587 int magic;
589 /* If we have an extension, see if we recognize it as implying a
590 particular format. */
591 ext = strrchr (filename, '.');
592 if (ext != NULL)
594 const struct format_map *m;
596 ++ext;
597 for (m = format_fileexts; m->name != NULL; m++)
598 if (strcasecmp (m->name, ext) == 0)
599 return m->format;
602 /* If we don't recognize the name of an output file, assume it's a
603 COFF file. */
604 if (! input)
605 return RES_FORMAT_COFF;
607 /* Read the first few bytes of the file to see if we can guess what
608 it is. */
609 e = fopen (filename, FOPEN_RB);
610 if (e == NULL)
611 fatal ("%s: %s", filename, strerror (errno));
613 b1 = getc (e);
614 b2 = getc (e);
615 b3 = getc (e);
616 b4 = getc (e);
617 b5 = getc (e);
619 fclose (e);
621 /* A PE executable starts with 0x4d 0x5a. */
622 if (b1 == 0x4d && b2 == 0x5a)
623 return RES_FORMAT_COFF;
625 /* A COFF .o file starts with a COFF magic number. */
626 magic = (b2 << 8) | b1;
627 switch (magic)
629 case 0x14c: /* i386 */
630 case 0x166: /* MIPS */
631 case 0x184: /* Alpha */
632 case 0x268: /* 68k */
633 case 0x1f0: /* PowerPC */
634 case 0x290: /* PA */
635 return RES_FORMAT_COFF;
638 /* A RES file starts with 0x0 0x0 0x0 0x0 0x20 0x0 0x0 0x0. */
639 if (b1 == 0 && b2 == 0 && b3 == 0 && b4 == 0 && b5 == 0x20)
640 return RES_FORMAT_RES;
642 /* If every character is printable or space, assume it's an RC file. */
643 if ((ISPRINT (b1) || ISSPACE (b1))
644 && (ISPRINT (b2) || ISSPACE (b2))
645 && (ISPRINT (b3) || ISSPACE (b3))
646 && (ISPRINT (b4) || ISSPACE (b4))
647 && (ISPRINT (b5) || ISSPACE (b5)))
648 return RES_FORMAT_RC;
650 /* Otherwise, we give up. */
651 fatal (_("can not determine type of file `%s'; use the -J option"),
652 filename);
654 /* Return something to silence the compiler warning. */
655 return RES_FORMAT_UNKNOWN;
658 /* Print a usage message and exit. */
660 static void
661 usage (FILE *stream, int status)
663 fprintf (stream, _("Usage: %s [option(s)] [input-file] [output-file]\n"),
664 program_name);
665 fprintf (stream, _(" The options are:\n\
666 -i --input=<file> Name input file\n\
667 -o --output=<file> Name output file\n\
668 -J --input-format=<format> Specify input format\n\
669 -O --output-format=<format> Specify output format\n\
670 -F --target=<target> Specify COFF target\n\
671 --preprocessor=<program> Program to use to preprocess rc file\n\
672 -I --include-dir=<dir> Include directory when preprocessing rc file\n\
673 -D --define <sym>[=<val>] Define SYM when preprocessing rc file\n\
674 -U --undefine <sym> Undefine SYM when preprocessing rc file\n\
675 -v --verbose Verbose - tells you what it's doing\n\
676 -c --codepage=<codepage> Specify default codepage\n\
677 -l --language=<val> Set language when reading rc file\n\
678 --use-temp-file Use a temporary file instead of popen to read\n\
679 the preprocessor output\n\
680 --no-use-temp-file Use popen (default)\n"));
681 #ifdef YYDEBUG
682 fprintf (stream, _("\
683 --yydebug Turn on parser debugging\n"));
684 #endif
685 fprintf (stream, _("\
686 -r Ignored for compatibility with rc\n\
687 @<file> Read options from <file>\n\
688 -h --help Print this help message\n\
689 -V --version Print version information\n"));
690 fprintf (stream, _("\
691 FORMAT is one of rc, res, or coff, and is deduced from the file name\n\
692 extension if not specified. A single file name is an input file.\n\
693 No input-file is stdin, default rc. No output-file is stdout, default rc.\n"));
695 list_supported_targets (program_name, stream);
697 if (REPORT_BUGS_TO[0] && status == 0)
698 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
700 exit (status);
703 /* Quote characters that will confuse the shell when we run the preprocessor. */
705 static const char *
706 quot (const char *string)
708 static char *buf = 0;
709 static int buflen = 0;
710 int slen = strlen (string);
711 const char *src;
712 char *dest;
714 if ((buflen < slen * 2 + 2) || ! buf)
716 buflen = slen * 2 + 2;
717 if (buf)
718 free (buf);
719 buf = (char *) xmalloc (buflen);
722 for (src=string, dest=buf; *src; src++, dest++)
724 if (*src == '(' || *src == ')' || *src == ' ')
725 *dest++ = '\\';
726 *dest = *src;
728 *dest = 0;
729 return buf;
732 /* Long options. */
734 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
736 #define OPTION_PREPROCESSOR 150
737 #define OPTION_USE_TEMP_FILE (OPTION_PREPROCESSOR + 1)
738 #define OPTION_NO_USE_TEMP_FILE (OPTION_USE_TEMP_FILE + 1)
739 #define OPTION_YYDEBUG (OPTION_NO_USE_TEMP_FILE + 1)
741 static const struct option long_options[] =
743 {"input", required_argument, 0, 'i'},
744 {"output", required_argument, 0, 'o'},
745 {"input-format", required_argument, 0, 'J'},
746 {"output-format", required_argument, 0, 'O'},
747 {"target", required_argument, 0, 'F'},
748 {"preprocessor", required_argument, 0, OPTION_PREPROCESSOR},
749 {"include-dir", required_argument, 0, 'I'},
750 {"define", required_argument, 0, 'D'},
751 {"undefine", required_argument, 0, 'U'},
752 {"verbose", no_argument, 0, 'v'},
753 {"codepage", required_argument, 0, 'c'},
754 {"language", required_argument, 0, 'l'},
755 {"use-temp-file", no_argument, 0, OPTION_USE_TEMP_FILE},
756 {"no-use-temp-file", no_argument, 0, OPTION_NO_USE_TEMP_FILE},
757 {"yydebug", no_argument, 0, OPTION_YYDEBUG},
758 {"version", no_argument, 0, 'V'},
759 {"help", no_argument, 0, 'h'},
760 {0, no_argument, 0, 0}
763 void
764 windres_add_include_dir (const char *p)
766 struct include_dir *n, **pp;
768 n = xmalloc (sizeof *n);
769 n->next = NULL;
770 n->dir = (char * ) p;
772 for (pp = &include_dirs; *pp != NULL; pp = &(*pp)->next)
774 *pp = n;
777 /* This keeps gcc happy when using -Wmissing-prototypes -Wstrict-prototypes. */
778 int main (int, char **);
780 /* The main function. */
783 main (int argc, char **argv)
785 int c;
786 char *input_filename;
787 char *output_filename;
788 enum res_format input_format;
789 enum res_format input_format_tmp;
790 enum res_format output_format;
791 char *target;
792 char *preprocessor;
793 char *preprocargs;
794 const char *quotedarg;
795 int language;
796 rc_res_directory *resources;
797 int use_temp_file;
799 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
800 setlocale (LC_MESSAGES, "");
801 #endif
802 #if defined (HAVE_SETLOCALE)
803 setlocale (LC_CTYPE, "");
804 #endif
805 bindtextdomain (PACKAGE, LOCALEDIR);
806 textdomain (PACKAGE);
808 program_name = argv[0];
809 xmalloc_set_program_name (program_name);
811 expandargv (&argc, &argv);
813 bfd_init ();
814 set_default_bfd_target ();
816 res_init ();
818 input_filename = NULL;
819 output_filename = NULL;
820 input_format = RES_FORMAT_UNKNOWN;
821 output_format = RES_FORMAT_UNKNOWN;
822 target = NULL;
823 preprocessor = NULL;
824 preprocargs = NULL;
825 language = 0x409; /* LANG_ENGLISH, SUBLANG_ENGLISH_US. */
826 use_temp_file = 0;
828 while ((c = getopt_long (argc, argv, "c:f:i:l:o:I:J:O:F:D:U:rhHvV", long_options,
829 (int *) 0)) != EOF)
831 switch (c)
833 case 'c':
835 rc_uint_type ncp;
837 if (optarg[0] == '0' && (optarg[1] == 'x' || optarg[1] == 'X'))
838 ncp = (rc_uint_type) strtol (optarg + 2, NULL, 16);
839 else
840 ncp = (rc_uint_type) strtol (optarg, NULL, 10);
841 if (ncp == CP_UTF16 || ! unicode_is_valid_codepage (ncp))
842 fatal (_("invalid codepage specified.\n"));
843 wind_default_codepage = wind_current_codepage = ncp;
845 break;
847 case 'i':
848 input_filename = optarg;
849 break;
851 case 'f':
852 /* For compatibility with rc we accept "-fo <name>" as being the
853 equivalent of "-o <name>". We do not advertise this fact
854 though, as we do not want users to use non-GNU like command
855 line switches. */
856 if (*optarg != 'o')
857 fatal (_("invalid option -f\n"));
858 optarg++;
859 if (* optarg == 0)
861 if (optind == argc)
862 fatal (_("No filename following the -fo option.\n"));
863 optarg = argv [optind++];
865 /* Fall through. */
867 case 'o':
868 output_filename = optarg;
869 break;
871 case 'J':
872 input_format = format_from_name (optarg, 1);
873 break;
875 case 'O':
876 output_format = format_from_name (optarg, 1);
877 break;
879 case 'F':
880 target = optarg;
881 break;
883 case OPTION_PREPROCESSOR:
884 preprocessor = optarg;
885 break;
887 case 'D':
888 case 'U':
889 if (preprocargs == NULL)
891 quotedarg = quot (optarg);
892 preprocargs = xmalloc (strlen (quotedarg) + 3);
893 sprintf (preprocargs, "-%c%s", c, quotedarg);
895 else
897 char *n;
899 quotedarg = quot (optarg);
900 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
901 sprintf (n, "%s -%c%s", preprocargs, c, quotedarg);
902 free (preprocargs);
903 preprocargs = n;
905 break;
907 case 'r':
908 /* Ignored for compatibility with rc. */
909 break;
911 case 'v':
912 verbose ++;
913 break;
915 case 'I':
916 /* For backward compatibility, should be removed in the future. */
917 input_format_tmp = format_from_name (optarg, 0);
918 if (input_format_tmp != RES_FORMAT_UNKNOWN)
920 fprintf (stderr,
921 _("Option -I is deprecated for setting the input format, please use -J instead.\n"));
922 input_format = input_format_tmp;
923 break;
926 if (preprocargs == NULL)
928 quotedarg = quot (optarg);
929 preprocargs = xmalloc (strlen (quotedarg) + 3);
930 sprintf (preprocargs, "-I%s", quotedarg);
932 else
934 char *n;
936 quotedarg = quot (optarg);
937 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
938 sprintf (n, "%s -I%s", preprocargs, quotedarg);
939 free (preprocargs);
940 preprocargs = n;
943 windres_add_include_dir (optarg);
945 break;
947 case 'l':
948 language = strtol (optarg, (char **) NULL, 16);
949 break;
951 case OPTION_USE_TEMP_FILE:
952 use_temp_file = 1;
953 break;
955 case OPTION_NO_USE_TEMP_FILE:
956 use_temp_file = 0;
957 break;
959 #ifdef YYDEBUG
960 case OPTION_YYDEBUG:
961 yydebug = 1;
962 break;
963 #endif
965 case 'h':
966 case 'H':
967 usage (stdout, 0);
968 break;
970 case 'V':
971 print_version ("windres");
972 break;
974 default:
975 usage (stderr, 1);
976 break;
980 if (input_filename == NULL && optind < argc)
982 input_filename = argv[optind];
983 ++optind;
986 if (output_filename == NULL && optind < argc)
988 output_filename = argv[optind];
989 ++optind;
992 if (argc != optind)
993 usage (stderr, 1);
995 if (input_format == RES_FORMAT_UNKNOWN)
997 if (input_filename == NULL)
998 input_format = RES_FORMAT_RC;
999 else
1000 input_format = format_from_filename (input_filename, 1);
1003 if (output_format == RES_FORMAT_UNKNOWN)
1005 if (output_filename == NULL)
1006 output_format = RES_FORMAT_RC;
1007 else
1008 output_format = format_from_filename (output_filename, 0);
1011 set_endianess (NULL, target);
1013 /* Read the input file. */
1014 switch (input_format)
1016 default:
1017 abort ();
1018 case RES_FORMAT_RC:
1019 resources = read_rc_file (input_filename, preprocessor, preprocargs,
1020 language, use_temp_file);
1021 break;
1022 case RES_FORMAT_RES:
1023 resources = read_res_file (input_filename);
1024 break;
1025 case RES_FORMAT_COFF:
1026 resources = read_coff_rsrc (input_filename, target);
1027 break;
1030 if (resources == NULL)
1031 fatal (_("no resources"));
1033 /* Sort the resources. This is required for COFF, convenient for
1034 rc, and unimportant for res. */
1035 resources = sort_resources (resources);
1037 /* Write the output file. */
1038 reswr_init ();
1040 switch (output_format)
1042 default:
1043 abort ();
1044 case RES_FORMAT_RC:
1045 write_rc_file (output_filename, resources);
1046 break;
1047 case RES_FORMAT_RES:
1048 write_res_file (output_filename, resources);
1049 break;
1050 case RES_FORMAT_COFF:
1051 write_coff_file (output_filename, target, resources);
1052 break;
1055 xexit (0);
1056 return 0;
1059 static void set_endianess (bfd *abfd, const char *target)
1061 const bfd_target *target_vec;
1063 def_target_arch = NULL;
1064 target_vec = bfd_find_target (target, abfd);
1065 if (! target_vec)
1066 fatal ("Can't detect target endianess and architecture.");
1067 target_is_bigendian = ((target_vec->byteorder == BFD_ENDIAN_BIG) ? 1 : 0);
1069 const char *tname = target_vec->name;
1070 const char **arch = bfd_arch_list();
1071 if (arch && tname)
1073 if (strchr (tname, '-') != NULL)
1074 tname = strchr (tname, '-') + 1;
1075 while (*arch != NULL)
1077 const char *in_a = strstr (*arch, tname);
1078 char end_ch = (in_a ? in_a[strlen(tname)] : 0);
1079 if (in_a && (in_a == *arch || in_a[-1] == ':')
1080 && end_ch == 0)
1082 def_target_arch = *arch;
1083 break;
1085 arch++;
1088 if (! def_target_arch)
1089 fatal ("Can't detect architecture.");
1093 bfd *
1094 windres_open_as_binary (const char *filename, int rdmode)
1096 bfd *abfd;
1098 abfd = (rdmode ? bfd_openr (filename, "binary") : bfd_openw (filename, "binary"));
1099 if (! abfd)
1100 fatal ("can't open `%s' for %s", filename, (rdmode ? "input" : "output"));
1102 if (rdmode && ! bfd_check_format (abfd, bfd_object))
1103 fatal ("can't open `%s' for input.", filename);
1105 return abfd;
1108 void
1109 set_windres_bfd_endianess (windres_bfd *wrbfd, int is_bigendian)
1111 assert (!! wrbfd);
1112 switch (WR_KIND(wrbfd))
1114 case WR_KIND_BFD_BIN_L:
1115 if (is_bigendian)
1116 WR_KIND(wrbfd) = WR_KIND_BFD_BIN_B;
1117 break;
1118 case WR_KIND_BFD_BIN_B:
1119 if (! is_bigendian)
1120 WR_KIND(wrbfd) = WR_KIND_BFD_BIN_L;
1121 break;
1122 default:
1123 /* only binary bfd can be overriden. */
1124 abort ();
1128 void
1129 set_windres_bfd (windres_bfd *wrbfd, bfd *abfd, asection *sec, rc_uint_type kind)
1131 assert (!! wrbfd);
1132 switch (kind)
1134 case WR_KIND_TARGET:
1135 abfd = NULL;
1136 sec = NULL;
1137 break;
1138 case WR_KIND_BFD:
1139 case WR_KIND_BFD_BIN_L:
1140 case WR_KIND_BFD_BIN_B:
1141 assert (!! abfd);
1142 assert (!!sec);
1143 break;
1144 default:
1145 abort ();
1147 WR_KIND(wrbfd) = kind;
1148 WR_BFD(wrbfd) = abfd;
1149 WR_SECTION(wrbfd) = sec;
1152 void
1153 set_windres_bfd_content(windres_bfd *wrbfd, const void *data, rc_uint_type off,
1154 rc_uint_type length)
1156 if (WR_KIND(wrbfd) != WR_KIND_TARGET)
1158 if (! bfd_set_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length))
1159 bfd_fatal ("bfd_set_section_contents");
1161 else
1162 abort ();
1165 void
1166 get_windres_bfd_content(windres_bfd *wrbfd, void *data, rc_uint_type off,
1167 rc_uint_type length)
1169 if (WR_KIND(wrbfd) != WR_KIND_TARGET)
1171 if (! bfd_get_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length))
1172 bfd_fatal ("bfd_get_section_contents");
1174 else
1175 abort ();
1178 void
1179 windres_put_8 (windres_bfd *wrbfd, void *p, rc_uint_type value)
1181 switch (WR_KIND(wrbfd))
1183 case WR_KIND_TARGET:
1184 target_put_8 (p, value);
1185 break;
1186 case WR_KIND_BFD:
1187 case WR_KIND_BFD_BIN_L:
1188 case WR_KIND_BFD_BIN_B:
1189 bfd_put_8 (WR_BFD(wrbfd), value, p);
1190 break;
1191 default:
1192 abort ();
1196 void
1197 windres_put_16 (windres_bfd *wrbfd, void *data, rc_uint_type value)
1199 switch (WR_KIND(wrbfd))
1201 case WR_KIND_TARGET:
1202 target_put_16 (data, value);
1203 break;
1204 case WR_KIND_BFD:
1205 case WR_KIND_BFD_BIN_B:
1206 bfd_put_16 (WR_BFD(wrbfd), value, data);
1207 break;
1208 case WR_KIND_BFD_BIN_L:
1209 bfd_putl16 (value, data);
1210 break;
1211 default:
1212 abort ();
1216 void
1217 windres_put_32 (windres_bfd *wrbfd, void *data, rc_uint_type value)
1219 switch (WR_KIND(wrbfd))
1221 case WR_KIND_TARGET:
1222 target_put_32 (data, value);
1223 break;
1224 case WR_KIND_BFD:
1225 case WR_KIND_BFD_BIN_B:
1226 bfd_put_32 (WR_BFD(wrbfd), value, data);
1227 break;
1228 case WR_KIND_BFD_BIN_L:
1229 bfd_putl32 (value, data);
1230 break;
1231 default:
1232 abort ();
1236 rc_uint_type
1237 windres_get_8 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1239 if (length < 1)
1240 fatal ("windres_get_8: unexpected eob.");
1241 switch (WR_KIND(wrbfd))
1243 case WR_KIND_TARGET:
1244 return target_get_8 (data, length);
1245 case WR_KIND_BFD:
1246 case WR_KIND_BFD_BIN_B:
1247 case WR_KIND_BFD_BIN_L:
1248 return bfd_get_8 (WR_BFD(wrbfd), data);
1249 default:
1250 abort ();
1252 return 0;
1255 rc_uint_type
1256 windres_get_16 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1258 if (length < 2)
1259 fatal ("windres_get_16: unexpected eob.");
1260 switch (WR_KIND(wrbfd))
1262 case WR_KIND_TARGET:
1263 return target_get_16 (data, length);
1264 case WR_KIND_BFD:
1265 case WR_KIND_BFD_BIN_B:
1266 return bfd_get_16 (WR_BFD(wrbfd), data);
1267 case WR_KIND_BFD_BIN_L:
1268 return bfd_getl16 (data);
1269 default:
1270 abort ();
1272 return 0;
1275 rc_uint_type
1276 windres_get_32 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1278 if (length < 4)
1279 fatal ("windres_get_32: unexpected eob.");
1280 switch (WR_KIND(wrbfd))
1282 case WR_KIND_TARGET:
1283 return target_get_32 (data, length);
1284 case WR_KIND_BFD:
1285 case WR_KIND_BFD_BIN_B:
1286 return bfd_get_32 (WR_BFD(wrbfd), data);
1287 case WR_KIND_BFD_BIN_L:
1288 return bfd_getl32 (data);
1289 default:
1290 abort ();
1292 return 0;
1295 static rc_uint_type
1296 target_get_8 (const void *p, rc_uint_type length)
1298 rc_uint_type ret;
1300 if (length < 1)
1301 fatal ("Resource too small for getting 8-bit value.");
1303 ret = (rc_uint_type) *((const bfd_byte *) p);
1304 return ret & 0xff;
1307 static rc_uint_type
1308 target_get_16 (const void *p, rc_uint_type length)
1310 if (length < 2)
1311 fatal ("Resource too small for getting 16-bit value.");
1313 if (target_is_bigendian)
1314 return bfd_getb16 (p);
1315 else
1316 return bfd_getl16 (p);
1319 static rc_uint_type
1320 target_get_32 (const void *p, rc_uint_type length)
1322 if (length < 4)
1323 fatal ("Resource too small for getting 32-bit value.");
1325 if (target_is_bigendian)
1326 return bfd_getb32 (p);
1327 else
1328 return bfd_getl32 (p);
1331 static void
1332 target_put_8 (void *p, rc_uint_type value)
1334 assert (!! p);
1335 *((bfd_byte *) p)=(bfd_byte) value;
1338 static void
1339 target_put_16 (void *p, rc_uint_type value)
1341 assert (!! p);
1343 if (target_is_bigendian)
1344 bfd_putb16 (value, p);
1345 else
1346 bfd_putl16 (value, p);
1349 static void
1350 target_put_32 (void *p, rc_uint_type value)
1352 assert (!! p);
1354 if (target_is_bigendian)
1355 bfd_putb32 (value, p);
1356 else
1357 bfd_putl32 (value, p);
1360 static int isInComment = 0;
1362 int wr_printcomment (FILE *e, const char *fmt, ...)
1364 va_list arg;
1365 int r = 0;
1367 if (isInComment)
1368 r += fprintf (e, "\n ");
1369 else
1370 fprintf (e, "/* ");
1371 isInComment = 1;
1372 if (fmt == NULL)
1373 return r;
1374 va_start (arg, fmt);
1375 r += vfprintf (e, fmt, arg);
1376 va_end (arg);
1377 return r;
1380 int wr_print (FILE *e, const char *fmt, ...)
1382 va_list arg;
1383 int r = 0;
1384 if (isInComment)
1385 r += fprintf (e, ". */\n");
1386 isInComment = 0;
1387 if (! fmt)
1388 return r;
1389 va_start (arg, fmt);
1390 r += vfprintf (e, fmt, arg);
1391 va_end (arg);
1392 return r;