[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.base / charset.exp

# This testcase is part of GDB, the GNU debugger.

# Copyright 2001, 2004, 2007 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# Please email any bugs, comments, and/or additions to this file to:
# bug-gdb@gnu.org

# Test GDB's character set support.

if $tracelevel then {
	strace $tracelevel
}

set prms_id 0
set bug_id 0

set testfile "charset"
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/${testfile}
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
    untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
    return -1
}

# Start with a fresh gdb.
gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}

# Parse the output from a `show charset' command.  Return the host
# and target charset as a two-element list.
proc parse_show_charset_output {testname} {
    global gdb_prompt

    gdb_expect {
        -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 $" {
            fail $testname
        }
        timeout {
            fail "$testname (timeout)"
        }
    }

    return $retlist
}


# Try the various `show charset' commands.  These are all aliases of each
# other; `show target-charset' and `show host-charset' actually print
# both the host and target charsets.

send_gdb "show charset\n"
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 {[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 {[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 ".*$gdb_prompt 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
# "0" otherwise.  We can use `array names charsets' just to get a list
# of all character sets.
array set charsets {}

proc all_charset_names {} {
    global charsets
    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)
	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] {
    if {[valid_host_charset $host_charset]} {

        set testname "try `set host-charset $host_charset'"
        send_gdb "set host-charset $host_charset\n"
        gdb_expect {
            -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
                # How did it get into `charsets' then?
                fail "$testname (didn't recognize name)"
            }
            -re "GDB can't use `.*' as its host character set\\.\[\r\n]+${gdb_prompt} $" {
                # Well, then why does its `charsets' entry say it can?
                fail $testname
            }
            -re "${gdb_prompt} $" {
                pass $testname
            }
            timeout {
                fail "$testname (timeout)"
            }
        }

        # Check that the command actually had its intended effect:
        # $host_charset should now be the host character set.
        send_gdb "show charset\n"
        set result [parse_show_charset_output "parse `show charset' after `set host-charset $host_charset'"]
        if {! [string compare [lindex $result 0] $host_charset]} {
            pass "check effect of `set host-charset $host_charset'"
        } else {
            fail "check effect of `set host-charset $host_charset'"
        }

        # Now try setting every possible target character set,
        # given that host charset.
        foreach target_charset [all_charset_names] {
            set testname "try `set target-charset $target_charset'"
            send_gdb "set target-charset $target_charset\n"
            gdb_expect {
                -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
                    fail "$testname (didn't recognize name)"
                }
                -re "GDB can't convert from the .* character set to .*\\.\[\r\n\]+${gdb_prompt} $" {
                    # This is a serious problem.  GDB should be able to convert
                    # between any arbitrary pair of character sets.
                    fail "$testname (can't convert)"
                }
                -re "${gdb_prompt} $" {
                    pass $testname
                }
                timeout {
                    fail "$testname (timeout)"
                }
            }

            # Check that the command actually had its intended effect:
            # $target_charset should now be the target charset.
            send_gdb "show charset\n"
            set result [parse_show_charset_output "parse `show charset' after `set target-charset $target_charset'"]
            if {! [string compare $result [list $host_charset $target_charset]]} {
                pass "check effect of `set target-charset $target_charset'"
            } else {
                fail "check effect of `set target-charset $target_charset'"
            }

            # Test handling of characters in the host charset which
            # can't be translated into the target charset.  \xA2 is
            # `cent' in ISO-8859-1, which has no equivalent in ASCII.
            #
            # On some systems, the pseudo-tty through which we
            # communicate with GDB insists on stripping the high bit
            # from input characters, meaning that `cent' turns into
            # `"'.  Since ISO-8859-1 and ASCII are identical in the
            # lower 128 characters, it's tough to see how we can test
            # this behavior on such systems, so we just xfail it.
	    #
	    # Note: the \x16 (Control-V) is an escape to allow \xA2 to
	    # get past readline.
            if {! [string compare $host_charset iso-8859-1] && ! [string compare $target_charset ascii]} {

                set testname "untranslatable character in character literal"
                send_gdb "print '\x16\xA2'\n"
                gdb_expect {
                    -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
                        pass $testname
                    }
                    -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
                        xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
                    }
                    -re "$gdb_prompt $" {
                        fail $testname
                    }
                    timeout {
                        fail "$testname (timeout)"
                    }
                }

                set testname "untranslatable character in string literal"
                # If the PTTY zeros bit seven, then this turns into
                #   print """
                # which gets us a syntax error.  We don't care.
                send_gdb "print \"\x16\xA2\"\n"
                gdb_expect {
                    -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
                        pass $testname
                    }
                    -re "Unterminated string in expression.\[\r\n\]+$gdb_prompt $" {
                        xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
                    }
                    -re "$gdb_prompt $" {
                        fail $testname
                    }
                    timeout {
                        fail "$testname (timeout)"
                    }
                }

                set testname "untranslatable characters in backslash escape"
                send_gdb "print '\\\x16\xA2'\n"
                gdb_expect {
                    -re "The escape sequence .* is equivalent to plain .*, which has no equivalent\[\r\n\]+in the .* character set\\.\[\r\n\]+$gdb_prompt $" {
                        pass $testname
                    }
                    -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
                        xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
                    }
                    -re "$gdb_prompt $" {
                        fail $testname
                    }
                    timeout {
                        fail "$testname (timeout)"
                    }
                }
            }
        }
    }
}


