Subversion Repositories open8_urisc

/* windmc.c -- a program to compile Windows message files.

   Copyright 2007, 2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

   Written by Kai Tietz, Onevision.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* This program can read and comile Windows message format.

   It is based on information taken from the following sources:

   * Microsoft documentation.

   * The wmc program, written by Bertho A. Stultiens (BS). */

#include "sysdep.h"

#include <assert.h>

#include <time.h>

#include "bfd.h"

#include "getopt.h"

#include "bucomm.h"

#include "libiberty.h"

#include "safe-ctype.h"

#include "obstack.h"

#include "windmc.h"

#include "windint.h"

/* Defines a message compiler element item with length and offset

   information.  */

typedef struct mc_msg_item

{

  rc_uint_type res_len;

  rc_uint_type res_off;

  struct bin_messagetable_item *res;

} mc_msg_item;

int target_is_bigendian = 0;

const char *def_target_arch;

/* Globals and static variable definitions. */

/* bfd global helper struct variable.  */

static struct

{

  bfd *abfd;

  asection *sec;

} mc_bfd;

/* Memory list.  */

mc_node *mc_nodes = NULL;

static mc_node_lang **mc_nodes_lang = NULL;

static int mc_nodes_lang_count = 0;

static mc_keyword **mc_severity_codes = NULL;

static int mc_severity_codes_count = 0;

static mc_keyword **mc_facility_codes = NULL;

static int mc_facility_codes_count = 0;

/* When we are building a resource tree, we allocate everything onto

   an obstack, so that we can free it all at once if we want.  */

#define obstack_chunk_alloc xmalloc

#define obstack_chunk_free free

/* The resource building obstack.  */

static struct obstack res_obstack;

/* Flag variables.  */

/* Set by -C. Set the default code page to be used for input text file.  */

static rc_uint_type mcset_codepage_in = 0;

/* Set by -O. Set the default code page to be used for output text files.  */

static rc_uint_type mcset_codepage_out = 0;

/* Set by -b. .BIN filename should have .mc filename_ included for uniqueness.  */

static int mcset_prefix_bin = 0;

/* The base name of the .mc file.  */

static const char *mcset_mc_basename = "unknown";

/* Set by -e <ext>. Specify the extension for the header file.  */

static const char *mcset_header_ext = ".h";

/* Set by -h <path>. Gives the path of where to create the C include file.  */

static const char *mcset_header_dir = "./";

/* Set by -r <path>. Gives the path of where to create the RC include file

   and the binary message resource files it includes. */

static const char *mcset_rc_dir = "./";

/* Modified by -a & -u. By -u input file is unicode, by -a is ASCII (default).  */

static int mcset_text_in_is_unicode = 0;

/* Modified by -A & -U. By -U bin file is unicode (default), by -A is ASCII.  */

static int mcset_bin_out_is_unicode = 1;

/* Set by -c. Sets the Customer bit in all the message ID's.  */

int mcset_custom_bit = 0;

/* Set by -o. Generate OLE2 header file. Use HRESULT definition instead of

   status code definition.  */

static int mcset_use_hresult = 0;

/* Set by -m <msglen>. Generate a warning if the size of any message exceeds

   maxmsglen characters.  */

rc_uint_type mcset_max_message_length = 0;

/* Set by -d. Sets message values in header to decimal initially.  */

int mcset_out_values_are_decimal = 0;

/* Set by -n. terminates all strings with null's in the message tables.  */

static int mcset_automatic_null_termination = 0;

/* The type used for message id output in header.  */

unichar *mcset_msg_id_typedef = NULL;

/* Set by -x path. Geberated debug C file for mapping ID's to text.  */

static const char *mcset_dbg_dir = NULL;

/* getopt long name definitions.  */

static const struct option long_options[] =

