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