gdb:

2003-05-02  Elena Zannoni  <ezannoni@redhat.com>

	* charset.c (GDB_DEFAULT_TARGET_CHARSET,
	GDB_DEFAULT_HOST_CHARSET): Move to earlier in the file.
	(host_charset_name, target_charset_name): New vars for use by
	set/show commands.
	(host_charset_enum, target_charset_enum): New enums for set/show
	commands.
	(set_charset_sfunc, set_host_charset_sfunc,
	set_target_charset_sfunc): New functions.
	(set_host_charset, set_target_charset): Make static.
	(list_charsets, set_host_charset_command,
	set_target_charset_command): Delete functions.
	(show_charset_command): Rewrite as....
	(show_charset): Hook this up with the set/show command mechanism.
	(_initialize_charset): Change names of charsets to match the
	set/show enums. Use host_charset_name and target_charset_name.
	Use set/show mechanism for charset, host-charset, target-charset
	commands. Do not make 'show host-charset' and 'show
	target-charset' be aliases of 'show charset'.

	* charset.h (set_host_charset, set_target_charset): Don't export,
	they are not used outside the file.

gdb/testsuite:
2003-05-01  Elena Zannoni  <ezannoni@redhat.com>

	* gdb.base/charset.exp: Update based on new behavior of set/show
	charset commands.

gdb/doc:
2003-05-02  Elena Zannoni  <ezannoni@redhat.com>

	* gdb.texinfo (Character Sets): Update to reflect new behavior of
	set/show charsets commands.

7 files changed, 364 insertions, 282 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index d6635c7..1826ec7 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,27 @@
+2003-05-02  Elena Zannoni  <ezannoni@redhat.com>
+
+	* charset.c (GDB_DEFAULT_TARGET_CHARSET,
+	GDB_DEFAULT_HOST_CHARSET): Move to earlier in the file.
+	(host_charset_name, target_charset_name): New vars for use by
+	set/show commands.
+	(host_charset_enum, target_charset_enum): New enums for set/show
+	commands.
+	(set_charset_sfunc, set_host_charset_sfunc,
+	set_target_charset_sfunc): New functions.
+	(set_host_charset, set_target_charset): Make static.
+	(list_charsets, set_host_charset_command,
+	set_target_charset_command): Delete functions.
+	(show_charset_command): Rewrite as....
+	(show_charset): Hook this up with the set/show command mechanism.
+	(_initialize_charset): Change names of charsets to match the
+	set/show enums. Use host_charset_name and target_charset_name.
+	Use set/show mechanism for charset, host-charset, target-charset
+	commands. Do not make 'show host-charset' and 'show
+	target-charset' be aliases of 'show charset'.
+
+	* charset.h (set_host_charset, set_target_charset): Don't export,
+	they are not used outside the file.
+
 2003-05-01  Andrew Cagney  <cagney@redhat.com>
 
 	* disasm.c (gdb_disassemble_from_exec): Delete global variable.
