]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/charset.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / charset.c
1 /* Character set conversion support for GDB.
2
3 Copyright (C) 2001, 2003, 2007 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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "defs.h"
23 #include "charset.h"
24 #include "gdbcmd.h"
25 #include "gdb_assert.h"
26
27 #include <stddef.h>
28 #include "gdb_string.h"
29 #include <ctype.h>
30
31 #ifdef HAVE_ICONV
32 #include <iconv.h>
33 #endif
34
35 \f
36 /* How GDB's character set support works
37
38 GDB has two global settings:
39
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.
43
44 - The `current target character set' is the character set the
45 program being debugged uses.
46
47 There are commands to set each of these, and mechanisms for
48 choosing reasonable default values. GDB has a global list of
49 character sets that it can use as its host or target character
50 sets.
51
52 The header file `charset.h' declares various functions that
53 different pieces of GDB need to perform tasks like:
54
55 - printing target strings and characters to the user's terminal
56 (mostly target->host conversions),
57
58 - building target-appropriate representations of strings and
59 characters the user enters in expressions (mostly host->target
60 conversions),
61
62 and so on.
63
64 Now, many of these operations are specific to a particular
65 host/target character set pair. If GDB supports N character sets,
66 there are N^2 possible pairs. This means that, the larger GDB's
67 repertoire of character sets gets, the more expensive it gets to add
68 new character sets.
69
70 To make sure that GDB can do the right thing for every possible
71 pairing of host and target character set, while still allowing
72 GDB's repertoire to scale, we use a two-tiered approach:
73
74 - We maintain a global table of "translations" --- groups of
75 functions specific to a particular pair of character sets.
76
77 - However, a translation can be incomplete: some functions can be
78 omitted. Where there is not a translation to specify exactly
79 what function to use, we provide reasonable defaults. The
80 default behaviors try to use the "iconv" library functions, which
81 support a wide range of character sets. However, even if iconv
82 is not available, there are fallbacks to support trivial
83 translations: when the host and target character sets are the
84 same. */
85
86 \f
87 /* The character set and translation structures. */
88
89
90 /* A character set GDB knows about. GDB only supports character sets
91 with stateless encodings, in which every character is one byte
92 long. */
93 struct charset {
94
95 /* A singly-linked list of all known charsets. */
96 struct charset *next;
97
98 /* The name of the character set. Comparisons on character set
99 names are case-sensitive. */
100 const char *name;
101
102 /* Non-zero iff this character set can be used as a host character
103 set. At present, GDB basically assumes that the host character
104 set is a superset of ASCII. */
105 int valid_host_charset;
106
107 /* Pointers to charset-specific functions that depend only on a
108 single character set, and data pointers to pass to them. */
109 int (*host_char_print_literally) (void *baton,
110 int host_char);
111 void *host_char_print_literally_baton;
112
113 int (*target_char_to_control_char) (void *baton,
114 int target_char,
115 int *target_ctrl_char);
116 void *target_char_to_control_char_baton;
117 };
118
119
120 /* A translation from one character set to another. */
121 struct translation {
122
123 /* A singly-linked list of all known translations. */
124 struct translation *next;
125
126 /* This structure describes functions going from the FROM character
127 set to the TO character set. Comparisons on character set names
128 are case-sensitive. */
129 const char *from, *to;
130
131 /* Pointers to translation-specific functions, and data pointers to
132 pass to them. These pointers can be zero, indicating that GDB
133 should fall back on the default behavior. We hope the default
134 behavior will be correct for many from/to pairs, reducing the
135 number of translations that need to be registered explicitly. */
136
137 /* TARGET_CHAR is in the `from' charset.
138 Returns a string in the `to' charset. */
139 const char *(*c_target_char_has_backslash_escape) (void *baton,
140 int target_char);
141 void *c_target_char_has_backslash_escape_baton;
142
143 /* HOST_CHAR is in the `from' charset.
144 TARGET_CHAR points to a char in the `to' charset. */
145 int (*c_parse_backslash) (void *baton, int host_char, int *target_char);
146 void *c_parse_backslash_baton;
147
148 /* This is used for the host_char_to_target and target_char_to_host
149 functions. */
150 int (*convert_char) (void *baton, int from, int *to);
151 void *convert_char_baton;
152 };
153
154
155 \f
156 /* The global lists of character sets and translations. */
157
158
159 #ifndef GDB_DEFAULT_HOST_CHARSET
160 #define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
161 #endif
162
163 #ifndef GDB_DEFAULT_TARGET_CHARSET
164 #define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
165 #endif
166
167 static const char *host_charset_name = GDB_DEFAULT_HOST_CHARSET;
168 static void
169 show_host_charset_name (struct ui_file *file, int from_tty,
170 struct cmd_list_element *c,
171 const char *value)
172 {
173 fprintf_filtered (file, _("The host character set is \"%s\".\n"), value);
174 }
175
176 static const char *target_charset_name = GDB_DEFAULT_TARGET_CHARSET;
177 static void
178 show_target_charset_name (struct ui_file *file, int from_tty,
179 struct cmd_list_element *c, const char *value)
180 {
181 fprintf_filtered (file, _("The target character set is \"%s\".\n"),
182 value);
183 }
184
185
186 static const char *host_charset_enum[] =
187 {
188 "ASCII",
189 "ISO-8859-1",
190 0
191 };
192
193 static const char *target_charset_enum[] =
194 {
195 "ASCII",
196 "ISO-8859-1",
197 "EBCDIC-US",
198 "IBM1047",
199 0
200 };
201
202 /* The global list of all the charsets GDB knows about. */
203 static struct charset *all_charsets;
204
205
206 static void
207 register_charset (struct charset *cs)
208 {
209 struct charset **ptr;
210
211 /* Put the new charset on the end, so that the list ends up in the
212 same order as the registrations in the _initialize function. */
213 for (ptr = &all_charsets; *ptr; ptr = &(*ptr)->next)
214 ;
215
216 cs->next = 0;
217 *ptr = cs;
218 }
219
220
221 static struct charset *
222 lookup_charset (const char *name)
223 {
224 struct charset *cs;
225
226 for (cs = all_charsets; cs; cs = cs->next)
227 if (! strcmp (name, cs->name))
228 return cs;
229
230 return NULL;
231 }
232
233
234 /* The global list of translations. */
235 static struct translation *all_translations;
236
237
238 static void
239 register_translation (struct translation *t)
240 {
241 t->next = all_translations;
242 all_translations = t;
243 }
244
245
246 static struct translation *
247 lookup_translation (const char *from, const char *to)
248 {
249 struct translation *t;
250
251 for (t = all_translations; t; t = t->next)
252 if (! strcmp (from, t->from)
253 && ! strcmp (to, t->to))
254 return t;
255
256 return 0;
257 }
258
259
260 \f
261 /* Constructing charsets. */
262
263 /* Allocate, initialize and return a straightforward charset.
264 Use this function, rather than creating the structures yourself,
265 so that we can add new fields to the structure in the future without
266 having to tweak all the old charset descriptions. */
267 static struct charset *
268 simple_charset (const char *name,
269 int valid_host_charset,
270 int (*host_char_print_literally) (void *baton, int host_char),
271 void *host_char_print_literally_baton,
272 int (*target_char_to_control_char) (void *baton,
273 int target_char,
274 int *target_ctrl_char),
275 void *target_char_to_control_char_baton)
276 {
277 struct charset *cs = xmalloc (sizeof (*cs));
278
279 memset (cs, 0, sizeof (*cs));
280 cs->name = name;
281 cs->valid_host_charset = valid_host_charset;
282 cs->host_char_print_literally = host_char_print_literally;
283 cs->host_char_print_literally_baton = host_char_print_literally_baton;
284 cs->target_char_to_control_char = target_char_to_control_char;
285 cs->target_char_to_control_char_baton = target_char_to_control_char_baton;
286
287 return cs;
288 }
289
290
291 \f
292 /* ASCII functions. */
293
294 static int
295 ascii_print_literally (void *baton, int c)
296 {
297 c &= 0xff;
298
299 return (0x20 <= c && c <= 0x7e);
300 }
301
302
303 static int
304 ascii_to_control (void *baton, int c, int *ctrl_char)
305 {
306 *ctrl_char = (c & 037);
307 return 1;
308 }
309
310 \f
311 /* ISO-8859 family functions. */
312
313
314 static int
315 iso_8859_print_literally (void *baton, int c)
316 {
317 c &= 0xff;
318
319 return ((0x20 <= c && c <= 0x7e) /* ascii printables */
320 || (! sevenbit_strings && 0xA0 <= c)); /* iso 8859 printables */
321 }
322
323
324 static int
325 iso_8859_to_control (void *baton, int c, int *ctrl_char)
326 {
327 *ctrl_char = (c & 0200) | (c & 037);
328 return 1;
329 }
330
331
332 /* Construct an ISO-8859-like character set. */
333 static struct charset *
334 iso_8859_family_charset (const char *name)
335 {
336 return simple_charset (name, 1,
337 iso_8859_print_literally, 0,
338 iso_8859_to_control, 0);
339 }
340
341
342 \f
343 /* EBCDIC family functions. */
344
345
346 static int
347 ebcdic_print_literally (void *baton, int c)
348 {
349 c &= 0xff;
350
351 return (64 <= c && c <= 254);
352 }
353
354
355 static int
356 ebcdic_to_control (void *baton, int c, int *ctrl_char)
357 {
358 /* There are no control character equivalents in EBCDIC. Use
359 numeric escapes. */
360 return 0;
361 }
362
363
364 /* Construct an EBCDIC-like character set. */
365 static struct charset *
366 ebcdic_family_charset (const char *name)
367 {
368 return simple_charset (name, 0,
369 ebcdic_print_literally, 0,
370 ebcdic_to_control, 0);
371 }
372
373
374
375
376 \f
377 /* Fallback functions using iconv. */
378
379 #if defined(HAVE_ICONV)
380
381 struct cached_iconv {
382 struct charset *from, *to;
383 iconv_t i;
384 };
385
386
387 /* Make sure the iconv cache *CI contains an iconv descriptor
388 translating from FROM to TO. If it already does, fine; otherwise,
389 close any existing descriptor, and open up a new one. On success,
390 return zero; on failure, return -1 and set errno. */
391 static int
392 check_iconv_cache (struct cached_iconv *ci,
393 struct charset *from,
394 struct charset *to)
395 {
396 iconv_t i;
397
398 /* Does the cached iconv descriptor match the conversion we're trying
399 to do now? */
400 if (ci->from == from
401 && ci->to == to
402 && ci->i != (iconv_t) 0)
403 return 0;
404
405 /* It doesn't. If we actually had any iconv descriptor open at
406 all, close it now. */
407 if (ci->i != (iconv_t) 0)
408 {
409 i = ci->i;
410 ci->i = (iconv_t) 0;
411
412 if (iconv_close (i) == -1)
413 error (_("Error closing `iconv' descriptor for "
414 "`%s'-to-`%s' character conversion: %s"),
415 ci->from->name, ci->to->name, safe_strerror (errno));
416 }
417
418 /* Open a new iconv descriptor for the required conversion. */
419 i = iconv_open (to->name, from->name);
420 if (i == (iconv_t) -1)
421 return -1;
422
423 ci->i = i;
424 ci->from = from;
425 ci->to = to;
426
427 return 0;
428 }
429
430
431 /* Convert FROM_CHAR using the cached iconv conversion *CI. Return
432 non-zero if the conversion was successful, zero otherwise. */
433 static int
434 cached_iconv_convert (struct cached_iconv *ci, int from_char, int *to_char)
435 {
436 char from;
437 ICONV_CONST char *from_ptr = &from;
438 char to, *to_ptr = &to;
439 size_t from_left = sizeof (from), to_left = sizeof (to);
440
441 gdb_assert (ci->i != (iconv_t) 0);
442
443 from = from_char;
444 if (iconv (ci->i, &from_ptr, &from_left, &to_ptr, &to_left)
445 == (size_t) -1)
446 {
447 /* These all suggest that the input or output character sets
448 have multi-byte encodings of some characters, which means
449 it's unsuitable for use as a GDB character set. We should
450 never have selected it. */
451 gdb_assert (errno != E2BIG && errno != EINVAL);
452
453 /* This suggests a bug in the code managing *CI. */
454 gdb_assert (errno != EBADF);
455
456 /* This seems to mean that there is no equivalent character in
457 the `to' character set. */
458 if (errno == EILSEQ)
459 return 0;
460
461 /* Anything else is mysterious. */
462 internal_error (__FILE__, __LINE__,
463 _("Error converting character `%d' from `%s' to `%s' "
464 "character set: %s"),
465 from_char, ci->from->name, ci->to->name,
466 safe_strerror (errno));
467 }
468
469 /* If the pointers weren't advanced across the input, that also
470 suggests something was wrong. */
471 gdb_assert (from_left == 0 && to_left == 0);
472
473 *to_char = (unsigned char) to;
474 return 1;
475 }
476
477
478 static void
479 register_iconv_charsets (void)
480 {
481 /* Here we should check whether various character sets were
482 recognized by the local iconv implementation.
483
484 The first implementation registered a bunch of character sets
485 recognized by iconv, but then we discovered that iconv on Solaris
486 and iconv on GNU/Linux had no character sets in common. So we
487 replaced them with the hard-coded tables that appear later in the
488 file. */
489 }
490
491 #endif /* defined (HAVE_ICONV) */
492
493 \f
494 /* Fallback routines for systems without iconv. */
495
496 #if ! defined (HAVE_ICONV)
497 struct cached_iconv { char nothing; };
498
499 static int
500 check_iconv_cache (struct cached_iconv *ci,
501 struct charset *from,
502 struct charset *to)
503 {
504 errno = EINVAL;
505 return -1;
506 }
507
508 static int
509 cached_iconv_convert (struct cached_iconv *ci, int from_char, int *to_char)
510 {
511 /* This function should never be called. */
512 gdb_assert (0);
513 }
514
515 static void
516 register_iconv_charsets (void)
517 {
518 }
519
520 #endif /* ! defined(HAVE_ICONV) */
521
522 \f
523 /* Default trivial conversion functions. */
524
525 static int
526 identity_either_char_to_other (void *baton, int either_char, int *other_char)
527 {
528 *other_char = either_char;
529 return 1;
530 }
531
532
533 \f
534 /* Default non-trivial conversion functions. */
535
536
537 static char backslashable[] = "abfnrtv";
538 static char *backslashed[] = {"a", "b", "f", "n", "r", "t", "v", "0"};
539 static char represented[] = "\a\b\f\n\r\t\v";
540
541
542 /* Translate TARGET_CHAR into the host character set, and see if it
543 matches any of our standard escape sequences. */
544 static const char *
545 default_c_target_char_has_backslash_escape (void *baton, int target_char)
546 {
547 int host_char;
548 const char *ix;
549
550 /* If target_char has no equivalent in the host character set,
551 assume it doesn't have a backslashed form. */
552 if (! target_char_to_host (target_char, &host_char))
553 return NULL;
554
555 ix = strchr (represented, host_char);
556 if (ix)
557 return backslashed[ix - represented];
558 else
559 return NULL;
560 }
561
562
563 /* Translate the backslash the way we would in the host character set,
564 and then try to translate that into the target character set. */
565 static int
566 default_c_parse_backslash (void *baton, int host_char, int *target_char)
567 {
568 const char *ix;
569
570 ix = strchr (backslashable, host_char);
571
572 if (! ix)
573 return 0;
574 else
575 return host_char_to_target (represented[ix - backslashable],
576 target_char);
577 }
578
579
580 /* Convert using a cached iconv descriptor. */
581 static int
582 iconv_convert (void *baton, int from_char, int *to_char)
583 {
584 struct cached_iconv *ci = baton;
585 return cached_iconv_convert (ci, from_char, to_char);
586 }
587
588
589 \f
590 /* Conversion tables. */
591
592
593 /* I'd much rather fall back on iconv whenever possible. But the
594 character set names you use with iconv aren't standardized at all,
595 a lot of platforms have really meager character set coverage, etc.
596 I wanted to have at least something we could use to exercise the
597 test suite on all platforms.
598
599 In the long run, we should have a configure-time process explore
600 somehow which character sets the host platform supports, and some
601 arrangement that allows GDB users to use platform-indepedent names
602 for character sets. */
603
604
605 /* We generated these tables using iconv on a GNU/Linux machine. */
606
607
608 static int ascii_to_iso_8859_1_table[] = {
609 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 16 */
610 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 32 */
611 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 48 */
612 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 64 */
613 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 80 */
614 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 96 */
615 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 112 */
616 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 128 */
617 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 144 */
618 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 160 */
619 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 176 */
620 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 208 */
622 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 224 */
623 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 240 */
624 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 256 */
625 };
626
627
628 static int ascii_to_ebcdic_us_table[] = {
629 0, 1, 2, 3, 55, 45, 46, 47, 22, 5, 37, 11, 12, 13, 14, 15, /* 16 */
630 16, 17, 18, 19, 60, 61, 50, 38, 24, 25, 63, 39, 28, 29, 30, 31, /* 32 */
631 64, 90,127,123, 91,108, 80,125, 77, 93, 92, 78,107, 96, 75, 97, /* 48 */
632 240,241,242,243,244,245,246,247,248,249,122, 94, 76,126,110,111, /* 64 */
633 124,193,194,195,196,197,198,199,200,201,209,210,211,212,213,214, /* 80 */
634 215,216,217,226,227,228,229,230,231,232,233, -1,224, -1, -1,109, /* 96 */
635 121,129,130,131,132,133,134,135,136,137,145,146,147,148,149,150, /* 112 */
636 151,152,153,162,163,164,165,166,167,168,169,192, 79,208,161, 7, /* 128 */
637 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 144 */
638 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 160 */
639 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 176 */
640 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
641 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 208 */
642 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 224 */
643 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 240 */
644 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 256 */
645 };
646
647
648 static int ascii_to_ibm1047_table[] = {
649 0, 1, 2, 3, 55, 45, 46, 47, 22, 5, 37, 11, 12, 13, 14, 15, /* 16 */
650 16, 17, 18, 19, 60, 61, 50, 38, 24, 25, 63, 39, 28, 29, 30, 31, /* 32 */
651 64, 90,127,123, 91,108, 80,125, 77, 93, 92, 78,107, 96, 75, 97, /* 48 */
652 240,241,242,243,244,245,246,247,248,249,122, 94, 76,126,110,111, /* 64 */
653 124,193,194,195,196,197,198,199,200,201,209,210,211,212,213,214, /* 80 */
654 215,216,217,226,227,228,229,230,231,232,233,173,224,189, 95,109, /* 96 */
655 121,129,130,131,132,133,134,135,136,137,145,146,147,148,149,150, /* 112 */
656 151,152,153,162,163,164,165,166,167,168,169,192, 79,208,161, 7, /* 128 */
657 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 144 */
658 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 160 */
659 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 176 */
660 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
661 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 208 */
662 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 224 */
663 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 240 */
664 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 256 */
665 };
666
667
668 static int iso_8859_1_to_ascii_table[] = {
669 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 16 */
670 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 32 */
671 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 48 */
672 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 64 */
673 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 80 */
674 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 96 */
675 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 112 */
676 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 128 */
677 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 144 */
678 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 160 */
679 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 176 */
680 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
681 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 208 */
682 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 224 */
683 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 240 */
684 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 256 */
685 };
686
687
688 static int iso_8859_1_to_ebcdic_us_table[] = {
689 0, 1, 2, 3, 55, 45, 46, 47, 22, 5, 37, 11, 12, 13, 14, 15, /* 16 */
690 16, 17, 18, 19, 60, 61, 50, 38, 24, 25, 63, 39, 28, 29, 30, 31, /* 32 */
691 64, 90,127,123, 91,108, 80,125, 77, 93, 92, 78,107, 96, 75, 97, /* 48 */
692 240,241,242,243,244,245,246,247,248,249,122, 94, 76,126,110,111, /* 64 */
693 124,193,194,195,196,197,198,199,200,201,209,210,211,212,213,214, /* 80 */
694 215,216,217,226,227,228,229,230,231,232,233, -1,224, -1, -1,109, /* 96 */
695 121,129,130,131,132,133,134,135,136,137,145,146,147,148,149,150, /* 112 */
696 151,152,153,162,163,164,165,166,167,168,169,192, 79,208,161, 7, /* 128 */
697 32, 33, 34, 35, 36, 21, 6, 23, 40, 41, 42, 43, 44, 9, 10, 27, /* 144 */
698 48, 49, 26, 51, 52, 53, 54, 8, 56, 57, 58, 59, 4, 20, 62,255, /* 160 */
699 -1, -1, 74, -1, -1, -1,106, -1, -1, -1, -1, -1, 95, -1, -1, -1, /* 176 */
700 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
701 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 208 */
702 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 224 */
703 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 240 */
704 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 256 */
705 };
706
707
708 static int iso_8859_1_to_ibm1047_table[] = {
709 0, 1, 2, 3, 55, 45, 46, 47, 22, 5, 37, 11, 12, 13, 14, 15, /* 16 */
710 16, 17, 18, 19, 60, 61, 50, 38, 24, 25, 63, 39, 28, 29, 30, 31, /* 32 */
711 64, 90,127,123, 91,108, 80,125, 77, 93, 92, 78,107, 96, 75, 97, /* 48 */
712 240,241,242,243,244,245,246,247,248,249,122, 94, 76,126,110,111, /* 64 */
713 124,193,194,195,196,197,198,199,200,201,209,210,211,212,213,214, /* 80 */
714 215,216,217,226,227,228,229,230,231,232,233,173,224,189, 95,109, /* 96 */
715 121,129,130,131,132,133,134,135,136,137,145,146,147,148,149,150, /* 112 */
716 151,152,153,162,163,164,165,166,167,168,169,192, 79,208,161, 7, /* 128 */
717 32, 33, 34, 35, 36, 21, 6, 23, 40, 41, 42, 43, 44, 9, 10, 27, /* 144 */
718 48, 49, 26, 51, 52, 53, 54, 8, 56, 57, 58, 59, 4, 20, 62,255, /* 160 */
719 65,170, 74,177,159,178,106,181,187,180,154,138,176,202,175,188, /* 176 */
720 144,143,234,250,190,160,182,179,157,218,155,139,183,184,185,171, /* 192 */
721 100,101, 98,102, 99,103,158,104,116,113,114,115,120,117,118,119, /* 208 */
722 172,105,237,238,235,239,236,191,128,253,254,251,252,186,174, 89, /* 224 */
723 68, 69, 66, 70, 67, 71,156, 72, 84, 81, 82, 83, 88, 85, 86, 87, /* 240 */
724 140, 73,205,206,203,207,204,225,112,221,222,219,220,141,142,223 /* 256 */
725 };
726
727
728 static int ebcdic_us_to_ascii_table[] = {
729 0, 1, 2, 3, -1, 9, -1,127, -1, -1, -1, 11, 12, 13, 14, 15, /* 16 */
730 16, 17, 18, 19, -1, -1, 8, -1, 24, 25, -1, -1, 28, 29, 30, 31, /* 32 */
731 -1, -1, -1, -1, -1, 10, 23, 27, -1, -1, -1, -1, -1, 5, 6, 7, /* 48 */
732 -1, -1, 22, -1, -1, -1, -1, 4, -1, -1, -1, -1, 20, 21, -1, 26, /* 64 */
733 32, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 46, 60, 40, 43,124, /* 80 */
734 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, 36, 42, 41, 59, -1, /* 96 */
735 45, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 37, 95, 62, 63, /* 112 */
736 -1, -1, -1, -1, -1, -1, -1, -1, -1, 96, 58, 35, 64, 39, 61, 34, /* 128 */
737 -1, 97, 98, 99,100,101,102,103,104,105, -1, -1, -1, -1, -1, -1, /* 144 */
738 -1,106,107,108,109,110,111,112,113,114, -1, -1, -1, -1, -1, -1, /* 160 */
739 -1,126,115,116,117,118,119,120,121,122, -1, -1, -1, -1, -1, -1, /* 176 */
740 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
741 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, -1, -1, -1, -1, -1, /* 208 */
742 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, -1, -1, -1, -1, /* 224 */
743 92, -1, 83, 84, 85, 86, 87, 88, 89, 90, -1, -1, -1, -1, -1, -1, /* 240 */
744 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, -1, -1, -1, -1, -1 /* 256 */
745 };
746
747
748 static int ebcdic_us_to_iso_8859_1_table[] = {
749 0, 1, 2, 3,156, 9,134,127,151,141,142, 11, 12, 13, 14, 15, /* 16 */
750 16, 17, 18, 19,157,133, 8,135, 24, 25,146,143, 28, 29, 30, 31, /* 32 */
751 128,129,130,131,132, 10, 23, 27,136,137,138,139,140, 5, 6, 7, /* 48 */
752 144,145, 22,147,148,149,150, 4,152,153,154,155, 20, 21,158, 26, /* 64 */
753 32, -1, -1, -1, -1, -1, -1, -1, -1, -1,162, 46, 60, 40, 43,124, /* 80 */
754 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, 36, 42, 41, 59,172, /* 96 */
755 45, 47, -1, -1, -1, -1, -1, -1, -1, -1,166, 44, 37, 95, 62, 63, /* 112 */
756 -1, -1, -1, -1, -1, -1, -1, -1, -1, 96, 58, 35, 64, 39, 61, 34, /* 128 */
757 -1, 97, 98, 99,100,101,102,103,104,105, -1, -1, -1, -1, -1, -1, /* 144 */
758 -1,106,107,108,109,110,111,112,113,114, -1, -1, -1, -1, -1, -1, /* 160 */
759 -1,126,115,116,117,118,119,120,121,122, -1, -1, -1, -1, -1, -1, /* 176 */
760 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
761 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, -1, -1, -1, -1, -1, /* 208 */
762 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, -1, -1, -1, -1, /* 224 */
763 92, -1, 83, 84, 85, 86, 87, 88, 89, 90, -1, -1, -1, -1, -1, -1, /* 240 */
764 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, -1, -1, -1, -1,159 /* 256 */
765 };
766
767
768 static int ebcdic_us_to_ibm1047_table[] = {
769 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 16 */
770 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 32 */
771 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 48 */
772 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 64 */
773 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, 74, 75, 76, 77, 78, 79, /* 80 */
774 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, 90, 91, 92, 93, 94,176, /* 96 */
775 96, 97, -1, -1, -1, -1, -1, -1, -1, -1,106,107,108,109,110,111, /* 112 */
776 -1, -1, -1, -1, -1, -1, -1, -1, -1,121,122,123,124,125,126,127, /* 128 */
777 -1,129,130,131,132,133,134,135,136,137, -1, -1, -1, -1, -1, -1, /* 144 */
778 -1,145,146,147,148,149,150,151,152,153, -1, -1, -1, -1, -1, -1, /* 160 */
779 -1,161,162,163,164,165,166,167,168,169, -1, -1, -1, -1, -1, -1, /* 176 */
780 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
781 192,193,194,195,196,197,198,199,200,201, -1, -1, -1, -1, -1, -1, /* 208 */
782 208,209,210,211,212,213,214,215,216,217, -1, -1, -1, -1, -1, -1, /* 224 */
783 224, -1,226,227,228,229,230,231,232,233, -1, -1, -1, -1, -1, -1, /* 240 */
784 240,241,242,243,244,245,246,247,248,249, -1, -1, -1, -1, -1,255 /* 256 */
785 };
786
787
788 static int ibm1047_to_ascii_table[] = {
789 0, 1, 2, 3, -1, 9, -1,127, -1, -1, -1, 11, 12, 13, 14, 15, /* 16 */
790 16, 17, 18, 19, -1, -1, 8, -1, 24, 25, -1, -1, 28, 29, 30, 31, /* 32 */
791 -1, -1, -1, -1, -1, 10, 23, 27, -1, -1, -1, -1, -1, 5, 6, 7, /* 48 */
792 -1, -1, 22, -1, -1, -1, -1, 4, -1, -1, -1, -1, 20, 21, -1, 26, /* 64 */
793 32, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 46, 60, 40, 43,124, /* 80 */
794 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, 36, 42, 41, 59, 94, /* 96 */
795 45, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 37, 95, 62, 63, /* 112 */
796 -1, -1, -1, -1, -1, -1, -1, -1, -1, 96, 58, 35, 64, 39, 61, 34, /* 128 */
797 -1, 97, 98, 99,100,101,102,103,104,105, -1, -1, -1, -1, -1, -1, /* 144 */
798 -1,106,107,108,109,110,111,112,113,114, -1, -1, -1, -1, -1, -1, /* 160 */
799 -1,126,115,116,117,118,119,120,121,122, -1, -1, -1, 91, -1, -1, /* 176 */
800 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 93, -1, -1, /* 192 */
801 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, -1, -1, -1, -1, -1, /* 208 */
802 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, -1, -1, -1, -1, /* 224 */
803 92, -1, 83, 84, 85, 86, 87, 88, 89, 90, -1, -1, -1, -1, -1, -1, /* 240 */
804 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, -1, -1, -1, -1, -1 /* 256 */
805 };
806
807
808 static int ibm1047_to_iso_8859_1_table[] = {
809 0, 1, 2, 3,156, 9,134,127,151,141,142, 11, 12, 13, 14, 15, /* 16 */
810 16, 17, 18, 19,157,133, 8,135, 24, 25,146,143, 28, 29, 30, 31, /* 32 */
811 128,129,130,131,132, 10, 23, 27,136,137,138,139,140, 5, 6, 7, /* 48 */
812 144,145, 22,147,148,149,150, 4,152,153,154,155, 20, 21,158, 26, /* 64 */
813 32,160,226,228,224,225,227,229,231,241,162, 46, 60, 40, 43,124, /* 80 */
814 38,233,234,235,232,237,238,239,236,223, 33, 36, 42, 41, 59, 94, /* 96 */
815 45, 47,194,196,192,193,195,197,199,209,166, 44, 37, 95, 62, 63, /* 112 */
816 248,201,202,203,200,205,206,207,204, 96, 58, 35, 64, 39, 61, 34, /* 128 */
817 216, 97, 98, 99,100,101,102,103,104,105,171,187,240,253,254,177, /* 144 */
818 176,106,107,108,109,110,111,112,113,114,170,186,230,184,198,164, /* 160 */
819 181,126,115,116,117,118,119,120,121,122,161,191,208, 91,222,174, /* 176 */
820 172,163,165,183,169,167,182,188,189,190,221,168,175, 93,180,215, /* 192 */
821 123, 65, 66, 67, 68, 69, 70, 71, 72, 73,173,244,246,242,243,245, /* 208 */
822 125, 74, 75, 76, 77, 78, 79, 80, 81, 82,185,251,252,249,250,255, /* 224 */
823 92,247, 83, 84, 85, 86, 87, 88, 89, 90,178,212,214,210,211,213, /* 240 */
824 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,179,219,220,217,218,159 /* 256 */
825 };
826
827
828 static int ibm1047_to_ebcdic_us_table[] = {
829 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 16 */
830 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 32 */
831 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 48 */
832 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 64 */
833 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, 74, 75, 76, 77, 78, 79, /* 80 */
834 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, 90, 91, 92, 93, 94, -1, /* 96 */
835 96, 97, -1, -1, -1, -1, -1, -1, -1, -1,106,107,108,109,110,111, /* 112 */
836 -1, -1, -1, -1, -1, -1, -1, -1, -1,121,122,123,124,125,126,127, /* 128 */
837 -1,129,130,131,132,133,134,135,136,137, -1, -1, -1, -1, -1, -1, /* 144 */
838 -1,145,146,147,148,149,150,151,152,153, -1, -1, -1, -1, -1, -1, /* 160 */
839 -1,161,162,163,164,165,166,167,168,169, -1, -1, -1, -1, -1, -1, /* 176 */
840 95, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 192 */
841 192,193,194,195,196,197,198,199,200,201, -1, -1, -1, -1, -1, -1, /* 208 */
842 208,209,210,211,212,213,214,215,216,217, -1, -1, -1, -1, -1, -1, /* 224 */
843 224, -1,226,227,228,229,230,231,232,233, -1, -1, -1, -1, -1, -1, /* 240 */
844 240,241,242,243,244,245,246,247,248,249, -1, -1, -1, -1, -1,255 /* 256 */
845 };
846
847
848 static int
849 table_convert_char (void *baton, int from, int *to)
850 {
851 int *table = (int *) baton;
852
853 if (0 <= from && from <= 255
854 && table[from] != -1)
855 {
856 *to = table[from];
857 return 1;
858 }
859 else
860 return 0;
861 }
862
863
864 static struct translation *
865 table_translation (const char *from, const char *to, int *table,
866 const char *(*c_target_char_has_backslash_escape)
867 (void *baton, int target_char),
868 void *c_target_char_has_backslash_escape_baton,
869 int (*c_parse_backslash) (void *baton,
870 int host_char,
871 int *target_char),
872 void *c_parse_backslash_baton)
873 {
874 struct translation *t = xmalloc (sizeof (*t));
875
876 memset (t, 0, sizeof (*t));
877 t->from = from;
878 t->to = to;
879 t->c_target_char_has_backslash_escape = c_target_char_has_backslash_escape;
880 t->c_target_char_has_backslash_escape_baton
881 = c_target_char_has_backslash_escape_baton;
882 t->c_parse_backslash = c_parse_backslash;
883 t->c_parse_backslash_baton = c_parse_backslash_baton;
884 t->convert_char = table_convert_char;
885 t->convert_char_baton = (void *) table;
886
887 return t;
888 }
889
890
891 static struct translation *
892 simple_table_translation (const char *from, const char *to, int *table)
893 {
894 return table_translation (from, to, table, 0, 0, 0, 0);
895 }
896
897
898 \f
899 /* Setting and retrieving the host and target charsets. */
900
901
902 /* The current host and target character sets. */
903 static struct charset *current_host_charset, *current_target_charset;
904
905 /* The current functions and batons we should use for the functions in
906 charset.h. */
907
908 static const char *(*c_target_char_has_backslash_escape_func)
909 (void *baton, int target_char);
910 static void *c_target_char_has_backslash_escape_baton;
911
912 static int (*c_parse_backslash_func) (void *baton,
913 int host_char,
914 int *target_char);
915 static void *c_parse_backslash_baton;
916
917 static int (*host_char_to_target_func) (void *baton,
918 int host_char,
919 int *target_char);
920 static void *host_char_to_target_baton;
921
922 static int (*target_char_to_host_func) (void *baton,
923 int target_char,
924 int *host_char);
925 static void *target_char_to_host_baton;
926
927
928 /* Cached iconv conversions, that might be useful to fallback
929 routines. */
930 static struct cached_iconv cached_iconv_host_to_target;
931 static struct cached_iconv cached_iconv_target_to_host;
932
933 \f
934 /* Charset structures manipulation functions. */
935
936 static struct charset *
937 lookup_charset_or_error (const char *name)
938 {
939 struct charset *cs = lookup_charset (name);
940
941 if (! cs)
942 error (_("GDB doesn't know of any character set named `%s'."), name);
943
944 return cs;
945 }
946
947 static void
948 check_valid_host_charset (struct charset *cs)
949 {
950 if (! cs->valid_host_charset)
951 error (_("GDB can't use `%s' as its host character set."), cs->name);
952 }
953
954 /* Set the host and target character sets to HOST and TARGET. */
955 static void
956 set_host_and_target_charsets (struct charset *host, struct charset *target)
957 {
958 struct translation *h2t, *t2h;
959
960 /* If they're not both initialized yet, then just do nothing for
961 now. As soon as we're done running our initialize function,
962 everything will be initialized. */
963 if (! host || ! target)
964 {
965 current_host_charset = host;
966 current_target_charset = target;
967 return;
968 }
969
970 h2t = lookup_translation (host->name, target->name);
971 t2h = lookup_translation (target->name, host->name);
972
973 /* If the translations don't provide conversion functions, make sure
974 iconv can back them up. Do this *before* modifying any state. */
975 if (host != target)
976 {
977 if (! h2t || ! h2t->convert_char)
978 {
979 if (check_iconv_cache (&cached_iconv_host_to_target, host, target)
980 < 0)
981 error (_("GDB can't convert from the `%s' character set to `%s'."),
982 host->name, target->name);
983 }
984 if (! t2h || ! t2h->convert_char)
985 {
986 if (check_iconv_cache (&cached_iconv_target_to_host, target, host)
987 < 0)
988 error (_("GDB can't convert from the `%s' character set to `%s'."),
989 target->name, host->name);
990 }
991 }
992
993 if (t2h && t2h->c_target_char_has_backslash_escape)
994 {
995 c_target_char_has_backslash_escape_func
996 = t2h->c_target_char_has_backslash_escape;
997 c_target_char_has_backslash_escape_baton
998 = t2h->c_target_char_has_backslash_escape_baton;
999 }
1000 else
1001 c_target_char_has_backslash_escape_func
1002 = default_c_target_char_has_backslash_escape;
1003
1004 if (h2t && h2t->c_parse_backslash)
1005 {
1006 c_parse_backslash_func = h2t->c_parse_backslash;
1007 c_parse_backslash_baton = h2t->c_parse_backslash_baton;
1008 }
1009 else
1010 c_parse_backslash_func = default_c_parse_backslash;
1011
1012 if (h2t && h2t->convert_char)
1013 {
1014 host_char_to_target_func = h2t->convert_char;
1015 host_char_to_target_baton = h2t->convert_char_baton;
1016 }
1017 else if (host == target)
1018 host_char_to_target_func = identity_either_char_to_other;
1019 else
1020 {
1021 host_char_to_target_func = iconv_convert;
1022 host_char_to_target_baton = &cached_iconv_host_to_target;
1023 }
1024
1025 if (t2h && t2h->convert_char)
1026 {
1027 target_char_to_host_func = t2h->convert_char;
1028 target_char_to_host_baton = t2h->convert_char_baton;
1029 }
1030 else if (host == target)
1031 target_char_to_host_func = identity_either_char_to_other;
1032 else
1033 {
1034 target_char_to_host_func = iconv_convert;
1035 target_char_to_host_baton = &cached_iconv_target_to_host;
1036 }
1037
1038 current_host_charset = host;
1039 current_target_charset = target;
1040 }
1041
1042 /* Do the real work of setting the host charset. */
1043 static void
1044 set_host_charset (const char *charset)
1045 {
1046 struct charset *cs = lookup_charset_or_error (charset);
1047 check_valid_host_charset (cs);
1048 set_host_and_target_charsets (cs, current_target_charset);
1049 }
1050
1051 /* Do the real work of setting the target charset. */
1052 static void
1053 set_target_charset (const char *charset)
1054 {
1055 struct charset *cs = lookup_charset_or_error (charset);
1056
1057 set_host_and_target_charsets (current_host_charset, cs);
1058 }
1059
1060 \f
1061 /* 'Set charset', 'set host-charset', 'set target-charset', 'show
1062 charset' sfunc's. */
1063
1064 /* This is the sfunc for the 'set charset' command. */
1065 static void
1066 set_charset_sfunc (char *charset, int from_tty, struct cmd_list_element *c)
1067 {
1068 struct charset *cs = lookup_charset_or_error (host_charset_name);
1069 check_valid_host_charset (cs);
1070 /* CAREFUL: set the target charset here as well. */
1071 target_charset_name = host_charset_name;
1072 set_host_and_target_charsets (cs, cs);
1073 }
1074
1075 /* 'set host-charset' command sfunc. We need a wrapper here because
1076 the function needs to have a specific signature. */
1077 static void
1078 set_host_charset_sfunc (char *charset, int from_tty,
1079 struct cmd_list_element *c)
1080 {
1081 set_host_charset (host_charset_name);
1082 }
1083
1084 /* Wrapper for the 'set target-charset' command. */
1085 static void
1086 set_target_charset_sfunc (char *charset, int from_tty,
1087 struct cmd_list_element *c)
1088 {
1089 set_target_charset (target_charset_name);
1090 }
1091
1092 /* sfunc for the 'show charset' command. */
1093 static void
1094 show_charset (struct ui_file *file, int from_tty, struct cmd_list_element *c,
1095 const char *name)
1096 {
1097 if (current_host_charset == current_target_charset)
1098 fprintf_filtered (file,
1099 _("The current host and target character set is `%s'.\n"),
1100 host_charset ());
1101 else
1102 {
1103 fprintf_filtered (file, _("The current host character set is `%s'.\n"),
1104 host_charset ());
1105 fprintf_filtered (file, _("The current target character set is `%s'.\n"),
1106 target_charset ());
1107 }
1108 }
1109
1110 \f
1111 /* Accessor functions. */
1112
1113 const char *
1114 host_charset (void)
1115 {
1116 return current_host_charset->name;
1117 }
1118
1119 const char *
1120 target_charset (void)
1121 {
1122 return current_target_charset->name;
1123 }
1124
1125
1126 \f
1127 /* Public character management functions. */
1128
1129
1130 const char *
1131 c_target_char_has_backslash_escape (int target_char)
1132 {
1133 return ((*c_target_char_has_backslash_escape_func)
1134 (c_target_char_has_backslash_escape_baton, target_char));
1135 }
1136
1137
1138 int
1139 c_parse_backslash (int host_char, int *target_char)
1140 {
1141 return (*c_parse_backslash_func) (c_parse_backslash_baton,
1142 host_char, target_char);
1143 }
1144
1145
1146 int
1147 host_char_print_literally (int host_char)
1148 {
1149 return ((*current_host_charset->host_char_print_literally)
1150 (current_host_charset->host_char_print_literally_baton,
1151 host_char));
1152 }
1153
1154
1155 int
1156 target_char_to_control_char (int target_char, int *target_ctrl_char)
1157 {
1158 return ((*current_target_charset->target_char_to_control_char)
1159 (current_target_charset->target_char_to_control_char_baton,
1160 target_char, target_ctrl_char));
1161 }
1162
1163
1164 int
1165 host_char_to_target (int host_char, int *target_char)
1166 {
1167 return ((*host_char_to_target_func)
1168 (host_char_to_target_baton, host_char, target_char));
1169 }
1170
1171
1172 int
1173 target_char_to_host (int target_char, int *host_char)
1174 {
1175 return ((*target_char_to_host_func)
1176 (target_char_to_host_baton, target_char, host_char));
1177 }
1178
1179
1180 \f
1181 /* The charset.c module initialization function. */
1182
1183 extern initialize_file_ftype _initialize_charset; /* -Wmissing-prototype */
1184
1185 void
1186 _initialize_charset (void)
1187 {
1188 struct cmd_list_element *new_cmd;
1189
1190 /* Register all the character set GDB knows about.
1191
1192 You should use the same names that iconv does, where possible, to
1193 take advantage of the iconv-based default behaviors.
1194
1195 CAUTION: if you register a character set, you must also register
1196 as many translations as are necessary to make that character set
1197 interoperate correctly with all the other character sets. We do
1198 provide default behaviors when no translation is available, or
1199 when a translation's function pointer for a particular operation
1200 is zero. Hopefully, these defaults will be correct often enough
1201 that we won't need to provide too many translations. */
1202 register_charset (simple_charset ("ASCII", 1,
1203 ascii_print_literally, 0,
1204 ascii_to_control, 0));
1205 register_charset (iso_8859_family_charset ("ISO-8859-1"));
1206 register_charset (ebcdic_family_charset ("EBCDIC-US"));
1207 register_charset (ebcdic_family_charset ("IBM1047"));
1208 register_iconv_charsets ();
1209
1210 {
1211 struct { char *from; char *to; int *table; } tlist[] = {
1212 { "ASCII", "ISO-8859-1", ascii_to_iso_8859_1_table },
1213 { "ASCII", "EBCDIC-US", ascii_to_ebcdic_us_table },
1214 { "ASCII", "IBM1047", ascii_to_ibm1047_table },
1215 { "ISO-8859-1", "ASCII", iso_8859_1_to_ascii_table },
1216 { "ISO-8859-1", "EBCDIC-US", iso_8859_1_to_ebcdic_us_table },
1217 { "ISO-8859-1", "IBM1047", iso_8859_1_to_ibm1047_table },
1218 { "EBCDIC-US", "ASCII", ebcdic_us_to_ascii_table },
1219 { "EBCDIC-US", "ISO-8859-1", ebcdic_us_to_iso_8859_1_table },
1220 { "EBCDIC-US", "IBM1047", ebcdic_us_to_ibm1047_table },
1221 { "IBM1047", "ASCII", ibm1047_to_ascii_table },
1222 { "IBM1047", "ISO-8859-1", ibm1047_to_iso_8859_1_table },
1223 { "IBM1047", "EBCDIC-US", ibm1047_to_ebcdic_us_table }
1224 };
1225
1226 int i;
1227
1228 for (i = 0; i < (sizeof (tlist) / sizeof (tlist[0])); i++)
1229 register_translation (simple_table_translation (tlist[i].from,
1230 tlist[i].to,
1231 tlist[i].table));
1232 }
1233
1234 set_host_charset (host_charset_name);
1235 set_target_charset (target_charset_name);
1236
1237 add_setshow_enum_cmd ("charset", class_support,
1238 host_charset_enum, &host_charset_name, _("\
1239 Set the host and target character sets."), _("\
1240 Show the host and target character sets."), _("\
1241 The `host character set' is the one used by the system GDB is running on.\n\
1242 The `target character set' is the one used by the program being debugged.\n\
1243 You may only use supersets of ASCII for your host character set; GDB does\n\
1244 not support any others.\n\
1245 To see a list of the character sets GDB supports, type `set charset <TAB>'."),
1246 /* Note that the sfunc below needs to set
1247 target_charset_name, because the 'set
1248 charset' command sets two variables. */
1249 set_charset_sfunc,
1250 show_charset,
1251 &setlist, &showlist);
1252
1253 add_setshow_enum_cmd ("host-charset", class_support,
1254 host_charset_enum, &host_charset_name, _("\
1255 Set the host character set."), _("\
1256 Show the host character set."), _("\
1257 The `host character set' is the one used by the system GDB is running on.\n\
1258 You may only use supersets of ASCII for your host character set; GDB does\n\
1259 not support any others.\n\
1260 To see a list of the character sets GDB supports, type `set host-charset <TAB>'."),
1261 set_host_charset_sfunc,
1262 show_host_charset_name,
1263 &setlist, &showlist);
1264
1265 add_setshow_enum_cmd ("target-charset", class_support,
1266 target_charset_enum, &target_charset_name, _("\
1267 Set the target character set."), _("\
1268 Show the target character set."), _("\
1269 The `target character set' is the one used by the program being debugged.\n\
1270 GDB translates characters and strings between the host and target\n\
1271 character sets as needed.\n\
1272 To see a list of the character sets GDB supports, type `set target-charset'<TAB>"),
1273 set_target_charset_sfunc,
1274 show_target_charset_name,
1275 &setlist, &showlist);
1276 }