binutils/windres.c

   1 /* windres.c -- a program to manipulate Windows resources
   2    Copyright (C) 1997-2019 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4    Rewritten by Kai Tietz, Onevision.
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* This program can read and write Windows resources in various
  24    formats.  In particular, it can act like the rc resource compiler
  25    program, and it can act like the cvtres res to COFF conversion
  26    program.
  27
  28    It is based on information taken from the following sources:
  29
  30    * Microsoft documentation.
  31
  32    * The rcl program, written by Gunther Ebert
  33      <gunther.ebert@ixos-leipzig.de>.
  34
  35    * The res2coff program, written by Pedro A. Aranda <paag@tid.es>.  */
  36
  37 #include "sysdep.h"
  38 #include <assert.h>
  39 #include "bfd.h"
  40 #include "getopt.h"
  41 #include "bucomm.h"
  42 #include "libiberty.h"
  43 #include "safe-ctype.h"
  44 #include "obstack.h"
  45 #include "windres.h"
  46
  47 /* Used by resrc.c at least.  */
  48
  49 int verbose = 0;
  50
  51 int target_is_bigendian = 0;
  52 const char *def_target_arch;
  53
  54 static void set_endianness (bfd *, const char *);
  55
  56 /* An enumeration of format types.  */
  57
  58 enum res_format
  59 {
  60   /* Unknown format.  */
  61   RES_FORMAT_UNKNOWN,
  62   /* Textual RC file.  */
  63   RES_FORMAT_RC,
  64   /* Binary RES file.  */
  65   RES_FORMAT_RES,
  66   /* COFF file.  */
  67   RES_FORMAT_COFF
  68 };
  69
  70 /* A structure used to map between format types and strings.  */
  71
  72 struct format_map
  73 {
  74   const char *name;
  75   enum res_format format;
  76 };
  77
  78 /* A mapping between names and format types.  */
  79
  80 static const struct format_map format_names[] =
  81 {
  82   { "rc", RES_FORMAT_RC },
  83   { "res", RES_FORMAT_RES },
  84   { "coff", RES_FORMAT_COFF },
  85   { NULL, RES_FORMAT_UNKNOWN }
  86 };
  87
  88 /* A mapping from file extensions to format types.  */
  89
  90 static const struct format_map format_fileexts[] =
  91 {
  92   { "rc", RES_FORMAT_RC },
  93   { "res", RES_FORMAT_RES },
  94   { "exe", RES_FORMAT_COFF },
  95   { "obj", RES_FORMAT_COFF },
  96   { "o", RES_FORMAT_COFF },
  97   { NULL, RES_FORMAT_UNKNOWN }
  98 };
  99
 100 /* A list of include directories.  */
 101
 102 struct include_dir
 103 {
 104   struct include_dir *next;
 105   char *dir;
 106 };
 107
 108 static struct include_dir *include_dirs;
 109
 110 /* Static functions.  */
 111
 112 static void res_init (void);
 113 static int extended_menuitems (const rc_menuitem *);
 114 static enum res_format format_from_name (const char *, int);
 115 static enum res_format format_from_filename (const char *, int);
 116 static void usage (FILE *, int);
 117 static int cmp_res_entry (const void *, const void *);
 118 static rc_res_directory *sort_resources (rc_res_directory *);
 119 static void reswr_init (void);
 120 static const char * quot (const char *);
 121 \f
 122 static rc_uint_type target_get_8 (const void *, rc_uint_type);
 123 static void target_put_8 (void *, rc_uint_type);
 124 static rc_uint_type target_get_16 (const void *, rc_uint_type);
 125 static void target_put_16 (void *, rc_uint_type);
 126 static rc_uint_type target_get_32 (const void *, rc_uint_type);
 127 static void target_put_32 (void *, rc_uint_type);
 128
 129 \f
 130 /* When we are building a resource tree, we allocate everything onto
 131    an obstack, so that we can free it all at once if we want.  */
 132
 133 #define obstack_chunk_alloc xmalloc
 134 #define obstack_chunk_free free
 135
 136 /* The resource building obstack.  */
 137
 138 static struct obstack res_obstack;
 139
 140 /* Initialize the resource building obstack.  */
 141
 142 static void
 143 res_init (void)
 144 {
 145   obstack_init (&res_obstack);
 146 }
 147
 148 /* Allocate space on the resource building obstack.  */
 149
 150 void *
 151 res_alloc (rc_uint_type bytes)
 152 {
 153   return obstack_alloc (&res_obstack, (size_t) bytes);
 154 }
 155
 156 /* We also use an obstack to save memory used while writing out a set
 157    of resources.  */
 158
 159 static struct obstack reswr_obstack;
 160
 161 /* Initialize the resource writing obstack.  */
 162
 163 static void
 164 reswr_init (void)
 165 {
 166   obstack_init (&reswr_obstack);
 167 }
 168
 169 /* Allocate space on the resource writing obstack.  */
 170
 171 void *
 172 reswr_alloc (rc_uint_type bytes)
 173 {
 174   return obstack_alloc (&reswr_obstack, (size_t) bytes);
 175 }
 176 \f
 177 /* Open a file using the include directory search list.  */
 178
 179 FILE *
 180 open_file_search (const char *filename, const char *mode, const char *errmsg,
 181                   char **real_filename)
 182 {
 183   FILE *e;
 184   struct include_dir *d;
 185
 186   e = fopen (filename, mode);
 187   if (e != NULL)
 188     {
 189       *real_filename = xstrdup (filename);
 190       return e;
 191     }
 192
 193   if (errno == ENOENT)
 194     {
 195       for (d = include_dirs; d != NULL; d = d->next)
 196         {
 197           char *n;
 198
 199           n = (char *) xmalloc (strlen (d->dir) + strlen (filename) + 2);
 200           sprintf (n, "%s/%s", d->dir, filename);
 201           e = fopen (n, mode);
 202           if (e != NULL)
 203             {
 204               *real_filename = n;
 205               return e;
 206             }
 207           free (n);
 208
 209           if (errno != ENOENT)
 210             break;
 211         }
 212     }
 213
 214   fatal (_("can't open %s `%s': %s"), errmsg, filename, strerror (errno));
 215
 216   /* Return a value to avoid a compiler warning.  */
 217   return NULL;
 218 }
 219 \f
 220 /* Compare two resource ID's.  We consider name entries to come before
 221    numeric entries, because that is how they appear in the COFF .rsrc
 222    section.  */
 223
 224 int
 225 res_id_cmp (rc_res_id a, rc_res_id b)
 226 {
 227   if (! a.named)
 228     {
 229       if (b.named)
 230         return 1;
 231       if (a.u.id > b.u.id)
 232         return 1;
 233       else if (a.u.id < b.u.id)
 234         return -1;
 235       else
 236         return 0;
 237     }
 238   else
 239     {
 240       unichar *as, *ase, *bs, *bse;
 241
 242       if (! b.named)
 243         return -1;
 244
 245       as = a.u.n.name;
 246       ase = as + a.u.n.length;
 247       bs = b.u.n.name;
 248       bse = bs + b.u.n.length;
 249
 250       while (as < ase)
 251         {
 252           int i;
 253
 254           if (bs >= bse)
 255             return 1;
 256           i = (int) *as - (int) *bs;
 257           if (i != 0)
 258             return i;
 259           ++as;
 260           ++bs;
 261         }
 262
 263       if (bs < bse)
 264         return -1;
 265
 266       return 0;
 267     }
 268 }
 269
 270 /* Print a resource ID.  */
 271
 272 void
 273 res_id_print (FILE *stream, rc_res_id id, int quote)
 274 {
 275   if (! id.named)
 276     fprintf (stream, "%u", (int) id.u.id);
 277   else
 278     {
 279       if (quote)
 280         unicode_print_quoted (stream, id.u.n.name, id.u.n.length);
 281       else
 282       unicode_print (stream, id.u.n.name, id.u.n.length);
 283     }
 284 }
 285
 286 /* Print a list of resource ID's.  */
 287
 288 void
 289 res_ids_print (FILE *stream, int cids, const rc_res_id *ids)
 290 {
 291   int i;
 292
 293   for (i = 0; i < cids; i++)
 294     {
 295       res_id_print (stream, ids[i], 1);
 296       if (i + 1 < cids)
 297         fprintf (stream, ": ");
 298     }
 299 }
 300
 301 /* Convert an ASCII string to a resource ID.  */
 302
 303 void
 304 res_string_to_id (rc_res_id *res_id, const char *string)
 305 {
 306   res_id->named = 1;
 307   unicode_from_ascii (&res_id->u.n.length, &res_id->u.n.name, string);
 308 }
 309
 310 /* Convert an unicode string to a resource ID.  */
 311 void
 312 res_unistring_to_id (rc_res_id *res_id, const unichar *u)
 313 {
 314   res_id->named = 1;
 315   res_id->u.n.length = unichar_len (u);
 316   res_id->u.n.name = unichar_dup_uppercase (u);
 317 }
 318
 319 /* Define a resource.  The arguments are the resource tree, RESOURCES,
 320    and the location at which to put it in the tree, CIDS and IDS.
 321    This returns a newly allocated rc_res_resource structure, which the
 322    caller is expected to initialize.  If DUPOK is non-zero, then if a
 323    resource with this ID exists, it is returned.  Otherwise, a warning
 324    is issued, and a new resource is created replacing the existing
 325    one.  */
 326
 327 rc_res_resource *
 328 define_resource (rc_res_directory **resources, int cids,
 329                  const rc_res_id *ids, int dupok)
 330 {
 331   rc_res_entry *re = NULL;
 332   int i;
 333
 334   assert (cids > 0);
 335   for (i = 0; i < cids; i++)
 336     {
 337       rc_res_entry **pp;
 338
 339       if (*resources == NULL)
 340         {
 341           *resources = ((rc_res_directory *)
 342                         res_alloc (sizeof (rc_res_directory)));
 343           (*resources)->characteristics = 0;
 344           /* Using a real timestamp only serves to create non-deterministic
 345              results.  Use zero instead.  */
 346           (*resources)->time = 0;
 347           (*resources)->major = 0;
 348           (*resources)->minor = 0;
 349           (*resources)->entries = NULL;
 350         }
 351
 352       for (pp = &(*resources)->entries; *pp != NULL; pp = &(*pp)->next)
 353         if (res_id_cmp ((*pp)->id, ids[i]) == 0)
 354           break;
 355
 356       if (*pp != NULL)
 357         re = *pp;
 358       else
 359         {
 360           re = (rc_res_entry *) res_alloc (sizeof (rc_res_entry));
 361           re->next = NULL;
 362           re->id = ids[i];
 363           if ((i + 1) < cids)
 364             {
 365               re->subdir = 1;
 366               re->u.dir = NULL;
 367             }
 368           else
 369             {
 370               re->subdir = 0;
 371               re->u.res = NULL;
 372             }
 373
 374           *pp = re;
 375         }
 376
 377       if ((i + 1) < cids)
 378         {
 379           if (! re->subdir)
 380             {
 381               fprintf (stderr, "%s: ", program_name);
 382               res_ids_print (stderr, i, ids);
 383               fprintf (stderr, _(": expected to be a directory\n"));
 384               xexit (1);
 385             }
 386
 387           resources = &re->u.dir;
 388         }
 389     }
 390
 391   if (re->subdir)
 392     {
 393       fprintf (stderr, "%s: ", program_name);
 394       res_ids_print (stderr, cids, ids);
 395       fprintf (stderr, _(": expected to be a leaf\n"));
 396       xexit (1);
 397     }
 398
 399   if (re->u.res != NULL)
 400     {
 401       if (dupok)
 402         return re->u.res;
 403
 404       fprintf (stderr, _("%s: warning: "), program_name);
 405       res_ids_print (stderr, cids, ids);
 406       fprintf (stderr, _(": duplicate value\n"));
 407     }
 408
 409   re->u.res = ((rc_res_resource *)
 410                res_alloc (sizeof (rc_res_resource)));
 411   memset (re->u.res, 0, sizeof (rc_res_resource));
 412
 413   re->u.res->type = RES_TYPE_UNINITIALIZED;
 414   return re->u.res;
 415 }
 416
 417 /* Define a standard resource.  This is a version of define_resource
 418    that just takes type, name, and language arguments.  */
 419
 420 rc_res_resource *
 421 define_standard_resource (rc_res_directory **resources, int type,
 422                           rc_res_id name, rc_uint_type language, int dupok)
 423 {
 424   rc_res_id a[3];
 425
 426   a[0].named = 0;
 427   a[0].u.id = type;
 428   a[1] = name;
 429   a[2].named = 0;
 430   a[2].u.id = language;
 431   return define_resource (resources, 3, a, dupok);
 432 }
 433
 434 /* Comparison routine for resource sorting.  */
 435
 436 static int
 437 cmp_res_entry (const void *p1, const void *p2)
 438 {
 439   const rc_res_entry **re1, **re2;
 440
 441   re1 = (const rc_res_entry **) p1;
 442   re2 = (const rc_res_entry **) p2;
 443   return res_id_cmp ((*re1)->id, (*re2)->id);
 444 }
 445
 446 /* Sort the resources.  */
 447
 448 static rc_res_directory *
 449 sort_resources (rc_res_directory *resdir)
 450 {
 451   int c, i;
 452   rc_res_entry *re;
 453   rc_res_entry **a;
 454
 455   if (resdir->entries == NULL)
 456     return resdir;
 457
 458   c = 0;
 459   for (re = resdir->entries; re != NULL; re = re->next)
 460     ++c;
 461
 462   /* This is a recursive routine, so using xmalloc is probably better
 463      than alloca.  */
 464   a = (rc_res_entry **) xmalloc (c * sizeof (rc_res_entry *));
 465
 466   for (i = 0, re = resdir->entries; re != NULL; re = re->next, i++)
 467     a[i] = re;
 468
 469   qsort (a, c, sizeof (rc_res_entry *), cmp_res_entry);
 470
 471   resdir->entries = a[0];
 472   for (i = 0; i < c - 1; i++)
 473     a[i]->next = a[i + 1];
 474   a[i]->next = NULL;
 475
 476   free (a);
 477
 478   /* Now sort the subdirectories.  */
 479
 480   for (re = resdir->entries; re != NULL; re = re->next)
 481     if (re->subdir)
 482       re->u.dir = sort_resources (re->u.dir);
 483
 484   return resdir;
 485 }
 486 \f
 487 /* Return whether the dialog resource DIALOG is a DIALOG or a
 488    DIALOGEX.  */
 489
 490 int
 491 extended_dialog (const rc_dialog *dialog)
 492 {
 493   const rc_dialog_control *c;
 494
 495   if (dialog->ex != NULL)
 496     return 1;
 497
 498   for (c = dialog->controls; c != NULL; c = c->next)
 499     if (c->data != NULL || c->help != 0)
 500       return 1;
 501
 502   return 0;
 503 }
 504
 505 /* Return whether MENUITEMS are a MENU or a MENUEX.  */
 506
 507 int
 508 extended_menu (const rc_menu *menu)
 509 {
 510   return extended_menuitems (menu->items);
 511 }
 512
 513 static int
 514 extended_menuitems (const rc_menuitem *menuitems)
 515 {
 516   const rc_menuitem *mi;
 517
 518   for (mi = menuitems; mi != NULL; mi = mi->next)
 519     {
 520       if (mi->help != 0 || mi->state != 0)
 521         return 1;
 522       if (mi->popup != NULL && mi->id != 0)
 523         return 1;
 524       if ((mi->type
 525            & ~ (MENUITEM_CHECKED
 526                 | MENUITEM_GRAYED
 527                 | MENUITEM_HELP
 528                 | MENUITEM_INACTIVE
 529                 | MENUITEM_MENUBARBREAK
 530                 | MENUITEM_MENUBREAK))
 531           != 0)
 532         return 1;
 533       if (mi->popup != NULL)
 534         {
 535           if (extended_menuitems (mi->popup))
 536             return 1;
 537         }
 538     }
 539
 540   return 0;
 541 }
 542 \f
 543 /* Convert a string to a format type, or exit if it can't be done.  */
 544
 545 static enum res_format
 546 format_from_name (const char *name, int exit_on_error)
 547 {
 548   const struct format_map *m;
 549
 550   for (m = format_names; m->name != NULL; m++)
 551     if (strcasecmp (m->name, name) == 0)
 552       break;
 553
 554   if (m->name == NULL && exit_on_error)
 555     {
 556       non_fatal (_("unknown format type `%s'"), name);
 557       fprintf (stderr, _("%s: supported formats:"), program_name);
 558       for (m = format_names; m->name != NULL; m++)
 559         fprintf (stderr, " %s", m->name);
 560       fprintf (stderr, "\n");
 561       xexit (1);
 562     }
 563
 564   return m->format;
 565 }
 566
 567 /* Work out a format type given a file name.  If INPUT is non-zero,
 568    it's OK to look at the file itself.  */
 569
 570 static enum res_format
 571 format_from_filename (const char *filename, int input)
 572 {
 573   const char *ext;
 574   FILE *e;
 575   bfd_byte b1, b2, b3, b4, b5;
 576   int magic;
 577
 578   /* If we have an extension, see if we recognize it as implying a
 579      particular format.  */
 580   ext = strrchr (filename, '.');
 581   if (ext != NULL)
 582     {
 583       const struct format_map *m;
 584
 585       ++ext;
 586       for (m = format_fileexts; m->name != NULL; m++)
 587         if (strcasecmp (m->name, ext) == 0)
 588           return m->format;
 589     }
 590
 591   /* If we don't recognize the name of an output file, assume it's a
 592      COFF file.  */
 593   if (! input)
 594     return RES_FORMAT_COFF;
 595
 596   /* Read the first few bytes of the file to see if we can guess what
 597      it is.  */
 598   e = fopen (filename, FOPEN_RB);
 599   if (e == NULL)
 600     fatal ("%s: %s", filename, strerror (errno));
 601
 602   b1 = getc (e);
 603   b2 = getc (e);
 604   b3 = getc (e);
 605   b4 = getc (e);
 606   b5 = getc (e);
 607
 608   fclose (e);
 609
 610   /* A PE executable starts with 0x4d 0x5a.  */
 611   if (b1 == 0x4d && b2 == 0x5a)
 612     return RES_FORMAT_COFF;
 613
 614   /* A COFF .o file starts with a COFF magic number.  */
 615   magic = (b2 << 8) | b1;
 616   switch (magic)
 617     {
 618     case 0x14c: /* i386 */
 619     case 0x166: /* MIPS */
 620     case 0x184: /* Alpha */
 621     case 0x268: /* 68k */
 622     case 0x1f0: /* PowerPC */
 623     case 0x290: /* PA */
 624       return RES_FORMAT_COFF;
 625     }
 626
 627   /* A RES file starts with 0x0 0x0 0x0 0x0 0x20 0x0 0x0 0x0.  */
 628   if (b1 == 0 && b2 == 0 && b3 == 0 && b4 == 0 && b5 == 0x20)
 629     return RES_FORMAT_RES;
 630
 631   /* If every character is printable or space, assume it's an RC file.  */
 632   if ((ISPRINT (b1) || ISSPACE (b1))
 633       && (ISPRINT (b2) || ISSPACE (b2))
 634       && (ISPRINT (b3) || ISSPACE (b3))
 635       && (ISPRINT (b4) || ISSPACE (b4))
 636       && (ISPRINT (b5) || ISSPACE (b5)))
 637     return RES_FORMAT_RC;
 638
 639   /* Otherwise, we give up.  */
 640   fatal (_("can not determine type of file `%s'; use the -J option"),
 641          filename);
 642
 643   /* Return something to silence the compiler warning.  */
 644   return RES_FORMAT_UNKNOWN;
 645 }
 646
 647 /* Print a usage message and exit.  */
 648
 649 static void
 650 usage (FILE *stream, int status)
 651 {
 652   fprintf (stream, _("Usage: %s [option(s)] [input-file] [output-file]\n"),
 653            program_name);
 654   fprintf (stream, _(" The options are:\n\
 655   -i --input=<file>            Name input file\n\
 656   -o --output=<file>           Name output file\n\
 657   -J --input-format=<format>   Specify input format\n\
 658   -O --output-format=<format>  Specify output format\n\
 659   -F --target=<target>         Specify COFF target\n\
 660      --preprocessor=<program>  Program to use to preprocess rc file\n\
 661      --preprocessor-arg=<arg>  Additional preprocessor argument\n\
 662   -I --include-dir=<dir>       Include directory when preprocessing rc file\n\
 663   -D --define <sym>[=<val>]    Define SYM when preprocessing rc file\n\
 664   -U --undefine <sym>          Undefine SYM when preprocessing rc file\n\
 665   -v --verbose                 Verbose - tells you what it's doing\n\
 666   -c --codepage=<codepage>     Specify default codepage\n\
 667   -l --language=<val>          Set language when reading rc file\n\
 668      --use-temp-file           Use a temporary file instead of popen to read\n\
 669                                the preprocessor output\n\
 670      --no-use-temp-file        Use popen (default)\n"));
 671 #ifdef YYDEBUG
 672   fprintf (stream, _("\
 673      --yydebug                 Turn on parser debugging\n"));
 674 #endif
 675   fprintf (stream, _("\
 676   -r                           Ignored for compatibility with rc\n\
 677   @<file>                      Read options from <file>\n\
 678   -h --help                    Print this help message\n\
 679   -V --version                 Print version information\n"));
 680   fprintf (stream, _("\
 681 FORMAT is one of rc, res, or coff, and is deduced from the file name\n\
 682 extension if not specified.  A single file name is an input file.\n\
 683 No input-file is stdin, default rc.  No output-file is stdout, default rc.\n"));
 684
 685   list_supported_targets (program_name, stream);
 686
 687   if (REPORT_BUGS_TO[0] && status == 0)
 688     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 689
 690   exit (status);
 691 }
 692
 693 /* Quote characters that will confuse the shell when we run the preprocessor.  */
 694
 695 static const char *
 696 quot (const char *string)
 697 {
 698   static char *buf = 0;
 699   static int buflen = 0;
 700   int slen = strlen (string);
 701   const char *src;
 702   char *dest;
 703
 704   if ((buflen < slen * 2 + 2) || ! buf)
 705     {
 706       buflen = slen * 2 + 2;
 707       if (buf)
 708         free (buf);
 709       buf = (char *) xmalloc (buflen);
 710     }
 711
 712   for (src=string, dest=buf; *src; src++, dest++)
 713     {
 714       if (*src == '(' || *src == ')' || *src == ' ')
 715         *dest++ = '\\';
 716       *dest = *src;
 717     }
 718   *dest = 0;
 719   return buf;
 720 }
 721
 722 /* Long options.  */
 723
 724 enum option_values
 725 {
 726   /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 727   OPTION_PREPROCESSOR   = 150,
 728   OPTION_USE_TEMP_FILE,
 729   OPTION_NO_USE_TEMP_FILE,
 730   OPTION_YYDEBUG,
 731   OPTION_INCLUDE_DIR,
 732   OPTION_PREPROCESSOR_ARG
 733 };
 734
 735 static const struct option long_options[] =
 736 {
 737   {"input", required_argument, 0, 'i'},
 738   {"output", required_argument, 0, 'o'},
 739   {"input-format", required_argument, 0, 'J'},
 740   {"output-format", required_argument, 0, 'O'},
 741   {"target", required_argument, 0, 'F'},
 742   {"preprocessor", required_argument, 0, OPTION_PREPROCESSOR},
 743   {"preprocessor-arg", required_argument, 0, OPTION_PREPROCESSOR_ARG},
 744   {"include-dir", required_argument, 0, OPTION_INCLUDE_DIR},
 745   {"define", required_argument, 0, 'D'},
 746   {"undefine", required_argument, 0, 'U'},
 747   {"verbose", no_argument, 0, 'v'},
 748   {"codepage", required_argument, 0, 'c'},
 749   {"language", required_argument, 0, 'l'},
 750   {"use-temp-file", no_argument, 0, OPTION_USE_TEMP_FILE},
 751   {"no-use-temp-file", no_argument, 0, OPTION_NO_USE_TEMP_FILE},
 752   {"yydebug", no_argument, 0, OPTION_YYDEBUG},
 753   {"version", no_argument, 0, 'V'},
 754   {"help", no_argument, 0, 'h'},
 755   {0, no_argument, 0, 0}
 756 };
 757
 758 void
 759 windres_add_include_dir (const char *p)
 760 {
 761   struct include_dir *n, **pp;
 762
 763   /* Computing paths is often complicated and error prone.
 764      The easiest way to check for mistakes is at the time
 765      we add them to include_dirs.  */
 766   assert (p != NULL);
 767   assert (*p != '\0');
 768
 769   n = xmalloc (sizeof *n);
 770   n->next = NULL;
 771   n->dir = (char * ) p;
 772
 773   for (pp = &include_dirs; *pp != NULL; pp = &(*pp)->next)
 774     ;
 775   *pp = n;
 776 }
 777
 778 /* This keeps gcc happy when using -Wmissing-prototypes -Wstrict-prototypes.  */
 779 int main (int, char **);
 780
 781 /* The main function.  */
 782
 783 int
 784 main (int argc, char **argv)
 785 {
 786   int c;
 787   char *input_filename;
 788   char *output_filename;
 789   enum res_format input_format;
 790   enum res_format input_format_tmp;
 791   enum res_format output_format;
 792   char *target;
 793   char *preprocessor;
 794   char *preprocargs;
 795   const char *quotedarg;
 796   int language;
 797   rc_res_directory *resources;
 798   int use_temp_file;
 799
 800 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 801   setlocale (LC_MESSAGES, "");
 802 #endif
 803 #if defined (HAVE_SETLOCALE)
 804   setlocale (LC_CTYPE, "");
 805 #endif
 806   bindtextdomain (PACKAGE, LOCALEDIR);
 807   textdomain (PACKAGE);
 808
 809   program_name = argv[0];
 810   xmalloc_set_program_name (program_name);
 811   bfd_set_error_program_name (program_name);
 812
 813   expandargv (&argc, &argv);
 814
 815   if (bfd_init () != BFD_INIT_MAGIC)
 816     fatal (_("fatal error: libbfd ABI mismatch"));
 817   set_default_bfd_target ();
 818
 819   res_init ();
 820
 821   input_filename = NULL;
 822   output_filename = NULL;
 823   input_format = RES_FORMAT_UNKNOWN;
 824   output_format = RES_FORMAT_UNKNOWN;
 825   target = NULL;
 826   preprocessor = NULL;
 827   preprocargs = NULL;
 828   language = 0x409;   /* LANG_ENGLISH, SUBLANG_ENGLISH_US.  */
 829   use_temp_file = 0;
 830
 831   while ((c = getopt_long (argc, argv, "c:f:i:l:o:I:J:O:F:D:U:rhHvV", long_options,
 832                            (int *) 0)) != EOF)
 833     {
 834       switch (c)
 835         {
 836         case 'c':
 837           {
 838             rc_uint_type ncp;
 839
 840             if (optarg[0] == '0' && (optarg[1] == 'x' || optarg[1] == 'X'))
 841               ncp = (rc_uint_type) strtol (optarg + 2, NULL, 16);
 842             else
 843               ncp = (rc_uint_type) strtol (optarg, NULL, 10);
 844             if (ncp == CP_UTF16 || ! unicode_is_valid_codepage (ncp))
 845               fatal (_("invalid codepage specified.\n"));
 846             wind_default_codepage = wind_current_codepage = ncp;
 847           }
 848           break;
 849
 850         case 'i':
 851           input_filename = optarg;
 852           break;
 853
 854         case 'f':
 855           /* For compatibility with rc we accept "-fo <name>" as being the
 856              equivalent of "-o <name>".  We do not advertise this fact
 857              though, as we do not want users to use non-GNU like command
 858              line switches.  */
 859           if (*optarg != 'o')
 860             fatal (_("invalid option -f\n"));
 861           optarg++;
 862           if (* optarg == 0)
 863             {
 864               if (optind == argc)
 865                 fatal (_("No filename following the -fo option.\n"));
 866               optarg = argv [optind++];
 867             }
 868           /* Fall through.  */
 869
 870         case 'o':
 871           output_filename = optarg;
 872           break;
 873
 874         case 'J':
 875           input_format = format_from_name (optarg, 1);
 876           break;
 877
 878         case 'O':
 879           output_format = format_from_name (optarg, 1);
 880           break;
 881
 882         case 'F':
 883           target = optarg;
 884           break;
 885
 886         case OPTION_PREPROCESSOR:
 887           preprocessor = optarg;
 888           break;
 889
 890         case OPTION_PREPROCESSOR_ARG:
 891           if (preprocargs == NULL)
 892             {
 893               quotedarg = quot (optarg);
 894               preprocargs = xstrdup (quotedarg);
 895             }
 896           else
 897             {
 898               char *n;
 899
 900               quotedarg = quot (optarg);
 901               n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 2);
 902               sprintf (n, "%s %s", preprocargs, quotedarg);
 903               free (preprocargs);
 904               preprocargs = n;
 905             }
 906           break;
 907
 908         case 'D':
 909         case 'U':
 910           if (preprocargs == NULL)
 911             {
 912               quotedarg = quot (optarg);
 913               preprocargs = xmalloc (strlen (quotedarg) + 3);
 914               sprintf (preprocargs, "-%c%s", c, quotedarg);
 915             }
 916           else
 917             {
 918               char *n;
 919
 920               quotedarg = quot (optarg);
 921               n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
 922               sprintf (n, "%s -%c%s", preprocargs, c, quotedarg);
 923               free (preprocargs);
 924               preprocargs = n;
 925             }
 926           break;
 927
 928         case 'r':
 929           /* Ignored for compatibility with rc.  */
 930           break;
 931
 932         case 'v':
 933           verbose ++;
 934           break;
 935
 936         case 'I':
 937           /* For backward compatibility, should be removed in the future.  */
 938           input_format_tmp = format_from_name (optarg, 0);
 939           if (input_format_tmp != RES_FORMAT_UNKNOWN)
 940             {
 941               struct stat statbuf;
 942               char modebuf[11];
 943
 944               if (stat (optarg, & statbuf) == 0
 945                   /* Coded this way to avoid importing knowledge of S_ISDIR into this file.  */
 946                   && (mode_string (statbuf.st_mode, modebuf), modebuf[0] == 'd'))
 947                 /* We have a -I option with a directory name that just happens
 948                    to match a format name as well.  eg: -I res  Assume that the
 949                    user knows what they are doing and do not complain.  */
 950                 ;
 951               else
 952                 {
 953                   fprintf (stderr,
 954                            _("Option -I is deprecated for setting the input format, please use -J instead.\n"));
 955                   input_format = input_format_tmp;
 956                   break;
 957                 }
 958             }
 959           /* Fall through.  */
 960
 961         case OPTION_INCLUDE_DIR:
 962           if (preprocargs == NULL)
 963             {
 964               quotedarg = quot (optarg);
 965               preprocargs = xmalloc (strlen (quotedarg) + 3);
 966               sprintf (preprocargs, "-I%s", quotedarg);
 967             }
 968           else
 969             {
 970               char *n;
 971
 972               quotedarg = quot (optarg);
 973               n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4);
 974               sprintf (n, "%s -I%s", preprocargs, quotedarg);
 975               free (preprocargs);
 976               preprocargs = n;
 977             }
 978
 979           windres_add_include_dir (optarg);
 980
 981           break;
 982
 983         case 'l':
 984           language = strtol (optarg, (char **) NULL, 16);
 985           break;
 986
 987         case OPTION_USE_TEMP_FILE:
 988           use_temp_file = 1;
 989           break;
 990
 991         case OPTION_NO_USE_TEMP_FILE:
 992           use_temp_file = 0;
 993           break;
 994
 995 #ifdef YYDEBUG
 996         case OPTION_YYDEBUG:
 997           yydebug = 1;
 998           break;
 999 #endif
1000
1001         case 'h':
1002         case 'H':
1003           usage (stdout, 0);
1004           break;
1005
1006         case 'V':
1007           print_version ("windres");
1008           break;
1009
1010         default:
1011           usage (stderr, 1);
1012           break;
1013         }
1014     }
1015
1016   if (input_filename == NULL && optind < argc)
1017     {
1018       input_filename = argv[optind];
1019       ++optind;
1020     }
1021
1022   if (output_filename == NULL && optind < argc)
1023     {
1024       output_filename = argv[optind];
1025       ++optind;
1026     }
1027
1028   if (argc != optind)
1029     usage (stderr, 1);
1030
1031   if (input_format == RES_FORMAT_UNKNOWN)
1032     {
1033       if (input_filename == NULL)
1034         input_format = RES_FORMAT_RC;
1035       else
1036         input_format = format_from_filename (input_filename, 1);
1037     }
1038
1039   if (output_format == RES_FORMAT_UNKNOWN)
1040     {
1041       if (output_filename == NULL)
1042         output_format = RES_FORMAT_RC;
1043       else
1044         output_format = format_from_filename (output_filename, 0);
1045     }
1046
1047   set_endianness (NULL, target);
1048
1049   /* Read the input file.  */
1050   switch (input_format)
1051     {
1052     default:
1053       abort ();
1054     case RES_FORMAT_RC:
1055       resources = read_rc_file (input_filename, preprocessor, preprocargs,
1056                                 language, use_temp_file);
1057       break;
1058     case RES_FORMAT_RES:
1059       resources = read_res_file (input_filename);
1060       break;
1061     case RES_FORMAT_COFF:
1062       resources = read_coff_rsrc (input_filename, target);
1063       break;
1064     }
1065
1066   if (resources == NULL)
1067     fatal (_("no resources"));
1068
1069   /* Sort the resources.  This is required for COFF, convenient for
1070      rc, and unimportant for res.  */
1071   resources = sort_resources (resources);
1072
1073   /* Write the output file.  */
1074   reswr_init ();
1075
1076   switch (output_format)
1077     {
1078     default:
1079       abort ();
1080     case RES_FORMAT_RC:
1081       write_rc_file (output_filename, resources);
1082       break;
1083     case RES_FORMAT_RES:
1084       write_res_file (output_filename, resources);
1085       break;
1086     case RES_FORMAT_COFF:
1087       write_coff_file (output_filename, target, resources);
1088       break;
1089     }
1090
1091   xexit (0);
1092   return 0;
1093 }
1094
1095 static void
1096 set_endianness (bfd *abfd, const char *target)
1097 {
1098   const bfd_target *target_vec;
1099
1100   def_target_arch = NULL;
1101   target_vec = bfd_get_target_info (target, abfd, &target_is_bigendian, NULL,
1102                                    &def_target_arch);
1103   if (! target_vec)
1104     fatal ("Can't detect target endianness and architecture.");
1105   if (! def_target_arch)
1106     fatal ("Can't detect architecture.");
1107 }
1108
1109 bfd *
1110 windres_open_as_binary (const char *filename, int rdmode)
1111 {
1112   bfd *abfd;
1113
1114   abfd = (rdmode ? bfd_openr (filename, "binary") : bfd_openw (filename, "binary"));
1115   if (! abfd)
1116     fatal ("can't open `%s' for %s", filename, (rdmode ? "input" : "output"));
1117
1118   if (rdmode && ! bfd_check_format (abfd, bfd_object))
1119     fatal ("can't open `%s' for input.", filename);
1120
1121   return abfd;
1122 }
1123
1124 void
1125 set_windres_bfd_endianness (windres_bfd *wrbfd, int is_bigendian)
1126 {
1127   assert (!! wrbfd);
1128   switch (WR_KIND(wrbfd))
1129   {
1130   case WR_KIND_BFD_BIN_L:
1131     if (is_bigendian)
1132       WR_KIND(wrbfd) = WR_KIND_BFD_BIN_B;
1133     break;
1134   case WR_KIND_BFD_BIN_B:
1135     if (! is_bigendian)
1136       WR_KIND(wrbfd) = WR_KIND_BFD_BIN_L;
1137     break;
1138   default:
1139     /* only binary bfd can be overriden. */
1140     abort ();
1141   }
1142 }
1143
1144 void
1145 set_windres_bfd (windres_bfd *wrbfd, bfd *abfd, asection *sec, rc_uint_type kind)
1146 {
1147   assert (!! wrbfd);
1148   switch (kind)
1149   {
1150   case WR_KIND_TARGET:
1151     abfd = NULL;
1152     sec = NULL;
1153     break;
1154   case WR_KIND_BFD:
1155   case WR_KIND_BFD_BIN_L:
1156   case WR_KIND_BFD_BIN_B:
1157     assert (!! abfd);
1158     assert (!!sec);
1159     break;
1160   default:
1161     abort ();
1162   }
1163   WR_KIND(wrbfd) = kind;
1164   WR_BFD(wrbfd) = abfd;
1165   WR_SECTION(wrbfd) = sec;
1166 }
1167
1168 void
1169 set_windres_bfd_content (windres_bfd *wrbfd, const void *data, rc_uint_type off,
1170                          rc_uint_type length)
1171 {
1172   if (WR_KIND(wrbfd) != WR_KIND_TARGET)
1173     {
1174       if (! bfd_set_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length))
1175         bfd_fatal ("bfd_set_section_contents");
1176     }
1177   else
1178     abort ();
1179 }
1180
1181 void
1182 get_windres_bfd_content (windres_bfd *wrbfd, void *data, rc_uint_type off,
1183                          rc_uint_type length)
1184 {
1185   if (WR_KIND(wrbfd) != WR_KIND_TARGET)
1186     {
1187       if (! bfd_get_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length))
1188         bfd_fatal ("bfd_get_section_contents");
1189     }
1190   else
1191     abort ();
1192 }
1193
1194 void
1195 windres_put_8 (windres_bfd *wrbfd, void *p, rc_uint_type value)
1196 {
1197   switch (WR_KIND(wrbfd))
1198     {
1199     case WR_KIND_TARGET:
1200       target_put_8 (p, value);
1201       break;
1202     case WR_KIND_BFD:
1203     case WR_KIND_BFD_BIN_L:
1204     case WR_KIND_BFD_BIN_B:
1205       bfd_put_8 (WR_BFD(wrbfd), value, p);
1206       break;
1207     default:
1208       abort ();
1209     }
1210 }
1211
1212 void
1213 windres_put_16 (windres_bfd *wrbfd, void *data, rc_uint_type value)
1214 {
1215   switch (WR_KIND(wrbfd))
1216     {
1217     case WR_KIND_TARGET:
1218       target_put_16 (data, value);
1219       break;
1220     case WR_KIND_BFD:
1221     case WR_KIND_BFD_BIN_B:
1222       bfd_put_16 (WR_BFD(wrbfd), value, data);
1223       break;
1224     case WR_KIND_BFD_BIN_L:
1225       bfd_putl16 (value, data);
1226       break;
1227     default:
1228       abort ();
1229     }
1230 }
1231
1232 void
1233 windres_put_32 (windres_bfd *wrbfd, void *data, rc_uint_type value)
1234 {
1235   switch (WR_KIND(wrbfd))
1236     {
1237     case WR_KIND_TARGET:
1238       target_put_32 (data, value);
1239       break;
1240     case WR_KIND_BFD:
1241     case WR_KIND_BFD_BIN_B:
1242       bfd_put_32 (WR_BFD(wrbfd), value, data);
1243       break;
1244     case WR_KIND_BFD_BIN_L:
1245       bfd_putl32 (value, data);
1246       break;
1247     default:
1248       abort ();
1249     }
1250 }
1251
1252 rc_uint_type
1253 windres_get_8 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1254 {
1255   if (length < 1)
1256     fatal ("windres_get_8: unexpected eob.");
1257   switch (WR_KIND(wrbfd))
1258     {
1259     case WR_KIND_TARGET:
1260       return target_get_8 (data, length);
1261     case WR_KIND_BFD:
1262     case WR_KIND_BFD_BIN_B:
1263     case WR_KIND_BFD_BIN_L:
1264       return bfd_get_8 (WR_BFD(wrbfd), data);
1265     default:
1266       abort ();
1267     }
1268   return 0;
1269 }
1270
1271 rc_uint_type
1272 windres_get_16 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1273 {
1274   if (length < 2)
1275     fatal ("windres_get_16: unexpected eob.");
1276   switch (WR_KIND(wrbfd))
1277     {
1278     case WR_KIND_TARGET:
1279       return target_get_16 (data, length);
1280     case WR_KIND_BFD:
1281     case WR_KIND_BFD_BIN_B:
1282       return bfd_get_16 (WR_BFD(wrbfd), data);
1283     case WR_KIND_BFD_BIN_L:
1284       return bfd_getl16 (data);
1285     default:
1286       abort ();
1287     }
1288   return 0;
1289 }
1290
1291 rc_uint_type
1292 windres_get_32 (windres_bfd *wrbfd, const void *data, rc_uint_type length)
1293 {
1294   if (length < 4)
1295     fatal ("windres_get_32: unexpected eob.");
1296   switch (WR_KIND(wrbfd))
1297     {
1298     case WR_KIND_TARGET:
1299       return target_get_32 (data, length);
1300     case WR_KIND_BFD:
1301     case WR_KIND_BFD_BIN_B:
1302       return bfd_get_32 (WR_BFD(wrbfd), data);
1303     case WR_KIND_BFD_BIN_L:
1304       return bfd_getl32 (data);
1305     default:
1306       abort ();
1307     }
1308   return 0;
1309 }
1310
1311 static rc_uint_type
1312 target_get_8 (const void *p, rc_uint_type length)
1313 {
1314   rc_uint_type ret;
1315
1316   if (length < 1)
1317     fatal ("Resource too small for getting 8-bit value.");
1318
1319   ret = (rc_uint_type) *((const bfd_byte *) p);
1320   return ret & 0xff;
1321 }
1322
1323 static rc_uint_type
1324 target_get_16 (const void *p, rc_uint_type length)
1325 {
1326   if (length < 2)
1327     fatal ("Resource too small for getting 16-bit value.");
1328
1329   if (target_is_bigendian)
1330     return bfd_getb16 (p);
1331   else
1332     return bfd_getl16 (p);
1333 }
1334
1335 static rc_uint_type
1336 target_get_32 (const void *p, rc_uint_type length)
1337 {
1338   if (length < 4)
1339     fatal ("Resource too small for getting 32-bit value.");
1340
1341   if (target_is_bigendian)
1342     return bfd_getb32 (p);
1343   else
1344     return bfd_getl32 (p);
1345 }
1346
1347 static void
1348 target_put_8 (void *p, rc_uint_type value)
1349 {
1350   assert (!! p);
1351   *((bfd_byte *) p)=(bfd_byte) value;
1352 }
1353
1354 static void
1355 target_put_16 (void *p, rc_uint_type value)
1356 {
1357   assert (!! p);
1358
1359   if (target_is_bigendian)
1360     bfd_putb16 (value, p);
1361   else
1362     bfd_putl16 (value, p);
1363 }
1364
1365 static void
1366 target_put_32 (void *p, rc_uint_type value)
1367 {
1368   assert (!! p);
1369
1370   if (target_is_bigendian)
1371     bfd_putb32 (value, p);
1372   else
1373     bfd_putl32 (value, p);
1374 }
1375
1376 static int isInComment = 0;
1377
1378 int wr_printcomment (FILE *e, const char *fmt, ...)
1379 {
1380   va_list arg;
1381   int r = 0;
1382
1383   if (isInComment)
1384     r += fprintf (e, "\n   ");
1385   else
1386     fprintf (e, "/* ");
1387   isInComment = 1;
1388   if (fmt == NULL)
1389     return r;
1390   va_start (arg, fmt);
1391   r += vfprintf (e, fmt, arg);
1392   va_end (arg);
1393   return r;
1394 }
1395
1396 int wr_print (FILE *e, const char *fmt, ...)
1397 {
1398   va_list arg;
1399   int r = 0;
1400   if (isInComment)
1401     r += fprintf (e, ".  */\n");
1402   isInComment = 0;
1403   if (! fmt)
1404     return r;
1405   va_start (arg, fmt);
1406   r += vfprintf (e, fmt, arg);
1407   va_end (arg);
1408   return r;
1409 }