Subversion Repositories openrisc

/* Character set conversion support for GDB.

/* Character set conversion support for GDB.

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

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

   This file is part of GDB.

   This file is part of GDB.

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

   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

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

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

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

   (at your option) any later version.

   (at your option) any later version.

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

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

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   GNU General Public License for more details.

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

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

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "defs.h"

#include "charset.h"

#include "charset.h"

#include "gdbcmd.h"

#include "gdbcmd.h"

#include "gdb_assert.h"

#include "gdb_assert.h"

#include <stddef.h>

#include <stddef.h>

#include "gdb_string.h"

#include "gdb_string.h"

#include <ctype.h>

#include <ctype.h>

#ifdef HAVE_ICONV

#ifdef HAVE_ICONV

#include <iconv.h>

#include <iconv.h>

#endif

#endif

/* How GDB's character set support works

/* How GDB's character set support works

   GDB has two global settings:

   GDB has two global settings:

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

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

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

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

     terminal knows how to display properly.

     terminal knows how to display properly.

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

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

     program being debugged uses.

     program being debugged uses.

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

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

   choosing reasonable default values.  GDB has a global list of

   choosing reasonable default values.  GDB has a global list of

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

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

   sets.

   sets.

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

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

   different pieces of GDB need to perform tasks like:

   different pieces of GDB need to perform tasks like:

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

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

     (mostly target->host conversions),

     (mostly target->host conversions),

   - building target-appropriate representations of strings and

   - building target-appropriate representations of strings and

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

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

     conversions),

     conversions),

   and so on.

   and so on.

   Now, many of these operations are specific to a particular

   Now, many of these operations are specific to a particular

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

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

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

   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

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

   new character sets.

   new character sets.

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

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

   pairing of host and target character set, while still allowing

   pairing of host and target character set, while still allowing

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

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

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

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

     functions specific to a particular pair of character sets.

     functions specific to a particular pair of character sets.

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

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

     omitted.  Where there is not a translation to specify exactly

     omitted.  Where there is not a translation to specify exactly

     what function to use, we provide reasonable defaults.  The

     what function to use, we provide reasonable defaults.  The

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

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

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

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

     is not available, there are fallbacks to support trivial

     is not available, there are fallbacks to support trivial

     translations: when the host and target character sets are the

     translations: when the host and target character sets are the

     same.  */

     same.  */

/* The character set and translation structures.  */

/* The character set and translation structures.  */

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

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

   with stateless encodings, in which every character is one byte

   with stateless encodings, in which every character is one byte

   long.  */

   long.  */

struct charset {

struct charset {

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

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

  struct charset *next;

  struct charset *next;

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

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

     names are case-sensitive.  */

     names are case-sensitive.  */

  const char *name;

  const char *name;

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

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

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

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

     set is a superset of ASCII.  */

     set is a superset of ASCII.  */

  int valid_host_charset;

  int valid_host_charset;

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

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

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

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

  int (*host_char_print_literally) (void *baton,

  int (*host_char_print_literally) (void *baton,

                                    int host_char);

                                    int host_char);

  void *host_char_print_literally_baton;

  void *host_char_print_literally_baton;

  int (*target_char_to_control_char) (void *baton,

  int (*target_char_to_control_char) (void *baton,

                                      int target_char,

                                      int target_char,

                                      int *target_ctrl_char);

                                      int *target_ctrl_char);

  void *target_char_to_control_char_baton;

  void *target_char_to_control_char_baton;

};

};

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

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

struct translation {

struct translation {

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

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

  struct translation *next;

  struct translation *next;

  /* This structure describes functions going from the FROM character

  /* This structure describes functions going from the FROM character

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

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

     are case-sensitive.  */

     are case-sensitive.  */

  const char *from, *to;

  const char *from, *to;

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

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

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

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

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

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

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

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

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

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

  /* TARGET_CHAR is in the `from' charset.

  /* TARGET_CHAR is in the `from' charset.

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

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

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

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

                                                     int target_char);

                                                     int target_char);

  void *c_target_char_has_backslash_escape_baton;

  void *c_target_char_has_backslash_escape_baton;

  /* HOST_CHAR is in the `from' charset.

  /* HOST_CHAR is in the `from' charset.

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

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

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

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

  void *c_parse_backslash_baton;

  void *c_parse_backslash_baton;

  /* This is used for the host_char_to_target and target_char_to_host

  /* This is used for the host_char_to_target and target_char_to_host

     functions.  */

