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