# Set the host character set to plain ASCII, and try actually printing
# some strings in various target character sets.  We need to run the
# test program to the point at which the strings have been
# initialized.
gdb_test "break ${srcfile}:[gdb_get_line_number "all strings initialized"]" \
         ".*Breakpoint.* at .*" \
         "set breakpoint after all strings have been initialized"
gdb_run_cmd
gdb_expect {
    -re "Breakpoint.*all strings initialized.*$gdb_prompt $" {
        pass "run until all strings have been initialized"
    }
    -re "$gdb_prompt $" {
        fail "run until all strings have been initialized"
    }
    timeout {
        fail "run until all strings have been initialized (timeout)"
    }
}


gdb_test "set host-charset ASCII" ""
foreach target_charset [all_charset_names] {
    send_gdb "set target-charset $target_charset\n" 
    gdb_expect {
        -re "$gdb_prompt $" {
            pass "set target-charset $target_charset"
        }
        timeout {
            fail "set target-charset $target_charset (timeout)"
        }
    }

    # Try printing the null character.  There seems to be a bug in
    # gdb_test that requires us to use gdb_expect here.
    send_gdb "print '\\0'\n"
    gdb_expect {
        -re "\\\$${decimal} = 0 '\\\\0'\[\r\n\]+$gdb_prompt $" {
            pass "print the null character in ${target_charset}"
        }
        -re "$gdb_prompt $" {
            fail "print the null character in ${target_charset}"
        }
        timeout {
            fail "print the null character in ${target_charset} (timeout)"
        }
    }

    # Compute the name of the variable in the test program that holds
    # a string in $target_charset.  The variable's name is the
    # character set's name, in lower-case, with all non-identifier
    # characters replaced with '_', with "_string" stuck on the end.
    set var_name [string tolower "${target_charset}_string"]
    regsub -all -- "\[^a-z0-9_\]" $var_name "_" var_name
    
    # Compute a regexp matching the results we expect.  This is static,
    # but it's easier than writing it out.
    regsub -all "." "abfnrtv" "(\\\\&|x)" escapes
    set uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    set lowercase "abcdefghijklmnopqrstuvwxyz"
    set digits "0123456789"
    set octal_escape "\\\\\[0-9\]\[0-9\]\[0-9\]"

    send_gdb "print $var_name\n"
    # ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
    gdb_expect {
        -re ".* = \"(\\\\a|x)(\\\\b|x)(\\\\f|x)(\\\\n|x)(\\\\r|x)(\\\\t|x)(\\\\v|x)${uppercase}${lowercase}${digits}(\\\\\[0-9\]\[0-9\]\[0-9\]|x)(\\\\\[0-9\]\[0-9\]\[0-9\]|x).*\"\[\r\n\]+$gdb_prompt $" {
            pass "print string in $target_charset"
        }
        -re "$gdb_prompt $" {
            fail "print string in $target_charset"
        }
        timeout {
            fail "print string in $target_charset (timeout)"
        }
    }

    # Try entering a character literal, and see if it comes back unchanged.
    gdb_test "print 'A'" \
             " = \[0-9-\]+ 'A'" \
             "parse character literal in ${target_charset}"

    # Check that the character literal was encoded correctly.
    gdb_test "print 'A' == $var_name\[7\]" \
             " = 1" \
             "check value of parsed character literal in ${target_charset}"

    # Try entering a string literal, and see if it comes back unchanged.
    gdb_test "print \"abcdefABCDEF012345\"" \
             " = \"abcdefABCDEF012345\"" \
             "parse string literal in ${target_charset}"

    # Check that the string literal was encoded correctly.
    gdb_test "print \"q\"\[0\] == $var_name\[49\]" \
             " = 1" \
             "check value of parsed string literal in ${target_charset}"

    # Test handling of characters in the target charset which
    # can't be translated into the host charset.
    if {! [string compare $target_charset iso-8859-1]} {
        gdb_test "print iso_8859_1_string\[69\]" \
                 " = \[0-9-\]+ '\\\\242'" \
                 "print character with no equivalent in host character set"
        gdb_test "print iso_8859_1_string + 70" \
                 " = ${hex} \"\\\\242.*\"" \
                 "print string with no equivalent in host character set"
    }

    # Make sure that we don't apply the ISO-8859-1 `print_literally'
    # function to ASCII.
    if {! [string compare $target_charset ascii]} {
        gdb_test "print iso_8859_1_string\[69\]" \
                 " = \[0-9-\]+ '\\\\242'" \
                 "print ASCII unprintable character"
        gdb_test "print iso_8859_1_string + 70" \
                 " = ${hex} \"\\\\242.*\"" \
                 "print ASCII unprintable string"
    }

    # Try printing characters with backslash escape equivalents.
    set escapees {a b f n r t v}
    for {set i 0} {$i < [llength $escapees]} {incr i} {
        set escape [lindex $escapees $i]
        send_gdb "print $var_name\[$i\]\n"
        set have_escape 1
        gdb_expect {
            -re "= \[0-9-\]+ '\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
                pass "try printing '\\${escape}' in ${target_charset}"
            }
            -re "= \[0-9-\]+ 'x'\[\r\n\]+$gdb_prompt $" {
                xfail "try printing '\\${escape}' in ${target_charset} (no such escape)"
                set have_escape 0
            }
            -re "$gdb_prompt $" {
                fail "try printing '\\${escape}' in ${target_charset}"
            }
            timeout {
                fail "try printing '\\${escape}' in ${target_charset} (timeout)"
            }
        }

        if {$have_escape} {

            # Try parsing a backslash escape in a character literal.
            gdb_test "print '\\${escape}' == $var_name\[$i\]" \
                     " = 1" \
                     "check value of '\\${escape}' in ${target_charset}"

            # Try parsing a backslash escape in a string literal.
            gdb_test "print \"\\${escape}\"\[0\] == $var_name\[$i\]" \
                     " = 1" \
                     "check value of \"\\${escape}\" in ${target_charset}"
        }
    }

    # Try printing a character escape that doesn't exist.  We should 
    # get the unescaped character, in the target character set.
    gdb_test "print '\\q'" " = \[0-9-\]+ 'q'" \
             "print escape that doesn't exist in $target_charset"
    gdb_test "print '\\q' == $var_name\[49\]" " = 1" \
             "check value of escape that doesn't exist in $target_charset"
}

