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