OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [charset.c] - Blame information for rev 294

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.