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