Subversion Repositories openrisc_me

/* Character set conversion support for GDB.

   Copyright (C) 2001, 2003, 2007, 2008 Free Software Foundation, Inc.

   This file is part of GDB.

   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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "charset.h"

#include "gdbcmd.h"

#include "gdb_assert.h"

#include <stddef.h>

#include "gdb_string.h"

#include <ctype.h>

#ifdef HAVE_ICONV

#include <iconv.h>

#endif

/* How GDB's character set support works

   GDB has two global settings:

   - The `current host character set' is the character set GDB should

     use in talking to the user, and which (hopefully) the user's

     terminal knows how to display properly.

   - The `current target character set' is the character set the

     program being debugged uses.

   There are commands to set each of these, and mechanisms for

   choosing reasonable default values.  GDB has a global list of

   character sets that it can use as its host or target character

   sets.

   The header file `charset.h' declares various functions that

   different pieces of GDB need to perform tasks like:

   - printing target strings and characters to the user's terminal

     (mostly target->host conversions),

   - building target-appropriate representations of strings and

     characters the user enters in expressions (mostly host->target

     conversions),

   and so on.

   Now, many of these operations are specific to a particular

   host/target character set pair.  If GDB supports N character sets,

   there are N^2 possible pairs.  This means that, the larger GDB's

   repertoire of character sets gets, the more expensive it gets to add

   new character sets.

   To make sure that GDB can do the right thing for every possible

   pairing of host and target character set, while still allowing

   GDB's repertoire to scale, we use a two-tiered approach:

   - We maintain a global table of "translations" --- groups of

     functions specific to a particular pair of character sets.

   - However, a translation can be incomplete: some functions can be

     omitted.  Where there is not a translation to specify exactly

     what function to use, we provide reasonable defaults.  The

     default behaviors try to use the "iconv" library functions, which

     support a wide range of character sets.  However, even if iconv

     is not available, there are fallbacks to support trivial

     translations: when the host and target character sets are the

     same.  */

/* The character set and translation structures.  */

/* A character set GDB knows about.  GDB only supports character sets

   with stateless encodings, in which every character is one byte

   long.  */

struct charset {

  /* A singly-linked list of all known charsets.  */

  struct charset *next;

  /* The name of the character set.  Comparisons on character set

     names are case-sensitive.  */

  const char *name;

  /* Non-zero iff this character set can be used as a host character

     set.  At present, GDB basically assumes that the host character

     set is a superset of ASCII.  */

  int valid_host_charset;

  /* Pointers to charset-specific functions that depend only on a

     single character set, and data pointers to pass to them.  */

  int (*host_char_print_literally) (void *baton,

                                    int host_char);

  void *host_char_print_literally_baton;

  int (*target_char_to_control_char) (void *baton,

                                      int target_char,

                                      int *target_ctrl_char);

  void *target_char_to_control_char_baton;

};

/* A translation from one character set to another.  */

struct translation {

  /* A singly-linked list of all known translations.  */

  struct translation *next;

  /* This structure describes functions going from the FROM character

     set to the TO character set.  Comparisons on character set names

     are case-sensitive.  */

  const char *from, *to;

  /* Pointers to translation-specific functions, and data pointers to

     pass to them.  These pointers can be zero, indicating that GDB

     should fall back on the default behavior.  We hope the default

     behavior will be correct for many from/to pairs, reducing the

     number of translations that need to be registered explicitly.  */

  /* TARGET_CHAR is in the `from' charset.

     Returns a string in the `to' charset.  */

  const char *(*c_target_char_has_backslash_escape) (void *baton,

                                                     int target_char);

  void *c_target_char_has_backslash_escape_baton;

  /* HOST_CHAR is in the `from' charset.

     TARGET_CHAR points to a char in the `to' charset.  */

  int (*c_parse_backslash) (void *baton, int host_char, int *target_char);

  void *c_parse_backslash_baton;

  /* This is used for the host_char_to_target and target_char_to_host

     functions.  */

  int (*convert_char) (void *baton, int from, int *to);