gdb_exit
Commit	Line	Data
0dcd613f AC	1	# This testcase is part of GDB, the GNU debugger.
0dcd613f AC	2
6aba47ca	3	# Copyright 2001, 2004, 2007 Free Software Foundation, Inc.
dea97812 KB	4
	5	# This program is free software; you can redistribute it and/or modify
	6	# it under the terms of the GNU General Public License as published by
e22f8b7c	7	# the Free Software Foundation; either version 3 of the License, or
dea97812	8	# (at your option) any later version.
e22f8b7c	9	#
dea97812 KB	10	# This program is distributed in the hope that it will be useful,
	11	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	# GNU General Public License for more details.
e22f8b7c	14	#
dea97812	15	# You should have received a copy of the GNU General Public License
e22f8b7c	16	# along with this program. If not, see <http://www.gnu.org/licenses/>.
dea97812 KB	17
dea97812 KB	18	# Please email any bugs, comments, and/or additions to this file to:
0dcd613f	19	# bug-gdb@gnu.org
dea97812 KB	20
	21	# Test GDB's character set support.
	22
	23	if $tracelevel then {
	24	strace $tracelevel
	25	}
	26
	27	set prms_id 0
	28	set bug_id 0
	29
	30	set testfile "charset"
	31	set srcfile ${testfile}.c
	32	set binfile ${objdir}/${subdir}/${testfile}
	33	if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
