gdb/charset.c

   1 /* Character set conversion support for GDB.
   2
   3    Copyright (C) 2001-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "charset.h"
  22 #include "gdbcmd.h"
  23 #include "gdb_assert.h"
  24 #include "gdb_obstack.h"
  25 #include "gdb_wait.h"
  26 #include "charset-list.h"
  27 #include "vec.h"
  28 #include "environ.h"
  29 #include "arch-utils.h"
  30 #include "gdb_vecs.h"
  31
  32 #include <string.h>
  33 #include <ctype.h>
  34
  35 #ifdef USE_WIN32API
  36 #include <windows.h>
  37 #endif
  38 \f
  39 /* How GDB's character set support works
  40
  41    GDB has three global settings:
  42
  43    - The `current host character set' is the character set GDB should
  44      use in talking to the user, and which (hopefully) the user's
  45      terminal knows how to display properly.  Most users should not
  46      change this.
  47
  48    - The `current target character set' is the character set the
  49      program being debugged uses.
  50
  51    - The `current target wide character set' is the wide character set
  52      the program being debugged uses, that is, the encoding used for
  53      wchar_t.
  54
  55    There are commands to set each of these, and mechanisms for
  56    choosing reasonable default values.  GDB has a global list of
  57    character sets that it can use as its host or target character
  58    sets.
  59
  60    The header file `charset.h' declares various functions that
  61    different pieces of GDB need to perform tasks like:
  62
  63    - printing target strings and characters to the user's terminal
  64      (mostly target->host conversions),
  65
  66    - building target-appropriate representations of strings and
  67      characters the user enters in expressions (mostly host->target
  68      conversions),
  69
  70      and so on.
  71
  72    To avoid excessive code duplication and maintenance efforts,
  73    GDB simply requires a capable iconv function.  Users on platforms
  74    without a suitable iconv can use the GNU iconv library.  */
  75
  76 \f
  77 #ifdef PHONY_ICONV
  78
  79 /* Provide a phony iconv that does as little as possible.  Also,
  80    arrange for there to be a single available character set.  */
  81
  82 #undef GDB_DEFAULT_HOST_CHARSET
  83 #define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
  84 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
  85 #define GDB_DEFAULT_TARGET_WIDE_CHARSET "ISO-8859-1"
  86 #undef DEFAULT_CHARSET_NAMES
  87 #define DEFAULT_CHARSET_NAMES GDB_DEFAULT_HOST_CHARSET ,
  88
  89 #undef iconv_t
  90 #define iconv_t int
  91 #undef iconv_open
  92 #define iconv_open phony_iconv_open
  93 #undef iconv
  94 #define iconv phony_iconv
  95 #undef iconv_close
  96 #define iconv_close phony_iconv_close
  97
  98 #undef ICONV_CONST
  99 #define ICONV_CONST const
 100
 101 /* Some systems don't have EILSEQ, so we define it here, but not as
 102    EINVAL, because callers of `iconv' want to distinguish EINVAL and
 103    EILSEQ.  This is what iconv.h from libiconv does as well.  Note
 104    that wchar.h may also define EILSEQ, so this needs to be after we
 105    include wchar.h, which happens in defs.h through gdb_wchar.h.  */
 106 #ifndef EILSEQ
 107 #define EILSEQ ENOENT
 108 #endif
 109
 110 static iconv_t
 111 phony_iconv_open (const char *to, const char *from)
 112 {
 113   /* We allow conversions from UTF-32BE, wchar_t, and the host charset.
 114      We allow conversions to wchar_t and the host charset.  */
 115   if (strcmp (from, "UTF-32BE") && strcmp (from, "wchar_t")
 116       && strcmp (from, GDB_DEFAULT_HOST_CHARSET))
 117     return -1;
 118   if (strcmp (to, "wchar_t") && strcmp (to, GDB_DEFAULT_HOST_CHARSET))
 119     return -1;
 120
 121   /* Return 1 if we are converting from UTF-32BE, 0 otherwise.  This is
 122      used as a flag in calls to iconv.  */
 123   return !strcmp (from, "UTF-32BE");
 124 }
 125
 126 static int
 127 phony_iconv_close (iconv_t arg)
 128 {
 129   return 0;
 130 }
 131
 132 static size_t
 133 phony_iconv (iconv_t utf_flag, const char **inbuf, size_t *inbytesleft,
 134              char **outbuf, size_t *outbytesleft)
 135 {
 136   if (utf_flag)
 137     {
 138       while (*inbytesleft >= 4)
 139         {
 140           size_t j;
 141           unsigned long c = 0;
 142
 143           for (j = 0; j < 4; ++j)
 144             {
 145               c <<= 8;
 146               c += (*inbuf)[j] & 0xff;
 147             }
 148
 149           if (c >= 256)
 150             {
 151               errno = EILSEQ;
 152               return -1;
 153             }
 154           **outbuf = c & 0xff;
 155           ++*outbuf;
 156           --*outbytesleft;
 157
 158           ++*inbuf;
 159           *inbytesleft -= 4;
 160         }
 161       if (*inbytesleft < 4)
 162         {
 163           errno = EINVAL;
 164           return -1;
 165         }
 166     }
 167   else
 168     {
 169       /* In all other cases we simply copy input bytes to the
 170          output.  */
 171       size_t amt = *inbytesleft;
 172
 173       if (amt > *outbytesleft)
 174         amt = *outbytesleft;
 175       memcpy (*outbuf, *inbuf, amt);
 176       *inbuf += amt;
 177       *outbuf += amt;
 178       *inbytesleft -= amt;
 179       *outbytesleft -= amt;
 180     }
 181
 182   if (*inbytesleft)
 183     {
 184       errno = E2BIG;
 185       return -1;
 186     }
 187
 188   /* The number of non-reversible conversions -- but they were all
 189      reversible.  */
 190   return 0;
 191 }
 192
 193 #endif
 194
 195
 196 \f
 197 /* The global lists of character sets and translations.  */
 198
 199
 200 #ifndef GDB_DEFAULT_TARGET_CHARSET
 201 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
 202 #endif
 203
 204 #ifndef GDB_DEFAULT_TARGET_WIDE_CHARSET
 205 #define GDB_DEFAULT_TARGET_WIDE_CHARSET "UTF-32"
 206 #endif
 207
 208 static const char *auto_host_charset_name = GDB_DEFAULT_HOST_CHARSET;
 209 static const char *host_charset_name = "auto";
 210 static void
 211 show_host_charset_name (struct ui_file *file, int from_tty,
 212                         struct cmd_list_element *c,
 213                         const char *value)
 214 {
 215   if (!strcmp (value, "auto"))
 216     fprintf_filtered (file,
 217                       _("The host character set is \"auto; currently %s\".\n"),
 218                       auto_host_charset_name);
 219   else
 220     fprintf_filtered (file, _("The host character set is \"%s\".\n"), value);
 221 }
 222
 223 static const char *target_charset_name = "auto";
 224 static void
 225 show_target_charset_name (struct ui_file *file, int from_tty,
 226                           struct cmd_list_element *c, const char *value)
 227 {
 228   if (!strcmp (value, "auto"))
 229     fprintf_filtered (file,
 230                       _("The target character set is \"auto; "
 231                         "currently %s\".\n"),
 232                       gdbarch_auto_charset (get_current_arch ()));
 233   else
 234     fprintf_filtered (file, _("The target character set is \"%s\".\n"),
 235                       value);
 236 }
 237
 238 static const char *target_wide_charset_name = "auto";
 239 static void
 240 show_target_wide_charset_name (struct ui_file *file,
 241                                int from_tty,
 242                                struct cmd_list_element *c,
 243                                const char *value)
 244 {
 245   if (!strcmp (value, "auto"))
 246     fprintf_filtered (file,
 247                       _("The target wide character set is \"auto; "
 248                         "currently %s\".\n"),
 249                       gdbarch_auto_wide_charset (get_current_arch ()));
 250   else
 251     fprintf_filtered (file, _("The target wide character set is \"%s\".\n"),
 252                       value);
 253 }
 254
 255 static const char *default_charset_names[] =
 256 {
 257   DEFAULT_CHARSET_NAMES
 258   0
 259 };
 260
 261 static const char **charset_enum;
 262
 263 \f
 264 /* If the target wide character set has big- or little-endian
 265    variants, these are the corresponding names.  */
 266 static const char *target_wide_charset_be_name;
 267 static const char *target_wide_charset_le_name;
 268
 269 /* The architecture for which the BE- and LE-names are valid.  */
 270 static struct gdbarch *be_le_arch;
 271
 272 /* A helper function which sets the target wide big- and little-endian
 273    character set names, if possible.  */
 274
 275 static void
 276 set_be_le_names (struct gdbarch *gdbarch)
 277 {
 278   int i, len;
 279   const char *target_wide;
 280
 281   if (be_le_arch == gdbarch)
 282     return;
 283   be_le_arch = gdbarch;
 284
 285   target_wide_charset_le_name = NULL;
 286   target_wide_charset_be_name = NULL;
 287
 288   target_wide = target_wide_charset_name;
 289   if (!strcmp (target_wide, "auto"))
 290     target_wide = gdbarch_auto_wide_charset (gdbarch);
 291
 292   len = strlen (target_wide);
 293   for (i = 0; charset_enum[i]; ++i)
 294     {
 295       if (strncmp (target_wide, charset_enum[i], len))
 296         continue;
 297       if ((charset_enum[i][len] == 'B'
 298            || charset_enum[i][len] == 'L')
 299           && charset_enum[i][len + 1] == 'E'
 300           && charset_enum[i][len + 2] == '\0')
 301         {
 302           if (charset_enum[i][len] == 'B')
 303             target_wide_charset_be_name = charset_enum[i];
 304           else
 305             target_wide_charset_le_name = charset_enum[i];
 306         }
 307     }
 308 }
 309
 310 /* 'Set charset', 'set host-charset', 'set target-charset', 'set
 311    target-wide-charset', 'set charset' sfunc's.  */
 312
 313 static void
 314 validate (struct gdbarch *gdbarch)
 315 {
 316   iconv_t desc;
 317   const char *host_cset = host_charset ();
 318   const char *target_cset = target_charset (gdbarch);
 319   const char *target_wide_cset = target_wide_charset_name;
 320
 321   if (!strcmp (target_wide_cset, "auto"))
 322     target_wide_cset = gdbarch_auto_wide_charset (gdbarch);
 323
 324   desc = iconv_open (target_wide_cset, host_cset);
 325   if (desc == (iconv_t) -1)
 326     error (_("Cannot convert between character sets `%s' and `%s'"),
 327            target_wide_cset, host_cset);
 328   iconv_close (desc);
 329
 330   desc = iconv_open (target_cset, host_cset);
 331   if (desc == (iconv_t) -1)
 332     error (_("Cannot convert between character sets `%s' and `%s'"),
 333            target_cset, host_cset);
 334   iconv_close (desc);
 335
 336   /* Clear the cache.  */
 337   be_le_arch = NULL;
 338 }
 339
 340 /* This is the sfunc for the 'set charset' command.  */
 341 static void
 342 set_charset_sfunc (char *charset, int from_tty,
 343                    struct cmd_list_element *c)
 344 {
 345   /* CAREFUL: set the target charset here as well.  */
 346   target_charset_name = host_charset_name;
 347   validate (get_current_arch ());
 348 }
 349
 350 /* 'set host-charset' command sfunc.  We need a wrapper here because
 351    the function needs to have a specific signature.  */
 352 static void
 353 set_host_charset_sfunc (char *charset, int from_tty,
 354                         struct cmd_list_element *c)
 355 {
 356   validate (get_current_arch ());
 357 }
 358
 359 /* Wrapper for the 'set target-charset' command.  */
 360 static void
 361 set_target_charset_sfunc (char *charset, int from_tty,
 362                           struct cmd_list_element *c)
 363 {
 364   validate (get_current_arch ());
 365 }
 366
 367 /* Wrapper for the 'set target-wide-charset' command.  */
 368 static void
 369 set_target_wide_charset_sfunc (char *charset, int from_tty,
 370                                struct cmd_list_element *c)
 371 {
 372   validate (get_current_arch ());
 373 }
 374
 375 /* sfunc for the 'show charset' command.  */
 376 static void
 377 show_charset (struct ui_file *file, int from_tty,
 378               struct cmd_list_element *c,
 379               const char *name)
 380 {
 381   show_host_charset_name (file, from_tty, c, host_charset_name);
 382   show_target_charset_name (file, from_tty, c, target_charset_name);
 383   show_target_wide_charset_name (file, from_tty, c,
 384                                  target_wide_charset_name);
 385 }
 386
 387 \f
 388 /* Accessor functions.  */
 389
 390 const char *
 391 host_charset (void)
 392 {
 393   if (!strcmp (host_charset_name, "auto"))
 394     return auto_host_charset_name;
 395   return host_charset_name;
 396 }
 397
 398 const char *
 399 target_charset (struct gdbarch *gdbarch)
 400 {
 401   if (!strcmp (target_charset_name, "auto"))
 402     return gdbarch_auto_charset (gdbarch);
 403   return target_charset_name;
 404 }
 405
 406 const char *
 407 target_wide_charset (struct gdbarch *gdbarch)
 408 {
 409   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 410
 411   set_be_le_names (gdbarch);
 412   if (byte_order == BFD_ENDIAN_BIG)
 413     {
 414       if (target_wide_charset_be_name)
 415         return target_wide_charset_be_name;
 416     }
 417   else
 418     {
 419       if (target_wide_charset_le_name)
 420         return target_wide_charset_le_name;
 421     }
 422
 423   if (!strcmp (target_wide_charset_name, "auto"))
 424     return gdbarch_auto_wide_charset (gdbarch);
 425
 426   return target_wide_charset_name;
 427 }
 428
 429 \f
 430 /* Host character set management.  For the time being, we assume that
 431    the host character set is some superset of ASCII.  */
 432
 433 char
 434 host_letter_to_control_character (char c)
 435 {
 436   if (c == '?')
 437     return 0177;
 438   return c & 0237;
 439 }
 440
 441 /* Convert a host character, C, to its hex value.  C must already have
 442    been validated using isxdigit.  */
 443
 444 int
 445 host_hex_value (char c)
 446 {
 447   if (isdigit (c))
 448     return c - '0';
 449   if (c >= 'a' && c <= 'f')
 450     return 10 + c - 'a';
 451   gdb_assert (c >= 'A' && c <= 'F');
 452   return 10 + c - 'A';
 453 }
 454
 455 \f
 456 /* Public character management functions.  */
 457
 458 /* A cleanup function which is run to close an iconv descriptor.  */
 459
 460 static void
 461 cleanup_iconv (void *p)
 462 {
 463   iconv_t *descp = p;
 464   iconv_close (*descp);
 465 }
 466
 467 void
 468 convert_between_encodings (const char *from, const char *to,
 469                            const gdb_byte *bytes, unsigned int num_bytes,
 470                            int width, struct obstack *output,
 471                            enum transliterations translit)
 472 {
 473   iconv_t desc;
 474   struct cleanup *cleanups;
 475   size_t inleft;
 476   ICONV_CONST char *inp;
 477   unsigned int space_request;
 478
 479   /* Often, the host and target charsets will be the same.  */
 480   if (!strcmp (from, to))
 481     {
 482       obstack_grow (output, bytes, num_bytes);
 483       return;
 484     }
 485
 486   desc = iconv_open (to, from);
 487   if (desc == (iconv_t) -1)
 488     perror_with_name (_("Converting character sets"));
 489   cleanups = make_cleanup (cleanup_iconv, &desc);
 490
 491   inleft = num_bytes;
 492   inp = (ICONV_CONST char *) bytes;
 493
 494   space_request = num_bytes;
 495
 496   while (inleft > 0)
 497     {
 498       char *outp;
 499       size_t outleft, r;
 500       int old_size;
 501
 502       old_size = obstack_object_size (output);
 503       obstack_blank (output, space_request);
 504
 505       outp = (char *) obstack_base (output) + old_size;
 506       outleft = space_request;
 507
 508       r = iconv (desc, &inp, &inleft, &outp, &outleft);
 509
 510       /* Now make sure that the object on the obstack only includes
 511          bytes we have converted.  */
 512       obstack_blank (output, - (int) outleft);
 513
 514       if (r == (size_t) -1)
 515         {
 516           switch (errno)
 517             {
 518             case EILSEQ:
 519               {
 520                 int i;
 521
 522                 /* Invalid input sequence.  */
 523                 if (translit == translit_none)
 524                   error (_("Could not convert character "
 525                            "to `%s' character set"), to);
 526
 527                 /* We emit escape sequence for the bytes, skip them,
 528                    and try again.  */
 529                 for (i = 0; i < width; ++i)
 530                   {
 531                     char octal[5];
 532
 533                     xsnprintf (octal, sizeof (octal), "\\%.3o", *inp & 0xff);
 534                     obstack_grow_str (output, octal);
 535
 536                     ++inp;
 537                     --inleft;
 538                   }
 539               }
 540               break;
 541
 542             case E2BIG:
 543               /* We ran out of space in the output buffer.  Make it
 544                  bigger next time around.  */
 545               space_request *= 2;
 546               break;
 547
 548             case EINVAL:
 549               /* Incomplete input sequence.  FIXME: ought to report this
 550                  to the caller somehow.  */
 551               inleft = 0;
 552               break;
 553
 554             default:
 555               perror_with_name (_("Internal error while "
 556                                   "converting character sets"));
 557             }
 558         }
 559     }
 560
 561   do_cleanups (cleanups);
 562 }
 563
 564 \f
 565
 566 /* An iterator that returns host wchar_t's from a target string.  */
 567 struct wchar_iterator
 568 {
 569   /* The underlying iconv descriptor.  */
 570   iconv_t desc;
 571
 572   /* The input string.  This is updated as convert characters.  */
 573   const gdb_byte *input;
 574   /* The number of bytes remaining in the input.  */
 575   size_t bytes;
 576
 577   /* The width of an input character.  */
 578   size_t width;
 579
 580   /* The output buffer and its size.  */
 581   gdb_wchar_t *out;
 582   size_t out_size;
 583 };
 584
 585 /* Create a new iterator.  */
 586 struct wchar_iterator *
 587 make_wchar_iterator (const gdb_byte *input, size_t bytes,
 588                      const char *charset, size_t width)
 589 {
 590   struct wchar_iterator *result;
 591   iconv_t desc;
 592
 593   desc = iconv_open (INTERMEDIATE_ENCODING, charset);
 594   if (desc == (iconv_t) -1)
 595     perror_with_name (_("Converting character sets"));
 596
 597   result = XNEW (struct wchar_iterator);
 598   result->desc = desc;
 599   result->input = input;
 600   result->bytes = bytes;
 601   result->width = width;
 602
 603   result->out = XNEW (gdb_wchar_t);
 604   result->out_size = 1;
 605
 606   return result;
 607 }
 608
 609 static void
 610 do_cleanup_iterator (void *p)
 611 {
 612   struct wchar_iterator *iter = p;
 613
 614   iconv_close (iter->desc);
 615   xfree (iter->out);
 616   xfree (iter);
 617 }
 618
 619 struct cleanup *
 620 make_cleanup_wchar_iterator (struct wchar_iterator *iter)
 621 {
 622   return make_cleanup (do_cleanup_iterator, iter);
 623 }
 624
 625 int
 626 wchar_iterate (struct wchar_iterator *iter,
 627                enum wchar_iterate_result *out_result,
 628                gdb_wchar_t **out_chars,
 629                const gdb_byte **ptr,
 630                size_t *len)
 631 {
 632   size_t out_request;
 633
 634   /* Try to convert some characters.  At first we try to convert just
 635      a single character.  The reason for this is that iconv does not
 636      necessarily update its outgoing arguments when it encounters an
 637      invalid input sequence -- but we want to reliably report this to
 638      our caller so it can emit an escape sequence.  */
 639   out_request = 1;
 640   while (iter->bytes > 0)
 641     {
 642       ICONV_CONST char *inptr = (ICONV_CONST char *) iter->input;
 643       char *outptr = (char *) &iter->out[0];
 644       const gdb_byte *orig_inptr = iter->input;
 645       size_t orig_in = iter->bytes;
 646       size_t out_avail = out_request * sizeof (gdb_wchar_t);
 647       size_t num;
 648       size_t r = iconv (iter->desc, &inptr, &iter->bytes, &outptr, &out_avail);
 649
 650       iter->input = (gdb_byte *) inptr;
 651
 652       if (r == (size_t) -1)
 653         {
 654           switch (errno)
 655             {
 656             case EILSEQ:
 657               /* Invalid input sequence.  We still might have
 658                  converted a character; if so, return it.  */
 659               if (out_avail < out_request * sizeof (gdb_wchar_t))
 660                 break;
 661
 662               /* Otherwise skip the first invalid character, and let
 663                  the caller know about it.  */
 664               *out_result = wchar_iterate_invalid;
 665               *ptr = iter->input;
 666               *len = iter->width;
 667               iter->input += iter->width;
 668               iter->bytes -= iter->width;
 669               return 0;
 670
 671             case E2BIG:
 672               /* We ran out of space.  We still might have converted a
 673                  character; if so, return it.  Otherwise, grow the
 674                  buffer and try again.  */
 675               if (out_avail < out_request * sizeof (gdb_wchar_t))
 676                 break;
 677
 678               ++out_request;
 679               if (out_request > iter->out_size)
 680                 {
 681                   iter->out_size = out_request;
 682                   iter->out = xrealloc (iter->out,
 683                                         out_request * sizeof (gdb_wchar_t));
 684                 }
 685               continue;
 686
 687             case EINVAL:
 688               /* Incomplete input sequence.  Let the caller know, and
 689                  arrange for future calls to see EOF.  */
 690               *out_result = wchar_iterate_incomplete;
 691               *ptr = iter->input;
 692               *len = iter->bytes;
 693               iter->bytes = 0;
 694               return 0;
 695
 696             default:
 697               perror_with_name (_("Internal error while "
 698                                   "converting character sets"));
 699             }
 700         }
 701
 702       /* We converted something.  */
 703       num = out_request - out_avail / sizeof (gdb_wchar_t);
 704       *out_result = wchar_iterate_ok;
 705       *out_chars = iter->out;
 706       *ptr = orig_inptr;
 707       *len = orig_in - iter->bytes;
 708       return num;
 709     }
 710
 711   /* Really done.  */
 712   *out_result = wchar_iterate_eof;
 713   return -1;
 714 }
 715
 716 \f
 717 /* The charset.c module initialization function.  */
 718
 719 extern initialize_file_ftype _initialize_charset; /* -Wmissing-prototype */
 720
 721 static VEC (char_ptr) *charsets;
 722
 723 #ifdef PHONY_ICONV
 724
 725 static void
 726 find_charset_names (void)
 727 {
 728   VEC_safe_push (char_ptr, charsets, GDB_DEFAULT_HOST_CHARSET);
 729   VEC_safe_push (char_ptr, charsets, NULL);
 730 }
 731
 732 #else /* PHONY_ICONV */
 733
 734 /* Sometimes, libiconv redefines iconvlist as libiconvlist -- but
 735    provides different symbols in the static and dynamic libraries.
 736    So, configure may see libiconvlist but not iconvlist.  But, calling
 737    iconvlist is the right thing to do and will work.  Hence we do a
 738    check here but unconditionally call iconvlist below.  */
 739 #if defined (HAVE_ICONVLIST) || defined (HAVE_LIBICONVLIST)
 740
 741 /* A helper function that adds some character sets to the vector of
 742    all character sets.  This is a callback function for iconvlist.  */
 743
 744 static int
 745 add_one (unsigned int count, const char *const *names, void *data)
 746 {
 747   unsigned int i;
 748
 749   for (i = 0; i < count; ++i)
 750     VEC_safe_push (char_ptr, charsets, xstrdup (names[i]));
 751
 752   return 0;
 753 }
 754
 755 static void
 756 find_charset_names (void)
 757 {
 758   iconvlist (add_one, NULL);
 759   VEC_safe_push (char_ptr, charsets, NULL);
 760 }
 761
 762 #else
 763
 764 /* Return non-zero if LINE (output from iconv) should be ignored.
 765    Older iconv programs (e.g. 2.2.2) include the human readable
 766    introduction even when stdout is not a tty.  Newer versions omit
 767    the intro if stdout is not a tty.  */
 768
 769 static int
 770 ignore_line_p (const char *line)
 771 {
 772   /* This table is used to filter the output.  If this text appears
 773      anywhere in the line, it is ignored (strstr is used).  */
 774   static const char * const ignore_lines[] =
 775     {
 776       "The following",
 777       "not necessarily",
 778       "the FROM and TO",
 779       "listed with several",
 780       NULL
 781     };
 782   int i;
 783
 784   for (i = 0; ignore_lines[i] != NULL; ++i)
 785     {
 786       if (strstr (line, ignore_lines[i]) != NULL)
 787         return 1;
 788     }
 789
 790   return 0;
 791 }
 792
 793 static void
 794 find_charset_names (void)
 795 {
 796   struct pex_obj *child;
 797   char *args[3];
 798   int err, status;
 799   int fail = 1;
 800   int flags;
 801   struct gdb_environ *iconv_env;
 802   char *iconv_program;
 803
 804   /* Older iconvs, e.g. 2.2.2, don't omit the intro text if stdout is
 805      not a tty.  We need to recognize it and ignore it.  This text is
 806      subject to translation, so force LANGUAGE=C.  */
 807   iconv_env = make_environ ();
 808   init_environ (iconv_env);
 809   set_in_environ (iconv_env, "LANGUAGE", "C");
 810   set_in_environ (iconv_env, "LC_ALL", "C");
 811
 812   child = pex_init (PEX_USE_PIPES, "iconv", NULL);
 813
 814 #ifdef ICONV_BIN
 815   {
 816     char *iconv_dir = relocate_gdb_directory (ICONV_BIN,
 817                                               ICONV_BIN_RELOCATABLE);
 818     iconv_program = concat (iconv_dir, SLASH_STRING, "iconv", NULL);
 819     xfree (iconv_dir);
 820   }
 821 #else
 822   iconv_program = xstrdup ("iconv");
 823 #endif
 824   args[0] = iconv_program;
 825   args[1] = "-l";
 826   args[2] = NULL;
 827   flags = PEX_STDERR_TO_STDOUT;
 828 #ifndef ICONV_BIN
 829   flags |= PEX_SEARCH;
 830 #endif
 831   /* Note that we simply ignore errors here.  */
 832   if (!pex_run_in_environment (child, flags,
 833                                args[0], args, environ_vector (iconv_env),
 834                                NULL, NULL, &err))
 835     {
 836       FILE *in = pex_read_output (child, 0);
 837
 838       /* POSIX says that iconv -l uses an unspecified format.  We
 839          parse the glibc and libiconv formats; feel free to add others
 840          as needed.  */
 841
 842       while (in != NULL && !feof (in))
 843         {
 844           /* The size of buf is chosen arbitrarily.  */
 845           char buf[1024];
 846           char *start, *r;
 847           int len;
 848
 849           r = fgets (buf, sizeof (buf), in);
 850           if (!r)
 851             break;
 852           len = strlen (r);
 853           if (len <= 3)
 854             continue;
 855           if (ignore_line_p (r))
 856             continue;
 857
 858           /* Strip off the newline.  */
 859           --len;
 860           /* Strip off one or two '/'s.  glibc will print lines like
 861              "8859_7//", but also "10646-1:1993/UCS4/".  */
 862           if (buf[len - 1] == '/')
 863             --len;
 864           if (buf[len - 1] == '/')
 865             --len;
 866           buf[len] = '\0';
 867
 868           /* libiconv will print multiple entries per line, separated
 869              by spaces.  Older iconvs will print multiple entries per
 870              line, indented by two spaces, and separated by ", "
 871              (i.e. the human readable form).  */
 872           start = buf;
 873           while (1)
 874             {
 875               int keep_going;
 876               char *p;
 877
 878               /* Skip leading blanks.  */
 879               for (p = start; *p && *p == ' '; ++p)
 880                 ;
 881               start = p;
 882               /* Find the next space, comma, or end-of-line.  */
 883               for ( ; *p && *p != ' ' && *p != ','; ++p)
 884                 ;
 885               /* Ignore an empty result.  */
 886               if (p == start)
 887                 break;
 888               keep_going = *p;
 889               *p = '\0';
 890               VEC_safe_push (char_ptr, charsets, xstrdup (start));
 891               if (!keep_going)
 892                 break;
 893               /* Skip any extra spaces.  */
 894               for (start = p + 1; *start && *start == ' '; ++start)
 895                 ;
 896             }
 897         }
 898
 899       if (pex_get_status (child, 1, &status)
 900           && WIFEXITED (status) && !WEXITSTATUS (status))
 901         fail = 0;
 902
 903     }
 904
 905   xfree (iconv_program);
 906   pex_free (child);
 907   free_environ (iconv_env);
 908
 909   if (fail)
 910     {
 911       /* Some error occurred, so drop the vector.  */
 912       free_char_ptr_vec (charsets);
 913       charsets = NULL;
 914     }
 915   else
 916     VEC_safe_push (char_ptr, charsets, NULL);
 917 }
 918
 919 #endif /* HAVE_ICONVLIST || HAVE_LIBICONVLIST */
 920 #endif /* PHONY_ICONV */
 921
 922 /* The "auto" target charset used by default_auto_charset.  */
 923 static const char *auto_target_charset_name = GDB_DEFAULT_TARGET_CHARSET;
 924
 925 const char *
 926 default_auto_charset (void)
 927 {
 928   return auto_target_charset_name;
 929 }
 930
 931 const char *
 932 default_auto_wide_charset (void)
 933 {
 934   return GDB_DEFAULT_TARGET_WIDE_CHARSET;
 935 }
 936
 937
 938 #ifdef USE_INTERMEDIATE_ENCODING_FUNCTION
 939 /* Macro used for UTF or UCS endianness suffix.  */
 940 #if WORDS_BIGENDIAN
 941 #define ENDIAN_SUFFIX "BE"
 942 #else
 943 #define ENDIAN_SUFFIX "LE"
 944 #endif
 945
 946 /* The code below serves to generate a compile time error if
 947    gdb_wchar_t type is not of size 2 nor 4, despite the fact that
 948    macro __STDC_ISO_10646__ is defined.
 949    This is better than a gdb_assert call, because GDB cannot handle
 950    strings correctly if this size is different.  */
 951
 952 extern char your_gdb_wchar_t_is_bogus[(sizeof (gdb_wchar_t) == 2
 953                                        || sizeof (gdb_wchar_t) == 4)
 954                                       ? 1 : -1];
 955
 956 /* intermediate_encoding returns the charset used internally by
 957    GDB to convert between target and host encodings. As the test above
 958    compiled, sizeof (gdb_wchar_t) is either 2 or 4 bytes.
 959    UTF-16/32 is tested first, UCS-2/4 is tested as a second option,
 960    otherwise an error is generated.  */
 961
 962 const char *
 963 intermediate_encoding (void)
 964 {
 965   iconv_t desc;
 966   static const char *stored_result = NULL;
 967   char *result;
 968
 969   if (stored_result)
 970     return stored_result;
 971   result = xstrprintf ("UTF-%d%s", (int) (sizeof (gdb_wchar_t) * 8),
 972                        ENDIAN_SUFFIX);
 973   /* Check that the name is supported by iconv_open.  */
 974   desc = iconv_open (result, host_charset ());
 975   if (desc != (iconv_t) -1)
 976     {
 977       iconv_close (desc);
 978       stored_result = result;
 979       return result;
 980     }
 981   /* Not valid, free the allocated memory.  */
 982   xfree (result);
 983   /* Second try, with UCS-2 type.  */
 984   result = xstrprintf ("UCS-%d%s", (int) sizeof (gdb_wchar_t),
 985                        ENDIAN_SUFFIX);
 986   /* Check that the name is supported by iconv_open.  */
 987   desc = iconv_open (result, host_charset ());
 988   if (desc != (iconv_t) -1)
 989     {
 990       iconv_close (desc);
 991       stored_result = result;
 992       return result;
 993     }
 994   /* Not valid, free the allocated memory.  */
 995   xfree (result);
 996   /* No valid charset found, generate error here.  */
 997   error (_("Unable to find a vaild charset for string conversions"));
 998 }
 999