  void *convert_char_baton;

};

/* The global lists of character sets and translations.  */

#ifndef GDB_DEFAULT_HOST_CHARSET

#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"

#endif

#ifndef GDB_DEFAULT_TARGET_CHARSET

#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"

#endif

static const char *host_charset_name = GDB_DEFAULT_HOST_CHARSET;

static void

show_host_charset_name (struct ui_file *file, int from_tty,

                        struct cmd_list_element *c,

                        const char *value)

{

  fprintf_filtered (file, _("The host character set is \"%s\".\n"), value);

}

static const char *target_charset_name = GDB_DEFAULT_TARGET_CHARSET;

static void

show_target_charset_name (struct ui_file *file, int from_tty,

                          struct cmd_list_element *c, const char *value)

{

  fprintf_filtered (file, _("The target character set is \"%s\".\n"),

                    value);

}

static const char *host_charset_enum[] =

{

  "ASCII",

  "ISO-8859-1",

};

static const char *target_charset_enum[] =

{

  "ASCII",

  "ISO-8859-1",

  "EBCDIC-US",

  "IBM1047",

};

/* The global list of all the charsets GDB knows about.  */

static struct charset *all_charsets;

static void

register_charset (struct charset *cs)

{

  struct charset **ptr;

  /* Put the new charset on the end, so that the list ends up in the

     same order as the registrations in the _initialize function.  */

  for (ptr = &all_charsets; *ptr; ptr = &(*ptr)->next)

    ;

  cs->next = 0;

  *ptr = cs;

}

static struct charset *

lookup_charset (const char *name)

{

  struct charset *cs;

  for (cs = all_charsets; cs; cs = cs->next)

    if (! strcmp (name, cs->name))

      return cs;

  return NULL;

}

/* The global list of translations.  */

static struct translation *all_translations;

static void

register_translation (struct translation *t)

{

  t->next = all_translations;

  all_translations = t;

}

static struct translation *

lookup_translation (const char *from, const char *to)

{

  struct translation *t;

  for (t = all_translations; t; t = t->next)

    if (! strcmp (from, t->from)

        && ! strcmp (to, t->to))

      return t;

  return 0;

}

/* Constructing charsets.  */

/* Allocate, initialize and return a straightforward charset.

   Use this function, rather than creating the structures yourself,

   so that we can add new fields to the structure in the future without

   having to tweak all the old charset descriptions.  */

static struct charset *

simple_charset (const char *name,

                int valid_host_charset,

                int (*host_char_print_literally) (void *baton, int host_char),

                void *host_char_print_literally_baton,

                int (*target_char_to_control_char) (void *baton,

                                                    int target_char,

                                                    int *target_ctrl_char),

                void *target_char_to_control_char_baton)

{

  struct charset *cs = xmalloc (sizeof (*cs));

  memset (cs, 0, sizeof (*cs));

  cs->name = name;

  cs->valid_host_charset = valid_host_charset;

  cs->host_char_print_literally = host_char_print_literally;

  cs->host_char_print_literally_baton = host_char_print_literally_baton;

  cs->target_char_to_control_char = target_char_to_control_char;

  cs->target_char_to_control_char_baton = target_char_to_control_char_baton;

  return cs;

}

/* ASCII functions.  */

static int

ascii_print_literally (void *baton, int c)

{

  c &= 0xff;

  return (0x20 <= c && c <= 0x7e);

}

static int

ascii_to_control (void *baton, int c, int *ctrl_char)

{

  *ctrl_char = (c & 037);

  return 1;

}

/* ISO-8859 family functions.  */

static int

iso_8859_print_literally (void *baton, int c)

{

  c &= 0xff;

  return ((0x20 <= c && c <= 0x7e) /* ascii printables */

          || (! sevenbit_strings && 0xA0 <= c)); /* iso 8859 printables */

}

static int

iso_8859_to_control (void *baton, int c, int *ctrl_char)

{

  *ctrl_char = (c & 0200) | (c & 037);

  return 1;

}

/* Construct an ISO-8859-like character set.  */

static struct charset *

