1 # Copyright 2001 Free Software Foundation, Inc.
3 # This program is free software; you can redistribute it and/or modify
4 # it under the terms of the GNU General Public License as published by
5 # the Free Software Foundation; either version 2 of the License, or
6 # (at your option) any later version.
8 # This program is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 # GNU General Public License for more details.
13 # You should have received a copy of the GNU General Public License
14 # along with this program; if not, write to the Free Software
15 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 # Please email any bugs, comments, and/or additions to this file to:
18 # bug-gdb@prep.ai.mit.edu
20 # Test GDB's character set support.
29 set testfile "charset"
30 set srcfile ${testfile}.c
31 set binfile ${objdir}/${subdir}/${testfile}
32 if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
33 gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
36 # Start with a fresh gdb.
39 gdb_reinitialize_dir $srcdir/$subdir
42 # Parse the output from a `show charset' command. Return the host
43 # and target charset as a two-element list.
44 proc parse_show_charset_output {testname} {
48 -re "The current host and target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
49 set host_charset $expect_out(1,string)
50 set target_charset $expect_out(1,string)
51 set retlist [list $host_charset $target_charset]
54 -re "The current host character set is `(.*)'\\.\[\r\n\]+The current target character set is `(.*)'\\.\[\r\n\]+$gdb_prompt $" {
55 set host_charset $expect_out(1,string)
56 set target_charset $expect_out(2,string)
57 set retlist [list $host_charset $target_charset]
60 -re "The host character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
61 set host_charset $expect_out(1,string)
62 set retlist [list $host_charset]
65 -re "The target character set is \"(.*)\"\\.\[\r\n\]+$gdb_prompt $" {
66 set target_charset $expect_out(1,string)
67 set retlist [list $target_charset]
70 -re ".*$gdb_prompt $" {
74 fail "$testname (timeout)"
82 # Try the various `show charset' commands. These are all aliases of each
83 # other; `show target-charset' and `show host-charset' actually print
84 # both the host and target charsets.
86 send_gdb "show charset\n"
87 set show_charset [parse_show_charset_output "show charset"]
89 send_gdb "show target-charset\n"
90 set show_target_charset [parse_show_charset_output "show target-charset"]
92 if {[lsearch $show_charset $show_target_charset] >= 0} {
93 pass "check `show target-charset' against `show charset'"
95 fail "check `show target-charset' against `show charset'"
98 send_gdb "show host-charset\n"
99 set show_host_charset [parse_show_charset_output "show host-charset"]
101 if {[lsearch $show_charset $show_host_charset] >= 0} {
102 pass "check `show host-charset' against `show charset'"
104 fail "check `show host-charset' against `show charset'"
108 # Get the list of supported (host) charsets as possible completions.
109 send_gdb "set charset \t\t"
111 # Check that we can at least use ASCII as a host character set.
114 -re "^set charset .*\r\nASCII.*\r\n$gdb_prompt set charset " {
115 # We got the output that we wanted, including ASCII as possible
116 # charset. Send a newline to get us back to the prompt. This will
117 # also generate an error message. Let's not check here that the error
118 # message makes sense, we do that below, as a separate testcase.
121 -re ".*Requires an argument.*$gdb_prompt $" {
122 pass "get valid character sets"
124 -re ".*$gdb_prompt $" {
127 -re ".*$gdb_prompt $" {
128 fail "get valid character sets"
133 fail "(timeout) get valid character sets"
137 -re ".*$gdb_prompt $" {
138 # We got some output that ended with a regular prompt
139 fail "get valid character sets"
141 -re "^set charset.*$" {
142 # We got some other output, send a cntrl-c to gdb to get us back
145 fail "get valid character sets"
148 fail "get valid character sets (timeout)"
152 # Try a malformed `set charset'.
153 gdb_test "set charset" \
154 "Requires an argument. Valid arguments are.*" \
155 "try malformed `set charset'"
157 # Try using `set host-charset' on an invalid character set.
158 gdb_test "set host-charset my_grandma_bonnie" \
159 "Undefined item: \"my_grandma_bonnie\"." \
160 "try `set host-charset' with invalid charset"
162 # Try using `set target-charset' on an invalid character set.
163 gdb_test "set target-charset my_grandma_bonnie" \
164 "Undefined item: \"my_grandma_bonnie\"." \
165 "try `set target-charset' with invalid charset"
167 # A Tcl array mapping the names of all the character sets we've seen
168 # to "1" if the character set can be used as a host character set, or
169 # "0" otherwise. We can use `array names charsets' just to get a list
170 # of all character sets.
171 array set charsets {}
173 proc all_charset_names {} {
175 return [array names charsets]
178 proc valid_host_charset {charset} {
180 return $charsets($charset)
183 send_gdb "set host-charset\n"
185 -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
186 #set host_charset_list $expect_out(1,string)
187 set charsets($expect_out(1,string)) 1
189 #pass "capture valid host charsets"
192 -re ", (\[^ \t\n\r,.\]*)" {
193 #set host_charset_list $expect_out(1,string)
194 set charsets($expect_out(1,string)) 1
196 #pass "capture valid host charsets"
199 -re "\\.\r\n$gdb_prompt $" {
200 #set host_charset_list $expect_out(1,string)
201 set charsets($expect_out(1,string)) 1
202 pass "capture valid host charsets"
205 -re ".*$gdb_prompt $" {
206 fail "capture valid host charsets"
209 fail "(timeout) capture valid host charsets"
214 send_gdb "set target-charset\n"
216 -re "Requires an argument. Valid arguments are (\[^ \t\n\r,.\]*)" {
217 set target_charset $expect_out(1,string)
218 if {! [info exists charsets($target_charset)]} {
219 set charsets($target_charset) 0
224 -re ", (\[^ \t\n\r,.\]*)" {
225 set target_charset $expect_out(1,string)
226 if {! [info exists charsets($target_charset)]} {
227 set charsets($target_charset) 0
232 -re "\\.\r\n$gdb_prompt $" {
233 pass "capture valid target charsets"
237 -re ".*$gdb_prompt $" {
238 fail "capture valid target charsets"
242 fail "(timeout) capture valid target charsets"
246 # Make sure that GDB supports every host/target charset combination.
247 foreach host_charset [all_charset_names] {
248 if {[valid_host_charset $host_charset]} {
250 set testname "try `set host-charset $host_charset'"
251 send_gdb "set host-charset $host_charset\n"
253 -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
254 # How did it get into `charsets' then?
255 fail "$testname (didn't recognize name)"
257 -re "GDB can't use `.*' as its host character set\\.\[\r\n]+${gdb_prompt} $" {
258 # Well, then why does its `charsets' entry say it can?
261 -re "${gdb_prompt} $" {
265 fail "$testname (timeout)"
269 # Check that the command actually had its intended effect:
270 # $host_charset should now be the host character set.
271 send_gdb "show charset\n"
272 set result [parse_show_charset_output "parse `show charset' after `set host-charset $host_charset'"]
273 if {! [string compare [lindex $result 0] $host_charset]} {
274 pass "check effect of `set host-charset $host_charset'"
276 fail "check effect of `set host-charset $host_charset'"
279 # Now try setting every possible target character set,
280 # given that host charset.
281 foreach target_charset [all_charset_names] {
282 set testname "try `set target-charset $target_charset'"
283 send_gdb "set target-charset $target_charset\n"
285 -re "GDB doesn't know of any character set named.*\[\r\n]+${gdb_prompt} $" {
286 fail "$testname (didn't recognize name)"
288 -re "GDB can't convert from the .* character set to .*\\.\[\r\n\]+${gdb_prompt} $" {
289 # This is a serious problem. GDB should be able to convert
290 # between any arbitrary pair of character sets.
291 fail "$testname (can't convert)"
293 -re "${gdb_prompt} $" {
297 fail "$testname (timeout)"
301 # Check that the command actually had its intended effect:
302 # $target_charset should now be the target charset.
303 send_gdb "show charset\n"
304 set result [parse_show_charset_output "parse `show charset' after `set target-charset $target_charset'"]
305 if {! [string compare $result [list $host_charset $target_charset]]} {
306 pass "check effect of `set target-charset $target_charset'"
308 fail "check effect of `set target-charset $target_charset'"
311 # Test handling of characters in the host charset which
312 # can't be translated into the target charset. \xA2 is
313 # `cent' in ISO-8859-1, which has no equivalent in ASCII.
315 # On some systems, the pseudo-tty through which we
316 # communicate with GDB insists on stripping the high bit
317 # from input characters, meaning that `cent' turns into
318 # `"'. Since ISO-8859-1 and ASCII are identical in the
319 # lower 128 characters, it's tough to see how we can test
320 # this behavior on such systems, so we just xfail it.
322 # Note: the \x16 (Control-V) is an escape to allow \xA2 to
324 if {! [string compare $host_charset iso-8859-1] && ! [string compare $target_charset ascii]} {
326 set testname "untranslatable character in character literal"
327 send_gdb "print '\x16\xA2'\n"
329 -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
332 -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
333 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
335 -re "$gdb_prompt $" {
339 fail "$testname (timeout)"
343 set testname "untranslatable character in string literal"
344 # If the PTTY zeros bit seven, then this turns into
346 # which gets us a syntax error. We don't care.
347 send_gdb "print \"\x16\xA2\"\n"
349 -re "There is no character corresponding to .* in the target character set .*\\.\[\r\n\]+$gdb_prompt $" {
352 -re "Unterminated string in expression.\[\r\n\]+$gdb_prompt $" {
353 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
355 -re "$gdb_prompt $" {
359 fail "$testname (timeout)"
363 set testname "untranslatable characters in backslash escape"
364 send_gdb "print '\\\x16\xA2'\n"
366 -re "The escape sequence .* is equivalent to plain .*, which has no equivalent\[\r\n\]+in the .* character set\\.\[\r\n\]+$gdb_prompt $" {
369 -re " = 34 '\"'\[\r\n\]+$gdb_prompt $" {
370 xfail "$testname (DejaGNU's pseudo-tty strips eighth bit)"
372 -re "$gdb_prompt $" {
376 fail "$testname (timeout)"
385 # Set the host character set to plain ASCII, and try actually printing
386 # some strings in various target character sets. We need to run the
387 # test program to the point at which the strings have been
389 gdb_test "break [gdb_get_line_number "all strings initialized"]" \
390 ".*Breakpoint.* at .*" \
391 "set breakpoint after all strings have been initialized"
394 -re "Breakpoint.*all strings initialized.*$gdb_prompt $" {
395 pass "run until all strings have been initialized"
397 -re "$gdb_prompt $" {
398 fail "run until all strings have been initialized"
401 fail "run until all strings have been initialized (timeout)"
406 gdb_test "set host-charset ASCII" ""
407 foreach target_charset [all_charset_names] {
408 send_gdb "set target-charset $target_charset\n"
410 -re "$gdb_prompt $" {
411 pass "set target-charset $target_charset"
414 fail "set target-charset $target_charset (timeout)"
418 # Try printing the null character. There seems to be a bug in
419 # gdb_test that requires us to use gdb_expect here.
420 send_gdb "print '\\0'\n"
422 -re "\\\$${decimal} = 0 '\\\\0'\[\r\n\]+$gdb_prompt $" {
423 pass "print the null character in ${target_charset}"
425 -re "$gdb_prompt $" {
426 fail "print the null character in ${target_charset}"
429 fail "print the null character in ${target_charset} (timeout)"
433 # Compute the name of the variable in the test program that holds
434 # a string in $target_charset. The variable's name is the
435 # character set's name, in lower-case, with all non-identifier
436 # characters replaced with '_', with "_string" stuck on the end.
437 set var_name [string tolower "${target_charset}_string"]
438 regsub -all -- "\[^a-z0-9_\]" $var_name "_" var_name
440 # Compute a regexp matching the results we expect. This is static,
441 # but it's easier than writing it out.
442 regsub -all "." "abefnrtv" "(\\\\&|x)" escapes
443 set uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
444 set lowercase "abcdefghijklmnopqrstuvwxyz"
445 set digits "0123456789"
446 set octal_escape "\\\\\[0-9\]\[0-9\]\[0-9\]"
448 send_gdb "print $var_name\n"
449 # ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
451 -re ".* = \"(\\\\a|x)(\\\\b|x)(\\\\e|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 $" {
452 pass "print string in $target_charset"
454 -re "$gdb_prompt $" {
455 fail "print string in $target_charset"
458 fail "print string in $target_charset (timeout)"
462 # Try entering a character literal, and see if it comes back unchanged.
463 gdb_test "print 'A'" \
465 "parse character literal in ${target_charset}"
467 # Check that the character literal was encoded correctly.
468 gdb_test "print 'A' == $var_name\[8\]" \
470 "check value of parsed character literal in ${target_charset}"
472 # Try entering a string literal, and see if it comes back unchanged.
473 gdb_test "print \"abcdefABCDEF012345\"" \
474 " = \"abcdefABCDEF012345\"" \
475 "parse string literal in ${target_charset}"
477 # Check that the string literal was encoded correctly.
478 gdb_test "print \"q\"\[0\] == $var_name\[50\]" \
480 "check value of parsed string literal in ${target_charset}"
482 # Test handling of characters in the target charset which
483 # can't be translated into the host charset.
484 if {! [string compare $target_charset iso-8859-1]} {
485 gdb_test "print iso_8859_1_string\[70\]" \
486 " = \[0-9-\]+ '\\\\242'" \
487 "print character with no equivalent in host character set"
488 gdb_test "print iso_8859_1_string + 70" \
489 " = ${hex} \"\\\\242.*\"" \
490 "print string with no equivalent in host character set"
493 # Make sure that we don't apply the ISO-8859-1 `print_literally'
495 if {! [string compare $target_charset ascii]} {
496 gdb_test "print iso_8859_1_string\[70\]" \
497 " = \[0-9-\]+ '\\\\242'" \
498 "print ASCII unprintable character"
499 gdb_test "print iso_8859_1_string + 70" \
500 " = ${hex} \"\\\\242.*\"" \
501 "print ASCII unprintable string"
504 # Try printing characters with backslash escape equivalents.
505 set escapees {a b e f n r t v}
506 for {set i 0} {$i < [llength $escapees]} {incr i} {
507 set escape [lindex $escapees $i]
508 send_gdb "print $var_name\[$i\]\n"
511 -re "= \[0-9-\]+ '\\\\${escape}'\[\r\n\]+$gdb_prompt $" {
512 pass "try printing '\\${escape}' in ${target_charset}"
514 -re "= \[0-9-\]+ 'x'\[\r\n\]+$gdb_prompt $" {
515 xfail "try printing '\\${escape}' in ${target_charset} (no such escape)"
518 -re "$gdb_prompt $" {
519 fail "try printing '\\${escape}' in ${target_charset}"
522 fail "try printing '\\${escape}' in ${target_charset} (timeout)"
528 # Try parsing a backslash escape in a character literal.
529 gdb_test "print '\\${escape}' == $var_name\[$i\]" \
531 "check value of '\\${escape}' in ${target_charset}"
533 # Try parsing a backslash escape in a string literal.
534 gdb_test "print \"\\${escape}\"\[0\] == $var_name\[$i\]" \
536 "check value of \"\\${escape}\" in ${target_charset}"
540 # Try printing a character escape that doesn't exist. We should
541 # get the unescaped character, in the target character set.
542 gdb_test "print '\\q'" " = \[0-9-\]+ 'q'" \
543 "print escape that doesn't exist in $target_charset"
544 gdb_test "print '\\q' == $var_name\[50\]" " = 1" \
545 "check value of escape that doesn't exist in $target_charset"