f21565d2 JB	34	untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
f21565d2 JB	35	return -1
dea97812 KB	36	}
	37
	38	# Start with a fresh gdb.
	39	gdb_exit
	40	gdb_start
	41	gdb_reinitialize_dir $srcdir/$subdir
	42	gdb_load ${binfile}
	43
	44	# Parse the output from a `show charset' command. Return the host
	45	# and target charset as a two-element list.
	46	proc parse_show_charset_output {testname} {
	47	global gdb_prompt
	48
	49	gdb_expect {
	50	-re "The current host and target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
	51	set host_charset $expect_out(1,string)
	52	set target_charset $expect_out(1,string)
e33d66ec	53	set retlist [list $host_charset $target_charset]
dea97812 KB	54	pass $testname
	55	}
	56	-re "The current host character set is `(.)'\\.\[\r\n\]+The current target character set is `(.)'\\.\[\r\n\]+$gdb_prompt $" {
	57	set host_charset $expect_out(1,string)
	58	set target_charset $expect_out(2,string)
e33d66ec EZ	59	set retlist [list $host_charset $target_charset]
	60	pass $testname
	61	}
	62	-re "The host character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
	63	set host_charset $expect_out(1,string)
	64	set retlist [list $host_charset]
	65	pass $testname
	66	}
	67	-re "The target character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
	68	set target_charset $expect_out(1,string)
	69	set retlist [list $target_charset]
dea97812 KB	70	pass $testname
	71	}
	72	-re ".*$gdb_prompt $" {
	73	fail $testname
	74	}
	75	timeout {
	76	fail "$testname (timeout)"
	77	}
	78	}
	79
e33d66ec	80	return $retlist
dea97812 KB	81	}
	82
	83
	84	# Try the various `show charset' commands. These are all aliases of each
	85	# other; `show target-charset' and `show host-charset' actually print
	86	# both the host and target charsets.
	87
	88	send_gdb "show charset\n"
	89	set show_charset [parse_show_charset_output "show charset"]
	90
	91	send_gdb "show target-charset\n"
	92	set show_target_charset [parse_show_charset_output "show target-charset"]
	93
e33d66ec	94	if {[lsearch $show_charset $show_target_charset] >= 0} {
dea97812 KB	95	pass "check `show target-charset' against `show charset'"
	96	} else {
	97	fail "check `show target-charset' against `show charset'"
	98	}
	99
	100	send_gdb "show host-charset\n"
	101	set show_host_charset [parse_show_charset_output "show host-charset"]
	102
e33d66ec	103	if {[lsearch $show_charset $show_host_charset] >= 0} {
dea97812 KB	104	pass "check `show host-charset' against `show charset'"
	105	} else {
	106	fail "check `show host-charset' against `show charset'"
	107	}
	108
	109
