This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH/RFC] charset.c/charset.exp/doco updates


Ok, here are the changes to make charset.c use the set/show mechanism
with enums.  Also, it now uses 'ASCII', 'ISO', 'IBM', 'EBDDIC' (which
makes it consistent with the doco). This means that only uppercase
charset names are used, and the case-insensitive string comparison
function is no longer necessary.

The other change is that 'show target-charset' shows now only the
value of the target-charset variable, instead of showing both host and
target. To see both host and target charsets, use 'show charset'.
The 'show charset' command has not changed.

Given that we use enums/set/show, we now have completion. Therefore if
you type 'set charset <ENTER>' or 'set host-charset <ENTER>' or 'set
target-charset <ENTER>' you get an error message. If you type any of
the above followed by TAB-TAB you get the list of valid charsets.
Note that since 'set charset' sets both the host and the target
charsets to be the same, the completion on this command shows the
intersection of the valid target charsets and the valid host
charsets. Right now such intersection is just the host charset (I
don't think there is much value in displaying all the possible
charsets and then entering one that will be rejected).

I updated the testsuite file and the doco as well.

elena


2003-04-24  Elena Zannoni  <ezannoni at redhat dot 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 note used outside the file.

Index: charset.c
===================================================================
RCS file: /cvs/uberbaum/gdb/charset.c,v
retrieving revision 1.3
diff -u -p -c -r1.3 charset.c
*** charset.c	14 Jan 2003 00:49:03 -0000	1.3
--- charset.c	24 Apr 2003 22:24:43 -0000
*************** struct charset {
*** 96,102 ****
    struct charset *next;
  
    /* The name of the character set.  Comparisons on character set
!      names are case-insensitive.  */
    const char *name;
  
    /* Non-zero iff this character set can be used as a host character
--- 96,102 ----
    struct charset *next;
  
    /* The name of the character set.  Comparisons on character set
!      names are case-sensitive.  */
    const char *name;
  
    /* Non-zero iff this character set can be used as a host character
*************** struct translation {
*** 125,131 ****
  
    /* This structure describes functions going from the FROM character
       set to the TO character set.  Comparisons on character set names
!      are case-insensitive.  */
    const char *from, *to;
  
    /* Pointers to translation-specific functions, and data pointers to
--- 125,131 ----
  
    /* This structure describes functions going from the FROM character
       set to the TO character set.  Comparisons on character set names
!      are case-sensitive.  */
    const char *from, *to;
  
    /* Pointers to translation-specific functions, and data pointers to
*************** struct translation {
*** 156,171 ****
  /* 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++;
  
!   return tolower (*p) - tolower (*q);
! }
  
  
  /* The global list of all the charsets GDB knows about.  */
  static struct charset *all_charsets;
--- 156,187 ----
  /* The global lists of character sets and translations.  */
  
  
! #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
! 
! 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;
*************** lookup_charset (const char *name)
*** 192,198 ****
    struct charset *cs;
  
    for (cs = all_charsets; cs; cs = cs->next)
!     if (! strcmp_case_insensitive (name, cs->name))
        return cs;
  
    return NULL;
--- 208,214 ----
    struct charset *cs;
  
    for (cs = all_charsets; cs; cs = cs->next)
!     if (! strcmp (name, cs->name))
        return cs;
  
    return NULL;
*************** lookup_translation (const char *from, co
*** 217,224 ****
    struct translation *t;
  
    for (t = all_translations; t; t = t->next)
!     if (! strcmp_case_insensitive (from, t->from)
!         && ! strcmp_case_insensitive (to, t->to))
        return t;
  
    return 0;
--- 233,240 ----
    struct translation *t;
  
    for (t = all_translations; t; t = t->next)
!     if (! strcmp (from, t->from)
!         && ! strcmp (to, t->to))
        return t;
  
    return 0;
*************** static void *target_char_to_host_baton;
*** 897,902 ****
--- 913,938 ----
  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
*************** set_host_and_target_charsets (struct cha
*** 986,1020 ****
    current_target_charset = target;
  }
  
  
! 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);
  }
  
  
! 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);
  }
  
  
  const char *
  host_charset (void)
--- 1022,1097 ----
    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);
+ }
  
! /* Do the real work of setting the target charset.  */
! static void
! set_target_charset (const char *charset)
  {
!   struct charset *cs = lookup_charset_or_error (charset);
  
!   set_host_and_target_charsets (current_host_charset, 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
! set_host_charset_sfunc (char *charset, int from_tty,
! 			  struct cmd_list_element *c)
  {
!   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);
+ }
  
! /* sfunc for the 'show charset' command.  */
! static void
! show_charset (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 ());
!     }
  }
  
+ 
+ /* Accessor functions.  */
  
  const char *
  host_charset (void)
*************** host_charset (void)
*** 1022,1037 ****
    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)
  {
--- 1099,1104 ----
*************** target_char_to_host (int target_char, in
*** 1094,1197 ****
  
  
  
- /* 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)
  {
    /* Register all the character set GDB knows about.
  
       You should use the same names that iconv does, where possible, to
--- 1161,1174 ----
  
  
  
  /* The charset.c module initialization function.  */
  
  
  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
*************** _initialize_charset (void)
*** 1204,1231 ****
       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,
                                      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_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 }
      };
  
      int i;
--- 1181,1208 ----
       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,
                                      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_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 }
      };
  
      int i;
*************** _initialize_charset (void)
*** 1236,1275 ****
                                                        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);
  }
