gdb/charset.c

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