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