1 /* resrc.c -- read and write Windows rc files. 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 file contains functions that read and write Windows rc files. 24 These are text files that represent resources. */ 25 26 #include "sysdep.h" 27 #include "bfd.h" 28 #include "bucomm.h" 29 #include "libiberty.h" 30 #include "safe-ctype.h" 31 #include "windres.h" 32 33 #include <assert.h> 34 35 #ifdef HAVE_SYS_WAIT_H 36 #include <sys/wait.h> 37 #else /* ! HAVE_SYS_WAIT_H */ 38 #if ! defined (_WIN32) || defined (__CYGWIN__) 39 #ifndef WIFEXITED 40 #define WIFEXITED(w) (((w)&0377) == 0) 41 #endif 42 #ifndef WIFSIGNALED 43 #define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0) 44 #endif 45 #ifndef WTERMSIG 46 #define WTERMSIG(w) ((w) & 0177) 47 #endif 48 #ifndef WEXITSTATUS 49 #define WEXITSTATUS(w) (((w) >> 8) & 0377) 50 #endif 51 #else /* defined (_WIN32) && ! defined (__CYGWIN__) */ 52 #ifndef WIFEXITED 53 #define WIFEXITED(w) (((w) & 0xff) == 0) 54 #endif 55 #ifndef WIFSIGNALED 56 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f) 57 #endif 58 #ifndef WTERMSIG 59 #define WTERMSIG(w) ((w) & 0x7f) 60 #endif 61 #ifndef WEXITSTATUS 62 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8) 63 #endif 64 #endif /* defined (_WIN32) && ! defined (__CYGWIN__) */ 65 #endif /* ! HAVE_SYS_WAIT_H */ 66 67 #ifndef STDOUT_FILENO 68 #define STDOUT_FILENO 1 69 #endif 70 71 #if defined (_WIN32) && ! defined (__CYGWIN__) 72 #define popen _popen 73 #define pclose _pclose 74 #endif 75 76 /* The default preprocessor. */ 77 78 #define DEFAULT_PREPROCESSOR_CMD "gcc" 79 #define DEFAULT_PREPROCESSOR_ARGS "-E -xc -DRC_INVOKED" 80 81 /* We read the directory entries in a cursor or icon file into 82 instances of this structure. */ 83 84 struct icondir 85 { 86 /* Width of image. */ 87 bfd_byte width; 88 /* Height of image. */ 89 bfd_byte height; 90 /* Number of colors in image. */ 91 bfd_byte colorcount; 92 union 93 { 94 struct 95 { 96 /* Color planes. */ 97 unsigned short planes; 98 /* Bits per pixel. */ 99 unsigned short bits; 100 } icon; 101 struct 102 { 103 /* X coordinate of hotspot. */ 104 unsigned short xhotspot; 105 /* Y coordinate of hotspot. */ 106 unsigned short yhotspot; 107 } cursor; 108 } u; 109 /* Bytes in image. */ 110 unsigned long bytes; 111 /* File offset of image. */ 112 unsigned long offset; 113 }; 114 115 /* The name of the rc file we are reading. */ 116 117 char *rc_filename; 118 119 /* The line number in the rc file. */ 120 121 int rc_lineno; 122 123 /* The pipe we are reading from, so that we can close it if we exit. */ 124 125 FILE *cpp_pipe; 126 127 /* The temporary file used if we're not using popen, so we can delete it 128 if we exit. */ 129 130 static char *cpp_temp_file; 131 132 /* Input stream is either a file or a pipe. */ 133 134 static enum {ISTREAM_PIPE, ISTREAM_FILE} istream_type; 135 136 /* As we read the rc file, we attach information to this structure. */ 137 138 static rc_res_directory *resources; 139 140 /* The number of cursor resources we have written out. */ 141 142 static int cursors; 143 144 /* The number of font resources we have written out. */ 145 146 static int fonts; 147 148 /* Font directory information. */ 149 150 rc_fontdir *fontdirs; 151 152 /* Resource info to use for fontdirs. */ 153 154 rc_res_res_info fontdirs_resinfo; 155 156 /* The number of icon resources we have written out. */ 157 158 static int icons; 159 160 /* The windres target bfd . */ 161 162 static windres_bfd wrtarget = 163 { 164 (bfd *) NULL, (asection *) NULL, WR_KIND_TARGET 165 }; 166 167 /* Local functions for rcdata based resource definitions. */ 168 169 static void define_font_rcdata (rc_res_id, const rc_res_res_info *, 170 rc_rcdata_item *); 171 static void define_icon_rcdata (rc_res_id, const rc_res_res_info *, 172 rc_rcdata_item *); 173 static void define_bitmap_rcdata (rc_res_id, const rc_res_res_info *, 174 rc_rcdata_item *); 175 static void define_cursor_rcdata (rc_res_id, const rc_res_res_info *, 176 rc_rcdata_item *); 177 static void define_fontdir_rcdata (rc_res_id, const rc_res_res_info *, 178 rc_rcdata_item *); 179 static void define_messagetable_rcdata (rc_res_id, const rc_res_res_info *, 180 rc_rcdata_item *); 181 static rc_uint_type rcdata_copy (const rc_rcdata_item *, bfd_byte *); 182 static bfd_byte *rcdata_render_as_buffer (const rc_rcdata_item *, rc_uint_type *); 183 184 static int run_cmd (char *, const char *); 185 static FILE *open_input_stream (char *); 186 static FILE *look_for_default 187 (char *, const char *, int, const char *, const char *); 188 static void close_input_stream (void); 189 static void unexpected_eof (const char *); 190 static int get_word (FILE *, const char *); 191 static unsigned long get_long (FILE *, const char *); 192 static void get_data (FILE *, bfd_byte *, rc_uint_type, const char *); 193 static void define_fontdirs (void); 194 195 /* Run `cmd' and redirect the output to `redir'. */ 196 197 static int 198 run_cmd (char *cmd, const char *redir) 199 { 200 char *s; 201 int pid, wait_status, retcode; 202 int i; 203 const char **argv; 204 char *errmsg_fmt = NULL, *errmsg_arg = NULL; 205 char *temp_base = choose_temp_base (); 206 int in_quote; 207 char sep; 208 int redir_handle = -1; 209 int stdout_save = -1; 210 211 /* Count the args. */ 212 i = 0; 213 214 for (s = cmd; *s; s++) 215 if (*s == ' ') 216 i++; 217 218 i++; 219 argv = xmalloc (sizeof (char *) * (i + 3)); 220 i = 0; 221 s = cmd; 222 223 while (1) 224 { 225 while (*s == ' ' && *s != 0) 226 s++; 227 228 if (*s == 0) 229 break; 230 231 in_quote = (*s == '\'' || *s == '"'); 232 sep = (in_quote) ? *s++ : ' '; 233 argv[i++] = s; 234 235 while (*s != sep && *s != 0) 236 s++; 237 238 if (*s == 0) 239 break; 240 241 *s++ = 0; 242 243 if (in_quote) 244 s++; 245 } 246 argv[i++] = NULL; 247 248 /* Setup the redirection. We can't use the usual fork/exec and redirect 249 since we may be running on non-POSIX Windows host. */ 250 251 fflush (stdout); 252 fflush (stderr); 253 254 /* Open temporary output file. */ 255 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT, 0666); 256 if (redir_handle == -1) 257 fatal (_("can't open temporary file `%s': %s"), redir, 258 strerror (errno)); 259 260 /* Duplicate the stdout file handle so it can be restored later. */ 261 stdout_save = dup (STDOUT_FILENO); 262 if (stdout_save == -1) 263 fatal (_("can't redirect stdout: `%s': %s"), redir, strerror (errno)); 264 265 /* Redirect stdout to our output file. */ 266 dup2 (redir_handle, STDOUT_FILENO); 267 268 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base, 269 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH); 270 free (argv); 271 272 /* Restore stdout to its previous setting. */ 273 dup2 (stdout_save, STDOUT_FILENO); 274 275 /* Close response file. */ 276 close (redir_handle); 277 278 if (pid == -1) 279 { 280 fatal ("%s %s: %s", errmsg_fmt, errmsg_arg, strerror (errno)); 281 return 1; 282 } 283 284 retcode = 0; 285 pid = pwait (pid, &wait_status, 0); 286 287 if (pid == -1) 288 { 289 fatal (_("wait: %s"), strerror (errno)); 290 retcode = 1; 291 } 292 else if (WIFSIGNALED (wait_status)) 293 { 294 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status)); 295 retcode = 1; 296 } 297 else if (WIFEXITED (wait_status)) 298 { 299 if (WEXITSTATUS (wait_status) != 0) 300 { 301 fatal (_("%s exited with status %d"), cmd, 302 WEXITSTATUS (wait_status)); 303 retcode = 1; 304 } 305 } 306 else 307 retcode = 1; 308 309 return retcode; 310 } 311 312 static FILE * 313 open_input_stream (char *cmd) 314 { 315 if (istream_type == ISTREAM_FILE) 316 { 317 char *fileprefix; 318 319 fileprefix = choose_temp_base (); 320 cpp_temp_file = (char *) xmalloc (strlen (fileprefix) + 5); 321 sprintf (cpp_temp_file, "%s.irc", fileprefix); 322 free (fileprefix); 323 324 if (run_cmd (cmd, cpp_temp_file)) 325 fatal (_("can't execute `%s': %s"), cmd, strerror (errno)); 326 327 cpp_pipe = fopen (cpp_temp_file, FOPEN_RT); 328 if (cpp_pipe == NULL) 329 fatal (_("can't open temporary file `%s': %s"), 330 cpp_temp_file, strerror (errno)); 331 332 if (verbose) 333 fprintf (stderr, 334 _("Using temporary file `%s' to read preprocessor output\n"), 335 cpp_temp_file); 336 } 337 else 338 { 339 cpp_pipe = popen (cmd, FOPEN_RT); 340 if (cpp_pipe == NULL) 341 fatal (_("can't popen `%s': %s"), cmd, strerror (errno)); 342 if (verbose) 343 fprintf (stderr, _("Using popen to read preprocessor output\n")); 344 } 345 346 xatexit (close_input_stream); 347 return cpp_pipe; 348 } 349 350 /* Determine if FILENAME contains special characters that 351 can cause problems unless the entire filename is quoted. */ 352 353 static int 354 filename_need_quotes (const char *filename) 355 { 356 if (filename == NULL || (filename[0] == '-' && filename[1] == 0)) 357 return 0; 358 359 while (*filename != 0) 360 { 361 switch (*filename) 362 { 363 case '&': 364 case ' ': 365 case '<': 366 case '>': 367 case '|': 368 case '%': 369 return 1; 370 } 371 ++filename; 372 } 373 return 0; 374 } 375 376 /* Look for the preprocessor program. */ 377 378 static FILE * 379 look_for_default (char *cmd, const char *prefix, int end_prefix, 380 const char *preprocargs, const char *filename) 381 { 382 int found; 383 struct stat s; 384 const char *fnquotes = (filename_need_quotes (filename) ? "\"" : ""); 385 386 strcpy (cmd, prefix); 387 388 sprintf (cmd + end_prefix, "%s", DEFAULT_PREPROCESSOR_CMD); 389 390 if ( 391 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32) 392 strchr (cmd, '\\') || 393 #endif 394 strchr (cmd, '/')) 395 { 396 found = (stat (cmd, &s) == 0 397 #ifdef HAVE_EXECUTABLE_SUFFIX 398 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0 399 #endif 400 ); 401 402 if (! found) 403 { 404 if (verbose) 405 fprintf (stderr, _("Tried `%s'\n"), cmd); 406 return NULL; 407 } 408 } 409 410 if (filename_need_quotes (cmd)) 411 { 412 char *cmd_copy = xmalloc (strlen (cmd)); 413 strcpy (cmd_copy, cmd); 414 sprintf (cmd, "\"%s\"", cmd_copy); 415 free (cmd_copy); 416 } 417 418 sprintf (cmd + strlen (cmd), " %s %s %s%s%s", 419 DEFAULT_PREPROCESSOR_ARGS, preprocargs, fnquotes, filename, fnquotes); 420 421 if (verbose) 422 fprintf (stderr, _("Using `%s'\n"), cmd); 423 424 cpp_pipe = open_input_stream (cmd); 425 return cpp_pipe; 426 } 427 428 /* Read an rc file. */ 429 430 rc_res_directory * 431 read_rc_file (const char *filename, const char *preprocessor, 432 const char *preprocargs, int language, int use_temp_file) 433 { 434 char *cmd; 435 const char *fnquotes = (filename_need_quotes (filename) ? "\"" : ""); 436 437 if (filename == NULL) 438 filename = "-"; 439 /* Setup the default resource import path taken from input file. */ 440 else if (strchr (filename, '/') != NULL || strchr (filename, '\\') != NULL) 441 { 442 char *edit, *dir; 443 444 if (filename[0] == '/' 445 || filename[0] == '\\' 446 || filename[1] == ':') 447 /* Absolute path. */ 448 edit = dir = xstrdup (filename); 449 else 450 { 451 /* Relative path. */ 452 edit = dir = xmalloc (strlen (filename) + 3); 453 sprintf (dir, "./%s", filename); 454 } 455 456 /* Walk dir backwards stopping at the first directory separator. */ 457 edit += strlen (dir); 458 while (edit > dir && (edit[-1] != '\\' && edit[-1] != '/')) 459 { 460 --edit; 461 edit[0] = 0; 462 } 463 464 /* Cut off trailing slash. */ 465 --edit; 466 edit[0] = 0; 467 468 /* Convert all back slashes to forward slashes. */ 469 while ((edit = strchr (dir, '\\')) != NULL) 470 *edit = '/'; 471 472 windres_add_include_dir (dir); 473 } 474 475 istream_type = (use_temp_file) ? ISTREAM_FILE : ISTREAM_PIPE; 476 477 if (preprocargs == NULL) 478 preprocargs = ""; 479 480 if (preprocessor) 481 { 482 cmd = xmalloc (strlen (preprocessor) 483 + strlen (preprocargs) 484 + strlen (filename) 485 + strlen (fnquotes) * 2 486 + 10); 487 sprintf (cmd, "%s %s %s%s%s", preprocessor, preprocargs, 488 fnquotes, filename, fnquotes); 489 490 cpp_pipe = open_input_stream (cmd); 491 } 492 else 493 { 494 char *dash, *slash, *cp; 495 496 cmd = xmalloc (strlen (program_name) 497 + strlen (DEFAULT_PREPROCESSOR_CMD) 498 + strlen (DEFAULT_PREPROCESSOR_ARGS) 499 + strlen (preprocargs) 500 + strlen (filename) 501 + strlen (fnquotes) * 2 502 #ifdef HAVE_EXECUTABLE_SUFFIX 503 + strlen (EXECUTABLE_SUFFIX) 504 #endif 505 + 10); 506 507 508 dash = slash = 0; 509 for (cp = program_name; *cp; cp++) 510 { 511 if (*cp == '-') 512 dash = cp; 513 if ( 514 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32) 515 *cp == ':' || *cp == '\\' || 516 #endif 517 *cp == '/') 518 { 519 slash = cp; 520 dash = 0; 521 } 522 } 523 524 cpp_pipe = 0; 525 526 if (dash) 527 { 528 /* First, try looking for a prefixed gcc in the windres 529 directory, with the same prefix as windres */ 530 531 cpp_pipe = look_for_default (cmd, program_name, dash - program_name + 1, 532 preprocargs, filename); 533 } 534 535 if (slash && ! cpp_pipe) 536 { 537 /* Next, try looking for a gcc in the same directory as 538 that windres */ 539 540 cpp_pipe = look_for_default (cmd, program_name, slash - program_name + 1, 541 preprocargs, filename); 542 } 543 544 if (! cpp_pipe) 545 { 546 /* Sigh, try the default */ 547 548 cpp_pipe = look_for_default (cmd, "", 0, preprocargs, filename); 549 } 550 551 } 552 553 free (cmd); 554 555 rc_filename = xstrdup (filename); 556 rc_lineno = 1; 557 if (language != -1) 558 rcparse_set_language (language); 559 yyparse (); 560 rcparse_discard_strings (); 561 562 close_input_stream (); 563 564 if (fontdirs != NULL) 565 define_fontdirs (); 566 567 free (rc_filename); 568 rc_filename = NULL; 569 570 return resources; 571 } 572 573 /* Close the input stream if it is open. */ 574 575 static void 576 close_input_stream (void) 577 { 578 if (istream_type == ISTREAM_FILE) 579 { 580 if (cpp_pipe != NULL) 581 fclose (cpp_pipe); 582 583 if (cpp_temp_file != NULL) 584 { 585 int errno_save = errno; 586 587 unlink (cpp_temp_file); 588 errno = errno_save; 589 free (cpp_temp_file); 590 } 591 } 592 else 593 { 594 if (cpp_pipe != NULL) 595 { 596 int err; 597 err = pclose (cpp_pipe); 598 /* We are reading from a pipe, therefore we don't 599 know if cpp failed or succeeded until pclose. */ 600 if (err != 0 || errno == ECHILD) 601 { 602 /* Since this is also run via xatexit, safeguard. */ 603 cpp_pipe = NULL; 604 cpp_temp_file = NULL; 605 fatal (_("preprocessing failed.")); 606 } 607 } 608 } 609 610 /* Since this is also run via xatexit, safeguard. */ 611 cpp_pipe = NULL; 612 cpp_temp_file = NULL; 613 } 614 615 /* Report an error while reading an rc file. */ 616 617 void 618 yyerror (const char *msg) 619 { 620 fatal ("%s:%d: %s", rc_filename, rc_lineno, msg); 621 } 622 623 /* Issue a warning while reading an rc file. */ 624 625 void 626 rcparse_warning (const char *msg) 627 { 628 fprintf (stderr, "%s:%d: %s\n", rc_filename, rc_lineno, msg); 629 } 630 631 /* Die if we get an unexpected end of file. */ 632 633 static void 634 unexpected_eof (const char *msg) 635 { 636 fatal (_("%s: unexpected EOF"), msg); 637 } 638 639 /* Read a 16 bit word from a file. The data is assumed to be little 640 endian. */ 641 642 static int 643 get_word (FILE *e, const char *msg) 644 { 645 int b1, b2; 646 647 b1 = getc (e); 648 b2 = getc (e); 649 if (feof (e)) 650 unexpected_eof (msg); 651 return ((b2 & 0xff) << 8) | (b1 & 0xff); 652 } 653 654 /* Read a 32 bit word from a file. The data is assumed to be little 655 endian. */ 656 657 static unsigned long 658 get_long (FILE *e, const char *msg) 659 { 660 int b1, b2, b3, b4; 661 662 b1 = getc (e); 663 b2 = getc (e); 664 b3 = getc (e); 665 b4 = getc (e); 666 if (feof (e)) 667 unexpected_eof (msg); 668 return (((((((b4 & 0xff) << 8) 669 | (b3 & 0xff)) << 8) 670 | (b2 & 0xff)) << 8) 671 | (b1 & 0xff)); 672 } 673 674 /* Read data from a file. This is a wrapper to do error checking. */ 675 676 static void 677 get_data (FILE *e, bfd_byte *p, rc_uint_type c, const char *msg) 678 { 679 rc_uint_type got; /* $$$d */ 680 681 got = (rc_uint_type) fread (p, 1, c, e); 682 if (got == c) 683 return; 684 685 fatal (_("%s: read of %lu returned %lu"), 686 msg, (unsigned long) c, (unsigned long) got); 687 } 688 689 /* Define an accelerator resource. */ 690 691 void 692 define_accelerator (rc_res_id id, const rc_res_res_info *resinfo, 693 rc_accelerator *data) 694 { 695 rc_res_resource *r; 696 697 r = define_standard_resource (&resources, RT_ACCELERATOR, id, 698 resinfo->language, 0); 699 r->type = RES_TYPE_ACCELERATOR; 700 r->u.acc = data; 701 r->res_info = *resinfo; 702 } 703 704 /* Define a bitmap resource. Bitmap data is stored in a file. The 705 first 14 bytes of the file are a standard header, which is not 706 included in the resource data. */ 707 708 #define BITMAP_SKIP (14) 709 710 void 711 define_bitmap (rc_res_id id, const rc_res_res_info *resinfo, 712 const char *filename) 713 { 714 FILE *e; 715 char *real_filename; 716 struct stat s; 717 bfd_byte *data; 718 rc_uint_type i; 719 rc_res_resource *r; 720 721 e = open_file_search (filename, FOPEN_RB, "bitmap file", &real_filename); 722 723 if (stat (real_filename, &s) < 0) 724 fatal (_("stat failed on bitmap file `%s': %s"), real_filename, 725 strerror (errno)); 726 727 data = (bfd_byte *) res_alloc (s.st_size - BITMAP_SKIP); 728 729 for (i = 0; i < BITMAP_SKIP; i++) 730 getc (e); 731 732 get_data (e, data, s.st_size - BITMAP_SKIP, real_filename); 733 734 fclose (e); 735 free (real_filename); 736 737 r = define_standard_resource (&resources, RT_BITMAP, id, 738 resinfo->language, 0); 739 740 r->type = RES_TYPE_BITMAP; 741 r->u.data.length = s.st_size - BITMAP_SKIP; 742 r->u.data.data = data; 743 r->res_info = *resinfo; 744 } 745 746 /* Define a cursor resource. A cursor file may contain a set of 747 bitmaps, each representing the same cursor at various different 748 resolutions. They each get written out with a different ID. The 749 real cursor resource is then a group resource which can be used to 750 select one of the actual cursors. */ 751 752 void 753 define_cursor (rc_res_id id, const rc_res_res_info *resinfo, 754 const char *filename) 755 { 756 FILE *e; 757 char *real_filename; 758 int type, count, i; 759 struct icondir *icondirs; 760 int first_cursor; 761 rc_res_resource *r; 762 rc_group_cursor *first, **pp; 763 764 e = open_file_search (filename, FOPEN_RB, "cursor file", &real_filename); 765 766 /* A cursor file is basically an icon file. The start of the file 767 is a three word structure. The first word is ignored. The 768 second word is the type of data. The third word is the number of 769 entries. */ 770 771 get_word (e, real_filename); 772 type = get_word (e, real_filename); 773 count = get_word (e, real_filename); 774 if (type != 2) 775 fatal (_("cursor file `%s' does not contain cursor data"), real_filename); 776 777 /* Read in the icon directory entries. */ 778 779 icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs); 780 781 for (i = 0; i < count; i++) 782 { 783 icondirs[i].width = getc (e); 784 icondirs[i].height = getc (e); 785 icondirs[i].colorcount = getc (e); 786 getc (e); 787 icondirs[i].u.cursor.xhotspot = get_word (e, real_filename); 788 icondirs[i].u.cursor.yhotspot = get_word (e, real_filename); 789 icondirs[i].bytes = get_long (e, real_filename); 790 icondirs[i].offset = get_long (e, real_filename); 791 792 if (feof (e)) 793 unexpected_eof (real_filename); 794 } 795 796 /* Define each cursor as a unique resource. */ 797 798 first_cursor = cursors; 799 800 for (i = 0; i < count; i++) 801 { 802 bfd_byte *data; 803 rc_res_id name; 804 rc_cursor *c; 805 806 if (fseek (e, icondirs[i].offset, SEEK_SET) != 0) 807 fatal (_("%s: fseek to %lu failed: %s"), real_filename, 808 icondirs[i].offset, strerror (errno)); 809 810 data = (bfd_byte *) res_alloc (icondirs[i].bytes); 811 812 get_data (e, data, icondirs[i].bytes, real_filename); 813 814 c = (rc_cursor *) res_alloc (sizeof (rc_cursor)); 815 c->xhotspot = icondirs[i].u.cursor.xhotspot; 816 c->yhotspot = icondirs[i].u.cursor.yhotspot; 817 c->length = icondirs[i].bytes; 818 c->data = data; 819 820 ++cursors; 821 822 name.named = 0; 823 name.u.id = cursors; 824 825 r = define_standard_resource (&resources, RT_CURSOR, name, 826 resinfo->language, 0); 827 r->type = RES_TYPE_CURSOR; 828 r->u.cursor = c; 829 r->res_info = *resinfo; 830 } 831 832 fclose (e); 833 free (real_filename); 834 835 /* Define a cursor group resource. */ 836 837 first = NULL; 838 pp = &first; 839 for (i = 0; i < count; i++) 840 { 841 rc_group_cursor *cg; 842 843 cg = (rc_group_cursor *) res_alloc (sizeof (rc_group_cursor)); 844 cg->next = NULL; 845 cg->width = icondirs[i].width; 846 cg->height = 2 * icondirs[i].height; 847 848 /* FIXME: What should these be set to? */ 849 cg->planes = 1; 850 cg->bits = 1; 851 852 cg->bytes = icondirs[i].bytes + 4; 853 cg->index = first_cursor + i + 1; 854 855 *pp = cg; 856 pp = &(*pp)->next; 857 } 858 859 free (icondirs); 860 861 r = define_standard_resource (&resources, RT_GROUP_CURSOR, id, 862 resinfo->language, 0); 863 r->type = RES_TYPE_GROUP_CURSOR; 864 r->u.group_cursor = first; 865 r->res_info = *resinfo; 866 } 867 868 /* Define a dialog resource. */ 869 870 void 871 define_dialog (rc_res_id id, const rc_res_res_info *resinfo, 872 const rc_dialog *dialog) 873 { 874 rc_dialog *copy; 875 rc_res_resource *r; 876 877 copy = (rc_dialog *) res_alloc (sizeof *copy); 878 *copy = *dialog; 879 880 r = define_standard_resource (&resources, RT_DIALOG, id, 881 resinfo->language, 0); 882 r->type = RES_TYPE_DIALOG; 883 r->u.dialog = copy; 884 r->res_info = *resinfo; 885 } 886 887 /* Define a dialog control. This does not define a resource, but 888 merely allocates and fills in a structure. */ 889 890 rc_dialog_control * 891 define_control (const rc_res_id iid, rc_uint_type id, rc_uint_type x, 892 rc_uint_type y, rc_uint_type width, rc_uint_type height, 893 const rc_res_id class, rc_uint_type style, 894 rc_uint_type exstyle) 895 { 896 rc_dialog_control *n; 897 898 n = (rc_dialog_control *) res_alloc (sizeof (rc_dialog_control)); 899 n->next = NULL; 900 n->id = id; 901 n->style = style; 902 n->exstyle = exstyle; 903 n->x = x; 904 n->y = y; 905 n->width = width; 906 n->height = height; 907 n->class = class; 908 n->text = iid; 909 n->data = NULL; 910 n->help = 0; 911 912 return n; 913 } 914 915 rc_dialog_control * 916 define_icon_control (rc_res_id iid, rc_uint_type id, rc_uint_type x, 917 rc_uint_type y, rc_uint_type style, 918 rc_uint_type exstyle, rc_uint_type help, 919 rc_rcdata_item *data, rc_dialog_ex *ex) 920 { 921 rc_dialog_control *n; 922 rc_res_id tid; 923 rc_res_id cid; 924 925 if (style == 0) 926 style = SS_ICON | WS_CHILD | WS_VISIBLE; 927 res_string_to_id (&tid, ""); 928 cid.named = 0; 929 cid.u.id = CTL_STATIC; 930 n = define_control (tid, id, x, y, 0, 0, cid, style, exstyle); 931 n->text = iid; 932 if (help && ! ex) 933 rcparse_warning (_("help ID requires DIALOGEX")); 934 if (data && ! ex) 935 rcparse_warning (_("control data requires DIALOGEX")); 936 n->help = help; 937 n->data = data; 938 939 return n; 940 } 941 942 /* Define a font resource. */ 943 944 void 945 define_font (rc_res_id id, const rc_res_res_info *resinfo, 946 const char *filename) 947 { 948 FILE *e; 949 char *real_filename; 950 struct stat s; 951 bfd_byte *data; 952 rc_res_resource *r; 953 long offset; 954 long fontdatalength; 955 bfd_byte *fontdata; 956 rc_fontdir *fd; 957 const char *device, *face; 958 rc_fontdir **pp; 959 960 e = open_file_search (filename, FOPEN_RB, "font file", &real_filename); 961 962 if (stat (real_filename, &s) < 0) 963 fatal (_("stat failed on font file `%s': %s"), real_filename, 964 strerror (errno)); 965 966 data = (bfd_byte *) res_alloc (s.st_size); 967 968 get_data (e, data, s.st_size, real_filename); 969 970 fclose (e); 971 free (real_filename); 972 973 r = define_standard_resource (&resources, RT_FONT, id, 974 resinfo->language, 0); 975 976 r->type = RES_TYPE_FONT; 977 r->u.data.length = s.st_size; 978 r->u.data.data = data; 979 r->res_info = *resinfo; 980 981 /* For each font resource, we must add an entry in the FONTDIR 982 resource. The FONTDIR resource includes some strings in the font 983 file. To find them, we have to do some magic on the data we have 984 read. */ 985 986 offset = ((((((data[47] << 8) 987 | data[46]) << 8) 988 | data[45]) << 8) 989 | data[44]); 990 if (offset > 0 && offset < s.st_size) 991 device = (char *) data + offset; 992 else 993 device = ""; 994 995 offset = ((((((data[51] << 8) 996 | data[50]) << 8) 997 | data[49]) << 8) 998 | data[48]); 999 if (offset > 0 && offset < s.st_size) 1000 face = (char *) data + offset; 1001 else 1002 face = ""; 1003 1004 ++fonts; 1005 1006 fontdatalength = 58 + strlen (device) + strlen (face); 1007 fontdata = (bfd_byte *) res_alloc (fontdatalength); 1008 memcpy (fontdata, data, 56); 1009 strcpy ((char *) fontdata + 56, device); 1010 strcpy ((char *) fontdata + 57 + strlen (device), face); 1011 1012 fd = (rc_fontdir *) res_alloc (sizeof (rc_fontdir)); 1013 fd->next = NULL; 1014 fd->index = fonts; 1015 fd->length = fontdatalength; 1016 fd->data = fontdata; 1017 1018 for (pp = &fontdirs; *pp != NULL; pp = &(*pp)->next) 1019 ; 1020 *pp = fd; 1021 1022 /* For the single fontdirs resource, we always use the resource 1023 information of the last font. I don't know what else to do. */ 1024 fontdirs_resinfo = *resinfo; 1025 } 1026 1027 static void 1028 define_font_rcdata (rc_res_id id,const rc_res_res_info *resinfo, 1029 rc_rcdata_item *data) 1030 { 1031 rc_res_resource *r; 1032 rc_uint_type len_data; 1033 bfd_byte *pb_data; 1034 1035 r = define_standard_resource (&resources, RT_FONT, id, 1036 resinfo->language, 0); 1037 1038 pb_data = rcdata_render_as_buffer (data, &len_data); 1039 1040 r->type = RES_TYPE_FONT; 1041 r->u.data.length = len_data; 1042 r->u.data.data = pb_data; 1043 r->res_info = *resinfo; 1044 } 1045 1046 /* Define the fontdirs resource. This is called after the entire rc 1047 file has been parsed, if any font resources were seen. */ 1048 1049 static void 1050 define_fontdirs (void) 1051 { 1052 rc_res_resource *r; 1053 rc_res_id id; 1054 1055 id.named = 0; 1056 id.u.id = 1; 1057 1058 r = define_standard_resource (&resources, RT_FONTDIR, id, 0x409, 0); 1059 1060 r->type = RES_TYPE_FONTDIR; 1061 r->u.fontdir = fontdirs; 1062 r->res_info = fontdirs_resinfo; 1063 } 1064 1065 static bfd_byte * 1066 rcdata_render_as_buffer (const rc_rcdata_item *data, rc_uint_type *plen) 1067 { 1068 const rc_rcdata_item *d; 1069 bfd_byte *ret = NULL, *pret; 1070 rc_uint_type len = 0; 1071 1072 for (d = data; d != NULL; d = d->next) 1073 len += rcdata_copy (d, NULL); 1074 if (len != 0) 1075 { 1076 ret = pret = (bfd_byte *) res_alloc (len); 1077 for (d = data; d != NULL; d = d->next) 1078 pret += rcdata_copy (d, pret); 1079 } 1080 if (plen) 1081 *plen = len; 1082 return ret; 1083 } 1084 1085 static void 1086 define_fontdir_rcdata (rc_res_id id,const rc_res_res_info *resinfo, 1087 rc_rcdata_item *data) 1088 { 1089 rc_res_resource *r; 1090 rc_fontdir *fd, *fd_first, *fd_cur; 1091 rc_uint_type len_data; 1092 bfd_byte *pb_data; 1093 rc_uint_type c; 1094 1095 fd_cur = fd_first = NULL; 1096 r = define_standard_resource (&resources, RT_FONTDIR, id, 0x409, 0); 1097 1098 pb_data = rcdata_render_as_buffer (data, &len_data); 1099 1100 if (pb_data) 1101 { 1102 rc_uint_type off = 2; 1103 c = windres_get_16 (&wrtarget, pb_data, len_data); 1104 for (; c > 0; c--) 1105 { 1106 size_t len; 1107 rc_uint_type safe_pos = off; 1108 const struct bin_fontdir_item *bfi; 1109 1110 bfi = (const struct bin_fontdir_item *) pb_data + off; 1111 fd = (rc_fontdir *) res_alloc (sizeof (rc_fontdir)); 1112 fd->index = windres_get_16 (&wrtarget, bfi->index, len_data - off); 1113 fd->data = pb_data + off; 1114 off += 56; 1115 len = strlen ((char *) bfi->device_name) + 1; 1116 off += (rc_uint_type) len; 1117 off += (rc_uint_type) strlen ((char *) bfi->device_name + len) + 1; 1118 fd->length = (off - safe_pos); 1119 fd->next = NULL; 1120 if (fd_first == NULL) 1121 fd_first = fd; 1122 else 1123 fd_cur->next = fd; 1124 fd_cur = fd; 1125 } 1126 } 1127 r->type = RES_TYPE_FONTDIR; 1128 r->u.fontdir = fd_first; 1129 r->res_info = *resinfo; 1130 } 1131 1132 static void define_messagetable_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1133 rc_rcdata_item *data) 1134 { 1135 rc_res_resource *r; 1136 rc_uint_type len_data; 1137 bfd_byte *pb_data; 1138 1139 r = define_standard_resource (&resources, RT_MESSAGETABLE, id, resinfo->language, 0); 1140 1141 pb_data = rcdata_render_as_buffer (data, &len_data); 1142 r->type = RES_TYPE_MESSAGETABLE; 1143 r->u.data.length = len_data; 1144 r->u.data.data = pb_data; 1145 r->res_info = *resinfo; 1146 } 1147 1148 /* Define an icon resource. An icon file may contain a set of 1149 bitmaps, each representing the same icon at various different 1150 resolutions. They each get written out with a different ID. The 1151 real icon resource is then a group resource which can be used to 1152 select one of the actual icon bitmaps. */ 1153 1154 void 1155 define_icon (rc_res_id id, const rc_res_res_info *resinfo, 1156 const char *filename) 1157 { 1158 FILE *e; 1159 char *real_filename; 1160 int type, count, i; 1161 struct icondir *icondirs; 1162 int first_icon; 1163 rc_res_resource *r; 1164 rc_group_icon *first, **pp; 1165 1166 e = open_file_search (filename, FOPEN_RB, "icon file", &real_filename); 1167 1168 /* The start of an icon file is a three word structure. The first 1169 word is ignored. The second word is the type of data. The third 1170 word is the number of entries. */ 1171 1172 get_word (e, real_filename); 1173 type = get_word (e, real_filename); 1174 count = get_word (e, real_filename); 1175 if (type != 1) 1176 fatal (_("icon file `%s' does not contain icon data"), real_filename); 1177 1178 /* Read in the icon directory entries. */ 1179 1180 icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs); 1181 1182 for (i = 0; i < count; i++) 1183 { 1184 icondirs[i].width = getc (e); 1185 icondirs[i].height = getc (e); 1186 icondirs[i].colorcount = getc (e); 1187 getc (e); 1188 icondirs[i].u.icon.planes = get_word (e, real_filename); 1189 icondirs[i].u.icon.bits = get_word (e, real_filename); 1190 icondirs[i].bytes = get_long (e, real_filename); 1191 icondirs[i].offset = get_long (e, real_filename); 1192 1193 if (feof (e)) 1194 unexpected_eof (real_filename); 1195 } 1196 1197 /* Define each icon as a unique resource. */ 1198 1199 first_icon = icons; 1200 1201 for (i = 0; i < count; i++) 1202 { 1203 bfd_byte *data; 1204 rc_res_id name; 1205 1206 if (fseek (e, icondirs[i].offset, SEEK_SET) != 0) 1207 fatal (_("%s: fseek to %lu failed: %s"), real_filename, 1208 icondirs[i].offset, strerror (errno)); 1209 1210 data = (bfd_byte *) res_alloc (icondirs[i].bytes); 1211 1212 get_data (e, data, icondirs[i].bytes, real_filename); 1213 1214 ++icons; 1215 1216 name.named = 0; 1217 name.u.id = icons; 1218 1219 r = define_standard_resource (&resources, RT_ICON, name, 1220 resinfo->language, 0); 1221 r->type = RES_TYPE_ICON; 1222 r->u.data.length = icondirs[i].bytes; 1223 r->u.data.data = data; 1224 r->res_info = *resinfo; 1225 } 1226 1227 fclose (e); 1228 free (real_filename); 1229 1230 /* Define an icon group resource. */ 1231 1232 first = NULL; 1233 pp = &first; 1234 for (i = 0; i < count; i++) 1235 { 1236 rc_group_icon *cg; 1237 1238 /* For some reason, at least in some files the planes and bits 1239 are zero. We instead set them from the color. This is 1240 copied from rcl. */ 1241 1242 cg = (rc_group_icon *) res_alloc (sizeof (rc_group_icon)); 1243 cg->next = NULL; 1244 cg->width = icondirs[i].width; 1245 cg->height = icondirs[i].height; 1246 cg->colors = icondirs[i].colorcount; 1247 1248 if (icondirs[i].u.icon.planes) 1249 cg->planes = icondirs[i].u.icon.planes; 1250 else 1251 cg->planes = 1; 1252 1253 if (icondirs[i].u.icon.bits) 1254 cg->bits = icondirs[i].u.icon.bits; 1255 else 1256 { 1257 cg->bits = 0; 1258 1259 while ((1L << cg->bits) < cg->colors) 1260 ++cg->bits; 1261 } 1262 1263 cg->bytes = icondirs[i].bytes; 1264 cg->index = first_icon + i + 1; 1265 1266 *pp = cg; 1267 pp = &(*pp)->next; 1268 } 1269 1270 free (icondirs); 1271 1272 r = define_standard_resource (&resources, RT_GROUP_ICON, id, 1273 resinfo->language, 0); 1274 r->type = RES_TYPE_GROUP_ICON; 1275 r->u.group_icon = first; 1276 r->res_info = *resinfo; 1277 } 1278 1279 static void 1280 define_group_icon_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1281 rc_rcdata_item *data) 1282 { 1283 rc_res_resource *r; 1284 rc_group_icon *cg, *first, *cur; 1285 rc_uint_type len_data; 1286 bfd_byte *pb_data; 1287 1288 pb_data = rcdata_render_as_buffer (data, &len_data); 1289 1290 cur = NULL; 1291 first = NULL; 1292 1293 while (len_data >= 6) 1294 { 1295 int c, i; 1296 unsigned short type; 1297 type = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2); 1298 if (type != 1) 1299 fatal (_("unexpected group icon type %d"), type); 1300 c = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4); 1301 len_data -= 6; 1302 pb_data += 6; 1303 1304 for (i = 0; i < c; i++) 1305 { 1306 if (len_data < 14) 1307 fatal ("too small group icon rcdata"); 1308 cg = (rc_group_icon *) res_alloc (sizeof (rc_group_icon)); 1309 cg->next = NULL; 1310 cg->width = pb_data[0]; 1311 cg->height = pb_data[1]; 1312 cg->colors = pb_data[2]; 1313 cg->planes = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4); 1314 cg->bits = windres_get_16 (&wrtarget, pb_data + 6, len_data - 6); 1315 cg->bytes = windres_get_32 (&wrtarget, pb_data + 8, len_data - 8); 1316 cg->index = windres_get_16 (&wrtarget, pb_data + 12, len_data - 12); 1317 if (! first) 1318 first = cg; 1319 else 1320 cur->next = cg; 1321 cur = cg; 1322 pb_data += 14; 1323 len_data -= 14; 1324 } 1325 } 1326 r = define_standard_resource (&resources, RT_GROUP_ICON, id, 1327 resinfo->language, 0); 1328 r->type = RES_TYPE_GROUP_ICON; 1329 r->u.group_icon = first; 1330 r->res_info = *resinfo; 1331 } 1332 1333 static void 1334 define_group_cursor_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1335 rc_rcdata_item *data) 1336 { 1337 rc_res_resource *r; 1338 rc_group_cursor *cg, *first, *cur; 1339 rc_uint_type len_data; 1340 bfd_byte *pb_data; 1341 1342 pb_data = rcdata_render_as_buffer (data, &len_data); 1343 1344 first = cur = NULL; 1345 1346 while (len_data >= 6) 1347 { 1348 int c, i; 1349 unsigned short type; 1350 type = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2); 1351 if (type != 2) 1352 fatal (_("unexpected group cursor type %d"), type); 1353 c = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4); 1354 len_data -= 6; 1355 pb_data += 6; 1356 1357 for (i = 0; i < c; i++) 1358 { 1359 if (len_data < 14) 1360 fatal ("too small group icon rcdata"); 1361 cg = (rc_group_cursor *) res_alloc (sizeof (rc_group_cursor)); 1362 cg->next = NULL; 1363 cg->width = windres_get_16 (&wrtarget, pb_data, len_data); 1364 cg->height = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2); 1365 cg->planes = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4); 1366 cg->bits = windres_get_16 (&wrtarget, pb_data + 6, len_data - 6); 1367 cg->bytes = windres_get_32 (&wrtarget, pb_data + 8, len_data - 8); 1368 cg->index = windres_get_16 (&wrtarget, pb_data + 12, len_data - 12); 1369 if (! first) 1370 first = cg; 1371 else 1372 cur->next = cg; 1373 cur = cg; 1374 pb_data += 14; 1375 len_data -= 14; 1376 } 1377 } 1378 1379 r = define_standard_resource (&resources, RT_GROUP_ICON, id, 1380 resinfo->language, 0); 1381 r->type = RES_TYPE_GROUP_CURSOR; 1382 r->u.group_cursor = first; 1383 r->res_info = *resinfo; 1384 } 1385 1386 static void 1387 define_cursor_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1388 rc_rcdata_item *data) 1389 { 1390 rc_cursor *c; 1391 rc_res_resource *r; 1392 rc_uint_type len_data; 1393 bfd_byte *pb_data; 1394 1395 pb_data = rcdata_render_as_buffer (data, &len_data); 1396 1397 c = (rc_cursor *) res_alloc (sizeof (rc_cursor)); 1398 c->xhotspot = windres_get_16 (&wrtarget, pb_data, len_data); 1399 c->yhotspot = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2); 1400 c->length = len_data - BIN_CURSOR_SIZE; 1401 c->data = (const bfd_byte *) (data + BIN_CURSOR_SIZE); 1402 1403 r = define_standard_resource (&resources, RT_CURSOR, id, resinfo->language, 0); 1404 r->type = RES_TYPE_CURSOR; 1405 r->u.cursor = c; 1406 r->res_info = *resinfo; 1407 } 1408 1409 static void 1410 define_bitmap_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1411 rc_rcdata_item *data) 1412 { 1413 rc_res_resource *r; 1414 rc_uint_type len_data; 1415 bfd_byte *pb_data; 1416 1417 pb_data = rcdata_render_as_buffer (data, &len_data); 1418 1419 r = define_standard_resource (&resources, RT_BITMAP, id, resinfo->language, 0); 1420 r->type = RES_TYPE_BITMAP; 1421 r->u.data.length = len_data; 1422 r->u.data.data = pb_data; 1423 r->res_info = *resinfo; 1424 } 1425 1426 static void 1427 define_icon_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1428 rc_rcdata_item *data) 1429 { 1430 rc_res_resource *r; 1431 rc_uint_type len_data; 1432 bfd_byte *pb_data; 1433 1434 pb_data = rcdata_render_as_buffer (data, &len_data); 1435 1436 r = define_standard_resource (&resources, RT_ICON, id, resinfo->language, 0); 1437 r->type = RES_TYPE_ICON; 1438 r->u.data.length = len_data; 1439 r->u.data.data = pb_data; 1440 r->res_info = *resinfo; 1441 } 1442 1443 /* Define a menu resource. */ 1444 1445 void 1446 define_menu (rc_res_id id, const rc_res_res_info *resinfo, 1447 rc_menuitem *menuitems) 1448 { 1449 rc_menu *m; 1450 rc_res_resource *r; 1451 1452 m = (rc_menu *) res_alloc (sizeof (rc_menu)); 1453 m->items = menuitems; 1454 m->help = 0; 1455 1456 r = define_standard_resource (&resources, RT_MENU, id, resinfo->language, 0); 1457 r->type = RES_TYPE_MENU; 1458 r->u.menu = m; 1459 r->res_info = *resinfo; 1460 } 1461 1462 /* Define a menu item. This does not define a resource, but merely 1463 allocates and fills in a structure. */ 1464 1465 rc_menuitem * 1466 define_menuitem (const unichar *text, rc_uint_type menuid, rc_uint_type type, 1467 rc_uint_type state, rc_uint_type help, 1468 rc_menuitem *menuitems) 1469 { 1470 rc_menuitem *mi; 1471 1472 mi = (rc_menuitem *) res_alloc (sizeof (rc_menuitem)); 1473 mi->next = NULL; 1474 mi->type = type; 1475 mi->state = state; 1476 mi->id = menuid; 1477 mi->text = unichar_dup (text); 1478 mi->help = help; 1479 mi->popup = menuitems; 1480 return mi; 1481 } 1482 1483 /* Define a messagetable resource. */ 1484 1485 void 1486 define_messagetable (rc_res_id id, const rc_res_res_info *resinfo, 1487 const char *filename) 1488 { 1489 FILE *e; 1490 char *real_filename; 1491 struct stat s; 1492 bfd_byte *data; 1493 rc_res_resource *r; 1494 1495 e = open_file_search (filename, FOPEN_RB, "messagetable file", 1496 &real_filename); 1497 1498 if (stat (real_filename, &s) < 0) 1499 fatal (_("stat failed on bitmap file `%s': %s"), real_filename, 1500 strerror (errno)); 1501 1502 data = (bfd_byte *) res_alloc (s.st_size); 1503 1504 get_data (e, data, s.st_size, real_filename); 1505 1506 fclose (e); 1507 free (real_filename); 1508 1509 r = define_standard_resource (&resources, RT_MESSAGETABLE, id, 1510 resinfo->language, 0); 1511 1512 r->type = RES_TYPE_MESSAGETABLE; 1513 r->u.data.length = s.st_size; 1514 r->u.data.data = data; 1515 r->res_info = *resinfo; 1516 } 1517 1518 /* Define an rcdata resource. */ 1519 1520 void 1521 define_rcdata (rc_res_id id, const rc_res_res_info *resinfo, 1522 rc_rcdata_item *data) 1523 { 1524 rc_res_resource *r; 1525 1526 r = define_standard_resource (&resources, RT_RCDATA, id, 1527 resinfo->language, 0); 1528 r->type = RES_TYPE_RCDATA; 1529 r->u.rcdata = data; 1530 r->res_info = *resinfo; 1531 } 1532 1533 /* Create an rcdata item holding a string. */ 1534 1535 rc_rcdata_item * 1536 define_rcdata_string (const char *string, rc_uint_type len) 1537 { 1538 rc_rcdata_item *ri; 1539 char *s; 1540 1541 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item)); 1542 ri->next = NULL; 1543 ri->type = RCDATA_STRING; 1544 ri->u.string.length = len; 1545 s = (char *) res_alloc (len); 1546 memcpy (s, string, len); 1547 ri->u.string.s = s; 1548 1549 return ri; 1550 } 1551 1552 /* Create an rcdata item holding a unicode string. */ 1553 1554 rc_rcdata_item * 1555 define_rcdata_unistring (const unichar *string, rc_uint_type len) 1556 { 1557 rc_rcdata_item *ri; 1558 unichar *s; 1559 1560 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item)); 1561 ri->next = NULL; 1562 ri->type = RCDATA_WSTRING; 1563 ri->u.wstring.length = len; 1564 s = (unichar *) res_alloc (len * sizeof (unichar)); 1565 memcpy (s, string, len * sizeof (unichar)); 1566 ri->u.wstring.w = s; 1567 1568 return ri; 1569 } 1570 1571 /* Create an rcdata item holding a number. */ 1572 1573 rc_rcdata_item * 1574 define_rcdata_number (rc_uint_type val, int dword) 1575 { 1576 rc_rcdata_item *ri; 1577 1578 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item)); 1579 ri->next = NULL; 1580 ri->type = dword ? RCDATA_DWORD : RCDATA_WORD; 1581 ri->u.word = val; 1582 1583 return ri; 1584 } 1585 1586 /* Define a stringtable resource. This is called for each string 1587 which appears in a STRINGTABLE statement. */ 1588 1589 void 1590 define_stringtable (const rc_res_res_info *resinfo, 1591 rc_uint_type stringid, const unichar *string, int len) 1592 { 1593 unichar *h; 1594 rc_res_id id; 1595 rc_res_resource *r; 1596 1597 id.named = 0; 1598 id.u.id = (stringid >> 4) + 1; 1599 r = define_standard_resource (&resources, RT_STRING, id, 1600 resinfo->language, 1); 1601 1602 if (r->type == RES_TYPE_UNINITIALIZED) 1603 { 1604 int i; 1605 1606 r->type = RES_TYPE_STRINGTABLE; 1607 r->u.stringtable = ((rc_stringtable *) 1608 res_alloc (sizeof (rc_stringtable))); 1609 for (i = 0; i < 16; i++) 1610 { 1611 r->u.stringtable->strings[i].length = 0; 1612 r->u.stringtable->strings[i].string = NULL; 1613 } 1614 1615 r->res_info = *resinfo; 1616 } 1617 h = (unichar *) res_alloc ((len + 1) * sizeof (unichar)); 1618 if (len) 1619 memcpy (h, string, len * sizeof (unichar)); 1620 h[len] = 0; 1621 r->u.stringtable->strings[stringid & 0xf].length = (rc_uint_type) len; 1622 r->u.stringtable->strings[stringid & 0xf].string = h; 1623 } 1624 1625 void 1626 define_toolbar (rc_res_id id, rc_res_res_info *resinfo, rc_uint_type width, rc_uint_type height, 1627 rc_toolbar_item *items) 1628 { 1629 rc_toolbar *t; 1630 rc_res_resource *r; 1631 1632 t = (rc_toolbar *) res_alloc (sizeof (rc_toolbar)); 1633 t->button_width = width; 1634 t->button_height = height; 1635 t->nitems = 0; 1636 t->items = items; 1637 while (items != NULL) 1638 { 1639 t->nitems+=1; 1640 items = items->next; 1641 } 1642 r = define_standard_resource (&resources, RT_TOOLBAR, id, resinfo->language, 0); 1643 r->type = RES_TYPE_TOOLBAR; 1644 r->u.toolbar = t; 1645 r->res_info = *resinfo; 1646 } 1647 1648 /* Define a user data resource where the data is in the rc file. */ 1649 1650 void 1651 define_user_data (rc_res_id id, rc_res_id type, 1652 const rc_res_res_info *resinfo, 1653 rc_rcdata_item *data) 1654 { 1655 rc_res_id ids[3]; 1656 rc_res_resource *r; 1657 bfd_byte *pb_data; 1658 rc_uint_type len_data; 1659 1660 /* We have to check if the binary data is parsed specially. */ 1661 if (type.named == 0) 1662 { 1663 switch (type.u.id) 1664 { 1665 case RT_FONTDIR: 1666 define_fontdir_rcdata (id, resinfo, data); 1667 return; 1668 case RT_FONT: 1669 define_font_rcdata (id, resinfo, data); 1670 return; 1671 case RT_ICON: 1672 define_icon_rcdata (id, resinfo, data); 1673 return; 1674 case RT_BITMAP: 1675 define_bitmap_rcdata (id, resinfo, data); 1676 return; 1677 case RT_CURSOR: 1678 define_cursor_rcdata (id, resinfo, data); 1679 return; 1680 case RT_GROUP_ICON: 1681 define_group_icon_rcdata (id, resinfo, data); 1682 return; 1683 case RT_GROUP_CURSOR: 1684 define_group_cursor_rcdata (id, resinfo, data); 1685 return; 1686 case RT_MESSAGETABLE: 1687 define_messagetable_rcdata (id, resinfo, data); 1688 return; 1689 default: 1690 /* Treat as normal user-data. */ 1691 break; 1692 } 1693 } 1694 ids[0] = type; 1695 ids[1] = id; 1696 ids[2].named = 0; 1697 ids[2].u.id = resinfo->language; 1698 1699 r = define_resource (& resources, 3, ids, 0); 1700 r->type = RES_TYPE_USERDATA; 1701 r->u.userdata = ((rc_rcdata_item *) 1702 res_alloc (sizeof (rc_rcdata_item))); 1703 r->u.userdata->next = NULL; 1704 r->u.userdata->type = RCDATA_BUFFER; 1705 pb_data = rcdata_render_as_buffer (data, &len_data); 1706 r->u.userdata->u.buffer.length = len_data; 1707 r->u.userdata->u.buffer.data = pb_data; 1708 r->res_info = *resinfo; 1709 } 1710 1711 void 1712 define_rcdata_file (rc_res_id id, const rc_res_res_info *resinfo, 1713 const char *filename) 1714 { 1715 rc_rcdata_item *ri; 1716 FILE *e; 1717 char *real_filename; 1718 struct stat s; 1719 bfd_byte *data; 1720 1721 e = open_file_search (filename, FOPEN_RB, "file", &real_filename); 1722 1723 1724 if (stat (real_filename, &s) < 0) 1725 fatal (_("stat failed on file `%s': %s"), real_filename, 1726 strerror (errno)); 1727 1728 data = (bfd_byte *) res_alloc (s.st_size); 1729 1730 get_data (e, data, s.st_size, real_filename); 1731 1732 fclose (e); 1733 free (real_filename); 1734 1735 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item)); 1736 ri->next = NULL; 1737 ri->type = RCDATA_BUFFER; 1738 ri->u.buffer.length = s.st_size; 1739 ri->u.buffer.data = data; 1740 1741 define_rcdata (id, resinfo, ri); 1742 } 1743 1744 /* Define a user data resource where the data is in a file. */ 1745 1746 void 1747 define_user_file (rc_res_id id, rc_res_id type, 1748 const rc_res_res_info *resinfo, const char *filename) 1749 { 1750 FILE *e; 1751 char *real_filename; 1752 struct stat s; 1753 bfd_byte *data; 1754 rc_res_id ids[3]; 1755 rc_res_resource *r; 1756 1757 e = open_file_search (filename, FOPEN_RB, "file", &real_filename); 1758 1759 if (stat (real_filename, &s) < 0) 1760 fatal (_("stat failed on file `%s': %s"), real_filename, 1761 strerror (errno)); 1762 1763 data = (bfd_byte *) res_alloc (s.st_size); 1764 1765 get_data (e, data, s.st_size, real_filename); 1766 1767 fclose (e); 1768 free (real_filename); 1769 1770 ids[0] = type; 1771 ids[1] = id; 1772 ids[2].named = 0; 1773 ids[2].u.id = resinfo->language; 1774 1775 r = define_resource (&resources, 3, ids, 0); 1776 r->type = RES_TYPE_USERDATA; 1777 r->u.userdata = ((rc_rcdata_item *) 1778 res_alloc (sizeof (rc_rcdata_item))); 1779 r->u.userdata->next = NULL; 1780 r->u.userdata->type = RCDATA_BUFFER; 1781 r->u.userdata->u.buffer.length = s.st_size; 1782 r->u.userdata->u.buffer.data = data; 1783 r->res_info = *resinfo; 1784 } 1785 1786 /* Define a versioninfo resource. */ 1787 1788 void 1789 define_versioninfo (rc_res_id id, rc_uint_type language, 1790 rc_fixed_versioninfo *fixedverinfo, 1791 rc_ver_info *verinfo) 1792 { 1793 rc_res_resource *r; 1794 1795 r = define_standard_resource (&resources, RT_VERSION, id, language, 0); 1796 r->type = RES_TYPE_VERSIONINFO; 1797 r->u.versioninfo = ((rc_versioninfo *) 1798 res_alloc (sizeof (rc_versioninfo))); 1799 r->u.versioninfo->fixed = fixedverinfo; 1800 r->u.versioninfo->var = verinfo; 1801 r->res_info.language = language; 1802 } 1803 1804 /* Add string version info to a list of version information. */ 1805 1806 rc_ver_info * 1807 append_ver_stringfileinfo (rc_ver_info *verinfo, 1808 rc_ver_stringtable *stringtables) 1809 { 1810 rc_ver_info *vi, **pp; 1811 1812 vi = (rc_ver_info *) res_alloc (sizeof (rc_ver_info)); 1813 vi->next = NULL; 1814 vi->type = VERINFO_STRING; 1815 vi->u.string.stringtables = stringtables; 1816 1817 for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next) 1818 ; 1819 *pp = vi; 1820 1821 return verinfo; 1822 } 1823 1824 rc_ver_stringtable * 1825 append_ver_stringtable (rc_ver_stringtable *stringtable, 1826 const char *language, 1827 rc_ver_stringinfo *strings) 1828 { 1829 rc_ver_stringtable *vst, **pp; 1830 1831 vst = (rc_ver_stringtable *) res_alloc (sizeof (rc_ver_stringtable)); 1832 vst->next = NULL; 1833 unicode_from_ascii ((rc_uint_type *) NULL, &vst->language, language); 1834 vst->strings = strings; 1835 1836 for (pp = &stringtable; *pp != NULL; pp = &(*pp)->next) 1837 ; 1838 *pp = vst; 1839 1840 return stringtable; 1841 } 1842 1843 /* Add variable version info to a list of version information. */ 1844 1845 rc_ver_info * 1846 append_ver_varfileinfo (rc_ver_info *verinfo, const unichar *key, 1847 rc_ver_varinfo *var) 1848 { 1849 rc_ver_info *vi, **pp; 1850 1851 vi = (rc_ver_info *) res_alloc (sizeof *vi); 1852 vi->next = NULL; 1853 vi->type = VERINFO_VAR; 1854 vi->u.var.key = unichar_dup (key); 1855 vi->u.var.var = var; 1856 1857 for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next) 1858 ; 1859 *pp = vi; 1860 1861 return verinfo; 1862 } 1863 1864 /* Append version string information to a list. */ 1865 1866 rc_ver_stringinfo * 1867 append_verval (rc_ver_stringinfo *strings, const unichar *key, 1868 const unichar *value) 1869 { 1870 rc_ver_stringinfo *vs, **pp; 1871 1872 vs = (rc_ver_stringinfo *) res_alloc (sizeof (rc_ver_stringinfo)); 1873 vs->next = NULL; 1874 vs->key = unichar_dup (key); 1875 vs->value = unichar_dup (value); 1876 1877 for (pp = &strings; *pp != NULL; pp = &(*pp)->next) 1878 ; 1879 *pp = vs; 1880 1881 return strings; 1882 } 1883 1884 /* Append version variable information to a list. */ 1885 1886 rc_ver_varinfo * 1887 append_vertrans (rc_ver_varinfo *var, rc_uint_type language, 1888 rc_uint_type charset) 1889 { 1890 rc_ver_varinfo *vv, **pp; 1891 1892 vv = (rc_ver_varinfo *) res_alloc (sizeof (rc_ver_varinfo)); 1893 vv->next = NULL; 1894 vv->language = language; 1895 vv->charset = charset; 1896 1897 for (pp = &var; *pp != NULL; pp = &(*pp)->next) 1898 ; 1899 *pp = vv; 1900 1901 return var; 1902 } 1903 1904 /* Local functions used to write out an rc file. */ 1905 1906 static void indent (FILE *, int); 1907 static void write_rc_directory (FILE *, const rc_res_directory *, const rc_res_id *, 1908 const rc_res_id *, rc_uint_type *, int); 1909 static void write_rc_subdir (FILE *, const rc_res_entry *, const rc_res_id *, 1910 const rc_res_id *, rc_uint_type *, int); 1911 static void write_rc_resource (FILE *, const rc_res_id *, const rc_res_id *, 1912 const rc_res_resource *, rc_uint_type *); 1913 static void write_rc_accelerators (FILE *, const rc_accelerator *); 1914 static void write_rc_cursor (FILE *, const rc_cursor *); 1915 static void write_rc_group_cursor (FILE *, const rc_group_cursor *); 1916 static void write_rc_dialog (FILE *, const rc_dialog *); 1917 static void write_rc_dialog_control (FILE *, const rc_dialog_control *); 1918 static void write_rc_fontdir (FILE *, const rc_fontdir *); 1919 static void write_rc_group_icon (FILE *, const rc_group_icon *); 1920 static void write_rc_menu (FILE *, const rc_menu *, int); 1921 static void write_rc_toolbar (FILE *, const rc_toolbar *); 1922 static void write_rc_menuitems (FILE *, const rc_menuitem *, int, int); 1923 static void write_rc_messagetable (FILE *, rc_uint_type , const bfd_byte *); 1924 1925 static void write_rc_datablock (FILE *, rc_uint_type , const bfd_byte *, int, int, int); 1926 static void write_rc_rcdata (FILE *, const rc_rcdata_item *, int); 1927 static void write_rc_stringtable (FILE *, const rc_res_id *, const rc_stringtable *); 1928 static void write_rc_versioninfo (FILE *, const rc_versioninfo *); 1929 1930 /* Indent a given number of spaces. */ 1931 1932 static void 1933 indent (FILE *e, int c) 1934 { 1935 int i; 1936 1937 for (i = 0; i < c; i++) 1938 putc (' ', e); 1939 } 1940 1941 /* Dump the resources we have read in the format of an rc file. 1942 1943 Reasoned by the fact, that some resources need to be stored into file and 1944 refer to that file, we use the user-data model for that to express it binary 1945 without the need to store it somewhere externally. */ 1946 1947 void 1948 write_rc_file (const char *filename, const rc_res_directory *res_dir) 1949 { 1950 FILE *e; 1951 rc_uint_type language; 1952 1953 if (filename == NULL) 1954 e = stdout; 1955 else 1956 { 1957 e = fopen (filename, FOPEN_WT); 1958 if (e == NULL) 1959 fatal (_("can't open `%s' for output: %s"), filename, strerror (errno)); 1960 } 1961 1962 language = (rc_uint_type) ((bfd_signed_vma) -1); 1963 write_rc_directory (e, res_dir, (const rc_res_id *) NULL, 1964 (const rc_res_id *) NULL, &language, 1); 1965 } 1966 1967 /* Write out a directory. E is the file to write to. RD is the 1968 directory. TYPE is a pointer to the level 1 ID which serves as the 1969 resource type. NAME is a pointer to the level 2 ID which serves as 1970 an individual resource name. LANGUAGE is a pointer to the current 1971 language. LEVEL is the level in the tree. */ 1972 1973 static void 1974 write_rc_directory (FILE *e, const rc_res_directory *rd, 1975 const rc_res_id *type, const rc_res_id *name, 1976 rc_uint_type *language, int level) 1977 { 1978 const rc_res_entry *re; 1979 1980 /* Print out some COFF information that rc files can't represent. */ 1981 if (rd->time != 0 || rd->characteristics != 0 || rd->major != 0 || rd->minor != 0) 1982 { 1983 wr_printcomment (e, "COFF information not part of RC"); 1984 if (rd->time != 0) 1985 wr_printcomment (e, "Time stamp: %u", rd->time); 1986 if (rd->characteristics != 0) 1987 wr_printcomment (e, "Characteristics: %u", rd->characteristics); 1988 if (rd->major != 0 || rd->minor != 0) 1989 wr_printcomment (e, "Version major:%d minor:%d", rd->major, rd->minor); 1990 } 1991 1992 for (re = rd->entries; re != NULL; re = re->next) 1993 { 1994 switch (level) 1995 { 1996 case 1: 1997 /* If we're at level 1, the key of this resource is the 1998 type. This normally duplicates the information we have 1999 stored with the resource itself, but we need to remember 2000 the type if this is a user define resource type. */ 2001 type = &re->id; 2002 break; 2003 2004 case 2: 2005 /* If we're at level 2, the key of this resource is the name 2006 we are going to use in the rc printout. */ 2007 name = &re->id; 2008 break; 2009 2010 case 3: 2011 /* If we're at level 3, then this key represents a language. 2012 Use it to update the current language. */ 2013 if (! re->id.named 2014 && re->id.u.id != (unsigned long) (unsigned int) *language 2015 && (re->id.u.id & 0xffff) == re->id.u.id) 2016 { 2017 wr_print (e, "LANGUAGE %u, %u\n", 2018 re->id.u.id & ((1 << SUBLANG_SHIFT) - 1), 2019 (re->id.u.id >> SUBLANG_SHIFT) & 0xff); 2020 *language = re->id.u.id; 2021 } 2022 break; 2023 2024 default: 2025 break; 2026 } 2027 2028 if (re->subdir) 2029 write_rc_subdir (e, re, type, name, language, level); 2030 else 2031 { 2032 if (level == 3) 2033 { 2034 /* This is the normal case: the three levels are 2035 TYPE/NAME/LANGUAGE. NAME will have been set at level 2036 2, and represents the name to use. We probably just 2037 set LANGUAGE, and it will probably match what the 2038 resource itself records if anything. */ 2039 write_rc_resource (e, type, name, re->u.res, language); 2040 } 2041 else 2042 { 2043 wr_printcomment (e, "Resource at unexpected level %d", level); 2044 write_rc_resource (e, type, (rc_res_id *) NULL, re->u.res, 2045 language); 2046 } 2047 } 2048 } 2049 if (rd->entries == NULL) 2050 { 2051 wr_print_flush (e); 2052 } 2053 } 2054 2055 /* Write out a subdirectory entry. E is the file to write to. RE is 2056 the subdirectory entry. TYPE and NAME are pointers to higher level 2057 IDs, or NULL. LANGUAGE is a pointer to the current language. 2058 LEVEL is the level in the tree. */ 2059 2060 static void 2061 write_rc_subdir (FILE *e, const rc_res_entry *re, 2062 const rc_res_id *type, const rc_res_id *name, 2063 rc_uint_type *language, int level) 2064 { 2065 fprintf (e, "\n"); 2066 switch (level) 2067 { 2068 case 1: 2069 wr_printcomment (e, "Type: "); 2070 if (re->id.named) 2071 res_id_print (e, re->id, 1); 2072 else 2073 { 2074 const char *s; 2075 2076 switch (re->id.u.id) 2077 { 2078 case RT_CURSOR: s = "cursor"; break; 2079 case RT_BITMAP: s = "bitmap"; break; 2080 case RT_ICON: s = "icon"; break; 2081 case RT_MENU: s = "menu"; break; 2082 case RT_DIALOG: s = "dialog"; break; 2083 case RT_STRING: s = "stringtable"; break; 2084 case RT_FONTDIR: s = "fontdir"; break; 2085 case RT_FONT: s = "font"; break; 2086 case RT_ACCELERATOR: s = "accelerators"; break; 2087 case RT_RCDATA: s = "rcdata"; break; 2088 case RT_MESSAGETABLE: s = "messagetable"; break; 2089 case RT_GROUP_CURSOR: s = "group cursor"; break; 2090 case RT_GROUP_ICON: s = "group icon"; break; 2091 case RT_VERSION: s = "version"; break; 2092 case RT_DLGINCLUDE: s = "dlginclude"; break; 2093 case RT_PLUGPLAY: s = "plugplay"; break; 2094 case RT_VXD: s = "vxd"; break; 2095 case RT_ANICURSOR: s = "anicursor"; break; 2096 case RT_ANIICON: s = "aniicon"; break; 2097 case RT_TOOLBAR: s = "toolbar"; break; 2098 case RT_HTML: s = "html"; break; 2099 default: s = NULL; break; 2100 } 2101 2102 if (s != NULL) 2103 fprintf (e, "%s", s); 2104 else 2105 res_id_print (e, re->id, 1); 2106 } 2107 break; 2108 2109 case 2: 2110 wr_printcomment (e, "Name: "); 2111 res_id_print (e, re->id, 1); 2112 break; 2113 2114 case 3: 2115 wr_printcomment (e, "Language: "); 2116 res_id_print (e, re->id, 1); 2117 break; 2118 2119 default: 2120 wr_printcomment (e, "Level %d: ", level); 2121 res_id_print (e, re->id, 1); 2122 } 2123 2124 write_rc_directory (e, re->u.dir, type, name, language, level + 1); 2125 } 2126 2127 /* Write out a single resource. E is the file to write to. TYPE is a 2128 pointer to the type of the resource. NAME is a pointer to the name 2129 of the resource; it will be NULL if there is a level mismatch. RES 2130 is the resource data. LANGUAGE is a pointer to the current 2131 language. */ 2132 2133 static void 2134 write_rc_resource (FILE *e, const rc_res_id *type, 2135 const rc_res_id *name, const rc_res_resource *res, 2136 rc_uint_type *language) 2137 { 2138 const char *s; 2139 int rt; 2140 int menuex = 0; 2141 2142 switch (res->type) 2143 { 2144 default: 2145 abort (); 2146 2147 case RES_TYPE_ACCELERATOR: 2148 s = "ACCELERATORS"; 2149 rt = RT_ACCELERATOR; 2150 break; 2151 2152 case RES_TYPE_BITMAP: 2153 s = "2 /* RT_BITMAP */"; 2154 rt = RT_BITMAP; 2155 break; 2156 2157 case RES_TYPE_CURSOR: 2158 s = "1 /* RT_CURSOR */"; 2159 rt = RT_CURSOR; 2160 break; 2161 2162 case RES_TYPE_GROUP_CURSOR: 2163 s = "12 /* RT_GROUP_CURSOR */"; 2164 rt = RT_GROUP_CURSOR; 2165 break; 2166 2167 case RES_TYPE_DIALOG: 2168 if (extended_dialog (res->u.dialog)) 2169 s = "DIALOGEX"; 2170 else 2171 s = "DIALOG"; 2172 rt = RT_DIALOG; 2173 break; 2174 2175 case RES_TYPE_FONT: 2176 s = "8 /* RT_FONT */"; 2177 rt = RT_FONT; 2178 break; 2179 2180 case RES_TYPE_FONTDIR: 2181 s = "7 /* RT_FONTDIR */"; 2182 rt = RT_FONTDIR; 2183 break; 2184 2185 case RES_TYPE_ICON: 2186 s = "3 /* RT_ICON */"; 2187 rt = RT_ICON; 2188 break; 2189 2190 case RES_TYPE_GROUP_ICON: 2191 s = "14 /* RT_GROUP_ICON */"; 2192 rt = RT_GROUP_ICON; 2193 break; 2194 2195 case RES_TYPE_MENU: 2196 if (extended_menu (res->u.menu)) 2197 { 2198 s = "MENUEX"; 2199 menuex = 1; 2200 } 2201 else 2202 { 2203 s = "MENU"; 2204 menuex = 0; 2205 } 2206 rt = RT_MENU; 2207 break; 2208 2209 case RES_TYPE_MESSAGETABLE: 2210 s = "11 /* RT_MESSAGETABLE */"; 2211 rt = RT_MESSAGETABLE; 2212 break; 2213 2214 case RES_TYPE_RCDATA: 2215 s = "RCDATA"; 2216 rt = RT_RCDATA; 2217 break; 2218 2219 case RES_TYPE_STRINGTABLE: 2220 s = "STRINGTABLE"; 2221 rt = RT_STRING; 2222 break; 2223 2224 case RES_TYPE_USERDATA: 2225 s = NULL; 2226 rt = 0; 2227 break; 2228 2229 case RES_TYPE_VERSIONINFO: 2230 s = "VERSIONINFO"; 2231 rt = RT_VERSION; 2232 break; 2233 2234 case RES_TYPE_TOOLBAR: 2235 s = "TOOLBAR"; 2236 rt = RT_TOOLBAR; 2237 break; 2238 } 2239 2240 if (rt != 0 2241 && type != NULL 2242 && (type->named || type->u.id != (unsigned long) rt)) 2243 { 2244 wr_printcomment (e, "Unexpected resource type mismatch: "); 2245 res_id_print (e, *type, 1); 2246 fprintf (e, " != %d", rt); 2247 } 2248 2249 if (res->coff_info.codepage != 0) 2250 wr_printcomment (e, "Code page: %u", res->coff_info.codepage); 2251 if (res->coff_info.reserved != 0) 2252 wr_printcomment (e, "COFF reserved value: %u", res->coff_info.reserved); 2253 2254 wr_print (e, "\n"); 2255 if (rt == RT_STRING) 2256 ; 2257 else 2258 { 2259 if (name != NULL) 2260 res_id_print (e, *name, 1); 2261 else 2262 fprintf (e, "??Unknown-Name??"); 2263 fprintf (e, " "); 2264 } 2265 2266 if (s != NULL) 2267 fprintf (e, "%s", s); 2268 else if (type != NULL) 2269 { 2270 if (type->named == 0) 2271 { 2272 #define PRINT_RT_NAME(NAME) case NAME: \ 2273 fprintf (e, "%u /* %s */", (unsigned int) NAME, #NAME); \ 2274 break 2275 2276 switch (type->u.id) 2277 { 2278 default: 2279 res_id_print (e, *type, 0); 2280 break; 2281 2282 PRINT_RT_NAME(RT_MANIFEST); 2283 PRINT_RT_NAME(RT_ANICURSOR); 2284 PRINT_RT_NAME(RT_ANIICON); 2285 PRINT_RT_NAME(RT_RCDATA); 2286 PRINT_RT_NAME(RT_ICON); 2287 PRINT_RT_NAME(RT_CURSOR); 2288 PRINT_RT_NAME(RT_BITMAP); 2289 PRINT_RT_NAME(RT_PLUGPLAY); 2290 PRINT_RT_NAME(RT_VXD); 2291 PRINT_RT_NAME(RT_FONT); 2292 PRINT_RT_NAME(RT_FONTDIR); 2293 PRINT_RT_NAME(RT_HTML); 2294 PRINT_RT_NAME(RT_MESSAGETABLE); 2295 PRINT_RT_NAME(RT_DLGINCLUDE); 2296 PRINT_RT_NAME(RT_DLGINIT); 2297 } 2298 #undef PRINT_RT_NAME 2299 } 2300 else 2301 res_id_print (e, *type, 1); 2302 } 2303 else 2304 fprintf (e, "??Unknown-Type??"); 2305 2306 if (res->res_info.memflags != 0) 2307 { 2308 if ((res->res_info.memflags & MEMFLAG_MOVEABLE) != 0) 2309 fprintf (e, " MOVEABLE"); 2310 if ((res->res_info.memflags & MEMFLAG_PURE) != 0) 2311 fprintf (e, " PURE"); 2312 if ((res->res_info.memflags & MEMFLAG_PRELOAD) != 0) 2313 fprintf (e, " PRELOAD"); 2314 if ((res->res_info.memflags & MEMFLAG_DISCARDABLE) != 0) 2315 fprintf (e, " DISCARDABLE"); 2316 } 2317 2318 if (res->type == RES_TYPE_DIALOG) 2319 { 2320 fprintf (e, " %d, %d, %d, %d", 2321 (int) res->u.dialog->x, (int) res->u.dialog->y, 2322 (int) res->u.dialog->width, (int) res->u.dialog->height); 2323 if (res->u.dialog->ex != NULL 2324 && res->u.dialog->ex->help != 0) 2325 fprintf (e, ", %u", (unsigned int) res->u.dialog->ex->help); 2326 } 2327 else if (res->type == RES_TYPE_TOOLBAR) 2328 { 2329 fprintf (e, " %d, %d", (int) res->u.toolbar->button_width, 2330 (int) res->u.toolbar->button_height); 2331 } 2332 2333 fprintf (e, "\n"); 2334 2335 if ((res->res_info.language != 0 && res->res_info.language != *language) 2336 || res->res_info.characteristics != 0 2337 || res->res_info.version != 0) 2338 { 2339 int modifiers; 2340 2341 switch (res->type) 2342 { 2343 case RES_TYPE_ACCELERATOR: 2344 case RES_TYPE_DIALOG: 2345 case RES_TYPE_MENU: 2346 case RES_TYPE_RCDATA: 2347 case RES_TYPE_STRINGTABLE: 2348 modifiers = 1; 2349 break; 2350 2351 default: 2352 modifiers = 0; 2353 break; 2354 } 2355 2356 if (res->res_info.language != 0 && res->res_info.language != *language) 2357 fprintf (e, "%sLANGUAGE %d, %d\n", 2358 modifiers ? "// " : "", 2359 (int) res->res_info.language & ((1<<SUBLANG_SHIFT)-1), 2360 (int) (res->res_info.language >> SUBLANG_SHIFT) & 0xff); 2361 if (res->res_info.characteristics != 0) 2362 fprintf (e, "%sCHARACTERISTICS %u\n", 2363 modifiers ? "// " : "", 2364 (unsigned int) res->res_info.characteristics); 2365 if (res->res_info.version != 0) 2366 fprintf (e, "%sVERSION %u\n", 2367 modifiers ? "// " : "", 2368 (unsigned int) res->res_info.version); 2369 } 2370 2371 switch (res->type) 2372 { 2373 default: 2374 abort (); 2375 2376 case RES_TYPE_ACCELERATOR: 2377 write_rc_accelerators (e, res->u.acc); 2378 break; 2379 2380 case RES_TYPE_CURSOR: 2381 write_rc_cursor (e, res->u.cursor); 2382 break; 2383 2384 case RES_TYPE_GROUP_CURSOR: 2385 write_rc_group_cursor (e, res->u.group_cursor); 2386 break; 2387 2388 case RES_TYPE_DIALOG: 2389 write_rc_dialog (e, res->u.dialog); 2390 break; 2391 2392 case RES_TYPE_FONTDIR: 2393 write_rc_fontdir (e, res->u.fontdir); 2394 break; 2395 2396 case RES_TYPE_GROUP_ICON: 2397 write_rc_group_icon (e, res->u.group_icon); 2398 break; 2399 2400 case RES_TYPE_MENU: 2401 write_rc_menu (e, res->u.menu, menuex); 2402 break; 2403 2404 case RES_TYPE_RCDATA: 2405 write_rc_rcdata (e, res->u.rcdata, 0); 2406 break; 2407 2408 case RES_TYPE_STRINGTABLE: 2409 write_rc_stringtable (e, name, res->u.stringtable); 2410 break; 2411 2412 case RES_TYPE_USERDATA: 2413 write_rc_rcdata (e, res->u.userdata, 0); 2414 break; 2415 2416 case RES_TYPE_TOOLBAR: 2417 write_rc_toolbar (e, res->u.toolbar); 2418 break; 2419 2420 case RES_TYPE_VERSIONINFO: 2421 write_rc_versioninfo (e, res->u.versioninfo); 2422 break; 2423 2424 case RES_TYPE_BITMAP: 2425 case RES_TYPE_FONT: 2426 case RES_TYPE_ICON: 2427 write_rc_datablock (e, res->u.data.length, res->u.data.data, 0, 1, 0); 2428 break; 2429 case RES_TYPE_MESSAGETABLE: 2430 write_rc_messagetable (e, res->u.data.length, res->u.data.data); 2431 break; 2432 } 2433 } 2434 2435 /* Write out accelerator information. */ 2436 2437 static void 2438 write_rc_accelerators (FILE *e, const rc_accelerator *accelerators) 2439 { 2440 const rc_accelerator *acc; 2441 2442 fprintf (e, "BEGIN\n"); 2443 for (acc = accelerators; acc != NULL; acc = acc->next) 2444 { 2445 int printable; 2446 2447 fprintf (e, " "); 2448 2449 if ((acc->key & 0x7f) == acc->key 2450 && ISPRINT (acc->key) 2451 && (acc->flags & ACC_VIRTKEY) == 0) 2452 { 2453 fprintf (e, "\"%c\"", (char) acc->key); 2454 printable = 1; 2455 } 2456 else 2457 { 2458 fprintf (e, "%d", (int) acc->key); 2459 printable = 0; 2460 } 2461 2462 fprintf (e, ", %d", (int) acc->id); 2463 2464 if (! printable) 2465 { 2466 if ((acc->flags & ACC_VIRTKEY) != 0) 2467 fprintf (e, ", VIRTKEY"); 2468 else 2469 fprintf (e, ", ASCII"); 2470 } 2471 2472 if ((acc->flags & ACC_SHIFT) != 0) 2473 fprintf (e, ", SHIFT"); 2474 if ((acc->flags & ACC_CONTROL) != 0) 2475 fprintf (e, ", CONTROL"); 2476 if ((acc->flags & ACC_ALT) != 0) 2477 fprintf (e, ", ALT"); 2478 2479 fprintf (e, "\n"); 2480 } 2481 2482 fprintf (e, "END\n"); 2483 } 2484 2485 /* Write out cursor information. This would normally be in a separate 2486 file, which the rc file would include. */ 2487 2488 static void 2489 write_rc_cursor (FILE *e, const rc_cursor *cursor) 2490 { 2491 fprintf (e, "BEGIN\n"); 2492 indent (e, 2); 2493 fprintf (e, " 0x%x, 0x%x,\t/* Hotspot x: %d, y: %d. */\n", 2494 (unsigned int) cursor->xhotspot, (unsigned int) cursor->yhotspot, 2495 (int) cursor->xhotspot, (int) cursor->yhotspot); 2496 write_rc_datablock (e, (rc_uint_type) cursor->length, (const bfd_byte *) cursor->data, 2497 0, 0, 0); 2498 fprintf (e, "END\n"); 2499 } 2500 2501 /* Write out group cursor data. This would normally be built from the 2502 cursor data. */ 2503 2504 static void 2505 write_rc_group_cursor (FILE *e, const rc_group_cursor *group_cursor) 2506 { 2507 const rc_group_cursor *gc; 2508 int c; 2509 2510 for (c = 0, gc = group_cursor; gc != NULL; gc = gc->next, c++) 2511 ; 2512 fprintf (e, "BEGIN\n"); 2513 2514 indent (e, 2); 2515 fprintf (e, "0, 2, %d%s\t /* Having %d items. */\n", c, (c != 0 ? "," : ""), c); 2516 indent (e, 4); 2517 fprintf (e, "/* width, height, planes, bits, bytes, index. */\n"); 2518 2519 for (c = 1, gc = group_cursor; gc != NULL; gc = gc->next, c++) 2520 { 2521 indent (e, 4); 2522 fprintf (e, "%d, %d, %d, %d, 0x%xL, %d%s /* Element %d. */\n", 2523 (int) gc->width, (int) gc->height, (int) gc->planes, (int) gc->bits, 2524 (unsigned int) gc->bytes, (int) gc->index, (gc->next != NULL ? "," : ""), c); 2525 fprintf (e, "/* width: %d; height %d; planes %d; bits %d. */\n", 2526 (int) gc->width, (int) gc->height, (int) gc->planes, 2527 (int) gc->bits); 2528 } 2529 fprintf (e, "END\n"); 2530 } 2531 2532 /* Write dialog data. */ 2533 2534 static void 2535 write_rc_dialog (FILE *e, const rc_dialog *dialog) 2536 { 2537 const rc_dialog_control *control; 2538 2539 fprintf (e, "STYLE 0x%x\n", dialog->style); 2540 2541 if (dialog->exstyle != 0) 2542 fprintf (e, "EXSTYLE 0x%x\n", (unsigned int) dialog->exstyle); 2543 2544 if ((dialog->class.named && dialog->class.u.n.length > 0) 2545 || dialog->class.u.id != 0) 2546 { 2547 fprintf (e, "CLASS "); 2548 res_id_print (e, dialog->class, 1); 2549 fprintf (e, "\n"); 2550 } 2551 2552 if (dialog->caption != NULL) 2553 { 2554 fprintf (e, "CAPTION "); 2555 unicode_print_quoted (e, dialog->caption, -1); 2556 fprintf (e, "\n"); 2557 } 2558 2559 if ((dialog->menu.named && dialog->menu.u.n.length > 0) 2560 || dialog->menu.u.id != 0) 2561 { 2562 fprintf (e, "MENU "); 2563 res_id_print (e, dialog->menu, 0); 2564 fprintf (e, "\n"); 2565 } 2566 2567 if (dialog->font != NULL) 2568 { 2569 fprintf (e, "FONT %d, ", (int) dialog->pointsize); 2570 unicode_print_quoted (e, dialog->font, -1); 2571 if (dialog->ex != NULL 2572 && (dialog->ex->weight != 0 2573 || dialog->ex->italic != 0 2574 || dialog->ex->charset != 1)) 2575 fprintf (e, ", %d, %d, %d", 2576 (int) dialog->ex->weight, 2577 (int) dialog->ex->italic, 2578 (int) dialog->ex->charset); 2579 fprintf (e, "\n"); 2580 } 2581 2582 fprintf (e, "BEGIN\n"); 2583 2584 for (control = dialog->controls; control != NULL; control = control->next) 2585 write_rc_dialog_control (e, control); 2586 2587 fprintf (e, "END\n"); 2588 } 2589 2590 /* For each predefined control keyword, this table provides the class 2591 and the style. */ 2592 2593 struct control_info 2594 { 2595 const char *name; 2596 unsigned short class; 2597 unsigned long style; 2598 }; 2599 2600 static const struct control_info control_info[] = 2601 { 2602 { "AUTO3STATE", CTL_BUTTON, BS_AUTO3STATE }, 2603 { "AUTOCHECKBOX", CTL_BUTTON, BS_AUTOCHECKBOX }, 2604 { "AUTORADIOBUTTON", CTL_BUTTON, BS_AUTORADIOBUTTON }, 2605 { "CHECKBOX", CTL_BUTTON, BS_CHECKBOX }, 2606 { "COMBOBOX", CTL_COMBOBOX, (unsigned long) -1 }, 2607 { "CTEXT", CTL_STATIC, SS_CENTER }, 2608 { "DEFPUSHBUTTON", CTL_BUTTON, BS_DEFPUSHBUTTON }, 2609 { "EDITTEXT", CTL_EDIT, (unsigned long) -1 }, 2610 { "GROUPBOX", CTL_BUTTON, BS_GROUPBOX }, 2611 { "ICON", CTL_STATIC, SS_ICON }, 2612 { "LISTBOX", CTL_LISTBOX, (unsigned long) -1 }, 2613 { "LTEXT", CTL_STATIC, SS_LEFT }, 2614 { "PUSHBOX", CTL_BUTTON, BS_PUSHBOX }, 2615 { "PUSHBUTTON", CTL_BUTTON, BS_PUSHBUTTON }, 2616 { "RADIOBUTTON", CTL_BUTTON, BS_RADIOBUTTON }, 2617 { "RTEXT", CTL_STATIC, SS_RIGHT }, 2618 { "SCROLLBAR", CTL_SCROLLBAR, (unsigned long) -1 }, 2619 { "STATE3", CTL_BUTTON, BS_3STATE }, 2620 /* It's important that USERBUTTON come after all the other button 2621 types, so that it won't be matched too early. */ 2622 { "USERBUTTON", CTL_BUTTON, (unsigned long) -1 }, 2623 { NULL, 0, 0 } 2624 }; 2625 2626 /* Write a dialog control. */ 2627 2628 static void 2629 write_rc_dialog_control (FILE *e, const rc_dialog_control *control) 2630 { 2631 const struct control_info *ci; 2632 2633 fprintf (e, " "); 2634 2635 if (control->class.named) 2636 ci = NULL; 2637 else 2638 { 2639 for (ci = control_info; ci->name != NULL; ++ci) 2640 if (ci->class == control->class.u.id 2641 && (ci->style == (unsigned long) -1 2642 || ci->style == (control->style & 0xff))) 2643 break; 2644 } 2645 if (ci == NULL) 2646 fprintf (e, "CONTROL"); 2647 else if (ci->name != NULL) 2648 fprintf (e, "%s", ci->name); 2649 else 2650 { 2651 fprintf (e, "CONTROL"); 2652 ci = NULL; 2653 } 2654 2655 /* For EDITTEXT, COMBOBOX, LISTBOX, and SCROLLBAR don't dump text. */ 2656 if ((control->text.named || control->text.u.id != 0) 2657 && (!ci 2658 || (ci->class != CTL_EDIT 2659 && ci->class != CTL_COMBOBOX 2660 && ci->class != CTL_LISTBOX 2661 && ci->class != CTL_SCROLLBAR))) 2662 { 2663 fprintf (e, " "); 2664 res_id_print (e, control->text, 1); 2665 fprintf (e, ","); 2666 } 2667 2668 fprintf (e, " %d, ", (int) control->id); 2669 2670 if (ci == NULL) 2671 { 2672 if (control->class.named) 2673 fprintf (e, "\""); 2674 res_id_print (e, control->class, 0); 2675 if (control->class.named) 2676 fprintf (e, "\""); 2677 fprintf (e, ", 0x%x, ", (unsigned int) control->style); 2678 } 2679 2680 fprintf (e, "%d, %d", (int) control->x, (int) control->y); 2681 2682 if (control->style != SS_ICON 2683 || control->exstyle != 0 2684 || control->width != 0 2685 || control->height != 0 2686 || control->help != 0) 2687 { 2688 fprintf (e, ", %d, %d", (int) control->width, (int) control->height); 2689 2690 /* FIXME: We don't need to print the style if it is the default. 2691 More importantly, in certain cases we actually need to turn 2692 off parts of the forced style, by using NOT. */ 2693 if (ci != NULL) 2694 fprintf (e, ", 0x%x", (unsigned int) control->style); 2695 2696 if (control->exstyle != 0 || control->help != 0) 2697 fprintf (e, ", 0x%x, %u", (unsigned int) control->exstyle, 2698 (unsigned int) control->help); 2699 } 2700 2701 fprintf (e, "\n"); 2702 2703 if (control->data != NULL) 2704 write_rc_rcdata (e, control->data, 2); 2705 } 2706 2707 /* Write out font directory data. This would normally be built from 2708 the font data. */ 2709 2710 static void 2711 write_rc_fontdir (FILE *e, const rc_fontdir *fontdir) 2712 { 2713 const rc_fontdir *fc; 2714 int c; 2715 2716 for (c = 0, fc = fontdir; fc != NULL; fc = fc->next, c++) 2717 ; 2718 fprintf (e, "BEGIN\n"); 2719 indent (e, 2); 2720 fprintf (e, "%d%s\t /* Has %d elements. */\n", c, (c != 0 ? "," : ""), c); 2721 for (c = 1, fc = fontdir; fc != NULL; fc = fc->next, c++) 2722 { 2723 indent (e, 4); 2724 fprintf (e, "%d,\t/* Font no %d with index %d. */\n", 2725 (int) fc->index, c, (int) fc->index); 2726 write_rc_datablock (e, (rc_uint_type) fc->length - 2, 2727 (const bfd_byte *) fc->data + 4,fc->next != NULL, 2728 0, 0); 2729 } 2730 fprintf (e, "END\n"); 2731 } 2732 2733 /* Write out group icon data. This would normally be built from the 2734 icon data. */ 2735 2736 static void 2737 write_rc_group_icon (FILE *e, const rc_group_icon *group_icon) 2738 { 2739 const rc_group_icon *gi; 2740 int c; 2741 2742 for (c = 0, gi = group_icon; gi != NULL; gi = gi->next, c++) 2743 ; 2744 2745 fprintf (e, "BEGIN\n"); 2746 indent (e, 2); 2747 fprintf (e, " 0, 1, %d%s\t /* Has %d elements. */\n", c, (c != 0 ? "," : ""), c); 2748 2749 indent (e, 4); 2750 fprintf (e, "/* \"width height colors pad\", planes, bits, bytes, index. */\n"); 2751 for (c = 1, gi = group_icon; gi != NULL; gi = gi->next, c++) 2752 { 2753 indent (e, 4); 2754 fprintf (e, "\"\\%03o\\%03o\\%03o\\%03o\", %d, %d, 0x%xL, %d%s\t/* Element no %d. */\n", 2755 gi->width, gi->height, gi->colors, 0, (int) gi->planes, (int) gi->bits, 2756 (unsigned int) gi->bytes, (int) gi->index, (gi->next != NULL ? "," : ""), c); 2757 } 2758 fprintf (e, "END\n"); 2759 } 2760 2761 /* Write out a menu resource. */ 2762 2763 static void 2764 write_rc_menu (FILE *e, const rc_menu *menu, int menuex) 2765 { 2766 if (menu->help != 0) 2767 fprintf (e, "// Help ID: %u\n", (unsigned int) menu->help); 2768 write_rc_menuitems (e, menu->items, menuex, 0); 2769 } 2770 2771 static void 2772 write_rc_toolbar (FILE *e, const rc_toolbar *tb) 2773 { 2774 rc_toolbar_item *it; 2775 indent (e, 0); 2776 fprintf (e, "BEGIN\n"); 2777 it = tb->items; 2778 while(it != NULL) 2779 { 2780 indent (e, 2); 2781 if (it->id.u.id == 0) 2782 fprintf (e, "SEPARATOR\n"); 2783 else 2784 fprintf (e, "BUTTON %d\n", (int) it->id.u.id); 2785 it = it->next; 2786 } 2787 indent (e, 0); 2788 fprintf (e, "END\n"); 2789 } 2790 2791 /* Write out menuitems. */ 2792 2793 static void 2794 write_rc_menuitems (FILE *e, const rc_menuitem *menuitems, int menuex, 2795 int ind) 2796 { 2797 const rc_menuitem *mi; 2798 2799 indent (e, ind); 2800 fprintf (e, "BEGIN\n"); 2801 2802 for (mi = menuitems; mi != NULL; mi = mi->next) 2803 { 2804 indent (e, ind + 2); 2805 2806 if (mi->popup == NULL) 2807 fprintf (e, "MENUITEM"); 2808 else 2809 fprintf (e, "POPUP"); 2810 2811 if (! menuex 2812 && mi->popup == NULL 2813 && mi->text == NULL 2814 && mi->type == 0 2815 && mi->id == 0) 2816 { 2817 fprintf (e, " SEPARATOR\n"); 2818 continue; 2819 } 2820 2821 if (mi->text == NULL) 2822 fprintf (e, " \"\""); 2823 else 2824 { 2825 fprintf (e, " "); 2826 unicode_print_quoted (e, mi->text, -1); 2827 } 2828 2829 if (! menuex) 2830 { 2831 if (mi->popup == NULL) 2832 fprintf (e, ", %d", (int) mi->id); 2833 2834 if ((mi->type & MENUITEM_CHECKED) != 0) 2835 fprintf (e, ", CHECKED"); 2836 if ((mi->type & MENUITEM_GRAYED) != 0) 2837 fprintf (e, ", GRAYED"); 2838 if ((mi->type & MENUITEM_HELP) != 0) 2839 fprintf (e, ", HELP"); 2840 if ((mi->type & MENUITEM_INACTIVE) != 0) 2841 fprintf (e, ", INACTIVE"); 2842 if ((mi->type & MENUITEM_MENUBARBREAK) != 0) 2843 fprintf (e, ", MENUBARBREAK"); 2844 if ((mi->type & MENUITEM_MENUBREAK) != 0) 2845 fprintf (e, ", MENUBREAK"); 2846 if ((mi->type & MENUITEM_OWNERDRAW) != 0) 2847 fprintf (e, ", OWNERDRAW"); 2848 if ((mi->type & MENUITEM_BITMAP) != 0) 2849 fprintf (e, ", BITMAP"); 2850 } 2851 else 2852 { 2853 if (mi->id != 0 || mi->type != 0 || mi->state != 0 || mi->help != 0) 2854 { 2855 fprintf (e, ", %d", (int) mi->id); 2856 if (mi->type != 0 || mi->state != 0 || mi->help != 0) 2857 { 2858 fprintf (e, ", %u", (unsigned int) mi->type); 2859 if (mi->state != 0 || mi->help != 0) 2860 { 2861 fprintf (e, ", %u", (unsigned int) mi->state); 2862 if (mi->help != 0) 2863 fprintf (e, ", %u", (unsigned int) mi->help); 2864 } 2865 } 2866 } 2867 } 2868 2869 fprintf (e, "\n"); 2870 2871 if (mi->popup != NULL) 2872 write_rc_menuitems (e, mi->popup, menuex, ind + 2); 2873 } 2874 2875 indent (e, ind); 2876 fprintf (e, "END\n"); 2877 } 2878 2879 static int 2880 test_rc_datablock_unicode (rc_uint_type length, const bfd_byte *data) 2881 { 2882 rc_uint_type i; 2883 if ((length & 1) != 0) 2884 return 0; 2885 2886 for (i = 0; i < length; i += 2) 2887 { 2888 if (data[i] == 0 && data[i + 1] == 0 && (i + 2) < length) 2889 return 0; 2890 if (data[i] == 0xff && data[i + 1] == 0xff) 2891 return 0; 2892 } 2893 return 1; 2894 } 2895 2896 static int 2897 test_rc_datablock_text (rc_uint_type length, const bfd_byte *data) 2898 { 2899 int has_nl; 2900 rc_uint_type c; 2901 rc_uint_type i; 2902 2903 if (length <= 1) 2904 return 0; 2905 2906 has_nl = 0; 2907 for (i = 0, c = 0; i < length; i++) 2908 { 2909 if (! ISPRINT (data[i]) && data[i] != '\n' 2910 && ! (data[i] == '\r' && (i + 1) < length && data[i + 1] == '\n') 2911 && data[i] != '\t' 2912 && ! (data[i] == 0 && (i + 1) != length)) 2913 { 2914 if (data[i] <= 7) 2915 return 0; 2916 c++; 2917 } 2918 else if (data[i] == '\n') has_nl++; 2919 } 2920 if (length > 80 && ! has_nl) 2921 return 0; 2922 c = (((c * 10000) + (i / 100) - 1)) / i; 2923 if (c >= 150) 2924 return 0; 2925 return 1; 2926 } 2927 2928 static void 2929 write_rc_messagetable (FILE *e, rc_uint_type length, const bfd_byte *data) 2930 { 2931 int has_error = 0; 2932 const struct bin_messagetable *mt; 2933 2934 fprintf (e, "BEGIN\n"); 2935 2936 write_rc_datablock (e, length, data, 0, 0, 0); 2937 2938 fprintf (e, "\n"); 2939 wr_printcomment (e, "MC syntax dump"); 2940 if (length < BIN_MESSAGETABLE_SIZE) 2941 has_error = 1; 2942 else 2943 do 2944 { 2945 rc_uint_type m, i; 2946 2947 mt = (const struct bin_messagetable *) data; 2948 m = windres_get_32 (&wrtarget, mt->cblocks, length); 2949 2950 if (length < (BIN_MESSAGETABLE_SIZE + m * BIN_MESSAGETABLE_BLOCK_SIZE)) 2951 { 2952 has_error = 1; 2953 break; 2954 } 2955 for (i = 0; i < m; i++) 2956 { 2957 rc_uint_type low, high, offset; 2958 const struct bin_messagetable_item *mti; 2959 2960 low = windres_get_32 (&wrtarget, mt->items[i].lowid, 4); 2961 high = windres_get_32 (&wrtarget, mt->items[i].highid, 4); 2962 offset = windres_get_32 (&wrtarget, mt->items[i].offset, 4); 2963 2964 while (low <= high) 2965 { 2966 rc_uint_type elen, flags; 2967 if ((offset + BIN_MESSAGETABLE_ITEM_SIZE) > length) 2968 { 2969 has_error = 1; 2970 break; 2971 } 2972 mti = (const struct bin_messagetable_item *) &data[offset]; 2973 elen = windres_get_16 (&wrtarget, mti->length, 2); 2974 flags = windres_get_16 (&wrtarget, mti->flags, 2); 2975 if ((offset + elen) > length) 2976 { 2977 has_error = 1; 2978 break; 2979 } 2980 wr_printcomment (e, "MessageId = 0x%x", low); 2981 wr_printcomment (e, ""); 2982 2983 if ((flags & MESSAGE_RESOURCE_UNICODE) == MESSAGE_RESOURCE_UNICODE) 2984 { 2985 /* PR 17512: file: 5c3232dc. */ 2986 if (elen > BIN_MESSAGETABLE_ITEM_SIZE * 2) 2987 unicode_print (e, (const unichar *) mti->data, 2988 (elen - BIN_MESSAGETABLE_ITEM_SIZE) / 2); 2989 } 2990 else 2991 { 2992 if (elen > BIN_MESSAGETABLE_ITEM_SIZE) 2993 ascii_print (e, (const char *) mti->data, 2994 (elen - BIN_MESSAGETABLE_ITEM_SIZE)); 2995 } 2996 2997 wr_printcomment (e,""); 2998 ++low; 2999 offset += elen; 3000 } 3001 } 3002 } 3003 while (0); 3004 3005 if (has_error) 3006 wr_printcomment (e, "Illegal data"); 3007 wr_print_flush (e); 3008 fprintf (e, "END\n"); 3009 } 3010 3011 static void 3012 write_rc_datablock (FILE *e, rc_uint_type length, const bfd_byte *data, int has_next, 3013 int hasblock, int show_comment) 3014 { 3015 int plen; 3016 3017 if (hasblock) 3018 fprintf (e, "BEGIN\n"); 3019 3020 if (show_comment == -1) 3021 { 3022 if (test_rc_datablock_text(length, data)) 3023 { 3024 rc_uint_type i, c; 3025 for (i = 0; i < length;) 3026 { 3027 indent (e, 2); 3028 fprintf (e, "\""); 3029 3030 for (c = 0; i < length && c < 160 && data[i] != '\n'; c++, i++) 3031 ; 3032 if (i < length && data[i] == '\n') 3033 ++i, ++c; 3034 ascii_print(e, (const char *) &data[i - c], c); 3035 fprintf (e, "\""); 3036 if (i < length) 3037 fprintf (e, "\n"); 3038 } 3039 3040 if (i == 0) 3041 { 3042 indent (e, 2); 3043 fprintf (e, "\"\""); 3044 } 3045 if (has_next) 3046 fprintf (e, ","); 3047 fprintf (e, "\n"); 3048 if (hasblock) 3049 fprintf (e, "END\n"); 3050 return; 3051 } 3052 if (test_rc_datablock_unicode (length, data)) 3053 { 3054 rc_uint_type i, c; 3055 for (i = 0; i < length;) 3056 { 3057 const unichar *u; 3058 3059 u = (const unichar *) &data[i]; 3060 indent (e, 2); 3061 fprintf (e, "L\""); 3062 3063 for (c = 0; i < length && c < 160 && u[c] != '\n'; c++, i += 2) 3064 ; 3065 if (i < length && u[c] == '\n') 3066 i += 2, ++c; 3067 unicode_print (e, u, c); 3068 fprintf (e, "\""); 3069 if (i < length) 3070 fprintf (e, "\n"); 3071 } 3072 3073 if (i == 0) 3074 { 3075 indent (e, 2); 3076 fprintf (e, "L\"\""); 3077 } 3078 if (has_next) 3079 fprintf (e, ","); 3080 fprintf (e, "\n"); 3081 if (hasblock) 3082 fprintf (e, "END\n"); 3083 return; 3084 } 3085 3086 show_comment = 0; 3087 } 3088 3089 if (length != 0) 3090 { 3091 rc_uint_type i, max_row; 3092 int first = 1; 3093 3094 max_row = (show_comment ? 4 : 8); 3095 indent (e, 2); 3096 for (i = 0; i + 3 < length;) 3097 { 3098 rc_uint_type k; 3099 rc_uint_type comment_start; 3100 3101 comment_start = i; 3102 3103 if (! first) 3104 indent (e, 2); 3105 3106 for (k = 0; k < max_row && i + 3 < length; k++, i += 4) 3107 { 3108 if (k == 0) 3109 plen = fprintf (e, "0x%lxL", 3110 (unsigned long) windres_get_32 (&wrtarget, data + i, length - i)); 3111 else 3112 plen = fprintf (e, " 0x%lxL", 3113 (unsigned long) windres_get_32 (&wrtarget, data + i, length - i)) - 1; 3114 if (has_next || (i + 4) < length) 3115 { 3116 if (plen>0 && plen < 11) 3117 indent (e, 11 - plen); 3118 fprintf (e, ","); 3119 } 3120 } 3121 if (show_comment) 3122 { 3123 fprintf (e, "\t/* "); 3124 ascii_print (e, (const char *) &data[comment_start], i - comment_start); 3125 fprintf (e, ". */"); 3126 } 3127 fprintf (e, "\n"); 3128 first = 0; 3129 } 3130 3131 if (i + 1 < length) 3132 { 3133 if (! first) 3134 indent (e, 2); 3135 plen = fprintf (e, "0x%x", 3136 (int) windres_get_16 (&wrtarget, data + i, length - i)); 3137 if (has_next || i + 2 < length) 3138 { 3139 if (plen > 0 && plen < 11) 3140 indent (e, 11 - plen); 3141 fprintf (e, ","); 3142 } 3143 if (show_comment) 3144 { 3145 fprintf (e, "\t/* "); 3146 ascii_print (e, (const char *) &data[i], 2); 3147 fprintf (e, ". */"); 3148 } 3149 fprintf (e, "\n"); 3150 i += 2; 3151 first = 0; 3152 } 3153 3154 if (i < length) 3155 { 3156 if (! first) 3157 indent (e, 2); 3158 fprintf (e, "\""); 3159 ascii_print (e, (const char *) &data[i], 1); 3160 fprintf (e, "\""); 3161 if (has_next) 3162 fprintf (e, ","); 3163 fprintf (e, "\n"); 3164 first = 0; 3165 } 3166 } 3167 if (hasblock) 3168 fprintf (e, "END\n"); 3169 } 3170 3171 /* Write out an rcdata resource. This is also used for other types of 3172 resources that need to print arbitrary data. */ 3173 3174 static void 3175 write_rc_rcdata (FILE *e, const rc_rcdata_item *rcdata, int ind) 3176 { 3177 const rc_rcdata_item *ri; 3178 3179 indent (e, ind); 3180 fprintf (e, "BEGIN\n"); 3181 3182 for (ri = rcdata; ri != NULL; ri = ri->next) 3183 { 3184 if (ri->type == RCDATA_BUFFER && ri->u.buffer.length == 0) 3185 continue; 3186 3187 switch (ri->type) 3188 { 3189 default: 3190 abort (); 3191 3192 case RCDATA_WORD: 3193 indent (e, ind + 2); 3194 fprintf (e, "%ld", (long) (ri->u.word & 0xffff)); 3195 break; 3196 3197 case RCDATA_DWORD: 3198 indent (e, ind + 2); 3199 fprintf (e, "%luL", (unsigned long) ri->u.dword); 3200 break; 3201 3202 case RCDATA_STRING: 3203 indent (e, ind + 2); 3204 fprintf (e, "\""); 3205 ascii_print (e, ri->u.string.s, ri->u.string.length); 3206 fprintf (e, "\""); 3207 break; 3208 3209 case RCDATA_WSTRING: 3210 indent (e, ind + 2); 3211 fprintf (e, "L\""); 3212 unicode_print (e, ri->u.wstring.w, ri->u.wstring.length); 3213 fprintf (e, "\""); 3214 break; 3215 3216 case RCDATA_BUFFER: 3217 write_rc_datablock (e, (rc_uint_type) ri->u.buffer.length, 3218 (const bfd_byte *) ri->u.buffer.data, 3219 ri->next != NULL, 0, -1); 3220 break; 3221 } 3222 3223 if (ri->type != RCDATA_BUFFER) 3224 { 3225 if (ri->next != NULL) 3226 fprintf (e, ","); 3227 fprintf (e, "\n"); 3228 } 3229 } 3230 3231 indent (e, ind); 3232 fprintf (e, "END\n"); 3233 } 3234 3235 /* Write out a stringtable resource. */ 3236 3237 static void 3238 write_rc_stringtable (FILE *e, const rc_res_id *name, 3239 const rc_stringtable *stringtable) 3240 { 3241 rc_uint_type offset; 3242 int i; 3243 3244 if (name != NULL && ! name->named) 3245 offset = (name->u.id - 1) << 4; 3246 else 3247 { 3248 fprintf (e, "/* %s string table name. */\n", 3249 name == NULL ? "Missing" : "Invalid"); 3250 offset = 0; 3251 } 3252 3253 fprintf (e, "BEGIN\n"); 3254 3255 for (i = 0; i < 16; i++) 3256 { 3257 if (stringtable->strings[i].length != 0) 3258 { 3259 fprintf (e, " %lu, ", (unsigned long) offset + i); 3260 unicode_print_quoted (e, stringtable->strings[i].string, 3261 stringtable->strings[i].length); 3262 fprintf (e, "\n"); 3263 } 3264 } 3265 3266 fprintf (e, "END\n"); 3267 } 3268 3269 /* Write out a versioninfo resource. */ 3270 3271 static void 3272 write_rc_versioninfo (FILE *e, const rc_versioninfo *versioninfo) 3273 { 3274 const rc_fixed_versioninfo *f; 3275 const rc_ver_info *vi; 3276 3277 f = versioninfo->fixed; 3278 if (f->file_version_ms != 0 || f->file_version_ls != 0) 3279 fprintf (e, " FILEVERSION %u, %u, %u, %u\n", 3280 (unsigned int) ((f->file_version_ms >> 16) & 0xffff), 3281 (unsigned int) (f->file_version_ms & 0xffff), 3282 (unsigned int) ((f->file_version_ls >> 16) & 0xffff), 3283 (unsigned int) (f->file_version_ls & 0xffff)); 3284 if (f->product_version_ms != 0 || f->product_version_ls != 0) 3285 fprintf (e, " PRODUCTVERSION %u, %u, %u, %u\n", 3286 (unsigned int) ((f->product_version_ms >> 16) & 0xffff), 3287 (unsigned int) (f->product_version_ms & 0xffff), 3288 (unsigned int) ((f->product_version_ls >> 16) & 0xffff), 3289 (unsigned int) (f->product_version_ls & 0xffff)); 3290 if (f->file_flags_mask != 0) 3291 fprintf (e, " FILEFLAGSMASK 0x%x\n", (unsigned int) f->file_flags_mask); 3292 if (f->file_flags != 0) 3293 fprintf (e, " FILEFLAGS 0x%x\n", (unsigned int) f->file_flags); 3294 if (f->file_os != 0) 3295 fprintf (e, " FILEOS 0x%x\n", (unsigned int) f->file_os); 3296 if (f->file_type != 0) 3297 fprintf (e, " FILETYPE 0x%x\n", (unsigned int) f->file_type); 3298 if (f->file_subtype != 0) 3299 fprintf (e, " FILESUBTYPE 0x%x\n", (unsigned int) f->file_subtype); 3300 if (f->file_date_ms != 0 || f->file_date_ls != 0) 3301 fprintf (e, "/* Date: %u, %u. */\n", 3302 (unsigned int) f->file_date_ms, (unsigned int) f->file_date_ls); 3303 3304 fprintf (e, "BEGIN\n"); 3305 3306 for (vi = versioninfo->var; vi != NULL; vi = vi->next) 3307 { 3308 switch (vi->type) 3309 { 3310 case VERINFO_STRING: 3311 { 3312 const rc_ver_stringtable *vst; 3313 const rc_ver_stringinfo *vs; 3314 3315 fprintf (e, " BLOCK \"StringFileInfo\"\n"); 3316 fprintf (e, " BEGIN\n"); 3317 3318 for (vst = vi->u.string.stringtables; vst != NULL; vst = vst->next) 3319 { 3320 fprintf (e, " BLOCK "); 3321 unicode_print_quoted (e, vst->language, -1); 3322 3323 fprintf (e, "\n"); 3324 fprintf (e, " BEGIN\n"); 3325 3326 for (vs = vst->strings; vs != NULL; vs = vs->next) 3327 { 3328 fprintf (e, " VALUE "); 3329 unicode_print_quoted (e, vs->key, -1); 3330 fprintf (e, ", "); 3331 unicode_print_quoted (e, vs->value, -1); 3332 fprintf (e, "\n"); 3333 } 3334 3335 fprintf (e, " END\n"); 3336 } 3337 fprintf (e, " END\n"); 3338 break; 3339 } 3340 3341 case VERINFO_VAR: 3342 { 3343 const rc_ver_varinfo *vv; 3344 3345 fprintf (e, " BLOCK \"VarFileInfo\"\n"); 3346 fprintf (e, " BEGIN\n"); 3347 fprintf (e, " VALUE "); 3348 unicode_print_quoted (e, vi->u.var.key, -1); 3349 3350 for (vv = vi->u.var.var; vv != NULL; vv = vv->next) 3351 fprintf (e, ", 0x%x, %d", (unsigned int) vv->language, 3352 (int) vv->charset); 3353 3354 fprintf (e, "\n END\n"); 3355 3356 break; 3357 } 3358 } 3359 } 3360 3361 fprintf (e, "END\n"); 3362 } 3363 3364 static rc_uint_type 3365 rcdata_copy (const rc_rcdata_item *src, bfd_byte *dst) 3366 { 3367 if (! src) 3368 return 0; 3369 switch (src->type) 3370 { 3371 case RCDATA_WORD: 3372 if (dst) 3373 windres_put_16 (&wrtarget, dst, (rc_uint_type) src->u.word); 3374 return 2; 3375 case RCDATA_DWORD: 3376 if (dst) 3377 windres_put_32 (&wrtarget, dst, (rc_uint_type) src->u.dword); 3378 return 4; 3379 case RCDATA_STRING: 3380 if (dst && src->u.string.length) 3381 memcpy (dst, src->u.string.s, src->u.string.length); 3382 return (rc_uint_type) src->u.string.length; 3383 case RCDATA_WSTRING: 3384 if (dst && src->u.wstring.length) 3385 memcpy (dst, src->u.wstring.w, src->u.wstring.length * sizeof (unichar)); 3386 return (rc_uint_type) (src->u.wstring.length * sizeof (unichar)); 3387 case RCDATA_BUFFER: 3388 if (dst && src->u.buffer.length) 3389 memcpy (dst, src->u.buffer.data, src->u.buffer.length); 3390 return (rc_uint_type) src->u.buffer.length; 3391 default: 3392 abort (); 3393 } 3394 /* Never reached. */ 3395 return 0; 3396 } 3397