     functions.  */

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

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

  void *convert_char_baton;

  void *convert_char_baton;

};

};

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

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

#ifndef GDB_DEFAULT_HOST_CHARSET

#ifndef GDB_DEFAULT_HOST_CHARSET

#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"

#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"

#endif

#endif

#ifndef GDB_DEFAULT_TARGET_CHARSET

#ifndef GDB_DEFAULT_TARGET_CHARSET

#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"

#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"

#endif

#endif

static const char *host_charset_name = GDB_DEFAULT_HOST_CHARSET;

static const char *host_charset_name = GDB_DEFAULT_HOST_CHARSET;

static void

static void

show_host_charset_name (struct ui_file *file, int from_tty,

show_host_charset_name (struct ui_file *file, int from_tty,

                        struct cmd_list_element *c,

                        struct cmd_list_element *c,

                        const char *value)

                        const char *value)

{

{

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

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

}

}

static const char *target_charset_name = GDB_DEFAULT_TARGET_CHARSET;

static const char *target_charset_name = GDB_DEFAULT_TARGET_CHARSET;

static void

static void

show_target_charset_name (struct ui_file *file, int from_tty,

show_target_charset_name (struct ui_file *file, int from_tty,

                          struct cmd_list_element *c, const char *value)

                          struct cmd_list_element *c, const char *value)

{

{

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

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

                    value);

                    value);

}

}

static const char *host_charset_enum[] =

static const char *host_charset_enum[] =

{

{

  "ASCII",

  "ASCII",

  "ISO-8859-1",

  "ISO-8859-1",

  0

  0

};

};

static const char *target_charset_enum[] =

static const char *target_charset_enum[] =

{

{

  "ASCII",

  "ASCII",

  "ISO-8859-1",

  "ISO-8859-1",

  "EBCDIC-US",

  "EBCDIC-US",

  "IBM1047",

  "IBM1047",

  0

  0

};

};

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

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

static struct charset *all_charsets;

static struct charset *all_charsets;

static void

static void

register_charset (struct charset *cs)

register_charset (struct charset *cs)

{

{

  struct charset **ptr;

  struct charset **ptr;

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

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

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

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

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

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

    ;

    ;

  cs->next = 0;

  cs->next = 0;

  *ptr = cs;

  *ptr = cs;

}

}

static struct charset *

static struct charset *

lookup_charset (const char *name)

lookup_charset (const char *name)

{

{

  struct charset *cs;

  struct charset *cs;

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

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

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

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

      return cs;

      return cs;

  return NULL;

  return NULL;

}

}

/* The global list of translations.  */

/* The global list of translations.  */

static struct translation *all_translations;

static struct translation *all_translations;

static void

static void

register_translation (struct translation *t)

register_translation (struct translation *t)

{

{

  t->next = all_translations;

  t->next = all_translations;

  all_translations = t;

  all_translations = t;

}

}

static struct translation *

static struct translation *

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

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

{

{

  struct translation *t;

  struct translation *t;

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

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

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

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

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

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

      return t;

      return t;

  return 0;

  return 0;

}

}

/* Constructing charsets.  */

/* Constructing charsets.  */

/* Allocate, initialize and return a straightforward charset.

/* Allocate, initialize and return a straightforward charset.

   Use this function, rather than creating the structures yourself,

   Use this function, rather than creating the structures yourself,

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

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

   having to tweak all the old charset descriptions.  */

   having to tweak all the old charset descriptions.  */

static struct charset *

static struct charset *

simple_charset (const char *name,

simple_charset (const char *name,

                int valid_host_charset,

                int valid_host_charset,

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

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

                void *host_char_print_literally_baton,

                void *host_char_print_literally_baton,

                int (*target_char_to_control_char) (void *baton,

                int (*target_char_to_control_char) (void *baton,

                                                    int target_char,

                                                    int target_char,

                                                    int *target_ctrl_char),

                                                    int *target_ctrl_char),

                void *target_char_to_control_char_baton)

                void *target_char_to_control_char_baton)

{

{

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

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

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

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

  cs->name = name;

  cs->name = name;

  cs->valid_host_charset = valid_host_charset;

  cs->valid_host_charset = valid_host_charset;

  cs->host_char_print_literally = host_char_print_literally;

  cs->host_char_print_literally = host_char_print_literally;

  cs->host_char_print_literally_baton = host_char_print_literally_baton;

  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 = target_char_to_control_char;

  cs->target_char_to_control_char_baton = target_char_to_control_char_baton;

  cs->target_char_to_control_char_baton = target_char_to_control_char_baton;

  return cs;

  return cs;

}

}

