1 /* windres.c -- a program to manipulate Windows resources 2 Copyright (C) 1997-2020 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 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 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 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 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 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 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 } 1410