{

  {"binprefix", no_argument, 0, 'b'},

  {"target", required_argument, 0, 'F'},

  {"extension", required_argument, 0, 'e'},

  {"headerdir", required_argument, 0, 'h'},

  {"rcdir", required_argument, 0, 'r'},

  {"verbose", no_argument, 0, 'v'},

  {"codepage_in", required_argument, 0, 'C'},

  {"codepage_out", required_argument, 0, 'O'},

  {"maxlength", required_argument, 0, 'm'},

  {"ascii_in", no_argument, 0, 'a'},

  {"ascii_out", no_argument, 0, 'A'},

  {"unicode_in", no_argument, 0, 'u'},

  {"unicode_out", no_argument, 0, 'U'},

  {"customflag", no_argument, 0, 'c'},

  {"decimal_values", no_argument, 0, 'd'},

  {"hresult_use", no_argument, 0, 'o'},

  {"nullterminate", no_argument, 0, 'n'},

  {"xdbg", required_argument, 0, 'x'},

  {"version", no_argument, 0, 'V'},

  {"help", no_argument, 0, 'H'},

  {0, no_argument, 0, 0}

};

/* Initialize the resource building obstack.  */

static void

res_init (void)

{

  obstack_init (&res_obstack);

}

/* Allocate space on the resource building obstack.  */

void *

res_alloc (rc_uint_type bytes)

{

  return obstack_alloc (&res_obstack, (size_t) bytes);

}

static FILE *

mc_create_path_text_file (const char *path, const char *ext)

{

  FILE *ret;

  size_t len = 1;

  char *hsz;

  len += (path != NULL ? strlen (path) : 0);

  len += strlen (mcset_mc_basename);

  len += (ext != NULL ? strlen (ext) : 0);

  hsz = xmalloc (len);

  sprintf (hsz, "%s%s%s", (path != NULL ? path : ""), mcset_mc_basename,

    (ext != NULL ? ext : ""));

  if ((ret = fopen (hsz, "wb")) == NULL)

    fatal (_("can't create %s file `%s' for output.\n"), (ext ? ext : "text"), hsz);

  free (hsz);

  return ret;

}

static void

usage (FILE *stream, int status)

