0d4d0e772a
The completion feature and other features on readline depend on the readline library. However, readline library is not always used, for example, running testsuite like make check RUNTESTFLAGS="--host_board=local-remote-host" the input stream is not a tty, and GDB doesn't use readline library as a result. This patch is to skip tests on completion and readline if 'show editing' is off, which means readline isn't used. Note that some tests in gdb.base/completion.exp test command complete, which isn't related to readline, so these tests aren't affected by readline library. This patch also moves these tests up, run them unconditionally, and run the rest if readline library is used. gdb/testsuite: 2014-03-26 Yao Qi <yao@codesourcery.com> * lib/gdb.exp (readline_is_used): New proc. * gdb.base/completion.exp: Move tests on command complete up. Skip the rest of tests if readline is not used. * gdb.ada/complete.exp: Skp the test if readline is not used. * gdb.base/filesym.exp: Likewise. * gdb.base/macscp.exp: Likewise. * gdb.base/readline-ask.exp: Likewise. * gdb.base/readline.exp: Likewise. * gdb.python/py-cmd.exp: Likewise. * gdb.trace/tfile.exp: Likewise.
696 lines
22 KiB
Text
696 lines
22 KiB
Text
# Test macro scoping.
|
|
# Copyright 2002-2014 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/>.
|
|
|
|
|
|
standard_testfile macscp1.c
|
|
set objfile [standard_output_file ${testfile}.o]
|
|
|
|
set options { debug additional_flags=-DFROM_COMMANDLINE=ARG}
|
|
|
|
get_compiler_info
|
|
if [test_compiler_info gcc*] {
|
|
lappend options additional_flags=-g3
|
|
}
|
|
|
|
# Generate the intermediate object file. This is required by Darwin to
|
|
# have access to the .debug_macinfo section.
|
|
if {[gdb_compile "${srcdir}/${subdir}/macscp1.c" "${objfile}" \
|
|
object $options] != ""
|
|
|| [gdb_compile "${objfile}" "${binfile}" executable $options] != "" } {
|
|
untested macscp.exp
|
|
return -1
|
|
}
|
|
|
|
clean_restart ${binfile}
|
|
|
|
|
|
# Ask GDB to show the current definition of MACRO, and return a list
|
|
# describing the result.
|
|
#
|
|
# The return value has the form {FILE1 FILE2 ... DEF}, which means
|
|
# that MACRO has the definition `DEF', and was defined in `FILE1',
|
|
# which was included from `FILE2', included from ... .
|
|
#
|
|
# If GDB says that MACRO has no definition, return the string `undefined'.
|
|
#
|
|
# If GDB complains that it doesn't have any information about
|
|
# preprocessor macro definitions, return the string `no-macro-info'.
|
|
#
|
|
# If expect times out waiting for GDB, we return the string `timeout'.
|
|
#
|
|
# If GDB's output doesn't otherwise match what we're expecting, we
|
|
# return the empty string.
|
|
|
|
proc info_macro {macro} {
|
|
global gdb_prompt
|
|
|
|
set filepat {macscp[0-9]+\.[ch]}
|
|
set definition {}
|
|
set location {}
|
|
|
|
# Line number zero is set for macros defined from the compiler command-line.
|
|
# Such macros are not being tested by this function.
|
|
set nonzero {[1-9][0-9]*}
|
|
|
|
send_gdb "info macro ${macro}\n"
|
|
|
|
set debug_me 0
|
|
|
|
if {$debug_me} {exp_internal 1}
|
|
gdb_expect {
|
|
-re "Defined at \[^\r\n\]*(${filepat}):${nonzero}\[\r\n\]" {
|
|
# `location' and `definition' should be empty when we see
|
|
# this message.
|
|
if {[llength $location] == 0 && [llength $definition] == 0} {
|
|
set location $expect_out(1,string)
|
|
exp_continue
|
|
} else {
|
|
# Exit this expect loop, with a result indicating failure.
|
|
set definition {}
|
|
}
|
|
}
|
|
-re "The symbol `${macro}' has no definition as a C/C\\+\\+ preprocessor macro\[^\r\n\]*\[\r\n\]" {
|
|
# `location' and `definition' should be empty when we see
|
|
# this message.
|
|
if {[llength $location] == 0 && [llength $definition] == 0} {
|
|
set definition undefined
|
|
exp_continue
|
|
} else {
|
|
# Exit this expect loop, with a result indicating failure.
|
|
set definition {}
|
|
}
|
|
}
|
|
-re "^\[\r\n\]* included at \[^\r\n\]*(${filepat}):${nonzero}\[\r\n\]" {
|
|
# `location' should *not* be empty when we see this
|
|
# message. It should have recorded at least the initial
|
|
# `Defined at ' message (for definitions) or ` at' message
|
|
# (for undefined symbols).
|
|
if {[llength $location] != 0} {
|
|
lappend location $expect_out(1,string)
|
|
exp_continue
|
|
} else {
|
|
# Exit this expect loop, with a result indicating failure.
|
|
set definition {}
|
|
}
|
|
}
|
|
-re "^\[\r\n\]*at \[^\r\n\]*(${filepat}):${nonzero}\[\r\n\]" {
|
|
# This appears after a `has no definition' message.
|
|
# `location' should be empty when we see it.
|
|
if {[string compare $definition undefined] == 0 \
|
|
&& [llength $location] == 0} {
|
|
set location $expect_out(1,string)
|
|
exp_continue
|
|
} else {
|
|
# Exit this expect loop, with a result indicating failure.
|
|
set definition {}
|
|
}
|
|
}
|
|
-re "#define ${macro} (\[^\r\n\]*)\[\r\n\]" {
|
|
# `definition' should be empty when we see this message.
|
|
if {[string compare $definition ""] == 0} {
|
|
set definition $expect_out(1,string)
|
|
exp_continue
|
|
} else {
|
|
# Exit this expect loop, with a result indicating failure.
|
|
set definition {}
|
|
}
|
|
}
|
|
-re "has no preprocessor macro information.*$gdb_prompt $" {
|
|
set definition no-macro-info
|
|
}
|
|
-re "$gdb_prompt $" {
|
|
# Exit the expect loop; let the existing value of `definition'
|
|
# indicate failure or success.
|
|
}
|
|
timeout {
|
|
set definition timeout
|
|
}
|
|
}
|
|
if {$debug_me} {exp_internal 0}
|
|
|
|
switch -exact -- $definition {
|
|
no-macro-info { return no-macro-info }
|
|
timeout { return timeout }
|
|
undefined { return undefined }
|
|
default {
|
|
if {[llength $location] >= 1} {
|
|
return [concat $location [list $definition]]
|
|
} else {
|
|
return {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
# Call info_macro to show the definition of MACRO. Expect a result of
|
|
# EXPECTED. Use WHERE in pass/fail messages to identify the context.
|
|
# Return non-zero if we should abort the entire test file, or zero if
|
|
# we can continue.
|
|
proc check_macro {macro expected where} {
|
|
set func_def [info_macro $macro]
|
|
if {[string compare $func_def $expected] == 0} {
|
|
pass "info macro $macro $where"
|
|
} else {
|
|
switch -exact -- $func_def {
|
|
no-macro-info {
|
|
xfail "executable includes no macro debugging information"
|
|
return 1
|
|
}
|
|
undefined {
|
|
fail "info macro $macro $where (undefined)"
|
|
return 1
|
|
}
|
|
timeout {
|
|
fail "info macro $macro $where (timeout)"
|
|
}
|
|
default {
|
|
fail "info macro $macro $where"
|
|
}
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
|
|
# List the function FUNC, and then show the definition of MACRO,
|
|
# expecting the result EXPECTED.
|
|
proc list_and_check_macro {func macro expected} {
|
|
gdb_test "list $func" ".*${func}.*" "list $func for $macro"
|
|
return [check_macro $macro $expected "after `list $func'"]
|
|
}
|
|
|
|
gdb_test "list main" ".*main.*" "list main for support check"
|
|
set macro_support "unknown"
|
|
gdb_test_multiple "info source" "Test macro information" {
|
|
-re "Includes preprocessor macro info\..*$gdb_prompt $" {
|
|
set macro_support 1
|
|
verbose "Source has macro information"
|
|
}
|
|
-re "Does not include preprocessor macro info\..*$gdb_prompt $" {
|
|
set macro_support 0
|
|
verbose "Source has no macro information"
|
|
}
|
|
default {
|
|
warning "couldn't check macro support (no valid response)."
|
|
}
|
|
}
|
|
if {$macro_support == 0} {
|
|
unsupported "Skipping test because debug information does not include macro information."
|
|
return 0
|
|
}
|
|
|
|
list_and_check_macro main WHERE {macscp1.c {before macscp1_3}}
|
|
list_and_check_macro macscp2_2 WHERE {macscp2.h macscp1.c {before macscp2_2}}
|
|
list_and_check_macro macscp3_2 WHERE {macscp3.h macscp1.c {before macscp3_2}}
|
|
|
|
|
|
# Assuming the current position inside program by `list' from above.
|
|
gdb_test "info macro FROM_COMMANDLINE" \
|
|
"Defined at \[^\r\n\]*:0\r\n-DFROM_COMMANDLINE=ARG"
|
|
|
|
gdb_test "info macro __FILE__" "#define __FILE__ \".*macscp3.h\"" \
|
|
"info macro __FILE__ before running"
|
|
gdb_test "info macro __LINE__" "#define __LINE__ 26" \
|
|
"info macro __LINE__ before running"
|
|
|
|
# Although GDB's macro table structures distinguish between multiple
|
|
# #inclusions of the same file, GDB's other structures don't. So the
|
|
# `list' command here doesn't reliably select one #inclusion or the
|
|
# other, even though it could. It would be nice to eventually change
|
|
# GDB's structures to handle this correctly.
|
|
gdb_test "list macscp4_2_from_macscp2" ".*macscp4_2_, MACSCP4_INCLUSION.*"
|
|
switch -exact -- [info_macro WHERE] {
|
|
{macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}} {
|
|
pass "info macro WHERE after `list macscp_4_2_from_macscp2'"
|
|
}
|
|
{macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}} {
|
|
setup_kfail "gdb/555" *-*-*
|
|
fail "info macro WHERE after `list macscp_4_2_from_macscp2' (gdb/555)"
|
|
}
|
|
timeout {
|
|
fail "info macro WHERE after `list macscp_4_2_from_macscp2' (timeout)"
|
|
}
|
|
default { fail "info macro WHERE after `list macscp_4_2_from_macscp2'" }
|
|
}
|
|
|
|
gdb_test "list macscp4_2_from_macscp3" ".*macscp4_2_, MACSCP4_INCLUSION.*"
|
|
switch -exact -- [info_macro WHERE] {
|
|
{macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}} {
|
|
pass "info macro WHERE after `list macscp_4_2_from_macscp3'"
|
|
}
|
|
{macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}} {
|
|
setup_kfail "gdb/555" *-*-*
|
|
fail "info macro WHERE after `list macscp_4_2_from_macscp3' (gdb/555)"
|
|
}
|
|
timeout {
|
|
fail "info macro WHERE after `list macscp_4_2_from_macscp3' (timeout)"
|
|
}
|
|
default { fail "info macro WHERE after `list macscp_4_2_from_macscp3'" }
|
|
}
|
|
|
|
|
|
#### Test the selection of the macro scope by the current frame.
|
|
|
|
### A table of functions, in the order they will be reached, which is
|
|
### also the order they appear in the preprocessed output. Each entry
|
|
### has the form {FUNCNAME WHERE KFAILWHERE}, where:
|
|
### - FUNCNAME is the name of the function,
|
|
### - WHERE is the definition we expect to see for the macro `WHERE', as
|
|
### returned by `info_macro', and
|
|
### - KFAILWHERE is an alternate definition which should be reported
|
|
### as a `known failure', due to GDB's inability to distinguish multiple
|
|
### #inclusions of the same file.
|
|
### KFAILWHERE may be omitted.
|
|
|
|
set funcs {
|
|
{
|
|
macscp1_1
|
|
{macscp1.c {before macscp1_1}}
|
|
}
|
|
{
|
|
macscp2_1
|
|
{macscp2.h macscp1.c {before macscp2_1}}
|
|
}
|
|
{
|
|
macscp4_1_from_macscp2
|
|
{macscp4.h macscp2.h macscp1.c {before macscp4_1_..., from macscp2.h}}
|
|
{macscp4.h macscp3.h macscp1.c {before macscp4_1_..., from macscp3.h}}
|
|
}
|
|
{
|
|
macscp4_2_from_macscp2
|
|
{macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}}
|
|
{macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}}
|
|
}
|
|
{
|
|
macscp2_2
|
|
{macscp2.h macscp1.c {before macscp2_2}}
|
|
}
|
|
{
|
|
macscp1_2
|
|
{macscp1.c {before macscp1_2}}
|
|
}
|
|
{
|
|
macscp3_1
|
|
{macscp3.h macscp1.c {before macscp3_1}}
|
|
}
|
|
{
|
|
macscp4_1_from_macscp3
|
|
{macscp4.h macscp3.h macscp1.c {before macscp4_1_..., from macscp3.h}}
|
|
{macscp4.h macscp2.h macscp1.c {before macscp4_1_..., from macscp2.h}}
|
|
}
|
|
{
|
|
macscp4_2_from_macscp3
|
|
{macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}}
|
|
{macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}}
|
|
}
|
|
{
|
|
macscp3_2
|
|
{macscp3.h macscp1.c {before macscp3_2}}
|
|
}
|
|
{
|
|
macscp1_3
|
|
{macscp1.c {before macscp1_3}}
|
|
}
|
|
}
|
|
|
|
proc maybe_kfail { func test_name } {
|
|
# We can't get the right scope info when we're stopped in
|
|
# the macro4_ functions.
|
|
if {[string match macscp4_* $func]} {
|
|
kfail gdb/555 "$test_name"
|
|
} else {
|
|
fail "$test_name"
|
|
}
|
|
}
|
|
|
|
# Start the program running.
|
|
if {! [runto_main]} {
|
|
fail "macro tests suppressed: couldn't run to main"
|
|
return 0
|
|
}
|
|
|
|
# Set a breakpoint on each of the functions.
|
|
foreach func_entry $funcs {
|
|
set func [lindex $func_entry 0]
|
|
gdb_test "break $func" "Breakpoint.*"
|
|
}
|
|
|
|
# Run to each of the breakpoints and check the definition (or lack
|
|
# thereof) of each macro.
|
|
for {set i 0} {$i < [llength $funcs]} {incr i} {
|
|
set func_entry [lindex $funcs $i]
|
|
set func [lindex $func_entry 0]
|
|
set expected [lindex $func_entry 1]
|
|
set kfail_expected [lindex $func_entry 2]
|
|
|
|
# Run to the breakpoint for $func.
|
|
gdb_test "continue" "Breakpoint $decimal, $func .*" "continue to $func"
|
|
|
|
# Check the macro WHERE.
|
|
set result [info_macro WHERE]
|
|
if {[string compare $result $expected] == 0} {
|
|
pass "info macro WHERE stopped in $func"
|
|
} elseif {[string compare $result $kfail_expected] == 0} {
|
|
setup_kfail "gdb/555" *-*-*
|
|
fail "info macro WHERE stopped in $func (gdb/555)"
|
|
} elseif {[string compare $result timeout] == 0} {
|
|
fail "info macro WHERE stopped in $func (timeout)"
|
|
} else {
|
|
fail "info macro WHERE stopped in $func"
|
|
}
|
|
|
|
# Check that the BEFORE_<func> macros for all prior functions are
|
|
# #defined, and that those for all subsequent functions are not.
|
|
for {set j 0} {$j < [llength $funcs]} {incr j} {
|
|
if {$j != $i} {
|
|
set func_j_entry [lindex $funcs $j]
|
|
set func_j [lindex $func_j_entry 0]
|
|
|
|
set before_macro "BEFORE_[string toupper $func_j]"
|
|
set test_name \
|
|
"$before_macro defined/undefined when stopped at $func"
|
|
set result [info_macro $before_macro]
|
|
|
|
if {$j < $i} {
|
|
if {[llength $result] >= 2 && \
|
|
[string compare [lindex $result end] {}] == 0} {
|
|
pass $test_name
|
|
} elseif {[string compare $result timeout] == 0} {
|
|
fail "$test_name (timeout)"
|
|
} else {
|
|
maybe_kfail $func "$test_name"
|
|
}
|
|
} elseif {$j > $i} {
|
|
switch -- [lindex $result end] {
|
|
undefined { pass $test_name }
|
|
timeout { fail "$test_name (timeout)" }
|
|
default {
|
|
maybe_kfail $func "$test_name"
|
|
}
|
|
}
|
|
}
|
|
|
|
set until_macro "UNTIL_[string toupper $func_j]"
|
|
set test_name \
|
|
"$until_macro defined/undefined when stopped at $func"
|
|
set result [info_macro $until_macro]
|
|
|
|
if {$j <= $i} {
|
|
switch -- [lindex $result end] {
|
|
undefined { pass $test_name }
|
|
timeout { fail "$test_name (timeout)" }
|
|
default {
|
|
maybe_kfail $func "$test_name"
|
|
}
|
|
}
|
|
} elseif {$j > $i} {
|
|
if {[llength $result] >= 2 && \
|
|
[string compare [lindex $result end] {}] == 0} {
|
|
pass $test_name
|
|
} elseif {[string compare $result timeout] == 0} {
|
|
fail "$test_name (timeout)"
|
|
} else {
|
|
maybe_kfail $func "$test_name"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
gdb_test "break [gdb_get_line_number "set breakpoint here"]" \
|
|
"Breakpoint.*at.* file .*, line.*" \
|
|
"breakpoint macscp_expr"
|
|
|
|
gdb_test "cond \$bpnum foo == MACRO_TO_EXPAND" \
|
|
"No symbol \"MACRO_TO_EXPAND\" in current context\." \
|
|
"macro MACRO_TO_EXPAND not in scope at breakpoint"
|
|
|
|
# Note that we choose the condition so that this breakpoint never
|
|
# stops.
|
|
set l2 [gdb_get_line_number "set second breakpoint here"]
|
|
gdb_test "break $l2 if foo != MACRO_TO_EXPAND" \
|
|
"Breakpoint.*at.*" \
|
|
"breakpoint macscp_expr using MACRO_TO_EXPAND"
|
|
|
|
gdb_test "continue" "foo = 0;.*" "continue to macsp_expr"
|
|
|
|
gdb_test "print address.addr" \
|
|
" = 0" \
|
|
"print address.addr"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
"No symbol \"MACRO_TO_EXPAND\" in current context\." \
|
|
"print expression with macro before define."
|
|
|
|
gdb_test "next" "foo = 1;.*here.*/" "next to definition 1"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
" = 0" \
|
|
"print expression with macro in scope."
|
|
|
|
gdb_test_no_output "macro define MACRO_TO_EXPAND 72" \
|
|
"user macro override"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
" = 72" \
|
|
"choose user macro"
|
|
|
|
gdb_test_no_output "macro undef MACRO_TO_EXPAND" \
|
|
"remove user override"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
" = 0" \
|
|
"print expression with macro after removing override"
|
|
|
|
gdb_test "next" "foo = 2;.*" "next to definition 2"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
"No symbol \"MACRO_TO_EXPAND\" in current context\." \
|
|
"print expression with macro after undef."
|
|
|
|
gdb_test_no_output "macro define MACRO_TO_EXPAND 5" \
|
|
"basic macro define"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
" = 5" \
|
|
"expansion of defined macro"
|
|
|
|
gdb_test "macro list" \
|
|
"macro define MACRO_TO_EXPAND 5" \
|
|
"basic macro list"
|
|
|
|
gdb_test_no_output "macro define MACRO_TO_EXPAND(x) x" \
|
|
"basic redefine, macro with args"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND (7)" \
|
|
" = 7" \
|
|
"expansion of macro with arguments"
|
|
|
|
gdb_test_no_output "macro undef MACRO_TO_EXPAND" \
|
|
"basic macro undef"
|
|
|
|
gdb_test "print MACRO_TO_EXPAND" \
|
|
"No symbol \"MACRO_TO_EXPAND\" in current context\." \
|
|
"print expression with macro after user undef."
|
|
|
|
# Regression test; this used to crash.
|
|
gdb_test "macro define" \
|
|
"usage: macro define.*" \
|
|
"macro define with no arguments"
|
|
|
|
# Regression test; this used to crash.
|
|
gdb_test "macro undef" \
|
|
"usage: macro undef.*" \
|
|
"macro undef with no arguments"
|
|
|
|
# Do completion tests if readline is used.
|
|
|
|
if { [readline_is_used] } {
|
|
|
|
# The macro FIFTY_SEVEN is in scope at this point.
|
|
send_gdb "p FIFTY_\t"
|
|
gdb_expect {
|
|
-re "^p FIFTY_SEVEN $" {
|
|
send_gdb "\n"
|
|
gdb_expect {
|
|
-re "^.* = 57.*$gdb_prompt $" {
|
|
pass "complete 'p FIFTY_SEVEN'"
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p FIFTY_SEVEN'" }
|
|
timeout { fail "(timeout) complete 'p FIFTY_SEVEN'" }
|
|
}
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p FIFTY_SEVEN'" }
|
|
timeout { fail "(timeout) complete 'p FIFTY_SEVEN' 2" }
|
|
}
|
|
|
|
# The macro TWENTY_THREE is not in scope.
|
|
send_gdb "p TWENTY_\t"
|
|
gdb_expect {
|
|
-re "^p TWENTY_\\\x07$" {
|
|
send_gdb "\n"
|
|
gdb_expect {
|
|
-re "No symbol \"TWENTY_\" in current context\\..*$gdb_prompt $" {
|
|
pass "complete 'p TWENTY_'"
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p TWENTY_'" }
|
|
timeout { fail "(timeout) complete 'p TWENTY_'"}
|
|
}
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p TWENTY_'" }
|
|
timeout { fail "(timeout) complete 'p TWENTY_' 2" }
|
|
}
|
|
|
|
# The macro FORTY_EIGHT was undefined and thus is not in scope.
|
|
send_gdb "p FORTY_\t"
|
|
gdb_expect {
|
|
-re "^p FORTY_\\\x07$" {
|
|
send_gdb "\n"
|
|
gdb_expect {
|
|
-re "No symbol \"FORTY_\" in current context\\..*$gdb_prompt $" {
|
|
pass "complete 'p FORTY_'"
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p FORTY_'" }
|
|
timeout {fail "(timeout) complete 'p FORTY_'"}
|
|
}
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p FORTY_'" }
|
|
timeout { fail "(timeout) complete 'p FORTY_' 2" }
|
|
}
|
|
|
|
gdb_test_no_output "macro define TWENTY_THREE 25" \
|
|
"defining TWENTY_THREE"
|
|
|
|
# User-defined macros are always in scope.
|
|
send_gdb "p TWENTY_\t"
|
|
gdb_expect {
|
|
-re "^p TWENTY_THREE $" {
|
|
send_gdb "\n"
|
|
gdb_expect {
|
|
-re "^.* = 25.*$gdb_prompt $" {
|
|
pass "complete 'p TWENTY_THREE'"
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p TWENTY_THREE'"}
|
|
timeout { fail "(timeout) complete 'p TWENTY_THREE'" }
|
|
}
|
|
}
|
|
-re ".*$gdb_prompt $" { fail "complete 'p TWENTY_THREE'" }
|
|
timeout { fail "(timeout) complete 'p TWENTY_THREE' 2" }
|
|
}
|
|
}
|
|
|
|
# Splicing tests.
|
|
|
|
gdb_test "macro expand SPLICE(x, y)" \
|
|
"expands to: xy" \
|
|
"basic macro splicing"
|
|
|
|
gdb_test_no_output "macro define robotinvasion 2010" \
|
|
"define splice helper"
|
|
|
|
gdb_test "macro expand SPLICE(robot, invasion)" \
|
|
"expands to: *2010" \
|
|
"splicing plus expansion"
|
|
|
|
# Varargs tests.
|
|
|
|
gdb_test_no_output "macro define va_c99(...) varfunc (fixedarg, __VA_ARGS__)" \
|
|
"define first varargs helper"
|
|
|
|
gdb_test_no_output "macro define va2_c99(x, y, ...) varfunc (fixedarg, x, y, __VA_ARGS__)" \
|
|
"define second varargs helper"
|
|
|
|
gdb_test_no_output "macro define va_gnu(args...) varfunc (fixedarg, args)" \
|
|
"define third varargs helper"
|
|
|
|
gdb_test_no_output "macro define va2_gnu(args...) varfunc (fixedarg, ## args)" \
|
|
"define fourth varargs helper"
|
|
|
|
gdb_test "macro expand va_c99(one, two, three)" \
|
|
"expands to: *varfunc \\(fixedarg, *one, two, three\\)" \
|
|
"c99 varargs expansion"
|
|
|
|
gdb_test "macro expand va_c99()" \
|
|
"expands to: *varfunc \\(fixedarg, *\\)" \
|
|
"c99 varargs expansion without an argument"
|
|
|
|
gdb_test "macro expand va2_c99(one, two, three, four)" \
|
|
"expands to: *varfunc \\(fixedarg, *one, two, three, four\\)" \
|
|
"c99 varargs expansion, multiple formal arguments"
|
|
|
|
gdb_test "macro expand va_gnu(one, two, three, four)" \
|
|
"expands to: *varfunc \\(fixedarg, *one, two, three, four\\)" \
|
|
"gnu varargs expansion"
|
|
|
|
gdb_test "macro expand va_gnu()" \
|
|
"expands to: *varfunc \\(fixedarg, *\\)" \
|
|
"gnu varargs expansion without an argument"
|
|
|
|
gdb_test "macro expand va2_gnu()" \
|
|
"expands to: *varfunc \\(fixedarg\\)" \
|
|
"gnu varargs expansion special splicing without an argument"
|
|
|
|
# Stringification tests.
|
|
|
|
gdb_test_no_output "macro define str(x) #x" \
|
|
"define stringification macro"
|
|
|
|
gdb_test_no_output "macro define maude 5" \
|
|
"define first stringification helper"
|
|
|
|
gdb_test_no_output "macro define xstr(x) str(x)" \
|
|
"define second stringification helper"
|
|
|
|
gdb_test "print str(5)" \
|
|
" = \"5\"" \
|
|
"simple stringify"
|
|
|
|
gdb_test "print str(hi bob)" \
|
|
" = \"hi bob\"" \
|
|
"stringify with one space"
|
|
|
|
gdb_test "print str( hi bob )" \
|
|
" = \"hi bob\"" \
|
|
"stringify with many spaces"
|
|
|
|
gdb_test "print str(hi \"bob\")" \
|
|
" = \"hi \\\\\"bob\\\\\"\"" \
|
|
"stringify with quotes"
|
|
|
|
gdb_test "print str(hi \\bob\\)" \
|
|
" = \"hi \\\\\\\\bob\\\\\\\\\"" \
|
|
"stringify with backslashes"
|
|
|
|
gdb_test "print str(maude)" \
|
|
" = \"maude\"" \
|
|
"stringify without substitution"
|
|
|
|
gdb_test "print xstr(maude)" \
|
|
" = \"5\"" \
|
|
"stringify with substitution"
|
|
|
|
# Regression test for pp-number bug.
|
|
gdb_test_no_output "macro define si_addr fields.fault.si_addr" \
|
|
"define si_addr macro"
|
|
|
|
gdb_test "macro expand siginfo.si_addr" \
|
|
"expands to: siginfo.fields.fault.si_addr" \
|
|
"macro expand siginfo.si_addr"
|
|
|
|
gdb_test "print __FILE__" " = \".*macscp1.c\""
|
|
gdb_test "print __LINE__" \
|
|
" = [gdb_get_line_number {stopping point for line test}]"
|