struct charset *next;
/* The name of the character set. Comparisons on character set
- names are case-insensitive. */
+ names are case-sensitive. */
const char *name;
/* Non-zero iff this character set can be used as a host character
/* This structure describes functions going from the FROM character
set to the TO character set. Comparisons on character set names
- are case-insensitive. */
+ are case-sensitive. */
const char *from, *to;
/* Pointers to translation-specific functions, and data pointers to
/* The global lists of character sets and translations. */
-/* Character set names are always compared ignoring case. */
-static int
-strcmp_case_insensitive (const char *p, const char *q)
-{
- while (*p && *q && tolower (*p) == tolower (*q))
- p++, q++;
+#ifndef GDB_DEFAULT_HOST_CHARSET
+#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
+#endif
- return tolower (*p) - tolower (*q);
-}
+#ifndef GDB_DEFAULT_TARGET_CHARSET
+#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
+#endif
+
+static const char *host_charset_name = GDB_DEFAULT_HOST_CHARSET;
+static const char *target_charset_name = GDB_DEFAULT_TARGET_CHARSET;
+static const char *host_charset_enum[] =
+{
+ "ASCII",
+ "ISO-8859-1",
+ 0
+};
+
+static const char *target_charset_enum[] =
+{
+ "ASCII",
+ "ISO-8859-1",
+ "EBCDIC-US",
+ "IBM1047",
+ 0
+};
/* The global list of all the charsets GDB knows about. */
static struct charset *all_charsets;
struct charset *cs;
for (cs = all_charsets; cs; cs = cs->next)
- if (! strcmp_case_insensitive (name, cs->name))
+ if (! strcmp (name, cs->name))
return cs;
return NULL;
struct translation *t;
for (t = all_translations; t; t = t->next)
- if (! strcmp_case_insensitive (from, t->from)
- && ! strcmp_case_insensitive (to, t->to))
+ if (! strcmp (from, t->from)
+ && ! strcmp (to, t->to))
return t;
return 0;
static struct cached_iconv cached_iconv_host_to_target;
static struct cached_iconv cached_iconv_target_to_host;
+\f
+/* Charset structures manipulation functions. */
+
+static struct charset *
+lookup_charset_or_error (const char *name)
+{
+ struct charset *cs = lookup_charset (name);
+
+ if (! cs)
+ error ("GDB doesn't know of any character set named `%s'.", name);
+
+ return cs;
+}
+
+static void
+check_valid_host_charset (struct charset *cs)
+{
+ if (! cs->valid_host_charset)
+ error ("GDB can't use `%s' as its host character set.", cs->name);
+}
/* Set the host and target character sets to HOST and TARGET. */
static void
current_target_charset = target;
}
+/* Do the real work of setting the host charset. */
+static void
+set_host_charset (const char *charset)
+{
+ struct charset *cs = lookup_charset_or_error (charset);
+ check_valid_host_charset (cs);
+ set_host_and_target_charsets (cs, current_target_charset);
+}
-static struct charset *
-lookup_charset_or_error (const char *name)
+/* Do the real work of setting the target charset. */
+static void
+set_target_charset (const char *charset)
{
- struct charset *cs = lookup_charset (name);
+ struct charset *cs = lookup_charset_or_error (charset);
- if (! cs)
- error ("GDB doesn't know of any character set named `%s'.", name);
+ set_host_and_target_charsets (current_host_charset, cs);
+}
- return cs;
+\f
+/* 'Set charset', 'set host-charset', 'set target-charset', 'show
+ charset' sfunc's. */
+
+/* This is the sfunc for the 'set charset' command. */
+static void
+set_charset_sfunc (char *charset, int from_tty, struct cmd_list_element *c)
+{
+ struct charset *cs = lookup_charset_or_error (host_charset_name);
+ check_valid_host_charset (cs);
+ /* CAREFUL: set the target charset here as well. */
+ target_charset_name = host_charset_name;
+ set_host_and_target_charsets (cs, cs);
}
-
+/* 'set host-charset' command sfunc. We need a wrapper here because
+ the function needs to have a specific signature. */
static void
-check_valid_host_charset (struct charset *cs)
+set_host_charset_sfunc (char *charset, int from_tty,
+ struct cmd_list_element *c)
{
- if (! cs->valid_host_charset)
- error ("GDB can't use `%s' as its host character set.", cs->name);
+ set_host_charset (host_charset_name);
}
+/* Wrapper for the 'set target-charset' command. */
+static void
+set_target_charset_sfunc (char *charset, int from_tty,
+ struct cmd_list_element *c)
+{
+ set_target_charset (target_charset_name);
+}
-void
-set_host_charset (const char *charset)
+/* sfunc for the 'show charset' command. */
+static void
+show_charset (char *arg, int from_tty)
{
- struct charset *cs = lookup_charset_or_error (charset);
- check_valid_host_charset (cs);
- set_host_and_target_charsets (cs, current_target_charset);
+ if (current_host_charset == current_target_charset)
+ {
+ printf_filtered ("The current host and target character set is `%s'.\n",
+ host_charset ());
+ }
+ else
+ {
+ printf_filtered ("The current host character set is `%s'.\n",
+ host_charset ());
+ printf_filtered ("The current target character set is `%s'.\n",
+ target_charset ());
+ }
}
+\f
+/* Accessor functions. */
const char *
host_charset (void)
return current_host_charset->name;
}
-
-void
-set_target_charset (const char *charset)
-{
- struct charset *cs = lookup_charset_or_error (charset);
-
- set_host_and_target_charsets (current_host_charset, cs);
-}
-
-
const char *
target_charset (void)
{
}
-\f
-/* Commands. */
-
-
-/* List the valid character sets. If HOST_ONLY is non-zero, list only
- those character sets which can be used as GDB's host character set. */
-static void
-list_charsets (int host_only)
-{
- struct charset *cs;
-
- printf_filtered ("Valid character sets are:\n");
-
- for (cs = all_charsets; cs; cs = cs->next)
- if (host_only && cs->valid_host_charset)
- printf_filtered (" %s\n", cs->name);
- else
- printf_filtered (" %s %s\n",
- cs->name,
- cs->valid_host_charset ? "*" : " ");
-
- if (! host_only)
- printf_filtered ("* - can be used as a host character set\n");
-}
-
-
-static void
-set_charset_command (char *arg, int from_tty)
-{
- if (! arg || arg[0] == '\0')
- list_charsets (0);
- else
- {
- struct charset *cs = lookup_charset_or_error (arg);
- check_valid_host_charset (cs);
- set_host_and_target_charsets (cs, cs);
- }
-}
-
-
-static void
-set_host_charset_command (char *arg, int from_tty)
-{
- if (! arg || arg[0] == '\0')
- list_charsets (1);
- else
- {
- struct charset *cs = lookup_charset_or_error (arg);
- check_valid_host_charset (cs);
- set_host_and_target_charsets (cs, current_target_charset);
- }
-}
-
-
-static void
-set_target_charset_command (char *arg, int from_tty)
-{
- if (! arg || arg[0] == '\0')
- list_charsets (0);
- else
- {
- struct charset *cs = lookup_charset_or_error (arg);
- set_host_and_target_charsets (current_host_charset, cs);
- }
-}
-
-
-static void
-show_charset_command (char *arg, int from_tty)
-{
- if (current_host_charset == current_target_charset)
- {
- printf_filtered ("The current host and target character set is `%s'.\n",
- host_charset ());
- }
- else
- {
- printf_filtered ("The current host character set is `%s'.\n",
- host_charset ());
- printf_filtered ("The current target character set is `%s'.\n",
- target_charset ());
- }
-}
-
-
\f
/* The charset.c module initialization function. */
-#ifndef GDB_DEFAULT_HOST_CHARSET
-#define GDB_DEFAULT_HOST_CHARSET "ISO-8859-1"
-#endif
-
-#ifndef GDB_DEFAULT_TARGET_CHARSET
-#define GDB_DEFAULT_TARGET_CHARSET "ISO-8859-1"
-#endif
void
_initialize_charset (void)
{
+ struct cmd_list_element *new_cmd;
+
/* Register all the character set GDB knows about.
You should use the same names that iconv does, where possible, to
when a translation's function pointer for a particular operation
is zero. Hopefully, these defaults will be correct often enough
that we won't need to provide too many translations. */
- register_charset (simple_charset ("ascii", 1,
+ register_charset (simple_charset ("ASCII", 1,
ascii_print_literally, 0,
ascii_to_control, 0));
- register_charset (iso_8859_family_charset ("iso-8859-1"));
- register_charset (ebcdic_family_charset ("ebcdic-us"));
- register_charset (ebcdic_family_charset ("ibm1047"));
+ register_charset (iso_8859_family_charset ("ISO-8859-1"));
+ register_charset (ebcdic_family_charset ("EBCDIC-US"));
+ register_charset (ebcdic_family_charset ("IBM1047"));
register_iconv_charsets ();
{
struct { char *from; char *to; int *table; } tlist[] = {
- { "ascii", "iso-8859-1", ascii_to_iso_8859_1_table },
- { "ascii", "ebcdic-us", ascii_to_ebcdic_us_table },
- { "ascii", "ibm1047", ascii_to_ibm1047_table },
- { "iso-8859-1", "ascii", iso_8859_1_to_ascii_table },
- { "iso-8859-1", "ebcdic-us", iso_8859_1_to_ebcdic_us_table },
- { "iso-8859-1", "ibm1047", iso_8859_1_to_ibm1047_table },
- { "ebcdic-us", "ascii", ebcdic_us_to_ascii_table },
- { "ebcdic-us", "iso-8859-1", ebcdic_us_to_iso_8859_1_table },
- { "ebcdic-us", "ibm1047", ebcdic_us_to_ibm1047_table },
- { "ibm1047", "ascii", ibm1047_to_ascii_table },
- { "ibm1047", "iso-8859-1", ibm1047_to_iso_8859_1_table },
- { "ibm1047", "ebcdic-us", ibm1047_to_ebcdic_us_table }
+ { "ASCII", "ISO-8859-1", ascii_to_iso_8859_1_table },
+ { "ASCII", "EBCDIC-US", ascii_to_ebcdic_us_table },
+ { "ASCII", "IBM1047", ascii_to_ibm1047_table },
+ { "ISO-8859-1", "ASCII", iso_8859_1_to_ascii_table },
+ { "ISO-8859-1", "EBCDIC-US", iso_8859_1_to_ebcdic_us_table },
+ { "ISO-8859-1", "IBM1047", iso_8859_1_to_ibm1047_table },
+ { "EBCDIC-US", "ASCII", ebcdic_us_to_ascii_table },
+ { "EBCDIC-US", "ISO-8859-1", ebcdic_us_to_iso_8859_1_table },
+ { "EBCDIC-US", "IBM1047", ebcdic_us_to_ibm1047_table },
+ { "IBM1047", "ASCII", ibm1047_to_ascii_table },
+ { "IBM1047", "ISO-8859-1", ibm1047_to_iso_8859_1_table },
+ { "IBM1047", "EBCDIC-US", ibm1047_to_ebcdic_us_table }
};
int i;
tlist[i].table));
}
- set_host_charset (GDB_DEFAULT_HOST_CHARSET);
- set_target_charset (GDB_DEFAULT_TARGET_CHARSET);
-
- add_cmd ("charset", class_support, set_charset_command,
- "Use CHARSET as the host and target character set.\n"
- "The `host character set' is the one used by the system GDB is running on.\n"
- "The `target character set' is the one used by the program being debugged.\n"
- "You may only use supersets of ASCII for your host character set; GDB does\n"
- "not support any others.\n"
- "To see a list of the character sets GDB supports, type `set charset'\n"
- "with no argument.",
- &setlist);
-
- add_cmd ("host-charset", class_support, set_host_charset_command,
- "Use CHARSET as the host character set.\n"
- "The `host character set' is the one used by the system GDB is running on.\n"
- "You may only use supersets of ASCII for your host character set; GDB does\n"
- "not support any others.\n"
- "To see a list of the character sets GDB supports, type `set host-charset'\n"
- "with no argument.",
- &setlist);
-
- add_cmd ("target-charset", class_support, set_target_charset_command,
- "Use CHARSET as the target character set.\n"
- "The `target character set' is the one used by the program being debugged.\n"
- "GDB translates characters and strings between the host and target\n"
- "character sets as needed.\n"
- "To see a list of the character sets GDB supports, type `set target-charset'\n"
- "with no argument.",
- &setlist);
-
- add_cmd ("charset", class_support, show_charset_command,
- "Show the current host and target character sets.",
- &showlist);
- add_alias_cmd ("host-charset", "charset", class_alias, 1, &showlist);
- add_alias_cmd ("target-charset", "charset", class_alias, 1, &showlist);
+ set_host_charset (host_charset_name);
+ set_target_charset (target_charset_name);
+
+ new_cmd = add_set_enum_cmd ("charset",
+ class_support,
+ host_charset_enum,
+ &host_charset_name,
+ "Set the host and target character sets.\n"
+ "The `host character set' is the one used by the system GDB is running on.\n"
+ "The `target character set' is the one used by the program being debugged.\n"
+ "You may only use supersets of ASCII for your host character set; GDB does\n"
+ "not support any others.\n"
+ "To see a list of the character sets GDB supports, type `set charset <TAB>'.",
+ &setlist);
+
+ /* Note that the sfunc below needs to set target_charset_name, because
+ the 'set charset' command sets two variables. */
+ set_cmd_sfunc (new_cmd, set_charset_sfunc);
+ /* Don't use set_from_show - need to print some extra info. */
+ add_cmd ("charset", class_support, show_charset,
+ "Show the host and target character sets.\n"
+ "The `host character set' is the one used by the system GDB is running on.\n"
+ "The `target character set' is the one used by the program being debugged.\n"
+ "You may only use supersets of ASCII for your host character set; GDB does\n"
+ "not support any others.\n"
+ "To see a list of the character sets GDB supports, type `set charset <TAB>'.",
+ &showlist);
+
+
+ new_cmd = add_set_enum_cmd ("host-charset",
+ class_support,
+ host_charset_enum,
+ &host_charset_name,
+ "Set the host character set.\n"
+ "The `host character set' is the one used by the system GDB is running on.\n"
+ "You may only use supersets of ASCII for your host character set; GDB does\n"
+ "not support any others.\n"
+ "To see a list of the character sets GDB supports, type `set host-charset <TAB>'.",
+ &setlist);
+
+ set_cmd_sfunc (new_cmd, set_host_charset_sfunc);
+
+ add_show_from_set (new_cmd, &showlist);
+
+
+
+ new_cmd = add_set_enum_cmd ("target-charset",
+ class_support,
+ target_charset_enum,
+ &target_charset_name,
+ "Set the target character set.\n"
+ "The `target character set' is the one used by the program being debugged.\n"
+ "GDB translates characters and strings between the host and target\n"
+ "character sets as needed.\n"
+ "To see a list of the character sets GDB supports, type `set target-charset'<TAB>",
+ &setlist);
+
+ set_cmd_sfunc (new_cmd, set_target_charset_sfunc);
+ add_show_from_set (new_cmd, &showlist);
}
running on an IBM mainframe, which uses the @sc{ebcdic} character set,
then the host character set is Latin-1, and the target character set is
@sc{ebcdic}. If you give @value{GDBN} the command @code{set
-target-charset ebcdic-us}, then @value{GDBN} translates between
+target-charset EBCDIC-US}, then @value{GDBN} translates between
@sc{ebcdic} and Latin 1 as you print character or string values, or use
character and string literals in expressions.
@item set target-charset @var{charset}
@kindex set target-charset
Set the current target character set to @var{charset}. We list the
-character set names @value{GDBN} recognizes below, but if you invoke the
-@code{set target-charset} command with no argument, @value{GDBN} lists
-the character sets it supports.
+character set names @value{GDBN} recognizes below, but if you type
+@code{set target-charset} followed by @key{TAB}@key{TAB}, @value{GDBN} will
+list the target character sets it supports.
@end table
@table @code
@value{GDBN} can only use certain character sets as its host character
set. We list the character set names @value{GDBN} recognizes below, and
-indicate which can be host character sets, but if you invoke the
-@code{set host-charset} command with no argument, @value{GDBN} lists the
-character sets it supports, placing an asterisk (@samp{*}) after those
-it can use as a host character set.
+indicate which can be host character sets, but if you type
+@code{set target-charset} followed by @key{TAB}@key{TAB}, @value{GDBN} will
+list the host character sets it supports.
@item set charset @var{charset}
@kindex set charset
-Set the current host and target character sets to @var{charset}. If you
-invoke the @code{set charset} command with no argument, it lists the
-character sets it supports. @value{GDBN} can only use certain character
-sets as its host character set; it marks those in the list with an
-asterisk (@samp{*}).
+Set the current host and target character sets to @var{charset}. As
+above, if you type @code{set charset} followed by @key{TAB}@key{TAB},
+@value{GDBN} will list the name of the character sets that can be used
+for both host and target.
+
@item show charset
-@itemx show host-charset
-@itemx show target-charset
@kindex show charset
+Show the names of the current host and target charsets.
+
+@itemx show host-charset
@kindex show host-charset
+Show the name of the current host charset.
+
+@itemx show target-charset
@kindex show target-charset
-Show the current host and target charsets. The @code{show host-charset}
-and @code{show target-charset} commands are synonyms for @code{show
-charset}.
+Show the name of the current target charset.
@end table
@item ISO-8859-1
@cindex ISO 8859-1 character set
@cindex ISO Latin 1 character set
-The ISO Latin 1 character set. This extends ASCII with accented
+The ISO Latin 1 character set. This extends @sc{ascii} with accented
characters needed for French, German, and Spanish. @value{GDBN} can use
this as its host character set.
@smallexample
(gdb) show charset
-The current host and target character set is `iso-8859-1'.
+The current host and target character set is `ISO-8859-1'.
(gdb)
@end smallexample
For the sake of printing this manual, let's use @sc{ascii} as our
initial character set:
@smallexample
-(gdb) set charset ascii
+(gdb) set charset ASCII
(gdb) show charset
-The current host and target character set is `ascii'.
+The current host and target character set is `ASCII'.
(gdb)
@end smallexample
(gdb)
@end smallexample
-If we invoke the @code{set target-charset} command without an argument,
+If we invoke the @code{set target-charset} followed by @key{TAB}@key{TAB},
@value{GDBN} tells us the character sets it supports:
@smallexample
(gdb) set target-charset
-Valid character sets are:
- ascii *
- iso-8859-1 *
- ebcdic-us
- ibm1047
-* - can be used as a host character set
+ASCII EBCDIC-US IBM1047 ISO-8859-1
+(gdb) set target-charset
@end smallexample
We can select @sc{ibm1047} as our target character set, and examine the
@sc{ascii}, and they display correctly:
@smallexample
-(gdb) set target-charset ibm1047
+(gdb) set target-charset IBM1047
(gdb) show charset
-The current host character set is `ascii'.
-The current target character set is `ibm1047'.
+The current host character set is `ASCII'.
+The current target character set is `IBM1047'.
(gdb) print ascii_hello
$6 = 0x401698 "\110\145%%?\054\040\167?\162%\144\041\012"
(gdb) print ascii_hello[0]
(gdb)
@end smallexample
-The IBM1047 character set uses the number 78 to encode the @samp{+}
+The @sc{ibm1047} character set uses the number 78 to encode the @samp{+}
character.
-re "The current host and target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
set host_charset $expect_out(1,string)
set target_charset $expect_out(1,string)
+ set retlist [list $host_charset $target_charset]
pass $testname
}
-re "The current host character set is `(.*)'\\.\[\r\n\]+The current target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
set host_charset $expect_out(1,string)
set target_charset $expect_out(2,string)
+ set retlist [list $host_charset $target_charset]
+ pass $testname
+ }
+ -re "The host character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
+ set host_charset $expect_out(1,string)
+ set retlist [list $host_charset]
+ pass $testname
+ }
+ -re "The target character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
+ set target_charset $expect_out(1,string)
+ set retlist [list $target_charset]
pass $testname
}
-re ".*$gdb_prompt $" {
}
}
- return [list $host_charset $target_charset]
+ return $retlist
}
send_gdb "show target-charset\n"
set show_target_charset [parse_show_charset_output "show target-charset"]
-if {! [string compare $show_charset $show_target_charset]} {
+if {[lsearch $show_charset $show_target_charset] >= 0} {
pass "check `show target-charset' against `show charset'"
} else {
fail "check `show target-charset' against `show charset'"
send_gdb "show host-charset\n"
set show_host_charset [parse_show_charset_output "show host-charset"]
-if {! [string compare $show_charset $show_host_charset]} {
+if {[lsearch $show_charset $show_host_charset] >= 0} {
pass "check `show host-charset' against `show charset'"
} else {
fail "check `show host-charset' against `show charset'"
}
-# Get the list of supported charsets.
-send_gdb "set charset\n"
+# Get the list of supported (host) charsets as possible completions.
+send_gdb "set charset \t\t"
-# True iff we've seen the "Valid character sets are:" message.
-set seen_valid 0
+# Check that we can at least use ASCII as a host character set.
+sleep 1
+gdb_expect {
+ -re "^set charset .*\r\nASCII.*\r\n$gdb_prompt set charset " {
+ # We got the output that we wanted, including ASCII as possible
+ # charset. Send a newline to get us back to the prompt. This will
+ # also generate an error message. Let's not check here that the error
+ # message makes sense, we do that below, as a separate testcase.
+ send_gdb "\n"
+ gdb_expect {
+ -re ".*Requires an argument.*$gdb_prompt $" {
+ pass "get valid character sets"
+ }
+ -re ".*$gdb_prompt $" {
+ send_gdb "\n"
+ gdb_expect {
+ -re ".*$gdb_prompt $" {
+ fail "get valid character sets"
+ }
+ }
+ }
+ timeout {
+ fail "(timeout) get valid character sets"
+ }
+ }
+ }
+ -re ".*$gdb_prompt $" {
+ # We got some output that ended with a regular prompt
+ fail "get valid character sets"
+ }
+ -re "^set charset.*$" {
+ # We got some other output, send a cntrl-c to gdb to get us back
+ # to the prompt.
+ send_gdb "\003"
+ fail "get valid character sets"
+ }
+ timeout {
+ fail "get valid character sets (timeout)"
+ }
+}
+
+# Try a malformed `set charset'.
+gdb_test "set charset" \
+ "Requires an argument. Valid arguments are.*" \
+ "try malformed `set charset'"
+
+# Try using `set host-charset' on an invalid character set.
+gdb_test "set host-charset my_grandma_bonnie" \
+ "Undefined item: \"my_grandma_bonnie\"." \
+ "try `set host-charset' with invalid charset"
-# True iff we've seen the "can be used as a host character set" message.
-set seen_can_host 0
+# Try using `set target-charset' on an invalid character set.
+gdb_test "set target-charset my_grandma_bonnie" \
+ "Undefined item: \"my_grandma_bonnie\"." \
+ "try `set target-charset' with invalid charset"
# A Tcl array mapping the names of all the character sets we've seen
# to "1" if the character set can be used as a host character set, or
return [array names charsets]
}
-proc charset_exists {charset} {
- global charsets
- return [info exists charsets($charset)]
-}
-
proc valid_host_charset {charset} {
global charsets
return $charsets($charset)
}
+send_gdb "set host-charset\n"
gdb_expect {
- -re "Valid character sets are:\[\r\n\]+" {
- # There's no ^ at the beginning of the pattern above, so that
- # expect can skip the echoed `set charset' command.
- set seen_valid 1
- exp_continue
+ -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
+ #set host_charset_list $expect_out(1,string)
+ set charsets($expect_out(1,string)) 1
+ exp_continue
+ #pass "capture valid host charsets"
}
- -re "^ (\[^ \t\n\]*) \\*\[\r\n\]+" {
- set charsets($expect_out(1,string)) 1
- exp_continue
- }
- -re "^ (\[^ \t\n\]*)\[ \t\]*\[\r\n\]+" {
- set charsets($expect_out(1,string)) 0
- exp_continue
+
+ -re ", (\[^ \t\n\r,.\]*)" {
+ #set host_charset_list $expect_out(1,string)
+ set charsets($expect_out(1,string)) 1
+ exp_continue
+ #pass "capture valid host charsets"
}
- -re "^\\* - can be used as a host character set\[\r\n\]+" {
- set seen_can_host 1
- exp_continue
+
+ -re "\\.\r\n$gdb_prompt $" {
+ #set host_charset_list $expect_out(1,string)
+ set charsets($expect_out(1,string)) 1
+ pass "capture valid host charsets"
}
- -re ".*${gdb_prompt} $" {
- # We don't do an exp_continue here.
+
+ -re ".*$gdb_prompt $" {
+ fail "capture valid host charsets"
}
timeout {
- fail "get valid character sets (timeout)"
+ fail "(timeout) capture valid host charsets"
}
}
-# Check that we've seen all the right pieces of the output, and that
-# we can at least use ASCII as a host character set.
-if {$seen_valid && $seen_can_host && [charset_exists ascii]} {
- # We can't do the below as part of the test above, since all the
- # [] substitution takes place before any expression evaluation
- # takes place; && doesn't really short circuit things the way
- # you'd like. We'd get an "can't read $charsets(ascii)" error
- # even when `info exists' had returned zero.
- if {[valid_host_charset ascii]} {
- pass "get valid character sets"
- } else {
- fail "get valid character sets"
+send_gdb "set target-charset\n"
+gdb_expect {
+ -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
+ set target_charset $expect_out(1,string)
+ if {! [info exists charsets($target_charset)]} {
+ set charsets($target_charset) 0
+ }
+ exp_continue
}
-} else {
- fail "get valid character sets (no ascii charset)"
-}
+ -re ", (\[^ \t\n\r,.\]*)" {
+ set target_charset $expect_out(1,string)
+ if {! [info exists charsets($target_charset)]} {
+ set charsets($target_charset) 0
+ }
+ exp_continue
+ }
-# Try using `set host-charset' on an invalid character set.
-gdb_test "set host-charset my_grandma_bonnie" \
- "GDB doesn't know of any character set named `my_grandma_bonnie'." \
- "try `set host-charset' with invalid charset"
+ -re "\\.\r\n$gdb_prompt $" {
+ pass "capture valid target charsets"
+ }
-# Try using `set target-charset' on an invalid character set.
-gdb_test "set target-charset my_grandma_bonnie" \
- "GDB doesn't know of any character set named `my_grandma_bonnie'." \
- "try `set target-charset' with invalid charset"
+ -re ".*$gdb_prompt $" {
+ fail "capture valid target charsets"
+ }
+ timeout {
+ fail "(timeout) capture valid target charsets"
+ }
+}
# Make sure that GDB supports every host/target charset combination.
foreach host_charset [all_charset_names] {
}
-gdb_test "set host-charset ascii" ""
+gdb_test "set host-charset ASCII" ""
foreach target_charset [all_charset_names] {
send_gdb "set target-charset $target_charset\n"
gdb_expect {
projects / binutils-gdb.git / commitdiff