projects / deliverable / binutils-gdb.git / blob
? search:


96de59c3f1289a701d21cde13ad4c177169563f5
[deliverable/binutils-gdb.git] / binutils / resrc.c
1 /* resrc.c -- read and write Windows rc files.
2 Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4
5 This file is part of GNU Binutils.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22 /* This file contains functions that read and write Windows rc files.
23 These are text files that represent resources. */
24
25 #include "bfd.h"
26 #include "bucomm.h"
27 #include "libiberty.h"
28 #include "safe-ctype.h"
29 #include "windres.h"
30
31 #include <assert.h>
32 #include <errno.h>
33 #include <sys/stat.h>
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #ifdef HAVE_SYS_WAIT_H
39 #include <sys/wait.h>
40 #else /* ! HAVE_SYS_WAIT_H */
41 #if ! defined (_WIN32) || defined (__CYGWIN__)
42 #ifndef WIFEXITED
43 #define WIFEXITED(w) (((w)&0377) == 0)
44 #endif
45 #ifndef WIFSIGNALED
46 #define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
47 #endif
48 #ifndef WTERMSIG
49 #define WTERMSIG(w) ((w) & 0177)
50 #endif
51 #ifndef WEXITSTATUS
52 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
53 #endif
54 #else /* defined (_WIN32) && ! defined (__CYGWIN__) */
55 #ifndef WIFEXITED
56 #define WIFEXITED(w) (((w) & 0xff) == 0)
57 #endif
58 #ifndef WIFSIGNALED
59 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
60 #endif
61 #ifndef WTERMSIG
62 #define WTERMSIG(w) ((w) & 0x7f)
63 #endif
64 #ifndef WEXITSTATUS
65 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
66 #endif
67 #endif /* defined (_WIN32) && ! defined (__CYGWIN__) */
68 #endif /* ! HAVE_SYS_WAIT_H */
69
70 #ifndef STDOUT_FILENO
71 #define STDOUT_FILENO 1
72 #endif
73
74 #if defined (_WIN32) && ! defined (__CYGWIN__)
75 #define popen _popen
76 #define pclose _pclose
77 #endif
78
79 /* The default preprocessor. */
80
81 #define DEFAULT_PREPROCESSOR "gcc -E -xc -DRC_INVOKED"
82
83 /* We read the directory entries in a cursor or icon file into
84 instances of this structure. */
85
86 struct icondir
87 {
88 /* Width of image. */
89 unsigned char width;
90 /* Height of image. */
91 unsigned char height;
92 /* Number of colors in image. */
93 unsigned char colorcount;
94 union
95 {
96 struct
97 {
98 /* Color planes. */
99 unsigned short planes;
100 /* Bits per pixel. */
101 unsigned short bits;
102 } icon;
103 struct
104 {
105 /* X coordinate of hotspot. */
106 unsigned short xhotspot;
107 /* Y coordinate of hotspot. */
108 unsigned short yhotspot;
109 } cursor;
110 } u;
111 /* Bytes in image. */
112 unsigned long bytes;
113 /* File offset of image. */
114 unsigned long offset;
115 };
116
117 /* The name of the rc file we are reading. */
118
119 char *rc_filename;
120
121 /* The line number in the rc file. */
122
123 int rc_lineno;
124
125 /* The pipe we are reading from, so that we can close it if we exit. */
126
127 static FILE *cpp_pipe;
128
129 /* The temporary file used if we're not using popen, so we can delete it
130 if we exit. */
131
132 static char *cpp_temp_file;
133
134 /* Input stream is either a file or a pipe. */
135
136 static enum {ISTREAM_PIPE, ISTREAM_FILE} istream_type;
137
138 /* As we read the rc file, we attach information to this structure. */
139
140 static struct res_directory *resources;
141
142 /* The number of cursor resources we have written out. */
143
144 static int cursors;
145
146 /* The number of font resources we have written out. */
147
148 static int fonts;
149
150 /* Font directory information. */
151
152 struct fontdir *fontdirs;
153
154 /* Resource info to use for fontdirs. */
155
156 struct res_res_info fontdirs_resinfo;
157
158 /* The number of icon resources we have written out. */
159
160 static int icons;
161
162 /* Local functions. */
163
164 static int run_cmd PARAMS ((char *, const char *));
165 static FILE *open_input_stream PARAMS ((char *));
166 static FILE *look_for_default PARAMS ((char *, const char *, int,
167 const char *, const char *));
168 static void close_input_stream PARAMS ((void));
169 static void unexpected_eof PARAMS ((const char *));
170 static int get_word PARAMS ((FILE *, const char *));
171 static unsigned long get_long PARAMS ((FILE *, const char *));
172 static void get_data
173 PARAMS ((FILE *, unsigned char *, unsigned long, const char *));
174 static void define_fontdirs PARAMS ((void));
175 \f
176 /* Run `cmd' and redirect the output to `redir'. */
177
178 static int
179 run_cmd (cmd, redir)
180 char *cmd;
181 const char *redir;
182 {
183 char *s;
184 int pid, wait_status, retcode;
185 int i;
186 const char **argv;
187 char *errmsg_fmt, *errmsg_arg;
188 char *temp_base = choose_temp_base ();
189 int in_quote;
190 char sep;
191 int redir_handle = -1;
192 int stdout_save = -1;
193
194 /* Count the args. */
195 i = 0;
196
197 for (s = cmd; *s; s++)
198 if (*s == ' ')
199 i++;
200
201 i++;
202 argv = alloca (sizeof (char *) * (i + 3));
203 i = 0;
204 s = cmd;
205
206 while (1)
207 {
208 while (*s == ' ' && *s != 0)
209 s++;
210
211 if (*s == 0)
212 break;
213
214 in_quote = (*s == '\'' || *s == '"');
215 sep = (in_quote) ? *s++ : ' ';
216 argv[i++] = s;
217
218 while (*s != sep && *s != 0)
219 s++;
220
221 if (*s == 0)
222 break;
223
224 *s++ = 0;
225
226 if (in_quote)
227 s++;
228 }
229 argv[i++] = NULL;
230
231 /* Setup the redirection. We can't use the usual fork/exec and redirect
232 since we may be running on non-POSIX Windows host. */
233
234 fflush (stdout);
235 fflush (stderr);
236
237 /* Open temporary output file. */
238 redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT, 0666);
239 if (redir_handle == -1)
240 fatal (_("can't open temporary file `%s': %s"), redir,
241 strerror (errno));
242
243 /* Duplicate the stdout file handle so it can be restored later. */
244 stdout_save = dup (STDOUT_FILENO);
245 if (stdout_save == -1)
246 fatal (_("can't redirect stdout: `%s': %s"), redir, strerror (errno));
247
248 /* Redirect stdout to our output file. */
249 dup2 (redir_handle, STDOUT_FILENO);
250
251 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
252 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
253
254 /* Restore stdout to its previous setting. */
255 dup2 (stdout_save, STDOUT_FILENO);
256
257 /* Close reponse file. */
258 close (redir_handle);
259
260 if (pid == -1)
261 {
262 fatal (_("%s %s: %s"), errmsg_fmt, errmsg_arg, strerror (errno));
263 return 1;
264 }
265
266 retcode = 0;
267 pid = pwait (pid, &wait_status, 0);
268
269 if (pid == -1)
270 {
271 fatal (_("wait: %s"), strerror (errno));
272 retcode = 1;
273 }
274 else if (WIFSIGNALED (wait_status))
275 {
276 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
277 retcode = 1;
278 }
279 else if (WIFEXITED (wait_status))
280 {
281 if (WEXITSTATUS (wait_status) != 0)
282 {
283 fatal (_("%s exited with status %d"), cmd,
284 WEXITSTATUS (wait_status));
285 retcode = 1;
286 }
287 }
288 else
289 retcode = 1;
290
291 return retcode;
292 }
293
294 static FILE *
295 open_input_stream (cmd)
296 char *cmd;
297 {
298 if (istream_type == ISTREAM_FILE)
299 {
300 char *fileprefix;
301
302 fileprefix = choose_temp_base ();
303 cpp_temp_file = (char *) xmalloc (strlen (fileprefix) + 5);
304 sprintf (cpp_temp_file, "%s.irc", fileprefix);
305 free (fileprefix);
306
307 if (run_cmd (cmd, cpp_temp_file))
308 fatal (_("can't execute `%s': %s"), cmd, strerror (errno));
309
310 cpp_pipe = fopen (cpp_temp_file, FOPEN_RT);;
311 if (cpp_pipe == NULL)
312 fatal (_("can't open temporary file `%s': %s"),
313 cpp_temp_file, strerror (errno));
314
315 if (verbose)
316 fprintf (stderr,
317 _("Using temporary file `%s' to read preprocessor output\n"),
318 cpp_temp_file);
319 }
320 else
321 {
322 cpp_pipe = popen (cmd, FOPEN_RT);
323 if (cpp_pipe == NULL)
324 fatal (_("can't popen `%s': %s"), cmd, strerror (errno));
325 if (verbose)
326 fprintf (stderr, _("Using popen to read preprocessor output\n"));
327 }
328
329 xatexit (close_input_stream);
330 return cpp_pipe;
331 }
332
333 /* look for the preprocessor program */
334
335 static FILE *
336 look_for_default (cmd, prefix, end_prefix, preprocargs, filename)
337 char *cmd;
338 const char *prefix;
339 int end_prefix;
340 const char *preprocargs;
341 const char *filename;
342 {
343 char *space;
344 int found;
345 struct stat s;
346
347 strcpy (cmd, prefix);
348
349 sprintf (cmd + end_prefix, "%s", DEFAULT_PREPROCESSOR);
350 space = strchr (cmd + end_prefix, ' ');
351 if (space)
352 *space = 0;
353
354 if (
355 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32)
356 strchr (cmd, '\\') ||
357 #endif
358 strchr (cmd, '/'))
359 {
360 found = (stat (cmd, &s) == 0
361 #ifdef HAVE_EXECUTABLE_SUFFIX
362 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
363 #endif
364 );
365
366 if (! found)
367 {
368 if (verbose)
369 fprintf (stderr, _("Tried `%s'\n"), cmd);
370 return NULL;
371 }
372 }
373
374 strcpy (cmd, prefix);
375
376 sprintf (cmd + end_prefix, "%s %s %s",
377 DEFAULT_PREPROCESSOR, preprocargs, filename);
378
379 if (verbose)
380 fprintf (stderr, _("Using `%s'\n"), cmd);
381
382 cpp_pipe = open_input_stream (cmd);
383 return cpp_pipe;
384 }
385
386 /* Read an rc file. */
387
388 struct res_directory *
389 read_rc_file (filename, preprocessor, preprocargs, language, use_temp_file)
390 const char *filename;
391 const char *preprocessor;
392 const char *preprocargs;
393 int language;
394 int use_temp_file;
395 {
396 char *cmd;
397
398 istream_type = (use_temp_file) ? ISTREAM_FILE : ISTREAM_PIPE;
399
400 if (preprocargs == NULL)
401 preprocargs = "";
402 if (filename == NULL)
403 filename = "-";
404
405 if (preprocessor)
406 {
407 cmd = xmalloc (strlen (preprocessor)
408 + strlen (preprocargs)
409 + strlen (filename)
410 + 10);
411 sprintf (cmd, "%s %s %s", preprocessor, preprocargs, filename);
412
413 cpp_pipe = open_input_stream (cmd);
414 }
415 else
416 {
417 char *dash, *slash, *cp;
418
419 preprocessor = DEFAULT_PREPROCESSOR;
420
421 cmd = xmalloc (strlen (program_name)
422 + strlen (preprocessor)
423 + strlen (preprocargs)
424 + strlen (filename)
425 #ifdef HAVE_EXECUTABLE_SUFFIX
426 + strlen (EXECUTABLE_SUFFIX)
427 #endif
428 + 10);
429
430
431 dash = slash = 0;
432 for (cp = program_name; *cp; cp++)
433 {
434 if (*cp == '-')
435 dash = cp;
436 if (
437 #if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32)
438 *cp == ':' || *cp == '\\' ||
439 #endif
440 *cp == '/')
441 {
442 slash = cp;
443 dash = 0;
444 }
445 }
446
447 cpp_pipe = 0;
448
449 if (dash)
450 {
451 /* First, try looking for a prefixed gcc in the windres
452 directory, with the same prefix as windres */
453
454 cpp_pipe = look_for_default (cmd, program_name, dash-program_name+1,
455 preprocargs, filename);
456 }
457
458 if (slash && !cpp_pipe)
459 {
460 /* Next, try looking for a gcc in the same directory as
461 that windres */
462
463 cpp_pipe = look_for_default (cmd, program_name, slash-program_name+1,
464 preprocargs, filename);
465 }
466
467 if (!cpp_pipe)
468 {
469 /* Sigh, try the default */
470
471 cpp_pipe = look_for_default (cmd, "", 0, preprocargs, filename);
472 }
473
474 }
475
476 free (cmd);
477
478 rc_filename = xstrdup (filename);
479 rc_lineno = 1;
480 if (language != -1)
481 rcparse_set_language (language);
482 yyin = cpp_pipe;
483 yyparse ();
484
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 & ((1 << SUBLANG_SHIFT) - 1),
1596 (re->id.u.id >> SUBLANG_SHIFT) & 0xff);
1597 *language = re->id.u.id;
1598 }
1599 break;
1600
1601 default:
1602 break;
1603 }
1604
1605 if (re->subdir)
1606 write_rc_subdir (e, re, type, name, language, level);
1607 else
1608 {
1609 if (level == 3)
1610 {
1611 /* This is the normal case: the three levels are
1612 TYPE/NAME/LANGUAGE. NAME will have been set at level
1613 2, and represents the name to use. We probably just
1614 set LANGUAGE, and it will probably match what the
1615 resource itself records if anything. */
1616 write_rc_resource (e, type, name, re->u.res, language);
1617 }
1618 else
1619 {
1620 fprintf (e, "// Resource at unexpected level %d\n", level);
1621 write_rc_resource (e, type, (struct res_id *) NULL, re->u.res,
1622 language);
1623 }
1624 }
1625 }
1626 }
1627
1628 /* Write out a subdirectory entry. E is the file to write to. RE is
1629 the subdirectory entry. TYPE and NAME are pointers to higher level
1630 IDs, or NULL. LANGUAGE is a pointer to the current language.
1631 LEVEL is the level in the tree. */
1632
1633 static void
1634 write_rc_subdir (e, re, type, name, language, level)
1635 FILE *e;
1636 const struct res_entry *re;
1637 const struct res_id *type;
1638 const struct res_id *name;
1639 int *language;
1640 int level;
1641 {
1642 fprintf (e, "\n");
1643 switch (level)
1644 {
1645 case 1:
1646 fprintf (e, "// Type: ");
1647 if (re->id.named)
1648 res_id_print (e, re->id, 1);
1649 else
1650 {
1651 const char *s;
1652
1653 switch (re->id.u.id)
1654 {
1655 case RT_CURSOR: s = "cursor"; break;
1656 case RT_BITMAP: s = "bitmap"; break;
1657 case RT_ICON: s = "icon"; break;
1658 case RT_MENU: s = "menu"; break;
1659 case RT_DIALOG: s = "dialog"; break;
1660 case RT_STRING: s = "stringtable"; break;
1661 case RT_FONTDIR: s = "fontdir"; break;
1662 case RT_FONT: s = "font"; break;
1663 case RT_ACCELERATOR: s = "accelerators"; break;
1664 case RT_RCDATA: s = "rcdata"; break;
1665 case RT_MESSAGETABLE: s = "messagetable"; break;
1666 case RT_GROUP_CURSOR: s = "group cursor"; break;
1667 case RT_GROUP_ICON: s = "group icon"; break;
1668 case RT_VERSION: s = "version"; break;
1669 case RT_DLGINCLUDE: s = "dlginclude"; break;
1670 case RT_PLUGPLAY: s = "plugplay"; break;
1671 case RT_VXD: s = "vxd"; break;
1672 case RT_ANICURSOR: s = "anicursor"; break;
1673 case RT_ANIICON: s = "aniicon"; break;
1674 default: s = NULL; break;
1675 }
1676
1677 if (s != NULL)
1678 fprintf (e, "%s", s);
1679 else
1680 res_id_print (e, re->id, 1);
1681 }
1682 fprintf (e, "\n");
1683 break;
1684
1685 case 2:
1686 fprintf (e, "// Name: ");
1687 res_id_print (e, re->id, 1);
1688 fprintf (e, "\n");
1689 break;
1690
1691 case 3:
1692 fprintf (e, "// Language: ");
1693 res_id_print (e, re->id, 1);
1694 fprintf (e, "\n");
1695 break;
1696
1697 default:
1698 fprintf (e, "// Level %d: ", level);
1699 res_id_print (e, re->id, 1);
1700 fprintf (e, "\n");
1701 }
1702
1703 write_rc_directory (e, re->u.dir, type, name, language, level + 1);
1704 }
1705
1706 /* Write out a single resource. E is the file to write to. TYPE is a
1707 pointer to the type of the resource. NAME is a pointer to the name
1708 of the resource; it will be NULL if there is a level mismatch. RES
1709 is the resource data. LANGUAGE is a pointer to the current
1710 language. */
1711
1712 static void
1713 write_rc_resource (e, type, name, res, language)
1714 FILE *e;
1715 const struct res_id *type;
1716 const struct res_id *name;
1717 const struct res_resource *res;
1718 int *language;
1719 {
1720 const char *s;
1721 int rt;
1722 int menuex = 0;
1723
1724 fprintf (e, "\n");
1725
1726 switch (res->type)
1727 {
1728 default:
1729 abort ();
1730
1731 case RES_TYPE_ACCELERATOR:
1732 s = "ACCELERATOR";
1733 rt = RT_ACCELERATOR;
1734 break;
1735
1736 case RES_TYPE_BITMAP:
1737 s = "BITMAP";
1738 rt = RT_BITMAP;
1739 break;
1740
1741 case RES_TYPE_CURSOR:
1742 s = "CURSOR";
1743 rt = RT_CURSOR;
1744 break;
1745
1746 case RES_TYPE_GROUP_CURSOR:
1747 s = "GROUP_CURSOR";
1748 rt = RT_GROUP_CURSOR;
1749 break;
1750
1751 case RES_TYPE_DIALOG:
1752 if (extended_dialog (res->u.dialog))
1753 s = "DIALOGEX";
1754 else
1755 s = "DIALOG";
1756 rt = RT_DIALOG;
1757 break;
1758
1759 case RES_TYPE_FONT:
1760 s = "FONT";
1761 rt = RT_FONT;
1762 break;
1763
1764 case RES_TYPE_FONTDIR:
1765 s = "FONTDIR";
1766 rt = RT_FONTDIR;
1767 break;
1768
1769 case RES_TYPE_ICON:
1770 s = "ICON";
1771 rt = RT_ICON;
1772 break;
1773
1774 case RES_TYPE_GROUP_ICON:
1775 s = "GROUP_ICON";
1776 rt = RT_GROUP_ICON;
1777 break;
1778
1779 case RES_TYPE_MENU:
1780 if (extended_menu (res->u.menu))
1781 {
1782 s = "MENUEX";
1783 menuex = 1;
1784 }
1785 else
1786 {
1787 s = "MENU";
1788 menuex = 0;
1789 }
1790 rt = RT_MENU;
1791 break;
1792
1793 case RES_TYPE_MESSAGETABLE:
1794 s = "MESSAGETABLE";
1795 rt = RT_MESSAGETABLE;
1796 break;
1797
1798 case RES_TYPE_RCDATA:
1799 s = "RCDATA";
1800 rt = RT_RCDATA;
1801 break;
1802
1803 case RES_TYPE_STRINGTABLE:
1804 s = "STRINGTABLE";
1805 rt = RT_STRING;
1806 break;
1807
1808 case RES_TYPE_USERDATA:
1809 s = NULL;
1810 rt = 0;
1811 break;
1812
1813 case RES_TYPE_VERSIONINFO:
1814 s = "VERSIONINFO";
1815 rt = RT_VERSION;
1816 break;
1817 }
1818
1819 if (rt != 0
1820 && type != NULL
1821 && (type->named || type->u.id != (unsigned long) rt))
1822 {
1823 fprintf (e, "// Unexpected resource type mismatch: ");
1824 res_id_print (e, *type, 1);
1825 fprintf (e, " != %d", rt);
1826 }
1827
1828 if (res->coff_info.codepage != 0)
1829 fprintf (e, "// Code page: %lu\n", res->coff_info.codepage);
1830 if (res->coff_info.reserved != 0)
1831 fprintf (e, "// COFF reserved value: %lu\n", res->coff_info.reserved);
1832
1833 if (name != NULL)
1834 res_id_print (e, *name, 0);
1835 else
1836 fprintf (e, "??Unknown-Name??");
1837
1838 fprintf (e, " ");
1839 if (s != NULL)
1840 fprintf (e, "%s", s);
1841 else if (type != NULL)
1842 res_id_print (e, *type, 0);
1843 else
1844 fprintf (e, "??Unknown-Type??");
1845
1846 if (res->res_info.memflags != 0)
1847 {
1848 if ((res->res_info.memflags & MEMFLAG_MOVEABLE) != 0)
1849 fprintf (e, " MOVEABLE");
1850 if ((res->res_info.memflags & MEMFLAG_PURE) != 0)
1851 fprintf (e, " PURE");
1852 if ((res->res_info.memflags & MEMFLAG_PRELOAD) != 0)
1853 fprintf (e, " PRELOAD");
1854 if ((res->res_info.memflags & MEMFLAG_DISCARDABLE) != 0)
1855 fprintf (e, " DISCARDABLE");
1856 }
1857
1858 if (res->type == RES_TYPE_DIALOG)
1859 {
1860 fprintf (e, " %d, %d, %d, %d", res->u.dialog->x, res->u.dialog->y,
1861 res->u.dialog->width, res->u.dialog->height);
1862 if (res->u.dialog->ex != NULL
1863 && res->u.dialog->ex->help != 0)
1864 fprintf (e, ", %lu", res->u.dialog->ex->help);
1865 }
1866
1867 fprintf (e, "\n");
1868
1869 if ((res->res_info.language != 0 && res->res_info.language != *language)
1870 || res->res_info.characteristics != 0
1871 || res->res_info.version != 0)
1872 {
1873 int modifiers;
1874
1875 switch (res->type)
1876 {
1877 case RES_TYPE_ACCELERATOR:
1878 case RES_TYPE_DIALOG:
1879 case RES_TYPE_MENU:
1880 case RES_TYPE_RCDATA:
1881 case RES_TYPE_STRINGTABLE:
1882 modifiers = 1;
1883 break;
1884
1885 default:
1886 modifiers = 0;
1887 break;
1888 }
1889
1890 if (res->res_info.language != 0 && res->res_info.language != *language)
1891 fprintf (e, "%sLANGUAGE %d, %d\n",
1892 modifiers ? "// " : "",
1893 res->res_info.language & ((1<<SUBLANG_SHIFT)-1),
1894 (res->res_info.language >> SUBLANG_SHIFT) & 0xff);
1895 if (res->res_info.characteristics != 0)
1896 fprintf (e, "%sCHARACTERISTICS %lu\n",
1897 modifiers ? "// " : "",
1898 res->res_info.characteristics);
1899 if (res->res_info.version != 0)
1900 fprintf (e, "%sVERSION %lu\n",
1901 modifiers ? "// " : "",
1902 res->res_info.version);
1903 }
1904
1905 switch (res->type)
1906 {
1907 default:
1908 abort ();
1909
1910 case RES_TYPE_ACCELERATOR:
1911 write_rc_accelerators (e, res->u.acc);
1912 break;
1913
1914 case RES_TYPE_CURSOR:
1915 write_rc_cursor (e, res->u.cursor);
1916 break;
1917
1918 case RES_TYPE_GROUP_CURSOR:
1919 write_rc_group_cursor (e, res->u.group_cursor);
1920 break;
1921
1922 case RES_TYPE_DIALOG:
1923 write_rc_dialog (e, res->u.dialog);
1924 break;
1925
1926 case RES_TYPE_FONTDIR:
1927 write_rc_fontdir (e, res->u.fontdir);
1928 break;
1929
1930 case RES_TYPE_GROUP_ICON:
1931 write_rc_group_icon (e, res->u.group_icon);
1932 break;
1933
1934 case RES_TYPE_MENU:
1935 write_rc_menu (e, res->u.menu, menuex);
1936 break;
1937
1938 case RES_TYPE_RCDATA:
1939 write_rc_rcdata (e, res->u.rcdata, 0);
1940 break;
1941
1942 case RES_TYPE_STRINGTABLE:
1943 write_rc_stringtable (e, name, res->u.stringtable);
1944 break;
1945
1946 case RES_TYPE_USERDATA:
1947 write_rc_rcdata (e, res->u.userdata, 0);
1948 break;
1949
1950 case RES_TYPE_VERSIONINFO:
1951 write_rc_versioninfo (e, res->u.versioninfo);
1952 break;
1953
1954 case RES_TYPE_BITMAP:
1955 case RES_TYPE_FONT:
1956 case RES_TYPE_ICON:
1957 case RES_TYPE_MESSAGETABLE:
1958 write_rc_filedata (e, res->u.data.length, res->u.data.data);
1959 break;
1960 }
1961 }
1962
1963 /* Write out accelerator information. */
1964
1965 static void
1966 write_rc_accelerators (e, accelerators)
1967 FILE *e;
1968 const struct accelerator *accelerators;
1969 {
1970 const struct accelerator *acc;
1971
1972 fprintf (e, "BEGIN\n");
1973 for (acc = accelerators; acc != NULL; acc = acc->next)
1974 {
1975 int printable;
1976
1977 fprintf (e, " ");
1978
1979 if ((acc->key & 0x7f) == acc->key
1980 && ISPRINT (acc->key)
1981 && (acc->flags & ACC_VIRTKEY) == 0)
1982 {
1983 fprintf (e, "\"%c\"", acc->key);
1984 printable = 1;
1985 }
1986 else
1987 {
1988 fprintf (e, "%d", acc->key);
1989 printable = 0;
1990 }
1991
1992 fprintf (e, ", %d", acc->id);
1993
1994 if (! printable)
1995 {
1996 if ((acc->flags & ACC_VIRTKEY) != 0)
1997 fprintf (e, ", VIRTKEY");
1998 else
1999 fprintf (e, ", ASCII");
2000 }
2001
2002 if ((acc->flags & ACC_SHIFT) != 0)
2003 fprintf (e, ", SHIFT");
2004 if ((acc->flags & ACC_CONTROL) != 0)
2005 fprintf (e, ", CONTROL");
2006 if ((acc->flags & ACC_ALT) != 0)
2007 fprintf (e, ", ALT");
2008
2009 fprintf (e, "\n");
2010 }
2011
2012 fprintf (e, "END\n");
2013 }
2014
2015 /* Write out cursor information. This would normally be in a separate
2016 file, which the rc file would include. */
2017
2018 static void
2019 write_rc_cursor (e, cursor)
2020 FILE *e;
2021 const struct cursor *cursor;
2022 {
2023 fprintf (e, "// Hotspot: x: %d; y: %d\n", cursor->xhotspot,
2024 cursor->yhotspot);
2025 write_rc_filedata (e, cursor->length, cursor->data);
2026 }
2027
2028 /* Write out group cursor data. This would normally be built from the
2029 cursor data. */
2030
2031 static void
2032 write_rc_group_cursor (e, group_cursor)
2033 FILE *e;
2034 const struct group_cursor *group_cursor;
2035 {
2036 const struct group_cursor *gc;
2037
2038 for (gc = group_cursor; gc != NULL; gc = gc->next)
2039 {
2040 fprintf (e, "// width: %d; height %d; planes %d; bits %d\n",
2041 gc->width, gc->height, gc->planes, gc->bits);
2042 fprintf (e, "// data bytes: %lu; index: %d\n",
2043 gc->bytes, gc->index);
2044 }
2045 }
2046
2047 /* Write dialog data. */
2048
2049 static void
2050 write_rc_dialog (e, dialog)
2051 FILE *e;
2052 const struct dialog *dialog;
2053 {
2054 const struct dialog_control *control;
2055
2056 fprintf (e, "STYLE 0x%lx\n", dialog->style);
2057
2058 if (dialog->exstyle != 0)
2059 fprintf (e, "EXSTYLE 0x%lx\n", dialog->exstyle);
2060
2061 if ((dialog->class.named && dialog->class.u.n.length > 0)
2062 || dialog->class.u.id != 0)
2063 {
2064 fprintf (e, "CLASS ");
2065 res_id_print (e, dialog->class, 1);
2066 fprintf (e, "\n");
2067 }
2068
2069 if (dialog->caption != NULL)
2070 {
2071 fprintf (e, "CAPTION \"");
2072 unicode_print (e, dialog->caption, -1);
2073 fprintf (e, "\"\n");
2074 }
2075
2076 if ((dialog->menu.named && dialog->menu.u.n.length > 0)
2077 || dialog->menu.u.id != 0)
2078 {
2079 fprintf (e, "MENU ");
2080 res_id_print (e, dialog->menu, 0);
2081 fprintf (e, "\n");
2082 }
2083
2084 if (dialog->font != NULL)
2085 {
2086 fprintf (e, "FONT %d, \"", dialog->pointsize);
2087 unicode_print (e, dialog->font, -1);
2088 fprintf (e, "\"");
2089 if (dialog->ex != NULL
2090 && (dialog->ex->weight != 0
2091 || dialog->ex->italic != 0
2092 || dialog->ex->charset != 1))
2093 fprintf (e, ", %d, %d, %d",
2094 dialog->ex->weight, dialog->ex->italic, dialog->ex->charset);
2095 fprintf (e, "\n");
2096 }
2097
2098 fprintf (e, "BEGIN\n");
2099
2100 for (control = dialog->controls; control != NULL; control = control->next)
2101 write_rc_dialog_control (e, control);
2102
2103 fprintf (e, "END\n");
2104 }
2105
2106 /* For each predefined control keyword, this table provides the class
2107 and the style. */
2108
2109 struct control_info
2110 {
2111 const char *name;
2112 unsigned short class;
2113 unsigned long style;
2114 };
2115
2116 static const struct control_info control_info[] =
2117 {
2118 { "AUTO3STATE", CTL_BUTTON, BS_AUTO3STATE },
2119 { "AUTOCHECKBOX", CTL_BUTTON, BS_AUTOCHECKBOX },
2120 { "AUTORADIOBUTTON", CTL_BUTTON, BS_AUTORADIOBUTTON },
2121 { "CHECKBOX", CTL_BUTTON, BS_CHECKBOX },
2122 { "COMBOBOX", CTL_COMBOBOX, (unsigned long) -1 },
2123 { "CTEXT", CTL_STATIC, SS_CENTER },
2124 { "DEFPUSHBUTTON", CTL_BUTTON, BS_DEFPUSHBUTTON },
2125 { "EDITTEXT", CTL_EDIT, (unsigned long) -1 },
2126 { "GROUPBOX", CTL_BUTTON, BS_GROUPBOX },
2127 { "ICON", CTL_STATIC, SS_ICON },
2128 { "LISTBOX", CTL_LISTBOX, (unsigned long) -1 },
2129 { "LTEXT", CTL_STATIC, SS_LEFT },
2130 { "PUSHBOX", CTL_BUTTON, BS_PUSHBOX },
2131 { "PUSHBUTTON", CTL_BUTTON, BS_PUSHBUTTON },
2132 { "RADIOBUTTON", CTL_BUTTON, BS_RADIOBUTTON },
2133 { "RTEXT", CTL_STATIC, SS_RIGHT },
2134 { "SCROLLBAR", CTL_SCROLLBAR, (unsigned long) -1 },
2135 { "STATE3", CTL_BUTTON, BS_3STATE },
2136 /* It's important that USERBUTTON come after all the other button
2137 types, so that it won't be matched too early. */
2138 { "USERBUTTON", CTL_BUTTON, (unsigned long) -1 },
2139 { NULL, 0, 0 }
2140 };
2141
2142 /* Write a dialog control. */
2143
2144 static void
2145 write_rc_dialog_control (e, control)
2146 FILE *e;
2147 const struct dialog_control *control;
2148 {
2149 const struct control_info *ci;
2150
2151 fprintf (e, " ");
2152
2153 if (control->class.named)
2154 ci = NULL;
2155 else
2156 {
2157 for (ci = control_info; ci->name != NULL; ++ci)
2158 if (ci->class == control->class.u.id
2159 && (ci->style == (unsigned long) -1
2160 || ci->style == (control->style & 0xff)))
2161 break;
2162 }
2163 if (ci == NULL)
2164 fprintf (e, "CONTROL");
2165 else if (ci->name != NULL)
2166 fprintf (e, "%s", ci->name);
2167 else
2168 fprintf (e, "CONTROL");
2169
2170 if (control->text.named || control->text.u.id != 0)
2171 {
2172 fprintf (e, " ");
2173 res_id_print (e, control->text, 1);
2174 fprintf (e, ",");
2175 }
2176
2177 fprintf (e, " %d, ", control->id);
2178
2179 if (ci == NULL)
2180 {
2181 if (control->class.named)
2182 fprintf (e, "\"");
2183 res_id_print (e, control->class, 0);
2184 if (control->class.named)
2185 fprintf (e, "\"");
2186 fprintf (e, ", 0x%lx, ", control->style);
2187 }
2188
2189 fprintf (e, "%d, %d", control->x, control->y);
2190
2191 if (control->style != SS_ICON
2192 || control->exstyle != 0
2193 || control->width != 0
2194 || control->height != 0
2195 || control->help != 0)
2196 {
2197 fprintf (e, ", %d, %d", control->width, control->height);
2198
2199 /* FIXME: We don't need to print the style if it is the default.
2200 More importantly, in certain cases we actually need to turn
2201 off parts of the forced style, by using NOT. */
2202 fprintf (e, ", 0x%lx", control->style);
2203
2204 if (control->exstyle != 0 || control->help != 0)
2205 fprintf (e, ", 0x%lx, %lu", control->exstyle, control->help);
2206 }
2207
2208 fprintf (e, "\n");
2209
2210 if (control->data != NULL)
2211 write_rc_rcdata (e, control->data, 2);
2212 }
2213
2214 /* Write out font directory data. This would normally be built from
2215 the font data. */
2216
2217 static void
2218 write_rc_fontdir (e, fontdir)
2219 FILE *e;
2220 const struct fontdir *fontdir;
2221 {
2222 const struct fontdir *fc;
2223
2224 for (fc = fontdir; fc != NULL; fc = fc->next)
2225 {
2226 fprintf (e, "// Font index: %d\n", fc->index);
2227 write_rc_filedata (e, fc->length, fc->data);
2228 }
2229 }
2230
2231 /* Write out group icon data. This would normally be built from the
2232 icon data. */
2233
2234 static void
2235 write_rc_group_icon (e, group_icon)
2236 FILE *e;
2237 const struct group_icon *group_icon;
2238 {
2239 const struct group_icon *gi;
2240
2241 for (gi = group_icon; gi != NULL; gi = gi->next)
2242 {
2243 fprintf (e, "// width: %d; height %d; colors: %d; planes %d; bits %d\n",
2244 gi->width, gi->height, gi->colors, gi->planes, gi->bits);
2245 fprintf (e, "// data bytes: %lu; index: %d\n",
2246 gi->bytes, gi->index);
2247 }
2248 }
2249
2250 /* Write out a menu resource. */
2251
2252 static void
2253 write_rc_menu (e, menu, menuex)
2254 FILE *e;
2255 const struct menu *menu;
2256 int menuex;
2257 {
2258 if (menu->help != 0)
2259 fprintf (e, "// Help ID: %lu\n", menu->help);
2260 write_rc_menuitems (e, menu->items, menuex, 0);
2261 }
2262
2263 /* Write out menuitems. */
2264
2265 static void
2266 write_rc_menuitems (e, menuitems, menuex, ind)
2267 FILE *e;
2268 const struct menuitem *menuitems;
2269 int menuex;
2270 int ind;
2271 {
2272 const struct menuitem *mi;
2273
2274 indent (e, ind);
2275 fprintf (e, "BEGIN\n");
2276
2277 for (mi = menuitems; mi != NULL; mi = mi->next)
2278 {
2279 indent (e, ind + 2);
2280
2281 if (mi->popup == NULL)
2282 fprintf (e, "MENUITEM");
2283 else
2284 fprintf (e, "POPUP");
2285
2286 if (! menuex
2287 && mi->popup == NULL
2288 && mi->text == NULL
2289 && mi->type == 0
2290 && mi->id == 0)
2291 {
2292 fprintf (e, " SEPARATOR\n");
2293 continue;
2294 }
2295
2296 if (mi->text == NULL)
2297 fprintf (e, " \"\"");
2298 else
2299 {
2300 fprintf (e, " \"");
2301 unicode_print (e, mi->text, -1);
2302 fprintf (e, "\"");
2303 }
2304
2305 if (! menuex)
2306 {
2307 if (mi->popup == NULL)
2308 fprintf (e, ", %d", mi->id);
2309
2310 if ((mi->type & MENUITEM_CHECKED) != 0)
2311 fprintf (e, ", CHECKED");
2312 if ((mi->type & MENUITEM_GRAYED) != 0)
2313 fprintf (e, ", GRAYED");
2314 if ((mi->type & MENUITEM_HELP) != 0)
2315 fprintf (e, ", HELP");
2316 if ((mi->type & MENUITEM_INACTIVE) != 0)
2317 fprintf (e, ", INACTIVE");
2318 if ((mi->type & MENUITEM_MENUBARBREAK) != 0)
2319 fprintf (e, ", MENUBARBREAK");
2320 if ((mi->type & MENUITEM_MENUBREAK) != 0)
2321 fprintf (e, ", MENUBREAK");
2322 }
2323 else
2324 {
2325 if (mi->id != 0 || mi->type != 0 || mi->state != 0 || mi->help != 0)
2326 {
2327 fprintf (e, ", %d", mi->id);
2328 if (mi->type != 0 || mi->state != 0 || mi->help != 0)
2329 {
2330 fprintf (e, ", %lu", mi->type);
2331 if (mi->state != 0 || mi->help != 0)
2332 {
2333 fprintf (e, ", %lu", mi->state);
2334 if (mi->help != 0)
2335 fprintf (e, ", %lu", mi->help);
2336 }
2337 }
2338 }
2339 }
2340
2341 fprintf (e, "\n");
2342
2343 if (mi->popup != NULL)
2344 write_rc_menuitems (e, mi->popup, menuex, ind + 2);
2345 }
2346
2347 indent (e, ind);
2348 fprintf (e, "END\n");
2349 }
2350
2351 /* Write out an rcdata resource. This is also used for other types of
2352 resources that need to print arbitrary data. */
2353
2354 static void
2355 write_rc_rcdata (e, rcdata, ind)
2356 FILE *e;
2357 const struct rcdata_item *rcdata;
2358 int ind;
2359 {
2360 const struct rcdata_item *ri;
2361
2362 indent (e, ind);
2363 fprintf (e, "BEGIN\n");
2364
2365 for (ri = rcdata; ri != NULL; ri = ri->next)
2366 {
2367 if (ri->type == RCDATA_BUFFER && ri->u.buffer.length == 0)
2368 continue;
2369
2370 indent (e, ind + 2);
2371
2372 switch (ri->type)
2373 {
2374 default:
2375 abort ();
2376
2377 case RCDATA_WORD:
2378 fprintf (e, "%d", ri->u.word);
2379 break;
2380
2381 case RCDATA_DWORD:
2382 fprintf (e, "%luL", ri->u.dword);
2383 break;
2384
2385 case RCDATA_STRING:
2386 {
2387 const char *s;
2388 unsigned long i;
2389
2390 fprintf (e, "\"");
2391 s = ri->u.string.s;
2392 for (i = 0; i < ri->u.string.length; i++)
2393 {
2394 if (ISPRINT (*s))
2395 putc (*s, e);
2396 else
2397 fprintf (e, "\\%03o", *s);
2398 }
2399 fprintf (e, "\"");
2400 break;
2401 }
2402
2403 case RCDATA_WSTRING:
2404 fprintf (e, "L\"");
2405 unicode_print (e, ri->u.wstring.w, ri->u.wstring.length);
2406 fprintf (e, "\"");
2407 break;
2408
2409 case RCDATA_BUFFER:
2410 {
2411 unsigned long i;
2412 int first;
2413
2414 /* Assume little endian data. */
2415
2416 first = 1;
2417 for (i = 0; i + 3 < ri->u.buffer.length; i += 4)
2418 {
2419 unsigned long l;
2420 int j;
2421
2422 if (! first)
2423 indent (e, ind + 2);
2424 l = ((((((ri->u.buffer.data[i + 3] << 8)
2425 | ri->u.buffer.data[i + 2]) << 8)
2426 | ri->u.buffer.data[i + 1]) << 8)
2427 | ri->u.buffer.data[i]);
2428 fprintf (e, "%luL", l);
2429 if (i + 4 < ri->u.buffer.length || ri->next != NULL)
2430 fprintf (e, ",");
2431 for (j = 0; j < 4; ++j)
2432 if (! ISPRINT (ri->u.buffer.data[i + j])
2433 && ri->u.buffer.data[i + j] != 0)
2434 break;
2435 if (j >= 4)
2436 {
2437 fprintf (e, "\t// ");
2438 for (j = 0; j < 4; ++j)
2439 {
2440 if (! ISPRINT (ri->u.buffer.data[i + j]))
2441 fprintf (e, "\\%03o", ri->u.buffer.data[i + j]);
2442 else
2443 {
2444 if (ri->u.buffer.data[i + j] == '\\')
2445 fprintf (e, "\\");
2446 fprintf (e, "%c", ri->u.buffer.data[i + j]);
2447 }
2448 }
2449 }
2450 fprintf (e, "\n");
2451 first = 0;
2452 }
2453
2454 if (i + 1 < ri->u.buffer.length)
2455 {
2456 int s;
2457 int j;
2458
2459 if (! first)
2460 indent (e, ind + 2);
2461 s = (ri->u.buffer.data[i + 1] << 8) | ri->u.buffer.data[i];
2462 fprintf (e, "%d", s);
2463 if (i + 2 < ri->u.buffer.length || ri->next != NULL)
2464 fprintf (e, ",");
2465 for (j = 0; j < 2; ++j)
2466 if (! ISPRINT (ri->u.buffer.data[i + j])
2467 && ri->u.buffer.data[i + j] != 0)
2468 break;
2469 if (j >= 2)
2470 {
2471 fprintf (e, "\t// ");
2472 for (j = 0; j < 2; ++j)
2473 {
2474 if (! ISPRINT (ri->u.buffer.data[i + j]))
2475 fprintf (e, "\\%03o", ri->u.buffer.data[i + j]);
2476 else
2477 {
2478 if (ri->u.buffer.data[i + j] == '\\')
2479 fprintf (e, "\\");
2480 fprintf (e, "%c", ri->u.buffer.data[i + j]);
2481 }
2482 }
2483 }
2484 fprintf (e, "\n");
2485 i += 2;
2486 first = 0;
2487 }
2488
2489 if (i < ri->u.buffer.length)
2490 {
2491 if (! first)
2492 indent (e, ind + 2);
2493 if ((ri->u.buffer.data[i] & 0x7f) == ri->u.buffer.data[i]
2494 && ISPRINT (ri->u.buffer.data[i]))
2495 fprintf (e, "\"%c\"", ri->u.buffer.data[i]);
2496 else
2497 fprintf (e, "\"\\%03o\"", ri->u.buffer.data[i]);
2498 if (ri->next != NULL)
2499 fprintf (e, ",");
2500 fprintf (e, "\n");
2501 first = 0;
2502 }
2503
2504 break;
2505 }
2506 }
2507
2508 if (ri->type != RCDATA_BUFFER)
2509 {
2510 if (ri->next != NULL)
2511 fprintf (e, ",");
2512 fprintf (e, "\n");
2513 }
2514 }
2515
2516 indent (e, ind);
2517 fprintf (e, "END\n");
2518 }
2519
2520 /* Write out a stringtable resource. */
2521
2522 static void
2523 write_rc_stringtable (e, name, stringtable)
2524 FILE *e;
2525 const struct res_id *name;
2526 const struct stringtable *stringtable;
2527 {
2528 unsigned long offset;
2529 int i;
2530
2531 if (name != NULL && ! name->named)
2532 offset = (name->u.id - 1) << 4;
2533 else
2534 {
2535 fprintf (e, "// %s string table name\n",
2536 name == NULL ? "Missing" : "Invalid");
2537 offset = 0;
2538 }
2539
2540 fprintf (e, "BEGIN\n");
2541
2542 for (i = 0; i < 16; i++)
2543 {
2544 if (stringtable->strings[i].length != 0)
2545 {
2546 fprintf (e, " %lu, \"", offset + i);
2547 unicode_print (e, stringtable->strings[i].string,
2548 stringtable->strings[i].length);
2549 fprintf (e, "\"\n");
2550 }
2551 }
2552
2553 fprintf (e, "END\n");
2554 }
2555
2556 /* Write out a versioninfo resource. */
2557
2558 static void
2559 write_rc_versioninfo (e, versioninfo)
2560 FILE *e;
2561 const struct versioninfo *versioninfo;
2562 {
2563 const struct fixed_versioninfo *f;
2564 const struct ver_info *vi;
2565
2566 f = versioninfo->fixed;
2567 if (f->file_version_ms != 0 || f->file_version_ls != 0)
2568 fprintf (e, " FILEVERSION %lu, %lu, %lu, %lu\n",
2569 (f->file_version_ms >> 16) & 0xffff,
2570 f->file_version_ms & 0xffff,
2571 (f->file_version_ls >> 16) & 0xffff,
2572 f->file_version_ls & 0xffff);
2573 if (f->product_version_ms != 0 || f->product_version_ls != 0)
2574 fprintf (e, " PRODUCTVERSION %lu, %lu, %lu, %lu\n",
2575 (f->product_version_ms >> 16) & 0xffff,
2576 f->product_version_ms & 0xffff,
2577 (f->product_version_ls >> 16) & 0xffff,
2578 f->product_version_ls & 0xffff);
2579 if (f->file_flags_mask != 0)
2580 fprintf (e, " FILEFLAGSMASK 0x%lx\n", f->file_flags_mask);
2581 if (f->file_flags != 0)
2582 fprintf (e, " FILEFLAGS 0x%lx\n", f->file_flags);
2583 if (f->file_os != 0)
2584 fprintf (e, " FILEOS 0x%lx\n", f->file_os);
2585 if (f->file_type != 0)
2586 fprintf (e, " FILETYPE 0x%lx\n", f->file_type);
2587 if (f->file_subtype != 0)
2588 fprintf (e, " FILESUBTYPE 0x%lx\n", f->file_subtype);
2589 if (f->file_date_ms != 0 || f->file_date_ls != 0)
2590 fprintf (e, "// Date: %lu, %lu\n", f->file_date_ms, f->file_date_ls);
2591
2592 fprintf (e, "BEGIN\n");
2593
2594 for (vi = versioninfo->var; vi != NULL; vi = vi->next)
2595 {
2596 switch (vi->type)
2597 {
2598 case VERINFO_STRING:
2599 {
2600 const struct ver_stringinfo *vs;
2601
2602 fprintf (e, " BLOCK \"StringFileInfo\"\n");
2603 fprintf (e, " BEGIN\n");
2604 fprintf (e, " BLOCK \"");
2605 unicode_print (e, vi->u.string.language, -1);
2606 fprintf (e, "\"\n");
2607 fprintf (e, " BEGIN\n");
2608
2609 for (vs = vi->u.string.strings; vs != NULL; vs = vs->next)
2610 {
2611 fprintf (e, " VALUE \"");
2612 unicode_print (e, vs->key, -1);
2613 fprintf (e, "\", \"");
2614 unicode_print (e, vs->value, -1);
2615 fprintf (e, "\"\n");
2616 }
2617
2618 fprintf (e, " END\n");
2619 fprintf (e, " END\n");
2620 break;
2621 }
2622
2623 case VERINFO_VAR:
2624 {
2625 const struct ver_varinfo *vv;
2626
2627 fprintf (e, " BLOCK \"VarFileInfo\"\n");
2628 fprintf (e, " BEGIN\n");
2629 fprintf (e, " VALUE \"");
2630 unicode_print (e, vi->u.var.key, -1);
2631 fprintf (e, "\"");
2632
2633 for (vv = vi->u.var.var; vv != NULL; vv = vv->next)
2634 fprintf (e, ", 0x%x, %d", (unsigned int) vv->language,
2635 vv->charset);
2636
2637 fprintf (e, "\n END\n");
2638
2639 break;
2640 }
2641 }
2642 }
2643
2644 fprintf (e, "END\n");
2645 }
2646
2647 /* Write out data which would normally be read from a file. */
2648
2649 static void
2650 write_rc_filedata (e, length, data)
2651 FILE *e;
2652 unsigned long length;
2653 const unsigned char *data;
2654 {
2655 unsigned long i;
2656
2657 for (i = 0; i + 15 < length; i += 16)
2658 {
2659 fprintf (e, "// %4lx: ", i);
2660 fprintf (e, "%02x %02x %02x %02x %02x %02x %02x %02x ",
2661 data[i + 0], data[i + 1], data[i + 2], data[i + 3],
2662 data[i + 4], data[i + 5], data[i + 6], data[i + 7]);
2663 fprintf (e, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
2664 data[i + 8], data[i + 9], data[i + 10], data[i + 11],
2665 data[i + 12], data[i + 13], data[i + 14], data[i + 15]);
2666 }
2667
2668 if (i < length)
2669 {
2670 fprintf (e, "// %4lx:", i);
2671 while (i < length)
2672 {
2673 fprintf (e, " %02x", data[i]);
2674 ++i;
2675 }
2676 fprintf (e, "\n");
2677 }
2678 }
GDB Binutils - Deliverables
This page took 0.103068 seconds and 4 git commands to generate.