* resbin.c: New file.

	* rclex.l, rcparse.y, rescoff.c, resrc.c, windres.c, windres.h:
	Numerous fixes and improvements.
	* Makefile.in: Rebuild dependencies.
 	(CFILES): Add resbin.c.
	(WINDRES_OBJS): Add resbin.o.

9 files changed, 3354 insertions, 246 deletions

diff --git a/binutils/.Sanitize b/binutils/.Sanitize
index e66607a..c66a8ff 100644
--- a/binutils/.Sanitize
+++ b/binutils/.Sanitize
@@ -84,6 +84,7 @@ ranlib.1
 ranlib.sh
 rclex.l
 rcparse.y
+resbin.c
 rescoff.c
 resrc.c
 rdcoff.c
diff --git a/binutils/ChangeLog b/binutils/ChangeLog
index 3c8f28b..fab29fa 100644
--- a/binutils/ChangeLog
+++ b/binutils/ChangeLog
@@ -1,3 +1,12 @@
+Wed Jun 25 20:57:06 1997  Ian Lance Taylor  <ian@cygnus.com>
+
+	* resbin.c: New file.
+	* rclex.l, rcparse.y, rescoff.c, resrc.c, windres.c, windres.h:
+	Numerous fixes and improvements.
+	* Makefile.in: Rebuild dependencies.
+ 	(CFILES): Add resbin.c.
+	(WINDRES_OBJS): Add resbin.o.
+
 Sun Jun 22 17:29:41 1997  Ian Lance Taylor  <ian@cygnus.com>
 
 	First stab at Windows resource compiler:
diff --git a/binutils/Makefile.in b/binutils/Makefile.in
index 3a0eb41..15e1c8d 100644
--- a/binutils/Makefile.in
+++ b/binutils/Makefile.in
@@ -138,7 +138,7 @@ CFILES = addr2line.c ar.c arsup.c bucomm.c coffdump.c coffgrok.c debug.c \
 	maybe-strip.c nlmconv.c nm.c not-ranlib.c not-strip.c \
 	objcopy.c objdump.c prdbg.c rdcoff.c rddbg.c size.c srconv.c \
 	stabs.c strings.c sysdump.c version.c wrstabs.c \
-	windres.c resrc.c rescoff.c
+	windres.c resrc.c rescoff.c resbin.c
 
 GENERATED_CFILES = \
 	underscore.c arparse.c arlex.c sysroff.c sysinfo.c syslex.c \
@@ -409,7 +409,7 @@ nlmconv.o: nlmconv.c $(INCDIR)/coff/sym.h $(INCDIR)/coff/ecoff.h
 $(NLMCONV_PROG): nlmconv.o nlmheader.o $(ADDL_DEPS)
 	$(HLDENV) $(CC) $(HLDFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ nlmconv.o nlmheader.o $(ADDL_LIBS) $(EXTRALIBS)
 
-WINDRES_OBJS = windres.o resrc.o rescoff.o rcparse.o rclex.o
+WINDRES_OBJS = windres.o resrc.o rescoff.o resbin.o rcparse.o rclex.o
 
 $(WINDRES_PROG): $(WINDRES_OBJS) $(ADDL_DEPS)
 	$(HLDENV) $(CC) $(HLDFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(WINDRES_OBJS) $(ADDL_LIBS) $(EXTRALIBS)
@@ -762,7 +762,7 @@ wrstabs.o: wrstabs.c ../bfd/bfd.h $(INCDIR)/ansidecl.h \
   $(INCDIR)/aout/stab.def
 windres.o: windres.c ../bfd/bfd.h $(INCDIR)/ansidecl.h \
   $(INCDIR)/getopt.h bucomm.h config.h $(INCDIR)/fopen-same.h \
-  $(INCDIR)/libiberty.h windres.h
+  $(INCDIR)/libiberty.h $(INCDIR)/obstack.h windres.h
 resrc.o: resrc.c ../bfd/bfd.h $(INCDIR)/ansidecl.h \
   bucomm.h config.h $(INCDIR)/fopen-same.h $(INCDIR)/libiberty.h \
   windres.h
@@ -770,6 +770,9 @@ rescoff.o: rescoff.c ../bfd/bfd.h $(INCDIR)/ansidecl.h \
   bucomm.h config.h $(INCDIR)/fopen-same.h $(INCDIR)/libiberty.h \
   windres.h $(INCDIR)/coff/internal.h $(BFDDIR)/libcoff.h \
   $(INCDIR)/bfdlink.h
+resbin.o: resbin.c ../bfd/bfd.h $(INCDIR)/ansidecl.h \
+  bucomm.h config.h $(INCDIR)/fopen-same.h $(INCDIR)/libiberty.h \
+  windres.h
 underscore.o: underscore.c
 arparse.o: arparse.c ../bfd/bfd.h $(INCDIR)/ansidecl.h \
   bucomm.h config.h $(INCDIR)/fopen-same.h arsup.h
diff --git a/binutils/rclex.l b/binutils/rclex.l
index eb36bf6..b92d9f3 100644
--- a/binutils/rclex.l
+++ b/binutils/rclex.l
@@ -32,8 +32,26 @@
 #include <ctype.h>
 #include <assert.h>
 
+/* Whether we are in rcdata mode, in which we returns the lengths of
+   strings.  */
+
+static int rcdata_mode;
+
+/* List of allocated strings.  */
+
+struct alloc_string
+{
+  struct alloc_string *next;
+  char *s;
+};
+
+static struct alloc_string *strings;
+
+/* Local functions.  */
+
 static void cpp_line PARAMS ((const char *));
-static char *handle_quotes PARAMS ((const char *));
+static char *handle_quotes PARAMS ((const char *, unsigned long *));
+static char *get_string PARAMS ((int));
 
 %}
 
@@ -133,9 +151,12 @@ static char *handle_quotes PARAMS ((const char *));
 			    return BLOCKVARFILEINFO;
 			  else
 			    {
-			      yylval.s = (char *) xmalloc (send - s + 1);
-			      strncpy (yylval.s, s, send - s);
-			      yylval.s[send - s] = '\0';
+			      char *r;
+
+			      r = get_string (send - s + 1);
+			      strncpy (r, s, send - s);
+			      r[send - s] = '\0';
+			      yylval.s = r;
 			      return BLOCK;
 			    }
 			}
@@ -157,12 +178,29 @@ static char *handle_quotes PARAMS ((const char *));
 			}
 
 ("\""[^\"\n]*"\""[ \t]*)+ {
-			  yylval.s = handle_quotes (yytext);
-			  return QUOTEDSTRING;
+			  char *s;
+			  unsigned long length;
+
+			  s = handle_quotes (yytext, &length);
+			  if (! rcdata_mode)
+			    {
+			      yylval.s = s;
+			      return QUOTEDSTRING;
+			    }
+			  else
+			    {
+			      yylval.ss.length = length;
+			      yylval.ss.s = s;
+			      return SIZEDSTRING;
+			    }
 			}
 
 [A-Za-z][^ \t\r\n]*	{
-			  yylval.s = xstrdup (yytext);
+			  char *s;
+
+			  s = get_string (strlen (yytext) + 1);
+			  strcpy (s, yytext);
+			  yylval.s = s;
 			  return STRING;
 			}
 
@@ -224,14 +262,15 @@ cpp_line (s)
    merged separated by whitespace are merged, as in C.  */
 
 static char *
-handle_quotes (input)
+handle_quotes (input, len)
      const char *input;
+     unsigned long *len;
 {
   char *ret, *s;
   const char *t;
   int ch;
 
-  ret = (char *) xmalloc (strlen (input) + 1);
+  ret = get_string (strlen (input) + 1);
 
   s = ret;
   t = input;
@@ -316,5 +355,62 @@ handle_quotes (input)
 
   *s = '\0';
 
+  *len = s - ret;
+
   return ret;
 }
+
+/* Allocate a string of a given length.  */
+
+static char *
+get_string (len)
+     int len;
+{
+  struct alloc_string *as;
+
+  as = (struct alloc_string *) xmalloc (sizeof *as);
+  as->s = xmalloc (len);
+
+  as->next = strings;
+  strings = as->next;
+
+  return as->s;
+}
+
+/* Discard all the strings we have allocated.  The parser calls this
+   when it no longer needs them.  */
+
+void
+rcparse_discard_strings ()
+{
+  struct alloc_string *as;
+
+  as = strings;
+  while (as != NULL)
+    {
+      struct alloc_string *n;
+
+      free (as->s);
+      n = as->next;
+      free (as);
+      as = n;
+    }
+
+  strings = NULL;
+}
+
+/* Enter rcdata mode.  */
+
+void
+rcparse_rcdata ()
+{
+  rcdata_mode = 1;
+}
+
+/* Go back to normal mode from rcdata mode.  */
+
+void
+rcparse_normal ()
+{
+  rcdata_mode = 0;
+}
diff --git a/binutils/rcparse.y b/binutils/rcparse.y
index 56c6db8..9ea9cf5 100644
--- a/binutils/rcparse.y
+++ b/binutils/rcparse.y
@@ -27,9 +27,11 @@
 #include "libiberty.h"
 #include "windres.h"
 
-/* The current language.  The default is U.S. English.  */
+#include <ctype.h>
 
-static unsigned short language = 0x409;
+/* The current language.  */
+
+static unsigned short language;
 
 /* The resource information during a sub statement.  */
 
@@ -60,7 +62,12 @@ static unsigned long class;
   struct accelerator *pacc;
   struct dialog_control *dialog_control;
   struct menuitem *menuitem;
-  struct rcdata_data *rcdata;
+  struct
+  {
+    struct rcdata_item *first;
+    struct rcdata_item *last;
+  } rcdata;
+  struct rcdata_item *rcdata_item;
   struct stringtable_data *stringtable;
   struct fixed_versioninfo *fixver;
   struct ver_info *verinfo;
@@ -81,7 +88,12 @@ static unsigned long class;
   } i;
   unsigned long il;
   unsigned short is;
-  char *s;
+  const char *s;
+  struct
+  {
+    unsigned long length;
+    const char *s;
+  } ss;
 };
 
 %token BEG END
@@ -109,12 +121,14 @@ static unsigned long class;
 %token NOT
 %token <s> QUOTEDSTRING STRING
 %token <i> NUMBER
+%token <ss> SIZEDSTRING
 
 %type <pacc> acc_entries
 %type <acc> acc_entry acc_event
 %type <dialog_control> control control_params
 %type <menuitem> menuitems menuitem menuexitems menuexitem
-%type <rcdata> optrcdata_data rcdata_data opt_control_data
+%type <rcdata> optrcdata_data optrcdata_data_int rcdata_data
+%type <rcdata_item> opt_control_data
 %type <fixver> fixedverinfo
 %type <verinfo> verblocks
 %type <verstring> vervals
@@ -139,20 +153,27 @@ static unsigned long class;
 
 input:
 	  /* empty */
-	| input accelerator
-	| input bitmap
-	| input cursor
-	| input dialog
-	| input font
-	| input icon
-	| input language
-	| input menu
-	| input menuex
-	| input messagetable
-	| input rcdata
-	| input stringtable
-	| input user
-	| input versioninfo
+	| input newcmd accelerator
+	| input newcmd bitmap
+	| input newcmd cursor
+	| input newcmd dialog
+	| input newcmd font
+	| input newcmd icon
+	| input newcmd language
+	| input newcmd menu
+	| input newcmd menuex
+	| input newcmd messagetable
+	| input newcmd rcdata
+	| input newcmd stringtable
+	| input newcmd user
+	| input newcmd versioninfo
+	;
+
+newcmd:
+	  /* empty */
+	  {
+	    rcparse_discard_strings ();
+	  }
 	;
 
 /* Accelerator resources.  */
@@ -173,7 +194,7 @@ acc_entries:
 	  {
 	    struct accelerator *a;
 
-	    a = (struct accelerator *) xmalloc (sizeof *a);
+	    a = (struct accelerator *) res_alloc (sizeof *a);
 	    *a = $2;
 	    if ($1 == NULL)
 	      $$ = a;
@@ -206,7 +227,7 @@ acc_entry:
 acc_event:
 	  QUOTEDSTRING
 	  {
-	    char *s = $1;
+	    const char *s = $1;
 
 	    $$.id = 0;
 	    if (*s != '^')
@@ -219,7 +240,6 @@ acc_event:
 	    $$.key = *s;
 	    if (s[1] != '\0')
 	      rcparse_warning ("accelerator should only be one character");
-	    free (s);
 	  }
 	| posnumexpr
 	  {
@@ -274,7 +294,6 @@ bitmap:
 	  id BITMAP memflags_move file_name
 	  {
 	    define_bitmap ($1, &$3, $4);
-	    free ($4);
 	  }
 	;
 
@@ -284,7 +303,6 @@ cursor:
 	  id CURSOR memflags_move_discard file_name
 	  {
 	    define_cursor ($1, &$3, $4);
-	    free ($4);
 	  }
 	;
 
@@ -322,7 +340,7 @@ dialog:
 	      dialog.exstyle = $4;
 	      dialog.font = NULL;
 	      dialog.ex = ((struct dialog_ex *)
-			   xmalloc (sizeof (struct dialog_ex)));
+			   res_alloc (sizeof (struct dialog_ex)));
 	      memset (dialog.ex, 0, sizeof (struct dialog_ex));
 	      dialog.controls = NULL;
 	      sub_res_info = $3;
@@ -343,7 +361,7 @@ dialog:
 	      dialog.exstyle = $4;
 	      dialog.font = NULL;
 	      dialog.ex = ((struct dialog_ex *)
-			   xmalloc (sizeof (struct dialog_ex)));
+			   res_alloc (sizeof (struct dialog_ex)));
 	      memset (dialog.ex, 0, sizeof (struct dialog_ex));
 	      dialog.ex->help = $9;
 	      dialog.controls = NULL;
@@ -370,7 +388,7 @@ styles:
 	  /* empty */
 	| styles CAPTION QUOTEDSTRING
 	  {
-	    dialog.caption = $3;
+	    unicode_from_ascii ((int *) NULL, &dialog.caption, $3);
 	  }
 	| styles CLASS id
 	  {
@@ -389,12 +407,12 @@ styles:
 	| styles FONT numexpr ',' QUOTEDSTRING
 	  {
 	    dialog.pointsize = $3;
-	    dialog.font = $5;
+	    unicode_from_ascii ((int *) NULL, &dialog.font, $5);
 	  }
 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr cnumexpr
 	  {
 	    dialog.pointsize = $3;
-	    dialog.font = $5;
+	    unicode_from_ascii ((int *) NULL, &dialog.font, $5);
 	    if (dialog.ex == NULL)
 	      rcparse_warning ("extended FONT requires DIALOGEX");
 	    else
@@ -766,7 +784,7 @@ opt_control_data:
 	  }
 	| BEG optrcdata_data END
 	  {
-	    $$ = $2;
+	    $$ = $2.first;
 	  }
 	;
 
@@ -796,7 +814,6 @@ font:
 	  id FONT memflags_move_discard file_name
 	  {
 	    define_font ($1, &$3, $4);
-	    free ($4);
 	  }
 	;
 
@@ -806,7 +823,6 @@ icon:
 	  id ICON memflags_move_discard file_name
 	  {
 	    define_icon ($1, &$3, $4);
-	    free ($4);
 	  }
 	;
 
@@ -975,7 +991,6 @@ messagetable:
 	  id MESSAGETABLE memflags_move file_name
 	  {
 	    define_messagetable ($1, &$3, $4);
-	    free ($4);
 	  }
 	;
 
@@ -984,14 +999,29 @@ messagetable:
 rcdata:
 	  id RCDATA suboptions BEG optrcdata_data END
 	  {
-	    define_rcdata ($1, &$3, $5);
+	    define_rcdata ($1, &$3, $5.first);
 	  }
 	;
 
+/* We use a different lexing algorithm, because rcdata strings may
+   contain embedded null bytes, and we need to know the length to use.  */
+
 optrcdata_data:
+	  {
+	    rcparse_rcdata ();
+	  }
+	  optrcdata_data_int
+	  {
+	    rcparse_normal ();
+	    $$ = $2;
+	  }
+	;
+
+optrcdata_data_int:
 	  /* empty */
 	  {
-	    $$ = NULL;
+	    $$.first = NULL;
+	    $$.last = NULL;
 	  }
 	| rcdata_data
 	  {
@@ -1000,21 +1030,39 @@ optrcdata_data:
 	;
 
 rcdata_data:
-	  QUOTEDSTRING
+	  SIZEDSTRING
 	  {
-	    $$ = append_rcdata_string (NULL, $1);
+	    struct rcdata_item *ri;
+
+	    ri = define_rcdata_string ($1.s, $1.length);
+	    $$.first = ri;
+	    $$.last = ri;
 	  }
 	| sizednumexpr
 	  {
-	    $$ = append_rcdata_number (NULL, $1.val, $1.dword);
+	    struct rcdata_item *ri;
+
+	    ri = define_rcdata_number ($1.val, $1.dword);
+	    $$.first = ri;
+	    $$.last = ri;
 	  }
-	| rcdata_data ',' QUOTEDSTRING
+	| rcdata_data ',' SIZEDSTRING
 	  {
-	    $$ = append_rcdata_string ($1, $3);
+	    struct rcdata_item *ri;
+
+	    ri = define_rcdata_string ($3.s, $3.length);
+	    $$.first = $1.first;
+	    $1.last->next = ri;
+	    $$.last = ri;
 	  }
 	| rcdata_data ',' sizednumexpr
 	  {
-	    $$ = append_rcdata_number ($1, $3.val, $3.dword);
+	    struct rcdata_item *ri;
+
+	    ri = define_rcdata_number ($3.val, $3.dword);
+	    $$.first = $1.first;
+	    $1.last->next = ri;
+	    $$.last = ri;
 	  }
 	;
 
@@ -1042,14 +1090,13 @@ string_data:
    file_name case to keep the parser happy.  */
 
 user:
-	  id id suboptions BEG rcdata_data END
+	  id id suboptions BEG optrcdata_data END
 	  {
-	    define_user_data ($1, $2, &$3, $5);
+	    define_user_data ($1, $2, &$3, $5.first);
 	  }
 	| id id suboptions file_name
 	  {
 	    define_user_file ($1, $2, &$3, $4);
-	    free ($4);
 	  }
 	;
 
@@ -1066,7 +1113,7 @@ fixedverinfo:
 	  /* empty */
 	  {
 	    $$ = ((struct fixed_versioninfo *)
-		  xmalloc (sizeof (struct fixed_versioninfo)));
+		  res_alloc (sizeof (struct fixed_versioninfo)));
 	    memset ($$, 0, sizeof (struct fixed_versioninfo));
 	  }
 	| fixedverinfo FILEVERSION numexpr cnumexpr cnumexpr cnumexpr
@@ -1161,8 +1208,15 @@ id:
 	  }
 	| STRING
 	  {
-	    res_string_to_id (&$$, $1);
-	    free ($1);
+	    char *copy, *s;
+
+	    /* It seems that resource ID's are forced to upper case.  */
+	    copy = xstrdup ($1);
+	    for (s = copy; *s != '\0'; s++)
+	      if (islower (*s))
+		*s = toupper (*s);
+	    res_string_to_id (&$$, copy);
+	    free (copy);
 	  }
 	;
 
