1 # This testcase is part of GDB, the GNU debugger.
3 # Copyright 2001, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
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
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
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.
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 # Please email any bugs, comments, and/or additions to this file to:
21 # Test GDB's character set support.
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}] != "" } {
34 untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
38 # Start with a fresh gdb.
41 gdb_reinitialize_dir $srcdir/$subdir
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} {
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)
53 set retlist [list $host_charset $target_charset]
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)
59 set retlist [list $host_charset $target_charset]
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]
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]
72 -re ".*$gdb_prompt $" {
76 fail "$testname (timeout)"
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.
88 send_gdb "show charset\n"
89 set show_charset [parse_show_charset_output "show charset"]
91 send_gdb "show target-charset\n"
92 set show_target_charset [parse_show_charset_output "show target-charset"]
94 if {[lsearch $show_charset $show_target_charset] >= 0} {
95 pass "check `show target-charset' against `show charset'"
97 fail "check `show target-charset' against `show charset'"
100 send_gdb "show host-charset\n"
101 set show_host_charset [parse_show_charset_output "show host-charset"]
103 if {[lsearch $show_charset $show_host_charset] >= 0} {
104 pass "check `show host-charset' against `show charset'"
106 fail "check `show host-charset' against `show charset'"
110 # Get the list of supported (host) charsets as possible completions.
111 send_gdb "set charset \t\t"
113 # Check that we can at least use ASCII as a host character set.
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.
123 -re ".*Requires an argument.*$gdb_prompt $" {
124 pass "get valid character sets"
126 -re ".*$gdb_prompt $" {
129 -re ".*$gdb_prompt $" {
130 fail "get valid character sets"
135 fail "(timeout) get valid character sets"
139 -re ".*$gdb_prompt $" {
140 # We got some output that ended with a regular prompt
141 fail "get valid character sets"
143 -re ".*$gdb_prompt set charset.*$" {
144 # We got some other output, send a cntrl-c to gdb to get us back
147 fail "get valid character sets"
150 fail "get valid character sets (timeout)"
154 # Try a malformed `set charset'.
155 gdb_test "set charset" \
156 "Requires an argument. Valid arguments are.*" \
157 "try malformed `set charset'"
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"
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"
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 {}
175 proc all_charset_names {} {
177 return [array names charsets]
180 proc valid_host_charset {charset} {
182 return $charsets($charset)
185 send_gdb "set host-charset\n"
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
191 #pass "capture valid host charsets"
194 -re ", (\[^ \t\n\r,.\]*)" {
195 #set host_charset_list $expect_out(1,string)
196 set charsets($expect_out(1,string)) 1
198 #pass "capture valid host charsets"
201 -re "\\.\r\n$gdb_prompt $" {
202 #set host_charset_list $expect_out(1,string)
203 pass "capture valid host charsets"
206 -re ".*$gdb_prompt $" {
207 fail "capture valid host charsets"
210 fail "(timeout) capture valid host charsets"
215 send_gdb "set target-charset\n"
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
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
233 -re "\\.\r\n$gdb_prompt $" {
234 pass "capture valid target charsets"
238 -re ".*$gdb_prompt $" {
239 fail "capture valid target charsets"
243 fail "(timeout) capture valid target charsets"
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]} {
251 set testname "try `set host-charset $host_charset'"
252 send_gdb "set host-charset $host_charset\n"
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)"
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?
262 -re "${gdb_prompt} $" {
266 fail "$testname (timeout)"
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'"
277 fail "check effect of `set host-charset $host_charset'"
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"
286 -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
287 fail "$testname (didn't recognize name)"
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)"
294 -re "${gdb_prompt} $" {
298 fail "$testname (timeout)"
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'"
309 fail "check effect of `set target-charset $target_charset'"
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.
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.
323 # Note: the \x16 (Control-V) is an escape to allow \xA2 to
325 if {! [string compare $host_charset iso-8859-1] && ! [string compare $target_charset ascii]} {
327 set testname "untranslatable character in character literal"
328 send_gdb "print '\x16\xA2'\n"
330 -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
333 -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
334 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
336 -re "$gdb_prompt $" {
340 fail "$testname (timeout)"
344 set testname "untranslatable character in string literal"
345 # If the PTTY zeros bit seven, then this turns into
347 # which gets us a syntax error. We don't care.
348 send_gdb "print \"\x16\xA2\"\n"
350 -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
353 -re "Unterminated string in expression.\[\r\n\]+$gdb_prompt $" {
354 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
356 -re "$gdb_prompt $" {
360 fail "$testname (timeout)"
364 set testname "untranslatable characters in backslash escape"
365 send_gdb "print '\\\x16\xA2'\n"
367 -re "The escape sequence .* is equivalent to plain .*, which has no equivalent\[\r\n\]+in the .* character set\\.\[\r\n\]+$gdb_prompt $" {
370 -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
371 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
373 -re "$gdb_prompt $" {
377 fail "$testname (timeout)"
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
390 gdb_test "break ${srcfile}:[gdb_get_line_number "all strings initialized"]" \
391 ".*Breakpoint.* at .*" \
392 "set breakpoint after all strings have been initialized"
395 -re "Breakpoint.*all strings initialized.*$gdb_prompt $" {
396 pass "run until all strings have been initialized"
398 -re "$gdb_prompt $" {
399 fail "run until all strings have been initialized"
402 fail "run until all strings have been initialized (timeout)"
407 gdb_test "set host-charset ASCII" ""
408 foreach target_charset [all_charset_names] {
409 send_gdb "set target-charset $target_charset\n"
411 -re "$gdb_prompt $" {
412 pass "set target-charset $target_charset"
415 fail "set target-charset $target_charset (timeout)"
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"
423 -re "\\\$${decimal} = 0 '\\\\0'\[\r\n\]+$gdb_prompt $" {
424 pass "print the null character in ${target_charset}"
426 -re "$gdb_prompt $" {
427 fail "print the null character in ${target_charset}"
430 fail "print the null character in ${target_charset} (timeout)"
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
441 # Compute a regexp matching the results we expect. This is static,
442 # but it's easier than writing it out.
443 regsub -all "." "abfnrtv" "(\\\\&|x)" escapes
444 set uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
445 set lowercase "abcdefghijklmnopqrstuvwxyz"
446 set digits "0123456789"
447 set octal_escape "\\\\\[0-9\]\[0-9\]\[0-9\]"
449 send_gdb "print $var_name\n"
450 # ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
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 $" {
453 pass "print string in $target_charset"
455 -re "$gdb_prompt $" {
456 fail "print string in $target_charset"
459 fail "print string in $target_charset (timeout)"
463 # Try entering a character literal, and see if it comes back unchanged.
464 gdb_test "print 'A'" \
466 "parse character literal in ${target_charset}"
468 # Check that the character literal was encoded correctly.
469 gdb_test "print 'A' == $var_name\[7\]" \
471 "check value of parsed character literal in ${target_charset}"
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}"
478 # Check that the string literal was encoded correctly.
479 gdb_test "print \"q\"\[0\] == $var_name\[49\]" \
481 "check value of parsed string literal in ${target_charset}"
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]} {
486 gdb_test "print iso_8859_1_string\[69\]" \
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"
494 # Make sure that we don't apply the ISO-8859-1 `print_literally'
496 if {! [string compare $target_charset ascii]} {
497 gdb_test "print iso_8859_1_string\[69\]" \
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"
505 # Try printing characters with backslash escape equivalents.
506 set escapees {a b f n r t v}
507 for {set i 0} {$i < [llength $escapees]} {incr i} {
508 set escape [lindex $escapees $i]
509 send_gdb "print $var_name\[$i\]\n"
512 -re "= \[0-9-\]+ '\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
513 pass "try printing '\\${escape}' in ${target_charset}"
515 -re "= \[0-9-\]+ 'x'\[\r\n\]+$gdb_prompt $" {
516 xfail "try printing '\\${escape}' in ${target_charset} (no such escape)"
519 -re "$gdb_prompt $" {
520 fail "try printing '\\${escape}' in ${target_charset}"
523 fail "try printing '\\${escape}' in ${target_charset} (timeout)"
529 # Try parsing a backslash escape in a character literal.
530 gdb_test "print '\\${escape}' == $var_name\[$i\]" \
532 "check value of '\\${escape}' in ${target_charset}"
534 # Try parsing a backslash escape in a string literal.
535 gdb_test "print \"\\${escape}\"\[0\] == $var_name\[$i\]" \
537 "check value of \"\\${escape}\" in ${target_charset}"
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"
545 gdb_test "print '\\q' == $var_name\[49\]" " = 1" \
546 "check value of escape that doesn't exist in $target_charset"