1 /* Character set conversion support for GDB.
3 Copyright (C) 2001-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "gdb_assert.h"
24 #include "gdb_obstack.h"
26 #include "charset-list.h"
29 #include "arch-utils.h"
40 /* How GDB's character set support works
42 GDB has three global settings:
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
49 - The `current target character set' is the character set the
50 program being debugged uses.
52 - The `current target wide character set' is the wide character set
53 the program being debugged uses, that is, the encoding used for
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
61 The header file `charset.h' declares various functions that
62 different pieces of GDB need to perform tasks like:
64 - printing target strings and characters to the user's terminal
65 (mostly target->host conversions),
67 - building target-appropriate representations of strings and
68 characters the user enters in expressions (mostly host->target
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. */
80 /* Provide a phony iconv that does as little as possible. Also,
81 arrange for there to be a single available character set. */
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 ,
93 #define iconv_open phony_iconv_open
95 #define iconv phony_iconv
97 #define iconv_close phony_iconv_close
100 #define ICONV_CONST const
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. */
108 #define EILSEQ ENOENT
112 phony_iconv_open (const char *to, const char *from)
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))
119 if (strcmp (to, "wchar_t") && strcmp (to, GDB_DEFAULT_HOST_CHARSET))
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");
128 phony_iconv_close (iconv_t arg)
134 phony_iconv (iconv_t utf_flag, const char **inbuf, size_t *inbytesleft,
135 char **outbuf, size_t *outbytesleft)
139 while (*inbytesleft >= 4)
144 for (j = 0; j < 4; ++j)
147 c += (*inbuf)[j] & 0xff;
162 if (*inbytesleft < 4)
170 /* In all other cases we simply copy input bytes to the
172 size_t amt = *inbytesleft;
174 if (amt > *outbytesleft)
176 memcpy (*outbuf, *inbuf, amt);
180 *outbytesleft -= amt;
189 /* The number of non-reversible conversions -- but they were all
198 /* The global lists of character sets and translations. */
201 #ifndef GDB_DEFAULT_TARGET_CHARSET
202 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
205 #ifndef GDB_DEFAULT_TARGET_WIDE_CHARSET
206 #define GDB_DEFAULT_TARGET_WIDE_CHARSET "UTF-32"
209 static const char *auto_host_charset_name = GDB_DEFAULT_HOST_CHARSET;
210 static const char *host_charset_name = "auto";
212 show_host_charset_name (struct ui_file *file, int from_tty,
213 struct cmd_list_element *c,
216 if (!strcmp (value, "auto"))
217 fprintf_filtered (file,
218 _("The host character set is \"auto; currently %s\".\n"),
219 auto_host_charset_name);
221 fprintf_filtered (file, _("The host character set is \"%s\".\n"), value);
224 static const char *target_charset_name = "auto";
226 show_target_charset_name (struct ui_file *file, int from_tty,
227 struct cmd_list_element *c, const char *value)
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 ()));
235 fprintf_filtered (file, _("The target character set is \"%s\".\n"),
239 static const char *target_wide_charset_name = "auto";
241 show_target_wide_charset_name (struct ui_file *file,
243 struct cmd_list_element *c,
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 ()));
252 fprintf_filtered (file, _("The target wide character set is \"%s\".\n"),
256 static const char *default_charset_names[] =
258 DEFAULT_CHARSET_NAMES
262 static const char **charset_enum;
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;
270 /* The architecture for which the BE- and LE-names are valid. */
271 static struct gdbarch *be_le_arch;
273 /* A helper function which sets the target wide big- and little-endian
274 character set names, if possible. */
277 set_be_le_names (struct gdbarch *gdbarch)
280 const char *target_wide;
282 if (be_le_arch == gdbarch)
284 be_le_arch = gdbarch;
286 target_wide_charset_le_name = NULL;
287 target_wide_charset_be_name = NULL;
289 target_wide = target_wide_charset_name;
290 if (!strcmp (target_wide, "auto"))
291 target_wide = gdbarch_auto_wide_charset (gdbarch);
293 len = strlen (target_wide);
294 for (i = 0; charset_enum[i]; ++i)
296 if (strncmp (target_wide, charset_enum[i], len))
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')
303 if (charset_enum[i][len] == 'B')
304 target_wide_charset_be_name = charset_enum[i];
306 target_wide_charset_le_name = charset_enum[i];
311 /* 'Set charset', 'set host-charset', 'set target-charset', 'set
312 target-wide-charset', 'set charset' sfunc's. */
315 validate (struct gdbarch *gdbarch)
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;
322 if (!strcmp (target_wide_cset, "auto"))
323 target_wide_cset = gdbarch_auto_wide_charset (gdbarch);
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);
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);
337 /* Clear the cache. */
341 /* This is the sfunc for the 'set charset' command. */
343 set_charset_sfunc (char *charset, int from_tty,
344 struct cmd_list_element *c)
346 /* CAREFUL: set the target charset here as well. */
347 target_charset_name = host_charset_name;
348 validate (get_current_arch ());
351 /* 'set host-charset' command sfunc. We need a wrapper here because
352 the function needs to have a specific signature. */
354 set_host_charset_sfunc (char *charset, int from_tty,
355 struct cmd_list_element *c)
357 validate (get_current_arch ());
360 /* Wrapper for the 'set target-charset' command. */
362 set_target_charset_sfunc (char *charset, int from_tty,
363 struct cmd_list_element *c)
365 validate (get_current_arch ());
368 /* Wrapper for the 'set target-wide-charset' command. */
370 set_target_wide_charset_sfunc (char *charset, int from_tty,
371 struct cmd_list_element *c)
373 validate (get_current_arch ());
376 /* sfunc for the 'show charset' command. */
378 show_charset (struct ui_file *file, int from_tty,
379 struct cmd_list_element *c,
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);
389 /* Accessor functions. */
394 if (!strcmp (host_charset_name, "auto"))
395 return auto_host_charset_name;
396 return host_charset_name;
400 target_charset (struct gdbarch *gdbarch)
402 if (!strcmp (target_charset_name, "auto"))
403 return gdbarch_auto_charset (gdbarch);
404 return target_charset_name;
408 target_wide_charset (struct gdbarch *gdbarch)
410 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
412 set_be_le_names (gdbarch);
413 if (byte_order == BFD_ENDIAN_BIG)
415 if (target_wide_charset_be_name)
416 return target_wide_charset_be_name;
420 if (target_wide_charset_le_name)
421 return target_wide_charset_le_name;
424 if (!strcmp (target_wide_charset_name, "auto"))
425 return gdbarch_auto_wide_charset (gdbarch);
427 return target_wide_charset_name;
431 /* Host character set management. For the time being, we assume that
432 the host character set is some superset of ASCII. */
435 host_letter_to_control_character (char c)
442 /* Convert a host character, C, to its hex value. C must already have
443 been validated using isxdigit. */
446 host_hex_value (char c)
450 if (c >= 'a' && c <= 'f')
452 gdb_assert (c >= 'A' && c <= 'F');
457 /* Public character management functions. */
459 /* A cleanup function which is run to close an iconv descriptor. */
462 cleanup_iconv (void *p)
465 iconv_close (*descp);
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)
475 struct cleanup *cleanups;
477 ICONV_CONST char *inp;
478 unsigned int space_request;
480 /* Often, the host and target charsets will be the same. */
481 if (!strcmp (from, to))
483 obstack_grow (output, bytes, num_bytes);
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);
493 inp = (ICONV_CONST char *) bytes;
495 space_request = num_bytes;
503 old_size = obstack_object_size (output);
504 obstack_blank (output, space_request);
506 outp = obstack_base (output) + old_size;
507 outleft = space_request;
509 r = iconv (desc, &inp, &inleft, &outp, &outleft);
511 /* Now make sure that the object on the obstack only includes
512 bytes we have converted. */
513 obstack_blank (output, - (int) outleft);
515 if (r == (size_t) -1)
523 /* Invalid input sequence. */
524 if (translit == translit_none)
525 error (_("Could not convert character "
526 "to `%s' character set"), to);
528 /* We emit escape sequence for the bytes, skip them,
530 for (i = 0; i < width; ++i)
534 xsnprintf (octal, sizeof (octal), "\\%.3o", *inp & 0xff);
535 obstack_grow_str (output, octal);
544 /* We ran out of space in the output buffer. Make it
545 bigger next time around. */
550 /* Incomplete input sequence. FIXME: ought to report this
551 to the caller somehow. */
556 perror_with_name (_("Internal error while "
557 "converting character sets"));
562 do_cleanups (cleanups);
567 /* An iterator that returns host wchar_t's from a target string. */
568 struct wchar_iterator
570 /* The underlying iconv descriptor. */
573 /* The input string. This is updated as convert characters. */
574 const gdb_byte *input;
575 /* The number of bytes remaining in the input. */
578 /* The width of an input character. */
581 /* The output buffer and its size. */
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)
591 struct wchar_iterator *result;
594 desc = iconv_open (INTERMEDIATE_ENCODING, charset);
595 if (desc == (iconv_t) -1)
596 perror_with_name (_("Converting character sets"));
598 result = XNEW (struct wchar_iterator);
600 result->input = input;
601 result->bytes = bytes;
602 result->width = width;
604 result->out = XNEW (gdb_wchar_t);
605 result->out_size = 1;
611 do_cleanup_iterator (void *p)
613 struct wchar_iterator *iter = p;
615 iconv_close (iter->desc);
621 make_cleanup_wchar_iterator (struct wchar_iterator *iter)
623 return make_cleanup (do_cleanup_iterator, iter);
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,
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. */
641 while (iter->bytes > 0)
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);
649 size_t r = iconv (iter->desc, &inptr, &iter->bytes, &outptr, &out_avail);
651 iter->input = (gdb_byte *) inptr;
653 if (r == (size_t) -1)
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))
663 /* Otherwise skip the first invalid character, and let
664 the caller know about it. */
665 *out_result = wchar_iterate_invalid;
668 iter->input += iter->width;
669 iter->bytes -= iter->width;
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))
680 if (out_request > iter->out_size)
682 iter->out_size = out_request;
683 iter->out = xrealloc (iter->out,
684 out_request * sizeof (gdb_wchar_t));
689 /* Incomplete input sequence. Let the caller know, and
690 arrange for future calls to see EOF. */
691 *out_result = wchar_iterate_incomplete;
698 perror_with_name (_("Internal error while "
699 "converting character sets"));
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;
708 *len = orig_in - iter->bytes;
713 *out_result = wchar_iterate_eof;
718 /* The charset.c module initialization function. */
720 extern initialize_file_ftype _initialize_charset; /* -Wmissing-prototype */
722 static VEC (char_ptr) *charsets;
727 find_charset_names (void)
729 VEC_safe_push (char_ptr, charsets, GDB_DEFAULT_HOST_CHARSET);
730 VEC_safe_push (char_ptr, charsets, NULL);
733 #else /* PHONY_ICONV */
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)
742 /* A helper function that adds some character sets to the vector of
743 all character sets. This is a callback function for iconvlist. */
746 add_one (unsigned int count, const char *const *names, void *data)
750 for (i = 0; i < count; ++i)
751 VEC_safe_push (char_ptr, charsets, xstrdup (names[i]));
757 find_charset_names (void)
759 iconvlist (add_one, NULL);
760 VEC_safe_push (char_ptr, charsets, NULL);
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. */
771 ignore_line_p (const char *line)
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[] =
780 "listed with several",
785 for (i = 0; ignore_lines[i] != NULL; ++i)
787 if (strstr (line, ignore_lines[i]) != NULL)
795 find_charset_names (void)
797 struct pex_obj *child;
802 struct gdb_environ *iconv_env;
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");
813 child = pex_init (PEX_USE_PIPES, "iconv", NULL);
817 char *iconv_dir = relocate_gdb_directory (ICONV_BIN,
818 ICONV_BIN_RELOCATABLE);
819 iconv_program = concat (iconv_dir, SLASH_STRING, "iconv", NULL);
823 iconv_program = xstrdup ("iconv");
825 args[0] = iconv_program;
828 flags = PEX_STDERR_TO_STDOUT;
832 /* Note that we simply ignore errors here. */
833 if (!pex_run_in_environment (child, flags,
834 args[0], args, environ_vector (iconv_env),
837 FILE *in = pex_read_output (child, 0);
839 /* POSIX says that iconv -l uses an unspecified format. We
840 parse the glibc and libiconv formats; feel free to add others
843 while (in != NULL && !feof (in))
845 /* The size of buf is chosen arbitrarily. */
850 r = fgets (buf, sizeof (buf), in);
856 if (ignore_line_p (r))
859 /* Strip off the newline. */
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] == '/')
865 if (buf[len - 1] == '/')
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). */
879 /* Skip leading blanks. */
880 for (p = start; *p && *p == ' '; ++p)
883 /* Find the next space, comma, or end-of-line. */
884 for ( ; *p && *p != ' ' && *p != ','; ++p)
886 /* Ignore an empty result. */
891 VEC_safe_push (char_ptr, charsets, xstrdup (start));
894 /* Skip any extra spaces. */
895 for (start = p + 1; *start && *start == ' '; ++start)
900 if (pex_get_status (child, 1, &status)
901 && WIFEXITED (status) && !WEXITSTATUS (status))
906 xfree (iconv_program);
908 free_environ (iconv_env);
912 /* Some error occurred, so drop the vector. */
913 free_char_ptr_vec (charsets);
917 VEC_safe_push (char_ptr, charsets, NULL);
920 #endif /* HAVE_ICONVLIST || HAVE_LIBICONVLIST */
921 #endif /* PHONY_ICONV */
923 /* The "auto" target charset used by default_auto_charset. */
924 static const char *auto_target_charset_name = GDB_DEFAULT_TARGET_CHARSET;
927 default_auto_charset (void)
929 return auto_target_charset_name;
933 default_auto_wide_charset (void)
935 return GDB_DEFAULT_TARGET_WIDE_CHARSET;
939 #ifdef USE_INTERMEDIATE_ENCODING_FUNCTION
940 /* Macro used for UTF or UCS endianness suffix. */
942 #define ENDIAN_SUFFIX "BE"
944 #define ENDIAN_SUFFIX "LE"
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. */
953 extern char your_gdb_wchar_t_is_bogus[(sizeof (gdb_wchar_t) == 2
954 || sizeof (gdb_wchar_t) == 4)
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. */
964 intermediate_encoding (void)
967 static const char *stored_result = NULL;
971 return stored_result;
972 result = xstrprintf ("UTF-%d%s", (int) (sizeof (gdb_wchar_t) * 8),
974 /* Check that the name is supported by iconv_open. */
975 desc = iconv_open (result, host_charset ());
976 if (desc != (iconv_t) -1)
979 stored_result = result;
982 /* Not valid, free the allocated memory. */
984 /* Second try, with UCS-2 type. */
985 result = xstrprintf ("UCS-%d%s", (int) sizeof (gdb_wchar_t),
987 /* Check that the name is supported by iconv_open. */
988 desc = iconv_open (result, host_charset ());
989 if (desc != (iconv_t) -1)
992 stored_result = result;
995 /* Not valid, free the allocated memory. */
997 /* No valid charset found, generate error here. */
998 error (_("Unable to find a vaild charset for string conversions"));
1001 #endif /* USE_INTERMEDIATE_ENCODING_FUNCTION */
1004 _initialize_charset (void)
1006 /* The first element is always "auto". */
1007 VEC_safe_push (char_ptr, charsets, xstrdup ("auto"));
1008 find_charset_names ();
1010 if (VEC_length (char_ptr, charsets) > 1)
1011 charset_enum = (const char **) VEC_address (char_ptr, charsets);
1013 charset_enum = default_charset_names;
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)
1029 /* "CP" + x<=5 digits + paranoia. */
1030 static char w32_host_default_charset[16];
1032 snprintf (w32_host_default_charset, sizeof w32_host_default_charset,
1034 auto_host_charset_name = w32_host_default_charset;
1035 auto_target_charset_name = auto_host_charset_name;
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. */
1054 &setlist, &showlist);
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);
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);
1080 add_setshow_enum_cmd ("target-wide-charset", class_support,
1081 charset_enum, &target_wide_charset_name,
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);