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