OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.base/] [charset.exp] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
# This testcase is part of GDB, the GNU debugger.
2
 
3
# Copyright 2001, 2004, 2007, 2008 Free Software Foundation, Inc.
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
7
# the Free Software Foundation; either version 3 of the License, or
8
# (at your option) any later version.
9
#
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.
14
#
15
# You should have received a copy of the GNU General Public License
16
# along with this program.  If not, see .
17
 
18
# Please email any bugs, comments, and/or additions to this file to:
19
# bug-gdb@gnu.org
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}] != "" } {
34
    untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
35
    return -1
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)
53
            set retlist [list $host_charset $target_charset]
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)
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]
70
            pass $testname
71
        }
72
        -re ".*$gdb_prompt $" {
73
            fail $testname
74
        }
75
        timeout {
76
            fail "$testname (timeout)"
77
        }
78
    }
79
 
80
    return $retlist
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
 
94
if {[lsearch $show_charset $show_target_charset] >= 0} {
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
 
103
if {[lsearch $show_charset $show_host_charset] >= 0} {
104
    pass "check `show host-charset' against `show charset'"
105
} else {
106
    fail "check `show host-charset' against `show charset'"
107
}
108
 
109
 
110
# Get the list of supported (host) charsets as possible completions.
111
send_gdb "set charset \t\t"
112
 
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
    }
143
    -re ".*$gdb_prompt set charset.*$" {
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"
163
 
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"
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
 
180
proc valid_host_charset {charset} {
181
    global charsets
182
    return $charsets($charset)
183
}
184
 
185
send_gdb "set host-charset\n"
186
gdb_expect {
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"
192
    }
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"
199
    }
200
 
201
    -re "\\.\r\n$gdb_prompt $" {
202
        #set host_charset_list $expect_out(1,string)
203
        pass "capture valid host charsets"
204
    }
205
 
206
    -re ".*$gdb_prompt $" {
207
        fail "capture valid host charsets"
208
    }
209
    timeout {
210
        fail "(timeout) capture valid host charsets"
211
    }
212
}
213
 
214
 
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
223
    }
224
 
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
    }
232
 
233
    -re "\\.\r\n$gdb_prompt $" {
234
        pass "capture valid target charsets"
235
 
236
    }
237
 
238
    -re ".*$gdb_prompt $" {
239
        fail "capture valid target charsets"
240
    }
241
 
242
    timeout {
243
        fail "(timeout) capture valid target charsets"
244
    }
245
}
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.
390
gdb_test "break ${srcfile}:[gdb_get_line_number "all strings initialized"]" \
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
 
407
gdb_test "set host-charset ASCII" ""
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.
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\]"
448
 
449
    send_gdb "print $var_name\n"
450
    # ${escapes}${uppercase}${lowercase}${digits}${octal}${octal}
451
    gdb_expect {
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"
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.
469
    gdb_test "print 'A' == $var_name\[7\]" \
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.
479
    gdb_test "print \"q\"\[0\] == $var_name\[49\]" \
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]} {
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"
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]} {
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"
503
    }
504
 
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"
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"
545
    gdb_test "print '\\q' == $var_name\[49\]" " = 1" \
546
             "check value of escape that doesn't exist in $target_charset"
547
}
548
 
549
gdb_exit

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.