/* windres.c -- a program to manipulate Windows resources
- Copyright 1997 Free Software Foundation, Inc.
+ Copyright 1997, 1998 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>
/* An enumeration of format types. */
/* 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;
void
unicode_from_ascii (length, unicode, ascii)
- unsigned short *length;
- unsigned short **unicode;
+ int *length;
+ unichar **unicode;
const char *ascii;
{
int len;
len = strlen (ascii);
if (length != NULL)
- {
- if (len > 0xffff)
- fatal ("string too long (%d chars > 0xffff)", len);
- *length = len;
- }
+ *length = len;
- *unicode = (unsigned short *) xmalloc ((len + 1) * sizeof (unsigned short));
+ *unicode = ((unichar *) res_alloc ((len + 1) * sizeof (unichar)));
for (s = ascii, w = *unicode; *s != '\0'; s++, w++)
*w = *s & 0xff;
void
unicode_print (e, unicode, length)
FILE *e;
- const unsigned short *unicode;
+ const unichar *unicode;
int length;
{
while (1)
{
- unsigned short ch;
+ unichar ch;
if (length == 0)
return;
ch = *unicode;
- if (ch == 0)
+ if (ch == 0 && length < 0)
return;
++unicode;
- if ((ch & 0x7f) == ch && isprint (ch))
- putc (ch, e);
+ if ((ch & 0x7f) == ch)
+ {
+ if (ch == '\\')
+ fputs ("\\", e);
+ else if (isprint (ch))
+ putc (ch, e);
+ else
+ {
+ switch (ch)
+ {
+ case ESCAPE_A:
+ fputs ("\\a", e);
+ break;
+
+ case ESCAPE_B:
+ fputs ("\\b", e);
+ break;
+
+ case ESCAPE_F:
+ fputs ("\\f", e);
+ break;
+
+ case ESCAPE_N:
+ fputs ("\\n", e);
+ break;
+
+ case ESCAPE_R:
+ fputs ("\\r", e);
+ break;
+
+ case ESCAPE_T:
+ fputs ("\\t", e);
+ break;
+
+ case ESCAPE_V:
+ fputs ("\\v", e);
+ break;
+
+ default:
+ fprintf (e, "\\%03o", (unsigned int) ch);
+ break;
+ }
+ }
+ }
else if ((ch & 0xff) == ch)
fprintf (e, "\\%03o", (unsigned int) ch);
else
}
else
{
- unsigned short *as, *ase, *bs, *bse;
+ unichar *as, *ase, *bs, *bse;
if (! b.named)
return -1;
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");
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\
--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\
+ --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);
}
int language;
struct res_directory *resources;
+ setlocale (LC_MESSAGES, "");
+ 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;
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:
read_res_file (filename)
const char *filename;
{
- fatal ("read_res_file unimplemented");
+ fatal (_("read_res_file unimplemented"));
return NULL;
}
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");
+ fatal (_("write_res_file unimplemented"));
}
projects / deliverable / binutils-gdb.git / blobdiff