1 /* windres.c -- a program to manipulate Windows resources
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5 Rewritten by Kai Tietz, Onevision.
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* This program can read and write Windows resources in various
25 formats. In particular, it can act like the rc resource compiler
26 program, and it can act like the cvtres res to COFF conversion
29 It is based on information taken from the following sources:
31 * Microsoft documentation.
33 * The rcl program, written by Gunther Ebert
34 <gunther.ebert@ixos-leipzig.de>.
36 * The res2coff program, written by Pedro A. Aranda <paag@tid.es>. */
44 #include "libiberty.h"
45 #include "safe-ctype.h"
49 /* Defined in bfd/binary.c. Used to set architecture and machine of input
51 extern enum bfd_architecture bfd_external_binary_architecture
;
52 extern unsigned long bfd_external_machine
;
54 /* Used by resrc.c at least. */
58 int target_is_bigendian
= 0;
59 const char *def_target_arch
;
61 static void set_endianess (bfd
*, const char *);
63 /* An enumeration of format types. */
69 /* Textual RC file. */
71 /* Binary RES file. */
77 /* A structure used to map between format types and strings. */
82 enum res_format format
;
85 /* A mapping between names and format types. */
87 static const struct format_map format_names
[] =
89 { "rc", RES_FORMAT_RC
},
90 { "res", RES_FORMAT_RES
},
91 { "coff", RES_FORMAT_COFF
},
92 { NULL
, RES_FORMAT_UNKNOWN
}
95 /* A mapping from file extensions to format types. */
97 static const struct format_map format_fileexts
[] =
99 { "rc", RES_FORMAT_RC
},
100 { "res", RES_FORMAT_RES
},
101 { "exe", RES_FORMAT_COFF
},
102 { "obj", RES_FORMAT_COFF
},
103 { "o", RES_FORMAT_COFF
},
104 { NULL
, RES_FORMAT_UNKNOWN
}
107 /* A list of include directories. */
111 struct include_dir
*next
;
115 static struct include_dir
*include_dirs
;
117 /* Static functions. */
119 static void res_init (void);
120 static int extended_menuitems (const rc_menuitem
*);
121 static enum res_format
format_from_name (const char *, int);
122 static enum res_format
format_from_filename (const char *, int);
123 static void usage (FILE *, int);
124 static int cmp_res_entry (const void *, const void *);
125 static rc_res_directory
*sort_resources (rc_res_directory
*);
126 static void reswr_init (void);
127 static const char * quot (const char *);
129 static rc_uint_type
target_get_8 (const void *, rc_uint_type
);
130 static void target_put_8 (void *, rc_uint_type
);
131 static rc_uint_type
target_get_16 (const void *, rc_uint_type
);
132 static void target_put_16 (void *, rc_uint_type
);
133 static rc_uint_type
target_get_32 (const void *, rc_uint_type
);
134 static void target_put_32 (void *, rc_uint_type
);
137 /* When we are building a resource tree, we allocate everything onto
138 an obstack, so that we can free it all at once if we want. */
140 #define obstack_chunk_alloc xmalloc
141 #define obstack_chunk_free free
143 /* The resource building obstack. */
145 static struct obstack res_obstack
;
147 /* Initialize the resource building obstack. */
152 obstack_init (&res_obstack
);
155 /* Allocate space on the resource building obstack. */
158 res_alloc (rc_uint_type bytes
)
160 return (void *) obstack_alloc (&res_obstack
, (size_t) bytes
);
163 /* We also use an obstack to save memory used while writing out a set
166 static struct obstack reswr_obstack
;
168 /* Initialize the resource writing obstack. */
173 obstack_init (&reswr_obstack
);
176 /* Allocate space on the resource writing obstack. */
179 reswr_alloc (rc_uint_type bytes
)
181 return (void *) obstack_alloc (&reswr_obstack
, (size_t) bytes
);
184 /* Open a file using the include directory search list. */
187 open_file_search (const char *filename
, const char *mode
, const char *errmsg
,
188 char **real_filename
)
191 struct include_dir
*d
;
193 e
= fopen (filename
, mode
);
196 *real_filename
= xstrdup (filename
);
202 for (d
= include_dirs
; d
!= NULL
; d
= d
->next
)
206 n
= (char *) xmalloc (strlen (d
->dir
) + strlen (filename
) + 2);
207 sprintf (n
, "%s/%s", d
->dir
, filename
);
220 fatal (_("can't open %s `%s': %s"), errmsg
, filename
, strerror (errno
));
222 /* Return a value to avoid a compiler warning. */
226 /* Compare two resource ID's. We consider name entries to come before
227 numeric entries, because that is how they appear in the COFF .rsrc
231 res_id_cmp (rc_res_id a
, rc_res_id b
)
239 else if (a
.u
.id
< b
.u
.id
)
246 unichar
*as
, *ase
, *bs
, *bse
;
252 ase
= as
+ a
.u
.n
.length
;
254 bse
= bs
+ b
.u
.n
.length
;
262 i
= (int) *as
- (int) *bs
;
276 /* Print a resource ID. */
279 res_id_print (FILE *stream
, rc_res_id id
, int quote
)
282 fprintf (stream
, "%u", (int) id
.u
.id
);
286 unicode_print_quoted (stream
, id
.u
.n
.name
, id
.u
.n
.length
);
288 unicode_print (stream
, id
.u
.n
.name
, id
.u
.n
.length
);
292 /* Print a list of resource ID's. */
295 res_ids_print (FILE *stream
, int cids
, const rc_res_id
*ids
)
299 for (i
= 0; i
< cids
; i
++)
301 res_id_print (stream
, ids
[i
], 1);
303 fprintf (stream
, ": ");
307 /* Convert an ASCII string to a resource ID. */
310 res_string_to_id (rc_res_id
*res_id
, const char *string
)
313 unicode_from_ascii (&res_id
->u
.n
.length
, &res_id
->u
.n
.name
, string
);
316 /* Convert an unicode string to a resource ID. */
318 res_unistring_to_id (rc_res_id
*res_id
, const unichar
*u
)
321 res_id
->u
.n
.length
= unichar_len (u
);
322 res_id
->u
.n
.name
= unichar_dup_uppercase (u
);
325 /* Define a resource. The arguments are the resource tree, RESOURCES,
326 and the location at which to put it in the tree, CIDS and IDS.
327 This returns a newly allocated rc_res_resource structure, which the
328 caller is expected to initialize. If DUPOK is non-zero, then if a
329 resource with this ID exists, it is returned. Otherwise, a warning
330 is issued, and a new resource is created replacing the existing
334 define_resource (rc_res_directory
**resources
, int cids
,
335 const rc_res_id
*ids
, int dupok
)
337 rc_res_entry
*re
= NULL
;
341 for (i
= 0; i
< cids
; i
++)
345 if (*resources
== NULL
)
347 static unsigned int timeval
;
349 /* Use the same timestamp for every resource created in a
352 timeval
= time (NULL
);
354 *resources
= ((rc_res_directory
*)
355 res_alloc (sizeof (rc_res_directory
)));
356 (*resources
)->characteristics
= 0;
357 (*resources
)->time
= timeval
;
358 (*resources
)->major
= 0;
359 (*resources
)->minor
= 0;
360 (*resources
)->entries
= NULL
;
363 for (pp
= &(*resources
)->entries
; *pp
!= NULL
; pp
= &(*pp
)->next
)
364 if (res_id_cmp ((*pp
)->id
, ids
[i
]) == 0)
371 re
= (rc_res_entry
*) res_alloc (sizeof (rc_res_entry
));
392 fprintf (stderr
, "%s: ", program_name
);
393 res_ids_print (stderr
, i
, ids
);
394 fprintf (stderr
, _(": expected to be a directory\n"));
398 resources
= &re
->u
.dir
;
404 fprintf (stderr
, "%s: ", program_name
);
405 res_ids_print (stderr
, cids
, ids
);
406 fprintf (stderr
, _(": expected to be a leaf\n"));
410 if (re
->u
.res
!= NULL
)
415 fprintf (stderr
, _("%s: warning: "), program_name
);
416 res_ids_print (stderr
, cids
, ids
);
417 fprintf (stderr
, _(": duplicate value\n"));
420 re
->u
.res
= ((rc_res_resource
*)
421 res_alloc (sizeof (rc_res_resource
)));
422 memset (re
->u
.res
, 0, sizeof (rc_res_resource
));
424 re
->u
.res
->type
= RES_TYPE_UNINITIALIZED
;
428 /* Define a standard resource. This is a version of define_resource
429 that just takes type, name, and language arguments. */
432 define_standard_resource (rc_res_directory
**resources
, int type
,
433 rc_res_id name
, rc_uint_type language
, int dupok
)
441 a
[2].u
.id
= language
;
442 return define_resource (resources
, 3, a
, dupok
);
445 /* Comparison routine for resource sorting. */
448 cmp_res_entry (const void *p1
, const void *p2
)
450 const rc_res_entry
**re1
, **re2
;
452 re1
= (const rc_res_entry
**) p1
;
453 re2
= (const rc_res_entry
**) p2
;
454 return res_id_cmp ((*re1
)->id
, (*re2
)->id
);
457 /* Sort the resources. */
459 static rc_res_directory
*
460 sort_resources (rc_res_directory
*resdir
)
466 if (resdir
->entries
== NULL
)
470 for (re
= resdir
->entries
; re
!= NULL
; re
= re
->next
)
473 /* This is a recursive routine, so using xmalloc is probably better
475 a
= (rc_res_entry
**) xmalloc (c
* sizeof (rc_res_entry
*));
477 for (i
= 0, re
= resdir
->entries
; re
!= NULL
; re
= re
->next
, i
++)
480 qsort (a
, c
, sizeof (rc_res_entry
*), cmp_res_entry
);
482 resdir
->entries
= a
[0];
483 for (i
= 0; i
< c
- 1; i
++)
484 a
[i
]->next
= a
[i
+ 1];
489 /* Now sort the subdirectories. */
491 for (re
= resdir
->entries
; re
!= NULL
; re
= re
->next
)
493 re
->u
.dir
= sort_resources (re
->u
.dir
);
498 /* Return whether the dialog resource DIALOG is a DIALOG or a
502 extended_dialog (const rc_dialog
*dialog
)
504 const rc_dialog_control
*c
;
506 if (dialog
->ex
!= NULL
)
509 for (c
= dialog
->controls
; c
!= NULL
; c
= c
->next
)
510 if (c
->data
!= NULL
|| c
->help
!= 0)
516 /* Return whether MENUITEMS are a MENU or a MENUEX. */
519 extended_menu (const rc_menu
*menu
)
521 return extended_menuitems (menu
->items
);
525 extended_menuitems (const rc_menuitem
*menuitems
)
527 const rc_menuitem
*mi
;
529 for (mi
= menuitems
; mi
!= NULL
; mi
= mi
->next
)
531 if (mi
->help
!= 0 || mi
->state
!= 0)
533 if (mi
->popup
!= NULL
&& mi
->id
!= 0)
536 & ~ (MENUITEM_CHECKED
540 | MENUITEM_MENUBARBREAK
541 | MENUITEM_MENUBREAK
))
544 if (mi
->popup
!= NULL
)
546 if (extended_menuitems (mi
->popup
))
554 /* Convert a string to a format type, or exit if it can't be done. */
556 static enum res_format
557 format_from_name (const char *name
, int exit_on_error
)
559 const struct format_map
*m
;
561 for (m
= format_names
; m
->name
!= NULL
; m
++)
562 if (strcasecmp (m
->name
, name
) == 0)
565 if (m
->name
== NULL
&& exit_on_error
)
567 non_fatal (_("unknown format type `%s'"), name
);
568 fprintf (stderr
, _("%s: supported formats:"), program_name
);
569 for (m
= format_names
; m
->name
!= NULL
; m
++)
570 fprintf (stderr
, " %s", m
->name
);
571 fprintf (stderr
, "\n");
578 /* Work out a format type given a file name. If INPUT is non-zero,
579 it's OK to look at the file itself. */
581 static enum res_format
582 format_from_filename (const char *filename
, int input
)
586 bfd_byte b1
, b2
, b3
, b4
, b5
;
589 /* If we have an extension, see if we recognize it as implying a
590 particular format. */
591 ext
= strrchr (filename
, '.');
594 const struct format_map
*m
;
597 for (m
= format_fileexts
; m
->name
!= NULL
; m
++)
598 if (strcasecmp (m
->name
, ext
) == 0)
602 /* If we don't recognize the name of an output file, assume it's a
605 return RES_FORMAT_COFF
;
607 /* Read the first few bytes of the file to see if we can guess what
609 e
= fopen (filename
, FOPEN_RB
);
611 fatal ("%s: %s", filename
, strerror (errno
));
621 /* A PE executable starts with 0x4d 0x5a. */
622 if (b1
== 0x4d && b2
== 0x5a)
623 return RES_FORMAT_COFF
;
625 /* A COFF .o file starts with a COFF magic number. */
626 magic
= (b2
<< 8) | b1
;
629 case 0x14c: /* i386 */
630 case 0x166: /* MIPS */
631 case 0x184: /* Alpha */
632 case 0x268: /* 68k */
633 case 0x1f0: /* PowerPC */
635 return RES_FORMAT_COFF
;
638 /* A RES file starts with 0x0 0x0 0x0 0x0 0x20 0x0 0x0 0x0. */
639 if (b1
== 0 && b2
== 0 && b3
== 0 && b4
== 0 && b5
== 0x20)
640 return RES_FORMAT_RES
;
642 /* If every character is printable or space, assume it's an RC file. */
643 if ((ISPRINT (b1
) || ISSPACE (b1
))
644 && (ISPRINT (b2
) || ISSPACE (b2
))
645 && (ISPRINT (b3
) || ISSPACE (b3
))
646 && (ISPRINT (b4
) || ISSPACE (b4
))
647 && (ISPRINT (b5
) || ISSPACE (b5
)))
648 return RES_FORMAT_RC
;
650 /* Otherwise, we give up. */
651 fatal (_("can not determine type of file `%s'; use the -J option"),
654 /* Return something to silence the compiler warning. */
655 return RES_FORMAT_UNKNOWN
;
658 /* Print a usage message and exit. */
661 usage (FILE *stream
, int status
)
663 fprintf (stream
, _("Usage: %s [option(s)] [input-file] [output-file]\n"),
665 fprintf (stream
, _(" The options are:\n\
666 -i --input=<file> Name input file\n\
667 -o --output=<file> Name output file\n\
668 -J --input-format=<format> Specify input format\n\
669 -O --output-format=<format> Specify output format\n\
670 -F --target=<target> Specify COFF target\n\
671 --preprocessor=<program> Program to use to preprocess rc file\n\
672 -I --include-dir=<dir> Include directory when preprocessing rc file\n\
673 -D --define <sym>[=<val>] Define SYM when preprocessing rc file\n\
674 -U --undefine <sym> Undefine SYM when preprocessing rc file\n\
675 -v --verbose Verbose - tells you what it's doing\n\
676 -c --codepage=<codepage> Specify default codepage\n\
677 -l --language=<val> Set language when reading rc file\n\
678 --use-temp-file Use a temporary file instead of popen to read\n\
679 the preprocessor output\n\
680 --no-use-temp-file Use popen (default)\n"));
682 fprintf (stream
, _("\
683 --yydebug Turn on parser debugging\n"));
685 fprintf (stream
, _("\
686 -r Ignored for compatibility with rc\n\
687 @<file> Read options from <file>\n\
688 -h --help Print this help message\n\
689 -V --version Print version information\n"));
690 fprintf (stream
, _("\
691 FORMAT is one of rc, res, or coff, and is deduced from the file name\n\
692 extension if not specified. A single file name is an input file.\n\
693 No input-file is stdin, default rc. No output-file is stdout, default rc.\n"));
695 list_supported_targets (program_name
, stream
);
697 if (REPORT_BUGS_TO
[0] && status
== 0)
698 fprintf (stream
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
703 /* Quote characters that will confuse the shell when we run the preprocessor. */
706 quot (const char *string
)
708 static char *buf
= 0;
709 static int buflen
= 0;
710 int slen
= strlen (string
);
714 if ((buflen
< slen
* 2 + 2) || ! buf
)
716 buflen
= slen
* 2 + 2;
719 buf
= (char *) xmalloc (buflen
);
722 for (src
=string
, dest
=buf
; *src
; src
++, dest
++)
724 if (*src
== '(' || *src
== ')' || *src
== ' ')
734 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
736 #define OPTION_PREPROCESSOR 150
737 #define OPTION_USE_TEMP_FILE (OPTION_PREPROCESSOR + 1)
738 #define OPTION_NO_USE_TEMP_FILE (OPTION_USE_TEMP_FILE + 1)
739 #define OPTION_YYDEBUG (OPTION_NO_USE_TEMP_FILE + 1)
741 static const struct option long_options
[] =
743 {"input", required_argument
, 0, 'i'},
744 {"output", required_argument
, 0, 'o'},
745 {"input-format", required_argument
, 0, 'J'},
746 {"output-format", required_argument
, 0, 'O'},
747 {"target", required_argument
, 0, 'F'},
748 {"preprocessor", required_argument
, 0, OPTION_PREPROCESSOR
},
749 {"include-dir", required_argument
, 0, 'I'},
750 {"define", required_argument
, 0, 'D'},
751 {"undefine", required_argument
, 0, 'U'},
752 {"verbose", no_argument
, 0, 'v'},
753 {"codepage", required_argument
, 0, 'c'},
754 {"language", required_argument
, 0, 'l'},
755 {"use-temp-file", no_argument
, 0, OPTION_USE_TEMP_FILE
},
756 {"no-use-temp-file", no_argument
, 0, OPTION_NO_USE_TEMP_FILE
},
757 {"yydebug", no_argument
, 0, OPTION_YYDEBUG
},
758 {"version", no_argument
, 0, 'V'},
759 {"help", no_argument
, 0, 'h'},
760 {0, no_argument
, 0, 0}
763 /* This keeps gcc happy when using -Wmissing-prototypes -Wstrict-prototypes. */
764 int main (int, char **);
766 /* The main function. */
769 main (int argc
, char **argv
)
772 char *input_filename
;
773 char *output_filename
;
774 enum res_format input_format
;
775 enum res_format input_format_tmp
;
776 enum res_format output_format
;
780 const char *quotedarg
;
782 rc_res_directory
*resources
;
785 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
786 setlocale (LC_MESSAGES
, "");
788 #if defined (HAVE_SETLOCALE)
789 setlocale (LC_CTYPE
, "");
791 bindtextdomain (PACKAGE
, LOCALEDIR
);
792 textdomain (PACKAGE
);
794 program_name
= argv
[0];
795 xmalloc_set_program_name (program_name
);
797 expandargv (&argc
, &argv
);
800 set_default_bfd_target ();
804 input_filename
= NULL
;
805 output_filename
= NULL
;
806 input_format
= RES_FORMAT_UNKNOWN
;
807 output_format
= RES_FORMAT_UNKNOWN
;
811 language
= 0x409; /* LANG_ENGLISH, SUBLANG_ENGLISH_US. */
814 while ((c
= getopt_long (argc
, argv
, "c:f:i:l:o:I:J:O:F:D:U:rhHvV", long_options
,
823 if (optarg
[0] == '0' && (optarg
[1] == 'x' || optarg
[1] == 'X'))
824 ncp
= (rc_uint_type
) strtol (optarg
+ 2, NULL
, 16);
826 ncp
= (rc_uint_type
) strtol (optarg
, NULL
, 10);
827 if (ncp
== CP_UTF16
|| ! unicode_is_valid_codepage (ncp
))
828 fatal (_("invalid codepage specified.\n"));
829 wind_default_codepage
= wind_current_codepage
= ncp
;
834 input_filename
= optarg
;
838 /* For compatibility with rc we accept "-fo <name>" as being the
839 equivalent of "-o <name>". We do not advertise this fact
840 though, as we do not want users to use non-GNU like command
843 fatal (_("invalid option -f\n"));
848 fatal (_("No filename following the -fo option.\n"));
849 optarg
= argv
[optind
++];
854 output_filename
= optarg
;
858 input_format
= format_from_name (optarg
, 1);
862 output_format
= format_from_name (optarg
, 1);
869 case OPTION_PREPROCESSOR
:
870 preprocessor
= optarg
;
875 if (preprocargs
== NULL
)
877 quotedarg
= quot (optarg
);
878 preprocargs
= xmalloc (strlen (quotedarg
) + 3);
879 sprintf (preprocargs
, "-%c%s", c
, quotedarg
);
885 quotedarg
= quot (optarg
);
886 n
= xmalloc (strlen (preprocargs
) + strlen (quotedarg
) + 4);
887 sprintf (n
, "%s -%c%s", preprocargs
, c
, quotedarg
);
894 /* Ignored for compatibility with rc. */
902 /* For backward compatibility, should be removed in the future. */
903 input_format_tmp
= format_from_name (optarg
, 0);
904 if (input_format_tmp
!= RES_FORMAT_UNKNOWN
)
907 _("Option -I is deprecated for setting the input format, please use -J instead.\n"));
908 input_format
= input_format_tmp
;
912 if (preprocargs
== NULL
)
914 quotedarg
= quot (optarg
);
915 preprocargs
= xmalloc (strlen (quotedarg
) + 3);
916 sprintf (preprocargs
, "-I%s", quotedarg
);
922 quotedarg
= quot (optarg
);
923 n
= xmalloc (strlen (preprocargs
) + strlen (quotedarg
) + 4);
924 sprintf (n
, "%s -I%s", preprocargs
, quotedarg
);
930 struct include_dir
*n
, **pp
;
932 n
= (struct include_dir
*) xmalloc (sizeof *n
);
936 for (pp
= &include_dirs
; *pp
!= NULL
; pp
= &(*pp
)->next
)
944 language
= strtol (optarg
, (char **) NULL
, 16);
947 case OPTION_USE_TEMP_FILE
:
951 case OPTION_NO_USE_TEMP_FILE
:
967 print_version ("windres");
976 if (input_filename
== NULL
&& optind
< argc
)
978 input_filename
= argv
[optind
];
982 if (output_filename
== NULL
&& optind
< argc
)
984 output_filename
= argv
[optind
];
991 if (input_format
== RES_FORMAT_UNKNOWN
)
993 if (input_filename
== NULL
)
994 input_format
= RES_FORMAT_RC
;
996 input_format
= format_from_filename (input_filename
, 1);
999 if (output_format
== RES_FORMAT_UNKNOWN
)
1001 if (output_filename
== NULL
)
1002 output_format
= RES_FORMAT_RC
;
1004 output_format
= format_from_filename (output_filename
, 0);
1007 set_endianess (NULL
, target
);
1009 /* Read the input file. */
1010 switch (input_format
)
1015 resources
= read_rc_file (input_filename
, preprocessor
, preprocargs
,
1016 language
, use_temp_file
);
1018 case RES_FORMAT_RES
:
1019 resources
= read_res_file (input_filename
);
1021 case RES_FORMAT_COFF
:
1022 resources
= read_coff_rsrc (input_filename
, target
);
1026 if (resources
== NULL
)
1027 fatal (_("no resources"));
1029 /* Sort the resources. This is required for COFF, convenient for
1030 rc, and unimportant for res. */
1031 resources
= sort_resources (resources
);
1033 /* Write the output file. */
1036 switch (output_format
)
1041 write_rc_file (output_filename
, resources
);
1043 case RES_FORMAT_RES
:
1044 write_res_file (output_filename
, resources
);
1046 case RES_FORMAT_COFF
:
1047 write_coff_file (output_filename
, target
, resources
);
1055 static void set_endianess (bfd
*abfd
, const char *target
)
1057 const bfd_target
*target_vec
;
1059 def_target_arch
= NULL
;
1060 target_vec
= bfd_find_target (target
, abfd
);
1062 fatal ("Can't detect target endianess and architecture.");
1063 target_is_bigendian
= ((target_vec
->byteorder
== BFD_ENDIAN_BIG
) ? 1 : 0);
1065 const char *tname
= target_vec
->name
;
1066 const char **arch
= bfd_arch_list();
1069 if (strchr (tname
, '-') != NULL
)
1070 tname
= strchr (tname
, '-') + 1;
1071 while (*arch
!= NULL
)
1073 const char *in_a
= strstr (*arch
, tname
);
1074 char end_ch
= (in_a
? in_a
[strlen(tname
)] : 0);
1075 if (in_a
&& (in_a
== *arch
|| in_a
[-1] == ':')
1078 def_target_arch
= *arch
;
1084 if (! def_target_arch
)
1085 fatal ("Can't detect architecture.");
1090 windres_open_as_binary (const char *filename
, int rdmode
)
1094 abfd
= (rdmode
? bfd_openr (filename
, "binary") : bfd_openw (filename
, "binary"));
1096 fatal ("can't open `%s' for %s", filename
, (rdmode
? "input" : "output"));
1098 if (rdmode
&& ! bfd_check_format (abfd
, bfd_object
))
1099 fatal ("can't open `%s' for input.", filename
);
1105 set_windres_bfd_endianess (windres_bfd
*wrbfd
, int is_bigendian
)
1108 switch (WR_KIND(wrbfd
))
1110 case WR_KIND_BFD_BIN_L
:
1112 WR_KIND(wrbfd
) = WR_KIND_BFD_BIN_B
;
1114 case WR_KIND_BFD_BIN_B
:
1116 WR_KIND(wrbfd
) = WR_KIND_BFD_BIN_L
;
1119 /* only binary bfd can be overriden. */
1125 set_windres_bfd (windres_bfd
*wrbfd
, bfd
*abfd
, asection
*sec
, rc_uint_type kind
)
1130 case WR_KIND_TARGET
:
1135 case WR_KIND_BFD_BIN_L
:
1136 case WR_KIND_BFD_BIN_B
:
1143 WR_KIND(wrbfd
) = kind
;
1144 WR_BFD(wrbfd
) = abfd
;
1145 WR_SECTION(wrbfd
) = sec
;
1149 set_windres_bfd_content(windres_bfd
*wrbfd
, const void *data
, rc_uint_type off
,
1150 rc_uint_type length
)
1152 if (WR_KIND(wrbfd
) != WR_KIND_TARGET
)
1154 if (! bfd_set_section_contents (WR_BFD(wrbfd
), WR_SECTION(wrbfd
), data
, off
, length
))
1155 bfd_fatal ("bfd_set_section_contents");
1162 get_windres_bfd_content(windres_bfd
*wrbfd
, void *data
, rc_uint_type off
,
1163 rc_uint_type length
)
1165 if (WR_KIND(wrbfd
) != WR_KIND_TARGET
)
1167 if (! bfd_get_section_contents (WR_BFD(wrbfd
), WR_SECTION(wrbfd
), data
, off
, length
))
1168 bfd_fatal ("bfd_get_section_contents");
1175 windres_put_8 (windres_bfd
*wrbfd
, void *p
, rc_uint_type value
)
1177 switch (WR_KIND(wrbfd
))
1179 case WR_KIND_TARGET
:
1180 target_put_8 (p
, value
);
1183 case WR_KIND_BFD_BIN_L
:
1184 case WR_KIND_BFD_BIN_B
:
1185 bfd_put_8 (WR_BFD(wrbfd
), value
, p
);
1193 windres_put_16 (windres_bfd
*wrbfd
, void *data
, rc_uint_type value
)
1195 switch (WR_KIND(wrbfd
))
1197 case WR_KIND_TARGET
:
1198 target_put_16 (data
, value
);
1201 case WR_KIND_BFD_BIN_B
:
1202 bfd_put_16 (WR_BFD(wrbfd
), value
, data
);
1204 case WR_KIND_BFD_BIN_L
:
1205 bfd_putl16 (value
, data
);
1213 windres_put_32 (windres_bfd
*wrbfd
, void *data
, rc_uint_type value
)
1215 switch (WR_KIND(wrbfd
))
1217 case WR_KIND_TARGET
:
1218 target_put_32 (data
, value
);
1221 case WR_KIND_BFD_BIN_B
:
1222 bfd_put_32 (WR_BFD(wrbfd
), value
, data
);
1224 case WR_KIND_BFD_BIN_L
:
1225 bfd_putl32 (value
, data
);
1233 windres_get_8 (windres_bfd
*wrbfd
, const void *data
, rc_uint_type length
)
1236 fatal ("windres_get_8: unexpected eob.");
1237 switch (WR_KIND(wrbfd
))
1239 case WR_KIND_TARGET
:
1240 return target_get_8 (data
, length
);
1242 case WR_KIND_BFD_BIN_B
:
1243 case WR_KIND_BFD_BIN_L
:
1244 return bfd_get_8 (WR_BFD(wrbfd
), data
);
1252 windres_get_16 (windres_bfd
*wrbfd
, const void *data
, rc_uint_type length
)
1255 fatal ("windres_get_16: unexpected eob.");
1256 switch (WR_KIND(wrbfd
))
1258 case WR_KIND_TARGET
:
1259 return target_get_16 (data
, length
);
1261 case WR_KIND_BFD_BIN_B
:
1262 return bfd_get_16 (WR_BFD(wrbfd
), data
);
1263 case WR_KIND_BFD_BIN_L
:
1264 return bfd_getl16 (data
);
1272 windres_get_32 (windres_bfd
*wrbfd
, const void *data
, rc_uint_type length
)
1275 fatal ("windres_get_32: unexpected eob.");
1276 switch (WR_KIND(wrbfd
))
1278 case WR_KIND_TARGET
:
1279 return target_get_32 (data
, length
);
1281 case WR_KIND_BFD_BIN_B
:
1282 return bfd_get_32 (WR_BFD(wrbfd
), data
);
1283 case WR_KIND_BFD_BIN_L
:
1284 return bfd_getl32 (data
);
1292 target_get_8 (const void *p
, rc_uint_type length
)
1297 fatal ("Resource too small for getting 8-bit value.");
1299 ret
= (rc_uint_type
) *((const bfd_byte
*) p
);
1304 target_get_16 (const void *p
, rc_uint_type length
)
1307 fatal ("Resource too small for getting 16-bit value.");
1309 if (target_is_bigendian
)
1310 return bfd_getb16 (p
);
1312 return bfd_getl16 (p
);
1316 target_get_32 (const void *p
, rc_uint_type length
)
1319 fatal ("Resource too small for getting 32-bit value.");
1321 if (target_is_bigendian
)
1322 return bfd_getb32 (p
);
1324 return bfd_getl32 (p
);
1328 target_put_8 (void *p
, rc_uint_type value
)
1331 *((bfd_byte
*) p
)=(bfd_byte
) value
;
1335 target_put_16 (void *p
, rc_uint_type value
)
1339 if (target_is_bigendian
)
1340 bfd_putb16 (value
, p
);
1342 bfd_putl16 (value
, p
);
1346 target_put_32 (void *p
, rc_uint_type value
)
1350 if (target_is_bigendian
)
1351 bfd_putb32 (value
, p
);
1353 bfd_putl32 (value
, p
);
1356 static int isInComment
= 0;
1358 int wr_printcomment (FILE *e
, const char *fmt
, ...)
1364 r
+= fprintf (e
, "\n ");
1370 va_start (arg
, fmt
);
1371 r
+= vfprintf (e
, fmt
, arg
);
1376 int wr_print (FILE *e
, const char *fmt
, ...)
1381 r
+= fprintf (e
, ". */\n");
1385 va_start (arg
, fmt
);
1386 r
+= vfprintf (e
, fmt
, arg
);