Subversion Repositories openrisc

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

   Copyright 2007

   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;

/* Defined in bfd/binary.c.  Used to set architecture and machine of input

   binary files.  */

extern enum bfd_architecture  bfd_external_binary_architecture;

extern unsigned long          bfd_external_machine;

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 (void *) 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 endianess.\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_endianess (bfd *abfd, const char *target)

{

  const bfd_target *target_vec;

  def_target_arch = NULL;

  target_vec = bfd_find_target (target, abfd);

  if (! target_vec)

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

  target_is_bigendian = ((target_vec->byteorder == BFD_ENDIAN_BIG) ? 1 : 0);

  {

    const char *  tname = target_vec->name;

    const char ** arches = bfd_arch_list ();

    if (arches && tname)

      {

        const char ** arch = arches;

        if (strchr (tname, '-') != NULL)

          tname = strchr (tname, '-') + 1;

        while (*arch != NULL)

          {

            const char *in_a = strstr (*arch, tname);

            char end_ch = (in_a ? in_a[strlen (tname)] : 0);

            if (in_a && (in_a == *arch || in_a[-1] == ':')

                && end_ch == 0)

              {

                def_target_arch = *arch;

                break;

              }

            arch++;

          }

      }

    free (arches);

    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", (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++);