* consistency.vlad/vlad.exp: Remove trailing semicolons.
* g++.dg/gcov/gcov.exp: Likewise.
* gcc.c-torture/execute/ieee/ieee.exp: Likewise.
* gcc.target/xstormy16/xstormy16.exp: Likewise.
* lib/c-torture.exp: Likewise.
* lib/fortran-torture.exp: Likewise.
* lib/g++.exp: Likewise.
* lib/gcc-defs.exp: Likewise.
* lib/gcc-dg.exp: Likewise.
* lib/gcc.exp: Likewise.
* lib/gcov.exp: Likewise.
* lib/gfortran.exp: Likewise.
* lib/mike-g++.exp: Likewise.
* lib/mike-gcc.exp: Likewise.
* lib/objc-torture.exp: Likewise.
* lib/objc.exp: Likewise.
* lib/profopt.exp: Likewise.
* lib/target-libpath.exp: Likewise.
* lib/target-supports.exp: Likewise.
* lib/treelang.exp: Likewise.
* lib/wrapper.exp: Likewise.
From-SVN: r96132
+2005-03-09 Ben Elliston <bje@au.ibm.com>
+
+ * consistency.vlad/vlad.exp: Remove trailing semicolons.
+ * g++.dg/gcov/gcov.exp: Likewise.
+ * gcc.c-torture/execute/ieee/ieee.exp: Likewise.
+ * gcc.target/xstormy16/xstormy16.exp: Likewise.
+ * lib/c-torture.exp: Likewise.
+ * lib/fortran-torture.exp: Likewise.
+ * lib/g++.exp: Likewise.
+ * lib/gcc-defs.exp: Likewise.
+ * lib/gcc-dg.exp: Likewise.
+ * lib/gcc.exp: Likewise.
+ * lib/gcov.exp: Likewise.
+ * lib/gfortran.exp: Likewise.
+ * lib/mike-g++.exp: Likewise.
+ * lib/mike-gcc.exp: Likewise.
+ * lib/objc-torture.exp: Likewise.
+ * lib/objc.exp: Likewise.
+ * lib/profopt.exp: Likewise.
+ * lib/target-libpath.exp: Likewise.
+ * lib/target-supports.exp: Likewise.
+ * lib/treelang.exp: Likewise.
+ * lib/wrapper.exp: Likewise.
+
2005-03-08 Jeff Law <law@redhat.com>
* gcc.dg/tree-ssa/20030728-1.c: Update to account for recent
close $fd
}
- set comp_output [gcc_target_compile "$cpp_flag $src -x none $wrap_file" "$executable" executable $options];
+ set comp_output [gcc_target_compile "$cpp_flag $src -x none $wrap_file" "$executable" executable $options]
# Set a few common compiler messages.
set fatal_signal "*cc: Internal compiler error: program*got fatal signal"
# Check for compilation only.
if [file exists $rootname.conly] {
remote_file build delete $executable
- return;
+ return
}
# See if this source file uses "long long" types, if it does, and
set exec_output ""
set result [consistency_load "$executable" "" ""]
- set status [lindex $result 0];
- set exec_output [lindex $result 1];
+ set status [lindex $result 0]
+ set exec_output [lindex $result 1]
# Strip random whitespace junk from the output. the
# whitejunk is an artifact of the way we get output
dg-init
# Delete old .gcda files.
-set files [glob -nocomplain gcov-*.gcda];
+set files [glob -nocomplain gcov-*.gcda]
if { $files != "" } {
- eval "remote_file build delete $files";
+ eval "remote_file build delete $files"
}
# Main loop.
strace $tracelevel
}
-set additional_flags "";
+set additional_flags ""
# We must use -ffloat-store/-mieee to ensure that excess precision on some
# machines does not cause problems
dg-init
# Delete old .gcda files.
-set files [glob -nocomplain gcov-*.gcda];
+set files [glob -nocomplain gcov-*.gcda]
if { $files != "" } {
- eval "remote_file build delete $files";
+ eval "remote_file build delete $files"
}
# Main loop.
# Main loop.
foreach testcase [lsort [find $srcdir/$subdir *.c]] {
- global test_counts;
+ global test_counts
set base "[file rootname [file tail $testcase]]"
set options ""
lappend options "additional_flags=-w $option"
- set comp_output [gcc_target_compile "$src" "$output" object $options];
+ set comp_output [gcc_target_compile "$src" "$output" object $options]
gcc_check_compile $testcase $option $output $comp_output
remote_file build delete $output
}
set src [lindex $sources 0]
if { [llength $args] > 0 } {
- set additional_flags [lindex $args 0];
+ set additional_flags [lindex $args 0]
} else {
- set additional_flags "";
+ set additional_flags ""
}
# Check for alternate driver.
if [file exists [file rootname $src].x] {
set testcase "[file tail [file dirname $src]]/[file tail $src]"
}
- set count 0;
- set oldstatus "foo";
+ set count 0
+ set oldstatus "foo"
foreach option $option_list {
if { $count > 0 } {
- set oldexec $execname;
+ set oldexec $execname
}
- set execname "${executable}${count}";
- incr count;
+ set execname "${executable}${count}"
+ incr count
# torture_{compile,execute}_xfail are set by the .x script
# (if present)
set ignore_me [eval $torture_eval_before_compile]
}
- remote_file build delete $execname;
+ remote_file build delete $execname
verbose "Testing $testcase, $option" 1
set options ""
lappend options "additional_flags=-w $option"
if { $additional_flags != "" } {
- lappend options "additional_flags=$additional_flags";
+ lappend options "additional_flags=$additional_flags"
}
- set comp_output [gcc_target_compile "$sources" "${execname}" executable $options];
+ set comp_output [gcc_target_compile "$sources" "${execname}" executable $options]
if ![gcc_check_compile "$testcase compilation" $option $execname $comp_output] {
unresolved "$testcase execution, $option"
# Do not do this for native testing since the cost to load/execute
# the test is fairly small and the comparison step actually slows
# the entire process down because it usually does not "hit".
- set skip 0;
+ set skip 0
if { ![isnative] && [info exists oldexec] } {
if { [remote_file build cmp $oldexec $execname] == 0 } {
- set skip 1;
+ set skip 1
}
}
if { $skip == 0 } {
set result [gcc_load "$execname" "" ""]
- set status [lindex $result 0];
- set output [lindex $result 1];
+ set status [lindex $result 0]
+ set output [lindex $result 1]
}
if { $oldstatus == "pass" } {
- remote_file build delete $oldexec;
+ remote_file build delete $oldexec
}
$status "$testcase execution, $option"
- set oldstatus $status;
+ set oldstatus $status
}
if [info exists status] {
if { $status == "pass" } {
- remote_file build delete $execname;
+ remote_file build delete $execname
}
}
}
proc c-torture { args } {
global srcdir subdir compiler_conditional_xfail_data
- set src [lindex $args 0];
+ set src [lindex $args 0]
if { [llength $args] > 1 } {
- set options [lindex $args 1];
+ set options [lindex $args 1]
} else {
set options ""
}
set options ""
lappend options "additional_flags=-w $option"
- set comp_output [gfortran_target_compile "$src" "$output" object $options];
+ set comp_output [gfortran_target_compile "$src" "$output" object $options]
# See if we got something bad.
set fatal_signal "*95*: Internal compiler error: program*got fatal signal"
global TORTURE_OPTIONS
# Check for alternate driver.
- set additional_flags "";
+ set additional_flags ""
if [file exists [file rootname $src].x] {
verbose "Using alternate driver [file rootname [file tail $src]].x" 2
set done_p 0
set options ""
lappend options "additional_flags=-w $option"
if { $additional_flags != "" } {
- lappend options "additional_flags=$additional_flags";
+ lappend options "additional_flags=$additional_flags"
}
- set comp_output [gfortran_target_compile "$src" "$executable" executable $options];
+ set comp_output [gfortran_target_compile "$src" "$executable" executable $options]
# See if we got something bad.
set fatal_signal "*95*: Internal compiler error: program*got fatal signal"
# Run the testcase, and analyse the output.
set result [gfortran_load "$executable" "" ""]
- set status [lindex $result 0];
- set output [lindex $result 1];
+ set status [lindex $result 0]
+ set output [lindex $result 1]
if { $status == "pass" } {
remote_file build delete $executable
}
global srcdir subdir
global compiler_conditional_xfail_data
- set src [lindex $args 0];
+ set src [lindex $args 0]
if { [llength $args] > 1 } {
- set options [lindex $args 1];
+ set options [lindex $args 1]
} else {
set options ""
}
# verify that the compiler exists
if { [is_remote host] || [which $compiler] != 0 } then {
set tmp [remote_exec host "$compiler -v"]
- set status [lindex $tmp 0];
- set output [lindex $tmp 1];
+ set status [lindex $tmp 0]
+ set output [lindex $tmp 1]
regexp " version \[^\n\r\]*" $output version
if { $status == 0 && [info exists version] } then {
if [is_remote host] {
}
}
} else {
- global tool_root_dir;
+ global tool_root_dir
- set libgpp [lookfor_file ${tool_root_dir} libg++];
+ set libgpp [lookfor_file ${tool_root_dir} libg++]
if { $libgpp != "" } {
- append flags "-L${libgpp} ";
+ append flags "-L${libgpp} "
append ld_library_path ":${libgpp}"
}
- set libstdcpp [lookfor_file ${tool_root_dir} libstdc++];
+ set libstdcpp [lookfor_file ${tool_root_dir} libstdc++]
if { $libstdcpp != "" } {
- append flags "-L${libstdcpp} ";
+ append flags "-L${libstdcpp} "
append ld_library_path ":${libstdcpp}"
}
- set libiberty [lookfor_file ${tool_root_dir} libiberty];
+ set libiberty [lookfor_file ${tool_root_dir} libiberty]
if { $libiberty != "" } {
- append flags "-L${libiberty} ";
+ append flags "-L${libiberty} "
}
- set librx [lookfor_file ${tool_root_dir} librx];
+ set librx [lookfor_file ${tool_root_dir} librx]
if { $librx != "" } {
- append flags "-L${librx} ";
+ append flags "-L${librx} "
}
}
global base_dir
global tmpdir
global libdir
- global gluefile wrap_flags;
+ global gluefile wrap_flags
global objdir srcdir
global ALWAYS_CXXFLAGS
global TOOL_EXECUTABLE TOOL_OPTIONS
if ![info exists GXX_UNDER_TEST] then {
if [info exists TOOL_EXECUTABLE] {
- set GXX_UNDER_TEST $TOOL_EXECUTABLE;
+ set GXX_UNDER_TEST $TOOL_EXECUTABLE
} else {
if { [is_remote host] || ! [info exists TESTING_IN_BUILD_TREE] } {
set GXX_UNDER_TEST [transform c++]
if ![is_remote host] {
if [info exists TOOL_OPTIONS] {
- lappend ALWAYS_CXXFLAGS "additional_flags=[g++_include_flags [get_multilibs ${TOOL_OPTIONS}] ]";
- lappend ALWAYS_CXXFLAGS "ldflags=[g++_link_flags [get_multilibs ${TOOL_OPTIONS}] ]";
+ lappend ALWAYS_CXXFLAGS "additional_flags=[g++_include_flags [get_multilibs ${TOOL_OPTIONS}] ]"
+ lappend ALWAYS_CXXFLAGS "ldflags=[g++_link_flags [get_multilibs ${TOOL_OPTIONS}] ]"
} else {
- lappend ALWAYS_CXXFLAGS "additional_flags=[g++_include_flags [get_multilibs] ]";
- lappend ALWAYS_CXXFLAGS "ldflags=[g++_link_flags [get_multilibs] ]";
+ lappend ALWAYS_CXXFLAGS "additional_flags=[g++_include_flags [get_multilibs] ]"
+ lappend ALWAYS_CXXFLAGS "ldflags=[g++_link_flags [get_multilibs] ]"
}
}
if [info exists TOOL_OPTIONS] {
- lappend ALWAYS_CXXFLAGS "additional_flags=$TOOL_OPTIONS";
+ lappend ALWAYS_CXXFLAGS "additional_flags=$TOOL_OPTIONS"
}
# Make sure that lines are not wrapped. That can confuse the
#
proc g++_target_compile { source dest type options } {
- global tmpdir;
+ global tmpdir
global gpp_compile_options
global gluefile wrap_flags
- global ALWAYS_CXXFLAGS;
- global GXX_UNDER_TEST;
+ global ALWAYS_CXXFLAGS
+ global GXX_UNDER_TEST
if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } {
lappend options "libs=${gluefile}"
}
lappend options "additional_flags=[libio_include_flags]"
- lappend options "compiler=$GXX_UNDER_TEST";
+ lappend options "compiler=$GXX_UNDER_TEST"
set options [concat $gpp_compile_options $options]
- set options [concat "$ALWAYS_CXXFLAGS" $options];
+ set options [concat "$ALWAYS_CXXFLAGS" $options]
if { [regexp "(^| )-frepo( |$)" $options] && \
[regexp "\.o(|bj)$" $dest] } then {
foreach x [split $option ","] {
lappend gpp_compile_options "additional_flags=$x"
}
- return 1;
+ return 1
} else {
return 0
}
proc ${tool}_finish { } {
# The testing harness apparently requires this.
- global errorInfo;
+ global errorInfo
if [info exists errorInfo] then {
unset errorInfo
#
proc ${tool}_exit { } {
- global gluefile;
+ global gluefile
if [info exists gluefile] {
- file_on_build delete $gluefile;
- unset gluefile;
+ file_on_build delete $gluefile
+ unset gluefile
}
}
set output_file "./[file rootname [file tail $prog]].exe"
# This is the only place where we care if an executable was
# created or not. If it was, dg.exp will try to run it.
- remote_file build delete $output_file;
+ remote_file build delete $output_file
}
default {
perror "$do_what: not a valid dg-do keyword"
lappend options "additional_flags=$extra_tool_flags"
}
- set comp_output [$target_compile "$prog" "$output_file" "$compile_type" $options];
+ set comp_output [$target_compile "$prog" "$output_file" "$compile_type" $options]
if { $do_what == "repo" } {
set object_file "$output_file"
proc default_gcc_version { } {
global GCC_UNDER_TEST
- gcc_init;
+ gcc_init
# ignore any arguments after the command
set compiler [lindex $GCC_UNDER_TEST 0]
if ![is_remote host] {
- set compiler_name [which $compiler];
+ set compiler_name [which $compiler]
} else {
- set compiler_name $compiler;
+ set compiler_name $compiler
}
# verify that the compiler exists
if { $compiler_name != 0 } then {
set tmp [remote_exec host "$compiler -v"]
- set status [lindex $tmp 0];
- set output [lindex $tmp 1];
+ set status [lindex $tmp 0]
+ set output [lindex $tmp 1]
regexp " version \[^\n\r\]*" $output version
if { $status == 0 && [info exists version] } then {
clone_output "$compiler_name $version\n"
#
proc gcc_version { } {
- default_gcc_version;
+ default_gcc_version
}
#
if ![info exists GCC_UNDER_TEST] {
if [info exists TOOL_EXECUTABLE] {
- set GCC_UNDER_TEST $TOOL_EXECUTABLE;
+ set GCC_UNDER_TEST $TOOL_EXECUTABLE
} else {
set GCC_UNDER_TEST "[find_gcc]"
}
#
proc gcc_target_compile { source dest type options } {
- global tmpdir;
- global gluefile wrap_flags;
+ global tmpdir
+ global gluefile wrap_flags
global GCC_UNDER_TEST
global TOOL_OPTIONS
# TOOL_OPTIONS must come first, so that it doesn't override testcase
# specific options.
if [info exists TOOL_OPTIONS] {
- set options [concat "{additional_flags=$TOOL_OPTIONS}" $options];
+ set options [concat "{additional_flags=$TOOL_OPTIONS}" $options]
}
if [target_info exists gcc,timeout] {
lappend options "timeout=[target_info gcc,timeout]"
}
verbose "Running $GCOV $testcase" 2
- set testcase [remote_download host $testcase];
- set result [remote_exec host $GCOV $gcov_args];
+ set testcase [remote_download host $testcase]
+ set result [remote_exec host $GCOV $gcov_args]
if { [lindex $result 0] != 0 } {
fail "$subdir/$testcase gcov failed: [lindex $result 1]"
clean-gcov $testcase
if { $files == "" } {
fail "$subdir/$testcase gcov failed: $testcase.gcov does not exist"
clean-gcov $testcase
- return;
+ return
}
- remote_upload host $testcase.gcov $testcase.gcov;
+ remote_upload host $testcase.gcov $testcase.gcov
if { $gcov_verify_xfail != "" } {
eval setup_xfail [split $gcov_verify_xfail]
# verify that the compiler exists
if { [is_remote host] || [which $compiler] != 0 } then {
set tmp [remote_exec host "$compiler -v"]
- set status [lindex $tmp 0];
- set output [lindex $tmp 1];
+ set status [lindex $tmp 0]
+ set output [lindex $tmp 1]
regexp " version \[^\n\r\]*" $output version
if { $status == 0 && [info exists version] } then {
if [is_remote host] {
global base_dir
global tmpdir
global libdir
- global gluefile wrap_flags;
+ global gluefile wrap_flags
global objdir srcdir
global ALWAYS_GFORTRANFLAGS
global TOOL_EXECUTABLE TOOL_OPTIONS
if ![info exists GFORTRAN_UNDER_TEST] then {
if [info exists TOOL_EXECUTABLE] {
- set GFORTRAN_UNDER_TEST $TOOL_EXECUTABLE;
+ set GFORTRAN_UNDER_TEST $TOOL_EXECUTABLE
} else {
if { [is_remote host] || ! [info exists TESTING_IN_BUILD_TREE] } {
set GFORTRAN_UNDER_TEST [transform gfortran]
if ![is_remote host] {
if [info exists TOOL_OPTIONS] {
- lappend ALWAYS_GFORTRANFLAGS "ldflags=[gfortran_link_flags [get_multilibs ${TOOL_OPTIONS}] ]";
+ lappend ALWAYS_GFORTRANFLAGS "ldflags=[gfortran_link_flags [get_multilibs ${TOOL_OPTIONS}] ]"
} else {
- lappend ALWAYS_GFORTRANFLAGS "ldflags=[gfortran_link_flags [get_multilibs] ]";
+ lappend ALWAYS_GFORTRANFLAGS "ldflags=[gfortran_link_flags [get_multilibs] ]"
}
}
if [info exists TOOL_OPTIONS] {
- lappend ALWAYS_GFORTRANFLAGS "additional_flags=$TOOL_OPTIONS";
+ lappend ALWAYS_GFORTRANFLAGS "additional_flags=$TOOL_OPTIONS"
}
verbose -log "ALWAYS_GFORTRANFLAGS set to $ALWAYS_GFORTRANFLAGS"
#
proc gfortran_target_compile { source dest type options } {
- global tmpdir;
+ global tmpdir
global gluefile wrap_flags
- global ALWAYS_GFORTRANFLAGS;
- global GFORTRAN_UNDER_TEST;
+ global ALWAYS_GFORTRANFLAGS
+ global GFORTRAN_UNDER_TEST
if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } {
lappend options "libs=${gluefile}"
lappend options "ldflags=${wrap_flags}"
}
- lappend options "compiler=$GFORTRAN_UNDER_TEST";
+ lappend options "compiler=$GFORTRAN_UNDER_TEST"
- set options [concat "$ALWAYS_GFORTRANFLAGS" $options];
+ set options [concat "$ALWAYS_GFORTRANFLAGS" $options]
return [target_compile $source $dest $type $options]
}
# mike_cleanup -- remove any files that are created by the testcase
#
proc mike_cleanup { src_code output_file assembly_file } {
- remote_file build delete $output_file $assembly_file;
+ remote_file build delete $output_file $assembly_file
}
#
}
if { [llength $args] > 0 } {
- set comp_options [lindex $args 0];
+ set comp_options [lindex $args 0]
} else {
set comp_options ""
}
case $actions {
compile
{
- set compile_type "assembly";
- set output_file $assembly_file;
+ set compile_type "assembly"
+ set output_file $assembly_file
}
assemble
{
- set compile_type "object";
- append output_file ".o";
+ set compile_type "object"
+ append output_file ".o"
}
link
{
- set compile_type "executable";
- append output_file ".exe";
+ set compile_type "executable"
+ append output_file ".exe"
}
run
{
- set compile_type "executable";
- append output_file ".exe";
- set run yes;
+ set compile_type "executable"
+ append output_file ".exe"
+ set run yes
}
default
{
- set output_file "";
- set compile_type "none";
+ set output_file ""
+ set compile_type "none"
}
}
}
if [string match $run yes] {
set result [g++_load $output_file]
- set status [lindex $result 0];
- set output [lindex $result 1];
+ set status [lindex $result 0]
+ set output [lindex $result 1]
if { $status == -1 } {
- mike_cleanup $src_code $output_file $assembly_file;
- return;
+ mike_cleanup $src_code $output_file $assembly_file
+ return
}
if { $verbose > 1 } {
send_user "Checking:\n$program_output\nto see if it matches:\n$output\n\n"
# mike_cleanup -- remove any files that are created by the testcase
#
proc mike_cleanup { src_code output_file assembly_file } {
- remote_file build delete $output_file $assembly_file;
+ remote_file build delete $output_file $assembly_file
}
#
}
if { [llength $args] > 0 } {
- set comp_options [lindex $args 0];
+ set comp_options [lindex $args 0]
} else {
set comp_options ""
}
case $actions {
compile
{
- set compile_type "assembly";
- set output_file $assembly_file;
+ set compile_type "assembly"
+ set output_file $assembly_file
}
assemble
{
- set compile_type "object";
- append output_file ".o";
+ set compile_type "object"
+ append output_file ".o"
}
link
{
- set compile_type "executable";
- append output_file ".exe";
+ set compile_type "executable"
+ append output_file ".exe"
}
run
{
- set compile_type "executable";
- append output_file ".exe";
- set run yes;
+ set compile_type "executable"
+ append output_file ".exe"
+ set run yes
}
default
{
- set output_file "";
- set compile_type "none";
+ set output_file ""
+ set compile_type "none"
}
}
lappend options "additional_flags=$comp_options"
}
- set comp_output [gcc_target_compile $src_file $output_file $compile_type $options];
+ set comp_output [gcc_target_compile $src_file $output_file $compile_type $options]
set pass no
}
if [string match $run yes] {
set result [gcc_load $output_file]
- set status [lindex $result 0];
- set output [lindex $result 1];
+ set status [lindex $result 0]
+ set output [lindex $result 1]
if { $status == -1 } {
- mike_cleanup $src_code $output_file $assembly_file;
- return;
+ mike_cleanup $src_code $output_file $assembly_file
+ return
}
if { $verbose > 1 } {
send_user "Checking:\n$program_output\nto see if it matches:\n$output\n\n"
set options ""
lappend options "additional_flags=-w $option"
- set comp_output [objc_target_compile "$src" "$output" object $options];
+ set comp_output [objc_target_compile "$src" "$output" object $options]
objc_check_compile $testcase $option $output $comp_output
remote_file build delete $output
}
global tmpdir tool srcdir output compiler_conditional_xfail_data
if { [llength $args] > 0 } {
- set additional_flags [lindex $args 0];
+ set additional_flags [lindex $args 0]
} else {
- set additional_flags "";
+ set additional_flags ""
}
# Check for alternate driver.
if [file exists [file rootname $src].x] {
set testcase "[file tail [file dirname $src]]/[file tail $src]"
}
- set count 0;
- set oldstatus "foo";
+ set count 0
+ set oldstatus "foo"
foreach option $option_list {
if { $count > 0 } {
- set oldexec $execname;
+ set oldexec $execname
}
- set execname "${executable}${count}";
- incr count;
+ set execname "${executable}${count}"
+ incr count
# torture_{compile,execute}_xfail are set by the .x script
# (if present)
set ignore_me [eval $torture_eval_before_compile]
}
- remote_file build delete $execname;
+ remote_file build delete $execname
verbose "Testing $testcase, $option" 1
set options ""
lappend options "additional_flags=-w $option"
if { $additional_flags != "" } {
- lappend options "additional_flags=$additional_flags";
+ lappend options "additional_flags=$additional_flags"
}
- set comp_output [objc_target_compile "$src" "${execname}" executable $options];
+ set comp_output [objc_target_compile "$src" "${execname}" executable $options]
if ![objc_check_compile "$testcase compilation" $option $execname $comp_output] {
unresolved "$testcase execution, $option"
# Do not do this for native testing since the cost to load/execute
# the test is fairly small and the comparison step actually slows
# the entire process down because it usually does not "hit".
- set skip 0;
+ set skip 0
if { ![isnative] && [info exists oldexec] } {
if { [remote_file build cmp $oldexec $execname] == 0 } {
- set skip 1;
+ set skip 1
}
}
if { $skip == 0 } {
set result [objc_load "$execname" "" ""]
- set status [lindex $result 0];
- set output [lindex $result 1];
+ set status [lindex $result 0]
+ set output [lindex $result 1]
}
if { $oldstatus == "pass" } {
- remote_file build delete $oldexec;
+ remote_file build delete $oldexec
}
$status "$testcase execution, $option"
- set oldstatus $status;
+ set oldstatus $status
}
if [info exists status] {
if { $status == "pass" } {
- remote_file build delete $execname;
+ remote_file build delete $execname
}
}
}
proc objc-torture { args } {
global srcdir subdir compiler_conditional_xfail_data
- set src [lindex $args 0];
+ set src [lindex $args 0]
if { [llength $args] > 1 } {
- set options [lindex $args 1];
+ set options [lindex $args 1]
} else {
set options ""
}
proc default_objc_version { } {
global OBJC_UNDER_TEST
- objc_init;
+ objc_init
# ignore any arguments after the command
set compiler [lindex $OBJC_UNDER_TEST 0]
if ![is_remote host] {
- set compiler_name [which $compiler];
+ set compiler_name [which $compiler]
} else {
- set compiler_name $compiler;
+ set compiler_name $compiler
}
# verify that the compiler exists
if { $compiler_name != 0 } then {
set tmp [remote_exec host "$compiler -v"]
- set status [lindex $tmp 0];
- set output [lindex $tmp 1];
+ set status [lindex $tmp 0]
+ set output [lindex $tmp 1]
regexp " version \[^\n\r\]*" $output version
if { $status == 0 && [info exists version] } then {
clone_output "$compiler_name $version\n"
# Call objc_version. We do it this way so we can override it if needed.
#
proc objc_version { } {
- default_objc_version;
+ default_objc_version
}
#
if ![info exists OBJC_UNDER_TEST] then {
if [info exists TOOL_EXECUTABLE] {
- set OBJC_UNDER_TEST $TOOL_EXECUTABLE;
+ set OBJC_UNDER_TEST $TOOL_EXECUTABLE
} else {
set OBJC_UNDER_TEST [find_gcc]
}
}
proc objc_target_compile { source dest type options } {
- global rootme;
- global tmpdir;
- global gluefile wrap_flags;
+ global rootme
+ global tmpdir
+ global gluefile wrap_flags
global srcdir
global OBJC_UNDER_TEST
global TOOL_OPTIONS
# TOOL_OPTIONS must come first, so that it doesn't override testcase
# specific options.
if [info exists TOOL_OPTIONS] {
- set options [concat "{additional_flags=$TOOL_OPTIONS}" $options];
+ set options [concat "{additional_flags=$TOOL_OPTIONS}" $options]
}
# If we have built libobjc along with the compiler (which usually
proc objc_finish { } {
# The testing harness apparently requires this.
- global errorInfo;
+ global errorInfo
if [info exists errorInfo] then {
unset errorInfo
}
proc objc_exit { } {
- global gluefile;
+ global gluefile
if [info exists gluefile] {
- file_on_build delete $gluefile;
- unset gluefile;
+ file_on_build delete $gluefile
+ unset gluefile
}
}
set options ""
lappend options "additional_flags=$option $profile_option"
set optstr "$option $profile_option"
- set comp_output [${tool}_target_compile "$src" "$execname1" executable $options];
+ set comp_output [${tool}_target_compile "$src" "$execname1" executable $options]
if ![${tool}_check_compile "$testcase compilation" $optstr $execname1 $comp_output] {
unresolved "$testcase execution, $optstr"
unresolved "$testcase compilation, $option $feedback_option"
set options ""
lappend options "additional_flags=$option $feedback_option"
set optstr "$option $feedback_option"
- set comp_output [${tool}_target_compile "$src" "$execname2" "executable" $options];
+ set comp_output [${tool}_target_compile "$src" "$execname2" "executable" $options]
if ![${tool}_check_compile "$testcase compilation" $optstr $execname2 $comp_output] {
unresolved "$testcase execution, $optstr"
continue
set options ""
lappend options "additional_flags=$option"
set optstr "$option"
- set comp_output [${tool}_target_compile "$src" "$execname3" "executable" $options];
+ set comp_output [${tool}_target_compile "$src" "$execname3" "executable" $options]
if ![${tool}_check_compile "$testcase compilation" $optstr $execname3 $comp_output] {
unresolved "$testcase execution, $optstr"
unresolved "$testcase perf check, $optstr"
}
if { $orig_environment_saved == 0 } {
- global env;
+ global env
set orig_environment_saved 1
# No error messages, everything is OK.
set result [${tool}_load "./$exe" "" ""]
- set status [lindex $result 0];
+ set status [lindex $result 0]
remote_file build delete $exe
verbose "check_iconv_available status is <$status>" 2
proc default_treelang_version { } {
global TREELANG_UNDER_TEST
- treelang_init;
+ treelang_init
# ignore any arguments after the command
set compiler [lindex $TREELANG_UNDER_TEST 0]
if ![is_remote host] {
- set compiler_name [which $compiler];
+ set compiler_name [which $compiler]
} else {
- set compiler_name $compiler;
+ set compiler_name $compiler
}
# verify that the compiler exists
if { $compiler_name != 0 } then {
set tmp [remote_exec host "$compiler -v"]
- set status [lindex $tmp 0];
- set output [lindex $tmp 1];
+ set status [lindex $tmp 0]
+ set output [lindex $tmp 1]
regexp " version \[^\n\r\]*" $output version
if { $status == 0 && [info exists version] } then {
clone_output "$compiler_name $version\n"
if ![info exists TREELANG_UNDER_TEST] then {
if [info exists TOOL_EXECUTABLE] {
- set TREELANG_UNDER_TEST $TOOL_EXECUTABLE;
+ set TREELANG_UNDER_TEST $TOOL_EXECUTABLE
} else {
set TREELANG_UNDER_TEST [find_gcc]
}
}
proc treelang_target_compile { source dest type options } {
- global rootme;
- global tmpdir;
- global gluefile wrap_flags;
+ global rootme
+ global tmpdir
+ global gluefile wrap_flags
global srcdir
global TREELANG_UNDER_TEST
global TOOL_OPTIONS
# TOOL_OPTIONS must come first, so that it doesn't override testcase
# specific options.
if [info exists TOOL_OPTIONS] {
- set options [concat "{additional_flags=$TOOL_OPTIONS}" $options];
+ set options [concat "{additional_flags=$TOOL_OPTIONS}" $options]
}
# If we have built libtreelang along with the compiler (which usually
proc treelang_finish { } {
# The testing harness apparently requires this.
- global errorInfo;
+ global errorInfo
if [info exists errorInfo] then {
unset errorInfo
}
proc treelang_exit { } {
- global gluefile;
+ global gluefile
if [info exists gluefile] {
- file_on_build delete $gluefile;
- unset gluefile;
+ file_on_build delete $gluefile
+ unset gluefile
}
}
# that gcc objects on may change, so just make sure -w is always
# passed to turn off all warnings.
set_currtarget_info wrap_compile_flags "$saved_wrap_compile_flags -w"
- set result [build_wrapper $filename];
+ set result [build_wrapper $filename]
set_currtarget_info wrap_compile_flags "$saved_wrap_compile_flags"
if { $result != "" } {
- set gluefile [lindex $result 0];
- set wrap_flags [lindex $result 1];
+ set gluefile [lindex $result 0]
+ set wrap_flags [lindex $result 1]
} else {
unset gluefile
}
projects / gcc.git / commitdiff