iso_8859_family_charset (const char *name)

{

  return simple_charset (name, 1,

                         iso_8859_print_literally, 0,

                         iso_8859_to_control, 0);

}

/* EBCDIC family functions.  */

static int

ebcdic_print_literally (void *baton, int c)

{

  c &= 0xff;

  return (64 <= c && c <= 254);

}

static int

ebcdic_to_control (void *baton, int c, int *ctrl_char)

{

  /* There are no control character equivalents in EBCDIC.  Use

     numeric escapes.  */

  return 0;

}

/* Construct an EBCDIC-like character set.  */

static struct charset *

ebcdic_family_charset (const char *name)

{

  return simple_charset (name, 0,

                         ebcdic_print_literally, 0,

                         ebcdic_to_control, 0);

}

/* Fallback functions using iconv.  */

#if defined(HAVE_ICONV)

struct cached_iconv {

  struct charset *from, *to;

  iconv_t i;

};

/* Make sure the iconv cache *CI contains an iconv descriptor

   translating from FROM to TO.  If it already does, fine; otherwise,

   close any existing descriptor, and open up a new one.  On success,

   return zero; on failure, return -1 and set errno.  */

static int

check_iconv_cache (struct cached_iconv *ci,

                   struct charset *from,

                   struct charset *to)

{

  iconv_t i;

  /* Does the cached iconv descriptor match the conversion we're trying

     to do now?  */

  if (ci->from == from

      && ci->to == to

      && ci->i != (iconv_t) 0)

    return 0;

  /* It doesn't.  If we actually had any iconv descriptor open at

     all, close it now.  */

  if (ci->i != (iconv_t) 0)

    {

      i = ci->i;

      ci->i = (iconv_t) 0;

      if (iconv_close (i) == -1)

        error (_("Error closing `iconv' descriptor for "

                 "`%s'-to-`%s' character conversion: %s"),

               ci->from->name, ci->to->name, safe_strerror (errno));

    }

  /* Open a new iconv descriptor for the required conversion.  */

  i = iconv_open (to->name, from->name);

  if (i == (iconv_t) -1)

    return -1;

  ci->i = i;

  ci->from = from;

  ci->to = to;

  return 0;

}

/* Convert FROM_CHAR using the cached iconv conversion *CI.  Return

   non-zero if the conversion was successful, zero otherwise.  */

static int

cached_iconv_convert (struct cached_iconv *ci, int from_char, int *to_char)

{

  char from;

  ICONV_CONST char *from_ptr = &from;

  char to, *to_ptr = &to;

  size_t from_left = sizeof (from), to_left = sizeof (to);

  gdb_assert (ci->i != (iconv_t) 0);

  from = from_char;

  if (iconv (ci->i, &from_ptr, &from_left, &to_ptr, &to_left)

      == (size_t) -1)

    {

      /* These all suggest that the input or output character sets

         have multi-byte encodings of some characters, which means

         it's unsuitable for use as a GDB character set.  We should

         never have selected it.  */

      gdb_assert (errno != E2BIG && errno != EINVAL);

      /* This suggests a bug in the code managing *CI.  */

      gdb_assert (errno != EBADF);

      /* This seems to mean that there is no equivalent character in

         the `to' character set.  */

      if (errno == EILSEQ)

        return 0;

      /* Anything else is mysterious.  */

      internal_error (__FILE__, __LINE__,

                      _("Error converting character `%d' from `%s' to `%s' "

                        "character set: %s"),

                      from_char, ci->from->name, ci->to->name,

                      safe_strerror (errno));

    }

  /* If the pointers weren't advanced across the input, that also

     suggests something was wrong.  */

  gdb_assert (from_left == 0 && to_left == 0);

  *to_char = (unsigned char) to;

  return 1;

}

static void

register_iconv_charsets (void)

{

  /* Here we should check whether various character sets were

     recognized by the local iconv implementation.

     The first implementation registered a bunch of character sets

     recognized by iconv, but then we discovered that iconv on Solaris

     and iconv on GNU/Linux had no character sets in common.  So we

     replaced them with the hard-coded tables that appear later in the

     file.  */

}

