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