Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / charset.c
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 }