#endif /* defined (HAVE_ICONV) */

/* Fallback routines for systems without iconv.  */

#if ! defined (HAVE_ICONV) 

struct cached_iconv { char nothing; };

static int

check_iconv_cache (struct cached_iconv *ci,

                   struct charset *from,

                   struct charset *to)

{

  errno = EINVAL;

  return -1;

}

static int

cached_iconv_convert (struct cached_iconv *ci, int from_char, int *to_char)

{

  /* This function should never be called.  */

  gdb_assert (0);

}

static void

register_iconv_charsets (void)

{

}

#endif /* ! defined(HAVE_ICONV) */

/* Default trivial conversion functions.  */

static int

identity_either_char_to_other (void *baton, int either_char, int *other_char)

{

  *other_char = either_char;

  return 1;

}

/* Default non-trivial conversion functions.  */

static char backslashable[] = "abfnrtv";

static char *backslashed[] = {"a", "b", "f", "n", "r", "t", "v", "0"};

static char represented[] = "\a\b\f\n\r\t\v";

/* Translate TARGET_CHAR into the host character set, and see if it

   matches any of our standard escape sequences.  */

static const char *

default_c_target_char_has_backslash_escape (void *baton, int target_char)

{

  int host_char;

  const char *ix;

  /* If target_char has no equivalent in the host character set,

     assume it doesn't have a backslashed form.  */

  if (! target_char_to_host (target_char, &host_char))

    return NULL;

  ix = strchr (represented, host_char);

  if (ix)

    return backslashed[ix - represented];

  else

    return NULL;

}

/* Translate the backslash the way we would in the host character set,

   and then try to translate that into the target character set.  */

static int

default_c_parse_backslash (void *baton, int host_char, int *target_char)

{

  const char *ix;

  ix = strchr (backslashable, host_char);

  if (! ix)

    return 0;

  else

    return host_char_to_target (represented[ix - backslashable],

                                target_char);

}

/* Convert using a cached iconv descriptor.  */

static int

iconv_convert (void *baton, int from_char, int *to_char)

{

  struct cached_iconv *ci = baton;

  return cached_iconv_convert (ci, from_char, to_char);

}

/* Conversion tables.  */

/* I'd much rather fall back on iconv whenever possible.  But the

   character set names you use with iconv aren't standardized at all,

   a lot of platforms have really meager character set coverage, etc.

   I wanted to have at least something we could use to exercise the

   test suite on all platforms.

   In the long run, we should have a configure-time process explore

   somehow which character sets the host platform supports, and some

   arrangement that allows GDB users to use platform-indepedent names

   for character sets.  */

/* We generated these tables using iconv on a GNU/Linux machine.  */

static int ascii_to_iso_8859_1_table[] = {

    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 16 */

   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 32 */

   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 48 */

   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 64 */

   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 80 */

   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 96 */

   96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 112 */

  112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 128 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 144 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 160 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 176 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 208 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 224 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 240 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1  /* 256 */

};

static int ascii_to_ebcdic_us_table[] = {

    0,  1,  2,  3, 55, 45, 46, 47, 22,  5, 37, 11, 12, 13, 14, 15, /* 16 */

   16, 17, 18, 19, 60, 61, 50, 38, 24, 25, 63, 39, 28, 29, 30, 31, /* 32 */

   64, 90,127,123, 91,108, 80,125, 77, 93, 92, 78,107, 96, 75, 97, /* 48 */

  240,241,242,243,244,245,246,247,248,249,122, 94, 76,126,110,111, /* 64 */

  124,193,194,195,196,197,198,199,200,201,209,210,211,212,213,214, /* 80 */

  215,216,217,226,227,228,229,230,231,232,233, -1,224, -1, -1,109, /* 96 */

  121,129,130,131,132,133,134,135,136,137,145,146,147,148,149,150, /* 112 */

  151,152,153,162,163,164,165,166,167,168,169,192, 79,208,161,  7, /* 128 */

   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 144 */