--- 1213,1275 ----
                                                        tlist[i].table));
    }
  
!   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);
  }



Index: charset.h
===================================================================
RCS file: /cvs/uberbaum/gdb/charset.h,v
retrieving revision 1.1
diff -u -p -r1.1 charset.h
--- charset.h   20 Sep 2002 00:24:01 -0000      1.1
+++ charset.h   24 Apr 2003 22:21:42 -0000
@@ -46,22 +46,11 @@
    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




2003-04-24  Elena Zannoni  <ezannoni at redhat dot com>

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



Index: charset.exp
===================================================================
RCS file: /cvs/uberbaum/gdb/testsuite/gdb.base/charset.exp,v
retrieving revision 1.1
diff -u -p -c -r1.1 charset.exp
*** charset.exp	20 Sep 2002 00:26:06 -0000	1.1
--- charset.exp	24 Apr 2003 22:19:56 -0000
*************** proc parse_show_charset_output {testname
*** 48,58 ****
--- 48,70 ----
          -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 $" {
*************** proc parse_show_charset_output {testname
*** 63,69 ****
          }
      }
  
!     return [list $host_charset $target_charset]
  }
  
  
--- 75,81 ----
          }
      }
  
!     return $retlist
  }
  
  
*************** set show_charset [parse_show_charset_out
*** 77,83 ****
  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]} {
      pass "check `show target-charset' against `show charset'"
  } else {
      fail "check `show target-charset' against `show charset'"
--- 89,95 ----
  send_gdb "show target-charset\n"
  set show_target_charset [parse_show_charset_output "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'"
*************** if {! [string compare $show_charset $sho
*** 86,106 ****
  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]} {
      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"
  
! # True iff we've seen the "Valid character sets are:" message.
! set seen_valid 0
  
! # True iff we've seen the "can be used as a host character set" message.
! set seen_can_host 0
  
  # 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
--- 98,168 ----
  send_gdb "show host-charset\n"
  set show_host_charset [parse_show_charset_output "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 (host) charsets as possible completions.
! send_gdb "set charset \t\t"
  
! # 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"
  
! # 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
*************** proc all_charset_names {} {
*** 113,185 ****
      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)
  }
  
  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 "^  (\[^ \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 "^\\* - can be used as a host character set\[\r\n\]+" {
!         set seen_can_host 1
!         exp_continue
      }
!     -re ".*${gdb_prompt} $" {
!         # We don't do an exp_continue here.
      }
      timeout {
!         fail "get valid character sets (timeout)"
      }
  }
  
  
! # 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"
      }
- } else {
-     fail "get valid character sets (no ascii charset)"
- }
  
  
! # 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"
  
  
! # 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"
  
  
  # Make sure that GDB supports every host/target charset combination.
  foreach host_charset [all_charset_names] {
--- 175,247 ----
      return [array names charsets]
  }
  
  proc valid_host_charset {charset} {
      global charsets
      return $charsets($charset)
  }
  
+ send_gdb "set host-charset\n"
  gdb_expect {
!     -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,.\]*)" {
! 	#set host_charset_list $expect_out(1,string)
! 	set charsets($expect_out(1,string)) 1
! 	exp_continue
! 	#pass "capture valid host charsets"
!     }
! 
!     -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 $" {
! 	fail "capture valid host charsets"
      }
      timeout {
! 	fail "(timeout) capture valid host charsets"
      }
  }
  
  
! 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
      }
  
+     -re ", (\[^ \t\n\r,.\]*)" {
+ 	set target_charset $expect_out(1,string)
+ 	if {! [info exists charsets($target_charset)]} {
+ 	    set charsets($target_charset) 0
+ 	}
+ 	exp_continue
+     }
  
!     -re "\\.\r\n$gdb_prompt $" {
! 	pass "capture valid target charsets"
  
+     }
  
!     -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_expect {
*** 341,347 ****
  }
  
  
! gdb_test "set host-charset ascii" ""
  foreach target_charset [all_charset_names] {
      send_gdb "set target-charset $target_charset\n" 
      gdb_expect {
--- 403,409 ----
  }
  
  
! gdb_test "set host-charset ASCII" ""
  foreach target_charset [all_charset_names] {
      send_gdb "set target-charset $target_charset\n" 
      gdb_expect {




2003-04-24  Elena Zannoni  <ezannoni at redhat dot com>

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


Index: gdb.texinfo
===================================================================
RCS file: /cvs/uberbaum/gdb/doc/gdb.texinfo,v
retrieving revision 1.156
diff -u -p -r1.156 gdb.texinfo
--- gdb.texinfo	14 Apr 2003 18:42:28 -0000	1.156
+++ gdb.texinfo	24 Apr 2003 21:50:08 -0000
@@ -5952,7 +5952,7 @@ remote protocol (@pxref{Remote,Remote De
 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
- at 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
+ at code{set target-charset} followed by @key{TAB} at 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 overrid
 
 @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
- at 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
+ at code{set target-charset} followed by @key{TAB} at 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} at key{TAB},
+ at value{GDBN} will list the name of the character sets that can be used
+for both host and target.
+
 
 @item show charset
- at itemx show host-charset
- at itemx show target-charset
 @kindex show charset
+Show the names of the current host and target charsets. 
+
+ at itemx show host-charset
 @kindex show host-charset
+Show the name of the current host charset. 
+
+ at 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} at 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 t
 @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.
 
 


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]