Automatic date update in version.in
[external/binutils.git] / binutils / windmc.c
1 /* windmc.c -- a program to compile Windows message files.
2    Copyright (C) 2007-2018 Free Software Foundation, Inc.
3    Written by Kai Tietz, Onevision.
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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA
20    02110-1301, USA.  */
21
22
23 /* This program can read and comile Windows message format.
24
25    It is based on information taken from the following sources:
26
27    * Microsoft documentation.
28
29    * The wmc program, written by Bertho A. Stultiens (BS). */
30
31 #include "sysdep.h"
32 #include <assert.h>
33 #include <time.h>
34 #include "bfd.h"
35 #include "getopt.h"
36 #include "bucomm.h"
37 #include "libiberty.h"
38 #include "safe-ctype.h"
39 #include "obstack.h"
40
41 #include "windmc.h"
42 #include "windint.h"
43
44 /* Defines a message compiler element item with length and offset
45    information.  */
46 typedef struct mc_msg_item
47 {
48   rc_uint_type res_len;
49   rc_uint_type res_off;
50   struct bin_messagetable_item *res;
51 } mc_msg_item;
52
53 int target_is_bigendian = 0;
54 const char *def_target_arch;
55
56 /* Globals and static variable definitions. */
57
58 /* bfd global helper struct variable.  */
59 static struct
60 {
61   bfd *abfd;
62   asection *sec;
63 } mc_bfd;
64
65 /* Memory list.  */
66 mc_node *mc_nodes = NULL;
67 static mc_node_lang **mc_nodes_lang = NULL;
68 static int mc_nodes_lang_count = 0;
69 static mc_keyword **mc_severity_codes = NULL;
70 static int mc_severity_codes_count = 0;
71 static mc_keyword **mc_facility_codes = NULL;
72 static int mc_facility_codes_count = 0;
73
74 /* When we are building a resource tree, we allocate everything onto
75    an obstack, so that we can free it all at once if we want.  */
76 #define obstack_chunk_alloc xmalloc
77 #define obstack_chunk_free free
78
79 /* The resource building obstack.  */
80 static struct obstack res_obstack;
81
82 /* Flag variables.  */
83 /* Set by -C. Set the default code page to be used for input text file.  */
84 static rc_uint_type mcset_codepage_in = 0;
85
86 /* Set by -O. Set the default code page to be used for output text files.  */
87 static rc_uint_type mcset_codepage_out = 0;
88
89 /* Set by -b. .BIN filename should have .mc filename_ included for uniqueness.  */
90 static int mcset_prefix_bin = 0;
91
92 /* The base name of the .mc file.  */
93 static const char *mcset_mc_basename = "unknown";
94
95 /* Set by -e <ext>. Specify the extension for the header file.  */
96 static const char *mcset_header_ext = ".h";
97
98 /* Set by -h <path>. Gives the path of where to create the C include file.  */
99 static const char *mcset_header_dir = "./";
100
101 /* Set by -r <path>. Gives the path of where to create the RC include file
102    and the binary message resource files it includes. */
103 static const char *mcset_rc_dir = "./";
104
105 /* Modified by -a & -u. By -u input file is unicode, by -a is ASCII (default).  */
106 static int mcset_text_in_is_unicode = 0;
107
108 /* Modified by -A & -U. By -U bin file is unicode (default), by -A is ASCII.  */
109 static int mcset_bin_out_is_unicode = 1;
110
111 /* Set by -c. Sets the Customer bit in all the message ID's.  */
112 int mcset_custom_bit = 0;
113
114 /* Set by -o. Generate OLE2 header file. Use HRESULT definition instead of
115    status code definition.  */
116 static int mcset_use_hresult = 0;
117
118 /* Set by -m <msglen>. Generate a warning if the size of any message exceeds
119    maxmsglen characters.  */
120 rc_uint_type mcset_max_message_length = 0;
121
122 /* Set by -d. Sets message values in header to decimal initially.  */
123 int mcset_out_values_are_decimal = 0;
124
125 /* Set by -n. terminates all strings with null's in the message tables.  */
126 static int mcset_automatic_null_termination = 0;
127
128 /* The type used for message id output in header.  */
129 unichar *mcset_msg_id_typedef = NULL;
130
131 /* Set by -x path. Geberated debug C file for mapping ID's to text.  */
132 static const char *mcset_dbg_dir = NULL;
133
134 /* getopt long name definitions.  */
135 static const struct option long_options[] =
136 {
137   {"binprefix", no_argument, 0, 'b'},
138   {"target", required_argument, 0, 'F'},
139   {"extension", required_argument, 0, 'e'},
140   {"headerdir", required_argument, 0, 'h'},
141   {"rcdir", required_argument, 0, 'r'},
142   {"verbose", no_argument, 0, 'v'},
143   {"codepage_in", required_argument, 0, 'C'},
144   {"codepage_out", required_argument, 0, 'O'},
145   {"maxlength", required_argument, 0, 'm'},
146   {"ascii_in", no_argument, 0, 'a'},
147   {"ascii_out", no_argument, 0, 'A'},
148   {"unicode_in", no_argument, 0, 'u'},
149   {"unicode_out", no_argument, 0, 'U'},
150   {"customflag", no_argument, 0, 'c'},
151   {"decimal_values", no_argument, 0, 'd'},
152   {"hresult_use", no_argument, 0, 'o'},
153   {"nullterminate", no_argument, 0, 'n'},
154   {"xdbg", required_argument, 0, 'x'},
155   {"version", no_argument, 0, 'V'},
156   {"help", no_argument, 0, 'H'},
157   {0, no_argument, 0, 0}
158 };
159
160
161 /* Initialize the resource building obstack.  */
162 static void
163 res_init (void)
164 {
165   obstack_init (&res_obstack);
166 }
167
168 /* Allocate space on the resource building obstack.  */
169 void *
170 res_alloc (rc_uint_type bytes)
171 {
172   return obstack_alloc (&res_obstack, (size_t) bytes);
173 }
174
175 static FILE *
176 mc_create_path_text_file (const char *path, const char *ext)
177 {
178   FILE *ret;
179   size_t len = 1;
180   char *hsz;
181
182   len += (path != NULL ? strlen (path) : 0);
183   len += strlen (mcset_mc_basename);
184   len += (ext != NULL ? strlen (ext) : 0);
185   hsz = xmalloc (len);
186   sprintf (hsz, "%s%s%s", (path != NULL ? path : ""), mcset_mc_basename,
187     (ext != NULL ? ext : ""));
188   if ((ret = fopen (hsz, "wb")) == NULL)
189     fatal (_("can't create %s file `%s' for output.\n"), (ext ? ext : "text"), hsz);
190   free (hsz);
191   return ret;
192 }
193
194 static void
195 usage (FILE *stream, int status)
196 {
197   fprintf (stream, _("Usage: %s [option(s)] [input-file]\n"),
198            program_name);
199   fprintf (stream, _(" The options are:\n\
200   -a --ascii_in                Read input file as ASCII file\n\
201   -A --ascii_out               Write binary messages as ASCII\n\
202   -b --binprefix               .bin filename is prefixed by .mc filename_ for uniqueness.\n\
203   -c --customflag              Set custom flags for messages\n\
204   -C --codepage_in=<val>       Set codepage when reading mc text file\n\
205   -d --decimal_values          Print values to text files decimal\n\
206   -e --extension=<extension>   Set header extension used on export header file\n\
207   -F --target <target>         Specify output target for endianness.\n\
208   -h --headerdir=<directory>   Set the export directory for headers\n\
209   -u --unicode_in              Read input file as UTF16 file\n\
210   -U --unicode_out             Write binary messages as UFT16\n\
211   -m --maxlength=<val>         Set the maximal allowed message length\n\
212   -n --nullterminate           Automatic add a zero termination to strings\n\
213   -o --hresult_use             Use HRESULT definition instead of status code definition\n\
214   -O --codepage_out=<val>      Set codepage used for writing text file\n\
215   -r --rcdir=<directory>       Set the export directory for rc files\n\
216   -x --xdbg=<directory>        Where to create the .dbg C include file\n\
217                                that maps message ID's to their symbolic name.\n\
218 "));
219   fprintf (stream, _("\
220   -H --help                    Print this help message\n\
221   -v --verbose                 Verbose - tells you what it's doing\n\
222   -V --version                 Print version information\n"));
223
224   list_supported_targets (program_name, stream);
225
226   if (REPORT_BUGS_TO[0] && status == 0)
227     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
228
229   exit (status);
230 }
231
232 static void
233 set_endianness (bfd *abfd, const char *target)
234 {
235   const bfd_target *target_vec;
236
237   def_target_arch = NULL;
238   target_vec = bfd_get_target_info (target, abfd, &target_is_bigendian, NULL,
239                                    &def_target_arch);
240   if (! target_vec)
241     fatal ("Can't detect target endianness and architecture.");
242   if (! def_target_arch)
243     fatal ("Can't detect architecture.");
244 }
245
246 static int
247 probe_codepage (rc_uint_type *cp, int *is_uni, const char *pswitch, int defmode)
248 {
249   if (*is_uni == -1)
250     {
251       if (*cp != CP_UTF16)
252         *is_uni = defmode;
253       else
254         *is_uni = 1;
255     }
256   if (*is_uni)
257     {
258       if (*cp != 0 && *cp != CP_UTF16)
259         {
260           fprintf (stderr, _("%s: warning: "), program_name);
261           fprintf (stderr, _("A codepage was specified switch `%s' and UTF16.\n"), pswitch);
262           fprintf (stderr, _("\tcodepage settings are ignored.\n"));
263         }
264       *cp = CP_UTF16;
265       return 1;
266     }
267   if (*cp == CP_UTF16)
268     {
269       *is_uni = 1;
270       return 1;
271     }
272   if (*cp == 0)
273     *cp = 1252;
274   if (! unicode_is_valid_codepage (*cp))
275         fatal ("Code page 0x%x is unknown.", (unsigned int) *cp);
276   *is_uni = 0;
277   return 1;
278 }
279
280 mc_node *
281 mc_add_node (void)
282 {
283   mc_node *ret;
284
285   ret = res_alloc (sizeof (mc_node));
286   memset (ret, 0, sizeof (mc_node));
287   if (! mc_nodes)
288     mc_nodes = ret;
289   else
290     {
291       mc_node *h = mc_nodes;
292
293       while (h->next != NULL)
294         h = h->next;
295       h->next = ret;
296     }
297   return ret;
298 }
299
300 mc_node_lang *
301 mc_add_node_lang (mc_node *root, const mc_keyword *lang, rc_uint_type vid)
302 {
303   mc_node_lang *ret, *h, *p;
304
305   if (! lang || ! root)
306     fatal (_("try to add a ill language."));
307   ret = res_alloc (sizeof (mc_node_lang));
308   memset (ret, 0, sizeof (mc_node_lang));
309   ret->lang = lang;
310   ret->vid = vid;
311   if ((h = root->sub) == NULL)
312     root->sub = ret;
313   else
314     {
315       p = NULL;
316       while (h != NULL)
317         {
318           if (h->lang->nval > lang->nval)
319             break;
320           if (h->lang->nval == lang->nval)
321             {
322               if (h->vid > vid)
323                 break;
324               if (h->vid == vid)
325                 fatal ("double defined message id %ld.\n", (long) vid);
326             }
327           h = (p = h)->next;
328         }
329       ret->next = h;
330       if (! p)
331         root->sub = ret;
332       else
333         p->next = ret;
334     }
335   return ret;
336 }
337
338 static char *
339 convert_unicode_to_ACP (const unichar *usz)
340 {
341   char *s;
342   rc_uint_type l;
343
344   if (! usz)
345     return NULL;
346   codepage_from_unicode (&l, usz, &s, mcset_codepage_out);
347   if (! s)
348     fatal ("unicode string not mappable to ASCII codepage 0x%lx.\n",
349            (unsigned long) mcset_codepage_out);
350   return s;
351 }
352
353 static void
354 write_dbg_define (FILE *fp, const unichar *sym_name, const unichar *typecast)
355 {
356   char *sym;
357
358   if (!sym_name || sym_name[0] == 0)
359     return;
360   sym = convert_unicode_to_ACP (sym_name);
361   fprintf (fp, "  {(");
362   if (typecast)
363     unicode_print (fp, typecast, unichar_len (typecast));
364   else
365     fprintf (fp, "DWORD");
366   fprintf (fp, ") %s, \"%s\" },\n", sym, sym);
367 }
368
369 static void
370 write_header_define (FILE *fp, const unichar *sym_name, rc_uint_type vid, const unichar *typecast, mc_node_lang *nl)
371 {
372   char *sym;
373   char *tdef = NULL;
374
375   if (!sym_name || sym_name[0] == 0)
376     {
377       if (nl != NULL)
378         {
379           if (mcset_out_values_are_decimal)
380             fprintf (fp, "//\n// MessageId: 0x%lu\n//\n", (unsigned long) vid);
381           else
382             fprintf (fp, "//\n// MessageId: 0x%lx\n//\n", (unsigned long) vid);
383         }
384       return;
385     }
386   sym = convert_unicode_to_ACP (sym_name);
387   if (typecast && typecast[0] != 0)
388     tdef = convert_unicode_to_ACP (typecast);
389   fprintf (fp, "//\n// MessageId: %s\n//\n", sym);
390   if (! mcset_out_values_are_decimal)
391     fprintf (fp, "#define %s %s%s%s 0x%lx\n\n", sym,
392       (tdef ? "(" : ""), (tdef ? tdef : ""), (tdef ? ")" : ""),
393     (unsigned long) vid);
394   else
395     fprintf (fp, "#define %s %s%s%s 0x%lu\n\n", sym,
396       (tdef ? "(" : ""), (tdef ? tdef : ""), (tdef ? ")" : ""),
397     (unsigned long) vid);
398 }
399
400 static int
401 sort_mc_node_lang (const void *l, const void *r)
402 {
403   const mc_node_lang *l1 = *((const mc_node_lang **)l);
404   const mc_node_lang *r1 = *((const mc_node_lang **)r);
405
406   if (l == r)
407     return 0;
408   if (l1->lang != r1->lang)
409     {
410       if (l1->lang->nval < r1->lang->nval)
411         return -1;
412       return 1;
413     }
414   if (l1->vid == r1->vid)
415     return 0;
416   if (l1->vid < r1->vid)
417     return -1;
418   return 1;
419 }
420
421 static int
422 sort_keyword_by_nval (const void *l, const void *r)
423 {
424   const mc_keyword *l1 = *((const mc_keyword **)l);
425   const mc_keyword *r1 = *((const mc_keyword **)r);
426   rc_uint_type len1, len2;
427   int e;
428
429   if (l == r)
430     return 0;
431   if (l1->nval != r1->nval)
432     {
433       if (l1->nval < r1->nval)
434         return -1;
435       return 1;
436     }
437   len1 = unichar_len (l1->usz);
438   len2 = unichar_len (r1->usz);
439   if (len1 <= len2)
440     e = memcmp (l1->usz, r1->usz, sizeof (unichar) * len1);
441   else
442     e = memcmp (l1->usz, r1->usz, sizeof (unichar) * len2);
443   if (e)
444     return e;
445   if (len1 < len2)
446     return -1;
447   else if (len1 > len2)
448     return 1;
449   return 0;
450 }
451
452 static void
453 do_sorts (void)
454 {
455   mc_node *h;
456   mc_node_lang *n;
457   const mc_keyword *k;
458   int i;
459
460   /* Sort message by their language and id ascending.  */
461   mc_nodes_lang_count = 0;
462
463   h = mc_nodes;
464   while (h != NULL)
465     {
466       n = h->sub;
467       while (n != NULL)
468         {
469           mc_nodes_lang_count +=1;
470           n = n->next;
471         }
472       h = h->next;
473     }
474
475   if (mc_nodes_lang_count != 0)
476     {
477       h = mc_nodes;
478       i = 0;
479       mc_nodes_lang = xmalloc (sizeof (mc_node_lang *) * mc_nodes_lang_count);
480
481       while (h != NULL)
482         {
483           n = h->sub;
484           while (n != NULL)
485             {
486               mc_nodes_lang[i++] = n;
487               n = n->next;
488             }
489           h = h->next;
490         }
491       qsort (mc_nodes_lang, (size_t) mc_nodes_lang_count, sizeof (mc_node_lang *), sort_mc_node_lang);
492     }
493   /* Sort facility code definitions by there id ascending.  */
494   i = 0;
495   while ((k = enum_facility (i)) != NULL)
496     ++i;
497   mc_facility_codes_count = i;
498   if (i != 0)
499     {
500       mc_facility_codes = xmalloc (sizeof (mc_keyword *) * i);
501       i = 0;
502       while ((k = enum_facility (i)) != NULL)
503         mc_facility_codes[i++] = (mc_keyword *) k;
504       qsort (mc_facility_codes, (size_t) mc_facility_codes_count, sizeof (mc_keyword *), sort_keyword_by_nval);
505     }
506
507   /* Sort severity code definitions by there id ascending.  */
508   i = 0;
509   while ((k = enum_severity (i)) != NULL)
510     ++i;
511   mc_severity_codes_count = i;
512   if (i != 0)
513     {
514       mc_severity_codes = xmalloc (sizeof (mc_keyword *) * i);
515       i = 0;
516       while ((k = enum_severity (i)) != NULL)
517         mc_severity_codes[i++] = (mc_keyword *) k;
518       qsort (mc_severity_codes, (size_t) mc_severity_codes_count, sizeof (mc_keyword *), sort_keyword_by_nval);
519     }
520 }
521
522 static int
523 mc_get_block_count (mc_node_lang **nl, int elems)
524 {
525   rc_uint_type exid;
526   int i, ret;
527
528   if (! nl)
529     return 0;
530   i = 0;
531   ret = 0;
532   while (i < elems)
533     {
534       ret++;
535       exid = nl[i++]->vid;
536       while (i < elems && nl[i]->vid == exid + 1)
537         exid = nl[i++]->vid;
538     }
539   return ret;
540 }
541
542 static bfd *
543 windmc_open_as_binary (const char *filename)
544 {
545   bfd *abfd;
546
547   abfd = bfd_openw (filename, "binary");
548   if (! abfd)
549     fatal ("can't open `%s' for output", filename);
550
551   return abfd;
552 }
553
554 static void
555 target_put_16 (void *p, rc_uint_type value)
556 {
557   assert (!! p);
558
559   if (target_is_bigendian)
560     bfd_putb16 (value, p);
561   else
562     bfd_putl16 (value, p);
563 }
564
565 static void
566 target_put_32 (void *p, rc_uint_type value)
567 {
568   assert (!! p);
569
570   if (target_is_bigendian)
571     bfd_putb32 (value, p);
572   else
573     bfd_putl32 (value, p);
574 }
575
576 static struct bin_messagetable_item *
577 mc_generate_bin_item (mc_node_lang *n, rc_uint_type *res_len)
578 {
579   struct bin_messagetable_item *ret = NULL;
580   rc_uint_type len;
581
582   *res_len = 0;
583   if (mcset_bin_out_is_unicode == 1)
584     {
585       unichar *ht = n->message;
586       rc_uint_type txt_len;
587
588       txt_len = unichar_len (n->message);
589       if (mcset_automatic_null_termination && txt_len != 0)
590         {
591           while (txt_len > 0 && ht[txt_len - 1] > 0 && ht[txt_len - 1] < 0x20)
592             ht[--txt_len] = 0;
593         }
594       txt_len *= sizeof (unichar);
595       len = BIN_MESSAGETABLE_ITEM_SIZE + txt_len + sizeof (unichar);
596       ret = res_alloc ((len + 3) & ~3);
597       memset (ret, 0, (len + 3) & ~3);
598       target_put_16 (ret->length, (len + 3) & ~3);
599       target_put_16 (ret->flags, MESSAGE_RESOURCE_UNICODE);
600       txt_len = 0;
601       while (*ht != 0)
602         {
603           target_put_16 (ret->data + txt_len, *ht++);
604           txt_len += 2;
605         }
606     }
607   else
608     {
609       rc_uint_type txt_len, l;
610       char *cvt_txt;
611
612       codepage_from_unicode( &l, n->message, &cvt_txt, n->lang->lang_info.wincp);
613       if (! cvt_txt)
614         fatal ("Failed to convert message to language codepage.\n");
615       txt_len = strlen (cvt_txt);
616       if (mcset_automatic_null_termination && txt_len > 0)
617         {
618           while (txt_len > 0 && cvt_txt[txt_len - 1] > 0 && cvt_txt[txt_len - 1] < 0x20)
619             cvt_txt[--txt_len] = 0;
620         }
621       len = BIN_MESSAGETABLE_ITEM_SIZE + txt_len + 1;
622       ret = res_alloc ((len + 3) & ~3);
623       memset (ret, 0, (len + 3) & ~3);
624       target_put_16 (ret->length, (len + 3) & ~3);
625       target_put_16 (ret->flags, 0);
626       strcpy ((char *) ret->data, cvt_txt);
627     }
628   *res_len = (len + 3) & ~3;
629   return ret;
630 }
631
632 static void
633 mc_write_blocks (struct bin_messagetable *mtbl, mc_node_lang **nl, mc_msg_item *ml, int elems)
634 {
635   int i, idx = 0;
636   rc_uint_type exid;
637
638   if (! nl)
639     return;
640   i = 0;
641   while (i < elems)
642     {
643       target_put_32 (mtbl->items[idx].lowid, nl[i]->vid);
644       target_put_32 (mtbl->items[idx].highid, nl[i]->vid);
645       target_put_32 (mtbl->items[idx].offset, ml[i].res_off);
646       exid = nl[i++]->vid;
647       while (i < elems && nl[i]->vid == exid + 1)
648         {
649           target_put_32 (mtbl->items[idx].highid, nl[i]->vid);
650           exid = nl[i++]->vid;
651         }
652       ++idx;
653     }
654 }
655
656 static void
657 set_windmc_bfd_content (const void *data, rc_uint_type off, rc_uint_type length)
658 {
659   if (! bfd_set_section_contents (mc_bfd.abfd, mc_bfd.sec, data, off, length))
660     bfd_fatal ("bfd_set_section_contents");
661 }
662
663 static void
664 windmc_write_bin (const char *filename, mc_node_lang **nl, int elems)
665 {
666   unsigned long sec_length = 1;
667   int block_count, i;
668   mc_msg_item *mi;
669   struct bin_messagetable *mtbl;
670   rc_uint_type dta_off, dta_start;
671
672   if (elems <= 0)
673     return;
674   mc_bfd.abfd = windmc_open_as_binary (filename);
675   mc_bfd.sec = bfd_make_section_with_flags (mc_bfd.abfd, ".data",
676                                             (SEC_HAS_CONTENTS | SEC_ALLOC
677                                              | SEC_LOAD | SEC_DATA));
678   if (mc_bfd.sec == NULL)
679     bfd_fatal ("bfd_make_section");
680   /* Requiring this is probably a bug in BFD.  */
681   mc_bfd.sec->output_section = mc_bfd.sec;
682
683   block_count = mc_get_block_count (nl, elems);
684
685   dta_off = (rc_uint_type) ((BIN_MESSAGETABLE_BLOCK_SIZE * block_count) + BIN_MESSAGETABLE_SIZE - 4);
686   dta_start = dta_off = (dta_off + 3) & ~3;
687   mi = xmalloc (sizeof (mc_msg_item) * elems);
688   mtbl = xmalloc (dta_start);
689
690   /* Clear header region.  */
691   memset (mtbl, 0, dta_start);
692   target_put_32 (mtbl->cblocks, block_count);
693   /* Prepare items section for output.  */
694   for (i = 0; i < elems; i++)
695     {
696       mi[i].res_off = dta_off;
697       mi[i].res = mc_generate_bin_item (nl[i], &mi[i].res_len);
698       dta_off += mi[i].res_len;
699     }
700   sec_length = (dta_off + 3) & ~3;
701   if (! bfd_set_section_size (mc_bfd.abfd, mc_bfd.sec, sec_length))
702     bfd_fatal ("bfd_set_section_size");
703   /* Make sure we write the complete block.  */
704   set_windmc_bfd_content ("\0", sec_length - 1, 1);
705
706   /* Write block information.  */
707   mc_write_blocks (mtbl, nl, mi, elems);
708
709   set_windmc_bfd_content (mtbl, 0, dta_start);
710
711   /* Write items.  */
712   for (i = 0; i < elems; i++)
713     set_windmc_bfd_content (mi[i].res, mi[i].res_off, mi[i].res_len);
714
715   free (mtbl);
716   free (mi);
717   bfd_close (mc_bfd.abfd);
718   mc_bfd.abfd = NULL;
719   mc_bfd.sec = NULL;
720 }
721
722 static void
723 write_bin (void)
724 {
725   mc_node_lang *n = NULL;
726   int i, c;
727
728   if (! mc_nodes_lang_count)
729     return;
730
731   i = 0;
732   while (i < mc_nodes_lang_count)
733     {
734       char *nd;
735       char *filename;
736
737       if (n && n->lang == mc_nodes_lang[i]->lang)
738         {
739           i++;
740           continue;
741         }
742       n = mc_nodes_lang[i];
743       c = i + 1;
744       while (c < mc_nodes_lang_count && n->lang == mc_nodes_lang[c]->lang)
745         c++;
746       nd = convert_unicode_to_ACP (n->lang->sval);
747
748       /* Prepare filename for binary output.  */
749       filename = xmalloc (strlen (nd) + 4 + 1 + strlen (mcset_mc_basename) + 1 + strlen (mcset_rc_dir));
750       strcpy (filename, mcset_rc_dir);
751       if (mcset_prefix_bin)
752         sprintf (filename + strlen (filename), "%s_", mcset_mc_basename);
753       strcat (filename, nd);
754       strcat (filename, ".bin");
755
756       /* Write message file.  */
757       windmc_write_bin (filename, &mc_nodes_lang[i], (c - i));
758
759       free (filename);
760       i = c;
761     }
762 }
763
764 static void
765 write_rc (FILE *fp)
766 {
767   mc_node_lang *n;
768   int i, l;
769
770   fprintf (fp,
771            "/* Do not edit this file manually.\n"
772            "   This file is autogenerated by windmc.  */\n\n");
773   if (! mc_nodes_lang_count)
774     return;
775   n = NULL;
776   i = 0;
777   for (l = 0; l < mc_nodes_lang_count; l++)
778     {
779       if (n && n->lang == mc_nodes_lang[l]->lang)
780         continue;
781       ++i;
782       n = mc_nodes_lang[l];
783       fprintf (fp, "\n// Country: %s\n// Language: %s\n#pragma code_page(%u)\n",
784                n->lang->lang_info.country, n->lang->lang_info.name,
785                (unsigned) n->lang->lang_info.wincp);
786       fprintf (fp, "LANGUAGE 0x%lx, 0x%lx\n",
787                (unsigned long) (n->lang->nval & 0x3ff),
788                (unsigned long) ((n->lang->nval & 0xffff) >> 10));
789       fprintf (fp, "1 MESSAGETABLE \"");
790       if (mcset_prefix_bin)
791         fprintf (fp, "%s_", mcset_mc_basename);
792       unicode_print (fp, n->lang->sval, unichar_len (n->lang->sval));
793       fprintf (fp, ".bin\"\n");
794     }
795 }
796
797 static void
798 write_dbg (FILE *fp)
799 {
800   mc_node *h;
801
802   fprintf (fp,
803     "/* Do not edit this file manually.\n"
804     "   This file is autogenerated by windmc.\n\n"
805     "   This file maps each message ID value in to a text string that contains\n"
806     "   the symbolic name used for it.  */\n\n");
807
808   fprintf (fp,
809     "struct %sSymbolicName\n"
810     "{\n  ", mcset_mc_basename);
811   if (mcset_msg_id_typedef)
812     unicode_print (fp, mcset_msg_id_typedef, unichar_len (mcset_msg_id_typedef));
813   else
814     fprintf (fp, "DWORD");
815   fprintf (fp,
816     " MessageId;\n"
817     "  char *SymbolicName;\n"
818     "} %sSymbolicNames[] =\n"
819     "{\n", mcset_mc_basename);
820   h = mc_nodes;
821   while (h != NULL)
822     {
823       if (h->symbol)
824         write_dbg_define (fp, h->symbol, mcset_msg_id_typedef);
825       h = h->next;
826     }
827   fprintf (fp, "  { (");
828   if (mcset_msg_id_typedef)
829     unicode_print (fp, mcset_msg_id_typedef, unichar_len (mcset_msg_id_typedef));
830   else
831     fprintf (fp, "DWORD");
832   fprintf (fp,
833     ") 0xffffffff, NULL }\n"
834     "};\n");
835 }
836
837 static void
838 write_header (FILE *fp)
839 {
840   char *s;
841   int i;
842   const mc_keyword *key;
843   mc_node *h;
844
845   fprintf (fp,
846     "/* Do not edit this file manually.\n"
847     "   This file is autogenerated by windmc.  */\n\n"
848     "//\n//  The values are 32 bit layed out as follows:\n//\n"
849     "//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1\n"
850     "//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0\n"
851     "//  +---+-+-+-----------------------+-------------------------------+\n"
852     "//  |Sev|C|R|     Facility          |               Code            |\n"
853     "//  +---+-+-+-----------------------+-------------------------------+\n//\n"
854     "//  where\n//\n"
855     "//      C    - is the Customer code flag\n//\n"
856     "//      R    - is a reserved bit\n//\n"
857     "//      Code - is the facility's status code\n//\n");
858
859   h = mc_nodes;
860
861   fprintf (fp, "//      Sev  - is the severity code\n//\n");
862   if (mc_severity_codes_count != 0)
863     {
864       for (i = 0; i < mc_severity_codes_count; i++)
865         {
866           key = mc_severity_codes[i];
867           fprintf (fp, "//           %s - %02lx\n", convert_unicode_to_ACP (key->usz),
868                    (unsigned long) key->nval);
869           if (key->sval && key->sval[0] != 0)
870             {
871               if (! mcset_out_values_are_decimal)
872                 fprintf (fp, "#define %s 0x%lx\n", convert_unicode_to_ACP (key->sval),
873                          (unsigned long) key->nval);
874               else
875                 fprintf (fp, "#define %s 0x%lu\n", convert_unicode_to_ACP (key->sval),
876                          (unsigned long) key->nval);
877             }
878         }
879       fprintf (fp, "//\n");
880     }
881   fprintf (fp, "//      Facility - is the facility code\n//\n");
882   if (mc_facility_codes_count != 0)
883     {
884       for (i = 0; i < mc_facility_codes_count; i++)
885         {
886           key = mc_facility_codes[i];
887           fprintf (fp, "//           %s - %04lx\n", convert_unicode_to_ACP (key->usz),
888                    (unsigned long) key->nval);
889           if (key->sval && key->sval[0] != 0)
890             {
891               if (! mcset_out_values_are_decimal)
892                 fprintf (fp, "#define %s 0x%lx\n", convert_unicode_to_ACP (key->sval),
893                          (unsigned long) key->nval);
894               else
895                 fprintf (fp, "#define %s 0x%lu\n", convert_unicode_to_ACP (key->sval),
896                          (unsigned long) key->nval);
897             }
898         }
899       fprintf (fp, "//\n");
900     }
901   fprintf (fp, "\n");
902   while (h != NULL)
903     {
904       if (h->user_text)
905         {
906           s = convert_unicode_to_ACP (h->user_text);
907           if (s)
908             fprintf (fp, "%s", s);
909         }
910       if (h->symbol)
911         write_header_define (fp, h->symbol, h->vid, mcset_msg_id_typedef, h->sub);
912       h = h->next;
913     }
914 }
915
916 static const char *
917 mc_unify_path (const char *path)
918 {
919   char *end;
920   char *hsz;
921
922   if (! path || *path == 0)
923     return "./";
924   hsz = xmalloc (strlen (path) + 2);
925   strcpy (hsz, path);
926   end = hsz + strlen (hsz);
927   if (hsz[-1] != '/' && hsz[-1] != '\\')
928     strcpy (end, "/");
929   while ((end = strchr (hsz, '\\')) != NULL)
930     *end = '/';
931   return hsz;
932 }
933
934 int main (int, char **);
935
936 int
937 main (int argc, char **argv)
938 {
939   FILE *h_fp;
940   int c;
941   char *target, *input_filename;
942   int verbose;
943
944 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
945   setlocale (LC_MESSAGES, "");
946 #endif
947 #if defined (HAVE_SETLOCALE)
948   setlocale (LC_CTYPE, "");
949 #endif
950   bindtextdomain (PACKAGE, LOCALEDIR);
951   textdomain (PACKAGE);
952
953   program_name = argv[0];
954   xmalloc_set_program_name (program_name);
955   bfd_set_error_program_name (program_name);
956
957   expandargv (&argc, &argv);
958
959   bfd_init ();
960   set_default_bfd_target ();
961
962   target = NULL;
963   verbose = 0;
964   input_filename = NULL;
965
966   res_init ();
967
968   while ((c = getopt_long (argc, argv, "C:F:O:h:e:m:r:x:aAbcdHunoUvV", long_options,
969                            (int *) 0)) != EOF)
970     {
971       switch (c)
972         {
973         case 'b':
974           mcset_prefix_bin = 1;
975           break;
976         case 'e':
977           {
978             mcset_header_ext = optarg;
979             if (mcset_header_ext[0] != '.' && mcset_header_ext[0] != 0)
980               {
981                 char *hsz = xmalloc (strlen (mcset_header_ext) + 2);
982
983                 sprintf (hsz, ".%s", mcset_header_ext);
984                 mcset_header_ext = hsz;
985               }
986           }
987           break;
988         case 'h':
989           mcset_header_dir = mc_unify_path (optarg);
990           break;
991         case 'r':
992           mcset_rc_dir = mc_unify_path (optarg);
993           break;
994         case 'a':
995           mcset_text_in_is_unicode = 0;
996           break;
997         case 'x':
998           if (*optarg != 0)
999             mcset_dbg_dir = mc_unify_path (optarg);
1000           break;
1001         case 'A':
1002           mcset_bin_out_is_unicode = 0;
1003           break;
1004         case 'd':
1005           mcset_out_values_are_decimal = 1;
1006           break;
1007         case 'u':
1008           mcset_text_in_is_unicode = 1;
1009           break;
1010         case 'U':
1011           mcset_bin_out_is_unicode = 1;
1012           break;
1013         case 'c':
1014           mcset_custom_bit = 1;
1015           break;
1016         case 'n':
1017           mcset_automatic_null_termination = 1;
1018           break;
1019         case 'o':
1020           mcset_use_hresult = 1;
1021           fatal ("option -o is not implemented until yet.\n");
1022           break;
1023         case 'F':
1024           target = optarg;
1025           break;
1026         case 'v':
1027           verbose ++;
1028           break;
1029         case 'm':
1030           mcset_max_message_length = strtol (optarg, (char **) NULL, 10);
1031           break;
1032         case 'C':
1033           mcset_codepage_in = strtol (optarg, (char **) NULL, 10);
1034           break;
1035         case 'O':
1036           mcset_codepage_out = strtol (optarg, (char **) NULL, 10);
1037           break;
1038         case '?':
1039         case 'H':
1040           usage (stdout, 0);
1041           break;
1042         case 'V':
1043           print_version ("windmc");
1044           break;
1045
1046         default:
1047           usage (stderr, 1);
1048           break;
1049         }
1050     }
1051   if (input_filename == NULL && optind < argc)
1052     {
1053       input_filename = argv[optind];
1054       ++optind;
1055     }
1056
1057   set_endianness (NULL, target);
1058
1059   if (input_filename == NULL)
1060     {
1061       fprintf (stderr, "Error: No input file was specified.\n");
1062       usage (stderr, 1);
1063     }
1064   mc_set_inputfile (input_filename);
1065
1066   if (!probe_codepage (&mcset_codepage_in, &mcset_text_in_is_unicode, "codepage_in", 0))
1067     usage (stderr, 1);
1068   if (mcset_codepage_out == 0)
1069     mcset_codepage_out = 1252;
1070   if (! unicode_is_valid_codepage (mcset_codepage_out))
1071     fatal ("Code page 0x%x is unknown.", (unsigned int) mcset_codepage_out);
1072   if (mcset_codepage_out == CP_UTF16)
1073     fatal ("UTF16 is no valid text output code page.");
1074   if (verbose)
1075     {
1076       fprintf (stderr, "// Default target is %s and it is %s endian.\n",
1077         def_target_arch, (target_is_bigendian ? "big" : "little"));
1078       fprintf (stderr, "// Input codepage: 0x%x\n", (unsigned int) mcset_codepage_in);
1079       fprintf (stderr, "// Output codepage: 0x%x\n", (unsigned int) mcset_codepage_out);
1080     }
1081
1082   if (argc != optind)
1083     usage (stderr, 1);
1084
1085   /* Initialize mcset_mc_basename.  */
1086   {
1087     const char *bn, *bn2;
1088     char *hsz;
1089
1090     bn = strrchr (input_filename, '/');
1091     bn2 = strrchr (input_filename, '\\');
1092     if (! bn)
1093       bn = bn2;
1094     if (bn && bn2 && bn < bn2)
1095       bn = bn2;
1096     if (! bn)
1097       bn = input_filename;
1098     else
1099       bn++;
1100     mcset_mc_basename = hsz = xstrdup (bn);
1101
1102     /* Cut of right-hand extension.  */
1103     if ((hsz = strrchr (hsz, '.')) != NULL)
1104       *hsz = 0;
1105   }
1106
1107   /* Load the input file and do code page transformations to UTF16.  */
1108   {
1109     unichar *u;
1110     rc_uint_type ul;
1111     char *buff;
1112     bfd_size_type flen;
1113     FILE *fp = fopen (input_filename, "rb");
1114
1115     if (!fp)
1116       fatal (_("unable to open file `%s' for input.\n"), input_filename);
1117
1118     fseek (fp, 0, SEEK_END);
1119     flen = ftell (fp);
1120     fseek (fp, 0, SEEK_SET);
1121     buff = malloc (flen + 3);
1122     memset (buff, 0, flen + 3);
1123     if (fread (buff, 1, flen, fp) < flen)
1124       fatal (_("unable to read contents of %s"), input_filename);
1125     fclose (fp);
1126     if (mcset_text_in_is_unicode != 1)
1127       {
1128         unicode_from_codepage (&ul, &u, buff, mcset_codepage_in);
1129         if (! u)
1130           fatal ("Failed to convert input to UFT16\n");
1131         mc_set_content (u);
1132       }
1133     else
1134       {
1135         if ((flen & 1) != 0)
1136           fatal (_("input file does not seems to be UFT16.\n"));
1137         mc_set_content ((unichar *) buff);
1138       }
1139     free (buff);
1140   }
1141
1142   while (yyparse ())
1143     ;
1144
1145   do_sorts ();
1146
1147   h_fp = mc_create_path_text_file (mcset_header_dir, mcset_header_ext);
1148   write_header (h_fp);
1149   fclose (h_fp);
1150
1151   h_fp = mc_create_path_text_file (mcset_rc_dir, ".rc");
1152   write_rc (h_fp);
1153   fclose (h_fp);
1154
1155   if (mcset_dbg_dir != NULL)
1156     {
1157       h_fp = mc_create_path_text_file (mcset_dbg_dir, ".dbg");
1158       write_dbg (h_fp);
1159       fclose (h_fp);
1160     }
1161   write_bin ();
1162
1163   if (mc_nodes_lang)
1164     free (mc_nodes_lang);
1165   if (mc_severity_codes)
1166     free (mc_severity_codes);
1167   if (mc_facility_codes)
1168     free (mc_facility_codes);
1169
1170   xexit (0);
1171   return 0;
1172 }