diff --git a/binutils/resbin.c b/binutils/resbin.c
new file mode 100644
index 0000000..47d102c
--- /dev/null
+++ b/binutils/resbin.c
@@ -0,0 +1,2368 @@
+/* resbin.c -- manipulate the Windows binary resource format.
+   Copyright 1997 Free Software Foundation, Inc.
+   Written by Ian Lance Taylor, Cygnus Support.
+
+   This file is part of GNU Binutils.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+/* This file contains functions to convert between the binary resource
+   format and the internal structures that we want to use.  The same
+   binary resource format is used in both res and COFF files.  */
+
+#include "bfd.h"
+#include "bucomm.h"
+#include "libiberty.h"
+#include "windres.h"
+
+/* Macros to swap in values.  */
+
+#define get_16(be, s) ((be) ? bfd_getb16 (s) : bfd_getl16 (s))
+#define get_32(be, s) ((be) ? bfd_getb32 (s) : bfd_getl32 (s))
+
+/* Local functions.  */
+
+static void toosmall PARAMS ((const char *));
+static unichar *get_unicode
+  PARAMS ((const unsigned char *, unsigned long, int, int *));
+static int get_resid
+  PARAMS ((struct res_id *, const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_generic
+  PARAMS ((enum res_type, const unsigned char *, unsigned long));
+static struct res_resource *bin_to_res_cursor
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_menu
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct menuitem *bin_to_res_menuitems
+  PARAMS ((const unsigned char *, unsigned long, int, int *));
+static struct menuitem *bin_to_res_menuexitems
+  PARAMS ((const unsigned char *, unsigned long, int, int *));
+static struct res_resource *bin_to_res_dialog
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_string
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_fontdir
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_accelerators
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_rcdata
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_group_cursor
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_group_icon
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_version
+  PARAMS ((const unsigned char *, unsigned long, int));
+static struct res_resource *bin_to_res_userdata
+  PARAMS ((const unsigned char *, unsigned long, int));
+
+/* Given a resource type ID, a pointer to data, a length, return a
+   res_resource structure which represents that resource.  The caller
+   is responsible for initializing the res_info and coff_info fields
+   of the returned structure.  */
+
+struct res_resource *
+bin_to_res (type, data, length, big_endian)
+     struct res_id type;
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  if (type.named)
+    return bin_to_res_userdata (data, length, big_endian);
+  else
+    {
+      switch (type.u.id)
+	{
+	default:
+	  return bin_to_res_userdata (data, length, big_endian);
+	case RT_CURSOR:
+	  return bin_to_res_cursor (data, length, big_endian);
+	case RT_BITMAP:
+	  return bin_to_res_generic (RES_TYPE_BITMAP, data, length);
+	case RT_ICON:
+	  return bin_to_res_generic (RES_TYPE_ICON, data, length);
+	case RT_MENU:
+	  return bin_to_res_menu (data, length, big_endian);
+	case RT_DIALOG:
+	  return bin_to_res_dialog (data, length, big_endian);
+	case RT_STRING:
+	  return bin_to_res_string (data, length, big_endian);
+	case RT_FONTDIR:
+	  return bin_to_res_fontdir (data, length, big_endian);
+	case RT_FONT:
+	  return bin_to_res_generic (RES_TYPE_FONT, data, length);
+	case RT_ACCELERATORS:
+	  return bin_to_res_accelerators (data, length, big_endian);
+	case RT_RCDATA:
+	  return bin_to_res_rcdata (data, length, big_endian);
+	case RT_MESSAGETABLE:
+	  return bin_to_res_generic (RES_TYPE_MESSAGETABLE, data, length);
+	case RT_GROUP_CURSOR:
+	  return bin_to_res_group_cursor (data, length, big_endian);
+	case RT_GROUP_ICON:
+	  return bin_to_res_group_icon (data, length, big_endian);
+	case RT_VERSION:
+	  return bin_to_res_version (data, length, big_endian);
+	}
+    }
+}
+
+/* Give an error if the binary data is too small.  */
+
+static void
+toosmall (msg)
+     const char *msg;
+{
+  fatal ("%s: not enough binary data", msg);
+}
+
+/* Swap in a NULL terminated unicode string.  */
+
+static unichar *
+get_unicode (data, length, big_endian, retlen)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+     int *retlen;
+{
+  int c, i;
+  unichar *ret;
+
+  c = 0;
+  while (1)
+    {
+      if (length < c * 2 + 2)
+	toosmall ("null terminated unicode string");
+      if (get_16 (big_endian, data + c * 2) == 0)
+	break;
+      ++c;
+    }
+
+  ret = (unichar *) res_alloc ((c + 1) * sizeof (unichar));
+
+  for (i = 0; i < c; i++)
+    ret[i] = get_16 (big_endian, data + i * 2);
+  ret[i] = 0;
+
+  if (retlen != NULL)
+    *retlen = c;
+
+  return ret;
+}
+
+/* Get a resource identifier.  This returns the number of bytes used.  */
+
+static int
+get_resid (id, data, length, big_endian)
+     struct res_id *id;
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  int first;
+
+  if (length < 2)
+    toosmall ("resource ID");
+
+  first = get_16 (big_endian, data);
+  if (first == 0xffff)
+    {
+      if (length < 4)
+	toosmall ("resource ID");
+      id->named = 0;
+      id->u.id = get_16 (big_endian, data + 2);
+      return 4;
+    }
+  else
+    {
+      id->named = 1;
+      id->u.n.name = get_unicode (data, length, big_endian, &id->u.n.length);
+      return id->u.n.length * 2 + 2;
+    }
+}
+
+/* Convert a resource which just stores uninterpreted data from
+   binary.  */
+
+struct res_resource *
+bin_to_res_generic (type, data, length)
+     enum res_type type;
+     const unsigned char *data;
+     unsigned long length;
+{
+  struct res_resource *r;
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = type;
+  r->u.data.data = data;
+  r->u.data.length = length;
+
+  return r;
+}
+
+/* Convert a cursor resource from binary.  */
+
+struct res_resource *
+bin_to_res_cursor (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  struct cursor *c;
+  struct res_resource *r;
+
+  if (length < 4)
+    toosmall ("cursor");
+
+  c = (struct cursor *) res_alloc (sizeof *c);
+  c->xhotspot = get_16 (big_endian, data);
+  c->yhotspot = get_16 (big_endian, data + 2);
+  c->length = length - 4;
+  c->data = data + 4;
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_CURSOR;
+  r->u.cursor = c;
+
+  return r;
+}
+
+/* Convert a menu resource from binary.  */
+
+struct res_resource *
+bin_to_res_menu (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  struct res_resource *r;
+  struct menu *m;
+  int version, read;
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_MENU;
+
+  m = (struct menu *) res_alloc (sizeof *m);
+  r->u.menu = m;
+
+  if (length < 2)
+    toosmall ("menu header");
+
+  version = get_16 (big_endian, data);
+
+  if (version == 0)
+    {
+      if (length < 4)
+	toosmall ("menu header");
+      m->help = 0;
+      m->items = bin_to_res_menuitems (data + 4, length - 4, big_endian,
+				       &read);
+    }
+  else if (version == 1)
+    {
+      int offset;
+
+      if (length < 8)
+	toosmall ("menuex header");
+      m->help = get_32 (big_endian, data + 4);
+      offset = get_16 (big_endian, data + 2);
+      if (offset + 4 >= length)
+	toosmall ("menuex offset");
+      m->items = bin_to_res_menuexitems (data + 4 + offset,
+					 length - (4 + offset),
+					 big_endian,
+					 &read);
+    }
+  else
+    fatal ("unsupported menu version %d", version);
+
+  return r;
+}
+
+/* Convert menu items from binary.  */
+
+static struct menuitem *
+bin_to_res_menuitems (data, length, big_endian, read)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+     int *read;
+{
+  struct menuitem *first, **pp;
+
+  first = NULL;
+  pp = &first;
+
+  *read = 0;
+
+  while (length > 0)
+    {
+      int flags, stroff, slen, itemlen;
+      struct menuitem *mi;
+
+      if (length < 4)
+	toosmall ("menuitem header");
+
+      mi = (struct menuitem *) res_alloc (sizeof *mi);
+      mi->state = 0;
+      mi->help = 0;
+
+      flags = get_16 (big_endian, data);
+      mi->type = flags;
+
+      if ((flags & MENUITEM_POPUP) == 0)
+	stroff = 4;
+      else
+	stroff = 2;
+
+      if (length < stroff + 2)
+	toosmall ("menuitem header");
+
+      if (get_16 (big_endian, data + stroff) == 0)
+	{
+	  slen = 0;
+	  mi->text = NULL;
+	}
+      else
+	mi->text = get_unicode (data + stroff, length - stroff, big_endian,
+				&slen);
+
+      itemlen = stroff + slen * 2 + 2;
+
+      if ((flags & MENUITEM_POPUP) == 0)
+	{
+	  mi->popup = NULL;
+	  mi->id = get_16 (big_endian, data + 2);
+	}
+      else
+	{
+	  int subread;
+
+	  mi->id = 0;
+	  mi->popup = bin_to_res_menuitems (data + itemlen, length - itemlen,
+					    big_endian, &subread);
+	  itemlen += subread;
+	}
+
+      mi->next = NULL;
+      *pp = mi;
+      pp = &mi->next;
+
+      data += itemlen;
+      length -= itemlen;
+      *read += itemlen;
+
+      if ((flags & MENUITEM_ENDMENU) != 0)
+	return first;
+    }
+
+  return first;
+}
+
+/* Convert menuex items from binary.  */
+
+static struct menuitem *
+bin_to_res_menuexitems (data, length, big_endian, read)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+     int *read;
+{
+  struct menuitem *first, **pp;
+
+  first = NULL;
+  pp = &first;
+
+  *read = 0;
+
+  while (length > 0)
+    {
+      int flags, slen, itemlen;
+      struct menuitem *mi;
+
+      if (length < 14)
+	toosmall ("menuitem header");
+
+      mi = (struct menuitem *) res_alloc (sizeof *mi);
+      mi->type = get_32 (big_endian, data);
+      mi->state = get_32 (big_endian, data + 4);
+      mi->id = get_16 (big_endian, data + 8);
+
+      flags = get_16 (big_endian, data + 10);
+
+      if (get_16 (big_endian, data + 12) == 0)
+	{
+	  slen = 0;
+	  mi->text = NULL;
+	}
+      else
+	mi->text = get_unicode (data + 12, length - 12, big_endian, &slen);
+
+      itemlen = 12 + slen * 2 + 2;
+      itemlen = (itemlen + 3) &~ 3;
+
+      if ((flags & 1) == 0)
+	{
+	  mi->popup = NULL;
+	  mi->help = 0;
+	}
+      else
+	{
+	  int subread;
+
+	  if (length < itemlen + 4)
+	    toosmall ("menuitem");
+	  mi->help = get_32 (big_endian, data + itemlen);
+	  itemlen += 4;
+
+	  mi->popup = bin_to_res_menuexitems (data + itemlen,
+					      length - itemlen,
+					      big_endian, &subread);
+	  itemlen += subread;
+	}
+
+      mi->next = NULL;
+      *pp = mi;
+      pp = &mi->next;
+
+      data += itemlen;
+      length -= itemlen;
+      *read += itemlen;
+
+      if ((flags & 0x80) != 0)
+	return first;
+    }
+
+  return first;
+}
+
+/* Convert a dialog resource from binary.  */
+
+static struct res_resource *
+bin_to_res_dialog (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  int version;
+  struct dialog *d;
+  int c, sublen, off, i;
+  struct dialog_control **pp;
+  struct res_resource *r;
+
+  if (length < 18)
+    toosmall ("dialog header");
+
+  d = (struct dialog *) res_alloc (sizeof *d);
+
+  version = get_16 (big_endian, data);
+  if (version != 0xffff)
+    {
+      d->ex = NULL;
+      d->style = get_32 (big_endian, data);
+      d->exstyle = get_32 (big_endian, data + 4);
+      off = 8;
+    }
+  else
+    {
+      int signature;
+
+      signature = get_16 (big_endian, data + 2);
+      if (signature != 1)
+	fatal ("unexpected dialog signature %d", signature);
+
+      d->ex = (struct dialog_ex *) res_alloc (sizeof (struct dialog_ex));
+      d->ex->help = get_32 (big_endian, data + 4);
+      d->exstyle = get_32 (big_endian, data + 8);
+      d->style = get_32 (big_endian, data + 12);
+      off = 16;
+    }
+
+  if (length < off + 10)
+    toosmall ("dialog header");
+
+  c = get_16 (big_endian, data + off);
+  d->x = get_16  (big_endian, data + off + 2);
+  d->y = get_16 (big_endian, data + off + 4);
+  d->width = get_16 (big_endian, data + off + 6);
+  d->height = get_16 (big_endian, data + off + 8);
+
+  off += 10;
+
+  sublen = get_resid (&d->menu, data + off, length - off, big_endian);
+  off += sublen;
+
+  sublen = get_resid (&d->class, data + off, length - off, big_endian);
+  off += sublen;
+
+  d->caption = get_unicode (data + off, length - off, big_endian, &sublen);
+  off += sublen * 2 + 2;
+
+  if ((d->style & DS_SETFONT) == 0)
+    {
+      d->pointsize = 0;
+      d->font = NULL;
+      if (d->ex != NULL)
+	{
+	  d->ex->weight = 0;
+	  d->ex->italic = 0;
+	}
+    }
+  else
+    {
+      if (length < off + 2)
+	toosmall ("dialog font point size");
+
+      d->pointsize = get_16 (big_endian, data + off);
+      off += 2;
+
+      if (d->ex != NULL)
+	{
+	  if (length < off + 4)
+	    toosmall ("dialogex font information");
+	  d->ex->weight = get_16 (big_endian, data + off);
+	  d->ex->italic = get_16 (big_endian, data + off + 2);
+	  off += 4;
+	}
+
+      d->font = get_unicode (data + off, length - off, big_endian, &sublen);
+      off += sublen * 2 + 2;
+    }
+
+  d->controls = NULL;
+  pp = &d->controls;
+
+  for (i = 0; i < c; i++)
+    {
+      struct dialog_control *dc;
+      int datalen;
+
+      off = (off + 3) &~ 3;
+
+      dc = (struct dialog_control *) res_alloc (sizeof *dc);
+
+      if (d->ex == NULL)
+	{
+	  if (length < off + 8)
+	    toosmall ("dialog control");
+
+	  dc->style = get_32 (big_endian, data + off);
+	  dc->exstyle = get_32 (big_endian, data + off + 4);
+	  dc->help = 0;
+	  off += 8;
+	}
+      else
+	{
+	  if (length < off + 12)
+	    toosmall ("dialogex control");
+	  dc->help = get_32 (big_endian, data + off);
+	  dc->exstyle = get_32 (big_endian, data + off + 4);
+	  dc->style = get_32 (big_endian, data + off + 18);
+	  off += 12;
+	}
+
+      if (length < off + 10)
+	toosmall ("dialog control");
+
+      dc->x = get_16 (big_endian, data + off);
+      dc->y = get_16 (big_endian, data + off + 2);
+      dc->width = get_16 (big_endian, data + off + 4);
+      dc->height = get_16 (big_endian, data + off + 6);
+      dc->id = get_16 (big_endian, data + off + 8);
+
+      off += 10;
+
+      sublen = get_resid (&dc->class, data + off, length - off, big_endian);
+      off += sublen;
+
+      sublen = get_resid (&dc->text, data + off, length - off, big_endian);
+      off += sublen;
+
+      if (length < off + 2)
+	toosmall ("dialog control end");
+
+      datalen = get_16 (big_endian, data + off);
+      off += 2;
+
+      if (datalen == 0)
+	dc->data = NULL;
+      else
+	{
+	  off = (off + 3) &~ 3;
+
+	  if (length < off + datalen)
+	    toosmall ("dialog control data");
+
+	  dc->data = ((struct rcdata_item *)
+		      res_alloc (sizeof (struct rcdata_item)));
+	  dc->data->next = NULL;
+	  dc->data->type = RCDATA_BUFFER;
+	  dc->data->u.buffer.length = datalen;
+	  dc->data->u.buffer.data = data + off;
+
+	  off += datalen;	  
+	}
+
+      dc->next = NULL;
+      *pp = dc;
+      pp = &dc->next;
+    }
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_DIALOG;
+  r->u.dialog = d;
+
+  return r;
+}
+
+/* Convert a stringtable resource from binary.  */
+
+static struct res_resource *
+bin_to_res_string (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  struct stringtable *st;
+  int i;
+  struct res_resource *r;
+
+  st = (struct stringtable *) res_alloc (sizeof *st);
+
+  for (i = 0; i < 16; i++)
+    {
+      int slen;
+
+      if (length < 2)
+	toosmall ("stringtable string length");
+      slen = get_16 (big_endian, data);
+      st->strings[i].length = slen;
+
+      if (slen > 0)
+	{
+	  unichar *s;
+	  int j;
+
+	  if (length < 2 + 2 * slen)
+	    toosmall ("stringtable string");
+
+	  s = (unichar *) res_alloc (slen * sizeof (unichar));
+	  st->strings[i].string = s;
+
+	  for (j = 0; j < slen; j++)
+	    s[j] = get_16 (big_endian, data + 2 + j * 2);
+	}
+
+      data += 2 + slen;
+      length -= 2 + slen;
+    }
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_STRINGTABLE;
+  r->u.stringtable = st;
+
+  return r;
+}
+
+/* Convert a fontdir resource from binary.  */
+
+static struct res_resource *
+bin_to_res_fontdir (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  int c, i;
+  struct fontdir *first, **pp;
+  struct res_resource *r;
+
+  if (length < 2)
+    toosmall ("fontdir header");
+
+  c = get_16 (big_endian, data);
+
+  first = NULL;
+  pp = &first;
+
+  for (i = 0; i < c; i++)
+    {
+      struct fontdir *fd;
+      int off;
+
+      if (length < 56)
+	toosmall ("fontdir");
+
+      fd = (struct fontdir *) res_alloc (sizeof *fd);
+      fd->index = get_16 (big_endian, data);
+
+      /* To work out the length of the fontdir data, we must get the
+         length of the device name and face name strings, even though
+         we don't store them in the fontdir structure.  The
+         documentation says that these are NULL terminated char
+         strings, not Unicode strings.  */
+
+      off = 56;
+
+      while (off < length && data[off] != '\0')
+	++off;
+      if (off >= length)
+	toosmall ("fontdir device name");
+      ++off;
+
+      while (off < length && data[off] != '\0')
+	++off;
+      if (off >= length)
+	toosmall ("fontdir face name");
+      ++off;
+
+      fd->length = off;
+      fd->data = data;
+
+      fd->next = NULL;
+      *pp = fd;
+      pp = &fd->next;
+
+      /* The documentation does not indicate that any rounding is
+         required.  */
+
+      data += off;
+      length -= off;
+    }
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_FONTDIR;
+  r->u.fontdir = first;
+
+  return r;
+}
+
+/* Convert an accelerators resource from binary.  */
+
+static struct res_resource *
+bin_to_res_accelerators (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  struct accelerator *first, **pp;
+  struct res_resource *r;
+
+  first = NULL;
+  pp = &first;
+
+  while (1)
+    {
+      struct accelerator *a;
+
+      if (length < 8)
+	toosmall ("accelerator");
+
+      a->flags = get_16 (big_endian, data);
+      a->key = get_16 (big_endian, data + 2);
+      a->id = get_16 (big_endian, data + 4);
+
+      a->next = NULL;
+      *pp = a;
+      pp = &a->next;
+
+      if ((a->flags & ACC_LAST) != 0)
+	break;
+
+      data += 8;
+      length -= 8;
+    }
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_ACCELERATOR;
+  r->u.acc = first;
+
+  return r;
+}
+
+/* Convert an rcdata resource from binary.  */
+
+static struct res_resource *
+bin_to_res_rcdata (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  struct rcdata_item *ri;
+  struct res_resource *r;
+
+  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
+
+  ri->next = NULL;
+  ri->type = RCDATA_BUFFER;
+  ri->u.buffer.length = length;
+  ri->u.buffer.data = data;
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_RCDATA;
+  r->u.rcdata = ri;
+
+  return r;
+}
+
+/* Convert a group cursor resource from binary.  */
+
+static struct res_resource *
+bin_to_res_group_cursor (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  int type, c, i;
+  struct group_cursor *first, **pp;
+  struct res_resource *r;
+
+  if (length < 6)
+    toosmall ("group cursor header");
+
+  type = get_16 (big_endian, data + 2);
+  if (type != 2)
+    fatal ("unexpected group cursor type %d", type);
+
+  c = get_16 (big_endian, data + 4);
+
+  data += 6;
+  length -= 6;
+
+  first = NULL;
+  pp = &first;
+
+  for (i = 0; i < c; i++)
+    {
+      struct group_cursor *gc;
+
+      if (length < 14)
+	toosmall ("group cursor");
+
+      gc = (struct group_cursor *) res_alloc (sizeof *gc);
+
+      gc->width = get_16 (big_endian, data);
+      gc->height = get_16 (big_endian, data + 2);
+      gc->planes = get_16 (big_endian, data + 4);
+      gc->bits = get_16 (big_endian, data + 6);
+      gc->bytes = get_32 (big_endian, data + 8);
+      gc->index = get_16 (big_endian, data + 12);
+
+      gc->next = NULL;
+      *pp = gc;
+      pp = &gc->next;
+
+      data += 14;
+      length -= 14;
+    }
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_GROUP_CURSOR;
+  r->u.group_cursor = first;
+
+  return r;
+}
+
+/* Convert a group icon resource from binary.  */
+
+static struct res_resource *
+bin_to_res_group_icon (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  int type, c, i;
+  struct group_icon *first, **pp;
+  struct res_resource *r;
+
+  if (length < 6)
+    toosmall ("group icon header");
+
+  type = get_16 (big_endian, data + 2);
+  if (type != 1)
+    fatal ("unexpected group icon type %d", type);
+
+  c = get_16 (big_endian, data + 4);
+
+  data += 6;
+  length -= 6;
+
+  first = NULL;
+  pp = &first;
+
+  for (i = 0; i < c; i++)
+    {
+      struct group_icon *gi;
+
+      if (length < 14)
+	toosmall ("group icon");
+
+      gi = (struct group_icon *) res_alloc (sizeof *gi);
+
+      gi->width = data[0];
+      gi->height = data[1];
+      gi->colors = data[2];
+      gi->planes = get_16 (big_endian, data + 4);
+      gi->bits = get_16 (big_endian, data + 6);
+      gi->bytes = get_32 (big_endian, data + 8);
+      gi->index = get_16 (big_endian, data + 12);
+
+      gi->next = NULL;
+      *pp = gi;
+      pp = &gi->next;
+
+      data += 14;
+      length -= 14;
+    }
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_GROUP_ICON;
+  r->u.group_icon = first;
+
+  return r;
+}
+
+/* Extract data from a version header.  If KEY is not NULL, then the
+   key must be KEY; otherwise, the key is returned in *PKEY.  This
+   sets *LEN to the total length, *VALLEN to the value length, *TYPE
+   to the type, and *OFF to the offset to the children.  */
+
+static void
+get_version_header (data, length, big_endian, key, pkey, len, vallen, type,
+		    off)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+     const char *key;
+     unichar **pkey;
+     int *len;
+     int *vallen;
+     int *type;
+     int *off;
+{
+  if (length < 8)
+    toosmall (key);
+
+  *len = get_16 (big_endian, data);
+  *vallen = get_16 (big_endian, data + 2);
+  *type = get_16 (big_endian, data + 4);
+
+  *off = 6;
+
+  length -= 6;
+  data += 6;
+
+  if (key == NULL)
+    {
+      int sublen;
+
+      *pkey = get_unicode (data, length, big_endian, &sublen);
+      *off += sublen * 2 + 2;
+    }
+  else
+    {
+      while (1)
+	{
+	  if (length < 2)
+	    toosmall (key);
+	  if (get_16 (big_endian, data) != *key)
+	    fatal ("unexpected version string");
+
+	  *off += 2;
+	  length -= 2;
+	  data += 2;
+
+	  if (*key == '\0')
+	    break;
+
+	  ++key;
+	}
+    }
+
+  *off = (*off + 3) &~ 3;
+}
+
+/* Convert a version resource from binary.  */
+
+static struct res_resource *
+bin_to_res_version (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  int verlen, vallen, type, off;
+  struct fixed_versioninfo *fi;
+  struct ver_info *first, **pp;
+  struct versioninfo *v;
+  struct res_resource *r;
+
+  get_version_header (data, length, big_endian, "VS_VERSION_INFO",
+		      (unichar *) NULL, &verlen, &vallen, &type, &off);
+
+  if (verlen != length)
+    fatal ("version length %d does not match resource length %lu",
+	   verlen, length);
+
+  if (type != 0)
+    fatal ("unexpected version type %d", type);
+
+  data += off;
+  length -= off;
+
+  if (vallen == 0)
+    fi = NULL;
+  else
+    {
+      unsigned long signature, fiv;
+
+      if (vallen != 52)
+	fatal ("unexpected fixed version information length %d", vallen);
+
+      if (length < 52)
+	toosmall ("fixed version info");
+
+      signature = get_32 (big_endian, data);
+      if (signature != 0xfeef04bd)
+	fatal ("unexpected fixed version signature %lu", signature);
+
+      fiv = get_32 (big_endian, data + 4);
+      if (fiv != 0 && fiv != 0x10000)
+	fatal ("unexpected fixed version info version %lu", fiv);
+
+      fi = (struct fixed_versioninfo *) res_alloc (sizeof *fi);
+
+      fi->file_version_ms = get_32 (big_endian, data + 8);
+      fi->file_version_ls = get_32 (big_endian, data + 12);
+      fi->product_version_ms = get_32 (big_endian, data + 16);
+      fi->product_version_ls = get_32 (big_endian, data + 20);
+      fi->file_flags_mask = get_32 (big_endian, data + 24);
+      fi->file_flags = get_32 (big_endian, data + 28);
+      fi->file_os = get_32 (big_endian, data + 32);
+      fi->file_type = get_32 (big_endian, data + 36);
+      fi->file_subtype = get_32 (big_endian, data + 40);
+      fi->file_date_ms = get_32 (big_endian, data + 44);
+      fi->file_date_ls = get_32 (big_endian, data + 48);
+
+      data += 52;
+      length -= 52;
+    }
+
+  first = NULL;
+  pp = &first;
+
+  while (length > 0)
+    {
+      struct ver_info *vi;
+      int ch;
+
+      if (length < 8)
+	toosmall ("version var info");
+
+      vi = (struct ver_info *) res_alloc (sizeof *vi);
+
+      ch = get_16 (big_endian, data + 6);
+
+      if (ch == 'S')
+	{
+	  struct ver_stringinfo **ppvs;
+
+	  vi->type = VERINFO_STRING;
+
+	  get_version_header (data, length, big_endian, "StringFileInfo",
+			      (unichar *) NULL, &verlen, &vallen, &type,
+			      &off);
+
+	  if (vallen != 0)
+	    fatal ("unexpected stringfileinfo value length %d", vallen);
+
+	  data += off;
+	  length -= off;
+
+	  get_version_header (data, length, big_endian, (const char *) NULL,
+			      &vi->u.string.language, &verlen, &vallen,
+			      &type, &off);
+
+	  if (vallen != 0)
+	    fatal ("unexpected version stringtable value length %d", vallen);
+
+	  data += off;
+	  length -= off;
+	  verlen -= off;
+
+	  vi->u.string.strings = NULL;
+	  ppvs = &vi->u.string.strings;
+
+	  /* It's convenient to round verlen to a 4 byte alignment,
+             since we round the subvariables in the loop.  */
+	  verlen = (verlen + 3) &~ 3;
+
+	  while (verlen > 0)
+	    {
+	      struct ver_stringinfo *vs;
+	      int subverlen, vslen, valoff;
+
+	      vs = (struct ver_stringinfo *) res_alloc (sizeof *vs);
+
+	      get_version_header (data, length, big_endian,
+				  (const char *) NULL, &vs->key, &subverlen,
+				  &vallen, &type, &off);
+
+	      subverlen = (subverlen + 3) &~ 3;
+
+	      data += off;
+	      length -= off;
+
+	      vs->value = get_unicode (data, length, big_endian, &vslen);
+	      valoff = vslen * 2 + 2;
+	      valoff = (valoff + 3) &~ 3;
+
+	      if (off + valoff != subverlen)
+		fatal ("unexpected version string length %d != %d + %d",
+		       subverlen, off, valoff);
+
+	      vs->next = NULL;
+	      *ppvs = vs;
+	      ppvs = &vs->next;
+
+	      data += valoff;
+	      length -= valoff;
+
+	      if (verlen < subverlen)
+		fatal ("unexpected version string length %d < %d",
+		       verlen, subverlen);
+
+	      verlen -= subverlen;
+	    }
+	}
+      else if (ch == 'V')
+	{
+	  struct ver_varinfo **ppvv;
+
+	  vi->type = VERINFO_VAR;
+
+	  get_version_header (data, length, big_endian, "VarFileInfo",
+			      (unichar *) NULL, &verlen, &vallen, &type,
+			      &off);
+
+	  if (vallen != 0)
+	    fatal ("unexpected varfileinfo value length %d", vallen);
+
+	  data += off;
+	  length -= off;
+
+	  get_version_header (data, length, big_endian, (const char *) NULL,
+			      &vi->u.var.key, &verlen, &vallen, &type, &off);
+
+	  data += off;
+	  length -= off;
+
+	  vi->u.var.var = NULL;
+	  ppvv = &vi->u.var.var;
+
+	  while (vallen > 0)
+	    {
+	      struct ver_varinfo *vv;
+
+	      if (length < 4)
+		toosmall ("version varfileinfo");
+
+	      vv = (struct ver_varinfo *) res_alloc (sizeof *vv);
+
+	      vv->language = get_16 (big_endian, data);
+	      vv->charset = get_16 (big_endian, data + 2);
+
+	      vv->next = NULL;
+	      *ppvv = vv;
+	      ppvv = &vv->next;
+
+	      data += 4;
+	      length -= 4;
+
+	      if (vallen < 4)
+		fatal ("unexpected version value length %d", vallen);
+
+	      vallen -= 4;
+	    }
+	}
+      else
+	fatal ("unexpected version string");
+
+      vi->next = NULL;
+      *pp = vi;
+      pp = &vi->next;      
+    }
+
+  v = (struct versioninfo *) res_alloc (sizeof *v);
+  v->fixed = fi;
+  v->var = first;
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_VERSIONINFO;
+  r->u.versioninfo = v;
+
+  return r;  
+}
+
+/* Convert an arbitrary user defined resource from binary.  */
+
+static struct res_resource *
+bin_to_res_userdata (data, length, big_endian)
+     const unsigned char *data;
+     unsigned long length;
+     int big_endian;
+{
+  struct rcdata_item *ri;
+  struct res_resource *r;
+
+  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
+
+  ri->next = NULL;
+  ri->type = RCDATA_BUFFER;
+  ri->u.buffer.length = length;
+  ri->u.buffer.data = data;
+
+  r = (struct res_resource *) res_alloc (sizeof *r);
+  r->type = RES_TYPE_USERDATA;
+  r->u.rcdata = ri;
+
+  return r;
+}
+
+/* Macros to swap out values.  */
+
+#define put_16(be, v, s) ((be) ? bfd_putb16 ((v), (s)) : bfd_putl16 ((v), (s)))
+#define put_32(be, v, s) ((be) ? bfd_putb32 ((v), (s)) : bfd_putl32 ((v), (s)))
+
+/* Local functions used to convert resources to binary format.  */
+
+static void dword_align_bin PARAMS ((struct bindata ***, unsigned long *));
+static struct bindata *resid_to_bin PARAMS ((struct res_id, int));
+static struct bindata *unicode_to_bin PARAMS ((const unichar *, int));
+static struct bindata *res_to_bin_accelerator
+  PARAMS ((const struct accelerator *, int));
+static struct bindata *res_to_bin_cursor
+  PARAMS ((const struct cursor *, int));
+static struct bindata *res_to_bin_group_cursor
+  PARAMS ((const struct group_cursor *, int));
+static struct bindata *res_to_bin_dialog
+  PARAMS ((const struct dialog *, int));
+static struct bindata *res_to_bin_fontdir
+  PARAMS ((const struct fontdir *, int));
+static struct bindata *res_to_bin_group_icon
+  PARAMS ((const struct group_icon *, int));
+static struct bindata *res_to_bin_menu
+  PARAMS ((const struct menu *, int));
+static struct bindata *res_to_bin_menuitems
+  PARAMS ((const struct menuitem *, int));
+static struct bindata *res_to_bin_menuexitems
+  PARAMS ((const struct menuitem *, int));
+static struct bindata *res_to_bin_rcdata
+  PARAMS ((const struct rcdata_item *, int));
+static struct bindata *res_to_bin_stringtable
+  PARAMS ((const struct stringtable *, int));
+static struct bindata *string_to_unicode_bin PARAMS ((const char *, int));
+static struct bindata *res_to_bin_versioninfo
+  PARAMS ((const struct versioninfo *, int));
+static struct bindata *res_to_bin_generic
+  PARAMS ((unsigned long, const unsigned char *));
+
+/* Convert a resource to binary.  */
+
+struct bindata *
+res_to_bin (res, big_endian)
+     const struct res_resource *res;
+     int big_endian;
+{
+  switch (res->type)
+    {
+    default:
+      abort ();
+    case RES_TYPE_BITMAP:
+    case RES_TYPE_FONT:
+    case RES_TYPE_ICON:
+    case RES_TYPE_MESSAGETABLE:
+      return res_to_bin_generic (res->u.data.length, res->u.data.data);
+    case RES_TYPE_ACCELERATOR:
+      return res_to_bin_accelerator (res->u.acc, big_endian);
+    case RES_TYPE_CURSOR:
+      return res_to_bin_cursor (res->u.cursor, big_endian);
+    case RES_TYPE_GROUP_CURSOR:
+      return res_to_bin_group_cursor (res->u.group_cursor, big_endian);
+    case RES_TYPE_DIALOG:
+      return res_to_bin_dialog (res->u.dialog, big_endian);
+    case RES_TYPE_FONTDIR:
+      return res_to_bin_fontdir (res->u.fontdir, big_endian);
+    case RES_TYPE_GROUP_ICON:
+      return res_to_bin_group_icon (res->u.group_icon, big_endian);
+    case RES_TYPE_MENU:
+      return res_to_bin_menu (res->u.menu, big_endian);
+    case RES_TYPE_RCDATA:
+      return res_to_bin_rcdata (res->u.rcdata, big_endian);
+    case RES_TYPE_STRINGTABLE:
+      return res_to_bin_stringtable (res->u.stringtable, big_endian);
+    case RES_TYPE_USERDATA:
+      return res_to_bin_rcdata (res->u.rcdata, big_endian);
+    case RES_TYPE_VERSIONINFO:
+      return res_to_bin_versioninfo (res->u.versioninfo, big_endian);
+    }
+}
+
+/* Align to a 32 bit boundary.  PPP points to the of a list of bindata
+   structures.  LENGTH points to the length of the structures.  If
+   necessary, this adds a new bindata to bring length up to a 32 bit
+   boundary.  It updates *PPP and *LENGTH.  */
+
+static void
+dword_align_bin (ppp, length)
+     struct bindata ***ppp;
+     unsigned long *length;
+{
+  int add;
+  struct bindata *d;
+
+  if ((*length & 3) == 0)
+    return;
+
+  add = 4 - (*length & 3);
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+  d->length = add;
+  d->data = (unsigned char *) reswr_alloc (add);
+  memset (d->data, 0, add);
+
+  d->next = NULL;
+  **ppp = d;
+  *ppp = &(**ppp)->next;
+
+  *length += add;
+}
+
+/* Convert a resource ID to binary.  This always returns exactly one
+   bindata structure.  */
+
+static struct bindata *
+resid_to_bin (id, big_endian)
+     struct res_id id;
+     int big_endian;
+{
+  struct bindata *d;
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+
+  if (! id.named)
+    {
+      d->length = 4;
+      d->data = (unsigned char *) reswr_alloc (4);
+      put_16 (big_endian, 0xffff, d->data);
+      put_16 (big_endian, id.u.id, d->data + 2);
+    }
+  else
+    {
+      int i;
+
+      d->length = id.u.n.length * 2 + 2;
+      d->data = (unsigned char *) reswr_alloc (d->length);
+      for (i = 0; i < id.u.n.length; i++)
+	put_16 (big_endian, id.u.n.name[i], d->data + i * 2);
+      put_16 (big_endian, 0, d->data + i * 2);
+    }
+
+  d->next = NULL;
+
+  return d;
+}
+
+/* Convert a null terminated unicode string to binary.  This always
+   returns exactly one bindata structure.  */
+
+static struct bindata *
+unicode_to_bin (str, big_endian)
+     const unichar *str;
+     int big_endian;
+{
+  int len;
+  struct bindata *d;
+
+  len = 0;
+  if (str != NULL)
+    {
+      const unichar *s;
+
+      for (s = str; *s != 0; s++)
+	++len;
+    }
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+  d->length = len * 2 + 2;
+  d->data = (unsigned char *) reswr_alloc (d->length);
+
+  if (str == NULL)
+    put_16 (big_endian, 0, d->data);
+  else
+    {
+      const unichar *s;
+      int i;
+
+      for (s = str, i = 0; *s != 0; s++, i++)
+	put_16 (big_endian, *s, d->data + i * 2);
+      put_16 (big_endian, 0, d->data + i * 2);
+    }
+
+  d->next = NULL;
+
+  return d;
+}
+
+/* Convert an accelerator resource to binary.  */
+
+static struct bindata *
+res_to_bin_accelerator (accelerators, big_endian)
+     const struct accelerator *accelerators;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  const struct accelerator *a;
+
+  first = NULL;
+  pp = &first;
+
+  for (a = accelerators; a != NULL; a = a->next)
+    {
+      struct bindata *d;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 8;
+      d->data = (unsigned char *) reswr_alloc (8);
+
+      put_16 (big_endian,
+	      a->flags | (a->next == NULL ? 0 : ACC_LAST),
+	      d->data);
+      put_16 (big_endian, a->key, d->data + 2);
+      put_16 (big_endian, a->id, d->data + 4);
+      put_16 (big_endian, 0, d->data + 8);
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;
+    }
+
+  return first;
+}
+
+/* Convert a cursor resource to binary.  */
+
+static struct bindata *
+res_to_bin_cursor (c, big_endian)
+     const struct cursor *c;
+     int big_endian;
+{
+  struct bindata *d;
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+  d->length = 4;
+  d->data = (unsigned char *) reswr_alloc (4);
+
+  put_16 (big_endian, c->xhotspot, d->data);
+  put_16 (big_endian, c->yhotspot, d->data + 2);
+
+  d->next = (struct bindata *) reswr_alloc (sizeof *d);
+  d->next->length = c->length;
+  d->next->data = (unsigned char *) c->data;
+  d->next->next = NULL;
+
+  return d;
+}
+
+/* Convert a group cursor resource to binary.  */
+
+static struct bindata *
+res_to_bin_group_cursor (group_cursors, big_endian)
+     const struct group_cursor *group_cursors;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  int c;
+  const struct group_cursor *gc;
+
+  first = (struct bindata *) reswr_alloc (sizeof *first);
+  first->length = 6;
+  first->data = (unsigned char *) reswr_alloc (6);
+
+  put_16 (big_endian, 0, first->data);
+  put_16 (big_endian, 2, first->data + 2);
+
+  first->next = NULL;
+  pp = &first->next;
+
+  c = 0;
+  for (gc = group_cursors; gc != NULL; gc = gc->next)
+    {
+      struct bindata *d;
+
+      ++c;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 14;
+      d->data = (unsigned char *) reswr_alloc (14);
+
+      put_16 (big_endian, gc->width, d->data);
+      put_16 (big_endian, gc->height, d->data + 2);
+      put_16 (big_endian, gc->planes, d->data + 4);
+      put_16 (big_endian, gc->bits, d->data + 6);
+      put_32 (big_endian, gc->bytes, d->data + 8);
+      put_16 (big_endian, gc->index, d->data + 12);
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;
+    }
+
+  put_16 (big_endian, c, first->data + 4);
+
+  return first;
+}
+
+/* Convert a dialog resource to binary.  */
+
+static struct bindata *
+res_to_bin_dialog (dialog, big_endian)
+     const struct dialog *dialog;
+     int big_endian;
+{
+  int dialogex;
+  struct bindata *first, **pp;
+  unsigned long length;
+  int off, c;
+  struct dialog_control *dc;
+
+  dialogex = extended_dialog (dialog);
+
+  first = (struct bindata *) reswr_alloc (sizeof *first);
+  first->length = dialogex ? 26 : 18;
+  first->data = (unsigned char *) reswr_alloc (first->length);
+
+  length = first->length;
+
+  if (! dialogex)
+    {
+      put_32 (big_endian, dialog->style, first->data);
+      put_32 (big_endian, dialog->style, first->data + 4);
+      off = 8;
+    }
+  else
+    {
+      put_16 (big_endian, 0xffff, first->data);
+      put_16 (big_endian, 1, first->data + 2);
+      if (dialog->ex == NULL)
+	put_32 (big_endian, 0, first->data + 4);
+      else
+	put_32 (big_endian, dialog->ex->help, first->data + 4);
+      put_32 (big_endian, dialog->exstyle, first->data + 8);
+      put_32 (big_endian, dialog->style, first->data + 12);
+      off = 16;
+    }
+
+  put_16 (big_endian, dialog->x, first->data + off + 2);
+  put_16 (big_endian, dialog->y, first->data + off + 4);
+  put_16 (big_endian, dialog->width, first->data + off + 6);
+  put_16 (big_endian, dialog->height, first->data + off + 8);
+
+  pp = &first->next;
+
+  *pp = resid_to_bin (dialog->menu, big_endian);
+  length += (*pp)->length;
+  pp = &(*pp)->next;
+
+  *pp = resid_to_bin (dialog->class, big_endian);
+  length += (*pp)->length;
+  pp = &(*pp)->next;
+
+  *pp = unicode_to_bin (dialog->caption, big_endian);
+  length += (*pp)->length;
+  pp = &(*pp)->next;
+
+  if ((dialog->style & DS_SETFONT) != 0)
+    {
+      struct bindata *d;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = dialogex ? 2 : 6;
+      d->data = (unsigned char *) reswr_alloc (d->length);
+
+      length += d->length;
+
+      put_16 (big_endian, dialog->pointsize, d->data);
+
+      if (dialogex)
+	{
+	  if (dialog->ex == NULL)
+	    {
+	      put_16 (big_endian, 0, d->data + 2);
+	      put_16 (big_endian, 0, d->data + 4);
+	    }
+	  else
+	    {
+	      put_16 (big_endian, dialog->ex->weight, d->data + 2);
+	      put_16 (big_endian, dialog->ex->italic, d->data + 4);
+	    }
+	}
+
+      *pp = d;
+      pp = &d->next;
+
+      *pp = unicode_to_bin (dialog->font, big_endian);
+      length += (*pp)->length;
+      pp = &(*pp)->next;
+    }
+
+  c = 0;
+  for (dc = dialog->controls; dc != NULL; dc = dc->next)
+    {
+      unsigned long length;
+      struct bindata *d;
+      int dcoff;
+
+      ++c;
+
+      dword_align_bin (&pp, &length);
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = dialogex ? 22 : 18;
+      d->data = (unsigned char *) reswr_alloc (d->length);
+
+      length += d->length;
+
+      if (! dialogex)
+	{
+	  put_32 (big_endian, dc->style, d->data);
+	  put_32 (big_endian, dc->exstyle, d->data + 4);
+	  dcoff = 8;
+	}
+      else
+	{
+	  put_32 (big_endian, dc->help, d->data);
+	  put_32 (big_endian, dc->exstyle, d->data + 4);
+	  put_32 (big_endian, dc->style, d->data + 8);
+	  dcoff = 12;
+	}
+
+      put_16 (big_endian, dc->x, d->data + dcoff);
+      put_16 (big_endian, dc->y, d->data + dcoff + 2);
+      put_16 (big_endian, dc->width, d->data + dcoff + 4);
+      put_16 (big_endian, dc->height, d->data + dcoff + 6);
+      put_16 (big_endian, dc->id, d->data + dcoff + 8);
+
+      *pp = d;
+      pp = &d->next;
+
+      *pp = resid_to_bin (dc->class, big_endian);
+      length += (*pp)->length;
+      pp = &(*pp)->next;
+
+      *pp = resid_to_bin (dc->text, big_endian);
+      length += (*pp)->length;
+      pp = &(*pp)->next;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 2;
+      d->data = (unsigned char *) reswr_alloc (2);
+
+      length += 2;
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;
+
+      if (dc->data == NULL)
+	put_16 (big_endian, 0, d->data);
+      else
+	{
+	  dword_align_bin (&pp, &length);
+
+	  *pp = res_to_bin_rcdata (dc->data, big_endian);
+	  while (*pp != NULL)
+	    {
+	      length += (*pp)->length;
+	      pp = &(*pp)->next;
+	    }
+	}
+    }
+
+  put_16 (big_endian, c, first->data + off);
+
+  return first;
+}
+
+/* Convert a fontdir resource to binary.  */
+
+static struct bindata *
+res_to_bin_fontdir (fontdirs, big_endian)
+     const struct fontdir *fontdirs;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  int c;
+  const struct fontdir *fd;
+
+  first = (struct bindata *) reswr_alloc (sizeof *first);
+  first->length = 2;
+  first->data = (unsigned char *) reswr_alloc (2);
+
+  first->next = NULL;
+  pp = &first->next;
+
+  c = 0;
+  for (fd = fontdirs; fd != NULL; fd = fd->next)
+    {
+      struct bindata *d;
+
+      ++c;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 2;
+      d->data = (unsigned char *) reswr_alloc (2);
+
+      put_16 (big_endian, fd->index, d->data);
+
+      *pp = d;
+      pp = &d->next;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = fd->length;
+      d->data = (unsigned char *) fd->data;
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;      
+    }
+
+  put_16 (big_endian, c, first->data);
+
+  return first;  
+}
+
+/* Convert a group icon resource to binary.  */
+
+static struct bindata *
+res_to_bin_group_icon (group_icons, big_endian)
+     const struct group_icon *group_icons;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  int c;
+  const struct group_icon *gi;
+
+  first = (struct bindata *) reswr_alloc (sizeof *first);
+  first->length = 6;
+  first->data = (unsigned char *) reswr_alloc (6);
+
+  put_16 (big_endian, 0, first->data);
+  put_16 (big_endian, 1, first->data + 2);
+
+  first->next = NULL;
+  pp = &first->next;
+
+  c = 0;
+  for (gi = group_icons; gi != NULL; gi = gi->next)
+    {
+      struct bindata *d;
+
+      ++c;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 14;
+      d->data = (unsigned char *) reswr_alloc (14);
+
+      d->data[0] = gi->width;
+      d->data[1] = gi->height;
+      d->data[2] = gi->colors;
+      d->data[3] = 0;
+      put_16 (big_endian, gi->planes, d->data + 4);
+      put_16 (big_endian, gi->bits, d->data + 6);
+      put_32 (big_endian, gi->bytes, d->data + 8);
+      put_16 (big_endian, gi->index, d->data + 12);
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;
+    }
+
+  put_16 (big_endian, c, first->data + 4);
+
+  return first;
+}
+
+/* Convert a menu resource to binary.  */
+
+static struct bindata *
+res_to_bin_menu (menu, big_endian)
+     const struct menu *menu;
+     int big_endian;
+{
+  int menuex;
+  struct bindata *d;
+
+  menuex = extended_menu (menu);
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+  d->length = menuex ? 4 : 8;
+  d->data = (unsigned char *) reswr_alloc (d->length);
+
+  if (! menuex)
+    {
+      put_16 (big_endian, 0, d->data);
+      put_16 (big_endian, 0, d->data + 2);
+
+      d->next = res_to_bin_menuitems (menu->items, big_endian);
+    }
+  else
+    {
+      put_16 (big_endian, 1, d->data);
+      put_16 (big_endian, 4, d->data + 2);
+      put_32 (big_endian, menu->help, d->data + 4);
+
+      d->next = res_to_bin_menuexitems (menu->items, big_endian);
+    }
+
+  return d;
+}
+
+/* Convert menu items to binary.  */
+
+static struct bindata *
+res_to_bin_menuitems (items, big_endian)
+     const struct menuitem *items;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  const struct menuitem *mi;
+
+  first = NULL;
+  pp = &first;
+
+  for (mi = items; mi != NULL; mi = mi->next)
+    {
+      struct bindata *d;
+      int flags;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = mi->popup == NULL ? 4 : 2;
+      d->data = (unsigned char *) reswr_alloc (d->length);
+
+      flags = mi->type;
+      if (mi->next == NULL)
+	flags |= MENUITEM_ENDMENU;
+      if (mi->popup != NULL)
+	flags |= MENUITEM_POPUP;
+
+      put_16 (big_endian, flags, d->data);
+
+      if (mi->popup == NULL)
+	put_16 (big_endian, mi->id, d->data + 2);
+
+      *pp = d;
+      pp = &d->next;
+
+      *pp = unicode_to_bin (mi->text, big_endian);
+      pp = &(*pp)->next;
+
+      if (mi->popup != NULL)
+	{
+	  *pp = res_to_bin_menuitems (mi->popup, big_endian);
+	  while (*pp != NULL)
+	    pp = &(*pp)->next;
+	}
+    }
+
+  return first;
+}
+
+/* Convert menuex items to binary.  */
+
+static struct bindata *
+res_to_bin_menuexitems (items, big_endian)
+     const struct menuitem *items;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  unsigned long length;
+  const struct menuitem *mi;
+
+  first = NULL;
+  pp = &first;
+
+  length = 0;
+
+  for (mi = items; mi != NULL; mi = mi->next)
+    {
+      struct bindata *d;
+      int flags;
+
+      dword_align_bin (&pp, &length);
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 12;
+      d->data = (unsigned char *) reswr_alloc (12);
+
+      length += 12;
+
+      put_32 (big_endian, mi->type, d->data);
+      put_32 (big_endian, mi->state, d->data + 4);
+      put_16 (big_endian, mi->id, d->data + 8);
+
+      flags = 0;
+      if (mi->next == NULL)
+	flags |= 0x80;
+      if (mi->popup != NULL)
+	flags |= 1;
+      put_16 (big_endian, flags, d->data + 10);
+
+      *pp = d;
+      pp = &d->next;
+
+      *pp = unicode_to_bin (mi->text, big_endian);
+      length += (*pp)->length;
+      pp = &(*pp)->next;
+
+      if (mi->popup != NULL)
+	{
+	  dword_align_bin (&pp, &length);
+
+	  d = (struct bindata *) reswr_alloc (sizeof *d);
+	  d->length = 4;
+	  d->data = (unsigned char *) reswr_alloc (4);
+
+	  put_32 (big_endian, mi->help, d->data);
+
+	  *pp = d;
+	  pp = &d->next;
+
+	  *pp = res_to_bin_menuexitems (mi->popup, big_endian);
+	  while (*pp != NULL)
+	    {
+	      length += (*pp)->length;
+	      pp = &(*pp)->next;
+	    }
+	}
+    }
+
+  return first;
+}
+
+/* Convert an rcdata resource to binary.  This is also used to convert
+   other information which happens to be stored in rcdata_item lists
+   to binary.  */
+
+static struct bindata *
+res_to_bin_rcdata (items, big_endian)
+     const struct rcdata_item *items;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  const struct rcdata_item *ri;
+
+  first = NULL;
+  pp = &first;
+
+  for (ri = items; ri != NULL; ri = ri->next)
+    {
+      struct bindata *d;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+
+      switch (ri->type)
+	{
+	default:
+	  abort ();
+
+	case RCDATA_WORD:
+	  d->length = 2;
+	  d->data = (unsigned char *) reswr_alloc (2);
+	  put_16 (big_endian, ri->u.word, d->data);
+	  break;
+
+	case RCDATA_DWORD:
+	  d->length = 4;
+	  d->data = (unsigned char *) reswr_alloc (4);
+	  put_32 (big_endian, ri->u.dword, d->data);
+	  break;
+
+	case RCDATA_STRING:
+	  d->length = ri->u.string.length;
+	  d->data = (unsigned char *) ri->u.string.s;
+	  break;
+
+	case RCDATA_WSTRING:
+	  {
+	    unsigned long i;
+
+	    d->length = ri->u.wstring.length * 2;
+	    d->data = (unsigned char *) reswr_alloc (d->length);
+	    for (i = 0; i < ri->u.wstring.length; i++)
+	      put_16 (big_endian, ri->u.wstring.w[i], d->data + i * 2);
+	    break;
+	  }
+
+	case RCDATA_BUFFER:
+	  d->length = ri->u.buffer.length;
+	  d->data = (unsigned char *) ri->u.buffer.data;
+	  break;
+	}
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;
+    }
+
+  return first;
+}
+
+/* Convert a stringtable resource to binary.  */
+
+static struct bindata *
+res_to_bin_stringtable (st, big_endian)
+     const struct stringtable *st;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  int i;
+
+  first = NULL;
+  pp = &first;
+
+  for (i = 0; i < 16; i++)
+    {
+      int slen, j;
+      struct bindata *d;
+      unichar *s;
+
+      slen = st->strings[i].length;
+      s = st->strings[i].string;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 2 + slen * 2;
+      d->data = (unsigned char *) reswr_alloc (d->length);
+
+      put_16 (big_endian, slen, d->data);
+
+      for (j = 0; j < slen; j++)
+	put_16 (big_endian, s[j], d->data + 2 + j * 2);
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;      
+    }
+
+  return first;
+}
+
+/* Convert an ASCII string to a unicode binary string.  This always
+   returns exactly one bindata structure.  */
+
+static struct bindata *
+string_to_unicode_bin (s, big_endian)
+     const char *s;
+     int big_endian;
+{
+  size_t len, i;
+  struct bindata *d;
+
+  len = strlen (s);
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+  d->length = len * 2 + 2;
+  d->data = (unsigned char *) reswr_alloc (d->length);
+
+  for (i = 0; i < len; i++)
+    put_16 (big_endian, s[i], d->data + i * 2);
+  put_16 (big_endian, 0, d->data + i * 2);
+
+  d->next = NULL;
+
+  return d;  
+}
+
+/* Convert a versioninfo resource to binary.  */
+
+static struct bindata *
+res_to_bin_versioninfo (versioninfo, big_endian)
+     const struct versioninfo *versioninfo;
+     int big_endian;
+{
+  struct bindata *first, **pp;
+  unsigned long length;
+  struct ver_info *vi;
+
+  first = (struct bindata *) reswr_alloc (sizeof *first);
+  first->length = 6;
+  first->data = (unsigned char *) reswr_alloc (6);
+
+  length = 6;
+
+  if (versioninfo->fixed == NULL)
+    put_16 (big_endian, 0, first->data + 2);
+  else
+    put_16 (big_endian, 52, first->data + 2);
+
+  put_16 (big_endian, 0, first->data + 4);
+
+  pp = &first->next;
+
+  *pp = string_to_unicode_bin ("VS_VERSION_INFO", big_endian);
+  length += (*pp)->length;
+  pp = &(*pp)->next;
+
+  dword_align_bin (&pp, &length);
+
+  if (versioninfo->fixed != NULL)
+    {
+      const struct fixed_versioninfo *fi;
+      struct bindata *d;
+
+      d = (struct bindata *) reswr_alloc (sizeof *d);
+      d->length = 52;
+      d->data = (unsigned char *) reswr_alloc (52);
+
+      length += 52;
+
+      fi = versioninfo->fixed;
+
+      put_32 (big_endian, 0xfeef04bd, d->data);
+      put_32 (big_endian, 0x10000, d->data + 4);
+      put_32 (big_endian, fi->file_version_ms, d->data + 8);
+      put_32 (big_endian, fi->file_version_ls, d->data + 12);
+      put_32 (big_endian, fi->product_version_ms, d->data + 16);
+      put_32 (big_endian, fi->product_version_ls, d->data + 20);
+      put_32 (big_endian, fi->file_flags_mask, d->data + 24);
+      put_32 (big_endian, fi->file_flags, d->data + 28);
+      put_32 (big_endian, fi->file_os, d->data + 32);
+      put_32 (big_endian, fi->file_type, d->data + 36);
+      put_32 (big_endian, fi->file_subtype, d->data + 40);
+      put_32 (big_endian, fi->file_date_ms, d->data + 44);
+      put_32 (big_endian, fi->file_date_ls, d->data + 48);
+
+      d->next = NULL;
+      *pp = d;
+      pp = &d->next;
+    }
+
+  for (vi = versioninfo->var; vi != NULL; vi = vi->next)
+    {
+      struct bindata *vid;
+      unsigned long vilen;
+
+      dword_align_bin (&pp, &length);
+
+      vid = (struct bindata *) reswr_alloc (sizeof *vid);
+      vid->length = 6;
+      vid->data = (unsigned char *) reswr_alloc (6);
+
+      length += 6;
+      vilen = 6;
+
+      put_16 (big_endian, 0, vid->data + 2);
+      put_16 (big_endian, 0, vid->data + 4);
+
+      *pp = vid;
+      pp = &vid->next;
+
+      switch (vi->type)
+	{
+	default:
+	  abort ();
+
+	case VERINFO_STRING:
+	  {
+	    unsigned long hold, vslen;
+	    struct bindata *vsd;
+	    const struct ver_stringinfo *vs;
+
+	    *pp = string_to_unicode_bin ("StringFileInfo", big_endian);
+	    length += (*pp)->length;
+	    vilen += (*pp)->length;
+	    pp = &(*pp)->next;
+
+	    hold = length;
+	    dword_align_bin (&pp, &length);
+	    vilen += length - hold;
+
+	    vsd = (struct bindata *) reswr_alloc (sizeof *vsd);
+	    vsd->length = 6;
+	    vsd->data = (unsigned char *) reswr_alloc (6);
+
+	    length += 6;
+	    vilen += 6;
+	    vslen = 6;
+
+	    put_16 (big_endian, 0, vsd->data + 2);
+	    put_16 (big_endian, 0, vsd->data + 4);
+
+	    *pp = vsd;
+	    pp = &vsd->next;
+
+	    *pp = unicode_to_bin (vi->u.string.language, big_endian);
+	    length += (*pp)->length;
+	    vilen += (*pp)->length;
+	    vslen += (*pp)->length;
+	    pp = &(*pp)->next;
+
+	    for (vs = vi->u.string.strings; vs != NULL; vs = vs->next)
+	      {
+		struct bindata *vssd;
+		unsigned long vsslen;
+
+		hold = length;
+		dword_align_bin (&pp, &length);
+		vilen += length - hold;
+		vslen += length - hold;
+
+		vssd = (struct bindata *) reswr_alloc (sizeof *vssd);
+		vssd->length = 6;
+		vssd->data = (unsigned char *) reswr_alloc (6);
+
+		length += 6;
+		vilen += 6;
+		vslen += 6;
+		vsslen = 6;
+
+		put_16 (big_endian, 0, vssd->data + 2);
+		put_16 (big_endian, 1, vssd->data + 4);
+
+		*pp = vssd;
+		pp = &vssd->next;
+
+		*pp = unicode_to_bin (vs->key, big_endian);
+		length += (*pp)->length;
+		vilen += (*pp)->length;
+		vslen += (*pp)->length;
+		vsslen += (*pp)->length;
+		pp = &(*pp)->next;
+
+		hold = length;
+		dword_align_bin (&pp, &length);
+		vilen += length - hold;
+		vslen += length - hold;
+		vsslen += length - hold;
+
+		*pp = unicode_to_bin (vs->value, big_endian);
+		length += (*pp)->length;
+		vilen += (*pp)->length;
+		vslen += (*pp)->length;
+		vsslen += (*pp)->length;
+		pp = &(*pp)->next;
+
+		put_16 (big_endian, vsslen, vssd->data);
+	      }
+
+	    put_16 (big_endian, vslen, vsd->data);
+
+	    break;
+	  }
+
+	case VERINFO_VAR:
+	  {
+	    unsigned long hold, vvlen, vvvlen;
+	    struct bindata *vvd;
+	    const struct ver_varinfo *vv;
+
+	    *pp = string_to_unicode_bin ("VarFileInfo", big_endian);
+	    length += (*pp)->length;
+	    vilen += (*pp)->length;
+	    pp = &(*pp)->next;
+
+	    hold = length;
+	    dword_align_bin (&pp, &length);
+	    vilen += length - hold;
+
+	    vvd = (struct bindata *) reswr_alloc (sizeof *vvd);
+	    vvd->length = 6;
+	    vvd->data = (unsigned char *) reswr_alloc (6);
+
+	    length += 6;
+	    vilen += 6;
+	    vvlen = 6;
+
+	    put_16 (big_endian, 0, vvd->data + 4);
+
+	    *pp = vvd;
+	    pp = &vvd->next;
+
+	    *pp = unicode_to_bin (vi->u.var.key, big_endian);
+	    length += (*pp)->length;
+	    vilen += (*pp)->length;
+	    vvlen += (*pp)->length;
+	    pp = &(*pp)->next;
+
+	    hold = length;
+	    dword_align_bin (&pp, &length);
+	    vilen += length - hold;
+	    vvlen += length - hold;
+
+	    vvvlen = 0;
+
+	    for (vv = vi->u.var.var; vv != NULL; vv = vv->next)
+	      {
+		struct bindata *vvsd;
+
+		vvsd = (struct bindata *) reswr_alloc (sizeof *vvsd);
+		vvsd->length = 4;
+		vvsd->data = (unsigned char *) reswr_alloc (4);
+
+		length += 4;
+		vilen += 4;
+		vvlen += 4;
+		vvvlen += 4;
+
+		put_16 (big_endian, vv->language, vvsd->data);
+		put_16 (big_endian, vv->charset, vvsd->data + 2);
+
+		vvsd->next = NULL;
+		*pp = vvsd;
+		pp = &vvsd->next;
+	      }
+
+	    put_16 (big_endian, vvlen, vvd->data);
+	    put_16 (big_endian, vvvlen, vvd->data + 2);
+
+	    break;
+	  }
+	}
+
+      put_16 (big_endian, vilen, vid->data);
+    }
+
+  put_16 (big_endian, length, first->data);
+
+  return first;
+}
+
+/* Convert a generic resource to binary.  */
+
+static struct bindata *
+res_to_bin_generic (length, data)
+     unsigned long length;
+     const unsigned char *data;
+{
+  struct bindata *d;
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+  d->length = length;
+  d->data = (unsigned char *) data;
+
+  d->next = NULL;
+
+  return d;
+}
diff --git a/binutils/rescoff.c b/binutils/rescoff.c
index 65df9bf..0f83e54 100644
--- a/binutils/rescoff.c
+++ b/binutils/rescoff.c
@@ -1,4 +1,4 @@
-/* resrc.c -- read and write Windows rc files.
+/* rescoff.c -- read and write resources in Windows COFF files.
    Copyright 1997 Free Software Foundation, Inc.
    Written by Ian Lance Taylor, Cygnus Support.
 
@@ -27,6 +27,8 @@
 #include "libiberty.h"
 #include "windres.h"
 
+#include <assert.h>
+
 /* In order to use the address of a resource data entry, we need to
    get the image base of the file.  Right now we extract it from
    internal BFD information.  FIXME.  */
