Commit | Line | Data |
---|---|---|
0dcd613f AC |
1 | # This testcase is part of GDB, the GNU debugger. |
2 | ||
9b254dd1 | 3 | # Copyright 2001, 2004, 2007, 2008 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 | |
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}" |
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. |
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 | } |
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 $" { |
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 |