rtld - do not allow both dynamic DTV index and static TLS offset
[dragonfly.git] / contrib / gdb-7 / gdb / charset.c
blob5835fd40872e7df62bc875782d4c8f8890179ca9
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/>. */
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"
32 #include <stddef.h>
33 #include "gdb_string.h"
34 #include <ctype.h>
36 #ifdef USE_WIN32API
37 #include <windows.h>
38 #endif
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
47 change this.
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
54 wchar_t.
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.
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
69 conversions),
71 and so on.
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. */
78 #ifdef PHONY_ICONV
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 ,
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
99 #undef ICONV_CONST
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. */
107 #ifndef EILSEQ
108 #define EILSEQ ENOENT
109 #endif
111 static iconv_t
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))
118 return -1;
119 if (strcmp (to, "wchar_t") && strcmp (to, GDB_DEFAULT_HOST_CHARSET))
120 return -1;
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");
127 static int
128 phony_iconv_close (iconv_t arg)
130 return 0;
133 static size_t
134 phony_iconv (iconv_t utf_flag, const char **inbuf, size_t *inbytesleft,
135 char **outbuf, size_t *outbytesleft)
137 if (utf_flag)
139 while (*inbytesleft >= 4)
141 size_t j;
142 unsigned long c = 0;
144 for (j = 0; j < 4; ++j)
146 c <<= 8;
147 c += (*inbuf)[j] & 0xff;
150 if (c >= 256)
152 errno = EILSEQ;
153 return -1;
155 **outbuf = c & 0xff;
156 ++*outbuf;
157 --*outbytesleft;
159 ++*inbuf;
160 *inbytesleft -= 4;
162 if (*inbytesleft < 4)
164 errno = EINVAL;
165 return -1;
168 else
170 /* In all other cases we simply copy input bytes to the
171 output. */
172 size_t amt = *inbytesleft;
174 if (amt > *outbytesleft)
175 amt = *outbytesleft;
176 memcpy (*outbuf, *inbuf, amt);
177 *inbuf += amt;
178 *outbuf += amt;
179 *inbytesleft -= amt;
180 *outbytesleft -= amt;
183 if (*inbytesleft)
185 errno = E2BIG;
186 return -1;
189 /* The number of non-reversible conversions -- but they were all
190 reversible. */
191 return 0;
194 #endif
198 /* The global lists of character sets and translations. */
201 #ifndef GDB_DEFAULT_TARGET_CHARSET
202 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
203 #endif
205 #ifndef GDB_DEFAULT_TARGET_WIDE_CHARSET
206 #define GDB_DEFAULT_TARGET_WIDE_CHARSET "UTF-32"
207 #endif
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)
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);
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)
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);
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)
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);
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. */
276 static void
277 set_be_le_names (struct gdbarch *gdbarch)
279 int i, len;
280 const char *target_wide;
282 if (be_le_arch == gdbarch)
283 return;
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))
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')
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];
311 /* 'Set charset', 'set host-charset', 'set target-charset', 'set
312 target-wide-charset', 'set charset' sfunc's. */
314 static void
315 validate (struct gdbarch *gdbarch)
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;
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);
329 iconv_close (desc);
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);
337 /* Clear the cache. */
338 be_le_arch = NULL;
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)
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. */
353 static void
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. */
361 static void
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. */
369 static void
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. */
377 static void
378 show_charset (struct ui_file *file, int from_tty,
379 struct cmd_list_element *c,
380 const char *name)
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. */
391 const char *
392 host_charset (void)
394 if (!strcmp (host_charset_name, "auto"))
395 return auto_host_charset_name;
396 return host_charset_name;
399 const char *
400 target_charset (struct gdbarch *gdbarch)
402 if (!strcmp (target_charset_name, "auto"))
403 return gdbarch_auto_charset (gdbarch);
404 return target_charset_name;
407 const char *
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;
418 else
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. */
434 char
435 host_letter_to_control_character (char c)
437 if (c == '?')
438 return 0177;
439 return c & 0237;
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)
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';
457 /* Public character management functions. */
459 /* A cleanup function which is run to close an iconv descriptor. */
461 static void
462 cleanup_iconv (void *p)
464 iconv_t *descp = p;
465 iconv_close (*descp);
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)
474 iconv_t desc;
475 struct cleanup *cleanups;
476 size_t inleft;
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);
484 return;
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);
492 inleft = num_bytes;
493 inp = (ICONV_CONST char *) bytes;
495 space_request = num_bytes;
497 while (inleft > 0)
499 char *outp;
500 size_t outleft, r;
501 int old_size;
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)
517 switch (errno)
519 case EILSEQ:
521 int i;
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,
529 and try again. */
530 for (i = 0; i < width; ++i)
532 char octal[5];
534 xsnprintf (octal, sizeof (octal), "\\%.3o", *inp & 0xff);
535 obstack_grow_str (output, octal);
537 ++inp;
538 --inleft;
541 break;
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;
549 case EINVAL:
550 /* Incomplete input sequence. FIXME: ought to report this
551 to the caller somehow. */
552 inleft = 0;
553 break;
555 default:
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. */
571 iconv_t desc;
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;
578 /* The width of an input character. */
579 size_t width;
581 /* The output buffer and its size. */
582 gdb_wchar_t *out;
583 size_t out_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;
592 iconv_t desc;
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);
599 result->desc = desc;
600 result->input = input;
601 result->bytes = bytes;
602 result->width = width;
604 result->out = XNEW (gdb_wchar_t);
605 result->out_size = 1;
607 return result;
610 static void
611 do_cleanup_iterator (void *p)
613 struct wchar_iterator *iter = p;
615 iconv_close (iter->desc);
616 xfree (iter->out);
617 xfree (iter);
620 struct cleanup *
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,
631 size_t *len)
633 size_t out_request;
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)
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);
651 iter->input = (gdb_byte *) inptr;
653 if (r == (size_t) -1)
655 switch (errno)
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;
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;
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;
679 ++out_request;
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));
686 continue;
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;
697 default:
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;
707 *ptr = orig_inptr;
708 *len = orig_in - iter->bytes;
709 return num;
712 /* Really done. */
713 *out_result = wchar_iterate_eof;
714 return -1;
718 /* The charset.c module initialization function. */
720 extern initialize_file_ftype _initialize_charset; /* -Wmissing-prototype */
722 static VEC (char_ptr) *charsets;
724 #ifdef PHONY_ICONV
726 static void
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. */
745 static int
746 add_one (unsigned int count, const char *const *names, void *data)
748 unsigned int i;
750 for (i = 0; i < count; ++i)
751 VEC_safe_push (char_ptr, charsets, xstrdup (names[i]));
753 return 0;
756 static void
757 find_charset_names (void)
759 iconvlist (add_one, NULL);
760 VEC_safe_push (char_ptr, charsets, NULL);
763 #else
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. */
770 static int
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[] =
777 "The following",
778 "not necessarily",
779 "the FROM and TO",
780 "listed with several",
781 NULL
783 int i;
785 for (i = 0; ignore_lines[i] != NULL; ++i)
787 if (strstr (line, ignore_lines[i]) != NULL)
788 return 1;
791 return 0;
794 static void
795 find_charset_names (void)
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;
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);
815 #ifdef ICONV_BIN
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);
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))
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
841 as needed. */
843 while (in != NULL && !feof (in))
845 /* The size of buf is chosen arbitrarily. */
846 char buf[1024];
847 char *start, *r;
848 int len;
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;
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';
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)
876 int keep_going;
877 char *p;
879 /* Skip leading blanks. */
880 for (p = start; *p && *p == ' '; ++p)
882 start = p;
883 /* Find the next space, comma, or end-of-line. */
884 for ( ; *p && *p != ' ' && *p != ','; ++p)
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)
900 if (pex_get_status (child, 1, &status)
901 && WIFEXITED (status) && !WEXITSTATUS (status))
902 fail = 0;
906 xfree (iconv_program);
907 pex_free (child);
908 free_environ (iconv_env);
910 if (fail)
912 /* Some error occurred, so drop the vector. */
913 free_char_ptr_vec (charsets);
914 charsets = NULL;
916 else
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;
926 const char *
927 default_auto_charset (void)
929 return auto_target_charset_name;
932 const char *
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. */
941 #if WORDS_BIGENDIAN
942 #define ENDIAN_SUFFIX "BE"
943 #else
944 #define ENDIAN_SUFFIX "LE"
945 #endif
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)
955 ? 1 : -1];
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. */
963 const char *
964 intermediate_encoding (void)
966 iconv_t desc;
967 static const char *stored_result = NULL;
968 char *result;
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)
978 iconv_close (desc);
979 stored_result = result;
980 return result;
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)
991 iconv_close (desc);
992 stored_result = result;
993 return result;
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"));
1001 #endif /* USE_INTERMEDIATE_ENCODING_FUNCTION */
1003 void
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);
1012 else
1013 charset_enum = default_charset_names;
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)
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,
1033 "CP%d", GetACP());
1034 auto_host_charset_name = w32_host_default_charset;
1035 auto_target_charset_name = auto_host_charset_name;
1037 #endif
1038 #endif
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);
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,
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);