1 /* Character set conversion support for GDB. 2 3 Copyright (C) 2001-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "charset.h" 22 #include "gdbcmd.h" 23 #include "gdb_assert.h" 24 #include "gdb_obstack.h" 25 #include "gdb_wait.h" 26 #include "charset-list.h" 27 #include "vec.h" 28 #include "environ.h" 29 #include "arch-utils.h" 30 #include "gdb_vecs.h" 31 32 #include <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 111 static iconv_t 112 phony_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 127 static int 128 phony_iconv_close (iconv_t arg) 129 { 130 return 0; 131 } 132 133 static size_t 134 phony_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 209 static const char *auto_host_charset_name = GDB_DEFAULT_HOST_CHARSET; 210 static const char *host_charset_name = "auto"; 211 static void 212 show_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 224 static const char *target_charset_name = "auto"; 225 static void 226 show_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 239 static const char *target_wide_charset_name = "auto"; 240 static void 241 show_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 256 static const char *default_charset_names[] = 257 { 258 DEFAULT_CHARSET_NAMES 259 0 260 }; 261 262 static 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. */ 267 static const char *target_wide_charset_be_name; 268 static const char *target_wide_charset_le_name; 269 270 /* The architecture for which the BE- and LE-names are valid. */ 271 static 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 276 static void 277 set_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 314 static void 315 validate (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. */ 342 static void 343 set_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. */ 353 static void 354 set_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. */ 361 static void 362 set_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. */ 369 static void 370 set_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. */ 377 static void 378 show_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 391 const char * 392 host_charset (void) 393 { 394 if (!strcmp (host_charset_name, "auto")) 395 return auto_host_charset_name; 396 return host_charset_name; 397 } 398 399 const char * 400 target_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 407 const char * 408 target_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 434 char 435 host_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 445 int 446 host_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 461 static void 462 cleanup_iconv (void *p) 463 { 464 iconv_t *descp = p; 465 iconv_close (*descp); 466 } 467 468 void 469 convert_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 ICONV_CONST 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 = (ICONV_CONST 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, &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 xsnprintf (octal, sizeof (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. */ 568 struct wchar_iterator 569 { 570 /* The underlying iconv descriptor. */ 571 iconv_t desc; 572 573 /* The input string. This is updated as convert characters. */ 574 const gdb_byte *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. */ 587 struct wchar_iterator * 588 make_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 = 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 610 static void 611 do_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 620 struct cleanup * 621 make_cleanup_wchar_iterator (struct wchar_iterator *iter) 622 { 623 return make_cleanup (do_cleanup_iterator, iter); 624 } 625 626 int 627 wchar_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 ICONV_CONST char *inptr = (ICONV_CONST char *) iter->input; 644 char *outptr = (char *) &iter->out[0]; 645 const gdb_byte *orig_inptr = iter->input; 646 size_t orig_in = iter->bytes; 647 size_t out_avail = out_request * sizeof (gdb_wchar_t); 648 size_t num; 649 size_t r = iconv (iter->desc, &inptr, &iter->bytes, &outptr, &out_avail); 650 651 iter->input = (gdb_byte *) inptr; 652 653 if (r == (size_t) -1) 654 { 655 switch (errno) 656 { 657 case EILSEQ: 658 /* Invalid input sequence. We still might have 659 converted a character; if so, return it. */ 660 if (out_avail < out_request * sizeof (gdb_wchar_t)) 661 break; 662 663 /* Otherwise skip the first invalid character, and let 664 the caller know about it. */ 665 *out_result = wchar_iterate_invalid; 666 *ptr = iter->input; 667 *len = iter->width; 668 iter->input += iter->width; 669 iter->bytes -= iter->width; 670 return 0; 671 672 case E2BIG: 673 /* We ran out of space. We still might have converted a 674 character; if so, return it. Otherwise, grow the 675 buffer and try again. */ 676 if (out_avail < out_request * sizeof (gdb_wchar_t)) 677 break; 678 679 ++out_request; 680 if (out_request > iter->out_size) 681 { 682 iter->out_size = out_request; 683 iter->out = xrealloc (iter->out, 684 out_request * sizeof (gdb_wchar_t)); 685 } 686 continue; 687 688 case EINVAL: 689 /* Incomplete input sequence. Let the caller know, and 690 arrange for future calls to see EOF. */ 691 *out_result = wchar_iterate_incomplete; 692 *ptr = iter->input; 693 *len = iter->bytes; 694 iter->bytes = 0; 695 return 0; 696 697 default: 698 perror_with_name (_("Internal error while " 699 "converting character sets")); 700 } 701 } 702 703 /* We converted something. */ 704 num = out_request - out_avail / sizeof (gdb_wchar_t); 705 *out_result = wchar_iterate_ok; 706 *out_chars = iter->out; 707 *ptr = orig_inptr; 708 *len = orig_in - iter->bytes; 709 return num; 710 } 711 712 /* Really done. */ 713 *out_result = wchar_iterate_eof; 714 return -1; 715 } 716 717 718 /* The charset.c module initialization function. */ 719 720 extern initialize_file_ftype _initialize_charset; /* -Wmissing-prototype */ 721 722 static VEC (char_ptr) *charsets; 723 724 #ifdef PHONY_ICONV 725 726 static void 727 find_charset_names (void) 728 { 729 VEC_safe_push (char_ptr, charsets, GDB_DEFAULT_HOST_CHARSET); 730 VEC_safe_push (char_ptr, charsets, NULL); 731 } 732 733 #else /* PHONY_ICONV */ 734 735 /* Sometimes, libiconv redefines iconvlist as libiconvlist -- but 736 provides different symbols in the static and dynamic libraries. 737 So, configure may see libiconvlist but not iconvlist. But, calling 738 iconvlist is the right thing to do and will work. Hence we do a 739 check here but unconditionally call iconvlist below. */ 740 #if defined (HAVE_ICONVLIST) || defined (HAVE_LIBICONVLIST) 741 742 /* A helper function that adds some character sets to the vector of 743 all character sets. This is a callback function for iconvlist. */ 744 745 static int 746 add_one (unsigned int count, const char *const *names, void *data) 747 { 748 unsigned int i; 749 750 for (i = 0; i < count; ++i) 751 VEC_safe_push (char_ptr, charsets, xstrdup (names[i])); 752 753 return 0; 754 } 755 756 static void 757 find_charset_names (void) 758 { 759 iconvlist (add_one, NULL); 760 VEC_safe_push (char_ptr, charsets, NULL); 761 } 762 763 #else 764 765 /* Return non-zero if LINE (output from iconv) should be ignored. 766 Older iconv programs (e.g. 2.2.2) include the human readable 767 introduction even when stdout is not a tty. Newer versions omit 768 the intro if stdout is not a tty. */ 769 770 static int 771 ignore_line_p (const char *line) 772 { 773 /* This table is used to filter the output. If this text appears 774 anywhere in the line, it is ignored (strstr is used). */ 775 static const char * const ignore_lines[] = 776 { 777 "The following", 778 "not necessarily", 779 "the FROM and TO", 780 "listed with several", 781 NULL 782 }; 783 int i; 784 785 for (i = 0; ignore_lines[i] != NULL; ++i) 786 { 787 if (strstr (line, ignore_lines[i]) != NULL) 788 return 1; 789 } 790 791 return 0; 792 } 793 794 static void 795 find_charset_names (void) 796 { 797 struct pex_obj *child; 798 char *args[3]; 799 int err, status; 800 int fail = 1; 801 int flags; 802 struct gdb_environ *iconv_env; 803 char *iconv_program; 804 805 /* Older iconvs, e.g. 2.2.2, don't omit the intro text if stdout is 806 not a tty. We need to recognize it and ignore it. This text is 807 subject to translation, so force LANGUAGE=C. */ 808 iconv_env = make_environ (); 809 init_environ (iconv_env); 810 set_in_environ (iconv_env, "LANGUAGE", "C"); 811 set_in_environ (iconv_env, "LC_ALL", "C"); 812 813 child = pex_init (PEX_USE_PIPES, "iconv", NULL); 814 815 #ifdef ICONV_BIN 816 { 817 char *iconv_dir = relocate_gdb_directory (ICONV_BIN, 818 ICONV_BIN_RELOCATABLE); 819 iconv_program = concat (iconv_dir, SLASH_STRING, "iconv", NULL); 820 xfree (iconv_dir); 821 } 822 #else 823 iconv_program = xstrdup ("iconv"); 824 #endif 825 args[0] = iconv_program; 826 args[1] = "-l"; 827 args[2] = NULL; 828 flags = PEX_STDERR_TO_STDOUT; 829 #ifndef ICONV_BIN 830 flags |= PEX_SEARCH; 831 #endif 832 /* Note that we simply ignore errors here. */ 833 if (!pex_run_in_environment (child, flags, 834 args[0], args, environ_vector (iconv_env), 835 NULL, NULL, &err)) 836 { 837 FILE *in = pex_read_output (child, 0); 838 839 /* POSIX says that iconv -l uses an unspecified format. We 840 parse the glibc and libiconv formats; feel free to add others 841 as needed. */ 842 843 while (in != NULL && !feof (in)) 844 { 845 /* The size of buf is chosen arbitrarily. */ 846 char buf[1024]; 847 char *start, *r; 848 int len; 849 850 r = fgets (buf, sizeof (buf), in); 851 if (!r) 852 break; 853 len = strlen (r); 854 if (len <= 3) 855 continue; 856 if (ignore_line_p (r)) 857 continue; 858 859 /* Strip off the newline. */ 860 --len; 861 /* Strip off one or two '/'s. glibc will print lines like 862 "8859_7//", but also "10646-1:1993/UCS4/". */ 863 if (buf[len - 1] == '/') 864 --len; 865 if (buf[len - 1] == '/') 866 --len; 867 buf[len] = '\0'; 868 869 /* libiconv will print multiple entries per line, separated 870 by spaces. Older iconvs will print multiple entries per 871 line, indented by two spaces, and separated by ", " 872 (i.e. the human readable form). */ 873 start = buf; 874 while (1) 875 { 876 int keep_going; 877 char *p; 878 879 /* Skip leading blanks. */ 880 for (p = start; *p && *p == ' '; ++p) 881 ; 882 start = p; 883 /* Find the next space, comma, or end-of-line. */ 884 for ( ; *p && *p != ' ' && *p != ','; ++p) 885 ; 886 /* Ignore an empty result. */ 887 if (p == start) 888 break; 889 keep_going = *p; 890 *p = '\0'; 891 VEC_safe_push (char_ptr, charsets, xstrdup (start)); 892 if (!keep_going) 893 break; 894 /* Skip any extra spaces. */ 895 for (start = p + 1; *start && *start == ' '; ++start) 896 ; 897 } 898 } 899 900 if (pex_get_status (child, 1, &status) 901 && WIFEXITED (status) && !WEXITSTATUS (status)) 902 fail = 0; 903 904 } 905 906 xfree (iconv_program); 907 pex_free (child); 908 free_environ (iconv_env); 909 910 if (fail) 911 { 912 /* Some error occurred, so drop the vector. */ 913 free_char_ptr_vec (charsets); 914 charsets = NULL; 915 } 916 else 917 VEC_safe_push (char_ptr, charsets, NULL); 918 } 919 920 #endif /* HAVE_ICONVLIST || HAVE_LIBICONVLIST */ 921 #endif /* PHONY_ICONV */ 922 923 /* The "auto" target charset used by default_auto_charset. */ 924 static const char *auto_target_charset_name = GDB_DEFAULT_TARGET_CHARSET; 925 926 const char * 927 default_auto_charset (void) 928 { 929 return auto_target_charset_name; 930 } 931 932 const char * 933 default_auto_wide_charset (void) 934 { 935 return GDB_DEFAULT_TARGET_WIDE_CHARSET; 936 } 937 938 939 #ifdef USE_INTERMEDIATE_ENCODING_FUNCTION 940 /* Macro used for UTF or UCS endianness suffix. */ 941 #if WORDS_BIGENDIAN 942 #define ENDIAN_SUFFIX "BE" 943 #else 944 #define ENDIAN_SUFFIX "LE" 945 #endif 946 947 /* The code below serves to generate a compile time error if 948 gdb_wchar_t type is not of size 2 nor 4, despite the fact that 949 macro __STDC_ISO_10646__ is defined. 950 This is better than a gdb_assert call, because GDB cannot handle 951 strings correctly if this size is different. */ 952 953 extern char your_gdb_wchar_t_is_bogus[(sizeof (gdb_wchar_t) == 2 954 || sizeof (gdb_wchar_t) == 4) 955 ? 1 : -1]; 956 957 /* intermediate_encoding returns the charset unsed internally by 958 GDB to convert between target and host encodings. As the test above 959 compiled, sizeof (gdb_wchar_t) is either 2 or 4 bytes. 960 UTF-16/32 is tested first, UCS-2/4 is tested as a second option, 961 otherwise an error is generated. */ 962 963 const char * 964 intermediate_encoding (void) 965 { 966 iconv_t desc; 967 static const char *stored_result = NULL; 968 char *result; 969 970 if (stored_result) 971 return stored_result; 972 result = xstrprintf ("UTF-%d%s", (int) (sizeof (gdb_wchar_t) * 8), 973 ENDIAN_SUFFIX); 974 /* Check that the name is supported by iconv_open. */ 975 desc = iconv_open (result, host_charset ()); 976 if (desc != (iconv_t) -1) 977 { 978 iconv_close (desc); 979 stored_result = result; 980 return result; 981 } 982 /* Not valid, free the allocated memory. */ 983 xfree (result); 984 /* Second try, with UCS-2 type. */ 985 result = xstrprintf ("UCS-%d%s", (int) sizeof (gdb_wchar_t), 986 ENDIAN_SUFFIX); 987 /* Check that the name is supported by iconv_open. */ 988 desc = iconv_open (result, host_charset ()); 989 if (desc != (iconv_t) -1) 990 { 991 iconv_close (desc); 992 stored_result = result; 993 return result; 994 } 995 /* Not valid, free the allocated memory. */ 996 xfree (result); 997 /* No valid charset found, generate error here. */ 998 error (_("Unable to find a vaild charset for string conversions")); 999 } 1000 1001 #endif /* USE_INTERMEDIATE_ENCODING_FUNCTION */ 1002 1003 void 1004 _initialize_charset (void) 1005 { 1006 /* The first element is always "auto". */ 1007 VEC_safe_push (char_ptr, charsets, xstrdup ("auto")); 1008 find_charset_names (); 1009 1010 if (VEC_length (char_ptr, charsets) > 1) 1011 charset_enum = (const char **) VEC_address (char_ptr, charsets); 1012 else 1013 charset_enum = default_charset_names; 1014 1015 #ifndef PHONY_ICONV 1016 #ifdef HAVE_LANGINFO_CODESET 1017 /* The result of nl_langinfo may be overwritten later. This may 1018 leak a little memory, if the user later changes the host charset, 1019 but that doesn't matter much. */ 1020 auto_host_charset_name = xstrdup (nl_langinfo (CODESET)); 1021 /* Solaris will return `646' here -- but the Solaris iconv then does 1022 not accept this. Darwin (and maybe FreeBSD) may return "" here, 1023 which GNU libiconv doesn't like (infinite loop). */ 1024 if (!strcmp (auto_host_charset_name, "646") || !*auto_host_charset_name) 1025 auto_host_charset_name = "ASCII"; 1026 auto_target_charset_name = auto_host_charset_name; 1027 #elif defined (USE_WIN32API) 1028 { 1029 /* "CP" + x<=5 digits + paranoia. */ 1030 static char w32_host_default_charset[16]; 1031 1032 snprintf (w32_host_default_charset, sizeof w32_host_default_charset, 1033 "CP%d", GetACP()); 1034 auto_host_charset_name = w32_host_default_charset; 1035 auto_target_charset_name = auto_host_charset_name; 1036 } 1037 #endif 1038 #endif 1039 1040 add_setshow_enum_cmd ("charset", class_support, 1041 charset_enum, &host_charset_name, _("\ 1042 Set the host and target character sets."), _("\ 1043 Show the host and target character sets."), _("\ 1044 The `host character set' is the one used by the system GDB is running on.\n\ 1045 The `target character set' is the one used by the program being debugged.\n\ 1046 You may only use supersets of ASCII for your host character set; GDB does\n\ 1047 not support any others.\n\ 1048 To see a list of the character sets GDB supports, type `set charset <TAB>'."), 1049 /* Note that the sfunc below needs to set 1050 target_charset_name, because the 'set 1051 charset' command sets two variables. */ 1052 set_charset_sfunc, 1053 show_charset, 1054 &setlist, &showlist); 1055 1056 add_setshow_enum_cmd ("host-charset", class_support, 1057 charset_enum, &host_charset_name, _("\ 1058 Set the host character set."), _("\ 1059 Show the host character set."), _("\ 1060 The `host character set' is the one used by the system GDB is running on.\n\ 1061 You may only use supersets of ASCII for your host character set; GDB does\n\ 1062 not support any others.\n\ 1063 To see a list of the character sets GDB supports, type `set host-charset <TAB>'."), 1064 set_host_charset_sfunc, 1065 show_host_charset_name, 1066 &setlist, &showlist); 1067 1068 add_setshow_enum_cmd ("target-charset", class_support, 1069 charset_enum, &target_charset_name, _("\ 1070 Set the target character set."), _("\ 1071 Show the target character set."), _("\ 1072 The `target character set' is the one used by the program being debugged.\n\ 1073 GDB translates characters and strings between the host and target\n\ 1074 character sets as needed.\n\ 1075 To see a list of the character sets GDB supports, type `set target-charset'<TAB>"), 1076 set_target_charset_sfunc, 1077 show_target_charset_name, 1078 &setlist, &showlist); 1079 1080 add_setshow_enum_cmd ("target-wide-charset", class_support, 1081 charset_enum, &target_wide_charset_name, 1082 _("\ 1083 Set the target wide character set."), _("\ 1084 Show the target wide character set."), _("\ 1085 The `target wide character set' is the one used by the program being debugged.\ 1086 \nIn particular it is the encoding used by `wchar_t'.\n\ 1087 GDB translates characters and strings between the host and target\n\ 1088 character sets as needed.\n\ 1089 To see a list of the character sets GDB supports, type\n\ 1090 `set target-wide-charset'<TAB>"), 1091 set_target_wide_charset_sfunc, 1092 show_target_wide_charset_name, 1093 &setlist, &showlist); 1094 } 1095