e33d66ec EZ	110	# Get the list of supported (host) charsets as possible completions.
e33d66ec EZ	111	send_gdb "set charset \t\t"
dea97812	112
e33d66ec EZ	113	# Check that we can at least use ASCII as a host character set.
	114	sleep 1
	115	gdb_expect {
	116	-re "^set charset .\r\nASCII.\r\n$gdb_prompt set charset " {
	117	# We got the output that we wanted, including ASCII as possible
	118	# charset. Send a newline to get us back to the prompt. This will
	119	# also generate an error message. Let's not check here that the error
	120	# message makes sense, we do that below, as a separate testcase.
	121	send_gdb "\n"
	122	gdb_expect {
	123	-re ".Requires an argument.$gdb_prompt $" {
	124	pass "get valid character sets"
	125	}
	126	-re ".*$gdb_prompt $" {
	127	send_gdb "\n"
	128	gdb_expect {
	129	-re ".*$gdb_prompt $" {
	130	fail "get valid character sets"
	131	}
	132	}
	133	}
	134	timeout {
	135	fail "(timeout) get valid character sets"
	136	}
	137	}
	138	}
	139	-re ".*$gdb_prompt $" {
	140	# We got some output that ended with a regular prompt
	141	fail "get valid character sets"
	142	}
1b413552	143	-re ".$gdb_prompt set charset.$" {
e33d66ec EZ	144	# We got some other output, send a cntrl-c to gdb to get us back
	145	# to the prompt.
	146	send_gdb "\003"
	147	fail "get valid character sets"
	148	}
	149	timeout {
	150	fail "get valid character sets (timeout)"
	151	}
	152	}
	153
	154	# Try a malformed `set charset'.
	155	gdb_test "set charset" \
	156	"Requires an argument. Valid arguments are.*" \
	157	"try malformed `set charset'"
	158
	159	# Try using `set host-charset' on an invalid character set.
	160	gdb_test "set host-charset my_grandma_bonnie" \
	161	"Undefined item: \"my_grandma_bonnie\"." \
	162	"try `set host-charset' with invalid charset"
dea97812	163
e33d66ec EZ	164	# Try using `set target-charset' on an invalid character set.
	165	gdb_test "set target-charset my_grandma_bonnie" \
	166	"Undefined item: \"my_grandma_bonnie\"." \
	167	"try `set target-charset' with invalid charset"
dea97812 KB	168
	169	# A Tcl array mapping the names of all the character sets we've seen
	170	# to "1" if the character set can be used as a host character set, or
	171	# "0" otherwise. We can use `array names charsets' just to get a list
	172	# of all character sets.
	173	array set charsets {}
	174
	175	proc all_charset_names {} {
	176	global charsets
	177	return [array names charsets]
	178	}
	179
dea97812 KB	180	proc valid_host_charset {charset} {
	181	global charsets
	182	return $charsets($charset)
	183	}
	184
e33d66ec	185	send_gdb "set host-charset\n"
dea97812	186	gdb_expect {
e33d66ec EZ	187	-re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
	188	#set host_charset_list $expect_out(1,string)
	189	set charsets($expect_out(1,string)) 1
	190	exp_continue
	191	#pass "capture valid host charsets"
dea97812	192	}
e33d66ec EZ	193
	194	-re ", (\[^ \t\n\r,.\]*)" {
	195	#set host_charset_list $expect_out(1,string)
	196	set charsets($expect_out(1,string)) 1
	197	exp_continue
	198	#pass "capture valid host charsets"
dea97812	199	}
e33d66ec EZ	200
	201	-re "\\.\r\n$gdb_prompt $" {
	202	#set host_charset_list $expect_out(1,string)
e33d66ec	203	pass "capture valid host charsets"
dea97812	204	}
e33d66ec EZ	205
	206	-re ".*$gdb_prompt $" {
	207	fail "capture valid host charsets"
dea97812 KB	208	}
dea97812 KB	209	timeout {
e33d66ec	210	fail "(timeout) capture valid host charsets"
dea97812 KB	211	}
	212	}
	213
	214
e33d66ec EZ	215	send_gdb "set target-charset\n"
	216	gdb_expect {
	217	-re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
	218	set target_charset $expect_out(1,string)
	219	if {! [info exists charsets($target_charset)]} {
	220	set charsets($target_charset) 0
	221	}
	222	exp_continue
dea97812	223	}
dea97812	224
e33d66ec EZ	225	-re ", (\[^ \t\n\r,.\]*)" {
	226	set target_charset $expect_out(1,string)
	227	if {! [info exists charsets($target_charset)]} {
	228	set charsets($target_charset) 0
	229	}
	230	exp_continue
	231	}
dea97812	232
e33d66ec EZ	233	-re "\\.\r\n$gdb_prompt $" {
e33d66ec EZ	234	pass "capture valid target charsets"
dea97812	235
e33d66ec	236	}
dea97812	237
e33d66ec EZ	238	-re ".*$gdb_prompt $" {
	239	fail "capture valid target charsets"
	240	}