1000 #endif /* USE_INTERMEDIATE_ENCODING_FUNCTION */
1001
1002 void
1003 _initialize_charset (void)
1004 {
1005   /* The first element is always "auto".  */
1006   VEC_safe_push (char_ptr, charsets, xstrdup ("auto"));
1007   find_charset_names ();
1008
1009   if (VEC_length (char_ptr, charsets) > 1)
1010     charset_enum = (const char **) VEC_address (char_ptr, charsets);
1011   else
1012     charset_enum = default_charset_names;
1013
1014 #ifndef PHONY_ICONV
1015 #ifdef HAVE_LANGINFO_CODESET
1016   /* The result of nl_langinfo may be overwritten later.  This may
1017      leak a little memory, if the user later changes the host charset,
1018      but that doesn't matter much.  */
1019   auto_host_charset_name = xstrdup (nl_langinfo (CODESET));
1020   /* Solaris will return `646' here -- but the Solaris iconv then does
1021      not accept this.  Darwin (and maybe FreeBSD) may return "" here,
1022      which GNU libiconv doesn't like (infinite loop).  */
1023   if (!strcmp (auto_host_charset_name, "646") || !*auto_host_charset_name)
1024     auto_host_charset_name = "ASCII";
1025   auto_target_charset_name = auto_host_charset_name;
1026 #elif defined (USE_WIN32API)
1027   {
1028     /* "CP" + x<=5 digits + paranoia.  */
1029     static char w32_host_default_charset[16];
1030
1031     snprintf (w32_host_default_charset, sizeof w32_host_default_charset,
1032               "CP%d", GetACP());
1033     auto_host_charset_name = w32_host_default_charset;
1034     auto_target_charset_name = auto_host_charset_name;
1035   }
1036 #endif
1037 #endif
1038
1039   add_setshow_enum_cmd ("charset", class_support,
1040                         charset_enum, &host_charset_name, _("\
1041 Set the host and target character sets."), _("\
1042 Show the host and target character sets."), _("\
1043 The `host character set' is the one used by the system GDB is running on.\n\
1044 The `target character set' is the one used by the program being debugged.\n\
1045 You may only use supersets of ASCII for your host character set; GDB does\n\
1046 not support any others.\n\
1047 To see a list of the character sets GDB supports, type `set charset <TAB>'."),
1048                         /* Note that the sfunc below needs to set
1049                            target_charset_name, because the 'set
1050                            charset' command sets two variables.  */
1051                         set_charset_sfunc,
1052                         show_charset,
1053                         &setlist, &showlist);
1054
1055   add_setshow_enum_cmd ("host-charset", class_support,
1056                         charset_enum, &host_charset_name, _("\
1057 Set the host character set."), _("\
1058 Show the host character set."), _("\
1059 The `host character set' is the one used by the system GDB is running on.\n\
1060 You may only use supersets of ASCII for your host character set; GDB does\n\
1061 not support any others.\n\
1062 To see a list of the character sets GDB supports, type `set host-charset <TAB>'."),
1063                         set_host_charset_sfunc,
1064                         show_host_charset_name,
1065                         &setlist, &showlist);
1066
1067   add_setshow_enum_cmd ("target-charset", class_support,
1068                         charset_enum, &target_charset_name, _("\
1069 Set the target character set."), _("\
1070 Show the target character set."), _("\
1071 The `target character set' is the one used by the program being debugged.\n\
1072 GDB translates characters and strings between the host and target\n\
1073 character sets as needed.\n\
1074 To see a list of the character sets GDB supports, type `set target-charset'<TAB>"),
1075                         set_target_charset_sfunc,
1076                         show_target_charset_name,
1077                         &setlist, &showlist);
1078
1079   add_setshow_enum_cmd ("target-wide-charset", class_support,
1080                         charset_enum, &target_wide_charset_name,
1081                         _("\
1082 Set the target wide character set."), _("\
1083 Show the target wide character set."), _("\
1084 The `target wide character set' is the one used by the program being debugged.\
1085 \nIn particular it is the encoding used by `wchar_t'.\n\
1086 GDB translates characters and strings between the host and target\n\
1087 character sets as needed.\n\
1088 To see a list of the character sets GDB supports, type\n\
1089 `set target-wide-charset'<TAB>"),
1090                         set_target_wide_charset_sfunc,
1091                         show_target_wide_charset_name,
1092                         &setlist, &showlist);
1093 }