{

  fprintf (stream, _("Usage: %s [option(s)] [input-file]\n"),

           program_name);

  fprintf (stream, _(" The options are:\n\

  -a --ascii_in                Read input file as ASCII file\n\

  -A --ascii_out               Write binary messages as ASCII\n\

  -b --binprefix               .bin filename is prefixed by .mc filename_ for uniqueness.\n\

  -c --customflag              Set custom flags for messages\n\

  -C --codepage_in=<val>       Set codepage when reading mc text file\n\

  -d --decimal_values          Print values to text files decimal\n\

  -e --extension=<extension>   Set header extension used on export header file\n\

  -F --target <target>         Specify output target for endianness.\n\

  -h --headerdir=<directory>   Set the export directory for headers\n\

  -u --unicode_in              Read input file as UTF16 file\n\

  -U --unicode_out             Write binary messages as UFT16\n\

  -m --maxlength=<val>         Set the maximal allowed message length\n\

  -n --nullterminate           Automatic add a zero termination to strings\n\

  -o --hresult_use             Use HRESULT definition instead of status code definition\n\

  -O --codepage_out=<val>      Set codepage used for writing text file\n\

  -r --rcdir=<directory>       Set the export directory for rc files\n\

  -x --xdbg=<directory>        Where to create the .dbg C include file\n\

                               that maps message ID's to their symbolic name.\n\

"));

  fprintf (stream, _("\

  -H --help                    Print this help message\n\

  -v --verbose                 Verbose - tells you what it's doing\n\

  -V --version                 Print version information\n"));

  list_supported_targets (program_name, stream);

  if (REPORT_BUGS_TO[0] && status == 0)

    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);

  exit (status);

}

static void

set_endianness (bfd *abfd, const char *target)

{

  const bfd_target *target_vec;

  def_target_arch = NULL;

  target_vec = bfd_get_target_info (target, abfd, &target_is_bigendian, NULL,

                                   &def_target_arch);

  if (! target_vec)

    fatal ("Can't detect target endianness and architecture.");

  if (! def_target_arch)

    fatal ("Can't detect architecture.");

}

static int

probe_codepage (rc_uint_type *cp, int *is_uni, const char *pswitch, int defmode)

{

  if (*is_uni == -1)

    {

      if (*cp != CP_UTF16)

        *is_uni = defmode;

      else

        *is_uni = 1;

    }

  if (*is_uni)

    {

      if (*cp != 0 && *cp != CP_UTF16)

        {

          fprintf (stderr, _("%s: warning: "), program_name);

          fprintf (stderr, _("A codepage was specified switch `%s' and UTF16.\n"), pswitch);

          fprintf (stderr, _("\tcodepage settings are ignored.\n"));

        }

      *cp = CP_UTF16;

      return 1;

    }

  if (*cp == CP_UTF16)

    {

      *is_uni = 1;

      return 1;

    }

  if (*cp == 0)

    *cp = 1252;

  if (! unicode_is_valid_codepage (*cp))

        fatal ("Code page 0x%x is unknown.", (unsigned int) *cp);

  *is_uni = 0;

  return 1;

}

mc_node *

mc_add_node (void)

{

  mc_node *ret;

  ret = res_alloc (sizeof (mc_node));

  memset (ret, 0, sizeof (mc_node));

  if (! mc_nodes)

    mc_nodes = ret;

  else

    {

      mc_node *h = mc_nodes;

      while (h->next != NULL)

        h = h->next;

      h->next = ret;

    }

  return ret;

}

mc_node_lang *

mc_add_node_lang (mc_node *root, const mc_keyword *lang, rc_uint_type vid)

{

  mc_node_lang *ret, *h, *p;

  if (! lang || ! root)

    fatal (_("try to add a ill language."));

  ret = res_alloc (sizeof (mc_node_lang));

  memset (ret, 0, sizeof (mc_node_lang));

  ret->lang = lang;

  ret->vid = vid;

  if ((h = root->sub) == NULL)

    root->sub = ret;

  else

    {

      p = NULL;

      while (h != NULL)

        {

          if (h->lang->nval > lang->nval)

            break;

          if (h->lang->nval == lang->nval)

            {

              if (h->vid > vid)

                break;

              if (h->vid == vid)

                fatal ("double defined message id %ld.\n", (long) vid);

            }

          h = (p = h)->next;

        }

      ret->next = h;

      if (! p)

        root->sub = ret;

      else

        p->next = ret;

    }

  return ret;

}

static char *

convert_unicode_to_ACP (const unichar *usz)

{

  char *s;

  rc_uint_type l;

  if (! usz)

    return NULL;

  codepage_from_unicode (&l, usz, &s, mcset_codepage_out);

  if (! s)

    fatal ("unicode string not mappable to ASCII codepage 0x%lx.\n",

           (unsigned long) mcset_codepage_out);

  return s;

}

static void

write_dbg_define (FILE *fp, const unichar *sym_name, const unichar *typecast)

{

  char *sym;

  if (!sym_name || sym_name[0] == 0)

    return;

  sym = convert_unicode_to_ACP (sym_name);

  fprintf (fp, "  {(");

  if (typecast)

    unicode_print (fp, typecast, unichar_len (typecast));

  else

    fprintf (fp, "DWORD");

  fprintf (fp, ") %s, \"%s\" },\n", sym, sym);

}

static void

write_header_define (FILE *fp, const unichar *sym_name, rc_uint_type vid, const unichar *typecast, mc_node_lang *nl)

{

  char *sym;

  char *tdef = NULL;

  if (!sym_name || sym_name[0] == 0)

    {

      if (nl != NULL)

        {

          if (mcset_out_values_are_decimal)

            fprintf (fp, "//\n// MessageId: 0x%lu\n//\n", (unsigned long) vid);

          else

            fprintf (fp, "//\n// MessageId: 0x%lx\n//\n", (unsigned long) vid);

        }

      return;

    }

  sym = convert_unicode_to_ACP (sym_name);

  if (typecast && typecast[0] != 0)

    tdef = convert_unicode_to_ACP (typecast);

  fprintf (fp, "//\n// MessageId: %s\n//\n", sym);

  if (! mcset_out_values_are_decimal)

    fprintf (fp, "#define %s %s%s%s 0x%lx\n\n", sym,

      (tdef ? "(" : ""), (tdef ? tdef : ""), (tdef ? ")" : ""),

    (unsigned long) vid);

  else

    fprintf (fp, "#define %s %s%s%s 0x%lu\n\n", sym,

      (tdef ? "(" : ""), (tdef ? tdef : ""), (tdef ? ")" : ""),

    (unsigned long) vid);

}

static int

sort_mc_node_lang (const void *l, const void *r)

{

  const mc_node_lang *l1 = *((const mc_node_lang **)l);

  const mc_node_lang *r1 = *((const mc_node_lang **)r);

  if (l == r)

    return 0;

  if (l1->lang != r1->lang)

    {

      if (l1->lang->nval < r1->lang->nval)

        return -1;

      return 1;

    }

  if (l1->vid == r1->vid)

    return 0;

  if (l1->vid < r1->vid)

    return -1;

  return 1;

}

static int

sort_keyword_by_nval (const void *l, const void *r)

{

  const mc_keyword *l1 = *((const mc_keyword **)l);

  const mc_keyword *r1 = *((const mc_keyword **)r);

  rc_uint_type len1, len2;

  int e;

  if (l == r)

    return 0;

  if (l1->nval != r1->nval)

    {

      if (l1->nval < r1->nval)

        return -1;

      return 1;

    }

  len1 = unichar_len (l1->usz);

  len2 = unichar_len (r1->usz);

  if (len1 <= len2)

    e = memcmp (l1->usz, r1->usz, sizeof (unichar) * len1);

  else

    e = memcmp (l1->usz, r1->usz, sizeof (unichar) * len2);

  if (e)

    return e;

  if (len1 < len2)

    return -1;

  else if (len1 > len2)

    return 1;

  return 0;

}

static void

do_sorts (void)

{

  mc_node *h;

  mc_node_lang *n;

  const mc_keyword *k;

  int i;

  /* Sort message by their language and id ascending.  */

  mc_nodes_lang_count = 0;

  h = mc_nodes;

  while (h != NULL)

    {

      n = h->sub;

      while (n != NULL)

        {

          mc_nodes_lang_count +=1;

          n = n->next;

        }

      h = h->next;

    }

  if (mc_nodes_lang_count != 0)

    {

      h = mc_nodes;

      i = 0;

      mc_nodes_lang = xmalloc (sizeof (mc_node_lang *) * mc_nodes_lang_count);

      while (h != NULL)

        {

          n = h->sub;

          while (n != NULL)

            {

              mc_nodes_lang[i++] = n;

              n = n->next;

            }

          h = h->next;

        }

      qsort (mc_nodes_lang, (size_t) mc_nodes_lang_count, sizeof (mc_node_lang *), sort_mc_node_lang);

    }

  /* Sort facility code definitions by there id ascending.  */

  i = 0;

  while ((k = enum_facility (i)) != NULL)

    ++i;

  mc_facility_codes_count = i;

  if (i != 0)

    {

      mc_facility_codes = xmalloc (sizeof (mc_keyword *) * i);

      i = 0;

      while ((k = enum_facility (i)) != NULL)

        mc_facility_codes[i++] = (mc_keyword *) k;

      qsort (mc_facility_codes, (size_t) mc_facility_codes_count, sizeof (mc_keyword *), sort_keyword_by_nval);

    }

  /* Sort severity code definitions by there id ascending.  */

  i = 0;

  while ((k = enum_severity (i)) != NULL)

    ++i;

  mc_severity_codes_count = i;

  if (i != 0)

    {

      mc_severity_codes = xmalloc (sizeof (mc_keyword *) * i);

      i = 0;

      while ((k = enum_severity (i)) != NULL)

        mc_severity_codes[i++] = (mc_keyword *) k;

      qsort (mc_severity_codes, (size_t) mc_severity_codes_count, sizeof (mc_keyword *), sort_keyword_by_nval);

    }

}

static int

mc_get_block_count (mc_node_lang **nl, int elems)

{

  rc_uint_type exid;

  int i, ret;

  if (! nl)

    return 0;

  i = 0;

  ret = 0;

  while (i < elems)

    {

      ret++;

      exid = nl[i++]->vid;

      while (i < elems && nl[i]->vid == exid + 1)

        exid = nl[i++]->vid;

    }

  return ret;

}

static bfd *

windmc_open_as_binary (const char *filename)

{

  bfd *abfd;

  abfd = bfd_openw (filename, "binary");

  if (! abfd)

    fatal ("can't open `%s' for output", filename);

  return abfd;

}

static void

target_put_16 (void *p, rc_uint_type value)

{

  assert (!! p);

  if (target_is_bigendian)

    bfd_putb16 (value, p);

  else

    bfd_putl16 (value, p);

}

static void

target_put_32 (void *p, rc_uint_type value)

{

  assert (!! p);

  if (target_is_bigendian)

    bfd_putb32 (value, p);

  else

    bfd_putl32 (value, p);

}

static struct bin_messagetable_item *

mc_generate_bin_item (mc_node_lang *n, rc_uint_type *res_len)

{

  struct bin_messagetable_item *ret = NULL;

  rc_uint_type len;

  *res_len = 0;

  if (mcset_bin_out_is_unicode == 1)

    {

      unichar *ht = n->message;

      rc_uint_type txt_len;

      txt_len = unichar_len (n->message);

      if (mcset_automatic_null_termination && txt_len != 0)

        {

          while (txt_len > 0 && ht[txt_len - 1] > 0 && ht[txt_len - 1] < 0x20)

            ht[--txt_len] = 0;

        }

      txt_len *= sizeof (unichar);

      len = BIN_MESSAGETABLE_ITEM_SIZE + txt_len + sizeof (unichar);

      ret = res_alloc ((len + 3) & ~3);

      memset (ret, 0, (len + 3) & ~3);

      target_put_16 (ret->length, (len + 3) & ~3);

      target_put_16 (ret->flags, MESSAGE_RESOURCE_UNICODE);

      txt_len = 0;

      while (*ht != 0)

        {

          target_put_16 (ret->data + txt_len, *ht++);

          txt_len += 2;

        }

    }

  else

    {

      rc_uint_type txt_len, l;

      char *cvt_txt;

      codepage_from_unicode( &l, n->message, &cvt_txt, n->lang->lang_info.wincp);

      if (! cvt_txt)

        fatal ("Failed to convert message to language codepage.\n");

      txt_len = strlen (cvt_txt);

      if (mcset_automatic_null_termination && txt_len > 0)

        {

          while (txt_len > 0 && cvt_txt[txt_len - 1] > 0 && cvt_txt[txt_len - 1] < 0x20)

            cvt_txt[--txt_len] = 0;

        }

      len = BIN_MESSAGETABLE_ITEM_SIZE + txt_len + 1;

      ret = res_alloc ((len + 3) & ~3);

      memset (ret, 0, (len + 3) & ~3);

      target_put_16 (ret->length, (len + 3) & ~3);

      target_put_16 (ret->flags, 0);

      strcpy ((char *) ret->data, cvt_txt);

    }

  *res_len = (len + 3) & ~3;

  return ret;

}

static void

mc_write_blocks (struct bin_messagetable *mtbl, mc_node_lang **nl, mc_msg_item *ml, int elems)