/* ASCII functions.  */

/* ASCII functions.  */

static int

static int

ascii_print_literally (void *baton, int c)

ascii_print_literally (void *baton, int c)

{

{

  c &= 0xff;

  c &= 0xff;

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

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

}

}

static int

static int

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

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

{

{

  *ctrl_char = (c & 037);

  *ctrl_char = (c & 037);

  return 1;

  return 1;

}

}

/* ISO-8859 family functions.  */

/* ISO-8859 family functions.  */

static int

static int

iso_8859_print_literally (void *baton, int c)

iso_8859_print_literally (void *baton, int c)

{

{

  c &= 0xff;

  c &= 0xff;

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

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

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

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

}

}

static int

static int

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

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

{

{

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

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

  return 1;

  return 1;

}

}

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

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

static struct charset *

static struct charset *

iso_8859_family_charset (const char *name)

iso_8859_family_charset (const char *name)

{

{

  return simple_charset (name, 1,

  return simple_charset (name, 1,

                         iso_8859_print_literally, 0,

                         iso_8859_print_literally, 0,

                         iso_8859_to_control, 0);

                         iso_8859_to_control, 0);

}

}

/* EBCDIC family functions.  */

/* EBCDIC family functions.  */

static int

static int

ebcdic_print_literally (void *baton, int c)

ebcdic_print_literally (void *baton, int c)

{

{

  c &= 0xff;

  c &= 0xff;

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

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

}

}

static int

static int

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

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

{

{

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

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

     numeric escapes.  */

     numeric escapes.  */

  return 0;

  return 0;

}

}

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

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

static struct charset *

static struct charset *

ebcdic_family_charset (const char *name)

ebcdic_family_charset (const char *name)

{

{

  return simple_charset (name, 0,

  return simple_charset (name, 0,

                         ebcdic_print_literally, 0,

                         ebcdic_print_literally, 0,

                         ebcdic_to_control, 0);

                         ebcdic_to_control, 0);

}

}

/* Fallback functions using iconv.  */

/* Fallback functions using iconv.  */

#if defined(HAVE_ICONV)

#if defined(HAVE_ICONV)

struct cached_iconv {

struct cached_iconv {

  struct charset *from, *to;

  struct charset *from, *to;

  iconv_t i;

  iconv_t i;

};

};

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

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

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

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

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

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

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

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

static int

static int

check_iconv_cache (struct cached_iconv *ci,

check_iconv_cache (struct cached_iconv *ci,

                   struct charset *from,

                   struct charset *from,

                   struct charset *to)

                   struct charset *to)

{

{

  iconv_t i;

  iconv_t i;

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

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

     to do now?  */

     to do now?  */

  if (ci->from == from

  if (ci->from == from

      && ci->to == to

      && ci->to == to

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

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

    return 0;

    return 0;

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

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

     all, close it now.  */

     all, close it now.  */

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

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

    {

    {

      i = ci->i;

      i = ci->i;

      ci->i = (iconv_t) 0;

      ci->i = (iconv_t) 0;

      if (iconv_close (i) == -1)

      if (iconv_close (i) == -1)

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

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

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

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

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

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

    }

    }

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

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

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

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

  if (i == (iconv_t) -1)

  if (i == (iconv_t) -1)

    return -1;

    return -1;

  ci->i = i;

  ci->i = i;

  ci->from = from;

  ci->from = from;

  ci->to = to;

  ci->to = to;

  return 0;

  return 0;

}

}

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

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

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

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

static int

static int

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

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

{

{

  char from;

  char from;

  ICONV_CONST char *from_ptr = &from;

  ICONV_CONST char *from_ptr = &from;

  char to, *to_ptr = &to;

  char to, *to_ptr = &to;

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

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

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

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

  from = from_char;

  from = from_char;

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

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

      == (size_t) -1)

      == (size_t) -1)

    {

    {

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

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

         have multi-byte encodings of some characters, which means

         have multi-byte encodings of some characters, which means

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

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

         never have selected it.  */

         never have selected it.  */

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

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

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

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

      gdb_assert (errno != EBADF);

      gdb_assert (errno != EBADF);

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

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

         the `to' character set.  */

         the `to' character set.  */

      if (errno == EILSEQ)

      if (errno == EILSEQ)

        return 0;

        return 0;

      /* Anything else is mysterious.  */

      /* Anything else is mysterious.  */

      internal_error (__FILE__, __LINE__,

      internal_error (__FILE__, __LINE__,

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

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

                        "character set: %s"),

                        "character set: %s"),

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

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

                      safe_strerror (errno));

                      safe_strerror (errno));

    }

    }

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

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

     suggests something was wrong.  */

     suggests something was wrong.  */

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

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

  *to_char = (unsigned char) to;

  *to_char = (unsigned char) to;

  return 1;

  return 1;

}

}

