/* windres.c -- a program to manipulate Windows resources
- Copyright 1997 Free Software Foundation, Inc.
+ Copyright 1997, 1998, 1999 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support.
This file is part of GNU Binutils.
#include "getopt.h"
#include "bucomm.h"
#include "libiberty.h"
+#include "obstack.h"
#include "windres.h"
#include <assert.h>
#include <ctype.h>
+#include <time.h>
+
+/* used by resrc.c at least */
+
+int verbose = 0;
/* An enumeration of format types. */
{"output-format", required_argument, 0, 'O'},
{"preprocessor", required_argument, 0, OPTION_PREPROCESSOR},
{"target", required_argument, 0, 'F'},
+ {"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, OPTION_VERSION},
{"yydebug", no_argument, 0, OPTION_YYDEBUG},
{0, no_argument, 0, 0}
/* Static functions. */
+static void res_init PARAMS ((void));
+static int extended_menuitems PARAMS ((const struct menuitem *));
static enum res_format format_from_name PARAMS ((const char *));
static enum res_format format_from_filename PARAMS ((const char *, int));
static void usage PARAMS ((FILE *, int));
+static int cmp_res_entry PARAMS ((const PTR, const PTR));
+static struct res_directory *sort_resources PARAMS ((struct res_directory *));
+\f
+/* When we are building a resource tree, we allocate everything onto
+ an obstack, so that we can free it all at once if we want. */
+
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+
+/* The resource building obstack. */
+
+static struct obstack res_obstack;
+
+/* Initialize the resource building obstack. */
+
+static void
+res_init ()
+{
+ obstack_init (&res_obstack);
+}
+
+/* Allocate space on the resource building obstack. */
+
+PTR
+res_alloc (bytes)
+ size_t bytes;
+{
+ return (PTR) obstack_alloc (&res_obstack, bytes);
+}
+
+/* We also use an obstack to save memory used while writing out a set
+ of resources. */
+
+static struct obstack reswr_obstack;
+
+/* Initialize the resource writing obstack. */
+
+static void
+reswr_init ()
+{
+ obstack_init (&reswr_obstack);
+}
+
+/* Allocate space on the resource writing obstack. */
+
+PTR
+reswr_alloc (bytes)
+ size_t bytes;
+{
+ return (PTR) obstack_alloc (&reswr_obstack, bytes);
+}
\f
/* Open a file using the include directory search list. */
}
}
- fatal ("can't open %s `%s': %s", errmsg, filename, strerror (errno));
+ fatal (_("can't open %s `%s': %s"), errmsg, filename, strerror (errno));
/* Return a value to avoid a compiler warning. */
return NULL;
}
\f
-/* Unicode support. */
-
-/* Convert an ASCII string to a unicode string. We just copy it,
- expanding chars to shorts, rather than doing something intelligent. */
-
-void
-unicode_from_ascii (length, unicode, ascii)
- unsigned short *length;
- unsigned short **unicode;
- const char *ascii;
-{
- int len;
- const char *s;
- unsigned short *w;
-
- len = strlen (ascii);
-
- if (length != NULL)
- {
- if (len > 0xffff)
- fatal ("string too long (%d chars > 0xffff)", len);
- *length = len;
- }
-
- *unicode = (unsigned short *) xmalloc ((len + 1) * sizeof (unsigned short));
-
- for (s = ascii, w = *unicode; *s != '\0'; s++, w++)
- *w = *s & 0xff;
- *w = 0;
-}
-
-/* Print the unicode string UNICODE to the file E. LENGTH is the
- number of characters to print, or -1 if we should print until the
- end of the string. */
-
-void
-unicode_print (e, unicode, length)
- FILE *e;
- const unsigned short *unicode;
- int length;
-{
- while (1)
- {
- unsigned short ch;
-
- if (length == 0)
- return;
- if (length > 0)
- --length;
-
- ch = *unicode;
-
- if (ch == 0)
- return;
-
- ++unicode;
-
- if ((ch & 0x7f) == ch && isprint (ch))
- putc (ch, e);
- else if ((ch & 0xff) == ch)
- fprintf (e, "\\%03o", (unsigned int) ch);
- else
- fprintf (e, "\\x%x", (unsigned int) ch);
- }
-}
-\f
/* Compare two resource ID's. We consider name entries to come before
numeric entries, because that is how they appear in the COFF .rsrc
section. */
}
else
{
- unsigned short *as, *ase, *bs, *bse;
+ unichar *as, *ase, *bs, *bse;
if (! b.named)
return -1;
fprintf (stream, "%lu", id.u.id);
else
{
- unsigned short *s, *se;
-
if (quote)
putc ('"', stream);
- s = id.u.n.name;
- se = s + id.u.n.length;
- while (s < se)
- {
- if (*s == '"')
- fprintf (stream, "\\\"");
- else if ((*s & 0xff) == *s && isprint (*s))
- putc (*s, stream);
- else
- fprintf (stream, "\\%03o", *s);
- ++s;
- }
+ unicode_print (stream, id.u.n.name, id.u.n.length);
if (quote)
putc ('"', stream);
}
if (*resources == NULL)
{
- *resources = (struct res_directory *) xmalloc (sizeof **resources);
+ static unsigned long timeval;
+
+ /* Use the same timestamp for every resource created in a
+ single run. */
+ if (timeval == 0)
+ timeval = time (NULL);
+
+ *resources = ((struct res_directory *)
+ res_alloc (sizeof **resources));
(*resources)->characteristics = 0;
- (*resources)->time = 0;
+ (*resources)->time = timeval;
(*resources)->major = 0;
(*resources)->minor = 0;
(*resources)->entries = NULL;
re = *pp;
else
{
- re = (struct res_entry *) xmalloc (sizeof *re);
+ re = (struct res_entry *) res_alloc (sizeof *re);
re->next = NULL;
re->id = ids[i];
if ((i + 1) < cids)
{
fprintf (stderr, "%s: ", program_name);
res_ids_print (stderr, i, ids);
- fprintf (stderr, ": expected to be a directory\n");
+ fprintf (stderr, _(": expected to be a directory\n"));
xexit (1);
}
{
fprintf (stderr, "%s: ", program_name);
res_ids_print (stderr, cids, ids);
- fprintf (stderr, ": expected to be a leaf\n");
+ fprintf (stderr, _(": expected to be a leaf\n"));
xexit (1);
}
if (dupok)
return re->u.res;
- fprintf (stderr, "%s: warning: ", program_name);
+ fprintf (stderr, _("%s: warning: "), program_name);
res_ids_print (stderr, cids, ids);
- fprintf (stderr, ": duplicate value\n");
+ fprintf (stderr, _(": duplicate value\n"));
}
- re->u.res = (struct res_resource *) xmalloc (sizeof (struct res_resource));
+ re->u.res = ((struct res_resource *)
+ res_alloc (sizeof (struct res_resource)));
re->u.res->type = RES_TYPE_UNINITIALIZED;
memset (&re->u.res->res_info, 0, sizeof (struct res_res_info));
a[2].u.id = language;
return define_resource (resources, 3, a, dupok);
}
+
+/* Comparison routine for resource sorting. */
+
+static int
+cmp_res_entry (p1, p2)
+ const PTR p1;
+ const PTR p2;
+{
+ const struct res_entry **re1, **re2;
+
+ re1 = (const struct res_entry **) p1;
+ re2 = (const struct res_entry **) p2;
+ return res_id_cmp ((*re1)->id, (*re2)->id);
+}
+
+/* Sort the resources. */
+
+static struct res_directory *
+sort_resources (resdir)
+ struct res_directory *resdir;
+{
+ int c, i;
+ struct res_entry *re;
+ struct res_entry **a;
+
+ if (resdir->entries == NULL)
+ return resdir;
+
+ c = 0;
+ for (re = resdir->entries; re != NULL; re = re->next)
+ ++c;
+
+ /* This is a recursive routine, so using xmalloc is probably better
+ than alloca. */
+ a = (struct res_entry **) xmalloc (c * sizeof (struct res_entry *));
+
+ for (i = 0, re = resdir->entries; re != NULL; re = re->next, i++)
+ a[i] = re;
+
+ qsort (a, c, sizeof (struct res_entry *), cmp_res_entry);
+
+ resdir->entries = a[0];
+ for (i = 0; i < c - 1; i++)
+ a[i]->next = a[i + 1];
+ a[i]->next = NULL;
+
+ free (a);
+
+ /* Now sort the subdirectories. */
+
+ for (re = resdir->entries; re != NULL; re = re->next)
+ if (re->subdir)
+ re->u.dir = sort_resources (re->u.dir);
+
+ return resdir;
+}
\f
/* Return whether the dialog resource DIALOG is a DIALOG or a
DIALOGEX. */
/* Return whether MENUITEMS are a MENU or a MENUEX. */
int
-extended_menu (menuitems)
+extended_menu (menu)
+ const struct menu *menu;
+{
+ return extended_menuitems (menu->items);
+}
+
+static int
+extended_menuitems (menuitems)
const struct menuitem *menuitems;
{
const struct menuitem *mi;
return 1;
if (mi->popup != NULL)
{
- if (extended_menu (mi->popup))
+ if (extended_menuitems (mi->popup))
return 1;
}
}
if (m->name == NULL)
{
- fprintf (stderr, "%s: unknown format type `%s'\n", program_name, name);
- fprintf (stderr, "%s: supported formats:", program_name);
+ fprintf (stderr, _("%s: unknown format type `%s'\n"), program_name, name);
+ fprintf (stderr, _("%s: supported formats:"), program_name);
for (m = format_names; m->name != NULL; m++)
fprintf (stderr, " %s", m->name);
fprintf (stderr, "\n");
fclose (e);
- /* A PE executable starts with 0x4d 0x5a 0x90 0x00. */
- if (b1 == 0x4d && b2 == 0x5a && b3 == 0x90 && b4 == 0)
+ /* A PE executable starts with 0x4d 0x5a. */
+ if (b1 == 0x4d && b2 == 0x5a)
return RES_FORMAT_COFF;
/* A COFF .o file starts with a COFF magic number. */
return RES_FORMAT_RC;
/* Otherwise, we give up. */
- fatal ("can not determine type of file `%s'; use the -I option",
+ fatal (_("can not determine type of file `%s'; use the -I option"),
filename);
/* Return something to silence the compiler warning. */
FILE *stream;
int status;
{
- fprintf (stream, "Usage: %s [options] [input-file] [output-file]\n",
+ fprintf (stream, _("Usage: %s [options] [input-file] [output-file]\n"),
program_name);
- fprintf (stream, "\
+ fprintf (stream, _("\
Options:\n\
-i FILE, --input FILE Name input file\n\
-o FILE, --output FILE Name output file\n\
-F TARGET, --target TARGET Specify COFF target\n\
--preprocessor PROGRAM Program to use to preprocess rc file\n\
--include-dir DIR Include directory when preprocessing rc file\n\
- --define SYM[=VAL] Define SYM when preprocessing rc file\n\
- --language VAL Set language when reading rc file\n\
+ -DSYM[=VAL], --define SYM[=VAL]\n\
+ Define SYM when preprocessing rc file\n\
+ -v Verbose - tells you what it's doing\n\
+ --language VAL Set language when reading rc file\n"));
#ifdef YYDEBUG
- --yydebug Turn on parser debugging\n\
+ fprintf (stream, _("\
+ --yydebug Turn on parser debugging\n"));
#endif
+ fprintf (stream, _("\
--help Print this help message\n\
- --version Print version information\n");
- fprintf (stream, "\
+ --version Print version information\n"));
+ fprintf (stream, _("\
FORMAT is one of rc, res, or coff, and is deduced from the file name\n\
extension if not specified. A single file name is an input file.\n\
-No input-file is stdin, default rc. No output-file is stdout, default rc.\n");
+No input-file is stdin, default rc. No output-file is stdout, default rc.\n"));
list_supported_targets (program_name, stream);
if (status == 0)
- fprintf (stream, "Report bugs to bug-gnu-utils@prep.ai.mit.edu\n");
+ fprintf (stream, _("Report bugs to bug-gnu-utils@gnu.org\n"));
exit (status);
}
+/* Quote characters that will confuse the shell when we run the preprocessor */
+static const char *quot (string)
+ const char *string;
+{
+ static char *buf = 0;
+ static int buflen = 0;
+ int slen = strlen (string);
+ const char *src;
+ char *dest;
+
+ if ((buflen < slen * 2 + 2) || !buf)
+ {
+ buflen = slen * 2 + 2;
+ if (buf)
+ free (buf);
+ buf = (char *) xmalloc (buflen);
+ }
+
+ for (src=string, dest=buf; *src; src++, dest++)
+ {
+ if (*src == '(' || *src == ')' || *src == ' ')
+ *dest++ = '\\';
+ *dest = *src;
+ }
+ *dest = 0;
+ return buf;
+}
+
/* The main function. */
int
char *target;
char *preprocessor;
char *preprocargs;
+ const char *quotedarg;
int language;
struct res_directory *resources;
+#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+ setlocale (LC_MESSAGES, "");
+#endif
+ bindtextdomain (PACKAGE, LOCALEDIR);
+ textdomain (PACKAGE);
+
program_name = argv[0];
xmalloc_set_program_name (program_name);
bfd_init ();
set_default_bfd_target ();
+ res_init ();
+
input_filename = NULL;
output_filename = NULL;
input_format = RES_FORMAT_UNKNOWN;
preprocargs = NULL;
language = -1;
- while ((c = getopt_long (argc, argv, "i:o:I:O:F:", long_options,
+ while ((c = getopt_long (argc, argv, "i:o:I:O:F:D:v", long_options,
(int *) 0)) != EOF)
{
switch (c)
preprocessor = optarg;
break;
+ case 'D':
case OPTION_DEFINE:
if (preprocargs == NULL)
{
- preprocargs = xmalloc (strlen (optarg) + 3);
- sprintf (preprocargs, "-D%s", optarg);
+ quotedarg = quot (optarg);
+ preprocargs = xmalloc (strlen (quotedarg) + 3);
+ sprintf (preprocargs, "-D%s", quotedarg);
}
else
{
char *n;
- n = xmalloc (strlen (preprocargs) + strlen (optarg) + 4);
- sprintf (n, "%s -D%s", preprocargs, optarg);
+ quotedarg = quot (optarg);
+ n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
+ sprintf (n, "%s -D%s", preprocargs, quotedarg);
free (preprocargs);
preprocargs = n;
}
break;
+ case 'v':
+ verbose ++;
+ break;
+
case OPTION_INCLUDE_DIR:
if (preprocargs == NULL)
{
- preprocargs = xmalloc (strlen (optarg) + 3);
- sprintf (preprocargs, "-I%s", optarg);
+ quotedarg = quot (optarg);
+ preprocargs = xmalloc (strlen (quotedarg) + 3);
+ sprintf (preprocargs, "-I%s", quotedarg);
}
else
{
char *n;
- n = xmalloc (strlen (preprocargs) + strlen (optarg) + 4);
- sprintf (n, "%s -I%s", preprocargs, optarg);
+ quotedarg = quot (optarg);
+ n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
+ sprintf (n, "%s -I%s", preprocargs, quotedarg);
free (preprocargs);
preprocargs = n;
}
break;
}
+ if (resources == NULL)
+ fatal (_("no resources"));
+
+ /* Sort the resources. This is required for COFF, convenient for
+ rc, and unimportant for res. */
+
+ resources = sort_resources (resources);
+
/* Write the output file. */
+ reswr_init ();
+
switch (output_format)
{
default:
return 0;
}
-struct res_directory *
-read_res_file (filename)
- const char *filename;
-{
- fatal ("read_res_file unimplemented");
- return NULL;
-}
-
-struct res_directory *
-read_coff_rsrc (filename, target)
- const char *filename;
- const char *target;
-{
- fatal ("read_coff_rsrc unimplemented");
- return NULL;
-}
-
-void
-write_res_file (filename, resources)
- const char *filename;
- const struct res_directory *resources;
-{
- fatal ("write_res_file unimplemented");
-}
-
-void
-write_coff_file (filename, target, resources)
- const char *filename;
- const char *target;
- const struct res_directory *resources;
-{
- fatal ("write_coff_file unimplemented");
-}