1 /* windres.c -- a program to manipulate Windows resources
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 /* This program can read and write Windows resources in various
23 formats. In particular, it can act like the rc resource compiler
24 program, and it can act like the cvtres res to COFF conversion
27 It is based on information taken from the following sources:
29 * Microsoft documentation.
31 * The rcl program, written by Gunther Ebert
32 <gunther.ebert@ixos-leipzig.de>.
34 * The res2coff program, written by Pedro A. Aranda <paag@tid.es>.
41 #include "libiberty.h"
42 #include "safe-ctype.h"
49 /* used by resrc.c at least */
53 /* An enumeration of format types. */
59 /* Textual RC file. */
61 /* Binary RES file. */
67 /* A structure used to map between format types and strings. */
72 enum res_format format;
75 /* A mapping between names and format types. */
77 static const struct format_map format_names[] =
79 { "rc", RES_FORMAT_RC },
80 { "res", RES_FORMAT_RES },
81 { "coff", RES_FORMAT_COFF },
82 { NULL, RES_FORMAT_UNKNOWN }
85 /* A mapping from file extensions to format types. */
87 static const struct format_map format_fileexts[] =
89 { "rc", RES_FORMAT_RC },
90 { "res", RES_FORMAT_RES },
91 { "exe", RES_FORMAT_COFF },
92 { "obj", RES_FORMAT_COFF },
93 { "o", RES_FORMAT_COFF },
94 { NULL, RES_FORMAT_UNKNOWN }
97 /* A list of include directories. */
101 struct include_dir *next;
105 static struct include_dir *include_dirs;
109 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
111 #define OPTION_DEFINE 150
112 #define OPTION_HELP (OPTION_DEFINE + 1)
113 #define OPTION_INCLUDE_DIR (OPTION_HELP + 1)
114 #define OPTION_LANGUAGE (OPTION_INCLUDE_DIR + 1)
115 #define OPTION_PREPROCESSOR (OPTION_LANGUAGE + 1)
116 #define OPTION_USE_TEMP_FILE (OPTION_PREPROCESSOR + 1)
117 #define OPTION_NO_USE_TEMP_FILE (OPTION_USE_TEMP_FILE + 1)
118 #define OPTION_VERSION (OPTION_NO_USE_TEMP_FILE + 1)
119 #define OPTION_YYDEBUG (OPTION_VERSION + 1)
121 static const struct option long_options[] =
123 {"define", required_argument, 0, OPTION_DEFINE},
124 {"help", no_argument, 0, OPTION_HELP},
125 {"include-dir", required_argument, 0, OPTION_INCLUDE_DIR},
126 {"input-format", required_argument, 0, 'I'},
127 {"language", required_argument, 0, OPTION_LANGUAGE},
128 {"output-format", required_argument, 0, 'O'},
129 {"preprocessor", required_argument, 0, OPTION_PREPROCESSOR},
130 {"target", required_argument, 0, 'F'},
131 {"use-temp-file", no_argument, 0, OPTION_USE_TEMP_FILE},
132 {"no-use-temp-file", no_argument, 0, OPTION_NO_USE_TEMP_FILE},
133 {"verbose", no_argument, 0, 'v'},
134 {"version", no_argument, 0, OPTION_VERSION},
135 {"yydebug", no_argument, 0, OPTION_YYDEBUG},
136 {0, no_argument, 0, 0}
139 /* Static functions. */
141 static void res_init PARAMS ((void));
142 static int extended_menuitems PARAMS ((const struct menuitem *));
143 static enum res_format format_from_name PARAMS ((const char *));
144 static enum res_format format_from_filename PARAMS ((const char *, int));
145 static void usage PARAMS ((FILE *, int));
146 static int cmp_res_entry PARAMS ((const PTR, const PTR));
147 static struct res_directory *sort_resources PARAMS ((struct res_directory *));
148 static void reswr_init PARAMS ((void));
149 static const char * quot PARAMS ((const char *));
151 /* When we are building a resource tree, we allocate everything onto
152 an obstack, so that we can free it all at once if we want. */
154 #define obstack_chunk_alloc xmalloc
155 #define obstack_chunk_free free
157 /* The resource building obstack. */
159 static struct obstack res_obstack;
161 /* Initialize the resource building obstack. */
166 obstack_init (&res_obstack);
169 /* Allocate space on the resource building obstack. */
175 return (PTR) obstack_alloc (&res_obstack, bytes);
178 /* We also use an obstack to save memory used while writing out a set
181 static struct obstack reswr_obstack;
183 /* Initialize the resource writing obstack. */
188 obstack_init (&reswr_obstack);
191 /* Allocate space on the resource writing obstack. */
197 return (PTR) obstack_alloc (&reswr_obstack, bytes);
200 /* Open a file using the include directory search list. */
203 open_file_search (filename, mode, errmsg, real_filename)
204 const char *filename;
207 char **real_filename;
210 struct include_dir *d;
212 e = fopen (filename, mode);
215 *real_filename = xstrdup (filename);
221 for (d = include_dirs; d != NULL; d = d->next)
225 n = (char *) xmalloc (strlen (d->dir) + strlen (filename) + 2);
226 sprintf (n, "%s/%s", d->dir, filename);
239 fatal (_("can't open %s `%s': %s"), errmsg, filename, strerror (errno));
241 /* Return a value to avoid a compiler warning. */
245 /* Compare two resource ID's. We consider name entries to come before
246 numeric entries, because that is how they appear in the COFF .rsrc
260 else if (a.u.id < b.u.id)
267 unichar *as, *ase, *bs, *bse;
273 ase = as + a.u.n.length;
275 bse = bs + b.u.n.length;
283 i = (int) *as - (int) *bs;
297 /* Print a resource ID. */
300 res_id_print (stream, id, quote)
306 fprintf (stream, "%lu", id.u.id);
311 unicode_print (stream, id.u.n.name, id.u.n.length);
317 /* Print a list of resource ID's. */
320 res_ids_print (stream, cids, ids)
323 const struct res_id *ids;
327 for (i = 0; i < cids; i++)
329 res_id_print (stream, ids[i], 1);
331 fprintf (stream, ": ");
335 /* Convert an ASCII string to a resource ID. */
338 res_string_to_id (res_id, string)
339 struct res_id *res_id;
343 unicode_from_ascii (&res_id->u.n.length, &res_id->u.n.name, string);
346 /* Define a resource. The arguments are the resource tree, RESOURCES,
347 and the location at which to put it in the tree, CIDS and IDS.
348 This returns a newly allocated res_resource structure, which the
349 caller is expected to initialize. If DUPOK is non-zero, then if a
350 resource with this ID exists, it is returned. Otherwise, a warning
351 is issued, and a new resource is created replacing the existing
354 struct res_resource *
355 define_resource (resources, cids, ids, dupok)
356 struct res_directory **resources;
358 const struct res_id *ids;
361 struct res_entry *re = NULL;
365 for (i = 0; i < cids; i++)
367 struct res_entry **pp;
369 if (*resources == NULL)
371 static unsigned long timeval;
373 /* Use the same timestamp for every resource created in a
376 timeval = time (NULL);
378 *resources = ((struct res_directory *)
379 res_alloc (sizeof **resources));
380 (*resources)->characteristics = 0;
381 (*resources)->time = timeval;
382 (*resources)->major = 0;
383 (*resources)->minor = 0;
384 (*resources)->entries = NULL;
387 for (pp = &(*resources)->entries; *pp != NULL; pp = &(*pp)->next)
388 if (res_id_cmp ((*pp)->id, ids[i]) == 0)
395 re = (struct res_entry *) res_alloc (sizeof *re);
416 fprintf (stderr, "%s: ", program_name);
417 res_ids_print (stderr, i, ids);
418 fprintf (stderr, _(": expected to be a directory\n"));
422 resources = &re->u.dir;
428 fprintf (stderr, "%s: ", program_name);
429 res_ids_print (stderr, cids, ids);
430 fprintf (stderr, _(": expected to be a leaf\n"));
434 if (re->u.res != NULL)
439 fprintf (stderr, _("%s: warning: "), program_name);
440 res_ids_print (stderr, cids, ids);
441 fprintf (stderr, _(": duplicate value\n"));
444 re->u.res = ((struct res_resource *)
445 res_alloc (sizeof (struct res_resource)));
446 memset (re->u.res, 0, sizeof (struct res_resource));
448 re->u.res->type = RES_TYPE_UNINITIALIZED;
452 /* Define a standard resource. This is a version of define_resource
453 that just takes type, name, and language arguments. */
455 struct res_resource *
456 define_standard_resource (resources, type, name, language, dupok)
457 struct res_directory **resources;
469 a[2].u.id = language;
470 return define_resource (resources, 3, a, dupok);
473 /* Comparison routine for resource sorting. */
476 cmp_res_entry (p1, p2)
480 const struct res_entry **re1, **re2;
482 re1 = (const struct res_entry **) p1;
483 re2 = (const struct res_entry **) p2;
484 return res_id_cmp ((*re1)->id, (*re2)->id);
487 /* Sort the resources. */
489 static struct res_directory *
490 sort_resources (resdir)
491 struct res_directory *resdir;
494 struct res_entry *re;
495 struct res_entry **a;
497 if (resdir->entries == NULL)
501 for (re = resdir->entries; re != NULL; re = re->next)
504 /* This is a recursive routine, so using xmalloc is probably better
506 a = (struct res_entry **) xmalloc (c * sizeof (struct res_entry *));
508 for (i = 0, re = resdir->entries; re != NULL; re = re->next, i++)
511 qsort (a, c, sizeof (struct res_entry *), cmp_res_entry);
513 resdir->entries = a[0];
514 for (i = 0; i < c - 1; i++)
515 a[i]->next = a[i + 1];
520 /* Now sort the subdirectories. */
522 for (re = resdir->entries; re != NULL; re = re->next)
524 re->u.dir = sort_resources (re->u.dir);
529 /* Return whether the dialog resource DIALOG is a DIALOG or a
533 extended_dialog (dialog)
534 const struct dialog *dialog;
536 const struct dialog_control *c;
538 if (dialog->ex != NULL)
541 for (c = dialog->controls; c != NULL; c = c->next)
542 if (c->data != NULL || c->help != 0)
548 /* Return whether MENUITEMS are a MENU or a MENUEX. */
552 const struct menu *menu;
554 return extended_menuitems (menu->items);
558 extended_menuitems (menuitems)
559 const struct menuitem *menuitems;
561 const struct menuitem *mi;
563 for (mi = menuitems; mi != NULL; mi = mi->next)
565 if (mi->help != 0 || mi->state != 0)
567 if (mi->popup != NULL && mi->id != 0)
570 & ~ (MENUITEM_CHECKED
574 | MENUITEM_MENUBARBREAK
575 | MENUITEM_MENUBREAK))
578 if (mi->popup != NULL)
580 if (extended_menuitems (mi->popup))
588 /* Convert a string to a format type, or exit if it can't be done. */
590 static enum res_format
591 format_from_name (name)
594 const struct format_map *m;
596 for (m = format_names; m->name != NULL; m++)
597 if (strcasecmp (m->name, name) == 0)
602 non_fatal (_("unknown format type `%s'"), name);
603 fprintf (stderr, _("%s: supported formats:"), program_name);
604 for (m = format_names; m->name != NULL; m++)
605 fprintf (stderr, " %s", m->name);
606 fprintf (stderr, "\n");
613 /* Work out a format type given a file name. If INPUT is non-zero,
614 it's OK to look at the file itself. */
616 static enum res_format
617 format_from_filename (filename, input)
618 const char *filename;
623 unsigned char b1, b2, b3, b4, b5;
626 /* If we have an extension, see if we recognize it as implying a
627 particular format. */
628 ext = strrchr (filename, '.');
631 const struct format_map *m;
634 for (m = format_fileexts; m->name != NULL; m++)
635 if (strcasecmp (m->name, ext) == 0)
639 /* If we don't recognize the name of an output file, assume it's a
642 return RES_FORMAT_COFF;
644 /* Read the first few bytes of the file to see if we can guess what
646 e = fopen (filename, FOPEN_RB);
648 fatal ("%s: %s", filename, strerror (errno));
658 /* A PE executable starts with 0x4d 0x5a. */
659 if (b1 == 0x4d && b2 == 0x5a)
660 return RES_FORMAT_COFF;
662 /* A COFF .o file starts with a COFF magic number. */
663 magic = (b2 << 8) | b1;
666 case 0x14c: /* i386 */
667 case 0x166: /* MIPS */
668 case 0x184: /* Alpha */
669 case 0x268: /* 68k */
670 case 0x1f0: /* PowerPC */
672 return RES_FORMAT_COFF;
675 /* A RES file starts with 0x0 0x0 0x0 0x0 0x20 0x0 0x0 0x0. */
676 if (b1 == 0 && b2 == 0 && b3 == 0 && b4 == 0 && b5 == 0x20)
677 return RES_FORMAT_RES;
679 /* If every character is printable or space, assume it's an RC file. */
680 if ((ISPRINT (b1) || ISSPACE (b1))
681 && (ISPRINT (b2) || ISSPACE (b2))
682 && (ISPRINT (b3) || ISSPACE (b3))
683 && (ISPRINT (b4) || ISSPACE (b4))
684 && (ISPRINT (b5) || ISSPACE (b5)))
685 return RES_FORMAT_RC;
687 /* Otherwise, we give up. */
688 fatal (_("can not determine type of file `%s'; use the -I option"),
691 /* Return something to silence the compiler warning. */
692 return RES_FORMAT_UNKNOWN;
695 /* Print a usage message and exit. */
698 usage (stream, status)
702 fprintf (stream, _("Usage: %s [option(s)] [input-file] [output-file]\n"),
704 fprintf (stream, _(" The options are:\n\
705 -i --input=<file> Name input file\n\
706 -o --output=<file> Name output file\n\
707 -I --input-format=<format> Specify input format\n\
708 -O --output-format=<format> Specify output format\n\
709 -F --target=<target> Specify COFF target\n\
710 --preprocessor=<program> Program to use to preprocess rc file\n\
711 --include-dir=<dir> Include directory when preprocessing rc file\n\
712 -D --define <sym>[=<val>] Define SYM when preprocessing rc file\n\
713 -v --verbose Verbose - tells you what it's doing\n\
714 --language=<val> Set language when reading rc file\n\
715 --use-temp-file Use a temporary file instead of popen to read\n\
716 the preprocessor output\n\
717 --no-use-temp-file Use popen (default)\n"));
719 fprintf (stream, _("\
720 --yydebug Turn on parser debugging\n"));
722 fprintf (stream, _("\
723 -r Ignored for compatibility with rc\n\
724 -h --help Print this help message\n\
725 -V --version Print version information\n"));
726 fprintf (stream, _("\
727 FORMAT is one of rc, res, or coff, and is deduced from the file name\n\
728 extension if not specified. A single file name is an input file.\n\
729 No input-file is stdin, default rc. No output-file is stdout, default rc.\n"));
731 list_supported_targets (program_name, stream);
734 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
739 /* Quote characters that will confuse the shell when we run the preprocessor. */
745 static char *buf = 0;
746 static int buflen = 0;
747 int slen = strlen (string);
751 if ((buflen < slen * 2 + 2) || !buf)
753 buflen = slen * 2 + 2;
756 buf = (char *) xmalloc (buflen);
759 for (src=string, dest=buf; *src; src++, dest++)
761 if (*src == '(' || *src == ')' || *src == ' ')
769 /* This keeps gcc happy when using -Wmissing-prototypes -Wstrict-prototypes. */
770 int main PARAMS ((int, char **));
772 /* The main function. */
780 char *input_filename;
781 char *output_filename;
782 enum res_format input_format;
783 enum res_format output_format;
787 const char *quotedarg;
789 struct res_directory *resources;
792 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
793 setlocale (LC_MESSAGES, "");
795 #if defined (HAVE_SETLOCALE)
796 setlocale (LC_CTYPE, "");
798 bindtextdomain (PACKAGE, LOCALEDIR);
799 textdomain (PACKAGE);
801 program_name = argv[0];
802 xmalloc_set_program_name (program_name);
805 set_default_bfd_target ();
809 input_filename = NULL;
810 output_filename = NULL;
811 input_format = RES_FORMAT_UNKNOWN;
812 output_format = RES_FORMAT_UNKNOWN;
816 language = 0x409; /* LANG_ENGLISH, SUBLANG_ENGLISH_US. */
819 while ((c = getopt_long (argc, argv, "i:o:I:O:F:D:rhHvV", long_options,
825 input_filename = optarg;
829 output_filename = optarg;
833 input_format = format_from_name (optarg);
837 output_format = format_from_name (optarg);
844 case OPTION_PREPROCESSOR:
845 preprocessor = optarg;
850 if (preprocargs == NULL)
852 quotedarg = quot (optarg);
853 preprocargs = xmalloc (strlen (quotedarg) + 3);
854 sprintf (preprocargs, "-D%s", quotedarg);
860 quotedarg = quot (optarg);
861 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
862 sprintf (n, "%s -D%s", preprocargs, quotedarg);
869 /* Ignored for compatibility with rc */
876 case OPTION_INCLUDE_DIR:
877 if (preprocargs == NULL)
879 quotedarg = quot (optarg);
880 preprocargs = xmalloc (strlen (quotedarg) + 3);
881 sprintf (preprocargs, "-I%s", quotedarg);
887 quotedarg = quot (optarg);
888 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
889 sprintf (n, "%s -I%s", preprocargs, quotedarg);
895 struct include_dir *n, **pp;
897 n = (struct include_dir *) xmalloc (sizeof *n);
901 for (pp = &include_dirs; *pp != NULL; pp = &(*pp)->next)
908 case OPTION_LANGUAGE:
909 language = strtol (optarg, (char **) NULL, 16);
912 case OPTION_USE_TEMP_FILE:
916 case OPTION_NO_USE_TEMP_FILE:
934 print_version ("windres");
943 if (input_filename == NULL && optind < argc)
945 input_filename = argv[optind];
949 if (output_filename == NULL && optind < argc)
951 output_filename = argv[optind];
958 if (input_format == RES_FORMAT_UNKNOWN)
960 if (input_filename == NULL)
961 input_format = RES_FORMAT_RC;
963 input_format = format_from_filename (input_filename, 1);
966 if (output_format == RES_FORMAT_UNKNOWN)
968 if (output_filename == NULL)
969 output_format = RES_FORMAT_RC;
971 output_format = format_from_filename (output_filename, 0);
974 /* Read the input file. */
976 switch (input_format)
981 resources = read_rc_file (input_filename, preprocessor, preprocargs,
982 language, use_temp_file);
985 resources = read_res_file (input_filename);
987 case RES_FORMAT_COFF:
988 resources = read_coff_rsrc (input_filename, target);
992 if (resources == NULL)
993 fatal (_("no resources"));
995 /* Sort the resources. This is required for COFF, convenient for
996 rc, and unimportant for res. */
998 resources = sort_resources (resources);
1000 /* Write the output file. */
1004 switch (output_format)
1009 write_rc_file (output_filename, resources);
1011 case RES_FORMAT_RES:
1012 write_res_file (output_filename, resources);
1014 case RES_FORMAT_COFF:
1015 write_coff_file (output_filename, target, resources);