dea97812	241
e33d66ec EZ	242	timeout {
	243	fail "(timeout) capture valid target charsets"
	244	}
	245	}
dea97812 KB	246
	247	# Make sure that GDB supports every host/target charset combination.
	248	foreach host_charset [all_charset_names] {
	249	if {[valid_host_charset $host_charset]} {
	250
	251	set testname "try `set host-charset $host_charset'"
	252	send_gdb "set host-charset $host_charset\n"
	253	gdb_expect {
	254	-re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
	255	# How did it get into `charsets' then?
	256	fail "$testname (didn't recognize name)"
	257	}
	258	-re "GDB can't use `.*' as its host character set\\.\[\r\n]+${gdb_prompt} $" {
	259	# Well, then why does its `charsets' entry say it can?
	260	fail $testname
	261	}
	262	-re "${gdb_prompt} $" {
	263	pass $testname
	264	}
	265	timeout {
	266	fail "$testname (timeout)"
	267	}
	268	}
	269
	270	# Check that the command actually had its intended effect:
	271	# $host_charset should now be the host character set.
	272	send_gdb "show charset\n"
	273	set result [parse_show_charset_output "parse `show charset' after `set host-charset $host_charset'"]
	274	if {! [string compare [lindex $result 0] $host_charset]} {
	275	pass "check effect of `set host-charset $host_charset'"
	276	} else {
	277	fail "check effect of `set host-charset $host_charset'"
	278	}
	279
	280	# Now try setting every possible target character set,
	281	# given that host charset.
	282	foreach target_charset [all_charset_names] {
	283	set testname "try `set target-charset $target_charset'"
	284	send_gdb "set target-charset $target_charset\n"
	285	gdb_expect {
	286	-re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
	287	fail "$testname (didn't recognize name)"
	288	}
	289	-re "GDB can't convert from the .* character set to .*\\.\[\r\n\]+${gdb_prompt} $" {
	290	# This is a serious problem. GDB should be able to convert
	291	# between any arbitrary pair of character sets.
	292	fail "$testname (can't convert)"
	293	}
	294	-re "${gdb_prompt} $" {
	295	pass $testname
	296	}
	297	timeout {
	298	fail "$testname (timeout)"
	299	}
	300	}
	301
	302	# Check that the command actually had its intended effect:
	303	# $target_charset should now be the target charset.
	304	send_gdb "show charset\n"
	305	set result [parse_show_charset_output "parse `show charset' after `set target-charset $target_charset'"]
	306	if {! [string compare $result [list $host_charset $target_charset]]} {
	307	pass "check effect of `set target-charset $target_charset'"
	308	} else {
	309	fail "check effect of `set target-charset $target_charset'"
310	}
311
312	# Test handling of characters in the host charset which
313	# can't be translated into the target charset. \xA2 is
314	# `cent' in ISO-8859-1, which has no equivalent in ASCII.
315	#
316	# On some systems, the pseudo-tty through which we
317	# communicate with GDB insists on stripping the high bit
318	# from input characters, meaning that `cent' turns into
319	# `"'. Since ISO-8859-1 and ASCII are identical in the
320	# lower 128 characters, it's tough to see how we can test
321	# this behavior on such systems, so we just xfail it.
322	#
323	# Note: the \x16 (Control-V) is an escape to allow \xA2 to
324	# get past readline.
325	if {! [string compare $host_charset iso-8859-1] && ! [string compare $target_charset ascii]} {
326
327	set testname "untranslatable character in character literal"
328	send_gdb "print '\x16\xA2'\n"
329	gdb_expect {
330	-re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
331	pass $testname
332	}
333	-re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
334	xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
335	}
336	-re "$gdb_prompt $" {
337	fail $testname
338	}
339	timeout {
340	fail "$testname (timeout)"
341	}
342	}
343
344	set testname "untranslatable character in string literal"
345	# If the PTTY zeros bit seven, then this turns into
346	# print """
347	# which gets us a syntax error. We don't care.
348	send_gdb "print \"\x16\xA2\"\n"
349	gdb_expect {
350	-re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
351	pass $testname
352	}
353	-re "Unterminated string in expression.\[\r\n\]+$gdb_prompt $" {
354	xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
355	}
356	-re "$gdb_prompt $" {
357	fail $testname
358	}
359	timeout {
360	fail "$testname (timeout)"
361	}
362	}
363
364	set testname "untranslatable characters in backslash escape"
365	send_gdb "print '\\\x16\xA2'\n"
366	gdb_expect {
367	-re "The escape sequence .* is equivalent to plain ., which has no equivalent\[\r\n\]+in the . character set\\.\[\r\n\]+$gdb_prompt $" {
368	pass $testname
369	}
370	-re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
371	xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
372	}
373	-re "$gdb_prompt $" {
374	fail $testname
375	}
376	timeout {
377	fail "$testname (timeout)"
378	}
379	}
380	}
381	}
382	}
383	}
384
385
386	# Set the host character set to plain ASCII, and try actually printing
387	# some strings in various target character sets. We need to run the
388	# test program to the point at which the strings have been
389	# initialized.
381bc39b	390	gdb_test "break ${srcfile}:[gdb_get_line_number "all strings initialized"]" \
dea97812 KB	391	".Breakpoint. at .*" \
	392	"set breakpoint after all strings have been initialized"
	393	gdb_run_cmd
	394	gdb_expect {
	395	-re "Breakpoint.all strings initialized.$gdb_prompt $" {
	396	pass "run until all strings have been initialized"
	397	}
	398	-re "$gdb_prompt $" {
	399	fail "run until all strings have been initialized"
	400	}
	401	timeout {
	402	fail "run until all strings have been initialized (timeout)"
	403	}
	404	}
	405
	406