diff --git a/gdb/charset.c b/gdb/charset.c
index 4f5e5b4..0062e28 100644
--- a/gdb/charset.c
+++ b/gdb/charset.c
@@ -96,7 +96,7 @@ struct charset {
   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
@@ -125,7 +125,7 @@ struct translation {
 
   /* 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
@@ -156,16 +156,32 @@ struct translation {
 /* 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;
@@ -192,7 +208,7 @@ lookup_charset (const char *name)
   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;
@@ -217,8 +233,8 @@ lookup_translation (const char *from, const char *to)
   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;
@@ -897,6 +913,26 @@ static void *target_char_to_host_baton;
 static struct cached_iconv cached_iconv_host_to_target;
 static struct cached_iconv cached_iconv_target_to_host;
 
+
+/* 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
@@ -986,35 +1022,76 @@ set_host_and_target_charsets (struct charset *host, struct charset *target)
   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;
+
+/* '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 ());
+    }
 }
 
+
+/* Accessor functions.  */
 
 const char *
 host_charset (void)
@@ -1022,16 +1099,6 @@ 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)
 {
@@ -1094,104 +1161,14 @@ target_char_to_host (int target_char, int *host_char)
 
 
 
-/* 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 ());
-    }
-}
-
-
-
 /* 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
@@ -1204,28 +1181,28 @@ _initialize_charset (void)
      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;
@@ -1236,40 +1213,63 @@ _initialize_charset (void)
                                                       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);
 }
diff --git a/gdb/charset.h b/gdb/charset.h
index 10578cb..31dbe6f 100644
--- a/gdb/charset.h
+++ b/gdb/charset.h
@@ -46,23 +46,12 @@
    the requirements above, it's easy to plug an entry into GDB's table
    that uses iconv to handle the details.  */
 
-
-/* Set the host character set to CHARSET.  CHARSET must be a superset
-   of ASCII, since GDB's code assumes this.  */
-void set_host_charset (const char *charset);
-
-
-/* Set the target character set to CHARSET.  */
-void set_target_charset (const char *charset);
-
-
 /* Return the name of the current host/target character set.  The
    result is owned by the charset module; the caller should not free
    it.  */
 const char *host_charset (void);
 const char *target_charset (void);
 
-
 /* In general, the set of C backslash escapes (\n, \f) is specific to
    the character set.  Not all character sets will have form feed
    characters, for example.
diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index 7433c58..70a56c2 100644
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,3 +1,8 @@
+2003-05-02  Elena Zannoni  <ezannoni@redhat.com>
+
+	* gdb.texinfo (Character Sets): Update to reflect new behavior of
+	set/show charsets commands.
+
 2003-04-28  Andrew Cagney  <cagney@redhat.com>
 
 	* gdbint.texinfo (Target Architecture Definition): Replace
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 00a4ac7..0aea716 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -5952,7 +5952,7 @@ remote protocol (@pxref{Remote,Remote Debugging}) to debug a program
 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.
 
@@ -5967,9 +5967,9 @@ support:
 @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
@@ -5983,28 +5983,29 @@ system it is running on; you can override that default using the
 
 @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
 
@@ -6021,7 +6022,7 @@ character set.
 @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.
 
@@ -6080,16 +6081,16 @@ strings:
 
 @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
 
@@ -6131,17 +6132,13 @@ $5 = 200 '\310'
 (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
@@ -6151,10 +6148,10 @@ target character set, @sc{ibm1047}, to the host character set,
 @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]
@@ -6175,7 +6172,7 @@ $10 = 78 '+'
 (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.
 
 
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 6dc760e..cdef9e0 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2003-05-02  Elena Zannoni  <ezannoni@redhat.com>
+
+	* gdb.base/charset.exp: Update based on new behavior of set/show
+	charset commands.
+
 2003-05-01  Andrew Cagney  <cagney@redhat.com>
 
 	* gdb.asm/asm-source.exp: Check that "disassm" and "x/i" of a
diff --git a/gdb/testsuite/gdb.base/charset.exp b/gdb/testsuite/gdb.base/charset.exp
index 8e765aa..e17bb14 100644
--- a/gdb/testsuite/gdb.base/charset.exp
+++ b/gdb/testsuite/gdb.base/charset.exp
@@ -48,11 +48,23 @@ proc parse_show_charset_output {testname} {
         -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 $" {
@@ -63,7 +75,7 @@ proc parse_show_charset_output {testname} {
         }
     }
 
-    return [list $host_charset $target_charset]
+    return $retlist
 }
 
 
@@ -77,7 +89,7 @@ set show_charset [parse_show_charset_output "show charset"]
 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'"
@@ -86,21 +98,71 @@ if {! [string compare $show_charset $show_target_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
@@ -113,73 +175,73 @@ proc all_charset_names {} {
     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] {
@@ -341,7 +403,7 @@ gdb_expect {
 }
 
 
-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 {