1 /* windres.c -- a program to manipulate Windows resources 2 Copyright (C) 1997-2022 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 bool 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_BITMAP 531 | MENUITEM_OWNERDRAW 532 | MENUITEM_MENUBREAK)) 533 != 0) 534 return 1; 535 if (mi->popup != NULL) 536 { 537 if (extended_menuitems (mi->popup)) 538 return 1; 539 } 540 } 541 542 return 0; 543 } 544 545 /* Convert a string to a format type, or exit if it can't be done. */ 546 547 static enum res_format 548 format_from_name (const char *name, int exit_on_error) 549 { 550 const struct format_map *m; 551 552 for (m = format_names; m->name != NULL; m++) 553 if (strcasecmp (m->name, name) == 0) 554 break; 555 556 if (m->name == NULL && exit_on_error) 557 { 558 non_fatal (_("unknown format type `%s'"), name); 559 fprintf (stderr, _("%s: supported formats:"), program_name); 560 for (m = format_names; m->name != NULL; m++) 561 fprintf (stderr, " %s", m->name); 562 fprintf (stderr, "\n"); 563 xexit (1); 564 } 565 566 return m->format; 567 } 568 569 /* Work out a format type given a file name. If INPUT is non-zero, 570 it's OK to look at the file itself. */ 571 572 static enum res_format 573 format_from_filename (const char *filename, int input) 574 { 575 const char *ext; 576 FILE *e; 577 bfd_byte b1, b2, b3, b4, b5; 578 int magic; 579 580 /* If we have an extension, see if we recognize it as implying a 581 particular format. */ 582 ext = strrchr (filename, '.'); 583 if (ext != NULL) 584 { 585 const struct format_map *m; 586 587 ++ext; 588 for (m = format_fileexts; m->name != NULL; m++) 589 if (strcasecmp (m->name, ext) == 0) 590 return m->format; 591 } 592 593 /* If we don't recognize the name of an output file, assume it's a 594 COFF file. */ 595 if (! input) 596 return RES_FORMAT_COFF; 597 598 /* Read the first few bytes of the file to see if we can guess what 599 it is. */ 600 e = fopen (filename, FOPEN_RB); 601 if (e == NULL) 602 fatal ("%s: %s", filename, strerror (errno)); 603 604 b1 = getc (e); 605 b2 = getc (e); 606 b3 = getc (e); 607 b4 = getc (e); 608 b5 = getc (e); 609 610 fclose (e); 611 612 /* A PE executable starts with 0x4d 0x5a. */ 613 if (b1 == 0x4d && b2 == 0x5a) 614 return RES_FORMAT_COFF; 615 616 /* A COFF .o file starts with a COFF magic number. */ 617 magic = (b2 << 8) | b1; 618 switch (magic) 619 { 620 case 0x14c: /* i386 */ 621 case 0x166: /* MIPS */ 622 case 0x184: /* Alpha */ 623 case 0x268: /* 68k */ 624 case 0x1f0: /* PowerPC */ 625 case 0x290: /* PA */ 626 return RES_FORMAT_COFF; 627 } 628 629 /* A RES file starts with 0x0 0x0 0x0 0x0 0x20 0x0 0x0 0x0. */ 630 if (b1 == 0 && b2 == 0 && b3 == 0 && b4 == 0 && b5 == 0x20) 631 return RES_FORMAT_RES; 632 633 /* If every character is printable or space, assume it's an RC file. */ 634 if ((ISPRINT (b1) || ISSPACE (b1)) 635 && (ISPRINT (b2) || ISSPACE (b2)) 636 && (ISPRINT (b3) || ISSPACE (b3)) 637 && (ISPRINT (b4) || ISSPACE (b4)) 638 && (ISPRINT (b5) || ISSPACE (b5))) 639 return RES_FORMAT_RC; 640 641 /* Otherwise, we give up. */ 642 fatal (_("can not determine type of file `%s'; use the -J option"), 643 filename); 644 645 /* Return something to silence the compiler warning. */ 646 return RES_FORMAT_UNKNOWN; 647 } 648 649 /* Print a usage message and exit. */ 650 651 static void 652 usage (FILE *stream, int status) 653 { 654 fprintf (stream, _("Usage: %s [option(s)] [input-file] [output-file]\n"), 655 program_name); 656 fprintf (stream, _(" The options are:\n\ 657 -i --input=<file> Name input file\n\ 658 -o --output=<file> Name output file\n\ 659 -J --input-format=<format> Specify input format\n\ 660 -O --output-format=<format> Specify output format\n\ 661 -F --target=<target> Specify COFF target\n\ 662 --preprocessor=<program> Program to use to preprocess rc file\n\ 663 --preprocessor-arg=<arg> Additional preprocessor argument\n\ 664 -I --include-dir=<dir> Include directory when preprocessing rc file\n\ 665 -D --define <sym>[=<val>] Define SYM when preprocessing rc file\n\ 666 -U --undefine <sym> Undefine SYM when preprocessing rc file\n\ 667 -v --verbose Verbose - tells you what it's doing\n\ 668 -c --codepage=<codepage> Specify default codepage\n\ 669 -l --language=<val> Set language when reading rc file\n\ 670 --use-temp-file Use a temporary file instead of popen to read\n\ 671 the preprocessor output\n\ 672 --no-use-temp-file Use popen (default)\n")); 673 #ifdef YYDEBUG 674 fprintf (stream, _("\ 675 --yydebug Turn on parser debugging\n")); 676 #endif 677 fprintf (stream, _("\ 678 -r Ignored for compatibility with rc\n\ 679 @<file> Read options from <file>\n\ 680 -h --help Print this help message\n\ 681 -V --version Print version information\n")); 682 fprintf (stream, _("\ 683 FORMAT is one of rc, res, or coff, and is deduced from the file name\n\ 684 extension if not specified. A single file name is an input file.\n\ 685 No input-file is stdin, default rc. No output-file is stdout, default rc.\n")); 686 687 list_supported_targets (program_name, stream); 688 689 if (REPORT_BUGS_TO[0] && status == 0) 690 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO); 691 692 exit (status); 693 } 694 695 /* Quote characters that will confuse the shell when we run the preprocessor. */ 696 697 static const char * 698 quot (const char *string) 699 { 700 static char *buf = 0; 701 static int buflen = 0; 702 int slen = strlen (string); 703 const char *src; 704 char *dest; 705 706 if ((buflen < slen * 2 + 3) || ! buf) 707 { 708 buflen = slen * 2 + 3; 709 free (buf); 710 buf = (char *) xmalloc (buflen); 711 } 712 713 for (src = string, dest = buf; *src; src++, dest++) 714 { 715 if (*src == '(' || *src == ')' || *src == ' ') 716 *dest++ = '\\'; 717 *dest = *src; 718 } 719 720 *dest = 0; 721 return buf; 722 } 723 724 /* Long options. */ 725 726 enum option_values 727 { 728 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */ 729 OPTION_PREPROCESSOR = 150, 730 OPTION_USE_TEMP_FILE, 731 OPTION_NO_USE_TEMP_FILE, 732 OPTION_YYDEBUG, 733 OPTION_INCLUDE_DIR, 734 OPTION_PREPROCESSOR_ARG 735 }; 736 737 static const struct option long_options[] = 738 { 739 {"input", required_argument, 0, 'i'}, 740 {"output", required_argument, 0, 'o'}, 741 {"input-format", required_argument, 0, 'J'}, 742 {"output-format", required_argument, 0, 'O'}, 743 {"target", required_argument, 0, 'F'}, 744 {"preprocessor", required_argument, 0, OPTION_PREPROCESSOR}, 745 {"preprocessor-arg", required_argument, 0, OPTION_PREPROCESSOR_ARG}, 746 {"include-dir", required_argument, 0, OPTION_INCLUDE_DIR}, 747 {"define", required_argument, 0, 'D'}, 748 {"undefine", required_argument, 0, 'U'}, 749 {"verbose", no_argument, 0, 'v'}, 750 {"codepage", required_argument, 0, 'c'}, 751 {"language", required_argument, 0, 'l'}, 752 {"use-temp-file", no_argument, 0, OPTION_USE_TEMP_FILE}, 753 {"no-use-temp-file", no_argument, 0, OPTION_NO_USE_TEMP_FILE}, 754 {"yydebug", no_argument, 0, OPTION_YYDEBUG}, 755 {"version", no_argument, 0, 'V'}, 756 {"help", no_argument, 0, 'h'}, 757 {0, no_argument, 0, 0} 758 }; 759 760 void 761 windres_add_include_dir (const char *p) 762 { 763 struct include_dir *n, **pp; 764 765 /* Computing paths is often complicated and error prone. 766 The easiest way to check for mistakes is at the time 767 we add them to include_dirs. */ 768 assert (p != NULL); 769 assert (*p != '\0'); 770 771 n = xmalloc (sizeof *n); 772 n->next = NULL; 773 n->dir = (char * ) p; 774 775 for (pp = &include_dirs; *pp != NULL; pp = &(*pp)->next) 776 ; 777 *pp = n; 778 } 779 780 /* This keeps gcc happy when using -Wmissing-prototypes -Wstrict-prototypes. */ 781 int main (int, char **); 782 783 /* The main function. */ 784 785 int 786 main (int argc, char **argv) 787 { 788 int c; 789 char *input_filename; 790 char *output_filename; 791 enum res_format input_format; 792 enum res_format input_format_tmp; 793 enum res_format output_format; 794 char *target; 795 char *preprocessor; 796 char *preprocargs; 797 const char *quotedarg; 798 int language; 799 rc_res_directory *resources; 800 int use_temp_file; 801 802 #ifdef HAVE_LC_MESSAGES 803 setlocale (LC_MESSAGES, ""); 804 #endif 805 setlocale (LC_CTYPE, ""); 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 if (strchr (optarg, ' ')) 888 { 889 if (asprintf (& preprocessor, "\"%s\"", optarg) == -1) 890 preprocessor = optarg; 891 } 892 else 893 preprocessor = optarg; 894 break; 895 896 case OPTION_PREPROCESSOR_ARG: 897 if (preprocargs == NULL) 898 { 899 quotedarg = quot (optarg); 900 preprocargs = xstrdup (quotedarg); 901 } 902 else 903 { 904 char *n; 905 906 quotedarg = quot (optarg); 907 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 2); 908 sprintf (n, "%s %s", preprocargs, quotedarg); 909 free (preprocargs); 910 preprocargs = n; 911 } 912 break; 913 914 case 'D': 915 case 'U': 916 if (preprocargs == NULL) 917 { 918 quotedarg = quot (optarg); 919 preprocargs = xmalloc (strlen (quotedarg) + 3); 920 sprintf (preprocargs, "-%c%s", c, quotedarg); 921 } 922 else 923 { 924 char *n; 925 926 quotedarg = quot (optarg); 927 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4); 928 sprintf (n, "%s -%c%s", preprocargs, c, quotedarg); 929 free (preprocargs); 930 preprocargs = n; 931 } 932 break; 933 934 case 'r': 935 /* Ignored for compatibility with rc. */ 936 break; 937 938 case 'v': 939 verbose ++; 940 break; 941 942 case 'I': 943 /* For backward compatibility, should be removed in the future. */ 944 input_format_tmp = format_from_name (optarg, 0); 945 if (input_format_tmp != RES_FORMAT_UNKNOWN) 946 { 947 struct stat statbuf; 948 char modebuf[11]; 949 950 if (stat (optarg, & statbuf) == 0 951 /* Coded this way to avoid importing knowledge of S_ISDIR into this file. */ 952 && (mode_string (statbuf.st_mode, modebuf), modebuf[0] == 'd')) 953 /* We have a -I option with a directory name that just happens 954 to match a format name as well. eg: -I res Assume that the 955 user knows what they are doing and do not complain. */ 956 ; 957 else 958 { 959 fprintf (stderr, 960 _("Option -I is deprecated for setting the input format, please use -J instead.\n")); 961 input_format = input_format_tmp; 962 break; 963 } 964 } 965 /* Fall through. */ 966 967 case OPTION_INCLUDE_DIR: 968 if (preprocargs == NULL) 969 { 970 quotedarg = quot (optarg); 971 preprocargs = xmalloc (strlen (quotedarg) + 3); 972 sprintf (preprocargs, "-I%s", quotedarg); 973 } 974 else 975 { 976 char *n; 977 978 quotedarg = quot (optarg); 979 n = xmalloc (strlen (preprocargs) + strlen (quotedarg) + 4); 980 sprintf (n, "%s -I%s", preprocargs, quotedarg); 981 free (preprocargs); 982 preprocargs = n; 983 } 984 985 windres_add_include_dir (optarg); 986 987 break; 988 989 case 'l': 990 language = strtol (optarg, (char **) NULL, 16); 991 break; 992 993 case OPTION_USE_TEMP_FILE: 994 use_temp_file = 1; 995 break; 996 997 case OPTION_NO_USE_TEMP_FILE: 998 use_temp_file = 0; 999 break; 1000 1001 #ifdef YYDEBUG 1002 case OPTION_YYDEBUG: 1003 yydebug = 1; 1004 break; 1005 #endif 1006 1007 case 'h': 1008 case 'H': 1009 usage (stdout, 0); 1010 break; 1011 1012 case 'V': 1013 print_version ("windres"); 1014 break; 1015 1016 default: 1017 usage (stderr, 1); 1018 break; 1019 } 1020 } 1021 1022 if (input_filename == NULL && optind < argc) 1023 { 1024 input_filename = argv[optind]; 1025 ++optind; 1026 } 1027 1028 if (output_filename == NULL && optind < argc) 1029 { 1030 output_filename = argv[optind]; 1031 ++optind; 1032 } 1033 1034 if (argc != optind) 1035 usage (stderr, 1); 1036 1037 if (input_format == RES_FORMAT_UNKNOWN) 1038 { 1039 if (input_filename == NULL) 1040 input_format = RES_FORMAT_RC; 1041 else 1042 input_format = format_from_filename (input_filename, 1); 1043 } 1044 1045 if (output_format == RES_FORMAT_UNKNOWN) 1046 { 1047 if (output_filename == NULL) 1048 output_format = RES_FORMAT_RC; 1049 else 1050 output_format = format_from_filename (output_filename, 0); 1051 } 1052 1053 set_endianness (NULL, target); 1054 1055 /* Read the input file. */ 1056 switch (input_format) 1057 { 1058 default: 1059 abort (); 1060 case RES_FORMAT_RC: 1061 resources = read_rc_file (input_filename, preprocessor, preprocargs, 1062 language, use_temp_file); 1063 break; 1064 case RES_FORMAT_RES: 1065 resources = read_res_file (input_filename); 1066 break; 1067 case RES_FORMAT_COFF: 1068 resources = read_coff_rsrc (input_filename, target); 1069 break; 1070 } 1071 1072 if (resources == NULL) 1073 fatal (_("no resources")); 1074 1075 /* Sort the resources. This is required for COFF, convenient for 1076 rc, and unimportant for res. */ 1077 resources = sort_resources (resources); 1078 1079 /* Write the output file. */ 1080 reswr_init (); 1081 1082 switch (output_format) 1083 { 1084 default: 1085 abort (); 1086 case RES_FORMAT_RC: 1087 write_rc_file (output_filename, resources); 1088 break; 1089 case RES_FORMAT_RES: 1090 write_res_file (output_filename, resources); 1091 break; 1092 case RES_FORMAT_COFF: 1093 write_coff_file (output_filename, target, resources); 1094 break; 1095 } 1096 1097 xexit (0); 1098 return 0; 1099 } 1100 1101 static void 1102 set_endianness (bfd *abfd, const char *target) 1103 { 1104 const bfd_target *target_vec; 1105 1106 def_target_arch = NULL; 1107 target_vec = bfd_get_target_info (target, abfd, &target_is_bigendian, NULL, 1108 &def_target_arch); 1109 if (! target_vec) 1110 fatal ("Can't detect target endianness and architecture."); 1111 if (! def_target_arch) 1112 fatal ("Can't detect architecture."); 1113 } 1114 1115 bfd * 1116 windres_open_as_binary (const char *filename, int rdmode) 1117 { 1118 bfd *abfd; 1119 1120 abfd = (rdmode ? bfd_openr (filename, "binary") : bfd_openw (filename, "binary")); 1121 if (! abfd) 1122 fatal ("can't open `%s' for %s", filename, (rdmode ? "input" : "output")); 1123 1124 if (rdmode && ! bfd_check_format (abfd, bfd_object)) 1125 fatal ("can't open `%s' for input.", filename); 1126 1127 return abfd; 1128 } 1129 1130 void 1131 set_windres_bfd_endianness (windres_bfd *wrbfd, int is_bigendian) 1132 { 1133 assert (!! wrbfd); 1134 switch (WR_KIND(wrbfd)) 1135 { 1136 case WR_KIND_BFD_BIN_L: 1137 if (is_bigendian) 1138 WR_KIND(wrbfd) = WR_KIND_BFD_BIN_B; 1139 break; 1140 case WR_KIND_BFD_BIN_B: 1141 if (! is_bigendian) 1142 WR_KIND(wrbfd) = WR_KIND_BFD_BIN_L; 1143 break; 1144 default: 1145 /* only binary bfd can be overriden. */ 1146 abort (); 1147 } 1148 } 1149 1150 void 1151 set_windres_bfd (windres_bfd *wrbfd, bfd *abfd, asection *sec, rc_uint_type kind) 1152 { 1153 assert (!! wrbfd); 1154 switch (kind) 1155 { 1156 case WR_KIND_TARGET: 1157 abfd = NULL; 1158 sec = NULL; 1159 break; 1160 case WR_KIND_BFD: 1161 case WR_KIND_BFD_BIN_L: 1162 case WR_KIND_BFD_BIN_B: 1163 assert (!! abfd); 1164 assert (!!sec); 1165 break; 1166 default: 1167 abort (); 1168 } 1169 WR_KIND(wrbfd) = kind; 1170 WR_BFD(wrbfd) = abfd; 1171 WR_SECTION(wrbfd) = sec; 1172 } 1173 1174 void 1175 set_windres_bfd_content (windres_bfd *wrbfd, const void *data, rc_uint_type off, 1176 rc_uint_type length) 1177 { 1178 if (WR_KIND(wrbfd) != WR_KIND_TARGET) 1179 { 1180 if (! bfd_set_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length)) 1181 bfd_fatal ("bfd_set_section_contents"); 1182 } 1183 else 1184 abort (); 1185 } 1186 1187 void 1188 get_windres_bfd_content (windres_bfd *wrbfd, void *data, rc_uint_type off, 1189 rc_uint_type length) 1190 { 1191 if (WR_KIND(wrbfd) != WR_KIND_TARGET) 1192 { 1193 if (! bfd_get_section_contents (WR_BFD(wrbfd), WR_SECTION(wrbfd), data, off, length)) 1194 bfd_fatal ("bfd_get_section_contents"); 1195 } 1196 else 1197 abort (); 1198 } 1199 1200 void 1201 windres_put_8 (windres_bfd *wrbfd, void *p, rc_uint_type value) 1202 { 1203 switch (WR_KIND(wrbfd)) 1204 { 1205 case WR_KIND_TARGET: 1206 target_put_8 (p, value); 1207 break; 1208 case WR_KIND_BFD: 1209 case WR_KIND_BFD_BIN_L: 1210 case WR_KIND_BFD_BIN_B: 1211 bfd_put_8 (WR_BFD(wrbfd), value, p); 1212 break; 1213 default: 1214 abort (); 1215 } 1216 } 1217 1218 void 1219 windres_put_16 (windres_bfd *wrbfd, void *data, rc_uint_type value) 1220 { 1221 switch (WR_KIND(wrbfd)) 1222 { 1223 case WR_KIND_TARGET: 1224 target_put_16 (data, value); 1225 break; 1226 case WR_KIND_BFD: 1227 case WR_KIND_BFD_BIN_B: 1228 bfd_put_16 (WR_BFD(wrbfd), value, data); 1229 break; 1230 case WR_KIND_BFD_BIN_L: 1231 bfd_putl16 (value, data); 1232 break; 1233 default: 1234 abort (); 1235 } 1236 } 1237 1238 void 1239 windres_put_32 (windres_bfd *wrbfd, void *data, rc_uint_type value) 1240 { 1241 switch (WR_KIND(wrbfd)) 1242 { 1243 case WR_KIND_TARGET: 1244 target_put_32 (data, value); 1245 break; 1246 case WR_KIND_BFD: 1247 case WR_KIND_BFD_BIN_B: 1248 bfd_put_32 (WR_BFD(wrbfd), value, data); 1249 break; 1250 case WR_KIND_BFD_BIN_L: 1251 bfd_putl32 (value, data); 1252 break; 1253 default: 1254 abort (); 1255 } 1256 } 1257 1258 rc_uint_type 1259 windres_get_8 (windres_bfd *wrbfd, const void *data, rc_uint_type length) 1260 { 1261 if (length < 1) 1262 fatal ("windres_get_8: unexpected eob."); 1263 switch (WR_KIND(wrbfd)) 1264 { 1265 case WR_KIND_TARGET: 1266 return target_get_8 (data, length); 1267 case WR_KIND_BFD: 1268 case WR_KIND_BFD_BIN_B: 1269 case WR_KIND_BFD_BIN_L: 1270 return bfd_get_8 (WR_BFD(wrbfd), data); 1271 default: 1272 abort (); 1273 } 1274 return 0; 1275 } 1276 1277 rc_uint_type 1278 windres_get_16 (windres_bfd *wrbfd, const void *data, rc_uint_type length) 1279 { 1280 if (length < 2) 1281 fatal ("windres_get_16: unexpected eob."); 1282 switch (WR_KIND(wrbfd)) 1283 { 1284 case WR_KIND_TARGET: 1285 return target_get_16 (data, length); 1286 case WR_KIND_BFD: 1287 case WR_KIND_BFD_BIN_B: 1288 return bfd_get_16 (WR_BFD(wrbfd), data); 1289 case WR_KIND_BFD_BIN_L: 1290 return bfd_getl16 (data); 1291 default: 1292 abort (); 1293 } 1294 return 0; 1295 } 1296 1297 rc_uint_type 1298 windres_get_32 (windres_bfd *wrbfd, const void *data, rc_uint_type length) 1299 { 1300 if (length < 4) 1301 fatal ("windres_get_32: unexpected eob."); 1302 switch (WR_KIND(wrbfd)) 1303 { 1304 case WR_KIND_TARGET: 1305 return target_get_32 (data, length); 1306 case WR_KIND_BFD: 1307 case WR_KIND_BFD_BIN_B: 1308 return bfd_get_32 (WR_BFD(wrbfd), data); 1309 case WR_KIND_BFD_BIN_L: 1310 return bfd_getl32 (data); 1311 default: 1312 abort (); 1313 } 1314 return 0; 1315 } 1316 1317 static rc_uint_type 1318 target_get_8 (const void *p, rc_uint_type length) 1319 { 1320 rc_uint_type ret; 1321 1322 if (length < 1) 1323 fatal ("Resource too small for getting 8-bit value."); 1324 1325 ret = (rc_uint_type) *((const bfd_byte *) p); 1326 return ret & 0xff; 1327 } 1328 1329 static rc_uint_type 1330 target_get_16 (const void *p, rc_uint_type length) 1331 { 1332 if (length < 2) 1333 fatal ("Resource too small for getting 16-bit value."); 1334 1335 if (target_is_bigendian) 1336 return bfd_getb16 (p); 1337 else 1338 return bfd_getl16 (p); 1339 } 1340 1341 static rc_uint_type 1342 target_get_32 (const void *p, rc_uint_type length) 1343 { 1344 if (length < 4) 1345 fatal ("Resource too small for getting 32-bit value."); 1346 1347 if (target_is_bigendian) 1348 return bfd_getb32 (p); 1349 else 1350 return bfd_getl32 (p); 1351 } 1352 1353 static void 1354 target_put_8 (void *p, rc_uint_type value) 1355 { 1356 assert (!! p); 1357 *((bfd_byte *) p)=(bfd_byte) value; 1358 } 1359 1360 static void 1361 target_put_16 (void *p, rc_uint_type value) 1362 { 1363 assert (!! p); 1364 1365 if (target_is_bigendian) 1366 bfd_putb16 (value, p); 1367 else 1368 bfd_putl16 (value, p); 1369 } 1370 1371 static void 1372 target_put_32 (void *p, rc_uint_type value) 1373 { 1374 assert (!! p); 1375 1376 if (target_is_bigendian) 1377 bfd_putb32 (value, p); 1378 else 1379 bfd_putl32 (value, p); 1380 } 1381 1382 static int isInComment = 0; 1383 1384 int wr_printcomment (FILE *e, const char *fmt, ...) 1385 { 1386 va_list arg; 1387 int r = 0; 1388 1389 if (isInComment) 1390 r += fprintf (e, "\n "); 1391 else 1392 fprintf (e, "/* "); 1393 isInComment = 1; 1394 if (fmt == NULL) 1395 return r; 1396 va_start (arg, fmt); 1397 r += vfprintf (e, fmt, arg); 1398 va_end (arg); 1399 return r; 1400 } 1401 1402 int wr_print (FILE *e, const char *fmt, ...) 1403 { 1404 va_list arg; 1405 int r = 0; 1406 if (isInComment) 1407 r += fprintf (e, ". */\n"); 1408 isInComment = 0; 1409 if (! fmt) 1410 return r; 1411 va_start (arg, fmt); 1412 r += vfprintf (e, fmt, arg); 1413 va_end (arg); 1414 return r; 1415 } 1416