e33d66ec	407	gdb_test "set host-charset ASCII" ""
dea97812 KB	408	foreach target_charset [all_charset_names] {
	409	send_gdb "set target-charset $target_charset\n"
	410	gdb_expect {
	411	-re "$gdb_prompt $" {
	412	pass "set target-charset $target_charset"
	413	}
	414	timeout {
	415	fail "set target-charset $target_charset (timeout)"
	416	}
	417	}
	418
	419	# Try printing the null character. There seems to be a bug in
	420	# gdb_test that requires us to use gdb_expect here.
	421	send_gdb "print '\\0'\n"
	422	gdb_expect {
	423	-re "\\\$${decimal} = 0 '\\\\0'\[\r\n\]+$gdb_prompt $" {
	424	pass "print the null character in ${target_charset}"
	425	}
	426	-re "$gdb_prompt $" {
	427	fail "print the null character in ${target_charset}"
	428	}
	429	timeout {
	430	fail "print the null character in ${target_charset} (timeout)"
	431	}
	432	}
	433
	434	# Compute the name of the variable in the test program that holds
	435	# a string in $target_charset. The variable's name is the
	436	# character set's name, in lower-case, with all non-identifier
	437	# characters replaced with '_', with "_string" stuck on the end.
	438	set var_name [string tolower "${target_charset}_string"]
	439	regsub -all -- "\[^a-z0-9_\]" $var_name "_" var_name
	440
	441	# Compute a regexp matching the results we expect. This is static,
	442	# but it's easier than writing it out.
0dcd613f	443	regsub -all "." "abfnrtv" "(\\\\&\|x)" escapes
dea97812 KB	444	set uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	445	set lowercase "abcdefghijklmnopqrstuvwxyz"
	446	set digits "0123456789"
	447	set octal_escape "\\\\\[0-9\]\[0-9\]\[0-9\]"
	448
	449	send_gdb "print $var_name\n"
	450	# ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
	451	gdb_expect {
0dcd613f	452	-re ".* = \"(\\\\a\|x)(\\\\b\|x)(\\\\f\|x)(\\\\n\|x)(\\\\r\|x)(\\\\t\|x)(\\\\v\|x)${uppercase}${lowercase}${digits}(\\\\\[0-9\]\[0-9\]\[0-9\]\|x)(\\\\\[0-9\]\[0-9\]\[0-9\]\|x).*\"\[\r\n\]+$gdb_prompt $" {
dea97812 KB	453	pass "print string in $target_charset"
	454	}
	455	-re "$gdb_prompt $" {
	456	fail "print string in $target_charset"
	457	}
	458	timeout {
	459	fail "print string in $target_charset (timeout)"
	460	}
	461	}
	462
	463	# Try entering a character literal, and see if it comes back unchanged.
	464	gdb_test "print 'A'" \
	465	" = \[0-9-\]+ 'A'" \
	466	"parse character literal in ${target_charset}"
	467
	468	# Check that the character literal was encoded correctly.
0dcd613f	469	gdb_test "print 'A' == $var_name\[7\]" \
dea97812 KB	470	" = 1" \
	471	"check value of parsed character literal in ${target_charset}"
	472
	473	# Try entering a string literal, and see if it comes back unchanged.
	474	gdb_test "print \"abcdefABCDEF012345\"" \
	475	" = \"abcdefABCDEF012345\"" \
	476	"parse string literal in ${target_charset}"
	477
	478	# Check that the string literal was encoded correctly.
0dcd613f	479	gdb_test "print \"q\"\[0\] == $var_name\[49\]" \
dea97812 KB	480	" = 1" \
	481	"check value of parsed string literal in ${target_charset}"
	482
	483	# Test handling of characters in the target charset which
	484	# can't be translated into the host charset.
	485	if {! [string compare $target_charset iso-8859-1]} {
0dcd613f	486	gdb_test "print iso_8859_1_string\[69\]" \
dea97812 KB	487	" = \[0-9-\]+ '\\\\242'" \
	488	"print character with no equivalent in host character set"
	489	gdb_test "print iso_8859_1_string + 70" \
	490	" = ${hex} \"\\\\242.*\"" \
	491	"print string with no equivalent in host character set"
	492	}
	493
	494	# Make sure that we don't apply the ISO-8859-1 `print_literally'
	495	# function to ASCII.
	496	if {! [string compare $target_charset ascii]} {
0dcd613f	497	gdb_test "print iso_8859_1_string\[69\]" \
dea97812 KB	498	" = \[0-9-\]+ '\\\\242'" \
	499	"print ASCII unprintable character"
	500	gdb_test "print iso_8859_1_string + 70" \
	501	" = ${hex} \"\\\\242.*\"" \
	502	"print ASCII unprintable string"
	503	}
	504
	505	# Try printing characters with backslash escape equivalents.
0dcd613f	506	set escapees {a b f n r t v}
dea97812 KB	507	for {set i 0} {$i < [llength $escapees]} {incr i} {
	508	set escape [lindex $escapees $i]
	509	send_gdb "print $var_name\[$i\]\n"
	510	set have_escape 1
	511	gdb_expect {
	512	-re "= \[0-9-\]+ '\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
	513	pass "try printing '\\${escape}' in ${target_charset}"
	514	}
	515	-re "= \[0-9-\]+ 'x'\[\r\n\]+$gdb_prompt $" {
	516	xfail "try printing '\\${escape}' in ${target_charset} (no such escape)"
	517	set have_escape 0
	518	}
	519	-re "$gdb_prompt $" {
	520	fail "try printing '\\${escape}' in ${target_charset}"
	521	}
	522	timeout {
	523	fail "try printing '\\${escape}' in ${target_charset} (timeout)"
	524	}
	525	}
	526
	527	if {$have_escape} {
	528
	529	# Try parsing a backslash escape in a character literal.
	530	gdb_test "print '\\${escape}' == $var_name\[$i\]" \
	531	" = 1" \
	532	"check value of '\\${escape}' in ${target_charset}"
	533
	534	# Try parsing a backslash escape in a string literal.
	535	gdb_test "print \"\\${escape}\"\[0\] == $var_name\[$i\]" \
	536	" = 1" \
	537	"check value of \"\\${escape}\" in ${target_charset}"
	538	}
	539	}
	540
	541	# Try printing a character escape that doesn't exist. We should
	542	# get the unescaped character, in the target character set.
	543	gdb_test "print '\\q'" " = \[0-9-\]+ 'q'" \
	544	"print escape that doesn't exist in $target_charset"
0dcd613f	545	gdb_test "print '\\q' == $var_name\[49\]" " = 1" \
dea97812 KB	546	"check value of escape that doesn't exist in $target_charset"
	547	}
	548
	549	gdb_exit