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