?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* ld-mips-elf/tlslib-o32-ver.got, ld-mips-elf/tlslib-o32.got:
[binutils.git] / binutils / resrc.c
blob73b482cd04ab6ffe8210a68bbe0ae5845327b104
1 /* resrc.c -- read and write Windows rc files.
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23 /* This file contains functions that read and write Windows rc files.
24 These are text files that represent resources. */
25
26 #include "bfd.h"
27 #include "bucomm.h"
28 #include "libiberty.h"
29 #include "safe-ctype.h"
30 #include "windres.h"
31
32 #include <assert.h>
33 #include <errno.h>
34 #include <sys/stat.h>
35 #ifdef HAVE_UNISTD_H
36 #include <unistd.h>
37 #endif
38
39 #ifdef HAVE_SYS_WAIT_H
40 #include <sys/wait.h>
41 #else /* ! HAVE_SYS_WAIT_H */
42 #if ! defined (_WIN32) || defined (__CYGWIN__)
43 #ifndef WIFEXITED
44 #define WIFEXITED(w) (((w)&0377) == 0)
45 #endif
46 #ifndef WIFSIGNALED
47 #define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
48 #endif
49 #ifndef WTERMSIG
50 #define WTERMSIG(w) ((w) & 0177)
51 #endif
52 #ifndef WEXITSTATUS
53 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
54 #endif
55 #else /* defined (_WIN32) && ! defined (__CYGWIN__) */
56 #ifndef WIFEXITED
57 #define WIFEXITED(w) (((w) & 0xff) == 0)
58 #endif
59 #ifndef WIFSIGNALED
60 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
61 #endif
62 #ifndef WTERMSIG
63 #define WTERMSIG(w) ((w) & 0x7f)
64 #endif
65 #ifndef WEXITSTATUS
66 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
67 #endif
68 #endif /* defined (_WIN32) && ! defined (__CYGWIN__) */
69 #endif /* ! HAVE_SYS_WAIT_H */
70
71 #ifndef STDOUT_FILENO
72 #define STDOUT_FILENO 1
73 #endif
74
75 #if defined (_WIN32) && ! defined (__CYGWIN__)
76 #define popen _popen
77 #define pclose _pclose
78 #endif
79
80 /* The default preprocessor. */
81
82 #define DEFAULT_PREPROCESSOR "gcc -E -xc -DRC_INVOKED"
83
84 /* We read the directory entries in a cursor or icon file into
85 instances of this structure. */
86
87 struct icondir
88 {
89 /* Width of image. */
90 unsigned char width;
91 /* Height of image. */
92 unsigned char height;
93 /* Number of colors in image. */
94 unsigned char colorcount;
95 union
96 {
97 struct
98 {
99 /* Color planes. */
100 unsigned short planes;
101 /* Bits per pixel. */
102 unsigned short bits;
103 } icon;
104 struct
105 {
106 /* X coordinate of hotspot. */
107 unsigned short xhotspot;
108 /* Y coordinate of hotspot. */
109 unsigned short yhotspot;
110 } cursor;
111 } u;
112 /* Bytes in image. */
113 unsigned long bytes;
114 /* File offset of image. */
115 unsigned long offset;
116 };
117
118 /* The name of the rc file we are reading. */
119
120 char *rc_filename;
121
122 /* The line number in the rc file. */
123
124 int rc_lineno;
125
126 /* The pipe we are reading from, so that we can close it if we exit. */
127
128 static FILE *cpp_pipe;
129
130 /* The temporary file used if we're not using popen, so we can delete it
131 if we exit. */
132
133 static char *cpp_temp_file;
134
135 /* Input stream is either a file or a pipe. */
136
137 static enum {ISTREAM_PIPE, ISTREAM_FILE} istream_type;
138
139 /* As we read the rc file, we attach information to this structure. */
140
141 static struct res_directory *resources;
142
143 /* The number of cursor resources we have written out. */
144
145 static int cursors;
146
147 /* The number of font resources we have written out. */
148
149 static int fonts;
150
151 /* Font directory information. */
152
153 struct fontdir *fontdirs;
154
155 /* Resource info to use for fontdirs. */
156
157 struct res_res_info fontdirs_resinfo;
158
159 /* The number of icon resources we have written out. */
160
161 static int icons;
162
163 /* Local functions. */
164
165 static int run_cmd (char *, const char *);
166 static FILE *open_input_stream (char *);
167 static FILE *look_for_default
168 (char *, const char *, int, const char *, const char *);
169 static void close_input_stream (void);
170 static void unexpected_eof (const char *);
171 static int get_word (FILE *, const char *);
172 static unsigned long get_long (FILE *, const char *);
173 static void get_data (FILE *, unsigned char *, unsigned long, const char *);
174 static void define_fontdirs (void);
175 \f
176 /* Run `cmd' and redirect the output to `redir'. */
177
178 static int
179 run_cmd (char *cmd, const char *redir)
180 {
181 char *s;
182 int pid, wait_status, retcode;
183 int i;
184 const char **argv;
185 char *errmsg_fmt, *errmsg_arg;
186 char *temp_base = choose_temp_base ();
187 int in_quote;
188 char sep;
189 int redir_handle = -1;
190 int stdout_save = -1;
191
192 /* Count the args. */
193 i = 0;
194
195 for (s = cmd; *s; s++)
196 if (*s == ' ')
197 i++;
198
199 i++;
200 argv = alloca (sizeof (char *) * (i + 3));
201 i = 0;
202 s = cmd;
203
204 while (1)
205 {
206 while (*s == ' ' && *s != 0)
207 s++;
208
209 if (*s == 0)
210 break;
211
212 in_quote = (*s == '\'' || *s == '"');
213 sep = (in_quote) ? *s++ : ' ';
214 argv[i++] = s;
215
216 while (*s != sep && *s != 0)
217 s++;
218
219 if (*s == 0)
220 break;
221
222 *s++ = 0;
223
224 if (in_quote)
225 s++;
226 }
227 argv[i++] = NULL;
228
229 /* Setup the redirection. We can't use the usual fork/exec and redirect
230 since we may be running on non-POSIX Windows host. */
231
232 fflush (stdout);
233 fflush (stderr);
234
235 /* Open temporary output file. */
236 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT, 0666);
237 if (redir_handle == -1)
238 fatal (_("can't open temporary file `%s': %s"), redir,
239 strerror (errno));
240
241 /* Duplicate the stdout file handle so it can be restored later. */
242 stdout_save = dup (STDOUT_FILENO);
243 if (stdout_save == -1)
244 fatal (_("can't redirect stdout: `%s': %s"), redir, strerror (errno));
245
246 /* Redirect stdout to our output file. */
247 dup2 (redir_handle, STDOUT_FILENO);
248
249 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
250 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
251
252 /* Restore stdout to its previous setting. */
253 dup2 (stdout_save, STDOUT_FILENO);
254
255 /* Close response file. */
256 close (redir_handle);
257
258 if (pid == -1)
259 {
260 fatal (_("%s %s: %s"), errmsg_fmt, errmsg_arg, strerror (errno));
261 return 1;
262 }
263
264 retcode = 0;
265 pid = pwait (pid, &wait_status, 0);
266
267 if (pid == -1)
268 {
269 fatal (_("wait: %s"), strerror (errno));
270 retcode = 1;
271 }
272 else if (WIFSIGNALED (wait_status))
273 {
274 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
275 retcode = 1;
276 }
277 else if (WIFEXITED (wait_status))
278 {
279 if (WEXITSTATUS (wait_status) != 0)
280 {
281 fatal (_("%s exited with status %d"), cmd,
282 WEXITSTATUS (wait_status));
283 retcode = 1;
284 }
285 }
286 else
287 retcode = 1;
288
289 return retcode;
290 }
291
292 static FILE *
293 open_input_stream (char *cmd)
294 {
295 if (istream_type == ISTREAM_FILE)
296 {
297 char *fileprefix;
298
299 fileprefix = choose_temp_base ();
300 cpp_temp_file = (char *) xmalloc (strlen (fileprefix) + 5);
301 sprintf (cpp_temp_file, "%s.irc", fileprefix);
302 free (fileprefix);
303
304 if (run_cmd (cmd, cpp_temp_file))
305 fatal (_("can't execute `%s': %s"), cmd, strerror (errno));
306
307 cpp_pipe = fopen (cpp_temp_file, FOPEN_RT);;
308 if (cpp_pipe == NULL)
309 fatal (_("can't open temporary file `%s': %s"),
310 cpp_temp_file, strerror (errno));
311
312 if (verbose)
313 fprintf (stderr,
314 _("Using temporary file `%s' to read preprocessor output\n"),
315 cpp_temp_file);
316 }
317 else
318 {
319 cpp_pipe = popen (cmd, FOPEN_RT);
320 if (cpp_pipe == NULL)
321 fatal (_("can't popen `%s': %s"), cmd, strerror (errno));
322 if (verbose)
323 fprintf (stderr, _("Using popen to read preprocessor output\n"));
324 }
325
326 xatexit (close_input_stream);
327 return cpp_pipe;
328 }
329
330 /* look for the preprocessor program */
331
332 static FILE *
333 look_for_default (char *cmd, const char *prefix, int end_prefix,
334 const char *preprocargs, const char *filename)
335 {
336 char *space;
337 int found;
338 struct stat s;
339
340 strcpy (cmd, prefix);
341
342 sprintf (cmd + end_prefix, "%s", DEFAULT_PREPROCESSOR);
343 space = strchr (cmd + end_prefix, ' ');
344 if (space)
345 *space = 0;
346
347 if (
348 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32)
349 strchr (cmd, '\\') ||
350 #endif
351 strchr (cmd, '/'))
352 {
353 found = (stat (cmd, &s) == 0
354 #ifdef HAVE_EXECUTABLE_SUFFIX
355 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
356 #endif
357 );
358
359 if (! found)
360 {
361 if (verbose)
362 fprintf (stderr, _("Tried `%s'\n"), cmd);
363 return NULL;
364 }
365 }
366
367 strcpy (cmd, prefix);
368
369 sprintf (cmd + end_prefix, "%s %s %s",
370 DEFAULT_PREPROCESSOR, preprocargs, filename);
371
372 if (verbose)
373 fprintf (stderr, _("Using `%s'\n"), cmd);
374
375 cpp_pipe = open_input_stream (cmd);
376 return cpp_pipe;
377 }
378
379 /* Read an rc file. */
380
381 struct res_directory *
382 read_rc_file (const char *filename, const char *preprocessor,
383 const char *preprocargs, int language, int use_temp_file)
384 {
385 char *cmd;
386
387 istream_type = (use_temp_file) ? ISTREAM_FILE : ISTREAM_PIPE;
388
389 if (preprocargs == NULL)
390 preprocargs = "";
391 if (filename == NULL)
392 filename = "-";
393
394 if (preprocessor)
395 {
396 cmd = xmalloc (strlen (preprocessor)
397 + strlen (preprocargs)
398 + strlen (filename)
399 + 10);
400 sprintf (cmd, "%s %s %s", preprocessor, preprocargs, filename);
401
402 cpp_pipe = open_input_stream (cmd);
403 }
404 else
405 {
406 char *dash, *slash, *cp;
407
408 preprocessor = DEFAULT_PREPROCESSOR;
409
410 cmd = xmalloc (strlen (program_name)
411 + strlen (preprocessor)
412 + strlen (preprocargs)
413 + strlen (filename)
414 #ifdef HAVE_EXECUTABLE_SUFFIX
415 + strlen (EXECUTABLE_SUFFIX)
416 #endif
417 + 10);
418
419
420 dash = slash = 0;
421 for (cp = program_name; *cp; cp++)
422 {
423 if (*cp == '-')
424 dash = cp;
425 if (
426 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32)
427 *cp == ':' || *cp == '\\' ||
428 #endif
429 *cp == '/')
430 {
431 slash = cp;
432 dash = 0;
433 }
434 }
435
436 cpp_pipe = 0;
437
438 if (dash)
439 {
440 /* First, try looking for a prefixed gcc in the windres
441 directory, with the same prefix as windres */
442
443 cpp_pipe = look_for_default (cmd, program_name, dash-program_name+1,
444 preprocargs, filename);
445 }
446
447 if (slash && !cpp_pipe)
448 {
449 /* Next, try looking for a gcc in the same directory as
450 that windres */
451
452 cpp_pipe = look_for_default (cmd, program_name, slash-program_name+1,
453 preprocargs, filename);
454 }
455
456 if (!cpp_pipe)
457 {
458 /* Sigh, try the default */
459
460 cpp_pipe = look_for_default (cmd, "", 0, preprocargs, filename);
461 }
462
463 }
464
465 free (cmd);
466
467 rc_filename = xstrdup (filename);
468 rc_lineno = 1;
469 if (language != -1)
470 rcparse_set_language (language);
471 yyin = cpp_pipe;
472 yyparse ();
473 rcparse_discard_strings ();
474
475 close_input_stream ();
476
477 if (fontdirs != NULL)
478 define_fontdirs ();
479
480 free (rc_filename);
481 rc_filename = NULL;
482
483 return resources;
484 }
485
486 /* Close the input stream if it is open. */
487
488 static void
489 close_input_stream (void)
490 {
491 if (istream_type == ISTREAM_FILE)
492 {
493 if (cpp_pipe != NULL)
494 fclose (cpp_pipe);
495
496 if (cpp_temp_file != NULL)
497 {
498 int errno_save = errno;
499
500 unlink (cpp_temp_file);
501 errno = errno_save;
502 free (cpp_temp_file);
503 }
504 }
505 else
506 {
507 if (cpp_pipe != NULL)
508 pclose (cpp_pipe);
509 }
510
511 /* Since this is also run via xatexit, safeguard. */
512 cpp_pipe = NULL;
513 cpp_temp_file = NULL;
514 }
515
516 /* Report an error while reading an rc file. */
517
518 void
519 yyerror (const char *msg)
520 {
521 fatal ("%s:%d: %s", rc_filename, rc_lineno, msg);
522 }
523
524 /* Issue a warning while reading an rc file. */
525
526 void
527 rcparse_warning (const char *msg)
528 {
529 fprintf (stderr, _("%s:%d: %s\n"), rc_filename, rc_lineno, msg);
530 }
531
532 /* Die if we get an unexpected end of file. */
533
534 static void
535 unexpected_eof (const char *msg)
536 {
537 fatal (_("%s: unexpected EOF"), msg);
538 }
539
540 /* Read a 16 bit word from a file. The data is assumed to be little
541 endian. */
542
543 static int
544 get_word (FILE *e, const char *msg)
545 {
546 int b1, b2;
547
548 b1 = getc (e);
549 b2 = getc (e);
550 if (feof (e))
551 unexpected_eof (msg);
552 return ((b2 & 0xff) << 8) | (b1 & 0xff);
553 }
554
555 /* Read a 32 bit word from a file. The data is assumed to be little
556 endian. */
557
558 static unsigned long
559 get_long (FILE *e, const char *msg)
560 {
561 int b1, b2, b3, b4;
562
563 b1 = getc (e);
564 b2 = getc (e);
565 b3 = getc (e);
566 b4 = getc (e);
567 if (feof (e))
568 unexpected_eof (msg);
569 return (((((((b4 & 0xff) << 8)
570 | (b3 & 0xff)) << 8)
571 | (b2 & 0xff)) << 8)
572 | (b1 & 0xff));
573 }
574
575 /* Read data from a file. This is a wrapper to do error checking. */
576
577 static void
578 get_data (FILE *e, unsigned char *p, unsigned long c, const char *msg)
579 {
580 unsigned long got;
581
582 got = fread (p, 1, c, e);
583 if (got == c)
584 return;
585
586 fatal (_("%s: read of %lu returned %lu"), msg, c, got);
587 }
588 \f
589 /* Define an accelerator resource. */
590
591 void
592 define_accelerator (struct res_id id, const struct res_res_info *resinfo,
593 struct accelerator *data)
594 {
595 struct res_resource *r;
596
597 r = define_standard_resource (&resources, RT_ACCELERATOR, id,
598 resinfo->language, 0);
599 r->type = RES_TYPE_ACCELERATOR;
600 r->u.acc = data;
601 r->res_info = *resinfo;
602 }
603
604 /* Define a bitmap resource. Bitmap data is stored in a file. The
605 first 14 bytes of the file are a standard header, which is not
606 included in the resource data. */
607
608 #define BITMAP_SKIP (14)
609
610 void
611 define_bitmap (struct res_id id, const struct res_res_info *resinfo,
612 const char *filename)
613 {
614 FILE *e;
615 char *real_filename;
616 struct stat s;
617 unsigned char *data;
618 int i;
619 struct res_resource *r;
620
621 e = open_file_search (filename, FOPEN_RB, "bitmap file", &real_filename);
622
623 if (stat (real_filename, &s) < 0)
624 fatal (_("stat failed on bitmap file `%s': %s"), real_filename,
625 strerror (errno));
626
627 data = (unsigned char *) res_alloc (s.st_size - BITMAP_SKIP);
628
629 for (i = 0; i < BITMAP_SKIP; i++)
630 getc (e);
631
632 get_data (e, data, s.st_size - BITMAP_SKIP, real_filename);
633
634 fclose (e);
635 free (real_filename);
636
637 r = define_standard_resource (&resources, RT_BITMAP, id,
638 resinfo->language, 0);
639
640 r->type = RES_TYPE_BITMAP;
641 r->u.data.length = s.st_size - BITMAP_SKIP;
642 r->u.data.data = data;
643 r->res_info = *resinfo;
644 }
645
646 /* Define a cursor resource. A cursor file may contain a set of
647 bitmaps, each representing the same cursor at various different
648 resolutions. They each get written out with a different ID. The
649 real cursor resource is then a group resource which can be used to
650 select one of the actual cursors. */
651
652 void
653 define_cursor (struct res_id id, const struct res_res_info *resinfo,
654 const char *filename)
655 {
656 FILE *e;
657 char *real_filename;
658 int type, count, i;
659 struct icondir *icondirs;
660 int first_cursor;
661 struct res_resource *r;
662 struct group_cursor *first, **pp;
663
664 e = open_file_search (filename, FOPEN_RB, "cursor file", &real_filename);
665
666 /* A cursor file is basically an icon file. The start of the file
667 is a three word structure. The first word is ignored. The
668 second word is the type of data. The third word is the number of
669 entries. */
670
671 get_word (e, real_filename);
672 type = get_word (e, real_filename);
673 count = get_word (e, real_filename);
674 if (type != 2)
675 fatal (_("cursor file `%s' does not contain cursor data"), real_filename);
676
677 /* Read in the icon directory entries. */
678
679 icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs);
680
681 for (i = 0; i < count; i++)
682 {
683 icondirs[i].width = getc (e);
684 icondirs[i].height = getc (e);
685 icondirs[i].colorcount = getc (e);
686 getc (e);
687 icondirs[i].u.cursor.xhotspot = get_word (e, real_filename);
688 icondirs[i].u.cursor.yhotspot = get_word (e, real_filename);
689 icondirs[i].bytes = get_long (e, real_filename);
690 icondirs[i].offset = get_long (e, real_filename);
691
692 if (feof (e))
693 unexpected_eof (real_filename);
694 }
695
696 /* Define each cursor as a unique resource. */
697
698 first_cursor = cursors;
699
700 for (i = 0; i < count; i++)
701 {
702 unsigned char *data;
703 struct res_id name;
704 struct cursor *c;
705
706 if (fseek (e, icondirs[i].offset, SEEK_SET) != 0)
707 fatal (_("%s: fseek to %lu failed: %s"), real_filename,
708 icondirs[i].offset, strerror (errno));
709
710 data = (unsigned char *) res_alloc (icondirs[i].bytes);
711
712 get_data (e, data, icondirs[i].bytes, real_filename);
713
714 c = (struct cursor *) res_alloc (sizeof *c);
715 c->xhotspot = icondirs[i].u.cursor.xhotspot;
716 c->yhotspot = icondirs[i].u.cursor.yhotspot;
717 c->length = icondirs[i].bytes;
718 c->data = data;
719
720 ++cursors;
721
722 name.named = 0;
723 name.u.id = cursors;
724
725 r = define_standard_resource (&resources, RT_CURSOR, name,
726 resinfo->language, 0);
727 r->type = RES_TYPE_CURSOR;
728 r->u.cursor = c;
729 r->res_info = *resinfo;
730 }
731
732 fclose (e);
733 free (real_filename);
734
735 /* Define a cursor group resource. */
736
737 first = NULL;
738 pp = &first;
739 for (i = 0; i < count; i++)
740 {
741 struct group_cursor *cg;
742
743 cg = (struct group_cursor *) res_alloc (sizeof *cg);
744 cg->next = NULL;
745 cg->width = icondirs[i].width;
746 cg->height = 2 * icondirs[i].height;
747
748 /* FIXME: What should these be set to? */
749 cg->planes = 1;
750 cg->bits = 1;
751
752 cg->bytes = icondirs[i].bytes + 4;
753 cg->index = first_cursor + i + 1;
754
755 *pp = cg;
756 pp = &(*pp)->next;
757 }
758
759 free (icondirs);
760
761 r = define_standard_resource (&resources, RT_GROUP_CURSOR, id,
762 resinfo->language, 0);
763 r->type = RES_TYPE_GROUP_CURSOR;
764 r->u.group_cursor = first;
765 r->res_info = *resinfo;
766 }
767
768 /* Define a dialog resource. */
769
770 void
771 define_dialog (struct res_id id, const struct res_res_info *resinfo,
772 const struct dialog *dialog)
773 {
774 struct dialog *copy;
775 struct res_resource *r;
776
777 copy = (struct dialog *) res_alloc (sizeof *copy);
778 *copy = *dialog;
779
780 r = define_standard_resource (&resources, RT_DIALOG, id,
781 resinfo->language, 0);
782 r->type = RES_TYPE_DIALOG;
783 r->u.dialog = copy;
784 r->res_info = *resinfo;
785 }
786
787 /* Define a dialog control. This does not define a resource, but
788 merely allocates and fills in a structure. */
789
790 struct dialog_control *
791 define_control (const struct res_id iid, unsigned long id, unsigned long x,
792 unsigned long y, unsigned long width, unsigned long height,
793 unsigned long class, unsigned long style,
794 unsigned long exstyle)
795 {
796 struct dialog_control *n;
797
798 n = (struct dialog_control *) res_alloc (sizeof *n);
799 n->next = NULL;
800 n->id = id;
801 n->style = style;
802 n->exstyle = exstyle;
803 n->x = x;
804 n->y = y;
805 n->width = width;
806 n->height = height;
807 n->class.named = 0;
808 n->class.u.id = class;
809 n->text = iid;
810 n->data = NULL;
811 n->help = 0;
812
813 return n;
814 }
815
816 struct dialog_control *
817 define_icon_control (struct res_id iid, unsigned long id, unsigned long x,
818 unsigned long y, unsigned long style,
819 unsigned long exstyle, unsigned long help,
820 struct rcdata_item *data, struct dialog_ex *ex)
821 {
822 struct dialog_control *n;
823 struct res_id tid;
824
825 if (style == 0)
826 style = SS_ICON | WS_CHILD | WS_VISIBLE;
827 res_string_to_id (&tid, "");
828 n = define_control (tid, id, x, y, 0, 0, CTL_STATIC, style, exstyle);
829 n->text = iid;
830 if (help && !ex)
831 rcparse_warning (_("help ID requires DIALOGEX"));
832 if (data && !ex)
833 rcparse_warning (_("control data requires DIALOGEX"));
834 n->help = help;
835 n->data = data;
836
837 return n;
838 }
839
840 /* Define a font resource. */
841
842 void
843 define_font (struct res_id id, const struct res_res_info *resinfo,
844 const char *filename)
845 {
846 FILE *e;
847 char *real_filename;
848 struct stat s;
849 unsigned char *data;
850 struct res_resource *r;
851 long offset;
852 long fontdatalength;
853 unsigned char *fontdata;
854 struct fontdir *fd;
855 const char *device, *face;
856 struct fontdir **pp;
857
858 e = open_file_search (filename, FOPEN_RB, "font file", &real_filename);
859
860 if (stat (real_filename, &s) < 0)
861 fatal (_("stat failed on font file `%s': %s"), real_filename,
862 strerror (errno));
863
864 data = (unsigned char *) res_alloc (s.st_size);
865
866 get_data (e, data, s.st_size, real_filename);
867
868 fclose (e);
869 free (real_filename);
870
871 r = define_standard_resource (&resources, RT_FONT, id,
872 resinfo->language, 0);
873
874 r->type = RES_TYPE_FONT;
875 r->u.data.length = s.st_size;
876 r->u.data.data = data;
877 r->res_info = *resinfo;
878
879 /* For each font resource, we must add an entry in the FONTDIR
880 resource. The FONTDIR resource includes some strings in the font
881 file. To find them, we have to do some magic on the data we have
882 read. */
883
884 offset = ((((((data[47] << 8)
885 | data[46]) << 8)
886 | data[45]) << 8)
887 | data[44]);
888 if (offset > 0 && offset < s.st_size)
889 device = (char *) data + offset;
890 else
891 device = "";
892
893 offset = ((((((data[51] << 8)
894 | data[50]) << 8)
895 | data[49]) << 8)
896 | data[48]);
897 if (offset > 0 && offset < s.st_size)
898 face = (char *) data + offset;
899 else
900 face = "";
901
902 ++fonts;
903
904 fontdatalength = 58 + strlen (device) + strlen (face);
905 fontdata = (unsigned char *) res_alloc (fontdatalength);
906 memcpy (fontdata, data, 56);
907 strcpy ((char *) fontdata + 56, device);
908 strcpy ((char *) fontdata + 57 + strlen (device), face);
909
910 fd = (struct fontdir *) res_alloc (sizeof *fd);
911 fd->next = NULL;
912 fd->index = fonts;
913 fd->length = fontdatalength;
914 fd->data = fontdata;
915
916 for (pp = &fontdirs; *pp != NULL; pp = &(*pp)->next)
917 ;
918 *pp = fd;
919
920 /* For the single fontdirs resource, we always use the resource
921 information of the last font. I don't know what else to do. */
922 fontdirs_resinfo = *resinfo;
923 }
924
925 /* Define the fontdirs resource. This is called after the entire rc
926 file has been parsed, if any font resources were seen. */
927
928 static void
929 define_fontdirs (void)
930 {
931 struct res_resource *r;
932 struct res_id id;
933
934 id.named = 0;
935 id.u.id = 1;
936
937 r = define_standard_resource (&resources, RT_FONTDIR, id, 0x409, 0);
938
939 r->type = RES_TYPE_FONTDIR;
940 r->u.fontdir = fontdirs;
941 r->res_info = fontdirs_resinfo;
942 }
943
944 /* Define an icon resource. An icon file may contain a set of
945 bitmaps, each representing the same icon at various different
946 resolutions. They each get written out with a different ID. The
947 real icon resource is then a group resource which can be used to
948 select one of the actual icon bitmaps. */
949
950 void
951 define_icon (struct res_id id, const struct res_res_info *resinfo,
952 const char *filename)
953 {
954 FILE *e;
955 char *real_filename;
956 int type, count, i;
957 struct icondir *icondirs;
958 int first_icon;
959 struct res_resource *r;
960 struct group_icon *first, **pp;
961
962 e = open_file_search (filename, FOPEN_RB, "icon file", &real_filename);
963
964 /* The start of an icon file is a three word structure. The first
965 word is ignored. The second word is the type of data. The third
966 word is the number of entries. */
967
968 get_word (e, real_filename);
969 type = get_word (e, real_filename);
970 count = get_word (e, real_filename);
971 if (type != 1)
972 fatal (_("icon file `%s' does not contain icon data"), real_filename);
973
974 /* Read in the icon directory entries. */
975
976 icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs);
977
978 for (i = 0; i < count; i++)
979 {
980 icondirs[i].width = getc (e);
981 icondirs[i].height = getc (e);
982 icondirs[i].colorcount = getc (e);
983 getc (e);
984 icondirs[i].u.icon.planes = get_word (e, real_filename);
985 icondirs[i].u.icon.bits = get_word (e, real_filename);
986 icondirs[i].bytes = get_long (e, real_filename);
987 icondirs[i].offset = get_long (e, real_filename);
988
989 if (feof (e))
990 unexpected_eof (real_filename);
991 }
992
993 /* Define each icon as a unique resource. */
994
995 first_icon = icons;
996
997 for (i = 0; i < count; i++)
998 {
999 unsigned char *data;
1000 struct res_id name;
1001
1002 if (fseek (e, icondirs[i].offset, SEEK_SET) != 0)
1003 fatal (_("%s: fseek to %lu failed: %s"), real_filename,
1004 icondirs[i].offset, strerror (errno));
1005
1006 data = (unsigned char *) res_alloc (icondirs[i].bytes);
1007
1008 get_data (e, data, icondirs[i].bytes, real_filename);
1009
1010 ++icons;
1011
1012 name.named = 0;
1013 name.u.id = icons;
1014
1015 r = define_standard_resource (&resources, RT_ICON, name,
1016 resinfo->language, 0);
1017 r->type = RES_TYPE_ICON;
1018 r->u.data.length = icondirs[i].bytes;
1019 r->u.data.data = data;
1020 r->res_info = *resinfo;
1021 }
1022
1023 fclose (e);
1024 free (real_filename);
1025
1026 /* Define an icon group resource. */
1027
1028 first = NULL;
1029 pp = &first;
1030 for (i = 0; i < count; i++)
1031 {
1032 struct group_icon *cg;
1033
1034 /* For some reason, at least in some files the planes and bits
1035 are zero. We instead set them from the color. This is
1036 copied from rcl. */
1037
1038 cg = (struct group_icon *) res_alloc (sizeof *cg);
1039 cg->next = NULL;
1040 cg->width = icondirs[i].width;
1041 cg->height = icondirs[i].height;
1042 cg->colors = icondirs[i].colorcount;
1043
1044 if (icondirs[i].u.icon.planes)
1045 cg->planes = icondirs[i].u.icon.planes;
1046 else
1047 cg->planes = 1;
1048
1049 if (icondirs[i].u.icon.bits)
1050 cg->bits = icondirs[i].u.icon.bits;
1051 else
1052 {
1053 cg->bits = 0;
1054
1055 while ((1L << cg->bits) < cg->colors)
1056 ++cg->bits;
1057 }
1058
1059 cg->bytes = icondirs[i].bytes;
1060 cg->index = first_icon + i + 1;
1061
1062 *pp = cg;
1063 pp = &(*pp)->next;
1064 }
1065
1066 free (icondirs);
1067
1068 r = define_standard_resource (&resources, RT_GROUP_ICON, id,
1069 resinfo->language, 0);
1070 r->type = RES_TYPE_GROUP_ICON;
1071 r->u.group_icon = first;
1072 r->res_info = *resinfo;
1073 }
1074
1075 /* Define a menu resource. */
1076
1077 void
1078 define_menu (struct res_id id, const struct res_res_info *resinfo,
1079 struct menuitem *menuitems)
1080 {
1081 struct menu *m;
1082 struct res_resource *r;
1083
1084 m = (struct menu *) res_alloc (sizeof *m);
1085 m->items = menuitems;
1086 m->help = 0;
1087
1088 r = define_standard_resource (&resources, RT_MENU, id, resinfo->language, 0);
1089 r->type = RES_TYPE_MENU;
1090 r->u.menu = m;
1091 r->res_info = *resinfo;
1092 }
1093
1094 /* Define a menu item. This does not define a resource, but merely
1095 allocates and fills in a structure. */
1096
1097 struct menuitem *
1098 define_menuitem (const char *text, int menuid, unsigned long type,
1099 unsigned long state, unsigned long help,
1100 struct menuitem *menuitems)
1101 {
1102 struct menuitem *mi;
1103
1104 mi = (struct menuitem *) res_alloc (sizeof *mi);
1105 mi->next = NULL;
1106 mi->type = type;
1107 mi->state = state;
1108 mi->id = menuid;
1109 if (text == NULL)
1110 mi->text = NULL;
1111 else
1112 unicode_from_ascii ((int *) NULL, &mi->text, text);
1113 mi->help = help;
1114 mi->popup = menuitems;
1115 return mi;
1116 }
1117
1118 /* Define a messagetable resource. */
1119
1120 void
1121 define_messagetable (struct res_id id, const struct res_res_info *resinfo,
1122 const char *filename)
1123 {
1124 FILE *e;
1125 char *real_filename;
1126 struct stat s;
1127 unsigned char *data;
1128 struct res_resource *r;
1129
1130 e = open_file_search (filename, FOPEN_RB, "messagetable file",
1131 &real_filename);
1132
1133 if (stat (real_filename, &s) < 0)
1134 fatal (_("stat failed on bitmap file `%s': %s"), real_filename,
1135 strerror (errno));
1136
1137 data = (unsigned char *) res_alloc (s.st_size);
1138
1139 get_data (e, data, s.st_size, real_filename);
1140
1141 fclose (e);
1142 free (real_filename);
1143
1144 r = define_standard_resource (&resources, RT_MESSAGETABLE, id,
1145 resinfo->language, 0);
1146
1147 r->type = RES_TYPE_MESSAGETABLE;
1148 r->u.data.length = s.st_size;
1149 r->u.data.data = data;
1150 r->res_info = *resinfo;
1151 }
1152
1153 /* Define an rcdata resource. */
1154
1155 void
1156 define_rcdata (struct res_id id, const struct res_res_info *resinfo,
1157 struct rcdata_item *data)
1158 {
1159 struct res_resource *r;
1160
1161 r = define_standard_resource (&resources, RT_RCDATA, id,
1162 resinfo->language, 0);
1163 r->type = RES_TYPE_RCDATA;
1164 r->u.rcdata = data;
1165 r->res_info = *resinfo;
1166 }
1167
1168 /* Create an rcdata item holding a string. */
1169
1170 struct rcdata_item *
1171 define_rcdata_string (const char *string, unsigned long len)
1172 {
1173 struct rcdata_item *ri;
1174 char *s;
1175
1176 ri = (struct rcdata_item *) res_alloc (sizeof *ri);
1177 ri->next = NULL;
1178 ri->type = RCDATA_STRING;
1179 ri->u.string.length = len;
1180 s = (char *) res_alloc (len);
1181 memcpy (s, string, len);
1182 ri->u.string.s = s;
1183
1184 return ri;
1185 }
1186
1187 /* Create an rcdata item holding a number. */
1188
1189 struct rcdata_item *
1190 define_rcdata_number (unsigned long val, int dword)
1191 {
1192 struct rcdata_item *ri;
1193
1194 ri = (struct rcdata_item *) res_alloc (sizeof *ri);
1195 ri->next = NULL;
1196 ri->type = dword ? RCDATA_DWORD : RCDATA_WORD;
1197 ri->u.word = val;
1198
1199 return ri;
1200 }
1201
1202 /* Define a stringtable resource. This is called for each string
1203 which appears in a STRINGTABLE statement. */
1204
1205 void
1206 define_stringtable (const struct res_res_info *resinfo,
1207 unsigned long stringid, const char *string)
1208 {
1209 struct res_id id;
1210 struct res_resource *r;
1211
1212 id.named = 0;
1213 id.u.id = (stringid >> 4) + 1;
1214 r = define_standard_resource (&resources, RT_STRING, id,
1215 resinfo->language, 1);
1216
1217 if (r->type == RES_TYPE_UNINITIALIZED)
1218 {
1219 int i;
1220
1221 r->type = RES_TYPE_STRINGTABLE;
1222 r->u.stringtable = ((struct stringtable *)
1223 res_alloc (sizeof (struct stringtable)));
1224 for (i = 0; i < 16; i++)
1225 {
1226 r->u.stringtable->strings[i].length = 0;
1227 r->u.stringtable->strings[i].string = NULL;
1228 }
1229
1230 r->res_info = *resinfo;
1231 }
1232
1233 unicode_from_ascii (&r->u.stringtable->strings[stringid & 0xf].length,
1234 &r->u.stringtable->strings[stringid & 0xf].string,
1235 string);
1236 }
1237
1238 /* Define a user data resource where the data is in the rc file. */
1239
1240 void
1241 define_user_data (struct res_id id, struct res_id type,
1242 const struct res_res_info *resinfo,
1243 struct rcdata_item *data)
1244 {
1245 struct res_id ids[3];
1246 struct res_resource *r;
1247
1248 ids[0] = type;
1249 ids[1] = id;
1250 ids[2].named = 0;
1251 ids[2].u.id = resinfo->language;
1252
1253 r = define_resource (& resources, 3, ids, 0);
1254 r->type = RES_TYPE_USERDATA;
1255 r->u.userdata = data;
1256 r->res_info = *resinfo;
1257 }
1258
1259 void
1260 define_rcdata_file (struct res_id id, const struct res_res_info *resinfo,
1261 const char *filename)
1262 {
1263 struct rcdata_item *ri;
1264 FILE *e;
1265 char *real_filename;
1266 struct stat s;
1267 unsigned char *data;
1268
1269 e = open_file_search (filename, FOPEN_RB, "file", &real_filename);
1270
1271
1272 if (stat (real_filename, &s) < 0)
1273 fatal (_("stat failed on file `%s': %s"), real_filename,
1274 strerror (errno));
1275
1276 data = (unsigned char *) res_alloc (s.st_size);
1277
1278 get_data (e, data, s.st_size, real_filename);
1279
1280 fclose (e);
1281 free (real_filename);
1282
1283 ri = (struct rcdata_item *) res_alloc (sizeof *ri);
1284 ri->next = NULL;
1285 ri->type = RCDATA_BUFFER;
1286 ri->u.buffer.length = s.st_size;
1287 ri->u.buffer.data = data;
1288
1289 define_rcdata (id, resinfo, ri);
1290 }
1291
1292 /* Define a user data resource where the data is in a file. */
1293
1294 void
1295 define_user_file (struct res_id id, struct res_id type,
1296 const struct res_res_info *resinfo, const char *filename)
1297 {
1298 FILE *e;
1299 char *real_filename;
1300 struct stat s;
1301 unsigned char *data;
1302 struct res_id ids[3];
1303 struct res_resource *r;
1304
1305 e = open_file_search (filename, FOPEN_RB, "file", &real_filename);
1306
1307 if (stat (real_filename, &s) < 0)
1308 fatal (_("stat failed on file `%s': %s"), real_filename,
1309 strerror (errno));
1310
1311 data = (unsigned char *) res_alloc (s.st_size);
1312
1313 get_data (e, data, s.st_size, real_filename);
1314
1315 fclose (e);
1316 free (real_filename);
1317
1318 ids[0] = type;
1319 ids[1] = id;
1320 ids[2].named = 0;
1321 ids[2].u.id = resinfo->language;
1322
1323 r = define_resource (&resources, 3, ids, 0);
1324 r->type = RES_TYPE_USERDATA;
1325 r->u.userdata = ((struct rcdata_item *)
1326 res_alloc (sizeof (struct rcdata_item)));
1327 r->u.userdata->next = NULL;
1328 r->u.userdata->type = RCDATA_BUFFER;
1329 r->u.userdata->u.buffer.length = s.st_size;
1330 r->u.userdata->u.buffer.data = data;
1331 r->res_info = *resinfo;
1332 }
1333
1334 /* Define a versioninfo resource. */
1335
1336 void
1337 define_versioninfo (struct res_id id, int language,
1338 struct fixed_versioninfo *fixedverinfo,
1339 struct ver_info *verinfo)
1340 {
1341 struct res_resource *r;
1342
1343 r = define_standard_resource (&resources, RT_VERSION, id, language, 0);
1344 r->type = RES_TYPE_VERSIONINFO;
1345 r->u.versioninfo = ((struct versioninfo *)
1346 res_alloc (sizeof (struct versioninfo)));
1347 r->u.versioninfo->fixed = fixedverinfo;
1348 r->u.versioninfo->var = verinfo;
1349 r->res_info.language = language;
1350 }
1351
1352 /* Add string version info to a list of version information. */
1353
1354 struct ver_info *
1355 append_ver_stringfileinfo (struct ver_info *verinfo, const char *language,
1356 struct ver_stringinfo *strings)
1357 {
1358 struct ver_info *vi, **pp;
1359
1360 vi = (struct ver_info *) res_alloc (sizeof *vi);
1361 vi->next = NULL;
1362 vi->type = VERINFO_STRING;
1363 unicode_from_ascii ((int *) NULL, &vi->u.string.language, language);
1364 vi->u.string.strings = strings;
1365
1366 for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
1367 ;
1368 *pp = vi;
1369
1370 return verinfo;
1371 }
1372
1373 /* Add variable version info to a list of version information. */
1374
1375 struct ver_info *
1376 append_ver_varfileinfo (struct ver_info *verinfo, const char *key,
1377 struct ver_varinfo *var)
1378 {
1379 struct ver_info *vi, **pp;
1380
1381 vi = (struct ver_info *) res_alloc (sizeof *vi);
1382 vi->next = NULL;
1383 vi->type = VERINFO_VAR;
1384 unicode_from_ascii ((int *) NULL, &vi->u.var.key, key);
1385 vi->u.var.var = var;
1386
1387 for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
1388 ;
1389 *pp = vi;
1390
1391 return verinfo;
1392 }
1393
1394 /* Append version string information to a list. */
1395
1396 struct ver_stringinfo *
1397 append_verval (struct ver_stringinfo *strings, const char *key,
1398 const char *value)
1399 {
1400 struct ver_stringinfo *vs, **pp;
1401
1402 vs = (struct ver_stringinfo *) res_alloc (sizeof *vs);
1403 vs->next = NULL;
1404 unicode_from_ascii ((int *) NULL, &vs->key, key);
1405 unicode_from_ascii ((int *) NULL, &vs->value, value);
1406
1407 for (pp = &strings; *pp != NULL; pp = &(*pp)->next)
1408 ;
1409 *pp = vs;
1410
1411 return strings;
1412 }
1413
1414 /* Append version variable information to a list. */
1415
1416 struct ver_varinfo *
1417 append_vertrans (struct ver_varinfo *var, unsigned long language,
1418 unsigned long charset)
1419 {
1420 struct ver_varinfo *vv, **pp;
1421
1422 vv = (struct ver_varinfo *) res_alloc (sizeof *vv);
1423 vv->next = NULL;
1424 vv->language = language;
1425 vv->charset = charset;
1426
1427 for (pp = &var; *pp != NULL; pp = &(*pp)->next)
1428 ;
1429 *pp = vv;
1430
1431 return var;
1432 }
1433 \f
1434 /* Local functions used to write out an rc file. */
1435
1436 static void indent (FILE *, int);
1437 static void write_rc_directory
1438 (FILE *, const struct res_directory *, const struct res_id *,
1439 const struct res_id *, int *, int);
1440 static void write_rc_subdir
1441 (FILE *, const struct res_entry *, const struct res_id *,
1442 const struct res_id *, int *, int);
1443 static void write_rc_resource
1444 (FILE *, const struct res_id *, const struct res_id *,
1445 const struct res_resource *, int *);
1446 static void write_rc_accelerators (FILE *, const struct accelerator *);
1447 static void write_rc_cursor (FILE *, const struct cursor *);
1448 static void write_rc_group_cursor (FILE *, const struct group_cursor *);
1449 static void write_rc_dialog (FILE *, const struct dialog *);
1450 static void write_rc_dialog_control (FILE *, const struct dialog_control *);
1451 static void write_rc_fontdir (FILE *, const struct fontdir *);
1452 static void write_rc_group_icon (FILE *, const struct group_icon *);
1453 static void write_rc_menu (FILE *, const struct menu *, int);
1454 static void write_rc_menuitems (FILE *, const struct menuitem *, int, int);
1455 static void write_rc_rcdata (FILE *, const struct rcdata_item *, int);
1456 static void write_rc_stringtable
1457 (FILE *, const struct res_id *, const struct stringtable *);
1458 static void write_rc_versioninfo (FILE *, const struct versioninfo *);
1459 static void write_rc_filedata (FILE *, unsigned long, const unsigned char *);
1460
1461 /* Indent a given number of spaces. */
1462
1463 static void
1464 indent (FILE *e, int c)
1465 {
1466 int i;
1467
1468 for (i = 0; i < c; i++)
1469 putc (' ', e);
1470 }
1471
1472 /* Dump the resources we have read in the format of an rc file.
1473
1474 Actually, we don't use the format of an rc file, because it's way
1475 too much of a pain--for example, we'd have to write icon resources
1476 into a file and refer to that file. We just generate a readable
1477 format that kind of looks like an rc file, and is useful for
1478 understanding the contents of a resource file. Someday we may want
1479 to generate an rc file which the rc compiler can read; if that day
1480 comes, this code will have to be fixed up. */
1481
1482 void
1483 write_rc_file (const char *filename, const struct res_directory *resources)
1484 {
1485 FILE *e;
1486 int language;
1487
1488 if (filename == NULL)
1489 e = stdout;
1490 else
1491 {
1492 e = fopen (filename, FOPEN_WT);
1493 if (e == NULL)
1494 fatal (_("can't open `%s' for output: %s"), filename, strerror (errno));
1495 }
1496
1497 language = -1;
1498 write_rc_directory (e, resources, (const struct res_id *) NULL,
1499 (const struct res_id *) NULL, &language, 1);
1500 }
1501
1502 /* Write out a directory. E is the file to write to. RD is the
1503 directory. TYPE is a pointer to the level 1 ID which serves as the
1504 resource type. NAME is a pointer to the level 2 ID which serves as
1505 an individual resource name. LANGUAGE is a pointer to the current
1506 language. LEVEL is the level in the tree. */
1507
1508 static void
1509 write_rc_directory (FILE *e, const struct res_directory *rd,
1510 const struct res_id *type, const struct res_id *name,
1511 int *language, int level)
1512 {
1513 const struct res_entry *re;
1514
1515 /* Print out some COFF information that rc files can't represent. */
1516
1517 if (rd->time != 0)
1518 fprintf (e, "// Time stamp: %lu\n", rd->time);
1519 if (rd->characteristics != 0)
1520 fprintf (e, "// Characteristics: %lu\n", rd->characteristics);
1521 if (rd->major != 0 || rd->minor != 0)
1522 fprintf (e, "// Version: %d %d\n", rd->major, rd->minor);
1523
1524 for (re = rd->entries; re != NULL; re = re->next)
1525 {
1526 switch (level)
1527 {
1528 case 1:
1529 /* If we're at level 1, the key of this resource is the
1530 type. This normally duplicates the information we have
1531 stored with the resource itself, but we need to remember
1532 the type if this is a user define resource type. */
1533 type = &re->id;
1534 break;
1535
1536 case 2:
1537 /* If we're at level 2, the key of this resource is the name
1538 we are going to use in the rc printout. */
1539 name = &re->id;
1540 break;
1541
1542 case 3:
1543 /* If we're at level 3, then this key represents a language.
1544 Use it to update the current language. */
1545 if (! re->id.named
1546 && re->id.u.id != (unsigned long) (unsigned int) *language
1547 && (re->id.u.id & 0xffff) == re->id.u.id)
1548 {
1549 fprintf (e, "LANGUAGE %lu, %lu\n",
1550 re->id.u.id & ((1 << SUBLANG_SHIFT) - 1),
1551 (re->id.u.id >> SUBLANG_SHIFT) & 0xff);
1552 *language = re->id.u.id;
1553 }
1554 break;
1555
1556 default:
1557 break;
1558 }
1559
1560 if (re->subdir)
1561 write_rc_subdir (e, re, type, name, language, level);
1562 else
1563 {
1564 if (level == 3)
1565 {
1566 /* This is the normal case: the three levels are
1567 TYPE/NAME/LANGUAGE. NAME will have been set at level
1568 2, and represents the name to use. We probably just
1569 set LANGUAGE, and it will probably match what the
1570 resource itself records if anything. */
1571 write_rc_resource (e, type, name, re->u.res, language);
1572 }
1573 else
1574 {
1575 fprintf (e, "// Resource at unexpected level %d\n", level);
1576 write_rc_resource (e, type, (struct res_id *) NULL, re->u.res,
1577 language);
1578 }
1579 }
1580 }
1581 }
1582
1583 /* Write out a subdirectory entry. E is the file to write to. RE is
1584 the subdirectory entry. TYPE and NAME are pointers to higher level
1585 IDs, or NULL. LANGUAGE is a pointer to the current language.
1586 LEVEL is the level in the tree. */
1587
1588 static void
1589 write_rc_subdir (FILE *e, const struct res_entry *re,
1590 const struct res_id *type, const struct res_id *name,
1591 int *language, int level)
1592 {
1593 fprintf (e, "\n");
1594 switch (level)
1595 {
1596 case 1:
1597 fprintf (e, "// Type: ");
1598 if (re->id.named)
1599 res_id_print (e, re->id, 1);
1600 else
1601 {
1602 const char *s;
1603
1604 switch (re->id.u.id)
1605 {
1606 case RT_CURSOR: s = "cursor"; break;
1607 case RT_BITMAP: s = "bitmap"; break;
1608 case RT_ICON: s = "icon"; break;
1609 case RT_MENU: s = "menu"; break;
1610 case RT_DIALOG: s = "dialog"; break;
1611 case RT_STRING: s = "stringtable"; break;
1612 case RT_FONTDIR: s = "fontdir"; break;
1613 case RT_FONT: s = "font"; break;
1614 case RT_ACCELERATOR: s = "accelerators"; break;
1615 case RT_RCDATA: s = "rcdata"; break;
1616 case RT_MESSAGETABLE: s = "messagetable"; break;
1617 case RT_GROUP_CURSOR: s = "group cursor"; break;
1618 case RT_GROUP_ICON: s = "group icon"; break;
1619 case RT_VERSION: s = "version"; break;
1620 case RT_DLGINCLUDE: s = "dlginclude"; break;
1621 case RT_PLUGPLAY: s = "plugplay"; break;
1622 case RT_VXD: s = "vxd"; break;
1623 case RT_ANICURSOR: s = "anicursor"; break;
1624 case RT_ANIICON: s = "aniicon"; break;
1625 default: s = NULL; break;
1626 }
1627
1628 if (s != NULL)
1629 fprintf (e, "%s", s);
1630 else
1631 res_id_print (e, re->id, 1);
1632 }
1633 fprintf (e, "\n");
1634 break;
1635
1636 case 2:
1637 fprintf (e, "// Name: ");
1638 res_id_print (e, re->id, 1);
1639 fprintf (e, "\n");
1640 break;
1641
1642 case 3:
1643 fprintf (e, "// Language: ");
1644 res_id_print (e, re->id, 1);
1645 fprintf (e, "\n");
1646 break;
1647
1648 default:
1649 fprintf (e, "// Level %d: ", level);
1650 res_id_print (e, re->id, 1);
1651 fprintf (e, "\n");
1652 }
1653
1654 write_rc_directory (e, re->u.dir, type, name, language, level + 1);
1655 }
1656
1657 /* Write out a single resource. E is the file to write to. TYPE is a
1658 pointer to the type of the resource. NAME is a pointer to the name
1659 of the resource; it will be NULL if there is a level mismatch. RES
1660 is the resource data. LANGUAGE is a pointer to the current
1661 language. */
1662
1663 static void
1664 write_rc_resource (FILE *e, const struct res_id *type,
1665 const struct res_id *name, const struct res_resource *res,
1666 int *language)
1667 {
1668 const char *s;
1669 int rt;
1670 int menuex = 0;
1671
1672 fprintf (e, "\n");
1673
1674 switch (res->type)
1675 {
1676 default:
1677 abort ();
1678
1679 case RES_TYPE_ACCELERATOR:
1680 s = "ACCELERATOR";
1681 rt = RT_ACCELERATOR;
1682 break;
1683
1684 case RES_TYPE_BITMAP:
1685 s = "BITMAP";
1686 rt = RT_BITMAP;
1687 break;
1688
1689 case RES_TYPE_CURSOR:
1690 s = "CURSOR";
1691 rt = RT_CURSOR;
1692 break;
1693
1694 case RES_TYPE_GROUP_CURSOR:
1695 s = "GROUP_CURSOR";
1696 rt = RT_GROUP_CURSOR;
1697 break;
1698
1699 case RES_TYPE_DIALOG:
1700 if (extended_dialog (res->u.dialog))
1701 s = "DIALOGEX";
1702 else
1703 s = "DIALOG";
1704 rt = RT_DIALOG;
1705 break;
1706
1707 case RES_TYPE_FONT:
1708 s = "FONT";
1709 rt = RT_FONT;
1710 break;
1711
1712 case RES_TYPE_FONTDIR:
1713 s = "FONTDIR";
1714 rt = RT_FONTDIR;
1715 break;
1716
1717 case RES_TYPE_ICON:
1718 s = "ICON";
1719 rt = RT_ICON;
1720 break;
1721
1722 case RES_TYPE_GROUP_ICON:
1723 s = "GROUP_ICON";
1724 rt = RT_GROUP_ICON;
1725 break;
1726
1727 case RES_TYPE_MENU:
1728 if (extended_menu (res->u.menu))
1729 {
1730 s = "MENUEX";
1731 menuex = 1;
1732 }
1733 else
1734 {
1735 s = "MENU";
1736 menuex = 0;
1737 }
1738 rt = RT_MENU;
1739 break;
1740
1741 case RES_TYPE_MESSAGETABLE:
1742 s = "MESSAGETABLE";
1743 rt = RT_MESSAGETABLE;
1744 break;
1745
1746 case RES_TYPE_RCDATA:
1747 s = "RCDATA";
1748 rt = RT_RCDATA;
1749 break;
1750
1751 case RES_TYPE_STRINGTABLE:
1752 s = "STRINGTABLE";
1753 rt = RT_STRING;
1754 break;
1755
1756 case RES_TYPE_USERDATA:
1757 s = NULL;
1758 rt = 0;
1759 break;
1760
1761 case RES_TYPE_VERSIONINFO:
1762 s = "VERSIONINFO";
1763 rt = RT_VERSION;
1764 break;
1765 }
1766
1767 if (rt != 0
1768 && type != NULL
1769 && (type->named || type->u.id != (unsigned long) rt))
1770 {
1771 fprintf (e, "// Unexpected resource type mismatch: ");
1772 res_id_print (e, *type, 1);
1773 fprintf (e, " != %d", rt);
1774 }
1775
1776 if (res->coff_info.codepage != 0)
1777 fprintf (e, "// Code page: %lu\n", res->coff_info.codepage);
1778 if (res->coff_info.reserved != 0)
1779 fprintf (e, "// COFF reserved value: %lu\n", res->coff_info.reserved);
1780
1781 if (name != NULL)
1782 res_id_print (e, *name, 0);
1783 else
1784 fprintf (e, "??Unknown-Name??");
1785
1786 fprintf (e, " ");
1787 if (s != NULL)
1788 fprintf (e, "%s", s);
1789 else if (type != NULL)
1790 res_id_print (e, *type, 0);
1791 else
1792 fprintf (e, "??Unknown-Type??");
1793
1794 if (res->res_info.memflags != 0)
1795 {
1796 if ((res->res_info.memflags & MEMFLAG_MOVEABLE) != 0)
1797 fprintf (e, " MOVEABLE");
1798 if ((res->res_info.memflags & MEMFLAG_PURE) != 0)
1799 fprintf (e, " PURE");
1800 if ((res->res_info.memflags & MEMFLAG_PRELOAD) != 0)
1801 fprintf (e, " PRELOAD");
1802 if ((res->res_info.memflags & MEMFLAG_DISCARDABLE) != 0)
1803 fprintf (e, " DISCARDABLE");
1804 }
1805
1806 if (res->type == RES_TYPE_DIALOG)
1807 {
1808 fprintf (e, " %d, %d, %d, %d", res->u.dialog->x, res->u.dialog->y,
1809 res->u.dialog->width, res->u.dialog->height);
1810 if (res->u.dialog->ex != NULL
1811 && res->u.dialog->ex->help != 0)
1812 fprintf (e, ", %lu", res->u.dialog->ex->help);
1813 }
1814
1815 fprintf (e, "\n");
1816
1817 if ((res->res_info.language != 0 && res->res_info.language != *language)
1818 || res->res_info.characteristics != 0
1819 || res->res_info.version != 0)
1820 {
1821 int modifiers;
1822
1823 switch (res->type)
1824 {
1825 case RES_TYPE_ACCELERATOR:
1826 case RES_TYPE_DIALOG:
1827 case RES_TYPE_MENU:
1828 case RES_TYPE_RCDATA:
1829 case RES_TYPE_STRINGTABLE:
1830 modifiers = 1;
1831 break;
1832
1833 default:
1834 modifiers = 0;
1835 break;
1836 }
1837
1838 if (res->res_info.language != 0 && res->res_info.language != *language)
1839 fprintf (e, "%sLANGUAGE %d, %d\n",
1840 modifiers ? "// " : "",
1841 res->res_info.language & ((1<<SUBLANG_SHIFT)-1),
1842 (res->res_info.language >> SUBLANG_SHIFT) & 0xff);
1843 if (res->res_info.characteristics != 0)
1844 fprintf (e, "%sCHARACTERISTICS %lu\n",
1845 modifiers ? "// " : "",
1846 res->res_info.characteristics);
1847 if (res->res_info.version != 0)
1848 fprintf (e, "%sVERSION %lu\n",
1849 modifiers ? "// " : "",
1850 res->res_info.version);
1851 }
1852
1853 switch (res->type)
1854 {
1855 default:
1856 abort ();
1857
1858 case RES_TYPE_ACCELERATOR:
1859 write_rc_accelerators (e, res->u.acc);
1860 break;
1861
1862 case RES_TYPE_CURSOR:
1863 write_rc_cursor (e, res->u.cursor);
1864 break;
1865
1866 case RES_TYPE_GROUP_CURSOR:
1867 write_rc_group_cursor (e, res->u.group_cursor);
1868 break;
1869
1870 case RES_TYPE_DIALOG:
1871 write_rc_dialog (e, res->u.dialog);
1872 break;
1873
1874 case RES_TYPE_FONTDIR:
1875 write_rc_fontdir (e, res->u.fontdir);
1876 break;
1877
1878 case RES_TYPE_GROUP_ICON:
1879 write_rc_group_icon (e, res->u.group_icon);
1880 break;
1881
1882 case RES_TYPE_MENU:
1883 write_rc_menu (e, res->u.menu, menuex);
1884 break;
1885
1886 case RES_TYPE_RCDATA:
1887 write_rc_rcdata (e, res->u.rcdata, 0);
1888 break;
1889
1890 case RES_TYPE_STRINGTABLE:
1891 write_rc_stringtable (e, name, res->u.stringtable);
1892 break;
1893
1894 case RES_TYPE_USERDATA:
1895 write_rc_rcdata (e, res->u.userdata, 0);
1896 break;
1897
1898 case RES_TYPE_VERSIONINFO:
1899 write_rc_versioninfo (e, res->u.versioninfo);
1900 break;
1901
1902 case RES_TYPE_BITMAP:
1903 case RES_TYPE_FONT:
1904 case RES_TYPE_ICON:
1905 case RES_TYPE_MESSAGETABLE:
1906 write_rc_filedata (e, res->u.data.length, res->u.data.data);
1907 break;
1908 }
1909 }
1910
1911 /* Write out accelerator information. */
1912
1913 static void
1914 write_rc_accelerators (FILE *e, const struct accelerator *accelerators)
1915 {
1916 const struct accelerator *acc;
1917
1918 fprintf (e, "BEGIN\n");
1919 for (acc = accelerators; acc != NULL; acc = acc->next)
1920 {
1921 int printable;
1922
1923 fprintf (e, " ");
1924
1925 if ((acc->key & 0x7f) == acc->key
1926 && ISPRINT (acc->key)
1927 && (acc->flags & ACC_VIRTKEY) == 0)
1928 {
1929 fprintf (e, "\"%c\"", acc->key);
1930 printable = 1;
1931 }
1932 else
1933 {
1934 fprintf (e, "%d", acc->key);
1935 printable = 0;
1936 }
1937
1938 fprintf (e, ", %d", acc->id);
1939
1940 if (! printable)
1941 {
1942 if ((acc->flags & ACC_VIRTKEY) != 0)
1943 fprintf (e, ", VIRTKEY");
1944 else
1945 fprintf (e, ", ASCII");
1946 }
1947
1948 if ((acc->flags & ACC_SHIFT) != 0)
1949 fprintf (e, ", SHIFT");
1950 if ((acc->flags & ACC_CONTROL) != 0)
1951 fprintf (e, ", CONTROL");
1952 if ((acc->flags & ACC_ALT) != 0)
1953 fprintf (e, ", ALT");
1954
1955 fprintf (e, "\n");
1956 }
1957
1958 fprintf (e, "END\n");
1959 }
1960
1961 /* Write out cursor information. This would normally be in a separate
1962 file, which the rc file would include. */
1963
1964 static void
1965 write_rc_cursor (FILE *e, const struct cursor *cursor)
1966 {
1967 fprintf (e, "// Hotspot: x: %d; y: %d\n", cursor->xhotspot,
1968 cursor->yhotspot);
1969 write_rc_filedata (e, cursor->length, cursor->data);
1970 }
1971
1972 /* Write out group cursor data. This would normally be built from the
1973 cursor data. */
1974
1975 static void
1976 write_rc_group_cursor (FILE *e, const struct group_cursor *group_cursor)
1977 {
1978 const struct group_cursor *gc;
1979
1980 for (gc = group_cursor; gc != NULL; gc = gc->next)
1981 {
1982 fprintf (e, "// width: %d; height %d; planes %d; bits %d\n",
1983 gc->width, gc->height, gc->planes, gc->bits);
1984 fprintf (e, "// data bytes: %lu; index: %d\n",
1985 gc->bytes, gc->index);
1986 }
1987 }
1988
1989 /* Write dialog data. */
1990
1991 static void
1992 write_rc_dialog (FILE *e, const struct dialog *dialog)
1993 {
1994 const struct dialog_control *control;
1995
1996 fprintf (e, "STYLE 0x%lx\n", dialog->style);
1997
1998 if (dialog->exstyle != 0)
1999 fprintf (e, "EXSTYLE 0x%lx\n", dialog->exstyle);
2000
2001 if ((dialog->class.named && dialog->class.u.n.length > 0)
2002 || dialog->class.u.id != 0)
2003 {
2004 fprintf (e, "CLASS ");
2005 res_id_print (e, dialog->class, 1);
2006 fprintf (e, "\n");
2007 }
2008
2009 if (dialog->caption != NULL)
2010 {
2011 fprintf (e, "CAPTION \"");
2012 unicode_print (e, dialog->caption, -1);
2013 fprintf (e, "\"\n");
2014 }
2015
2016 if ((dialog->menu.named && dialog->menu.u.n.length > 0)
2017 || dialog->menu.u.id != 0)
2018 {
2019 fprintf (e, "MENU ");
2020 res_id_print (e, dialog->menu, 0);
2021 fprintf (e, "\n");
2022 }
2023
2024 if (dialog->font != NULL)
2025 {
2026 fprintf (e, "FONT %d, \"", dialog->pointsize);
2027 unicode_print (e, dialog->font, -1);
2028 fprintf (e, "\"");
2029 if (dialog->ex != NULL
2030 && (dialog->ex->weight != 0
2031 || dialog->ex->italic != 0
2032 || dialog->ex->charset != 1))
2033 fprintf (e, ", %d, %d, %d",
2034 dialog->ex->weight, dialog->ex->italic, dialog->ex->charset);
2035 fprintf (e, "\n");
2036 }
2037
2038 fprintf (e, "BEGIN\n");
2039
2040 for (control = dialog->controls; control != NULL; control = control->next)
2041 write_rc_dialog_control (e, control);
2042
2043 fprintf (e, "END\n");
2044 }
2045
2046 /* For each predefined control keyword, this table provides the class
2047 and the style. */
2048
2049 struct control_info
2050 {
2051 const char *name;
2052 unsigned short class;
2053 unsigned long style;
2054 };
2055
2056 static const struct control_info control_info[] =
2057 {
2058 { "AUTO3STATE", CTL_BUTTON, BS_AUTO3STATE },
2059 { "AUTOCHECKBOX", CTL_BUTTON, BS_AUTOCHECKBOX },
2060 { "AUTORADIOBUTTON", CTL_BUTTON, BS_AUTORADIOBUTTON },
2061 { "CHECKBOX", CTL_BUTTON, BS_CHECKBOX },
2062 { "COMBOBOX", CTL_COMBOBOX, (unsigned long) -1 },
2063 { "CTEXT", CTL_STATIC, SS_CENTER },
2064 { "DEFPUSHBUTTON", CTL_BUTTON, BS_DEFPUSHBUTTON },
2065 { "EDITTEXT", CTL_EDIT, (unsigned long) -1 },
2066 { "GROUPBOX", CTL_BUTTON, BS_GROUPBOX },
2067 { "ICON", CTL_STATIC, SS_ICON },
2068 { "LISTBOX", CTL_LISTBOX, (unsigned long) -1 },
2069 { "LTEXT", CTL_STATIC, SS_LEFT },
2070 { "PUSHBOX", CTL_BUTTON, BS_PUSHBOX },
2071 { "PUSHBUTTON", CTL_BUTTON, BS_PUSHBUTTON },
2072 { "RADIOBUTTON", CTL_BUTTON, BS_RADIOBUTTON },
2073 { "RTEXT", CTL_STATIC, SS_RIGHT },
2074 { "SCROLLBAR", CTL_SCROLLBAR, (unsigned long) -1 },
2075 { "STATE3", CTL_BUTTON, BS_3STATE },
2076 /* It's important that USERBUTTON come after all the other button
2077 types, so that it won't be matched too early. */
2078 { "USERBUTTON", CTL_BUTTON, (unsigned long) -1 },
2079 { NULL, 0, 0 }
2080 };
2081
2082 /* Write a dialog control. */
2083
2084 static void
2085 write_rc_dialog_control (FILE *e, const struct dialog_control *control)
2086 {
2087 const struct control_info *ci;
2088
2089 fprintf (e, " ");
2090
2091 if (control->class.named)
2092 ci = NULL;
2093 else
2094 {
2095 for (ci = control_info; ci->name != NULL; ++ci)
2096 if (ci->class == control->class.u.id
2097 && (ci->style == (unsigned long) -1
2098 || ci->style == (control->style & 0xff)))
2099 break;
2100 }
2101 if (ci == NULL)
2102 fprintf (e, "CONTROL");
2103 else if (ci->name != NULL)
2104 fprintf (e, "%s", ci->name);
2105 else
2106 fprintf (e, "CONTROL");
2107
2108 if (control->text.named || control->text.u.id != 0)
2109 {
2110 fprintf (e, " ");
2111 res_id_print (e, control->text, 1);
2112 fprintf (e, ",");
2113 }
2114
2115 fprintf (e, " %d, ", control->id);
2116
2117 if (ci == NULL)
2118 {
2119 if (control->class.named)
2120 fprintf (e, "\"");
2121 res_id_print (e, control->class, 0);
2122 if (control->class.named)
2123 fprintf (e, "\"");
2124 fprintf (e, ", 0x%lx, ", control->style);
2125 }
2126
2127 fprintf (e, "%d, %d", control->x, control->y);
2128
2129 if (control->style != SS_ICON
2130 || control->exstyle != 0
2131 || control->width != 0
2132 || control->height != 0
2133 || control->help != 0)
2134 {
2135 fprintf (e, ", %d, %d", control->width, control->height);
2136
2137 /* FIXME: We don't need to print the style if it is the default.
2138 More importantly, in certain cases we actually need to turn
2139 off parts of the forced style, by using NOT. */
2140 fprintf (e, ", 0x%lx", control->style);
2141
2142 if (control->exstyle != 0 || control->help != 0)
2143 fprintf (e, ", 0x%lx, %lu", control->exstyle, control->help);
2144 }
2145
2146 fprintf (e, "\n");
2147
2148 if (control->data != NULL)
2149 write_rc_rcdata (e, control->data, 2);
2150 }
2151
2152 /* Write out font directory data. This would normally be built from
2153 the font data. */
2154
2155 static void
2156 write_rc_fontdir (FILE *e, const struct fontdir *fontdir)
2157 {
2158 const struct fontdir *fc;
2159
2160 for (fc = fontdir; fc != NULL; fc = fc->next)
2161 {
2162 fprintf (e, "// Font index: %d\n", fc->index);
2163 write_rc_filedata (e, fc->length, fc->data);
2164 }
2165 }
2166
2167 /* Write out group icon data. This would normally be built from the
2168 icon data. */
2169
2170 static void
2171 write_rc_group_icon (FILE *e, const struct group_icon *group_icon)
2172 {
2173 const struct group_icon *gi;
2174
2175 for (gi = group_icon; gi != NULL; gi = gi->next)
2176 {
2177 fprintf (e, "// width: %d; height %d; colors: %d; planes %d; bits %d\n",
2178 gi->width, gi->height, gi->colors, gi->planes, gi->bits);
2179 fprintf (e, "// data bytes: %lu; index: %d\n",
2180 gi->bytes, gi->index);
2181 }
2182 }
2183
2184 /* Write out a menu resource. */
2185
2186 static void
2187 write_rc_menu (FILE *e, const struct menu *menu, int menuex)
2188 {
2189 if (menu->help != 0)
2190 fprintf (e, "// Help ID: %lu\n", menu->help);
2191 write_rc_menuitems (e, menu->items, menuex, 0);
2192 }
2193
2194 /* Write out menuitems. */
2195
2196 static void
2197 write_rc_menuitems (FILE *e, const struct menuitem *menuitems, int menuex,
2198 int ind)
2199 {
2200 const struct menuitem *mi;
2201
2202 indent (e, ind);
2203 fprintf (e, "BEGIN\n");
2204
2205 for (mi = menuitems; mi != NULL; mi = mi->next)
2206 {
2207 indent (e, ind + 2);
2208
2209 if (mi->popup == NULL)
2210 fprintf (e, "MENUITEM");
2211 else
2212 fprintf (e, "POPUP");
2213
2214 if (! menuex
2215 && mi->popup == NULL
2216 && mi->text == NULL
2217 && mi->type == 0
2218 && mi->id == 0)
2219 {
2220 fprintf (e, " SEPARATOR\n");
2221 continue;
2222 }
2223
2224 if (mi->text == NULL)
2225 fprintf (e, " \"\"");
2226 else
2227 {
2228 fprintf (e, " \"");
2229 unicode_print (e, mi->text, -1);
2230 fprintf (e, "\"");
2231 }
2232
2233 if (! menuex)
2234 {
2235 if (mi->popup == NULL)
2236 fprintf (e, ", %d", mi->id);
2237
2238 if ((mi->type & MENUITEM_CHECKED) != 0)
2239 fprintf (e, ", CHECKED");
2240 if ((mi->type & MENUITEM_GRAYED) != 0)
2241 fprintf (e, ", GRAYED");
2242 if ((mi->type & MENUITEM_HELP) != 0)
2243 fprintf (e, ", HELP");
2244 if ((mi->type & MENUITEM_INACTIVE) != 0)
2245 fprintf (e, ", INACTIVE");
2246 if ((mi->type & MENUITEM_MENUBARBREAK) != 0)
2247 fprintf (e, ", MENUBARBREAK");
2248 if ((mi->type & MENUITEM_MENUBREAK) != 0)
2249 fprintf (e, ", MENUBREAK");
2250 }
2251 else
2252 {
2253 if (mi->id != 0 || mi->type != 0 || mi->state != 0 || mi->help != 0)
2254 {
2255 fprintf (e, ", %d", mi->id);
2256 if (mi->type != 0 || mi->state != 0 || mi->help != 0)
2257 {
2258 fprintf (e, ", %lu", mi->type);
2259 if (mi->state != 0 || mi->help != 0)
2260 {
2261 fprintf (e, ", %lu", mi->state);
2262 if (mi->help != 0)
2263 fprintf (e, ", %lu", mi->help);
2264 }
2265 }
2266 }
2267 }
2268
2269 fprintf (e, "\n");
2270
2271 if (mi->popup != NULL)
2272 write_rc_menuitems (e, mi->popup, menuex, ind + 2);
2273 }
2274
2275 indent (e, ind);
2276 fprintf (e, "END\n");
2277 }
2278
2279 /* Write out an rcdata resource. This is also used for other types of
2280 resources that need to print arbitrary data. */
2281
2282 static void
2283 write_rc_rcdata (FILE *e, const struct rcdata_item *rcdata, int ind)
2284 {
2285 const struct rcdata_item *ri;
2286
2287 indent (e, ind);
2288 fprintf (e, "BEGIN\n");
2289
2290 for (ri = rcdata; ri != NULL; ri = ri->next)
2291 {
2292 if (ri->type == RCDATA_BUFFER && ri->u.buffer.length == 0)
2293 continue;
2294
2295 indent (e, ind + 2);
2296
2297 switch (ri->type)
2298 {
2299 default:
2300 abort ();
2301
2302 case RCDATA_WORD:
2303 fprintf (e, "%d", ri->u.word);
2304 break;
2305
2306 case RCDATA_DWORD:
2307 fprintf (e, "%luL", ri->u.dword);
2308 break;
2309
2310 case RCDATA_STRING:
2311 {
2312 const char *s;
2313 unsigned long i;
2314
2315 fprintf (e, "\"");
2316 s = ri->u.string.s;
2317 for (i = 0; i < ri->u.string.length; i++)
2318 {
2319 if (ISPRINT (*s))
2320 putc (*s, e);
2321 else
2322 fprintf (e, "\\%03o", *s);
2323 }
2324 fprintf (e, "\"");
2325 break;
2326 }
2327
2328 case RCDATA_WSTRING:
2329 fprintf (e, "L\"");
2330 unicode_print (e, ri->u.wstring.w, ri->u.wstring.length);
2331 fprintf (e, "\"");
2332 break;
2333
2334 case RCDATA_BUFFER:
2335 {
2336 unsigned long i;
2337 int first;
2338
2339 /* Assume little endian data. */
2340
2341 first = 1;
2342 for (i = 0; i + 3 < ri->u.buffer.length; i += 4)
2343 {
2344 unsigned long l;
2345 int j;
2346
2347 if (! first)
2348 indent (e, ind + 2);
2349 l = ((((((ri->u.buffer.data[i + 3] << 8)
2350 | ri->u.buffer.data[i + 2]) << 8)
2351 | ri->u.buffer.data[i + 1]) << 8)
2352 | ri->u.buffer.data[i]);
2353 fprintf (e, "%luL", l);
2354 if (i + 4 < ri->u.buffer.length || ri->next != NULL)
2355 fprintf (e, ",");
2356 for (j = 0; j < 4; ++j)
2357 if (! ISPRINT (ri->u.buffer.data[i + j])
2358 && ri->u.buffer.data[i + j] != 0)
2359 break;
2360 if (j >= 4)
2361 {
2362 fprintf (e, "\t// ");
2363 for (j = 0; j < 4; ++j)
2364 {
2365 if (! ISPRINT (ri->u.buffer.data[i + j]))
2366 fprintf (e, "\\%03o", ri->u.buffer.data[i + j]);
2367 else
2368 {
2369 if (ri->u.buffer.data[i + j] == '\\')
2370 fprintf (e, "\\");
2371 fprintf (e, "%c", ri->u.buffer.data[i + j]);
2372 }
2373 }
2374 }
2375 fprintf (e, "\n");
2376 first = 0;
2377 }
2378
2379 if (i + 1 < ri->u.buffer.length)
2380 {
2381 int s;
2382 int j;
2383
2384 if (! first)
2385 indent (e, ind + 2);
2386 s = (ri->u.buffer.data[i + 1] << 8) | ri->u.buffer.data[i];
2387 fprintf (e, "%d", s);
2388 if (i + 2 < ri->u.buffer.length || ri->next != NULL)
2389 fprintf (e, ",");
2390 for (j = 0; j < 2; ++j)
2391 if (! ISPRINT (ri->u.buffer.data[i + j])
2392 && ri->u.buffer.data[i + j] != 0)
2393 break;
2394 if (j >= 2)
2395 {
2396 fprintf (e, "\t// ");
2397 for (j = 0; j < 2; ++j)
2398 {
2399 if (! ISPRINT (ri->u.buffer.data[i + j]))
2400 fprintf (e, "\\%03o", ri->u.buffer.data[i + j]);
2401 else
2402 {
2403 if (ri->u.buffer.data[i + j] == '\\')
2404 fprintf (e, "\\");
2405 fprintf (e, "%c", ri->u.buffer.data[i + j]);
2406 }
2407 }
2408 }
2409 fprintf (e, "\n");
2410 i += 2;
2411 first = 0;
2412 }
2413
2414 if (i < ri->u.buffer.length)
2415 {
2416 if (! first)
2417 indent (e, ind + 2);
2418 if ((ri->u.buffer.data[i] & 0x7f) == ri->u.buffer.data[i]
2419 && ISPRINT (ri->u.buffer.data[i]))
2420 fprintf (e, "\"%c\"", ri->u.buffer.data[i]);
2421 else
2422 fprintf (e, "\"\\%03o\"", ri->u.buffer.data[i]);
2423 if (ri->next != NULL)
2424 fprintf (e, ",");
2425 fprintf (e, "\n");
2426 first = 0;
2427 }
2428
2429 break;
2430 }
2431 }
2432
2433 if (ri->type != RCDATA_BUFFER)
2434 {
2435 if (ri->next != NULL)
2436 fprintf (e, ",");
2437 fprintf (e, "\n");
2438 }
2439 }
2440
2441 indent (e, ind);
2442 fprintf (e, "END\n");
2443 }
2444
2445 /* Write out a stringtable resource. */
2446
2447 static void
2448 write_rc_stringtable (FILE *e, const struct res_id *name,
2449 const struct stringtable *stringtable)
2450 {
2451 unsigned long offset;
2452 int i;
2453
2454 if (name != NULL && ! name->named)
2455 offset = (name->u.id - 1) << 4;
2456 else
2457 {
2458 fprintf (e, "// %s string table name\n",
2459 name == NULL ? "Missing" : "Invalid");
2460 offset = 0;
2461 }
2462
2463 fprintf (e, "BEGIN\n");
2464
2465 for (i = 0; i < 16; i++)
2466 {
2467 if (stringtable->strings[i].length != 0)
2468 {
2469 fprintf (e, " %lu, \"", offset + i);
2470 unicode_print (e, stringtable->strings[i].string,
2471 stringtable->strings[i].length);
2472 fprintf (e, "\"\n");
2473 }
2474 }
2475
2476 fprintf (e, "END\n");
2477 }
2478
2479 /* Write out a versioninfo resource. */
2480
2481 static void
2482 write_rc_versioninfo (FILE *e, const struct versioninfo *versioninfo)
2483 {
2484 const struct fixed_versioninfo *f;
2485 const struct ver_info *vi;
2486
2487 f = versioninfo->fixed;
2488 if (f->file_version_ms != 0 || f->file_version_ls != 0)
2489 fprintf (e, " FILEVERSION %lu, %lu, %lu, %lu\n",
2490 (f->file_version_ms >> 16) & 0xffff,
2491 f->file_version_ms & 0xffff,
2492 (f->file_version_ls >> 16) & 0xffff,
2493 f->file_version_ls & 0xffff);
2494 if (f->product_version_ms != 0 || f->product_version_ls != 0)
2495 fprintf (e, " PRODUCTVERSION %lu, %lu, %lu, %lu\n",
2496 (f->product_version_ms >> 16) & 0xffff,
2497 f->product_version_ms & 0xffff,
2498 (f->product_version_ls >> 16) & 0xffff,
2499 f->product_version_ls & 0xffff);
2500 if (f->file_flags_mask != 0)
2501 fprintf (e, " FILEFLAGSMASK 0x%lx\n", f->file_flags_mask);
2502 if (f->file_flags != 0)
2503 fprintf (e, " FILEFLAGS 0x%lx\n", f->file_flags);
2504 if (f->file_os != 0)
2505 fprintf (e, " FILEOS 0x%lx\n", f->file_os);
2506 if (f->file_type != 0)
2507 fprintf (e, " FILETYPE 0x%lx\n", f->file_type);
2508 if (f->file_subtype != 0)
2509 fprintf (e, " FILESUBTYPE 0x%lx\n", f->file_subtype);
2510 if (f->file_date_ms != 0 || f->file_date_ls != 0)
2511 fprintf (e, "// Date: %lu, %lu\n", f->file_date_ms, f->file_date_ls);
2512
2513 fprintf (e, "BEGIN\n");
2514
2515 for (vi = versioninfo->var; vi != NULL; vi = vi->next)
2516 {
2517 switch (vi->type)
2518 {
2519 case VERINFO_STRING:
2520 {
2521 const struct ver_stringinfo *vs;
2522
2523 fprintf (e, " BLOCK \"StringFileInfo\"\n");
2524 fprintf (e, " BEGIN\n");
2525 fprintf (e, " BLOCK \"");
2526 unicode_print (e, vi->u.string.language, -1);
2527 fprintf (e, "\"\n");
2528 fprintf (e, " BEGIN\n");
2529
2530 for (vs = vi->u.string.strings; vs != NULL; vs = vs->next)
2531 {
2532 fprintf (e, " VALUE \"");
2533 unicode_print (e, vs->key, -1);
2534 fprintf (e, "\", \"");
2535 unicode_print (e, vs->value, -1);
2536 fprintf (e, "\"\n");
2537 }
2538
2539 fprintf (e, " END\n");
2540 fprintf (e, " END\n");
2541 break;
2542 }
2543
2544 case VERINFO_VAR:
2545 {
2546 const struct ver_varinfo *vv;
2547
2548 fprintf (e, " BLOCK \"VarFileInfo\"\n");
2549 fprintf (e, " BEGIN\n");
2550 fprintf (e, " VALUE \"");
2551 unicode_print (e, vi->u.var.key, -1);
2552 fprintf (e, "\"");
2553
2554 for (vv = vi->u.var.var; vv != NULL; vv = vv->next)
2555 fprintf (e, ", 0x%x, %d", (unsigned int) vv->language,
2556 vv->charset);
2557
2558 fprintf (e, "\n END\n");
2559
2560 break;
2561 }
2562 }
2563 }
2564
2565 fprintf (e, "END\n");
2566 }
2567
2568 /* Write out data which would normally be read from a file. */
2569
2570 static void
2571 write_rc_filedata (FILE *e, unsigned long length, const unsigned char *data)
2572 {
2573 unsigned long i;
2574
2575 for (i = 0; i + 15 < length; i += 16)
2576 {
2577 fprintf (e, "// %4lx: ", i);
2578 fprintf (e, "%02x %02x %02x %02x %02x %02x %02x %02x ",
2579 data[i + 0], data[i + 1], data[i + 2], data[i + 3],
2580 data[i + 4], data[i + 5], data[i + 6], data[i + 7]);
2581 fprintf (e, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
2582 data[i + 8], data[i + 9], data[i + 10], data[i + 11],
2583 data[i + 12], data[i + 13], data[i + 14], data[i + 15]);
2584 }
2585
2586 if (i < length)
2587 {
2588 fprintf (e, "// %4lx:", i);
2589 while (i < length)
2590 {
2591 fprintf (e, " %02x", data[i]);
2592 ++i;
2593 }
2594 fprintf (e, "\n");
2595 }
2596 }
git-cvsimport of binutils cvsroot