@@ -95,16 +97,18 @@ struct extern_res_data
 
 /* Macros to swap in values.  */
 
-#define get_16(fi, s) ((fi)->big_endian ? bfd_getb16 (s) : bfd_getl16 (s))
-#define get_32(fi, s) ((fi)->big_endian ? bfd_getb32 (s) : bfd_getl32 (s))
+#define getfi_16(fi, s) ((fi)->big_endian ? bfd_getb16 (s) : bfd_getl16 (s))
+#define getfi_32(fi, s) ((fi)->big_endian ? bfd_getb32 (s) : bfd_getl32 (s))
 
 /* Local functions.  */
 
 static void overrun PARAMS ((const struct coff_file_info *, const char *));
 static struct res_directory *read_coff_res_dir
-  PARAMS ((const bfd_byte *, const struct coff_file_info *));
+  PARAMS ((const bfd_byte *, const struct coff_file_info *,
+	   const struct res_id *, int));
 static struct res_resource *read_coff_data_entry
-  PARAMS ((const bfd_byte *, const struct coff_file_info *));
+  PARAMS ((const bfd_byte *, const struct coff_file_info *,
+	   const struct res_id *));
 
 /* Read the resources in a COFF file.  */
 
@@ -141,7 +145,7 @@ read_coff_rsrc (filename, target)
     }
 
   size = bfd_section_size (abfd, sec);
