1 /* Character set conversion support for GDB.
3 Copyright (C) 2001-2015 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_obstack.h"
25 #include "charset-list.h"
28 #include "arch-utils.h"
36 /* How GDB's character set support works
38 GDB has three global settings:
40 - The `current host character set' is the character set GDB should
41 use in talking to the user, and which (hopefully) the user's
42 terminal knows how to display properly. Most users should not
45 - The `current target character set' is the character set the
46 program being debugged uses.
48 - The `current target wide character set' is the wide character set
49 the program being debugged uses, that is, the encoding used for
52 There are commands to set each of these, and mechanisms for
53 choosing reasonable default values. GDB has a global list of
54 character sets that it can use as its host or target character
57 The header file `charset.h' declares various functions that
58 different pieces of GDB need to perform tasks like:
60 - printing target strings and characters to the user's terminal
61 (mostly target->host conversions),
63 - building target-appropriate representations of strings and
64 characters the user enters in expressions (mostly host->target
69 To avoid excessive code duplication and maintenance efforts,
70 GDB simply requires a capable iconv function. Users on platforms
71 without a suitable iconv can use the GNU iconv library. */
76 /* Provide a phony iconv that does as little as possible. Also,
77 arrange for there to be a single available character set. */
79 #undef GDB_DEFAULT_HOST_CHARSET
80 #define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
81 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
82 #define GDB_DEFAULT_TARGET_WIDE_CHARSET "ISO-8859-1"
83 #undef DEFAULT_CHARSET_NAMES
84 #define DEFAULT_CHARSET_NAMES GDB_DEFAULT_HOST_CHARSET ,
89 #define iconv_open phony_iconv_open
91 #define iconv phony_iconv
93 #define iconv_close phony_iconv_close
96 #define ICONV_CONST const
99 phony_iconv_open (const char *to, const char *from)
101 /* We allow conversions from UTF-32BE, wchar_t, and the host charset.
102 We allow conversions to wchar_t and the host charset. */
103 if (strcmp (from, "UTF-32BE") && strcmp (from, "wchar_t")
104 && strcmp (from, GDB_DEFAULT_HOST_CHARSET))
106 if (strcmp (to, "wchar_t") && strcmp (to, GDB_DEFAULT_HOST_CHARSET))
109 /* Return 1 if we are converting from UTF-32BE, 0 otherwise. This is
110 used as a flag in calls to iconv. */
111 return !strcmp (from, "UTF-32BE");
115 phony_iconv_close (iconv_t arg)
121 phony_iconv (iconv_t utf_flag, const char **inbuf, size_t *inbytesleft,
122 char **outbuf, size_t *outbytesleft)
126 while (*inbytesleft >= 4)
131 for (j = 0; j < 4; ++j)
134 c += (*inbuf)[j] & 0xff;
149 if (*inbytesleft < 4)
157 /* In all other cases we simply copy input bytes to the
159 size_t amt = *inbytesleft;
161 if (amt > *outbytesleft)
163 memcpy (*outbuf, *inbuf, amt);
167 *outbytesleft -= amt;
176 /* The number of non-reversible conversions -- but they were all
181 #else /* PHONY_ICONV */
183 /* On systems that don't have EILSEQ, GNU iconv's iconv.h defines it
184 to ENOENT, while gnulib defines it to a different value. Always
185 map ENOENT to gnulib's EILSEQ, leaving callers agnostic. */
188 gdb_iconv (iconv_t utf_flag, ICONV_CONST char **inbuf, size_t *inbytesleft,
189 char **outbuf, size_t *outbytesleft)
193 ret = iconv (utf_flag, inbuf, inbytesleft, outbuf, outbytesleft);
200 #define iconv gdb_iconv
202 #endif /* PHONY_ICONV */
205 /* The global lists of character sets and translations. */
208 #ifndef GDB_DEFAULT_TARGET_CHARSET
209 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
212 #ifndef GDB_DEFAULT_TARGET_WIDE_CHARSET
213 #define GDB_DEFAULT_TARGET_WIDE_CHARSET "UTF-32"
216 static const char *auto_host_charset_name = GDB_DEFAULT_HOST_CHARSET;
217 static const char *host_charset_name = "auto";
219 show_host_charset_name (struct ui_file *file, int from_tty,
220 struct cmd_list_element *c,
223 if (!strcmp (value, "auto"))
224 fprintf_filtered (file,
225 _("The host character set is \"auto; currently %s\".\n"),
226 auto_host_charset_name);
228 fprintf_filtered (file, _("The host character set is \"%s\".\n"), value);
231 static const char *target_charset_name = "auto";
233 show_target_charset_name (struct ui_file *file, int from_tty,
234 struct cmd_list_element *c, const char *value)
236 if (!strcmp (value, "auto"))
237 fprintf_filtered (file,
238 _("The target character set is \"auto; "
239 "currently %s\".\n"),
240 gdbarch_auto_charset (get_current_arch ()));
242 fprintf_filtered (file, _("The target character set is \"%s\".\n"),
246 static const char *target_wide_charset_name = "auto";
248 show_target_wide_charset_name (struct ui_file *file,
250 struct cmd_list_element *c,
253 if (!strcmp (value, "auto"))
254 fprintf_filtered (file,
255 _("The target wide character set is \"auto; "
256 "currently %s\".\n"),
257 gdbarch_auto_wide_charset (get_current_arch ()));
259 fprintf_filtered (file, _("The target wide character set is \"%s\".\n"),
263 static const char *default_charset_names[] =
265 DEFAULT_CHARSET_NAMES
269 static const char **charset_enum;
272 /* If the target wide character set has big- or little-endian
273 variants, these are the corresponding names. */
274 static const char *target_wide_charset_be_name;
275 static const char *target_wide_charset_le_name;
277 /* The architecture for which the BE- and LE-names are valid. */
278 static struct gdbarch *be_le_arch;
280 /* A helper function which sets the target wide big- and little-endian
281 character set names, if possible. */
284 set_be_le_names (struct gdbarch *gdbarch)
287 const char *target_wide;
289 if (be_le_arch == gdbarch)
291 be_le_arch = gdbarch;
293 target_wide_charset_le_name = NULL;
294 target_wide_charset_be_name = NULL;
296 target_wide = target_wide_charset_name;
297 if (!strcmp (target_wide, "auto"))
298 target_wide = gdbarch_auto_wide_charset (gdbarch);
300 len = strlen (target_wide);
301 for (i = 0; charset_enum[i]; ++i)
303 if (strncmp (target_wide, charset_enum[i], len))
305 if ((charset_enum[i][len] == 'B'
306 || charset_enum[i][len] == 'L')
307 && charset_enum[i][len + 1] == 'E'
308 && charset_enum[i][len + 2] == '\0')
310 if (charset_enum[i][len] == 'B')
311 target_wide_charset_be_name = charset_enum[i];
313 target_wide_charset_le_name = charset_enum[i];
318 /* 'Set charset', 'set host-charset', 'set target-charset', 'set
319 target-wide-charset', 'set charset' sfunc's. */
322 validate (struct gdbarch *gdbarch)
325 const char *host_cset = host_charset ();
326 const char *target_cset = target_charset (gdbarch);
327 const char *target_wide_cset = target_wide_charset_name;
329 if (!strcmp (target_wide_cset, "auto"))
330 target_wide_cset = gdbarch_auto_wide_charset (gdbarch);
332 desc = iconv_open (target_wide_cset, host_cset);
333 if (desc == (iconv_t) -1)
334 error (_("Cannot convert between character sets `%s' and `%s'"),
335 target_wide_cset, host_cset);
338 desc = iconv_open (target_cset, host_cset);
339 if (desc == (iconv_t) -1)
340 error (_("Cannot convert between character sets `%s' and `%s'"),
341 target_cset, host_cset);
344 /* Clear the cache. */
348 /* This is the sfunc for the 'set charset' command. */
350 set_charset_sfunc (char *charset, int from_tty,
351 struct cmd_list_element *c)
353 /* CAREFUL: set the target charset here as well. */
354 target_charset_name = host_charset_name;
355 validate (get_current_arch ());
358 /* 'set host-charset' command sfunc. We need a wrapper here because
359 the function needs to have a specific signature. */
361 set_host_charset_sfunc (char *charset, int from_tty,
362 struct cmd_list_element *c)
364 validate (get_current_arch ());
367 /* Wrapper for the 'set target-charset' command. */
369 set_target_charset_sfunc (char *charset, int from_tty,
370 struct cmd_list_element *c)
372 validate (get_current_arch ());
375 /* Wrapper for the 'set target-wide-charset' command. */
377 set_target_wide_charset_sfunc (char *charset, int from_tty,
378 struct cmd_list_element *c)
380 validate (get_current_arch ());
383 /* sfunc for the 'show charset' command. */
385 show_charset (struct ui_file *file, int from_tty,
386 struct cmd_list_element *c,
389 show_host_charset_name (file, from_tty, c, host_charset_name);
390 show_target_charset_name (file, from_tty, c, target_charset_name);
391 show_target_wide_charset_name (file, from_tty, c,
392 target_wide_charset_name);
396 /* Accessor functions. */
401 if (!strcmp (host_charset_name, "auto"))
402 return auto_host_charset_name;
403 return host_charset_name;
407 target_charset (struct gdbarch *gdbarch)
409 if (!strcmp (target_charset_name, "auto"))
410 return gdbarch_auto_charset (gdbarch);
411 return target_charset_name;
415 target_wide_charset (struct gdbarch *gdbarch)
417 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
419 set_be_le_names (gdbarch);
420 if (byte_order == BFD_ENDIAN_BIG)
422 if (target_wide_charset_be_name)
423 return target_wide_charset_be_name;
427 if (target_wide_charset_le_name)
428 return target_wide_charset_le_name;
431 if (!strcmp (target_wide_charset_name, "auto"))
432 return gdbarch_auto_wide_charset (gdbarch);
434 return target_wide_charset_name;
438 /* Host character set management. For the time being, we assume that
439 the host character set is some superset of ASCII. */
442 host_letter_to_control_character (char c)
449 /* Convert a host character, C, to its hex value. C must already have
450 been validated using isxdigit. */
453 host_hex_value (char c)
457 if (c >= 'a' && c <= 'f')
459 gdb_assert (c >= 'A' && c <= 'F');
464 /* Public character management functions. */
466 /* A cleanup function which is run to close an iconv descriptor. */
469 cleanup_iconv (void *p)
471 iconv_t *descp = (iconv_t *) p;
472 iconv_close (*descp);
476 convert_between_encodings (const char *from, const char *to,
477 const gdb_byte *bytes, unsigned int num_bytes,
478 int width, struct obstack *output,
479 enum transliterations translit)
482 struct cleanup *cleanups;
484 ICONV_CONST char *inp;
485 unsigned int space_request;
487 /* Often, the host and target charsets will be the same. */
488 if (!strcmp (from, to))
490 obstack_grow (output, bytes, num_bytes);
494 desc = iconv_open (to, from);
495 if (desc == (iconv_t) -1)
496 perror_with_name (_("Converting character sets"));
497 cleanups = make_cleanup (cleanup_iconv, &desc);
500 inp = (ICONV_CONST char *) bytes;
502 space_request = num_bytes;
510 old_size = obstack_object_size (output);
511 obstack_blank (output, space_request);
513 outp = (char *) obstack_base (output) + old_size;
514 outleft = space_request;
516 r = iconv (desc, &inp, &inleft, &outp, &outleft);
518 /* Now make sure that the object on the obstack only includes
519 bytes we have converted. */
520 obstack_blank_fast (output, -outleft);
522 if (r == (size_t) -1)
530 /* Invalid input sequence. */
531 if (translit == translit_none)
532 error (_("Could not convert character "
533 "to `%s' character set"), to);
535 /* We emit escape sequence for the bytes, skip them,
537 for (i = 0; i < width; ++i)
541 xsnprintf (octal, sizeof (octal), "\\%.3o", *inp & 0xff);
542 obstack_grow_str (output, octal);
551 /* We ran out of space in the output buffer. Make it
552 bigger next time around. */
557 /* Incomplete input sequence. FIXME: ought to report this
558 to the caller somehow. */
563 perror_with_name (_("Internal error while "
564 "converting character sets"));
569 do_cleanups (cleanups);
574 /* An iterator that returns host wchar_t's from a target string. */
575 struct wchar_iterator
577 /* The underlying iconv descriptor. */
580 /* The input string. This is updated as convert characters. */
581 const gdb_byte *input;
582 /* The number of bytes remaining in the input. */
585 /* The width of an input character. */
588 /* The output buffer and its size. */
593 /* Create a new iterator. */
594 struct wchar_iterator *
595 make_wchar_iterator (const gdb_byte *input, size_t bytes,
596 const char *charset, size_t width)
598 struct wchar_iterator *result;
601 desc = iconv_open (INTERMEDIATE_ENCODING, charset);
602 if (desc == (iconv_t) -1)
603 perror_with_name (_("Converting character sets"));
605 result = XNEW (struct wchar_iterator);
607 result->input = input;
608 result->bytes = bytes;
609 result->width = width;
611 result->out = XNEW (gdb_wchar_t);
612 result->out_size = 1;
618 do_cleanup_iterator (void *p)
620 struct wchar_iterator *iter = (struct wchar_iterator *) p;
622 iconv_close (iter->desc);
628 make_cleanup_wchar_iterator (struct wchar_iterator *iter)
630 return make_cleanup (do_cleanup_iterator, iter);
634 wchar_iterate (struct wchar_iterator *iter,
635 enum wchar_iterate_result *out_result,
636 gdb_wchar_t **out_chars,
637 const gdb_byte **ptr,
642 /* Try to convert some characters. At first we try to convert just
643 a single character. The reason for this is that iconv does not
644 necessarily update its outgoing arguments when it encounters an
645 invalid input sequence -- but we want to reliably report this to
646 our caller so it can emit an escape sequence. */
648 while (iter->bytes > 0)
650 ICONV_CONST char *inptr = (ICONV_CONST char *) iter->input;
651 char *outptr = (char *) &iter->out[0];
652 const gdb_byte *orig_inptr = iter->input;
653 size_t orig_in = iter->bytes;
654 size_t out_avail = out_request * sizeof (gdb_wchar_t);
656 size_t r = iconv (iter->desc, &inptr, &iter->bytes, &outptr, &out_avail);
658 iter->input = (gdb_byte *) inptr;
660 if (r == (size_t) -1)
665 /* Invalid input sequence. We still might have
666 converted a character; if so, return it. */
667 if (out_avail < out_request * sizeof (gdb_wchar_t))
670 /* Otherwise skip the first invalid character, and let
671 the caller know about it. */
672 *out_result = wchar_iterate_invalid;
675 iter->input += iter->width;
676 iter->bytes -= iter->width;
680 /* We ran out of space. We still might have converted a
681 character; if so, return it. Otherwise, grow the
682 buffer and try again. */
683 if (out_avail < out_request * sizeof (gdb_wchar_t))
687 if (out_request > iter->out_size)
689 iter->out_size = out_request;
690 iter->out = XRESIZEVEC (gdb_wchar_t, iter->out, out_request);
695 /* Incomplete input sequence. Let the caller know, and
696 arrange for future calls to see EOF. */
697 *out_result = wchar_iterate_incomplete;
704 perror_with_name (_("Internal error while "
705 "converting character sets"));
709 /* We converted something. */
710 num = out_request - out_avail / sizeof (gdb_wchar_t);
711 *out_result = wchar_iterate_ok;
712 *out_chars = iter->out;
714 *len = orig_in - iter->bytes;
719 *out_result = wchar_iterate_eof;
724 /* The charset.c module initialization function. */
726 extern initialize_file_ftype _initialize_charset; /* -Wmissing-prototype */
728 static VEC (char_ptr) *charsets;
733 find_charset_names (void)
735 VEC_safe_push (char_ptr, charsets, GDB_DEFAULT_HOST_CHARSET);
736 VEC_safe_push (char_ptr, charsets, NULL);
739 #else /* PHONY_ICONV */
741 /* Sometimes, libiconv redefines iconvlist as libiconvlist -- but
742 provides different symbols in the static and dynamic libraries.
743 So, configure may see libiconvlist but not iconvlist. But, calling
744 iconvlist is the right thing to do and will work. Hence we do a
745 check here but unconditionally call iconvlist below. */
746 #if defined (HAVE_ICONVLIST) || defined (HAVE_LIBICONVLIST)
748 /* A helper function that adds some character sets to the vector of
749 all character sets. This is a callback function for iconvlist. */
752 add_one (unsigned int count, const char *const *names, void *data)
756 for (i = 0; i < count; ++i)
757 VEC_safe_push (char_ptr, charsets, xstrdup (names[i]));
763 find_charset_names (void)
765 iconvlist (add_one, NULL);
766 VEC_safe_push (char_ptr, charsets, NULL);
771 /* Return non-zero if LINE (output from iconv) should be ignored.
772 Older iconv programs (e.g. 2.2.2) include the human readable
773 introduction even when stdout is not a tty. Newer versions omit
774 the intro if stdout is not a tty. */
777 ignore_line_p (const char *line)
779 /* This table is used to filter the output. If this text appears
780 anywhere in the line, it is ignored (strstr is used). */
781 static const char * const ignore_lines[] =
786 "listed with several",
791 for (i = 0; ignore_lines[i] != NULL; ++i)
793 if (strstr (line, ignore_lines[i]) != NULL)
801 find_charset_names (void)
803 struct pex_obj *child;
808 struct gdb_environ *iconv_env;
811 /* Older iconvs, e.g. 2.2.2, don't omit the intro text if stdout is
812 not a tty. We need to recognize it and ignore it. This text is
813 subject to translation, so force LANGUAGE=C. */
814 iconv_env = make_environ ();
815 init_environ (iconv_env);
816 set_in_environ (iconv_env, "LANGUAGE", "C");
817 set_in_environ (iconv_env, "LC_ALL", "C");
819 child = pex_init (PEX_USE_PIPES, "iconv", NULL);
823 char *iconv_dir = relocate_gdb_directory (ICONV_BIN,
824 ICONV_BIN_RELOCATABLE);
825 iconv_program = concat (iconv_dir, SLASH_STRING, "iconv", NULL);
829 iconv_program = xstrdup ("iconv");
831 args[0] = iconv_program;
834 flags = PEX_STDERR_TO_STDOUT;
838 /* Note that we simply ignore errors here. */
839 if (!pex_run_in_environment (child, flags,
840 args[0], args, environ_vector (iconv_env),
843 FILE *in = pex_read_output (child, 0);
845 /* POSIX says that iconv -l uses an unspecified format. We
846 parse the glibc and libiconv formats; feel free to add others
849 while (in != NULL && !feof (in))
851 /* The size of buf is chosen arbitrarily. */
856 r = fgets (buf, sizeof (buf), in);
862 if (ignore_line_p (r))
865 /* Strip off the newline. */
867 /* Strip off one or two '/'s. glibc will print lines like
868 "8859_7//", but also "10646-1:1993/UCS4/". */
869 if (buf[len - 1] == '/')
871 if (buf[len - 1] == '/')
875 /* libiconv will print multiple entries per line, separated
876 by spaces. Older iconvs will print multiple entries per
877 line, indented by two spaces, and separated by ", "
878 (i.e. the human readable form). */
885 /* Skip leading blanks. */
886 for (p = start; *p && *p == ' '; ++p)
889 /* Find the next space, comma, or end-of-line. */
890 for ( ; *p && *p != ' ' && *p != ','; ++p)
892 /* Ignore an empty result. */
897 VEC_safe_push (char_ptr, charsets, xstrdup (start));
900 /* Skip any extra spaces. */
901 for (start = p + 1; *start && *start == ' '; ++start)
906 if (pex_get_status (child, 1, &status)
907 && WIFEXITED (status) && !WEXITSTATUS (status))
912 xfree (iconv_program);
914 free_environ (iconv_env);
918 /* Some error occurred, so drop the vector. */
919 free_char_ptr_vec (charsets);
923 VEC_safe_push (char_ptr, charsets, NULL);
926 #endif /* HAVE_ICONVLIST || HAVE_LIBICONVLIST */
927 #endif /* PHONY_ICONV */
929 /* The "auto" target charset used by default_auto_charset. */
930 static const char *auto_target_charset_name = GDB_DEFAULT_TARGET_CHARSET;
933 default_auto_charset (void)
935 return auto_target_charset_name;
939 default_auto_wide_charset (void)
941 return GDB_DEFAULT_TARGET_WIDE_CHARSET;
945 #ifdef USE_INTERMEDIATE_ENCODING_FUNCTION
946 /* Macro used for UTF or UCS endianness suffix. */
948 #define ENDIAN_SUFFIX "BE"
950 #define ENDIAN_SUFFIX "LE"
953 /* The code below serves to generate a compile time error if
954 gdb_wchar_t type is not of size 2 nor 4, despite the fact that
955 macro __STDC_ISO_10646__ is defined.
956 This is better than a gdb_assert call, because GDB cannot handle
957 strings correctly if this size is different. */
959 extern char your_gdb_wchar_t_is_bogus[(sizeof (gdb_wchar_t) == 2
960 || sizeof (gdb_wchar_t) == 4)
963 /* intermediate_encoding returns the charset used internally by
964 GDB to convert between target and host encodings. As the test above
965 compiled, sizeof (gdb_wchar_t) is either 2 or 4 bytes.
966 UTF-16/32 is tested first, UCS-2/4 is tested as a second option,
967 otherwise an error is generated. */
970 intermediate_encoding (void)
973 static const char *stored_result = NULL;
977 return stored_result;
978 result = xstrprintf ("UTF-%d%s", (int) (sizeof (gdb_wchar_t) * 8),
980 /* Check that the name is supported by iconv_open. */
981 desc = iconv_open (result, host_charset ());
982 if (desc != (iconv_t) -1)
985 stored_result = result;
988 /* Not valid, free the allocated memory. */
990 /* Second try, with UCS-2 type. */
991 result = xstrprintf ("UCS-%d%s", (int) sizeof (gdb_wchar_t),
993 /* Check that the name is supported by iconv_open. */
994 desc = iconv_open (result, host_charset ());
995 if (desc != (iconv_t) -1)
998 stored_result = result;
1001 /* Not valid, free the allocated memory. */
1003 /* No valid charset found, generate error here. */
1004 error (_("Unable to find a vaild charset for string conversions"));
1007 #endif /* USE_INTERMEDIATE_ENCODING_FUNCTION */
1010 _initialize_charset (void)
1012 /* The first element is always "auto". */
1013 VEC_safe_push (char_ptr, charsets, xstrdup ("auto"));
1014 find_charset_names ();
1016 if (VEC_length (char_ptr, charsets) > 1)
1017 charset_enum = (const char **) VEC_address (char_ptr, charsets);
1019 charset_enum = default_charset_names;
1022 #ifdef HAVE_LANGINFO_CODESET
1023 /* The result of nl_langinfo may be overwritten later. This may
1024 leak a little memory, if the user later changes the host charset,
1025 but that doesn't matter much. */
1026 auto_host_charset_name = xstrdup (nl_langinfo (CODESET));
1027 /* Solaris will return `646' here -- but the Solaris iconv then does
1028 not accept this. Darwin (and maybe FreeBSD) may return "" here,
1029 which GNU libiconv doesn't like (infinite loop). */
1030 if (!strcmp (auto_host_charset_name, "646") || !*auto_host_charset_name)
1031 auto_host_charset_name = "ASCII";
1032 auto_target_charset_name = auto_host_charset_name;
1033 #elif defined (USE_WIN32API)
1035 /* "CP" + x<=5 digits + paranoia. */
1036 static char w32_host_default_charset[16];
1038 snprintf (w32_host_default_charset, sizeof w32_host_default_charset,
1040 auto_host_charset_name = w32_host_default_charset;
1041 auto_target_charset_name = auto_host_charset_name;
1046 add_setshow_enum_cmd ("charset", class_support,
1047 charset_enum, &host_charset_name, _("\
1048 Set the host and target character sets."), _("\
1049 Show the host and target character sets."), _("\
1050 The `host character set' is the one used by the system GDB is running on.\n\
1051 The `target character set' is the one used by the program being debugged.\n\
1052 You may only use supersets of ASCII for your host character set; GDB does\n\
1053 not support any others.\n\
1054 To see a list of the character sets GDB supports, type `set charset <TAB>'."),
1055 /* Note that the sfunc below needs to set
1056 target_charset_name, because the 'set
1057 charset' command sets two variables. */
1060 &setlist, &showlist);
1062 add_setshow_enum_cmd ("host-charset", class_support,
1063 charset_enum, &host_charset_name, _("\
1064 Set the host character set."), _("\
1065 Show the host character set."), _("\
1066 The `host character set' is the one used by the system GDB is running on.\n\
1067 You may only use supersets of ASCII for your host character set; GDB does\n\
1068 not support any others.\n\
1069 To see a list of the character sets GDB supports, type `set host-charset <TAB>'."),
1070 set_host_charset_sfunc,
1071 show_host_charset_name,
1072 &setlist, &showlist);
1074 add_setshow_enum_cmd ("target-charset", class_support,
1075 charset_enum, &target_charset_name, _("\
1076 Set the target character set."), _("\
1077 Show the target character set."), _("\
1078 The `target character set' is the one used by the program being debugged.\n\
1079 GDB translates characters and strings between the host and target\n\
1080 character sets as needed.\n\
1081 To see a list of the character sets GDB supports, type `set target-charset'<TAB>"),
1082 set_target_charset_sfunc,
1083 show_target_charset_name,
1084 &setlist, &showlist);
1086 add_setshow_enum_cmd ("target-wide-charset", class_support,
1087 charset_enum, &target_wide_charset_name,
1089 Set the target wide character set."), _("\
1090 Show the target wide character set."), _("\
1091 The `target wide character set' is the one used by the program being debugged.\
1092 \nIn particular it is the encoding used by `wchar_t'.\n\
1093 GDB translates characters and strings between the host and target\n\
1094 character sets as needed.\n\
1095 To see a list of the character sets GDB supports, type\n\
1096 `set target-wide-charset'<TAB>"),
1097 set_target_wide_charset_sfunc,
1098 show_target_wide_charset_name,
1099 &setlist, &showlist);