daily update
[binutils.git] / binutils / resrc.c
blob8a5900bdc489bc86041cfd5898b3a3ee733ea8d7
1 /* resrc.c -- read and write Windows rc files.
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 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 3 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
22 02110-1301, USA. */
24 /* This file contains functions that read and write Windows rc files.
25 These are text files that represent resources. */
27 #include "sysdep.h"
28 #include "bfd.h"
29 #include "bucomm.h"
30 #include "libiberty.h"
31 #include "safe-ctype.h"
32 #include "windres.h"
34 #include <assert.h>
35 #include <errno.h>
36 #include <sys/stat.h>
37 #ifdef HAVE_UNISTD_H
38 #include <unistd.h>
39 #endif
41 #ifdef HAVE_SYS_WAIT_H
42 #include <sys/wait.h>
43 #else /* ! HAVE_SYS_WAIT_H */
44 #if ! defined (_WIN32) || defined (__CYGWIN__)
45 #ifndef WIFEXITED
46 #define WIFEXITED(w) (((w)&0377) == 0)
47 #endif
48 #ifndef WIFSIGNALED
49 #define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
50 #endif
51 #ifndef WTERMSIG
52 #define WTERMSIG(w) ((w) & 0177)
53 #endif
54 #ifndef WEXITSTATUS
55 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
56 #endif
57 #else /* defined (_WIN32) && ! defined (__CYGWIN__) */
58 #ifndef WIFEXITED
59 #define WIFEXITED(w) (((w) & 0xff) == 0)
60 #endif
61 #ifndef WIFSIGNALED
62 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
63 #endif
64 #ifndef WTERMSIG
65 #define WTERMSIG(w) ((w) & 0x7f)
66 #endif
67 #ifndef WEXITSTATUS
68 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
69 #endif
70 #endif /* defined (_WIN32) && ! defined (__CYGWIN__) */
71 #endif /* ! HAVE_SYS_WAIT_H */
73 #ifndef STDOUT_FILENO
74 #define STDOUT_FILENO 1
75 #endif
77 #if defined (_WIN32) && ! defined (__CYGWIN__)
78 #define popen _popen
79 #define pclose _pclose
80 #endif
82 /* The default preprocessor. */
84 #define DEFAULT_PREPROCESSOR "gcc -E -xc -DRC_INVOKED"
86 /* We read the directory entries in a cursor or icon file into
87 instances of this structure. */
89 struct icondir
91 /* Width of image. */
92 bfd_byte width;
93 /* Height of image. */
94 bfd_byte height;
95 /* Number of colors in image. */
96 bfd_byte colorcount;
97 union
99 struct
101 /* Color planes. */
102 unsigned short planes;
103 /* Bits per pixel. */
104 unsigned short bits;
105 } icon;
106 struct
108 /* X coordinate of hotspot. */
109 unsigned short xhotspot;
110 /* Y coordinate of hotspot. */
111 unsigned short yhotspot;
112 } cursor;
113 } u;
114 /* Bytes in image. */
115 unsigned long bytes;
116 /* File offset of image. */
117 unsigned long offset;
120 /* The name of the rc file we are reading. */
122 char *rc_filename;
124 /* The line number in the rc file. */
126 int rc_lineno;
128 /* The pipe we are reading from, so that we can close it if we exit. */
130 FILE *cpp_pipe;
132 /* The temporary file used if we're not using popen, so we can delete it
133 if we exit. */
135 static char *cpp_temp_file;
137 /* Input stream is either a file or a pipe. */
139 static enum {ISTREAM_PIPE, ISTREAM_FILE} istream_type;
141 /* As we read the rc file, we attach information to this structure. */
143 static rc_res_directory *resources;
145 /* The number of cursor resources we have written out. */
147 static int cursors;
149 /* The number of font resources we have written out. */
151 static int fonts;
153 /* Font directory information. */
155 rc_fontdir *fontdirs;
157 /* Resource info to use for fontdirs. */
159 rc_res_res_info fontdirs_resinfo;
161 /* The number of icon resources we have written out. */
163 static int icons;
165 /* The windres target bfd . */
167 static windres_bfd wrtarget =
169 (bfd *) NULL, (asection *) NULL, WR_KIND_TARGET
172 /* Local functions for rcdata based resource definitions. */
174 static void define_font_rcdata (rc_res_id, const rc_res_res_info *,
175 rc_rcdata_item *);
176 static void define_icon_rcdata (rc_res_id, const rc_res_res_info *,
177 rc_rcdata_item *);
178 static void define_bitmap_rcdata (rc_res_id, const rc_res_res_info *,
179 rc_rcdata_item *);
180 static void define_cursor_rcdata (rc_res_id, const rc_res_res_info *,
181 rc_rcdata_item *);
182 static void define_fontdir_rcdata (rc_res_id, const rc_res_res_info *,
183 rc_rcdata_item *);
184 static void define_messagetable_rcdata (rc_res_id, const rc_res_res_info *,
185 rc_rcdata_item *);
186 static rc_uint_type rcdata_copy (const rc_rcdata_item *, bfd_byte *);
187 static bfd_byte *rcdata_render_as_buffer (const rc_rcdata_item *, rc_uint_type *);
189 static int run_cmd (char *, const char *);
190 static FILE *open_input_stream (char *);
191 static FILE *look_for_default
192 (char *, const char *, int, const char *, const char *);
193 static void close_input_stream (void);
194 static void unexpected_eof (const char *);
195 static int get_word (FILE *, const char *);
196 static unsigned long get_long (FILE *, const char *);
197 static void get_data (FILE *, bfd_byte *, rc_uint_type, const char *);
198 static void define_fontdirs (void);
200 /* Run `cmd' and redirect the output to `redir'. */
202 static int
203 run_cmd (char *cmd, const char *redir)
205 char *s;
206 int pid, wait_status, retcode;
207 int i;
208 const char **argv;
209 char *errmsg_fmt, *errmsg_arg;
210 char *temp_base = choose_temp_base ();
211 int in_quote;
212 char sep;
213 int redir_handle = -1;
214 int stdout_save = -1;
216 /* Count the args. */
217 i = 0;
219 for (s = cmd; *s; s++)
220 if (*s == ' ')
221 i++;
223 i++;
224 argv = alloca (sizeof (char *) * (i + 3));
225 i = 0;
226 s = cmd;
228 while (1)
230 while (*s == ' ' && *s != 0)
231 s++;
233 if (*s == 0)
234 break;
236 in_quote = (*s == '\'' || *s == '"');
237 sep = (in_quote) ? *s++ : ' ';
238 argv[i++] = s;
240 while (*s != sep && *s != 0)
241 s++;
243 if (*s == 0)
244 break;
246 *s++ = 0;
248 if (in_quote)
249 s++;
251 argv[i++] = NULL;
253 /* Setup the redirection. We can't use the usual fork/exec and redirect
254 since we may be running on non-POSIX Windows host. */
256 fflush (stdout);
257 fflush (stderr);
259 /* Open temporary output file. */
260 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT, 0666);
261 if (redir_handle == -1)
262 fatal (_("can't open temporary file `%s': %s"), redir,
263 strerror (errno));
265 /* Duplicate the stdout file handle so it can be restored later. */
266 stdout_save = dup (STDOUT_FILENO);
267 if (stdout_save == -1)
268 fatal (_("can't redirect stdout: `%s': %s"), redir, strerror (errno));
270 /* Redirect stdout to our output file. */
271 dup2 (redir_handle, STDOUT_FILENO);
273 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
274 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
276 /* Restore stdout to its previous setting. */
277 dup2 (stdout_save, STDOUT_FILENO);
279 /* Close response file. */
280 close (redir_handle);
282 if (pid == -1)
284 fatal (_("%s %s: %s"), errmsg_fmt, errmsg_arg, strerror (errno));
285 return 1;
288 retcode = 0;
289 pid = pwait (pid, &wait_status, 0);
291 if (pid == -1)
293 fatal (_("wait: %s"), strerror (errno));
294 retcode = 1;
296 else if (WIFSIGNALED (wait_status))
298 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
299 retcode = 1;
301 else if (WIFEXITED (wait_status))
303 if (WEXITSTATUS (wait_status) != 0)
305 fatal (_("%s exited with status %d"), cmd,
306 WEXITSTATUS (wait_status));
307 retcode = 1;
310 else
311 retcode = 1;
313 return retcode;
316 static FILE *
317 open_input_stream (char *cmd)
319 if (istream_type == ISTREAM_FILE)
321 char *fileprefix;
323 fileprefix = choose_temp_base ();
324 cpp_temp_file = (char *) xmalloc (strlen (fileprefix) + 5);
325 sprintf (cpp_temp_file, "%s.irc", fileprefix);
326 free (fileprefix);
328 if (run_cmd (cmd, cpp_temp_file))
329 fatal (_("can't execute `%s': %s"), cmd, strerror (errno));
331 cpp_pipe = fopen (cpp_temp_file, FOPEN_RT);;
332 if (cpp_pipe == NULL)
333 fatal (_("can't open temporary file `%s': %s"),
334 cpp_temp_file, strerror (errno));
336 if (verbose)
337 fprintf (stderr,
338 _("Using temporary file `%s' to read preprocessor output\n"),
339 cpp_temp_file);
341 else
343 cpp_pipe = popen (cmd, FOPEN_RT);
344 if (cpp_pipe == NULL)
345 fatal (_("can't popen `%s': %s"), cmd, strerror (errno));
346 if (verbose)
347 fprintf (stderr, _("Using popen to read preprocessor output\n"));
350 xatexit (close_input_stream);
351 return cpp_pipe;
354 /* Determine if FILENAME contains special characters that
355 can cause problems unless the entire filename is quoted. */
357 static int
358 filename_need_quotes (const char *filename)
360 if (filename == NULL || (filename[0] == '-' && filename[1] == 0))
361 return 0;
363 while (*filename != 0)
365 switch (*filename)
367 case '&':
368 case ' ':
369 case '<':
370 case '>':
371 case '|':
372 case '%':
373 return 1;
375 ++filename;
377 return 0;
380 /* Look for the preprocessor program. */
382 static FILE *
383 look_for_default (char *cmd, const char *prefix, int end_prefix,
384 const char *preprocargs, const char *filename)
386 char *space;
387 int found;
388 struct stat s;
389 const char *fnquotes = (filename_need_quotes (filename) ? "\"" : "");
391 strcpy (cmd, prefix);
393 sprintf (cmd + end_prefix, "%s", DEFAULT_PREPROCESSOR);
394 space = strchr (cmd + end_prefix, ' ');
395 if (space)
396 *space = 0;
398 if (
399 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32)
400 strchr (cmd, '\\') ||
401 #endif
402 strchr (cmd, '/'))
404 found = (stat (cmd, &s) == 0
405 #ifdef HAVE_EXECUTABLE_SUFFIX
406 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
407 #endif
410 if (! found)
412 if (verbose)
413 fprintf (stderr, _("Tried `%s'\n"), cmd);
414 return NULL;
418 strcpy (cmd, prefix);
420 sprintf (cmd + end_prefix, "%s %s %s%s%s",
421 DEFAULT_PREPROCESSOR, preprocargs, fnquotes, filename, fnquotes);
423 if (verbose)
424 fprintf (stderr, _("Using `%s'\n"), cmd);
426 cpp_pipe = open_input_stream (cmd);
427 return cpp_pipe;
430 /* Read an rc file. */
432 rc_res_directory *
433 read_rc_file (const char *filename, const char *preprocessor,
434 const char *preprocargs, int language, int use_temp_file)
436 char *cmd;
437 const char *fnquotes = (filename_need_quotes (filename) ? "\"" : "");
439 if (filename == NULL)
440 filename = "-";
441 /* Setup the default resource import path taken from input file. */
442 else if (strchr (filename, '/') != NULL || strchr (filename, '\\') != NULL)
444 char *edit, *dir;
446 if (filename[0] == '/'
447 || filename[0] == '\\'
448 || filename[1] == ':')
449 /* Absolute path. */
450 edit = dir = xstrdup (filename);
451 else
453 /* Relative path. */
454 edit = dir = xmalloc (strlen (filename) + 3);
455 sprintf (dir, "./%s", filename);
458 /* Walk dir backwards stopping at the first directory separator. */
459 edit += strlen (dir);
460 while (edit > dir && (edit[-1] != '\\' && edit[-1] != '/'))
462 --edit;
463 edit[0] = 0;
466 /* Cut off trailing slash. */
467 --edit;
468 edit[0] = 0;
470 /* Convert all back slashes to forward slashes. */
471 while ((edit = strchr (dir, '\\')) != NULL)
472 *edit = '/';
474 windres_add_include_dir (dir);
477 istream_type = (use_temp_file) ? ISTREAM_FILE : ISTREAM_PIPE;
479 if (preprocargs == NULL)
480 preprocargs = "";
482 if (preprocessor)
484 cmd = xmalloc (strlen (preprocessor)
485 + strlen (preprocargs)
486 + strlen (filename)
487 + strlen (fnquotes) * 2
488 + 10);
489 sprintf (cmd, "%s %s %s%s%s", preprocessor, preprocargs,
490 fnquotes, filename, fnquotes);
492 cpp_pipe = open_input_stream (cmd);
494 else
496 char *dash, *slash, *cp;
498 preprocessor = DEFAULT_PREPROCESSOR;
500 cmd = xmalloc (strlen (program_name)
501 + strlen (preprocessor)
502 + strlen (preprocargs)
503 + strlen (filename)
504 + strlen (fnquotes) * 2
505 #ifdef HAVE_EXECUTABLE_SUFFIX
506 + strlen (EXECUTABLE_SUFFIX)
507 #endif
508 + 10);
511 dash = slash = 0;
512 for (cp = program_name; *cp; cp++)
514 if (*cp == '-')
515 dash = cp;
516 if (
517 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32)
518 *cp == ':' || *cp == '\\' ||
519 #endif
520 *cp == '/')
522 slash = cp;
523 dash = 0;
527 cpp_pipe = 0;
529 if (dash)
531 /* First, try looking for a prefixed gcc in the windres
532 directory, with the same prefix as windres */
534 cpp_pipe = look_for_default (cmd, program_name, dash - program_name + 1,
535 preprocargs, filename);
538 if (slash && ! cpp_pipe)
540 /* Next, try looking for a gcc in the same directory as
541 that windres */
543 cpp_pipe = look_for_default (cmd, program_name, slash - program_name + 1,
544 preprocargs, filename);
547 if (! cpp_pipe)
549 /* Sigh, try the default */
551 cpp_pipe = look_for_default (cmd, "", 0, preprocargs, filename);
556 free (cmd);
558 rc_filename = xstrdup (filename);
559 rc_lineno = 1;
560 if (language != -1)
561 rcparse_set_language (language);
562 yyparse ();
563 rcparse_discard_strings ();
565 close_input_stream ();
567 if (fontdirs != NULL)
568 define_fontdirs ();
570 free (rc_filename);
571 rc_filename = NULL;
573 return resources;
576 /* Close the input stream if it is open. */
578 static void
579 close_input_stream (void)
581 if (istream_type == ISTREAM_FILE)
583 if (cpp_pipe != NULL)
584 fclose (cpp_pipe);
586 if (cpp_temp_file != NULL)
588 int errno_save = errno;
590 unlink (cpp_temp_file);
591 errno = errno_save;
592 free (cpp_temp_file);
595 else
597 if (cpp_pipe != NULL)
599 int err;
600 err = pclose (cpp_pipe);
601 /* We are reading from a pipe, therefore we don't
602 know if cpp failed or succeeded until pclose. */
603 if (err != 0 || errno == ECHILD)
605 /* Since this is also run via xatexit, safeguard. */
606 cpp_pipe = NULL;
607 cpp_temp_file = NULL;
608 fatal (_("preprocessing failed."));
613 /* Since this is also run via xatexit, safeguard. */
614 cpp_pipe = NULL;
615 cpp_temp_file = NULL;
618 /* Report an error while reading an rc file. */
620 void
621 yyerror (const char *msg)
623 fatal ("%s:%d: %s", rc_filename, rc_lineno, msg);
626 /* Issue a warning while reading an rc file. */
628 void
629 rcparse_warning (const char *msg)
631 fprintf (stderr, _("%s:%d: %s\n"), rc_filename, rc_lineno, msg);
634 /* Die if we get an unexpected end of file. */
636 static void
637 unexpected_eof (const char *msg)
639 fatal (_("%s: unexpected EOF"), msg);
642 /* Read a 16 bit word from a file. The data is assumed to be little
643 endian. */
645 static int
646 get_word (FILE *e, const char *msg)
648 int b1, b2;
650 b1 = getc (e);
651 b2 = getc (e);
652 if (feof (e))
653 unexpected_eof (msg);
654 return ((b2 & 0xff) << 8) | (b1 & 0xff);
657 /* Read a 32 bit word from a file. The data is assumed to be little
658 endian. */
660 static unsigned long
661 get_long (FILE *e, const char *msg)
663 int b1, b2, b3, b4;
665 b1 = getc (e);
666 b2 = getc (e);
667 b3 = getc (e);
668 b4 = getc (e);
669 if (feof (e))
670 unexpected_eof (msg);
671 return (((((((b4 & 0xff) << 8)
672 | (b3 & 0xff)) << 8)
673 | (b2 & 0xff)) << 8)
674 | (b1 & 0xff));
677 /* Read data from a file. This is a wrapper to do error checking. */
679 static void
680 get_data (FILE *e, bfd_byte *p, rc_uint_type c, const char *msg)
682 rc_uint_type got; // $$$d
684 got = (rc_uint_type) fread (p, 1, c, e);
685 if (got == c)
686 return;
688 fatal (_("%s: read of %lu returned %lu"), msg, (long) c, (long) got);
691 /* Define an accelerator resource. */
693 void
694 define_accelerator (rc_res_id id, const rc_res_res_info *resinfo,
695 rc_accelerator *data)
697 rc_res_resource *r;
699 r = define_standard_resource (&resources, RT_ACCELERATOR, id,
700 resinfo->language, 0);
701 r->type = RES_TYPE_ACCELERATOR;
702 r->u.acc = data;
703 r->res_info = *resinfo;
706 /* Define a bitmap resource. Bitmap data is stored in a file. The
707 first 14 bytes of the file are a standard header, which is not
708 included in the resource data. */
710 #define BITMAP_SKIP (14)
712 void
713 define_bitmap (rc_res_id id, const rc_res_res_info *resinfo,
714 const char *filename)
716 FILE *e;
717 char *real_filename;
718 struct stat s;
719 bfd_byte *data;
720 rc_uint_type i;
721 rc_res_resource *r;
723 e = open_file_search (filename, FOPEN_RB, "bitmap file", &real_filename);
725 if (stat (real_filename, &s) < 0)
726 fatal (_("stat failed on bitmap file `%s': %s"), real_filename,
727 strerror (errno));
729 data = (bfd_byte *) res_alloc (s.st_size - BITMAP_SKIP);
731 for (i = 0; i < BITMAP_SKIP; i++)
732 getc (e);
734 get_data (e, data, s.st_size - BITMAP_SKIP, real_filename);
736 fclose (e);
737 free (real_filename);
739 r = define_standard_resource (&resources, RT_BITMAP, id,
740 resinfo->language, 0);
742 r->type = RES_TYPE_BITMAP;
743 r->u.data.length = s.st_size - BITMAP_SKIP;
744 r->u.data.data = data;
745 r->res_info = *resinfo;
748 /* Define a cursor resource. A cursor file may contain a set of
749 bitmaps, each representing the same cursor at various different
750 resolutions. They each get written out with a different ID. The
751 real cursor resource is then a group resource which can be used to
752 select one of the actual cursors. */
754 void
755 define_cursor (rc_res_id id, const rc_res_res_info *resinfo,
756 const char *filename)
758 FILE *e;
759 char *real_filename;
760 int type, count, i;
761 struct icondir *icondirs;
762 int first_cursor;
763 rc_res_resource *r;
764 rc_group_cursor *first, **pp;
766 e = open_file_search (filename, FOPEN_RB, "cursor file", &real_filename);
768 /* A cursor file is basically an icon file. The start of the file
769 is a three word structure. The first word is ignored. The
770 second word is the type of data. The third word is the number of
771 entries. */
773 get_word (e, real_filename);
774 type = get_word (e, real_filename);
775 count = get_word (e, real_filename);
776 if (type != 2)
777 fatal (_("cursor file `%s' does not contain cursor data"), real_filename);
779 /* Read in the icon directory entries. */
781 icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs);
783 for (i = 0; i < count; i++)
785 icondirs[i].width = getc (e);
786 icondirs[i].height = getc (e);
787 icondirs[i].colorcount = getc (e);
788 getc (e);
789 icondirs[i].u.cursor.xhotspot = get_word (e, real_filename);
790 icondirs[i].u.cursor.yhotspot = get_word (e, real_filename);
791 icondirs[i].bytes = get_long (e, real_filename);
792 icondirs[i].offset = get_long (e, real_filename);
794 if (feof (e))
795 unexpected_eof (real_filename);
798 /* Define each cursor as a unique resource. */
800 first_cursor = cursors;
802 for (i = 0; i < count; i++)
804 bfd_byte *data;
805 rc_res_id name;
806 rc_cursor *c;
808 if (fseek (e, icondirs[i].offset, SEEK_SET) != 0)
809 fatal (_("%s: fseek to %lu failed: %s"), real_filename,
810 icondirs[i].offset, strerror (errno));
812 data = (bfd_byte *) res_alloc (icondirs[i].bytes);
814 get_data (e, data, icondirs[i].bytes, real_filename);
816 c = (rc_cursor *) res_alloc (sizeof (rc_cursor));
817 c->xhotspot = icondirs[i].u.cursor.xhotspot;
818 c->yhotspot = icondirs[i].u.cursor.yhotspot;
819 c->length = icondirs[i].bytes;
820 c->data = data;
822 ++cursors;
824 name.named = 0;
825 name.u.id = cursors;
827 r = define_standard_resource (&resources, RT_CURSOR, name,
828 resinfo->language, 0);
829 r->type = RES_TYPE_CURSOR;
830 r->u.cursor = c;
831 r->res_info = *resinfo;
834 fclose (e);
835 free (real_filename);
837 /* Define a cursor group resource. */
839 first = NULL;
840 pp = &first;
841 for (i = 0; i < count; i++)
843 rc_group_cursor *cg;
845 cg = (rc_group_cursor *) res_alloc (sizeof (rc_group_cursor));
846 cg->next = NULL;
847 cg->width = icondirs[i].width;
848 cg->height = 2 * icondirs[i].height;
850 /* FIXME: What should these be set to? */
851 cg->planes = 1;
852 cg->bits = 1;
854 cg->bytes = icondirs[i].bytes + 4;
855 cg->index = first_cursor + i + 1;
857 *pp = cg;
858 pp = &(*pp)->next;
861 free (icondirs);
863 r = define_standard_resource (&resources, RT_GROUP_CURSOR, id,
864 resinfo->language, 0);
865 r->type = RES_TYPE_GROUP_CURSOR;
866 r->u.group_cursor = first;
867 r->res_info = *resinfo;
870 /* Define a dialog resource. */
872 void
873 define_dialog (rc_res_id id, const rc_res_res_info *resinfo,
874 const rc_dialog *dialog)
876 rc_dialog *copy;
877 rc_res_resource *r;
879 copy = (rc_dialog *) res_alloc (sizeof *copy);
880 *copy = *dialog;
882 r = define_standard_resource (&resources, RT_DIALOG, id,
883 resinfo->language, 0);
884 r->type = RES_TYPE_DIALOG;
885 r->u.dialog = copy;
886 r->res_info = *resinfo;
889 /* Define a dialog control. This does not define a resource, but
890 merely allocates and fills in a structure. */
892 rc_dialog_control *
893 define_control (const rc_res_id iid, rc_uint_type id, rc_uint_type x,
894 rc_uint_type y, rc_uint_type width, rc_uint_type height,
895 const rc_res_id class, rc_uint_type style,
896 rc_uint_type exstyle)
898 rc_dialog_control *n;
900 n = (rc_dialog_control *) res_alloc (sizeof (rc_dialog_control));
901 n->next = NULL;
902 n->id = id;
903 n->style = style;
904 n->exstyle = exstyle;
905 n->x = x;
906 n->y = y;
907 n->width = width;
908 n->height = height;
909 n->class = class;
910 n->text = iid;
911 n->data = NULL;
912 n->help = 0;
914 return n;
917 rc_dialog_control *
918 define_icon_control (rc_res_id iid, rc_uint_type id, rc_uint_type x,
919 rc_uint_type y, rc_uint_type style,
920 rc_uint_type exstyle, rc_uint_type help,
921 rc_rcdata_item *data, rc_dialog_ex *ex)
923 rc_dialog_control *n;
924 rc_res_id tid;
925 rc_res_id cid;
927 if (style == 0)
928 style = SS_ICON | WS_CHILD | WS_VISIBLE;
929 res_string_to_id (&tid, "");
930 cid.named = 0;
931 cid.u.id = CTL_STATIC;
932 n = define_control (tid, id, x, y, 0, 0, cid, style, exstyle);
933 n->text = iid;
934 if (help && ! ex)
935 rcparse_warning (_("help ID requires DIALOGEX"));
936 if (data && ! ex)
937 rcparse_warning (_("control data requires DIALOGEX"));
938 n->help = help;
939 n->data = data;
941 return n;
944 /* Define a font resource. */
946 void
947 define_font (rc_res_id id, const rc_res_res_info *resinfo,
948 const char *filename)
950 FILE *e;
951 char *real_filename;
952 struct stat s;
953 bfd_byte *data;
954 rc_res_resource *r;
955 long offset;
956 long fontdatalength;
957 bfd_byte *fontdata;
958 rc_fontdir *fd;
959 const char *device, *face;
960 rc_fontdir **pp;
962 e = open_file_search (filename, FOPEN_RB, "font file", &real_filename);
964 if (stat (real_filename, &s) < 0)
965 fatal (_("stat failed on font file `%s': %s"), real_filename,
966 strerror (errno));
968 data = (bfd_byte *) res_alloc (s.st_size);
970 get_data (e, data, s.st_size, real_filename);
972 fclose (e);
973 free (real_filename);
975 r = define_standard_resource (&resources, RT_FONT, id,
976 resinfo->language, 0);
978 r->type = RES_TYPE_FONT;
979 r->u.data.length = s.st_size;
980 r->u.data.data = data;
981 r->res_info = *resinfo;
983 /* For each font resource, we must add an entry in the FONTDIR
984 resource. The FONTDIR resource includes some strings in the font
985 file. To find them, we have to do some magic on the data we have
986 read. */
988 offset = ((((((data[47] << 8)
989 | data[46]) << 8)
990 | data[45]) << 8)
991 | data[44]);
992 if (offset > 0 && offset < s.st_size)
993 device = (char *) data + offset;
994 else
995 device = "";
997 offset = ((((((data[51] << 8)
998 | data[50]) << 8)
999 | data[49]) << 8)
1000 | data[48]);
1001 if (offset > 0 && offset < s.st_size)
1002 face = (char *) data + offset;
1003 else
1004 face = "";
1006 ++fonts;
1008 fontdatalength = 58 + strlen (device) + strlen (face);
1009 fontdata = (bfd_byte *) res_alloc (fontdatalength);
1010 memcpy (fontdata, data, 56);
1011 strcpy ((char *) fontdata + 56, device);
1012 strcpy ((char *) fontdata + 57 + strlen (device), face);
1014 fd = (rc_fontdir *) res_alloc (sizeof (rc_fontdir));
1015 fd->next = NULL;
1016 fd->index = fonts;
1017 fd->length = fontdatalength;
1018 fd->data = fontdata;
1020 for (pp = &fontdirs; *pp != NULL; pp = &(*pp)->next)
1022 *pp = fd;
1024 /* For the single fontdirs resource, we always use the resource
1025 information of the last font. I don't know what else to do. */
1026 fontdirs_resinfo = *resinfo;
1029 static void
1030 define_font_rcdata (rc_res_id id,const rc_res_res_info *resinfo,
1031 rc_rcdata_item *data)
1033 rc_res_resource *r;
1034 rc_uint_type len_data;
1035 bfd_byte *pb_data;
1037 r = define_standard_resource (&resources, RT_FONT, id,
1038 resinfo->language, 0);
1040 pb_data = rcdata_render_as_buffer (data, &len_data);
1042 r->type = RES_TYPE_FONT;
1043 r->u.data.length = len_data;
1044 r->u.data.data = pb_data;
1045 r->res_info = *resinfo;
1048 /* Define the fontdirs resource. This is called after the entire rc
1049 file has been parsed, if any font resources were seen. */
1051 static void
1052 define_fontdirs (void)
1054 rc_res_resource *r;
1055 rc_res_id id;
1057 id.named = 0;
1058 id.u.id = 1;
1060 r = define_standard_resource (&resources, RT_FONTDIR, id, 0x409, 0);
1062 r->type = RES_TYPE_FONTDIR;
1063 r->u.fontdir = fontdirs;
1064 r->res_info = fontdirs_resinfo;
1067 static bfd_byte *
1068 rcdata_render_as_buffer (const rc_rcdata_item *data, rc_uint_type *plen)
1070 const rc_rcdata_item *d;
1071 bfd_byte *ret = NULL, *pret;
1072 rc_uint_type len = 0;
1074 for (d = data; d != NULL; d = d->next)
1075 len += rcdata_copy (d, NULL);
1076 if (len != 0)
1078 ret = pret = (bfd_byte *) res_alloc (len);
1079 for (d = data; d != NULL; d = d->next)
1080 pret += rcdata_copy (d, pret);
1082 if (plen)
1083 *plen = len;
1084 return ret;
1087 static void
1088 define_fontdir_rcdata (rc_res_id id,const rc_res_res_info *resinfo,
1089 rc_rcdata_item *data)
1091 rc_res_resource *r;
1092 rc_fontdir *fd, *fd_first, *fd_cur;
1093 rc_uint_type len_data;
1094 bfd_byte *pb_data;
1095 rc_uint_type c;
1097 fd_cur = fd_first = NULL;
1098 r = define_standard_resource (&resources, RT_FONTDIR, id, 0x409, 0);
1100 pb_data = rcdata_render_as_buffer (data, &len_data);
1102 if (pb_data)
1104 rc_uint_type off = 2;
1105 c = windres_get_16 (&wrtarget, pb_data, len_data);
1106 for (; c > 0; c--)
1108 size_t len;
1109 rc_uint_type safe_pos = off;
1110 const struct bin_fontdir_item *bfi;
1112 bfi = (const struct bin_fontdir_item *) pb_data + off;
1113 fd = (rc_fontdir *) res_alloc (sizeof (rc_fontdir));
1114 fd->index = windres_get_16 (&wrtarget, bfi->index, len_data - off);
1115 fd->data = pb_data + off;
1116 off += 56;
1117 len = strlen ((char *) bfi->device_name) + 1;
1118 off += (rc_uint_type) len;
1119 off += (rc_uint_type) strlen ((char *) bfi->device_name + len) + 1;
1120 fd->length = (off - safe_pos);
1121 fd->next = NULL;
1122 if (fd_first == NULL)
1123 fd_first = fd;
1124 else
1125 fd_cur->next = fd;
1126 fd_cur = fd;
1129 r->type = RES_TYPE_FONTDIR;
1130 r->u.fontdir = fd_first;
1131 r->res_info = *resinfo;
1134 static void define_messagetable_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1135 rc_rcdata_item *data)
1137 rc_res_resource *r;
1138 rc_uint_type len_data;
1139 bfd_byte *pb_data;
1141 r = define_standard_resource (&resources, RT_MESSAGETABLE, id, resinfo->language, 0);
1143 pb_data = rcdata_render_as_buffer (data, &len_data);
1144 r->type = RES_TYPE_MESSAGETABLE;
1145 r->u.data.length = len_data;
1146 r->u.data.data = pb_data;
1147 r->res_info = *resinfo;
1150 /* Define an icon resource. An icon file may contain a set of
1151 bitmaps, each representing the same icon at various different
1152 resolutions. They each get written out with a different ID. The
1153 real icon resource is then a group resource which can be used to
1154 select one of the actual icon bitmaps. */
1156 void
1157 define_icon (rc_res_id id, const rc_res_res_info *resinfo,
1158 const char *filename)
1160 FILE *e;
1161 char *real_filename;
1162 int type, count, i;
1163 struct icondir *icondirs;
1164 int first_icon;
1165 rc_res_resource *r;
1166 rc_group_icon *first, **pp;
1168 e = open_file_search (filename, FOPEN_RB, "icon file", &real_filename);
1170 /* The start of an icon file is a three word structure. The first
1171 word is ignored. The second word is the type of data. The third
1172 word is the number of entries. */
1174 get_word (e, real_filename);
1175 type = get_word (e, real_filename);
1176 count = get_word (e, real_filename);
1177 if (type != 1)
1178 fatal (_("icon file `%s' does not contain icon data"), real_filename);
1180 /* Read in the icon directory entries. */
1182 icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs);
1184 for (i = 0; i < count; i++)
1186 icondirs[i].width = getc (e);
1187 icondirs[i].height = getc (e);
1188 icondirs[i].colorcount = getc (e);
1189 getc (e);
1190 icondirs[i].u.icon.planes = get_word (e, real_filename);
1191 icondirs[i].u.icon.bits = get_word (e, real_filename);
1192 icondirs[i].bytes = get_long (e, real_filename);
1193 icondirs[i].offset = get_long (e, real_filename);
1195 if (feof (e))
1196 unexpected_eof (real_filename);
1199 /* Define each icon as a unique resource. */
1201 first_icon = icons;
1203 for (i = 0; i < count; i++)
1205 bfd_byte *data;
1206 rc_res_id name;
1208 if (fseek (e, icondirs[i].offset, SEEK_SET) != 0)
1209 fatal (_("%s: fseek to %lu failed: %s"), real_filename,
1210 icondirs[i].offset, strerror (errno));
1212 data = (bfd_byte *) res_alloc (icondirs[i].bytes);
1214 get_data (e, data, icondirs[i].bytes, real_filename);
1216 ++icons;
1218 name.named = 0;
1219 name.u.id = icons;
1221 r = define_standard_resource (&resources, RT_ICON, name,
1222 resinfo->language, 0);
1223 r->type = RES_TYPE_ICON;
1224 r->u.data.length = icondirs[i].bytes;
1225 r->u.data.data = data;
1226 r->res_info = *resinfo;
1229 fclose (e);
1230 free (real_filename);
1232 /* Define an icon group resource. */
1234 first = NULL;
1235 pp = &first;
1236 for (i = 0; i < count; i++)
1238 rc_group_icon *cg;
1240 /* For some reason, at least in some files the planes and bits
1241 are zero. We instead set them from the color. This is
1242 copied from rcl. */
1244 cg = (rc_group_icon *) res_alloc (sizeof (rc_group_icon));
1245 cg->next = NULL;
1246 cg->width = icondirs[i].width;
1247 cg->height = icondirs[i].height;
1248 cg->colors = icondirs[i].colorcount;
1250 if (icondirs[i].u.icon.planes)
1251 cg->planes = icondirs[i].u.icon.planes;
1252 else
1253 cg->planes = 1;
1255 if (icondirs[i].u.icon.bits)
1256 cg->bits = icondirs[i].u.icon.bits;
1257 else
1259 cg->bits = 0;
1261 while ((1L << cg->bits) < cg->colors)
1262 ++cg->bits;
1265 cg->bytes = icondirs[i].bytes;
1266 cg->index = first_icon + i + 1;
1268 *pp = cg;
1269 pp = &(*pp)->next;
1272 free (icondirs);
1274 r = define_standard_resource (&resources, RT_GROUP_ICON, id,
1275 resinfo->language, 0);
1276 r->type = RES_TYPE_GROUP_ICON;
1277 r->u.group_icon = first;
1278 r->res_info = *resinfo;
1281 static void
1282 define_group_icon_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1283 rc_rcdata_item *data)
1285 rc_res_resource *r;
1286 rc_group_icon *cg, *first, *cur;
1287 rc_uint_type len_data;
1288 bfd_byte *pb_data;
1290 pb_data = rcdata_render_as_buffer (data, &len_data);
1292 cur = NULL;
1293 first = NULL;
1295 while (len_data >= 6)
1297 int c, i;
1298 unsigned short type;
1299 type = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2);
1300 if (type != 1)
1301 fatal (_("unexpected group icon type %d"), type);
1302 c = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4);
1303 len_data -= 6;
1304 pb_data += 6;
1306 for (i = 0; i < c; i++)
1308 if (len_data < 14)
1309 fatal ("too small group icon rcdata");
1310 cg = (rc_group_icon *) res_alloc (sizeof (rc_group_icon));
1311 cg->next = NULL;
1312 cg->width = pb_data[0];
1313 cg->height = pb_data[1];
1314 cg->colors = pb_data[2];
1315 cg->planes = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4);
1316 cg->bits = windres_get_16 (&wrtarget, pb_data + 6, len_data - 6);
1317 cg->bytes = windres_get_32 (&wrtarget, pb_data + 8, len_data - 8);
1318 cg->index = windres_get_16 (&wrtarget, pb_data + 12, len_data - 12);
1319 if (! first)
1320 first = cg;
1321 else
1322 cur->next = cg;
1323 cur = cg;
1324 pb_data += 14;
1325 len_data -= 14;
1328 r = define_standard_resource (&resources, RT_GROUP_ICON, id,
1329 resinfo->language, 0);
1330 r->type = RES_TYPE_GROUP_ICON;
1331 r->u.group_icon = first;
1332 r->res_info = *resinfo;
1335 static void
1336 define_group_cursor_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1337 rc_rcdata_item *data)
1339 rc_res_resource *r;
1340 rc_group_cursor *cg, *first, *cur;
1341 rc_uint_type len_data;
1342 bfd_byte *pb_data;
1344 pb_data = rcdata_render_as_buffer (data, &len_data);
1346 first = cur = NULL;
1348 while (len_data >= 6)
1350 int c, i;
1351 unsigned short type;
1352 type = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2);
1353 if (type != 2)
1354 fatal (_("unexpected group cursor type %d"), type);
1355 c = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4);
1356 len_data -= 6;
1357 pb_data += 6;
1359 for (i = 0; i < c; i++)
1361 if (len_data < 14)
1362 fatal ("too small group icon rcdata");
1363 cg = (rc_group_cursor *) res_alloc (sizeof (rc_group_cursor));
1364 cg->next = NULL;
1365 cg->width = windres_get_16 (&wrtarget, pb_data, len_data);
1366 cg->height = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2);
1367 cg->planes = windres_get_16 (&wrtarget, pb_data + 4, len_data - 4);
1368 cg->bits = windres_get_16 (&wrtarget, pb_data + 6, len_data - 6);
1369 cg->bytes = windres_get_32 (&wrtarget, pb_data + 8, len_data - 8);
1370 cg->index = windres_get_16 (&wrtarget, pb_data + 12, len_data - 12);
1371 if (! first)
1372 first = cg;
1373 else
1374 cur->next = cg;
1375 cur = cg;
1376 pb_data += 14;
1377 len_data -= 14;
1381 r = define_standard_resource (&resources, RT_GROUP_ICON, id,
1382 resinfo->language, 0);
1383 r->type = RES_TYPE_GROUP_CURSOR;
1384 r->u.group_cursor = first;
1385 r->res_info = *resinfo;
1388 static void
1389 define_cursor_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1390 rc_rcdata_item *data)
1392 rc_cursor *c;
1393 rc_res_resource *r;
1394 rc_uint_type len_data;
1395 bfd_byte *pb_data;
1397 pb_data = rcdata_render_as_buffer (data, &len_data);
1399 c = (rc_cursor *) res_alloc (sizeof (rc_cursor));
1400 c->xhotspot = windres_get_16 (&wrtarget, pb_data, len_data);
1401 c->yhotspot = windres_get_16 (&wrtarget, pb_data + 2, len_data - 2);
1402 c->length = len_data - BIN_CURSOR_SIZE;
1403 c->data = (const bfd_byte *) (data + BIN_CURSOR_SIZE);
1405 r = define_standard_resource (&resources, RT_CURSOR, id, resinfo->language, 0);
1406 r->type = RES_TYPE_CURSOR;
1407 r->u.cursor = c;
1408 r->res_info = *resinfo;
1411 static void
1412 define_bitmap_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1413 rc_rcdata_item *data)
1415 rc_res_resource *r;
1416 rc_uint_type len_data;
1417 bfd_byte *pb_data;
1419 pb_data = rcdata_render_as_buffer (data, &len_data);
1421 r = define_standard_resource (&resources, RT_BITMAP, id, resinfo->language, 0);
1422 r->type = RES_TYPE_BITMAP;
1423 r->u.data.length = len_data;
1424 r->u.data.data = pb_data;
1425 r->res_info = *resinfo;
1428 static void
1429 define_icon_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1430 rc_rcdata_item *data)
1432 rc_res_resource *r;
1433 rc_uint_type len_data;
1434 bfd_byte *pb_data;
1436 pb_data = rcdata_render_as_buffer (data, &len_data);
1438 r = define_standard_resource (&resources, RT_ICON, id, resinfo->language, 0);
1439 r->type = RES_TYPE_ICON;
1440 r->u.data.length = len_data;
1441 r->u.data.data = pb_data;
1442 r->res_info = *resinfo;
1445 /* Define a menu resource. */
1447 void
1448 define_menu (rc_res_id id, const rc_res_res_info *resinfo,
1449 rc_menuitem *menuitems)
1451 rc_menu *m;
1452 rc_res_resource *r;
1454 m = (rc_menu *) res_alloc (sizeof (rc_menu));
1455 m->items = menuitems;
1456 m->help = 0;
1458 r = define_standard_resource (&resources, RT_MENU, id, resinfo->language, 0);
1459 r->type = RES_TYPE_MENU;
1460 r->u.menu = m;
1461 r->res_info = *resinfo;
1464 /* Define a menu item. This does not define a resource, but merely
1465 allocates and fills in a structure. */
1467 rc_menuitem *
1468 define_menuitem (const unichar *text, rc_uint_type menuid, rc_uint_type type,
1469 rc_uint_type state, rc_uint_type help,
1470 rc_menuitem *menuitems)
1472 rc_menuitem *mi;
1474 mi = (rc_menuitem *) res_alloc (sizeof (rc_menuitem));
1475 mi->next = NULL;
1476 mi->type = type;
1477 mi->state = state;
1478 mi->id = menuid;
1479 mi->text = unichar_dup (text);
1480 mi->help = help;
1481 mi->popup = menuitems;
1482 return mi;
1485 /* Define a messagetable resource. */
1487 void
1488 define_messagetable (rc_res_id id, const rc_res_res_info *resinfo,
1489 const char *filename)
1491 FILE *e;
1492 char *real_filename;
1493 struct stat s;
1494 bfd_byte *data;
1495 rc_res_resource *r;
1497 e = open_file_search (filename, FOPEN_RB, "messagetable file",
1498 &real_filename);
1500 if (stat (real_filename, &s) < 0)
1501 fatal (_("stat failed on bitmap file `%s': %s"), real_filename,
1502 strerror (errno));
1504 data = (bfd_byte *) res_alloc (s.st_size);
1506 get_data (e, data, s.st_size, real_filename);
1508 fclose (e);
1509 free (real_filename);
1511 r = define_standard_resource (&resources, RT_MESSAGETABLE, id,
1512 resinfo->language, 0);
1514 r->type = RES_TYPE_MESSAGETABLE;
1515 r->u.data.length = s.st_size;
1516 r->u.data.data = data;
1517 r->res_info = *resinfo;
1520 /* Define an rcdata resource. */
1522 void
1523 define_rcdata (rc_res_id id, const rc_res_res_info *resinfo,
1524 rc_rcdata_item *data)
1526 rc_res_resource *r;
1528 r = define_standard_resource (&resources, RT_RCDATA, id,
1529 resinfo->language, 0);
1530 r->type = RES_TYPE_RCDATA;
1531 r->u.rcdata = data;
1532 r->res_info = *resinfo;
1535 /* Create an rcdata item holding a string. */
1537 rc_rcdata_item *
1538 define_rcdata_string (const char *string, rc_uint_type len)
1540 rc_rcdata_item *ri;
1541 char *s;
1543 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
1544 ri->next = NULL;
1545 ri->type = RCDATA_STRING;
1546 ri->u.string.length = len;
1547 s = (char *) res_alloc (len);
1548 memcpy (s, string, len);
1549 ri->u.string.s = s;
1551 return ri;
1554 /* Create an rcdata item holding a unicode string. */
1556 rc_rcdata_item *
1557 define_rcdata_unistring (const unichar *string, rc_uint_type len)
1559 rc_rcdata_item *ri;
1560 unichar *s;
1562 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
1563 ri->next = NULL;
1564 ri->type = RCDATA_WSTRING;
1565 ri->u.wstring.length = len;
1566 s = (unichar *) res_alloc (len * sizeof (unichar));
1567 memcpy (s, string, len * sizeof (unichar));
1568 ri->u.wstring.w = s;
1570 return ri;
1573 /* Create an rcdata item holding a number. */
1575 rc_rcdata_item *
1576 define_rcdata_number (rc_uint_type val, int dword)
1578 rc_rcdata_item *ri;
1580 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
1581 ri->next = NULL;
1582 ri->type = dword ? RCDATA_DWORD : RCDATA_WORD;
1583 ri->u.word = val;
1585 return ri;
1588 /* Define a stringtable resource. This is called for each string
1589 which appears in a STRINGTABLE statement. */
1591 void
1592 define_stringtable (const rc_res_res_info *resinfo,
1593 rc_uint_type stringid, const unichar *string)
1595 rc_res_id id;
1596 rc_res_resource *r;
1598 id.named = 0;
1599 id.u.id = (stringid >> 4) + 1;
1600 r = define_standard_resource (&resources, RT_STRING, id,
1601 resinfo->language, 1);
1603 if (r->type == RES_TYPE_UNINITIALIZED)
1605 int i;
1607 r->type = RES_TYPE_STRINGTABLE;
1608 r->u.stringtable = ((rc_stringtable *)
1609 res_alloc (sizeof (rc_stringtable)));
1610 for (i = 0; i < 16; i++)
1612 r->u.stringtable->strings[i].length = 0;
1613 r->u.stringtable->strings[i].string = NULL;
1616 r->res_info = *resinfo;
1619 r->u.stringtable->strings[stringid & 0xf].length = unichar_len (string);
1620 r->u.stringtable->strings[stringid & 0xf].string = unichar_dup (string);
1623 void
1624 define_toolbar (rc_res_id id, rc_res_res_info *resinfo, rc_uint_type width, rc_uint_type height,
1625 rc_toolbar_item *items)
1627 rc_toolbar *t;
1628 rc_res_resource *r;
1630 t = (rc_toolbar *) res_alloc (sizeof (rc_toolbar));
1631 t->button_width = width;
1632 t->button_height = height;
1633 t->nitems = 0;
1634 t->items = items;
1635 while (items != NULL)
1637 t->nitems+=1;
1638 items = items->next;
1640 r = define_standard_resource (&resources, RT_TOOLBAR, id, resinfo->language, 0);
1641 r->type = RES_TYPE_TOOLBAR;
1642 r->u.toolbar = t;
1643 r->res_info = *resinfo;
1646 /* Define a user data resource where the data is in the rc file. */
1648 void
1649 define_user_data (rc_res_id id, rc_res_id type,
1650 const rc_res_res_info *resinfo,
1651 rc_rcdata_item *data)
1653 rc_res_id ids[3];
1654 rc_res_resource *r;
1655 bfd_byte *pb_data;
1656 rc_uint_type len_data;
1658 /* We have to check if the binary data is parsed specially. */
1659 if (type.named == 0)
1661 switch (type.u.id)
1663 case RT_FONTDIR:
1664 define_fontdir_rcdata (id, resinfo, data);
1665 return;
1666 case RT_FONT:
1667 define_font_rcdata (id, resinfo, data);
1668 return;
1669 case RT_ICON:
1670 define_icon_rcdata (id, resinfo, data);
1671 return;
1672 case RT_BITMAP:
1673 define_bitmap_rcdata (id, resinfo, data);
1674 return;
1675 case RT_CURSOR:
1676 define_cursor_rcdata (id, resinfo, data);
1677 return;
1678 case RT_GROUP_ICON:
1679 define_group_icon_rcdata (id, resinfo, data);
1680 return;
1681 case RT_GROUP_CURSOR:
1682 define_group_cursor_rcdata (id, resinfo, data);
1683 return;
1684 case RT_MESSAGETABLE:
1685 define_messagetable_rcdata (id, resinfo, data);
1686 return;
1687 default:
1688 /* Treat as normal user-data. */
1689 break;
1692 ids[0] = type;
1693 ids[1] = id;
1694 ids[2].named = 0;
1695 ids[2].u.id = resinfo->language;
1697 r = define_resource (& resources, 3, ids, 0);
1698 r->type = RES_TYPE_USERDATA;
1699 r->u.userdata = ((rc_rcdata_item *)
1700 res_alloc (sizeof (rc_rcdata_item)));
1701 r->u.userdata->next = NULL;
1702 r->u.userdata->type = RCDATA_BUFFER;
1703 pb_data = rcdata_render_as_buffer (data, &len_data);
1704 r->u.userdata->u.buffer.length = len_data;
1705 r->u.userdata->u.buffer.data = pb_data;
1706 r->res_info = *resinfo;
1709 void
1710 define_rcdata_file (rc_res_id id, const rc_res_res_info *resinfo,
1711 const char *filename)
1713 rc_rcdata_item *ri;
1714 FILE *e;
1715 char *real_filename;
1716 struct stat s;
1717 bfd_byte *data;
1719 e = open_file_search (filename, FOPEN_RB, "file", &real_filename);
1722 if (stat (real_filename, &s) < 0)
1723 fatal (_("stat failed on file `%s': %s"), real_filename,
1724 strerror (errno));
1726 data = (bfd_byte *) res_alloc (s.st_size);
1728 get_data (e, data, s.st_size, real_filename);
1730 fclose (e);
1731 free (real_filename);
1733 ri = (rc_rcdata_item *) res_alloc (sizeof (rc_rcdata_item));
1734 ri->next = NULL;
1735 ri->type = RCDATA_BUFFER;
1736 ri->u.buffer.length = s.st_size;
1737 ri->u.buffer.data = data;
1739 define_rcdata (id, resinfo, ri);
1742 /* Define a user data resource where the data is in a file. */
1744 void
1745 define_user_file (rc_res_id id, rc_res_id type,
1746 const rc_res_res_info *resinfo, const char *filename)
1748 FILE *e;
1749 char *real_filename;
1750 struct stat s;
1751 bfd_byte *data;
1752 rc_res_id ids[3];
1753 rc_res_resource *r;
1755 e = open_file_search (filename, FOPEN_RB, "file", &real_filename);
1757 if (stat (real_filename, &s) < 0)
1758 fatal (_("stat failed on file `%s': %s"), real_filename,
1759 strerror (errno));
1761 data = (bfd_byte *) res_alloc (s.st_size);
1763 get_data (e, data, s.st_size, real_filename);
1765 fclose (e);
1766 free (real_filename);
1768 ids[0] = type;
1769 ids[1] = id;
1770 ids[2].named = 0;
1771 ids[2].u.id = resinfo->language;
1773 r = define_resource (&resources, 3, ids, 0);
1774 r->type = RES_TYPE_USERDATA;
1775 r->u.userdata = ((rc_rcdata_item *)
1776 res_alloc (sizeof (rc_rcdata_item)));
1777 r->u.userdata->next = NULL;
1778 r->u.userdata->type = RCDATA_BUFFER;
1779 r->u.userdata->u.buffer.length = s.st_size;
1780 r->u.userdata->u.buffer.data = data;
1781 r->res_info = *resinfo;
1784 /* Define a versioninfo resource. */
1786 void
1787 define_versioninfo (rc_res_id id, rc_uint_type language,
1788 rc_fixed_versioninfo *fixedverinfo,
1789 rc_ver_info *verinfo)
1791 rc_res_resource *r;
1793 r = define_standard_resource (&resources, RT_VERSION, id, language, 0);
1794 r->type = RES_TYPE_VERSIONINFO;
1795 r->u.versioninfo = ((rc_versioninfo *)
1796 res_alloc (sizeof (rc_versioninfo)));
1797 r->u.versioninfo->fixed = fixedverinfo;
1798 r->u.versioninfo->var = verinfo;
1799 r->res_info.language = language;
1802 /* Add string version info to a list of version information. */
1804 rc_ver_info *
1805 append_ver_stringfileinfo (rc_ver_info *verinfo, const char *language,
1806 rc_ver_stringinfo *strings)
1808 rc_ver_info *vi, **pp;
1810 vi = (rc_ver_info *) res_alloc (sizeof (rc_ver_info));
1811 vi->next = NULL;
1812 vi->type = VERINFO_STRING;
1813 unicode_from_ascii ((rc_uint_type *) NULL, &vi->u.string.language, language);
1814 vi->u.string.strings = strings;
1816 for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
1818 *pp = vi;
1820 return verinfo;
1823 /* Add variable version info to a list of version information. */
1825 rc_ver_info *
1826 append_ver_varfileinfo (rc_ver_info *verinfo, const unichar *key,
1827 rc_ver_varinfo *var)
1829 rc_ver_info *vi, **pp;
1831 vi = (rc_ver_info *) res_alloc (sizeof *vi);
1832 vi->next = NULL;
1833 vi->type = VERINFO_VAR;
1834 vi->u.var.key = unichar_dup (key);
1835 vi->u.var.var = var;
1837 for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
1839 *pp = vi;
1841 return verinfo;
1844 /* Append version string information to a list. */
1846 rc_ver_stringinfo *
1847 append_verval (rc_ver_stringinfo *strings, const unichar *key,
1848 const unichar *value)
1850 rc_ver_stringinfo *vs, **pp;
1852 vs = (rc_ver_stringinfo *) res_alloc (sizeof (rc_ver_stringinfo));
1853 vs->next = NULL;
1854 vs->key = unichar_dup (key);
1855 vs->value = unichar_dup (value);
1857 for (pp = &strings; *pp != NULL; pp = &(*pp)->next)
1859 *pp = vs;
1861 return strings;
1864 /* Append version variable information to a list. */
1866 rc_ver_varinfo *
1867 append_vertrans (rc_ver_varinfo *var, rc_uint_type language,
1868 rc_uint_type charset)
1870 rc_ver_varinfo *vv, **pp;
1872 vv = (rc_ver_varinfo *) res_alloc (sizeof (rc_ver_varinfo));
1873 vv->next = NULL;
1874 vv->language = language;
1875 vv->charset = charset;
1877 for (pp = &var; *pp != NULL; pp = &(*pp)->next)
1879 *pp = vv;
1881 return var;
1884 /* Local functions used to write out an rc file. */
1886 static void indent (FILE *, int);
1887 static void write_rc_directory (FILE *, const rc_res_directory *, const rc_res_id *,
1888 const rc_res_id *, rc_uint_type *, int);
1889 static void write_rc_subdir (FILE *, const rc_res_entry *, const rc_res_id *,
1890 const rc_res_id *, rc_uint_type *, int);
1891 static void write_rc_resource (FILE *, const rc_res_id *, const rc_res_id *,
1892 const rc_res_resource *, rc_uint_type *);
1893 static void write_rc_accelerators (FILE *, const rc_accelerator *);
1894 static void write_rc_cursor (FILE *, const rc_cursor *);
1895 static void write_rc_group_cursor (FILE *, const rc_group_cursor *);
1896 static void write_rc_dialog (FILE *, const rc_dialog *);
1897 static void write_rc_dialog_control (FILE *, const rc_dialog_control *);
1898 static void write_rc_fontdir (FILE *, const rc_fontdir *);
1899 static void write_rc_group_icon (FILE *, const rc_group_icon *);
1900 static void write_rc_menu (FILE *, const rc_menu *, int);
1901 static void write_rc_toolbar (FILE *, const rc_toolbar *);
1902 static void write_rc_menuitems (FILE *, const rc_menuitem *, int, int);
1903 static void write_rc_messagetable (FILE *, rc_uint_type , const bfd_byte *);
1905 static void write_rc_datablock (FILE *, rc_uint_type , const bfd_byte *, int, int, int);
1906 static void write_rc_rcdata (FILE *, const rc_rcdata_item *, int);
1907 static void write_rc_stringtable (FILE *, const rc_res_id *, const rc_stringtable *);
1908 static void write_rc_versioninfo (FILE *, const rc_versioninfo *);
1910 /* Indent a given number of spaces. */
1912 static void
1913 indent (FILE *e, int c)
1915 int i;
1917 for (i = 0; i < c; i++)
1918 putc (' ', e);
1921 /* Dump the resources we have read in the format of an rc file.
1923 Reasoned by the fact, that some resources need to be stored into file and
1924 refer to that file, we use the user-data model for that to express it binary
1925 without the need to store it somewhere externally. */
1927 void
1928 write_rc_file (const char *filename, const rc_res_directory *resources)
1930 FILE *e;
1931 rc_uint_type language;
1933 if (filename == NULL)
1934 e = stdout;
1935 else
1937 e = fopen (filename, FOPEN_WT);
1938 if (e == NULL)
1939 fatal (_("can't open `%s' for output: %s"), filename, strerror (errno));
1942 language = (rc_uint_type) ((bfd_signed_vma) -1);
1943 write_rc_directory (e, resources, (const rc_res_id *) NULL,
1944 (const rc_res_id *) NULL, &language, 1);
1947 /* Write out a directory. E is the file to write to. RD is the
1948 directory. TYPE is a pointer to the level 1 ID which serves as the
1949 resource type. NAME is a pointer to the level 2 ID which serves as
1950 an individual resource name. LANGUAGE is a pointer to the current
1951 language. LEVEL is the level in the tree. */
1953 static void
1954 write_rc_directory (FILE *e, const rc_res_directory *rd,
1955 const rc_res_id *type, const rc_res_id *name,
1956 rc_uint_type *language, int level)
1958 const rc_res_entry *re;
1960 /* Print out some COFF information that rc files can't represent. */
1961 if (rd->time != 0 || rd->characteristics != 0 || rd->major != 0 || rd->minor != 0)
1963 wr_printcomment (e, "COFF information not part of RC");
1964 if (rd->time != 0)
1965 wr_printcomment (e, "Time stamp: %u", rd->time);
1966 if (rd->characteristics != 0)
1967 wr_printcomment (e, "Characteristics: %u", rd->characteristics);
1968 if (rd->major != 0 || rd->minor != 0)
1969 wr_printcomment (e, "Version major:%d minor:%d", rd->major, rd->minor);
1972 for (re = rd->entries; re != NULL; re = re->next)
1974 switch (level)
1976 case 1:
1977 /* If we're at level 1, the key of this resource is the
1978 type. This normally duplicates the information we have
1979 stored with the resource itself, but we need to remember
1980 the type if this is a user define resource type. */
1981 type = &re->id;
1982 break;
1984 case 2:
1985 /* If we're at level 2, the key of this resource is the name
1986 we are going to use in the rc printout. */
1987 name = &re->id;
1988 break;
1990 case 3:
1991 /* If we're at level 3, then this key represents a language.
1992 Use it to update the current language. */
1993 if (! re->id.named
1994 && re->id.u.id != (unsigned long) (unsigned int) *language
1995 && (re->id.u.id & 0xffff) == re->id.u.id)
1997 wr_print (e, "LANGUAGE %u, %u\n",
1998 re->id.u.id & ((1 << SUBLANG_SHIFT) - 1),
1999 (re->id.u.id >> SUBLANG_SHIFT) & 0xff);
2000 *language = re->id.u.id;
2002 break;
2004 default:
2005 break;
2008 if (re->subdir)
2009 write_rc_subdir (e, re, type, name, language, level);
2010 else
2012 if (level == 3)
2014 /* This is the normal case: the three levels are
2015 TYPE/NAME/LANGUAGE. NAME will have been set at level
2016 2, and represents the name to use. We probably just
2017 set LANGUAGE, and it will probably match what the
2018 resource itself records if anything. */
2019 write_rc_resource (e, type, name, re->u.res, language);
2021 else
2023 wr_printcomment (e, "Resource at unexpected level %d", level);
2024 write_rc_resource (e, type, (rc_res_id *) NULL, re->u.res,
2025 language);
2029 if (rd->entries == NULL)
2031 wr_print_flush (e);
2035 /* Write out a subdirectory entry. E is the file to write to. RE is
2036 the subdirectory entry. TYPE and NAME are pointers to higher level
2037 IDs, or NULL. LANGUAGE is a pointer to the current language.
2038 LEVEL is the level in the tree. */
2040 static void
2041 write_rc_subdir (FILE *e, const rc_res_entry *re,
2042 const rc_res_id *type, const rc_res_id *name,
2043 rc_uint_type *language, int level)
2045 fprintf (e, "\n");
2046 switch (level)
2048 case 1:
2049 wr_printcomment (e, "Type: ");
2050 if (re->id.named)
2051 res_id_print (e, re->id, 1);
2052 else
2054 const char *s;
2056 switch (re->id.u.id)
2058 case RT_CURSOR: s = "cursor"; break;
2059 case RT_BITMAP: s = "bitmap"; break;
2060 case RT_ICON: s = "icon"; break;
2061 case RT_MENU: s = "menu"; break;
2062 case RT_DIALOG: s = "dialog"; break;
2063 case RT_STRING: s = "stringtable"; break;
2064 case RT_FONTDIR: s = "fontdir"; break;
2065 case RT_FONT: s = "font"; break;
2066 case RT_ACCELERATOR: s = "accelerators"; break;
2067 case RT_RCDATA: s = "rcdata"; break;
2068 case RT_MESSAGETABLE: s = "messagetable"; break;
2069 case RT_GROUP_CURSOR: s = "group cursor"; break;
2070 case RT_GROUP_ICON: s = "group icon"; break;
2071 case RT_VERSION: s = "version"; break;
2072 case RT_DLGINCLUDE: s = "dlginclude"; break;
2073 case RT_PLUGPLAY: s = "plugplay"; break;
2074 case RT_VXD: s = "vxd"; break;
2075 case RT_ANICURSOR: s = "anicursor"; break;
2076 case RT_ANIICON: s = "aniicon"; break;
2077 case RT_TOOLBAR: s = "toolbar"; break;
2078 case RT_HTML: s = "html"; break;
2079 default: s = NULL; break;
2082 if (s != NULL)
2083 fprintf (e, "%s", s);
2084 else
2085 res_id_print (e, re->id, 1);
2087 break;
2089 case 2:
2090 wr_printcomment (e, "Name: ");
2091 res_id_print (e, re->id, 1);
2092 break;
2094 case 3:
2095 wr_printcomment (e, "Language: ");
2096 res_id_print (e, re->id, 1);
2097 break;
2099 default:
2100 wr_printcomment (e, "Level %d: ", level);
2101 res_id_print (e, re->id, 1);
2104 write_rc_directory (e, re->u.dir, type, name, language, level + 1);
2107 /* Write out a single resource. E is the file to write to. TYPE is a
2108 pointer to the type of the resource. NAME is a pointer to the name
2109 of the resource; it will be NULL if there is a level mismatch. RES
2110 is the resource data. LANGUAGE is a pointer to the current
2111 language. */
2113 static void
2114 write_rc_resource (FILE *e, const rc_res_id *type,
2115 const rc_res_id *name, const rc_res_resource *res,
2116 rc_uint_type *language)
2118 const char *s;
2119 int rt;
2120 int menuex = 0;
2122 switch (res->type)
2124 default:
2125 abort ();
2127 case RES_TYPE_ACCELERATOR:
2128 s = "ACCELERATORS";
2129 rt = RT_ACCELERATOR;
2130 break;
2132 case RES_TYPE_BITMAP:
2133 s = "2 /* RT_BITMAP */";
2134 rt = RT_BITMAP;
2135 break;
2137 case RES_TYPE_CURSOR:
2138 s = "1 /* RT_CURSOR */";
2139 rt = RT_CURSOR;
2140 break;
2142 case RES_TYPE_GROUP_CURSOR:
2143 s = "12 /* RT_GROUP_CURSOR */";
2144 rt = RT_GROUP_CURSOR;
2145 break;
2147 case RES_TYPE_DIALOG:
2148 if (extended_dialog (res->u.dialog))
2149 s = "DIALOGEX";
2150 else
2151 s = "DIALOG";
2152 rt = RT_DIALOG;
2153 break;
2155 case RES_TYPE_FONT:
2156 s = "8 /* RT_FONT */";
2157 rt = RT_FONT;
2158 break;
2160 case RES_TYPE_FONTDIR:
2161 s = "7 /* RT_FONTDIR */";
2162 rt = RT_FONTDIR;
2163 break;
2165 case RES_TYPE_ICON:
2166 s = "3 /* RT_ICON */";
2167 rt = RT_ICON;
2168 break;
2170 case RES_TYPE_GROUP_ICON:
2171 s = "14 /* RT_GROUP_ICON */";
2172 rt = RT_GROUP_ICON;
2173 break;
2175 case RES_TYPE_MENU:
2176 if (extended_menu (res->u.menu))
2178 s = "MENUEX";
2179 menuex = 1;
2181 else
2183 s = "MENU";
2184 menuex = 0;
2186 rt = RT_MENU;
2187 break;
2189 case RES_TYPE_MESSAGETABLE:
2190 s = "11 /* RT_MESSAGETABLE */";
2191 rt = RT_MESSAGETABLE;
2192 break;
2194 case RES_TYPE_RCDATA:
2195 s = "RCDATA";
2196 rt = RT_RCDATA;
2197 break;
2199 case RES_TYPE_STRINGTABLE:
2200 s = "STRINGTABLE";
2201 rt = RT_STRING;
2202 break;
2204 case RES_TYPE_USERDATA:
2205 s = NULL;
2206 rt = 0;
2207 break;
2209 case RES_TYPE_VERSIONINFO:
2210 s = "VERSIONINFO";
2211 rt = RT_VERSION;
2212 break;
2214 case RES_TYPE_TOOLBAR:
2215 s = "TOOLBAR";
2216 rt = RT_TOOLBAR;
2217 break;
2220 if (rt != 0
2221 && type != NULL
2222 && (type->named || type->u.id != (unsigned long) rt))
2224 wr_printcomment (e, "Unexpected resource type mismatch: ");
2225 res_id_print (e, *type, 1);
2226 fprintf (e, " != %d", rt);
2229 if (res->coff_info.codepage != 0)
2230 wr_printcomment (e, "Code page: %u", res->coff_info.codepage);
2231 if (res->coff_info.reserved != 0)
2232 wr_printcomment (e, "COFF reserved value: %u", res->coff_info.reserved);
2234 wr_print (e, "\n");
2235 if (rt == RT_STRING)
2237 else
2239 if (name != NULL)
2240 res_id_print (e, *name, 1);
2241 else
2242 fprintf (e, "??Unknown-Name??");
2243 fprintf (e, " ");
2246 if (s != NULL)
2247 fprintf (e, "%s", s);
2248 else if (type != NULL)
2250 if (type->named == 0)
2252 #define PRINT_RT_NAME(NAME) case NAME: \
2253 fprintf (e, "%u /* %s */", (unsigned int) NAME, #NAME); \
2254 break
2256 switch (type->u.id)
2258 default:
2259 res_id_print (e, *type, 0);
2260 break;
2262 PRINT_RT_NAME(RT_MANIFEST);
2263 PRINT_RT_NAME(RT_ANICURSOR);
2264 PRINT_RT_NAME(RT_ANIICON);
2265 PRINT_RT_NAME(RT_RCDATA);
2266 PRINT_RT_NAME(RT_ICON);
2267 PRINT_RT_NAME(RT_CURSOR);
2268 PRINT_RT_NAME(RT_BITMAP);
2269 PRINT_RT_NAME(RT_PLUGPLAY);
2270 PRINT_RT_NAME(RT_VXD);
2271 PRINT_RT_NAME(RT_FONT);
2272 PRINT_RT_NAME(RT_FONTDIR);
2273 PRINT_RT_NAME(RT_HTML);
2274 PRINT_RT_NAME(RT_MESSAGETABLE);
2275 PRINT_RT_NAME(RT_DLGINCLUDE);
2276 PRINT_RT_NAME(RT_DLGINIT);
2278 #undef PRINT_RT_NAME
2280 else
2281 res_id_print (e, *type, 1);
2283 else
2284 fprintf (e, "??Unknown-Type??");
2286 if (res->res_info.memflags != 0)
2288 if ((res->res_info.memflags & MEMFLAG_MOVEABLE) != 0)
2289 fprintf (e, " MOVEABLE");
2290 if ((res->res_info.memflags & MEMFLAG_PURE) != 0)
2291 fprintf (e, " PURE");
2292 if ((res->res_info.memflags & MEMFLAG_PRELOAD) != 0)
2293 fprintf (e, " PRELOAD");
2294 if ((res->res_info.memflags & MEMFLAG_DISCARDABLE) != 0)
2295 fprintf (e, " DISCARDABLE");
2298 if (res->type == RES_TYPE_DIALOG)
2300 fprintf (e, " %d, %d, %d, %d",
2301 (int) res->u.dialog->x, (int) res->u.dialog->y,
2302 (int) res->u.dialog->width, (int) res->u.dialog->height);
2303 if (res->u.dialog->ex != NULL
2304 && res->u.dialog->ex->help != 0)
2305 fprintf (e, ", %u", (unsigned int) res->u.dialog->ex->help);
2307 else if (res->type == RES_TYPE_TOOLBAR)
2309 fprintf (e, " %d, %d", (int) res->u.toolbar->button_width,
2310 (int) res->u.toolbar->button_height);
2313 fprintf (e, "\n");
2315 if ((res->res_info.language != 0 && res->res_info.language != *language)
2316 || res->res_info.characteristics != 0
2317 || res->res_info.version != 0)
2319 int modifiers;
2321 switch (res->type)
2323 case RES_TYPE_ACCELERATOR:
2324 case RES_TYPE_DIALOG:
2325 case RES_TYPE_MENU:
2326 case RES_TYPE_RCDATA:
2327 case RES_TYPE_STRINGTABLE:
2328 modifiers = 1;
2329 break;
2331 default:
2332 modifiers = 0;
2333 break;
2336 if (res->res_info.language != 0 && res->res_info.language != *language)
2337 fprintf (e, "%sLANGUAGE %d, %d\n",
2338 modifiers ? "// " : "",
2339 (int) res->res_info.language & ((1<<SUBLANG_SHIFT)-1),
2340 (int) (res->res_info.language >> SUBLANG_SHIFT) & 0xff);
2341 if (res->res_info.characteristics != 0)
2342 fprintf (e, "%sCHARACTERISTICS %u\n",
2343 modifiers ? "// " : "",
2344 (unsigned int) res->res_info.characteristics);
2345 if (res->res_info.version != 0)
2346 fprintf (e, "%sVERSION %u\n",
2347 modifiers ? "// " : "",
2348 (unsigned int) res->res_info.version);
2351 switch (res->type)
2353 default:
2354 abort ();
2356 case RES_TYPE_ACCELERATOR:
2357 write_rc_accelerators (e, res->u.acc);
2358 break;
2360 case RES_TYPE_CURSOR:
2361 write_rc_cursor (e, res->u.cursor);
2362 break;
2364 case RES_TYPE_GROUP_CURSOR:
2365 write_rc_group_cursor (e, res->u.group_cursor);
2366 break;
2368 case RES_TYPE_DIALOG:
2369 write_rc_dialog (e, res->u.dialog);
2370 break;
2372 case RES_TYPE_FONTDIR:
2373 write_rc_fontdir (e, res->u.fontdir);
2374 break;
2376 case RES_TYPE_GROUP_ICON:
2377 write_rc_group_icon (e, res->u.group_icon);
2378 break;
2380 case RES_TYPE_MENU:
2381 write_rc_menu (e, res->u.menu, menuex);
2382 break;
2384 case RES_TYPE_RCDATA:
2385 write_rc_rcdata (e, res->u.rcdata, 0);
2386 break;
2388 case RES_TYPE_STRINGTABLE:
2389 write_rc_stringtable (e, name, res->u.stringtable);
2390 break;
2392 case RES_TYPE_USERDATA:
2393 write_rc_rcdata (e, res->u.userdata, 0);
2394 break;
2396 case RES_TYPE_TOOLBAR:
2397 write_rc_toolbar (e, res->u.toolbar);
2398 break;
2400 case RES_TYPE_VERSIONINFO:
2401 write_rc_versioninfo (e, res->u.versioninfo);
2402 break;
2404 case RES_TYPE_BITMAP:
2405 case RES_TYPE_FONT:
2406 case RES_TYPE_ICON:
2407 write_rc_datablock (e, res->u.data.length, res->u.data.data, 0, 1, 0);
2408 break;
2409 case RES_TYPE_MESSAGETABLE:
2410 write_rc_messagetable (e, res->u.data.length, res->u.data.data);
2411 break;
2415 /* Write out accelerator information. */
2417 static void
2418 write_rc_accelerators (FILE *e, const rc_accelerator *accelerators)
2420 const rc_accelerator *acc;
2422 fprintf (e, "BEGIN\n");
2423 for (acc = accelerators; acc != NULL; acc = acc->next)
2425 int printable;
2427 fprintf (e, " ");
2429 if ((acc->key & 0x7f) == acc->key
2430 && ISPRINT (acc->key)
2431 && (acc->flags & ACC_VIRTKEY) == 0)
2433 fprintf (e, "\"%c\"", (char) acc->key);
2434 printable = 1;
2436 else
2438 fprintf (e, "%d", (int) acc->key);
2439 printable = 0;
2442 fprintf (e, ", %d", (int) acc->id);
2444 if (! printable)
2446 if ((acc->flags & ACC_VIRTKEY) != 0)
2447 fprintf (e, ", VIRTKEY");
2448 else
2449 fprintf (e, ", ASCII");
2452 if ((acc->flags & ACC_SHIFT) != 0)
2453 fprintf (e, ", SHIFT");
2454 if ((acc->flags & ACC_CONTROL) != 0)
2455 fprintf (e, ", CONTROL");
2456 if ((acc->flags & ACC_ALT) != 0)
2457 fprintf (e, ", ALT");
2459 fprintf (e, "\n");
2462 fprintf (e, "END\n");
2465 /* Write out cursor information. This would normally be in a separate
2466 file, which the rc file would include. */
2468 static void
2469 write_rc_cursor (FILE *e, const rc_cursor *cursor)
2471 fprintf (e, "BEGIN\n");
2472 indent (e, 2);
2473 fprintf (e, " 0x%x, 0x%x,\t/* Hotspot x: %d, y: %d. */\n",
2474 (unsigned int) cursor->xhotspot, (unsigned int) cursor->yhotspot,
2475 (int) cursor->xhotspot, (int) cursor->yhotspot);
2476 write_rc_datablock (e, (rc_uint_type) cursor->length, (const bfd_byte *) cursor->data,
2477 0, 0, 0);
2478 fprintf (e, "END\n");
2481 /* Write out group cursor data. This would normally be built from the
2482 cursor data. */
2484 static void
2485 write_rc_group_cursor (FILE *e, const rc_group_cursor *group_cursor)
2487 const rc_group_cursor *gc;
2488 int c;
2490 for (c = 0, gc = group_cursor; gc != NULL; gc = gc->next, c++)
2492 fprintf (e, "BEGIN\n");
2494 indent (e, 2);
2495 fprintf (e, "0, 2, %d%s\t /* Having %d items. */\n", c, (c != 0 ? "," : ""), c);
2496 indent (e, 4);
2497 fprintf (e, "/* width, height, planes, bits, bytes, index. */\n");
2499 for (c = 1, gc = group_cursor; gc != NULL; gc = gc->next, c++)
2501 indent (e, 4);
2502 fprintf (e, "%d, %d, %d, %d, 0x%xL, %d%s /* Element %d. */\n",
2503 (int) gc->width, (int) gc->height, (int) gc->planes, (int) gc->bits,
2504 (unsigned int) gc->bytes, (int) gc->index, (gc->next != NULL ? "," : ""), c);
2505 fprintf (e, "/* width: %d; height %d; planes %d; bits %d. */\n",
2506 (int) gc->width, (int) gc->height, (int) gc->planes,
2507 (int) gc->bits);
2509 fprintf (e, "END\n");
2512 /* Write dialog data. */
2514 static void
2515 write_rc_dialog (FILE *e, const rc_dialog *dialog)
2517 const rc_dialog_control *control;
2519 fprintf (e, "STYLE 0x%x\n", dialog->style);
2521 if (dialog->exstyle != 0)
2522 fprintf (e, "EXSTYLE 0x%x\n", (unsigned int) dialog->exstyle);
2524 if ((dialog->class.named && dialog->class.u.n.length > 0)
2525 || dialog->class.u.id != 0)
2527 fprintf (e, "CLASS ");
2528 res_id_print (e, dialog->class, 1);
2529 fprintf (e, "\n");
2532 if (dialog->caption != NULL)
2534 fprintf (e, "CAPTION ");
2535 unicode_print_quoted (e, dialog->caption, -1);
2536 fprintf (e, "\n");
2539 if ((dialog->menu.named && dialog->menu.u.n.length > 0)
2540 || dialog->menu.u.id != 0)
2542 fprintf (e, "MENU ");
2543 res_id_print (e, dialog->menu, 0);
2544 fprintf (e, "\n");
2547 if (dialog->font != NULL)
2549 fprintf (e, "FONT %d, ", (int) dialog->pointsize);
2550 unicode_print_quoted (e, dialog->font, -1);
2551 if (dialog->ex != NULL
2552 && (dialog->ex->weight != 0
2553 || dialog->ex->italic != 0
2554 || dialog->ex->charset != 1))
2555 fprintf (e, ", %d, %d, %d",
2556 (int) dialog->ex->weight,
2557 (int) dialog->ex->italic,
2558 (int) dialog->ex->charset);
2559 fprintf (e, "\n");
2562 fprintf (e, "BEGIN\n");
2564 for (control = dialog->controls; control != NULL; control = control->next)
2565 write_rc_dialog_control (e, control);
2567 fprintf (e, "END\n");
2570 /* For each predefined control keyword, this table provides the class
2571 and the style. */
2573 struct control_info
2575 const char *name;
2576 unsigned short class;
2577 unsigned long style;
2580 static const struct control_info control_info[] =
2582 { "AUTO3STATE", CTL_BUTTON, BS_AUTO3STATE },
2583 { "AUTOCHECKBOX", CTL_BUTTON, BS_AUTOCHECKBOX },
2584 { "AUTORADIOBUTTON", CTL_BUTTON, BS_AUTORADIOBUTTON },
2585 { "CHECKBOX", CTL_BUTTON, BS_CHECKBOX },
2586 { "COMBOBOX", CTL_COMBOBOX, (unsigned long) -1 },
2587 { "CTEXT", CTL_STATIC, SS_CENTER },
2588 { "DEFPUSHBUTTON", CTL_BUTTON, BS_DEFPUSHBUTTON },
2589 { "EDITTEXT", CTL_EDIT, (unsigned long) -1 },
2590 { "GROUPBOX", CTL_BUTTON, BS_GROUPBOX },
2591 { "ICON", CTL_STATIC, SS_ICON },
2592 { "LISTBOX", CTL_LISTBOX, (unsigned long) -1 },
2593 { "LTEXT", CTL_STATIC, SS_LEFT },
2594 { "PUSHBOX", CTL_BUTTON, BS_PUSHBOX },
2595 { "PUSHBUTTON", CTL_BUTTON, BS_PUSHBUTTON },
2596 { "RADIOBUTTON", CTL_BUTTON, BS_RADIOBUTTON },
2597 { "RTEXT", CTL_STATIC, SS_RIGHT },
2598 { "SCROLLBAR", CTL_SCROLLBAR, (unsigned long) -1 },
2599 { "STATE3", CTL_BUTTON, BS_3STATE },
2600 /* It's important that USERBUTTON come after all the other button
2601 types, so that it won't be matched too early. */
2602 { "USERBUTTON", CTL_BUTTON, (unsigned long) -1 },
2603 { NULL, 0, 0 }
2606 /* Write a dialog control. */
2608 static void
2609 write_rc_dialog_control (FILE *e, const rc_dialog_control *control)
2611 const struct control_info *ci;
2613 fprintf (e, " ");
2615 if (control->class.named)
2616 ci = NULL;
2617 else
2619 for (ci = control_info; ci->name != NULL; ++ci)
2620 if (ci->class == control->class.u.id
2621 && (ci->style == (unsigned long) -1
2622 || ci->style == (control->style & 0xff)))
2623 break;
2625 if (ci == NULL)
2626 fprintf (e, "CONTROL");
2627 else if (ci->name != NULL)
2628 fprintf (e, "%s", ci->name);
2629 else
2631 fprintf (e, "CONTROL");
2632 ci = NULL;
2635 if (control->text.named || control->text.u.id != 0)
2637 fprintf (e, " ");
2638 res_id_print (e, control->text, 1);
2639 fprintf (e, ",");
2642 fprintf (e, " %d, ", (int) control->id);
2644 if (ci == NULL)
2646 if (control->class.named)
2647 fprintf (e, "\"");
2648 res_id_print (e, control->class, 0);
2649 if (control->class.named)
2650 fprintf (e, "\"");
2651 fprintf (e, ", 0x%x, ", (unsigned int) control->style);
2654 fprintf (e, "%d, %d", (int) control->x, (int) control->y);
2656 if (control->style != SS_ICON
2657 || control->exstyle != 0
2658 || control->width != 0
2659 || control->height != 0
2660 || control->help != 0)
2662 fprintf (e, ", %d, %d", (int) control->width, (int) control->height);
2664 /* FIXME: We don't need to print the style if it is the default.
2665 More importantly, in certain cases we actually need to turn
2666 off parts of the forced style, by using NOT. */
2667 if (ci != NULL)
2668 fprintf (e, ", 0x%x", (unsigned int) control->style);
2670 if (control->exstyle != 0 || control->help != 0)
2671 fprintf (e, ", 0x%x, %u", (unsigned int) control->exstyle,
2672 (unsigned int) control->help);
2675 fprintf (e, "\n");
2677 if (control->data != NULL)
2678 write_rc_rcdata (e, control->data, 2);
2681 /* Write out font directory data. This would normally be built from
2682 the font data. */
2684 static void
2685 write_rc_fontdir (FILE *e, const rc_fontdir *fontdir)
2687 const rc_fontdir *fc;
2688 int c;
2690 for (c = 0, fc = fontdir; fc != NULL; fc = fc->next, c++)
2692 fprintf (e, "BEGIN\n");
2693 indent (e, 2);
2694 fprintf (e, "%d%s\t /* Has %d elements. */\n", c, (c != 0 ? "," : ""), c);
2695 for (c = 1, fc = fontdir; fc != NULL; fc = fc->next, c++)
2697 indent (e, 4);
2698 fprintf (e, "%d,\t/* Font no %d with index %d. */\n",
2699 (int) fc->index, c, (int) fc->index);
2700 write_rc_datablock (e, (rc_uint_type) fc->length - 2,
2701 (const bfd_byte *) fc->data + 4,fc->next != NULL,
2702 0, 0);
2704 fprintf (e, "END\n");
2707 /* Write out group icon data. This would normally be built from the
2708 icon data. */
2710 static void
2711 write_rc_group_icon (FILE *e, const rc_group_icon *group_icon)
2713 const rc_group_icon *gi;
2714 int c;
2716 for (c = 0, gi = group_icon; gi != NULL; gi = gi->next, c++)
2719 fprintf (e, "BEGIN\n");
2720 indent (e, 2);
2721 fprintf (e, " 0, 1, %d%s\t /* Has %d elements. */\n", c, (c != 0 ? "," : ""), c);
2723 indent (e, 4);
2724 fprintf (e, "/* \"width height colors pad\", planes, bits, bytes, index. */\n");
2725 for (c = 1, gi = group_icon; gi != NULL; gi = gi->next, c++)
2727 indent (e, 4);
2728 fprintf (e, "\"\\%03o\\%03o\\%03o\\%03o\", %d, %d, 0x%xL, %d%s\t/* Element no %d. */\n",
2729 gi->width, gi->height, gi->colors, 0, (int) gi->planes, (int) gi->bits,
2730 (unsigned int) gi->bytes, (int) gi->index, (gi->next != NULL ? "," : ""), c);
2732 fprintf (e, "END\n");
2735 /* Write out a menu resource. */
2737 static void
2738 write_rc_menu (FILE *e, const rc_menu *menu, int menuex)
2740 if (menu->help != 0)
2741 fprintf (e, "// Help ID: %u\n", (unsigned int) menu->help);
2742 write_rc_menuitems (e, menu->items, menuex, 0);
2745 static void
2746 write_rc_toolbar (FILE *e, const rc_toolbar *tb)
2748 rc_toolbar_item *it;
2749 indent (e, 0);
2750 fprintf (e, "BEGIN\n");
2751 it = tb->items;
2752 while(it != NULL)
2754 indent (e, 2);
2755 if (it->id.u.id == 0)
2756 fprintf (e, "SEPARATOR\n");
2757 else
2758 fprintf (e, "BUTTON %d\n", (int) it->id.u.id);
2759 it = it->next;
2761 indent (e, 0);
2762 fprintf (e, "END\n");
2765 /* Write out menuitems. */
2767 static void
2768 write_rc_menuitems (FILE *e, const rc_menuitem *menuitems, int menuex,
2769 int ind)
2771 const rc_menuitem *mi;
2773 indent (e, ind);
2774 fprintf (e, "BEGIN\n");
2776 for (mi = menuitems; mi != NULL; mi = mi->next)
2778 indent (e, ind + 2);
2780 if (mi->popup == NULL)
2781 fprintf (e, "MENUITEM");
2782 else
2783 fprintf (e, "POPUP");
2785 if (! menuex
2786 && mi->popup == NULL
2787 && mi->text == NULL
2788 && mi->type == 0
2789 && mi->id == 0)
2791 fprintf (e, " SEPARATOR\n");
2792 continue;
2795 if (mi->text == NULL)
2796 fprintf (e, " \"\"");
2797 else
2799 fprintf (e, " ");
2800 unicode_print_quoted (e, mi->text, -1);
2803 if (! menuex)
2805 if (mi->popup == NULL)
2806 fprintf (e, ", %d", (int) mi->id);
2808 if ((mi->type & MENUITEM_CHECKED) != 0)
2809 fprintf (e, ", CHECKED");
2810 if ((mi->type & MENUITEM_GRAYED) != 0)
2811 fprintf (e, ", GRAYED");
2812 if ((mi->type & MENUITEM_HELP) != 0)
2813 fprintf (e, ", HELP");
2814 if ((mi->type & MENUITEM_INACTIVE) != 0)
2815 fprintf (e, ", INACTIVE");
2816 if ((mi->type & MENUITEM_MENUBARBREAK) != 0)
2817 fprintf (e, ", MENUBARBREAK");
2818 if ((mi->type & MENUITEM_MENUBREAK) != 0)
2819 fprintf (e, ", MENUBREAK");
2821 else
2823 if (mi->id != 0 || mi->type != 0 || mi->state != 0 || mi->help != 0)
2825 fprintf (e, ", %d", (int) mi->id);
2826 if (mi->type != 0 || mi->state != 0 || mi->help != 0)
2828 fprintf (e, ", %u", (unsigned int) mi->type);
2829 if (mi->state != 0 || mi->help != 0)
2831 fprintf (e, ", %u", (unsigned int) mi->state);
2832 if (mi->help != 0)
2833 fprintf (e, ", %u", (unsigned int) mi->help);
2839 fprintf (e, "\n");
2841 if (mi->popup != NULL)
2842 write_rc_menuitems (e, mi->popup, menuex, ind + 2);
2845 indent (e, ind);
2846 fprintf (e, "END\n");
2849 static int
2850 test_rc_datablock_unicode (rc_uint_type length, const bfd_byte *data)
2852 rc_uint_type i;
2853 if ((length & 1) != 0)
2854 return 0;
2856 for (i = 0; i < length; i += 2)
2858 if (data[i] == 0 && data[i + 1] == 0 && (i + 2) < length)
2859 return 0;
2860 if (data[i] == 0xff && data[i + 1] == 0xff)
2861 return 0;
2863 return 1;
2866 static int
2867 test_rc_datablock_text (rc_uint_type length, const bfd_byte *data)
2869 int has_nl;
2870 rc_uint_type c;
2871 rc_uint_type i;
2873 if (length <= 1)
2874 return 0;
2876 has_nl = 0;
2877 for (i = 0, c = 0; i < length; i++)
2879 if (! ISPRINT (data[i]) && data[i] != '\n'
2880 && ! (data[i] == '\r' && (i + 1) < length && data[i + 1] == '\n')
2881 && data[i] != '\t'
2882 && ! (data[i] == 0 && (i + 1) != length))
2884 if (data[i] <= 7)
2885 return 0;
2886 c++;
2888 else if (data[i] == '\n') has_nl++;
2890 if (length > 80 && ! has_nl)
2891 return 0;
2892 c = (((c * 10000) + (i / 100) - 1)) / i;
2893 if (c >= 150)
2894 return 0;
2895 return 1;
2898 static void
2899 write_rc_messagetable (FILE *e, rc_uint_type length, const bfd_byte *data)
2901 int has_error = 0;
2902 const struct bin_messagetable *mt;
2903 fprintf (e, "BEGIN\n");
2905 write_rc_datablock (e, length, data, 0, 0, 0);
2907 fprintf (e, "\n");
2908 wr_printcomment (e, "MC syntax dump");
2909 if (length < BIN_MESSAGETABLE_SIZE)
2910 has_error = 1;
2911 else
2912 do {
2913 rc_uint_type m, i;
2914 mt = (const struct bin_messagetable *) data;
2915 m = windres_get_32 (&wrtarget, mt->cblocks, length);
2916 if (length < (BIN_MESSAGETABLE_SIZE + m * BIN_MESSAGETABLE_BLOCK_SIZE))
2918 has_error = 1;
2919 break;
2921 for (i = 0; i < m; i++)
2923 rc_uint_type low, high, offset;
2924 const struct bin_messagetable_item *mti;
2926 low = windres_get_32 (&wrtarget, mt->items[i].lowid, 4);
2927 high = windres_get_32 (&wrtarget, mt->items[i].highid, 4);
2928 offset = windres_get_32 (&wrtarget, mt->items[i].offset, 4);
2929 while (low <= high)
2931 rc_uint_type elen, flags;
2932 if ((offset + BIN_MESSAGETABLE_ITEM_SIZE) > length)
2934 has_error = 1;
2935 break;
2937 mti = (const struct bin_messagetable_item *) &data[offset];
2938 elen = windres_get_16 (&wrtarget, mti->length, 2);
2939 flags = windres_get_16 (&wrtarget, mti->flags, 2);
2940 if ((offset + elen) > length)
2942 has_error = 1;
2943 break;
2945 wr_printcomment (e, "MessageId = 0x%x", low);
2946 wr_printcomment (e, "");
2947 if ((flags & MESSAGE_RESOURCE_UNICODE) == MESSAGE_RESOURCE_UNICODE)
2948 unicode_print (e, (const unichar *) mti->data,
2949 (elen - BIN_MESSAGETABLE_ITEM_SIZE) / 2);
2950 else
2951 ascii_print (e, (const char *) mti->data,
2952 (elen - BIN_MESSAGETABLE_ITEM_SIZE));
2953 wr_printcomment (e,"");
2954 ++low;
2955 offset += elen;
2958 } while (0);
2959 if (has_error)
2960 wr_printcomment (e, "Illegal data");
2961 wr_print_flush (e);
2962 fprintf (e, "END\n");
2965 static void
2966 write_rc_datablock (FILE *e, rc_uint_type length, const bfd_byte *data, int has_next,
2967 int hasblock, int show_comment)
2969 int plen;
2971 if (hasblock)
2972 fprintf (e, "BEGIN\n");
2974 if (show_comment == -1)
2976 if (test_rc_datablock_text(length, data))
2978 rc_uint_type i, c;
2979 for (i = 0; i < length;)
2981 indent (e, 2);
2982 fprintf (e, "\"");
2984 for (c = 0; i < length && c < 160 && data[i] != '\n'; c++, i++)
2986 if (i < length && data[i] == '\n')
2987 ++i, ++c;
2988 ascii_print (e, (const char *) &data[i - c], c);
2989 fprintf (e, "\"");
2990 if (i < length)
2991 fprintf (e, "\n");
2994 if (i == 0)
2996 indent (e, 2);
2997 fprintf (e, "\"\"");
2999 if (has_next)
3000 fprintf (e, ",");
3001 fprintf (e, "\n");
3002 if (hasblock)
3003 fprintf (e, "END\n");
3004 return;
3006 if (test_rc_datablock_unicode (length, data))
3008 rc_uint_type i, c;
3009 for (i = 0; i < length;)
3011 const unichar *u;
3013 u = (const unichar *) &data[i];
3014 indent (e, 2);
3015 fprintf (e, "L\"");
3017 for (c = 0; i < length && c < 160 && u[c] != '\n'; c++, i += 2)
3019 if (i < length && u[c] == '\n')
3020 i += 2, ++c;
3021 unicode_print (e, u, c);
3022 fprintf (e, "\"");
3023 if (i < length)
3024 fprintf (e, "\n");
3027 if (i == 0)
3029 indent (e, 2);
3030 fprintf (e, "L\"\"");
3032 if (has_next)
3033 fprintf (e, ",");
3034 fprintf (e, "\n");
3035 if (hasblock)
3036 fprintf (e, "END\n");
3037 return;
3040 show_comment = 0;
3043 if (length != 0)
3045 rc_uint_type i, max_row;
3046 int first = 1;
3048 max_row = (show_comment ? 4 : 8);
3049 indent (e, 2);
3050 for (i = 0; i + 3 < length;)
3052 rc_uint_type k;
3053 rc_uint_type comment_start;
3055 comment_start = i;
3057 if (! first)
3058 indent (e, 2);
3060 for (k = 0; k < max_row && i + 3 < length; k++, i += 4)
3062 if (k == 0)
3063 plen = fprintf (e, "0x%lxL",
3064 (long) windres_get_32 (&wrtarget, data + i, length - i));
3065 else
3066 plen = fprintf (e, " 0x%lxL",
3067 (long) windres_get_32 (&wrtarget, data + i, length - i)) - 1;
3068 if (has_next || (i + 4) < length)
3070 if (plen>0 && plen < 11)
3071 indent (e, 11 - plen);
3072 fprintf (e, ",");
3075 if (show_comment)
3077 fprintf (e, "\t/* ");
3078 ascii_print (e, (const char *) &data[comment_start], i - comment_start);
3079 fprintf (e, ". */");
3081 fprintf (e, "\n");
3082 first = 0;
3085 if (i + 1 < length)
3087 if (! first)
3088 indent (e, 2);
3089 plen = fprintf (e, "0x%x",
3090 (int) windres_get_16 (&wrtarget, data + i, length - i));
3091 if (has_next || i + 2 < length)
3093 if (plen > 0 && plen < 11)
3094 indent (e, 11 - plen);
3095 fprintf (e, ",");
3097 if (show_comment)
3099 fprintf (e, "\t/* ");
3100 ascii_print (e, (const char *) &data[i], 2);
3101 fprintf (e, ". */");
3103 fprintf (e, "\n");
3104 i += 2;
3105 first = 0;
3108 if (i < length)
3110 if (! first)
3111 indent (e, 2);
3112 fprintf (e, "\"");
3113 ascii_print (e, (const char *) &data[i], 1);
3114 fprintf (e, "\"");
3115 if (has_next)
3116 fprintf (e, ",");
3117 fprintf (e, "\n");
3118 first = 0;
3121 if (hasblock)
3122 fprintf (e, "END\n");
3125 /* Write out an rcdata resource. This is also used for other types of
3126 resources that need to print arbitrary data. */
3128 static void
3129 write_rc_rcdata (FILE *e, const rc_rcdata_item *rcdata, int ind)
3131 const rc_rcdata_item *ri;
3133 indent (e, ind);
3134 fprintf (e, "BEGIN\n");
3136 for (ri = rcdata; ri != NULL; ri = ri->next)
3138 if (ri->type == RCDATA_BUFFER && ri->u.buffer.length == 0)
3139 continue;
3141 switch (ri->type)
3143 default:
3144 abort ();
3146 case RCDATA_WORD:
3147 indent (e, ind + 2);
3148 fprintf (e, "%ld", (long) (ri->u.word & 0xffff));
3149 break;
3151 case RCDATA_DWORD:
3152 indent (e, ind + 2);
3153 fprintf (e, "%luL", (unsigned long) ri->u.dword);
3154 break;
3156 case RCDATA_STRING:
3157 indent (e, ind + 2);
3158 fprintf (e, "\"");
3159 ascii_print (e, ri->u.string.s, ri->u.string.length);
3160 fprintf (e, "\"");
3161 break;
3163 case RCDATA_WSTRING:
3164 indent (e, ind + 2);
3165 fprintf (e, "L\"");
3166 unicode_print (e, ri->u.wstring.w, ri->u.wstring.length);
3167 fprintf (e, "\"");
3168 break;
3170 case RCDATA_BUFFER:
3171 write_rc_datablock (e, (rc_uint_type) ri->u.buffer.length,
3172 (const bfd_byte *) ri->u.buffer.data,
3173 ri->next != NULL, 0, -1);
3174 break;
3177 if (ri->type != RCDATA_BUFFER)
3179 if (ri->next != NULL)
3180 fprintf (e, ",");
3181 fprintf (e, "\n");
3185 indent (e, ind);
3186 fprintf (e, "END\n");
3189 /* Write out a stringtable resource. */
3191 static void
3192 write_rc_stringtable (FILE *e, const rc_res_id *name,
3193 const rc_stringtable *stringtable)
3195 rc_uint_type offset;
3196 int i;
3198 if (name != NULL && ! name->named)
3199 offset = (name->u.id - 1) << 4;
3200 else
3202 fprintf (e, "/* %s string table name. */\n",
3203 name == NULL ? "Missing" : "Invalid");
3204 offset = 0;
3207 fprintf (e, "BEGIN\n");
3209 for (i = 0; i < 16; i++)
3211 if (stringtable->strings[i].length != 0)
3213 fprintf (e, " %lu, ", (long) offset + i);
3214 unicode_print_quoted (e, stringtable->strings[i].string,
3215 stringtable->strings[i].length);
3216 fprintf (e, "\n");
3220 fprintf (e, "END\n");
3223 /* Write out a versioninfo resource. */
3225 static void
3226 write_rc_versioninfo (FILE *e, const rc_versioninfo *versioninfo)
3228 const rc_fixed_versioninfo *f;
3229 const rc_ver_info *vi;
3231 f = versioninfo->fixed;
3232 if (f->file_version_ms != 0 || f->file_version_ls != 0)
3233 fprintf (e, " FILEVERSION %u, %u, %u, %u\n",
3234 (unsigned int) ((f->file_version_ms >> 16) & 0xffff),
3235 (unsigned int) (f->file_version_ms & 0xffff),
3236 (unsigned int) ((f->file_version_ls >> 16) & 0xffff),
3237 (unsigned int) (f->file_version_ls & 0xffff));
3238 if (f->product_version_ms != 0 || f->product_version_ls != 0)
3239 fprintf (e, " PRODUCTVERSION %u, %u, %u, %u\n",
3240 (unsigned int) ((f->product_version_ms >> 16) & 0xffff),
3241 (unsigned int) (f->product_version_ms & 0xffff),
3242 (unsigned int) ((f->product_version_ls >> 16) & 0xffff),
3243 (unsigned int) (f->product_version_ls & 0xffff));
3244 if (f->file_flags_mask != 0)
3245 fprintf (e, " FILEFLAGSMASK 0x%x\n", (unsigned int) f->file_flags_mask);
3246 if (f->file_flags != 0)
3247 fprintf (e, " FILEFLAGS 0x%x\n", (unsigned int) f->file_flags);
3248 if (f->file_os != 0)
3249 fprintf (e, " FILEOS 0x%x\n", (unsigned int) f->file_os);
3250 if (f->file_type != 0)
3251 fprintf (e, " FILETYPE 0x%x\n", (unsigned int) f->file_type);
3252 if (f->file_subtype != 0)
3253 fprintf (e, " FILESUBTYPE 0x%x\n", (unsigned int) f->file_subtype);
3254 if (f->file_date_ms != 0 || f->file_date_ls != 0)
3255 fprintf (e, "/* Date: %u, %u. */\n",
3256 (unsigned int) f->file_date_ms, (unsigned int) f->file_date_ls);
3258 fprintf (e, "BEGIN\n");
3260 for (vi = versioninfo->var; vi != NULL; vi = vi->next)
3262 switch (vi->type)
3264 case VERINFO_STRING:
3266 const rc_ver_stringinfo *vs;
3268 fprintf (e, " BLOCK \"StringFileInfo\"\n");
3269 fprintf (e, " BEGIN\n");
3270 fprintf (e, " BLOCK ");
3271 unicode_print_quoted (e, vi->u.string.language, -1);
3272 fprintf (e, "\n");
3273 fprintf (e, " BEGIN\n");
3275 for (vs = vi->u.string.strings; vs != NULL; vs = vs->next)
3277 fprintf (e, " VALUE ");
3278 unicode_print_quoted (e, vs->key, -1);
3279 fprintf (e, ", ");
3280 unicode_print_quoted (e, vs->value, -1);
3281 fprintf (e, "\n");
3284 fprintf (e, " END\n");
3285 fprintf (e, " END\n");
3286 break;
3289 case VERINFO_VAR:
3291 const rc_ver_varinfo *vv;
3293 fprintf (e, " BLOCK \"VarFileInfo\"\n");
3294 fprintf (e, " BEGIN\n");
3295 fprintf (e, " VALUE ");
3296 unicode_print_quoted (e, vi->u.var.key, -1);
3298 for (vv = vi->u.var.var; vv != NULL; vv = vv->next)
3299 fprintf (e, ", 0x%x, %d", (unsigned int) vv->language,
3300 (int) vv->charset);
3302 fprintf (e, "\n END\n");
3304 break;
3309 fprintf (e, "END\n");
3312 static rc_uint_type
3313 rcdata_copy (const rc_rcdata_item *src, bfd_byte *dst)
3315 if (! src)
3316 return 0;
3317 switch (src->type)
3319 case RCDATA_WORD:
3320 if (dst)
3321 windres_put_16 (&wrtarget, dst, (rc_uint_type) src->u.word);
3322 return 2;
3323 case RCDATA_DWORD:
3324 if (dst)
3325 windres_put_32 (&wrtarget, dst, (rc_uint_type) src->u.dword);
3326 return 4;
3327 case RCDATA_STRING:
3328 if (dst && src->u.string.length)
3329 memcpy (dst, src->u.string.s, src->u.string.length);
3330 return (rc_uint_type) src->u.string.length;
3331 case RCDATA_WSTRING:
3332 if (dst && src->u.wstring.length)
3333 memcpy (dst, src->u.wstring.w, src->u.wstring.length * sizeof (unichar));
3334 return (rc_uint_type) (src->u.wstring.length * sizeof (unichar));
3335 case RCDATA_BUFFER:
3336 if (dst && src->u.buffer.length)
3337 memcpy (dst, src->u.buffer.data, src->u.buffer.length);
3338 return (rc_uint_type) src->u.buffer.length;
3339 default:
3340 abort ();
3342 /* Never reached. */
3343 return 0;