gdb/charset.c

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