static void

static void

register_iconv_charsets (void)

register_iconv_charsets (void)

{

{

  /* Here we should check whether various character sets were

  /* Here we should check whether various character sets were

     recognized by the local iconv implementation.

     recognized by the local iconv implementation.

     The first implementation registered a bunch of character sets

     The first implementation registered a bunch of character sets

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

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

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

     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

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

     file.  */

     file.  */

}

}

#endif /* defined (HAVE_ICONV) */

#endif /* defined (HAVE_ICONV) */

/* Fallback routines for systems without iconv.  */

/* Fallback routines for systems without iconv.  */

#if ! defined (HAVE_ICONV) 

#if ! defined (HAVE_ICONV) 

struct cached_iconv { char nothing; };

struct cached_iconv { char nothing; };

static int

static int

check_iconv_cache (struct cached_iconv *ci,

check_iconv_cache (struct cached_iconv *ci,

                   struct charset *from,

                   struct charset *from,

                   struct charset *to)

                   struct charset *to)

{

{

  errno = EINVAL;

  errno = EINVAL;

  return -1;

  return -1;

}

}

static int

static int

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

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

{

{

  /* This function should never be called.  */

  /* This function should never be called.  */

  gdb_assert (0);

  gdb_assert (0);

}

}

static void

static void

register_iconv_charsets (void)

register_iconv_charsets (void)

{

{

}

}

#endif /* ! defined(HAVE_ICONV) */

#endif /* ! defined(HAVE_ICONV) */

/* Default trivial conversion functions.  */

/* Default trivial conversion functions.  */

static int

static int

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

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

{

{

  *other_char = either_char;

  *other_char = either_char;

  return 1;

  return 1;

}

}

/* Default non-trivial conversion functions.  */

/* Default non-trivial conversion functions.  */

static char backslashable[] = "abfnrtv";

static char backslashable[] = "abfnrtv";

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

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

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

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

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

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

   matches any of our standard escape sequences.  */

   matches any of our standard escape sequences.  */

static const char *

static const char *

default_c_target_char_has_backslash_escape (void *baton, int target_char)

default_c_target_char_has_backslash_escape (void *baton, int target_char)

{

{

  int host_char;

  int host_char;

  const char *ix;

  const char *ix;

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

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

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

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

  if (! target_char_to_host (target_char, &host_char))

  if (! target_char_to_host (target_char, &host_char))

    return NULL;

    return NULL;

  ix = strchr (represented, host_char);

  ix = strchr (represented, host_char);

  if (ix)

  if (ix)

    return backslashed[ix - represented];

    return backslashed[ix - represented];

  else

  else

    return NULL;

    return NULL;

}

}

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

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

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

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

static int

static int

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

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

{

{

  const char *ix;

  const char *ix;

  ix = strchr (backslashable, host_char);

  ix = strchr (backslashable, host_char);

  if (! ix)

  if (! ix)

    return 0;

    return 0;

  else

  else

    return host_char_to_target (represented[ix - backslashable],

    return host_char_to_target (represented[ix - backslashable],

                                target_char);

                                target_char);

}

}

/* Convert using a cached iconv descriptor.  */

/* Convert using a cached iconv descriptor.  */

static int

static int

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

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

{

{

  struct cached_iconv *ci = baton;

  struct cached_iconv *ci = baton;

  return cached_iconv_convert (ci, from_char, to_char);

  return cached_iconv_convert (ci, from_char, to_char);

}

}

/* Conversion tables.  */

/* Conversion tables.  */

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

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

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

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

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

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

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

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

   test suite on all platforms.

   test suite on all platforms.

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

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

   somehow which character sets the host platform supports, and some

   somehow which character sets the host platform supports, and some

   arrangement that allows GDB users to use platform-indepedent names

   arrangement that allows GDB users to use platform-indepedent names

   for character sets.  */

   for character sets.  */

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

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

static int ascii_to_iso_8859_1_table[] = {

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 */