-  data = (bfd_byte *) xmalloc (size);
+  data = (bfd_byte *) res_alloc (size);
 
   if (! bfd_get_section_contents (abfd, sec, data, 0, size))
     bfd_fatal ("can't read resource section");
@@ -160,7 +164,7 @@ read_coff_rsrc (filename, target)
      it.  If we ever want to free up the resource information we read,
      this will have to be cleaned up.  */
 
-  return read_coff_res_dir (data, &finfo);
+  return read_coff_res_dir (data, &finfo, (const struct res_id *) NULL, 0);
 }
 
 /* Give an error if we are out of bounds.  */
@@ -176,9 +180,11 @@ overrun (finfo, msg)
 /* Read a resource directory.  */
 
 static struct res_directory *
-read_coff_res_dir (data, finfo)
+read_coff_res_dir (data, finfo, type, level)
      const bfd_byte *data;
      const struct coff_file_info *finfo;
+     const struct res_id *type;
+     int level;
 {
   const struct extern_res_directory *erd;
   struct res_directory *rd;
@@ -191,15 +197,15 @@ read_coff_res_dir (data, finfo)
 
   erd = (const struct extern_res_directory *) data;
 
-  rd = (struct res_directory *) xmalloc (sizeof *rd);
-  rd->characteristics = get_32 (finfo, erd->characteristics);
-  rd->time = get_32 (finfo, erd->time);
-  rd->major = get_16 (finfo, erd->major);
-  rd->minor = get_16 (finfo, erd->minor);
+  rd = (struct res_directory *) res_alloc (sizeof *rd);
+  rd->characteristics = getfi_32 (finfo, erd->characteristics);
+  rd->time = getfi_32 (finfo, erd->time);
+  rd->major = getfi_16 (finfo, erd->major);
+  rd->minor = getfi_16 (finfo, erd->minor);
   rd->entries = NULL;
 
-  name_count = get_16 (finfo, erd->name_count);
-  id_count = get_16 (finfo, erd->id_count);
+  name_count = getfi_16 (finfo, erd->name_count);
+  id_count = getfi_16 (finfo, erd->id_count);
 
   pp = &rd->entries;
 
@@ -217,8 +223,8 @@ read_coff_res_dir (data, finfo)
       if ((const bfd_byte *) ere >= finfo->data_end)
 	overrun (finfo, "named directory entry");
 
-      name = get_32 (finfo, ere->name);
-      rva = get_32 (finfo, ere->rva);
+      name = getfi_32 (finfo, ere->name);
+      rva = getfi_32 (finfo, ere->rva);
 
       /* For some reason the high bit in NAME is set.  */
       name &=~ 0x80000000;
@@ -228,15 +234,17 @@ read_coff_res_dir (data, finfo)
 
       ers = finfo->data + name;
 
-      re = (struct res_entry *) xmalloc (sizeof *re);
+      re = (struct res_entry *) res_alloc (sizeof *re);
       re->next = NULL;
       re->id.named = 1;
-      length = get_16 (finfo, ers);
+      length = getfi_16 (finfo, ers);
       re->id.u.n.length = length;
-      re->id.u.n.name = ((unsigned short *)
-			 xmalloc (length * sizeof (unsigned short)));
+      re->id.u.n.name = (unichar *) res_alloc (length * sizeof (unichar));
       for (j = 0; j < length; j++)
-	re->id.u.n.name[j] = get_16 (finfo, ers + j * 2 + 2);
+	re->id.u.n.name[j] = getfi_16 (finfo, ers + j * 2 + 2);
+
+      if (level == 0)
+	type = &re->id;
 
       if ((rva & 0x80000000) != 0)
 	{
@@ -244,14 +252,15 @@ read_coff_res_dir (data, finfo)
 	  if (rva >= finfo->data_end - finfo->data)
 	    overrun (finfo, "named subdirectory");
 	  re->subdir = 1;
-	  re->u.dir = read_coff_res_dir (finfo->data + rva, finfo);
+	  re->u.dir = read_coff_res_dir (finfo->data + rva, finfo, type,
+					 level + 1);
 	}
       else
 	{
 	  if (rva >= finfo->data_end - finfo->data)
 	    overrun (finfo, "named resource");
 	  re->subdir = 0;
-	  re->u.res = read_coff_data_entry (finfo->data + rva, finfo);
+	  re->u.res = read_coff_data_entry (finfo->data + rva, finfo, type);
 	}
 
       *pp = re;
@@ -266,28 +275,32 @@ read_coff_res_dir (data, finfo)
       if ((const bfd_byte *) ere >= finfo->data_end)
 	overrun (finfo, "ID directory entry");
 
-      name = get_32 (finfo, ere->name);
-      rva = get_32 (finfo, ere->rva);
+      name = getfi_32 (finfo, ere->name);
+      rva = getfi_32 (finfo, ere->rva);
 
-      re = (struct res_entry *) xmalloc (sizeof *re);
+      re = (struct res_entry *) res_alloc (sizeof *re);
       re->next = NULL;
       re->id.named = 0;
       re->id.u.id = name;
 
+      if (level == 0)
+	type = &re->id;
+
       if ((rva & 0x80000000) != 0)
 	{
 	  rva &=~ 0x80000000;
 	  if (rva >= finfo->data_end - finfo->data)
 	    overrun (finfo, "ID subdirectory");
 	  re->subdir = 1;
-	  re->u.dir = read_coff_res_dir (finfo->data + rva, finfo);
+	  re->u.dir = read_coff_res_dir (finfo->data + rva, finfo, type,
+					 level + 1);
 	}
       else
 	{
 	  if (rva >= finfo->data_end - finfo->data)
 	    overrun (finfo, "ID resource");
 	  re->subdir = 0;
-	  re->u.res = read_coff_data_entry (finfo->data + rva, finfo);
+	  re->u.res = read_coff_data_entry (finfo->data + rva, finfo, type);
 	}
 
       *pp = re;
@@ -300,43 +313,459 @@ read_coff_res_dir (data, finfo)
 /* Read a resource data entry.  */
 
 static struct res_resource *
-read_coff_data_entry (data, finfo)
+read_coff_data_entry (data, finfo, type)
      const bfd_byte *data;
      const struct coff_file_info *finfo;
+     const struct res_id *type;
 {
   const struct extern_res_data *erd;
   struct res_resource *r;
   unsigned long size, rva;
   const bfd_byte *resdata;
 
+  if (type == NULL)
+    fatal ("resource type unknown");
+
   if (finfo->data_end - data < sizeof (struct extern_res_data))
     overrun (finfo, "data entry");
 
   erd = (const struct extern_res_data *) data;
 
-  r = (struct res_resource *) xmalloc (sizeof *r);
-  memset (&r->res_info, 0, sizeof (struct res_res_info));
-  r->coff_info.codepage = get_32 (finfo, erd->codepage);
-  r->coff_info.reserved = get_32 (finfo, erd->reserved);
-
-  size = get_32 (finfo, erd->size);
-  rva = get_32 (finfo, erd->rva);
+  size = getfi_32 (finfo, erd->size);
+  rva = getfi_32 (finfo, erd->rva);
   if (rva < finfo->secaddr
       || rva - finfo->secaddr >= finfo->data_end - finfo->data)
     overrun (finfo, "resource data");
 
   resdata = finfo->data + (rva - finfo->secaddr);
 
-  r->type = RES_TYPE_USERDATA;
-  r->u.userdata = ((struct rcdata_data *)
-		   xmalloc (sizeof (struct rcdata_data)));
-  r->u.userdata->first = ((struct rcdata_item *)
-			  xmalloc (sizeof (struct rcdata_item)));
-  r->u.userdata->last = r->u.userdata->first;
-  r->u.userdata->first->next = NULL;
-  r->u.userdata->first->type = RCDATA_BUFFER;
-  r->u.userdata->first->u.buffer.length = size;
-  r->u.userdata->first->u.buffer.data = (unsigned char *) resdata;
+  if (size > finfo->data_end - resdata)
+    overrun (finfo, "resource data size");
+
+  r = bin_to_res (*type, resdata, size, finfo->big_endian);
+
+  memset (&r->res_info, 0, sizeof (struct res_res_info));
+  r->coff_info.codepage = getfi_32 (finfo, erd->codepage);
+  r->coff_info.reserved = getfi_32 (finfo, erd->reserved);
 
   return r;
 }
+
+/* This structure is used to build a list of bindata structures.  */
+
+struct bindata_build
+{
+  /* The data.  */
+  struct bindata *d;
+  /* The last structure we have added to the list.  */
+  struct bindata *last;
+  /* The size of the list as a whole.  */
+  unsigned long length;
+};
+
+/* This structure keeps track of information as we build the directory
+   tree.  */
+
+struct coff_write_info
+{
+  /* These fields are based on the BFD.  */
+  /* The BFD itself.  */
+  bfd *abfd;
+  /* Non-zero if the file is big endian.  */
+  int big_endian;
+  /* Pointer to section symbol used to build RVA relocs.  */
+  asymbol **sympp;
+
+  /* These fields are computed initially, and then not changed.  */
+  /* Length of directory tables and entries.  */
+  unsigned long dirsize;
+  /* Length of directory entry strings.  */
+  unsigned long dirstrsize;
+  /* Length of resource data entries.  */
+  unsigned long dataentsize;
+
+  /* These fields are updated as we add data.  */
+  /* Directory tables and entries.  */
+  struct bindata_build dirs;
+  /* Directory entry strings.  */
+  struct bindata_build dirstrs;
+  /* Resource data entries.  */
+  struct bindata_build dataents;
+  /* Actual resource data.  */
+  struct bindata_build resources;
+  /* Relocations.  */
+  arelent **relocs;
+  /* Number of relocations.  */
+  unsigned int reloc_count;
+};
+
+/* Macros to swap out values.  */
+
+#define putcwi_16(cwi, v, s) \
+  ((cwi->big_endian) ? bfd_putb16 ((v), (s)) : bfd_putl16 ((v), (s)))
+#define putcwi_32(cwi, v, s) \
+  ((cwi->big_endian) ? bfd_putb32 ((v), (s)) : bfd_putl32 ((v), (s)))
+
+static void coff_bin_sizes
+  PARAMS ((const struct res_directory *, struct coff_write_info *));
+static unsigned char *coff_alloc PARAMS ((struct bindata_build *, size_t));
+static void coff_to_bin
+  PARAMS ((const struct res_directory *, struct coff_write_info *));
+static void coff_res_to_bin
+  PARAMS ((const struct res_resource *, struct coff_write_info *));
+
+/* Write resources to a COFF file.  RESOURCES should already be
+   sorted.
+
+   Right now we always create a new file.  Someday we should also
+   offer the ability to merge resources into an existing file.  This
+   would require doing the basic work of objcopy, just modifying or
+   adding the .rsrc section.  */
+
+
+void
+write_coff_file (filename, target, resources)
+     const char *filename;
+     const char *target;
+     const struct res_directory *resources;
+{
+  bfd *abfd;
+  asection *sec;
+  struct coff_write_info cwi;
+  struct bindata *d;
+  unsigned long length, offset;
+
+  abfd = bfd_openw (filename, target);
+  if (abfd == NULL)
+    bfd_fatal (filename);
+
+  if (! bfd_set_format (abfd, bfd_object))
+    bfd_fatal ("bfd_set_format");
+
+  /* FIXME: This is obviously i386 specific.  */
+  if (! bfd_set_arch_mach (abfd, bfd_arch_i386, 0))
+    bfd_fatal ("bfd_set_arch_mach");
+
+  if (! bfd_set_file_flags (abfd, HAS_SYMS | HAS_RELOC))
+    bfd_fatal ("bfd_set_file_flags");
+
+  sec = bfd_make_section (abfd, ".rsrc");
+  if (sec == NULL)
+    bfd_fatal ("bfd_make_section");
+
+  if (! bfd_set_section_flags (abfd, sec,
+			       (SEC_HAS_CONTENTS | SEC_ALLOC
+				| SEC_LOAD | SEC_DATA)))
+    bfd_fatal ("bfd_set_section_flags");
+
+  if (! bfd_set_symtab (abfd, sec->symbol_ptr_ptr, 1))
+    bfd_fatal ("bfd_set_symtab");
+
+  /* Requiring this is probably a bug in BFD.  */
+  sec->output_section = sec;
+
+  /* The order of data in the .rsrc section is
+       resource directory tables and entries
+       resource directory strings
+       resource data entries
+       actual resource data
+
+     We build these different types of data in different lists.  */
+
+  cwi.abfd = abfd;
+  cwi.big_endian = bfd_big_endian (abfd);
+  cwi.sympp = sec->symbol_ptr_ptr;
+  cwi.dirsize = 0;
+  cwi.dirstrsize = 0;
+  cwi.dataentsize = 0;
+  cwi.dirs.d = NULL;
+  cwi.dirs.last = NULL;
+  cwi.dirs.length = 0;
+  cwi.dirstrs.d = NULL;
+  cwi.dirstrs.last = NULL;
+  cwi.dirstrs.length = 0;
+  cwi.dataents.d = NULL;
+  cwi.dataents.last = NULL;
+  cwi.dataents.length = 0;
+  cwi.resources.d = NULL;
+  cwi.resources.last = NULL;
+  cwi.resources.length = 0;
+  cwi.relocs = NULL;
+  cwi.reloc_count = 0;
+
+  /* Work out the sizes of the resource directory entries, so that we
+     know the various offsets we will need.  */
+  coff_bin_sizes (resources, &cwi);
+
+  /* Force the directory strings to be 32 bit aligned.  Every other
+     structure is 32 bit aligned anyhow.  */
+  cwi.dirstrsize = (cwi.dirstrsize + 3) &~ 3;
+
+  /* Actually convert the resources to binary.  */
+  coff_to_bin (resources, &cwi);
+
+  /* Add another 2 bytes to the directory strings if needed for
+     alignment.  */
+  if ((cwi.dirstrs.length & 3) != 0)
+    {
+      unsigned char *ex;
+
+      ex = coff_alloc (&cwi.dirstrs, 2);
+      ex[0] = 0;
+      ex[1] = 0;
+    }
+
+  /* Make sure that the data we built came out to the same size as we
+     calculated initially.  */
+  assert (cwi.dirs.length == cwi.dirsize);
+  assert (cwi.dirstrs.length == cwi.dirstrsize);
+  assert (cwi.dataents.length == cwi.dataentsize);
+
+  length = (cwi.dirsize
+	    + cwi.dirstrsize
+	    + cwi.dataentsize
+	    + cwi.resources.length);
+
+  if (! bfd_set_section_size (abfd, sec, length))
+    bfd_fatal ("bfd_set_section_size");
+
+  bfd_set_reloc (abfd, sec, cwi.relocs, cwi.reloc_count);
+
+  /* We allocated the relocs array using malloc.  */
+  free (cwi.relocs);
+
+  offset = 0;
+  for (d = cwi.dirs.d; d != NULL; d = d->next)
+    {
+      if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
+	bfd_fatal ("bfd_set_section_contents");
+      offset += d->length;
+    }
+  for (d = cwi.dirstrs.d; d != NULL; d = d->next)
+    {
+      if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
+	bfd_fatal ("bfd_set_section_contents");
+      offset += d->length;
+    }
+  for (d = cwi.dataents.d; d != NULL; d = d->next)
+    {
+      if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
+	bfd_fatal ("bfd_set_section_contents");
+      offset += d->length;
+    }
+  for (d = cwi.resources.d; d != NULL; d = d->next)
+    {
+      if (! bfd_set_section_contents (abfd, sec, d->data, offset, d->length))
+	bfd_fatal ("bfd_set_section_contents");
+      offset += d->length;
+    }
+
+  assert (offset == length);
+
+  if (! bfd_close (abfd))
+    bfd_fatal ("bfd_close");
+}
+
+/* Work out the sizes of the various fixed size resource directory
+   entries.  This updates fields in CWI.  */
+
+static void
+coff_bin_sizes (resdir, cwi)
+     const struct res_directory *resdir;
+     struct coff_write_info *cwi;
+{
+  const struct res_entry *re;
+
+  cwi->dirsize += sizeof (struct extern_res_directory);
+
+  for (re = resdir->entries; re != NULL; re = re->next)
+    {
+      cwi->dirsize += sizeof (struct extern_res_entry);
+
+      if (re->id.named)
+	cwi->dirstrsize += re->id.u.n.length * 2 + 2;
+
+      if (re->subdir)
+	coff_bin_sizes (re->u.dir, cwi);
+      else
+	cwi->dataentsize += sizeof (struct extern_res_data);
+    }
+}
+
+/* Allocate data for a particular list.  */
+
+static unsigned char *
+coff_alloc (bb, size)
+     struct bindata_build *bb;
+     size_t size;
+{
+  struct bindata *d;
+
+  d = (struct bindata *) reswr_alloc (sizeof *d);
+
+  d->next = NULL;
+  d->data = (unsigned char *) reswr_alloc (size);
+  d->length = size;
+
+  if (bb->d == NULL)
+    bb->d = d;
+  else
+    bb->last->next = d;
+  bb->last = d;
+  bb->length += size;
+
+  return d->data;
+}
+
+/* Convert the resource directory RESDIR to binary.  */
+
+static void
+coff_to_bin (resdir, cwi)
+     const struct res_directory *resdir;
+     struct coff_write_info *cwi;
+{
+  struct extern_res_directory *erd;
+  int ci, cn;
+  const struct res_entry *e;
+  struct extern_res_entry *ere;
+
+  /* Write out the directory table.  */
+
+  erd = ((struct extern_res_directory *)
+	 coff_alloc (&cwi->dirs, sizeof (*erd)));
+
+  putcwi_32 (cwi, resdir->characteristics, erd->characteristics);
+  putcwi_32 (cwi, resdir->time, erd->time);
+  putcwi_16 (cwi, resdir->major, erd->major);
+  putcwi_16 (cwi, resdir->minor, erd->minor);
+
+  ci = 0;
+  cn = 0;
+  for (e = resdir->entries; e != NULL; e = e->next)
+    {
+      if (e->id.named)
+	++cn;
+      else
+	++ci;
+    }
+
+  putcwi_16 (cwi, cn, erd->name_count);
+  putcwi_16 (cwi, ci, erd->id_count);
+
+  /* Write out the data entries.  Note that we allocate space for all
+     the entries before writing them out.  That permits a recursive
+     call to work correctly when writing out subdirectories.  */
+
+  ere = ((struct extern_res_entry *)
+	 coff_alloc (&cwi->dirs, (ci + cn) * sizeof (*ere)));
+  for (e = resdir->entries; e != NULL; e = e->next, ere++)
+    {
+      if (! e->id.named)
+	putcwi_32 (cwi, e->id.u.id, ere->name);
+      else
+	{
+	  unsigned char *str;
+	  int i;
+
+	  /* For some reason existing files seem to have the high bit
+             set on the address of the name, although that is not
+             documented.  */
+	  putcwi_32 (cwi,
+		     0x80000000 | (cwi->dirsize + cwi->dirstrs.length),
+		     ere->name);
+
+	  str = coff_alloc (&cwi->dirstrs, e->id.u.n.length * 2 + 2);
+	  putcwi_16 (cwi, e->id.u.n.length, str);
+	  for (i = 0; i < e->id.u.n.length; i++)
+	    putcwi_16 (cwi, e->id.u.n.name[i], str + i * 2 + 2);
+	}
+
+      if (e->subdir)
+	{
+	  putcwi_32 (cwi, 0x80000000 | cwi->dirs.length, ere->rva);
+	  coff_to_bin (e->u.dir, cwi);
+	}
+      else
+	{
+	  putcwi_32 (cwi,
+		     cwi->dirsize + cwi->dirstrsize + cwi->dataents.length,
+		     ere->rva);
+
+	  coff_res_to_bin (e->u.res, cwi);
+	}
+    }
+}
+
+/* Convert the resource RES to binary.  */
+
+static void
+coff_res_to_bin (res, cwi)
+     const struct res_resource *res;
+     struct coff_write_info *cwi;
+{
+  arelent *r;
+  struct extern_res_data *erd;
+  struct bindata *d;
+  unsigned long length;
+
+  /* For some reason, although every other address is a section
+     offset, the address of the resource data itself is an RVA.  That
+     means that we need to generate a relocation for it.  We allocate
+     the relocs array using malloc so that we can use realloc.  FIXME:
+     This relocation handling is correct for the i386, but probably
+     not for any other target.  */
+
+  r = (arelent *) reswr_alloc (sizeof (arelent));
+  r->sym_ptr_ptr = cwi->sympp;
+  r->address = cwi->dirsize + cwi->dirstrsize + cwi->dataents.length;
+  r->addend = 0;
+  r->howto = bfd_reloc_type_lookup (cwi->abfd, BFD_RELOC_RVA);
+  if (r->howto == NULL)
+    bfd_fatal ("can't get BFD_RELOC_RVA relocation type");
+
+  cwi->relocs = xrealloc (cwi->relocs,
+			  (cwi->reloc_count + 2) * sizeof (arelent *));
+  cwi->relocs[cwi->reloc_count] = r;
+  cwi->relocs[cwi->reloc_count + 1] = NULL;
+  ++cwi->reloc_count;
+
+  erd = (struct extern_res_data *) coff_alloc (&cwi->dataents, sizeof (*erd));
+
+  putcwi_32 (cwi,
+	     (cwi->dirsize
+	      + cwi->dirstrsize
+	      + cwi->dataentsize
+	      + cwi->resources.length),
+	     erd->rva);
+  putcwi_32 (cwi, res->coff_info.codepage, erd->codepage);
+  putcwi_32 (cwi, res->coff_info.reserved, erd->reserved);
+
+  d = res_to_bin (res, cwi->big_endian);
+
+  if (cwi->resources.d == NULL)
+    cwi->resources.d = d;
+  else
+    cwi->resources.last->next = d;
+
+  length = 0;
+  for (; d->next != NULL; d = d->next)
+    length += d->length;
+  length += d->length;
+  cwi->resources.last = d;
+  cwi->resources.length += length;
+
+  putcwi_32 (cwi, length, erd->size);
+
+  /* Force the next resource to have 32 bit alignment.  */
+
+  if ((length & 3) != 0)
+    {
+      int add;
+      unsigned char *ex;
+
+      add = 4 - (length & 3);
+
+      ex = coff_alloc (&cwi->resources, add);
+      memset (ex, 0, add);
+    }
+}
diff --git a/binutils/resrc.c b/binutils/resrc.c
index fb340fa..60cf4ed 100644
--- a/binutils/resrc.c
+++ b/binutils/resrc.c
@@ -143,6 +143,7 @@ read_rc_file (filename, preprocessor, preprocargs, language)
   cpp_pipe = popen (cmd, FOPEN_RT);
   if (cpp_pipe == NULL)
     fatal ("can't popen `%s': %s", cmd, strerror (errno));
+  free (cmd);
 
   xatexit (close_pipe);
 
@@ -301,7 +302,7 @@ define_bitmap (id, resinfo, filename)
     fatal ("stat failed on bitmap file `%s': %s", real_filename,
 	   strerror (errno));
 
-  data = (unsigned char *) xmalloc (s.st_size - BITMAP_SKIP);
+  data = (unsigned char *) res_alloc (s.st_size - BITMAP_SKIP);
 
   for (i = 0; i < BITMAP_SKIP; i++)
     getc (e);
@@ -386,11 +387,11 @@ define_cursor (id, resinfo, filename)
 	fatal ("%s: fseek to %lu failed: %s", real_filename,
 	       icondirs[i].offset, strerror (errno));
 
-      data = (unsigned char *) xmalloc (icondirs[i].bytes);
+      data = (unsigned char *) res_alloc (icondirs[i].bytes);
 
       get_data (e, data, icondirs[i].bytes, real_filename);
 
-      c = (struct cursor *) xmalloc (sizeof *c);
+      c = (struct cursor *) res_alloc (sizeof *c);
       c->xhotspot = icondirs[i].u.cursor.xhotspot;
       c->yhotspot = icondirs[i].u.cursor.yhotspot;
       c->length = icondirs[i].bytes;
@@ -419,21 +420,24 @@ define_cursor (id, resinfo, filename)
     {
       struct group_cursor *cg;
 
-      /* These manipulations of icondirs into cg are copied from rcl.  */
-
-      cg = (struct group_cursor *) xmalloc (sizeof *cg);
+      cg = (struct group_cursor *) res_alloc (sizeof *cg);
       cg->next = NULL;
       cg->width = icondirs[i].width;
       cg->height = 2 * icondirs[i].height;
+
+      /* FIXME: What should these be set to?  */
       cg->planes = 1;
-      cg->bits = 4;
-      cg->bytes = icondirs[i].bytes + 8;
+      cg->bits = 1;
+
+      cg->bytes = icondirs[i].bytes + 4;
       cg->index = first_cursor + i + 1;
 
       *pp = cg;
       pp = &(*pp)->next;
     }
 
+  free (icondirs);
+
   r = define_standard_resource (&resources, RT_GROUP_CURSOR, id,
 				resinfo->language, 0);
   r->type = RES_TYPE_GROUP_CURSOR;
@@ -452,7 +456,7 @@ define_dialog (id, resinfo, dialog)
   struct dialog *copy;
   struct res_resource *r;
 
-  copy = (struct dialog *) xmalloc (sizeof *copy);
+  copy = (struct dialog *) res_alloc (sizeof *copy);
   *copy = *dialog;
 
   r = define_standard_resource (&resources, RT_DIALOG, id,
@@ -467,7 +471,7 @@ define_dialog (id, resinfo, dialog)
 
 struct dialog_control *
 define_control (text, id, x, y, width, height, class, style, exstyle)
-     char *text;
+     const char *text;
      unsigned long id;
      unsigned long x;
      unsigned long y;
@@ -479,7 +483,7 @@ define_control (text, id, x, y, width, height, class, style, exstyle)
 {
   struct dialog_control *n;
 
-  n = (struct dialog_control *) xmalloc (sizeof *n);
+  n = (struct dialog_control *) res_alloc (sizeof *n);
   n->next = NULL;
   n->id = id;
   n->style = style;
@@ -497,7 +501,6 @@ define_control (text, id, x, y, width, height, class, style, exstyle)
       n->text.named = 0;
       n->text.u.id = 0;
     }
-  free (text);
   n->data = NULL;
   n->help = 0;
 
@@ -517,8 +520,10 @@ define_font (id, resinfo, filename)
   struct stat s;
   unsigned char *data;
   struct res_resource *r;
-  struct fontdir *fd;
   long offset;
+  long fontdatalength;
+  unsigned char *fontdata;
+  struct fontdir *fd;
   const char *device, *face;
   struct fontdir **pp;
 
@@ -528,7 +533,7 @@ define_font (id, resinfo, filename)
     fatal ("stat failed on bitmap file `%s': %s", real_filename,
 	   strerror (errno));
 
-  data = (unsigned char *) xmalloc (s.st_size);
+  data = (unsigned char *) res_alloc (s.st_size);
 
   get_data (e, data, s.st_size, real_filename);
 
@@ -568,15 +573,17 @@ define_font (id, resinfo, filename)
 
   ++fonts;
 
-  fd = (struct fontdir *) xmalloc (sizeof *fd);
+  fontdatalength = 58 + strlen (device) + strlen (face);
+  fontdata = (unsigned char *) res_alloc (fontdatalength);
+  memcpy (fontdata, data, 56);
+  strcpy ((char *) fontdata + 56, device);
+  strcpy ((char *) fontdata + 57 + strlen (device), face);
+
+  fd = (struct fontdir *) res_alloc (sizeof *fd);
   fd->next = NULL;
   fd->index = fonts;
-  fd->length = 58 + strlen (device) + strlen (face);
-  fd->data = (unsigned char *) xmalloc (fd->length);
-
-  memcpy (fd->data, data, 56);
-  strcpy ((char *) fd->data + 56, device);
-  strcpy ((char *) fd->data + 57 + strlen (device), face);
+  fd->length = fontdatalength;
+  fd->data = fontdata;
 
   for (pp = &fontdirs; *pp != NULL; pp = &(*pp)->next)
     ;
@@ -670,7 +677,7 @@ define_icon (id, resinfo, filename)
 	fatal ("%s: fseek to %lu failed: %s", real_filename,
 	       icondirs[i].offset, strerror (errno));
 
-      data = (unsigned char *) xmalloc (icondirs[i].bytes);
+      data = (unsigned char *) res_alloc (icondirs[i].bytes);
 
       get_data (e, data, icondirs[i].bytes, real_filename);
 
@@ -698,16 +705,21 @@ define_icon (id, resinfo, filename)
     {
       struct group_icon *cg;
 
-      /* FIXME: rcl sets planes and bits based on colors, rather than
-         just copying the values from the file.  */
+      /* For some reason, at least in some files the planes and bits
+         are zero.  We instead set them from the color.  This is
+         copied from rcl.  */
 
-      cg = (struct group_icon *) xmalloc (sizeof *cg);
+      cg = (struct group_icon *) res_alloc (sizeof *cg);
       cg->next = NULL;
       cg->width = icondirs[i].width;
       cg->height = icondirs[i].height;
       cg->colors = icondirs[i].colorcount;
-      cg->planes = icondirs[i].u.icon.planes;
-      cg->bits = icondirs[i].u.icon.bits;
+
+      cg->planes = 1;
+      cg->bits = 0;
+      while ((1 << cg->bits) < cg->colors)
+	++cg->bits;
+
       cg->bytes = icondirs[i].bytes;
       cg->index = first_icon + i + 1;
 
@@ -715,6 +727,8 @@ define_icon (id, resinfo, filename)
       pp = &(*pp)->next;
     }
 
+  free (icondirs);
+
   r = define_standard_resource (&resources, RT_GROUP_ICON, id,
 				resinfo->language, 0);
   r->type = RES_TYPE_GROUP_ICON;
@@ -730,11 +744,16 @@ define_menu (id, resinfo, menuitems)
      const struct res_res_info *resinfo;
      struct menuitem *menuitems;
 {
+  struct menu *m;
   struct res_resource *r;
 
+  m = (struct menu *) res_alloc (sizeof *m);
+  m->items = menuitems;
+  m->help = 0;
+
   r = define_standard_resource (&resources, RT_MENU, id, resinfo->language, 0);
   r->type = RES_TYPE_MENU;
-  r->u.menu = menuitems;
+  r->u.menu = m;
   r->res_info = *resinfo;
 }
 
@@ -743,7 +762,7 @@ define_menu (id, resinfo, menuitems)
 
 struct menuitem *
 define_menuitem (text, menuid, type, state, help, menuitems)
-     char *text;
+     const char *text;
      int menuid;
      unsigned long type;
      unsigned long state;
@@ -752,12 +771,15 @@ define_menuitem (text, menuid, type, state, help, menuitems)
 {
   struct menuitem *mi;
 
-  mi = (struct menuitem *) xmalloc (sizeof *mi);
+  mi = (struct menuitem *) res_alloc (sizeof *mi);
   mi->next = NULL;
   mi->type = type;
   mi->state = state;
   mi->id = menuid;
-  mi->text = text;
+  if (text == NULL)
+    mi->text = NULL;
+  else
+    unicode_from_ascii ((int *) NULL, &mi->text, text);
   mi->help = help;
   mi->popup = menuitems;
   return mi;
@@ -784,7 +806,7 @@ define_messagetable (id, resinfo, filename)
     fatal ("stat failed on bitmap file `%s': %s", real_filename,
 	   strerror (errno));
 
-  data = (unsigned char *) xmalloc (s.st_size);
+  data = (unsigned char *) res_alloc (s.st_size);
 
   get_data (e, data, s.st_size, real_filename);
 
@@ -806,7 +828,7 @@ void
 define_rcdata (id, resinfo, data)
      struct res_id id;
      const struct res_res_info *resinfo;
-     struct rcdata_data *data;
+     struct rcdata_item *data;
 {
   struct res_resource *r;
 
@@ -817,61 +839,42 @@ define_rcdata (id, resinfo, data)
   r->res_info = *resinfo;
 }
 
-/* Add an rcdata_item to an rcdata resource.  */
-
-struct rcdata_data *
-append_rcdata_item (data, item)
-     struct rcdata_data *data;
-     struct rcdata_item *item;
-{
-  if (data == NULL)
-    {
-      data = (struct rcdata_data *) xmalloc (sizeof *data);
-      data->first = item;
-      data->last = item;
-    }
-  else
-    {
-      data->last->next = item;
-      data->last = item;
-    }
-
-  return data;
-}
-
-/* Add a string to an rcdata resource.  */
+/* Create an rcdata item holding a string.  */
 
-struct rcdata_data *
-append_rcdata_string (data, string)
-     struct rcdata_data *data;
-     char *string;
+struct rcdata_item *
+define_rcdata_string (string, len)
+     const char *string;
+     unsigned long len;
 {
   struct rcdata_item *ri;
+  char *s;
 
-  ri = (struct rcdata_item *) xmalloc (sizeof *ri);
+  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
   ri->next = NULL;
   ri->type = RCDATA_STRING;
-  ri->u.string = string;
+  ri->u.string.length = len;
+  s = (char *) res_alloc (len);
+  memcpy (s, string, len);
+  ri->u.string.s = s;
 
-  return append_rcdata_item (data, ri);
+  return ri;
 }
 
-/* Add a number to an rcdata resource.  */
+/* Create an rcdata item holding a number.  */
 
-struct rcdata_data *
-append_rcdata_number (data, val, dword)
-     struct rcdata_data *data;
+struct rcdata_item *
+define_rcdata_number (val, dword)
      unsigned long val;
      int dword;
 {
   struct rcdata_item *ri;
 
-  ri = (struct rcdata_item *) xmalloc (sizeof *ri);
+  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
   ri->next = NULL;
   ri->type = dword ? RCDATA_DWORD : RCDATA_WORD;
   ri->u.word = val;
 
-  return append_rcdata_item (data, ri);
+  return ri;
 }
 
 /* Define a stringtable resource.  This is called for each string
@@ -881,7 +884,7 @@ void
 define_stringtable (resinfo, stringid, string)
      const struct res_res_info *resinfo;
      unsigned long stringid;
-     char *string;
+     const char *string;
 {
   struct res_id id;
   struct res_resource *r;
@@ -897,7 +900,7 @@ define_stringtable (resinfo, stringid, string)
 
       r->type = RES_TYPE_STRINGTABLE;
       r->u.stringtable = ((struct stringtable *)
-			  xmalloc (sizeof (struct stringtable)));
+			  res_alloc (sizeof (struct stringtable)));
       for (i = 0; i < 16; i++)
 	{
 	  r->u.stringtable->strings[i].length = 0;
@@ -910,7 +913,6 @@ define_stringtable (resinfo, stringid, string)
   unicode_from_ascii (&r->u.stringtable->strings[stringid & 0xf].length,
 		      &r->u.stringtable->strings[stringid & 0xf].string,
 		      string);
-  free (string);
 }
 
 /* Define a user data resource where the data is in the rc file.  */
@@ -920,7 +922,7 @@ define_user_data (id, type, resinfo, data)
      struct res_id id;
      struct res_id type;
      const struct res_res_info *resinfo;
-     struct rcdata_data *data;
+     struct rcdata_item *data;
 {
   struct res_id ids[3];
   struct res_resource *r;
@@ -958,7 +960,7 @@ define_user_file (id, type, resinfo, filename)
     fatal ("stat failed on bitmap file `%s': %s", real_filename,
 	   strerror (errno));
 
-  data = (unsigned char *) xmalloc (s.st_size);
+  data = (unsigned char *) res_alloc (s.st_size);
 
   get_data (e, data, s.st_size, real_filename);
 
@@ -972,15 +974,12 @@ define_user_file (id, type, resinfo, filename)
 
   r = define_resource (&resources, 3, ids, 0);
   r->type = RES_TYPE_USERDATA;
-  r->u.userdata = ((struct rcdata_data *)
-		   xmalloc (sizeof (struct rcdata_data)));
-  r->u.userdata->first = ((struct rcdata_item *)
-			  xmalloc (sizeof (struct rcdata_item)));
-  r->u.userdata->last = r->u.userdata->first;
-  r->u.userdata->first->next = NULL;
-  r->u.userdata->first->type = RCDATA_BUFFER;
-  r->u.userdata->first->u.buffer.length = s.st_size;
-  r->u.userdata->first->u.buffer.data = data;
+  r->u.userdata = ((struct rcdata_item *)
+		   res_alloc (sizeof (struct rcdata_item)));
+  r->u.userdata->next = NULL;
+  r->u.userdata->type = RCDATA_BUFFER;
+  r->u.userdata->u.buffer.length = s.st_size;
+  r->u.userdata->u.buffer.data = data;
   r->res_info = *resinfo;
 }
 
@@ -998,7 +997,7 @@ define_versioninfo (id, language, fixedverinfo, verinfo)
   r = define_standard_resource (&resources, RT_VERSION, id, language, 0);
   r->type = RES_TYPE_VERSIONINFO;
   r->u.versioninfo = ((struct versioninfo *)
-		      xmalloc (sizeof (struct versioninfo)));
+		      res_alloc (sizeof (struct versioninfo)));
   r->u.versioninfo->fixed = fixedverinfo;
   r->u.versioninfo->var = verinfo;
   r->res_info.language = language;
@@ -1009,17 +1008,15 @@ define_versioninfo (id, language, fixedverinfo, verinfo)
 struct ver_info *
 append_ver_stringfileinfo (verinfo, language, strings)
      struct ver_info *verinfo;
-     char *language;
+     const char *language;
      struct ver_stringinfo *strings;
 {
   struct ver_info *vi, **pp;
 
-  vi = (struct ver_info *) xmalloc (sizeof *vi);
+  vi = (struct ver_info *) res_alloc (sizeof *vi);
   vi->next = NULL;
   vi->type = VERINFO_STRING;
-  unicode_from_ascii ((unsigned short *) NULL, &vi->u.string.language,
-		      language);
-  free (language);
+  unicode_from_ascii ((int *) NULL, &vi->u.string.language, language);
   vi->u.string.strings = strings;
 
   for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
@@ -1034,16 +1031,15 @@ append_ver_stringfileinfo (verinfo, language, strings)
 struct ver_info *
 append_ver_varfileinfo (verinfo, key, var)
      struct ver_info *verinfo;
-     char *key;
+     const char *key;
      struct ver_varinfo *var;
 {
   struct ver_info *vi, **pp;
 
-  vi = (struct ver_info *) xmalloc (sizeof *vi);
+  vi = (struct ver_info *) res_alloc (sizeof *vi);
   vi->next = NULL;
   vi->type = VERINFO_VAR;
-  unicode_from_ascii ((unsigned short *) NULL, &vi->u.var.key, key);
-  free (key);
+  unicode_from_ascii ((int *) NULL, &vi->u.var.key, key);
   vi->u.var.var = var;
 
   for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
@@ -1058,17 +1054,15 @@ append_ver_varfileinfo (verinfo, key, var)
 struct ver_stringinfo *
 append_verval (strings, key, value)
      struct ver_stringinfo *strings;
-     char *key;
-     char *value;
+     const char *key;
+     const char *value;
 {
   struct ver_stringinfo *vs, **pp;
 
-  vs = (struct ver_stringinfo *) xmalloc (sizeof *vs);
+  vs = (struct ver_stringinfo *) res_alloc (sizeof *vs);
   vs->next = NULL;
-  unicode_from_ascii ((unsigned short *) NULL, &vs->key, key);
-  free (key);
-  unicode_from_ascii ((unsigned short *) NULL, &vs->value, value);
-  free (value);
+  unicode_from_ascii ((int *) NULL, &vs->key, key);
+  unicode_from_ascii ((int *) NULL, &vs->value, value);
 
   for (pp = &strings; *pp != NULL; pp = &(*pp)->next)
     ;
@@ -1087,7 +1081,7 @@ append_vertrans (var, language, charset)
 {
   struct ver_varinfo *vv, **pp;
 
-  vv = (struct ver_varinfo *) xmalloc (sizeof *vv);
+  vv = (struct ver_varinfo *) res_alloc (sizeof *vv);
   vv->next = NULL;
   vv->language = language;
   vv->charset = charset;
@@ -1121,8 +1115,10 @@ static void write_rc_dialog_control
   PARAMS ((FILE *, const struct dialog_control *));
 static void write_rc_fontdir PARAMS ((FILE *, const struct fontdir *));
 static void write_rc_group_icon PARAMS ((FILE *, const struct group_icon *));
-static void write_rc_menu PARAMS ((FILE *, const struct menuitem *, int, int));
-static void write_rc_rcdata PARAMS ((FILE *, const struct rcdata_data *, int));
+static void write_rc_menu PARAMS ((FILE *, const struct menu *, int));
+static void write_rc_menuitems
+  PARAMS ((FILE *, const struct menuitem *, int, int));
+static void write_rc_rcdata PARAMS ((FILE *, const struct rcdata_item *, int));
 static void write_rc_stringtable
   PARAMS ((FILE *, const struct res_id *, const struct stringtable *));
 static void write_rc_versioninfo PARAMS ((FILE *, const struct versioninfo *));
@@ -1565,7 +1561,7 @@ write_rc_resource (e, type, name, res, language)
       break;
 
     case RES_TYPE_MENU:
-      write_rc_menu (e, res->u.menu, menuex, 0);
+      write_rc_menu (e, res->u.menu, menuex);
       break;
 
     case RES_TYPE_RCDATA:
@@ -1697,7 +1693,11 @@ write_rc_dialog (e, dialog)
       fprintf (e, "\n");
     }
   if (dialog->caption != NULL)
-    fprintf (e, "CAPTION \"%s\"\n", dialog->caption);
+    {
+      fprintf (e, "CAPTION \"");
+      unicode_print (e, dialog->caption, -1);
+      fprintf (e, "\"\n");
+    }
   if (dialog->menu.named || dialog->menu.u.id != 0)
     {
       fprintf (e, "MENU ");
@@ -1706,7 +1706,9 @@ write_rc_dialog (e, dialog)
     }
   if (dialog->font != NULL)
     {
-      fprintf (e, "FONT %d, \"%s\"", dialog->pointsize, dialog->font);
+      fprintf (e, "FONT %d, \"", dialog->pointsize);
+      unicode_print (e, dialog->font, -1);
+      fprintf (e, "\"");
       if (dialog->ex != NULL
 	  && (dialog->ex->weight != 0 || dialog->ex->italic != 0))
 	fprintf (e, ", %d, %d", dialog->ex->weight, dialog->ex->italic);
@@ -1863,7 +1865,20 @@ write_rc_group_icon (e, group_icon)
 /* Write out a menu resource.  */
 
 static void
-write_rc_menu (e, menuitems, menuex, ind)
+write_rc_menu (e, menu, menuex)
+     FILE *e;
+     const struct menu *menu;
+     int menuex;
+{
+  if (menu->help != 0)
+    fprintf (e, "// Help ID: %lu\n", menu->help);
+  write_rc_menuitems (e, menu->items, menuex, 0);
+}
+
+/* Write out menuitems.  */
+
+static void
+write_rc_menuitems (e, menuitems, menuex, ind)
      FILE *e;
      const struct menuitem *menuitems;
      int menuex;
@@ -1896,7 +1911,11 @@ write_rc_menu (e, menuitems, menuex, ind)
       if (mi->text == NULL)
 	fprintf (e, " \"\"");
       else
-	fprintf (e, " \"%s\"", mi->text);
+	{
+	  fprintf (e, " \"");
+	  unicode_print (e, mi->text, -1);
+	  fprintf (e, "\"");
+	}
 
       if (! menuex)
 	{
@@ -1937,7 +1956,7 @@ write_rc_menu (e, menuitems, menuex, ind)
       fprintf (e, "\n");
 
       if (mi->popup != NULL)
-	write_rc_menu (e, mi->popup, menuex, ind + 2);
+	write_rc_menuitems (e, mi->popup, menuex, ind + 2);
     }
 
   indent (e, ind);
@@ -1950,7 +1969,7 @@ write_rc_menu (e, menuitems, menuex, ind)
 static void
 write_rc_rcdata (e, rcdata, ind)
      FILE *e;
-     const struct rcdata_data *rcdata;
+     const struct rcdata_item *rcdata;
      int ind;
 {
   const struct rcdata_item *ri;
@@ -1958,7 +1977,7 @@ write_rc_rcdata (e, rcdata, ind)
   indent (e, ind);
   fprintf (e, "BEGIN\n");
 
-  for (ri = rcdata->first; ri != NULL; ri = ri->next)
+  for (ri = rcdata; ri != NULL; ri = ri->next)
     {
       if (ri->type == RCDATA_BUFFER && ri->u.buffer.length == 0)
 	continue;
@@ -1979,12 +1998,26 @@ write_rc_rcdata (e, rcdata, ind)
 	  break;
 
 	case RCDATA_STRING:
-	  fprintf (e, "\"%s\"", ri->u.string);
-	  break;
+	  {
+	    const char *s;
+	    unsigned long i;
+
+	    fprintf (e, "\"");
+	    s = ri->u.string.s;
+	    for (i = 0; i < ri->u.string.length; i++)
+	      {
+		if (isprint (*s))
+		  putc (*s, e);
+		else
+		  fprintf (e, "\\%03o", *s);
+	      }
+	    fprintf (e, "\"");
+	    break;
+	  }
 
 	case RCDATA_WSTRING:
 	  fprintf (e, "L\"");
-	  unicode_print (e, ri->u.wstring, -1);
+	  unicode_print (e, ri->u.wstring.w, ri->u.wstring.length);
 	  fprintf (e, "\"");
 	  break;
 
diff --git a/binutils/windres.c b/binutils/windres.c
index bd17aaf..3134b3d 100644
--- a/binutils/windres.c
+++ b/binutils/windres.c
@@ -39,6 +39,7 @@
 #include "getopt.h"
 #include "bucomm.h"
 #include "libiberty.h"
+#include "obstack.h"
 #include "windres.h"
 
 #include <assert.h>
@@ -127,9 +128,62 @@ static const struct option long_options[] =
 
 /* 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 *));
+
+/* 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);
+}
 
 /* Open a file using the include directory search list.  */
 
@@ -183,8 +237,8 @@ open_file_search (filename, mode, errmsg, real_filename)
 
 void
 unicode_from_ascii (length, unicode, ascii)
-     unsigned short *length;
-     unsigned short **unicode;
+     int *length;
+     unichar **unicode;
      const char *ascii;
 {
   int len;
@@ -194,13 +248,9 @@ unicode_from_ascii (length, unicode, ascii)
   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;
@@ -214,12 +264,12 @@ unicode_from_ascii (length, unicode, ascii)
 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;
@@ -228,7 +278,7 @@ unicode_print (e, unicode, length)
 
       ch = *unicode;
 
-      if (ch == 0)
+      if (ch == 0 && length < 0)
 	return;
 
       ++unicode;
@@ -264,7 +314,7 @@ res_id_cmp (a, b)
     }
   else
     {
-      unsigned short *as, *ase, *bs, *bse;
+      unichar *as, *ase, *bs, *bse;
 
       if (! b.named)
 	return -1;
@@ -368,7 +418,8 @@ define_resource (resources, cids, ids, dupok)
 
       if (*resources == NULL)
 	{
-	  *resources = (struct res_directory *) xmalloc (sizeof **resources);
+	  *resources = ((struct res_directory *)
+			res_alloc (sizeof **resources));
 	  (*resources)->characteristics = 0;
 	  (*resources)->time = 0;
 	  (*resources)->major = 0;
@@ -384,7 +435,7 @@ define_resource (resources, cids, ids, dupok)
 	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)
@@ -433,7 +484,8 @@ define_resource (resources, cids, ids, dupok)
       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));
@@ -462,6 +514,62 @@ define_standard_resource (resources, type, name, language, dupok)
   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;
+}
 
 /* Return whether the dialog resource DIALOG is a DIALOG or a
    DIALOGEX.  */
@@ -485,7 +593,14 @@ extended_dialog (dialog)
 /* 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;
@@ -507,7 +622,7 @@ extended_menu (menuitems)
 	return 1;
       if (mi->popup != NULL)
 	{
-	  if (extended_menu (mi->popup))
+	  if (extended_menuitems (mi->popup))
 	    return 1;
 	}
     }
@@ -685,6 +800,8 @@ main (argc, argv)
   bfd_init ();
   set_default_bfd_target ();
 
+  res_init ();
+
   input_filename = NULL;
   output_filename = NULL;
   input_format = RES_FORMAT_UNKNOWN;
@@ -843,8 +960,15 @@ main (argc, argv)
       break;
     }
 
+  /* 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:
@@ -879,12 +1003,3 @@ write_res_file (filename, 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");
-}