OSDN Git Service

ace5f6c2b2d2fa4ae6950201ffb0600ca6c38d03
[pf3gnuchains/gcc-fork.git] / libjava / testsuite / lib / libjava.exp
1 # Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
2
3 load_lib "libgloss.exp"
4
5 # GCJ_UNDER_TEST is the compiler under test.
6
7 global tmpdir
8
9 if ![info exists tmpdir] {
10     set tmpdir "/tmp"
11 }
12
13 # This is like `target_compile' but it does some surgery to work
14 # around stupid DejaGNU bugs.  In particular DejaGNU has very poor
15 # quoting, so for instance a `$' will be re-evaluated at spawn time.
16 # We don't want that.
17 proc libjava_tcompile {source destfile type options} {
18     # This strange-looking expression really does quote the `$'.
19     regsub -all -- {\$} $source {\$} source
20     regsub -all -- {\$} $destfile {\$} destfile
21     return [target_compile $source $destfile $type $options]
22 }
23
24 # Read an `xfail' file if it exists.  Returns a list of xfail tokens.
25 proc libjava_read_xfail {file} {
26     if {! [file exists $file]} {
27         return ""
28     }
29     set fd [open $file r]
30     set tokens [string trim [read $fd]]
31     close $fd
32     return $tokens
33 }
34
35 # Find a particular executable.  FIXME: this relies on DejaGnu
36 # internals.  These should probably be exposed in a better way.
37 proc libjava_find_program {prog} {
38     global tool_root_dir
39
40     set file [lookfor_file $tool_root_dir $prog]
41     if { $file == "" } {
42         set file [lookfor_file $tool_root_dir gcc/$prog];
43     }
44     if {$file == ""} {
45         set file $prog
46     }
47     return $file
48 }
49
50 # Find `jv-scan'.
51 proc find_jvscan {} {
52     return [libjava_find_program jv-scan]
53 }
54
55 # Find `gcjh'.
56 proc find_gcjh {} {
57     return [libjava_find_program gcjh]
58 }
59
60 proc find_javac {} {
61     global SUN_JAVAC GCJ_UNDER_TEST env
62     # If JDK doesn't run on your platform but some other
63     # JDK-compatible javac does, you may set SUN_JAVAC to point to it.
64     # One of the most important properties of a SUN_JAVAC is that it
65     # must create class-files even for classes that have not been
66     # specified in the command line, but that were needed to compile
67     # those that have.  For example, Pizza won't do it, but you can
68     # use `kaffe sun.tools.javac.Main', if you have Sun's classes.zip
69     # in the kaffe's default search path.
70     if {![info exists SUN_JAVAC]} {
71         if {[info exists env(SUN_JAVAC)]} {
72             set SUN_JAVAC $env(SUN_JAVAC)
73         } else {
74             set SUN_JAVAC "$GCJ_UNDER_TEST -C"
75         }
76     }
77     return $SUN_JAVAC
78 }
79
80 proc bytecompile_file { file objdir {classpath {}} } {
81     global env
82     set dirname [file dirname $file]
83
84     set javac [find_javac]
85     if {$classpath != ""} then {
86         set env(CLASSPATH) $classpath
87     }
88     set here [pwd]
89     cd $dirname
90     if {[catch {
91         set q [eval exec "$javac [list $file] -d $objdir 2>@ stdout"]
92     } msg]} then {
93         verbose "couldn't compile $file: $msg"
94         set r 0
95     } else {
96         set r 1
97     }
98     cd $here
99     return $r
100 }
101
102 set libjava_initialized 0
103
104 #
105 # Build the status wrapper library as needed.
106 #
107 proc libjava_init { args } {
108     global wrapper_file;
109     global wrap_compile_flags;
110     global libjava_initialized libjava_uses_threads
111     global GCJ_UNDER_TEST
112     global TOOL_EXECUTABLE
113     global original_ld_library_path
114     global env objdir
115
116     if { $libjava_initialized == 1 } { return; }
117
118     if ![info exists GCJ_UNDER_TEST] {
119         if [info exists TOOL_EXECUTABLE] {
120             set GCJ_UNDER_TEST $TOOL_EXECUTABLE;
121         } else {
122             if [info exists env(GCJ)] {
123                 set GCJ_UNDER_TEST $env(GCJ)
124             } else {
125                 set GCJ_UNDER_TEST "[find_gcj]"
126             }
127         }
128     }
129
130     # The -B is so we find libgcj.spec.
131     set text [eval exec "$GCJ_UNDER_TEST -B$objdir/../ -v 2>@ stdout"]
132     regexp -- "Thread model: (\[^\n\]+)\n" $text ignore model
133     set libjava_uses_threads [expr {! ($model == "no"
134                                        || $model == "none"
135                                        || $model == "single")}]
136
137     # Always set encoding used by gcj.
138     append GCJ_UNDER_TEST " --encoding=UTF-8"
139
140     if [info exists env(LD_LIBRARY_PATH)] {
141         set original_ld_library_path $env(LD_LIBRARY_PATH)
142     } else {
143         if [info exists env(SHLIB_PATH)] {
144             set original_ld_library_path $env(SHLIB_PATH)
145         } else {
146             set original_ld_library_path ""
147         }
148     }
149
150     set wrapper_file "";
151     set wrap_compile_flags "";
152     if [target_info exists needs_status_wrapper] {
153         set result [build_wrapper "testglue.o"];
154         if { $result != "" } {
155             set wrapper_file [lindex $result 0];
156             set wrap_compile_flags [lindex $result 1];
157         } else {
158             warning "Status wrapper failed to build."
159         }
160     }
161
162     set libjava_initialized 1
163 }
164
165 # Find a library.  We know where libtool puts the actual libraries,
166 # and we look there.  The implementation is fairly hacky.  We can't
167 # compile with -nodefaultlibs, because that will also eliminate the
168 # system libraries we need.  In order to have gcj still work, it must
169 # find the appropriate libraries so we must add -L options for their
170 # paths.  However we can't simply use those libraries; we still need
171 # libtool for linking.
172 proc libjava_find_lib {dir name} {
173     global base_dir
174     set gp [get_multilibs]
175     foreach sub {.libs _libs} {
176         if {$gp != ""} {
177             if {[file exists $gp/$dir/$sub/lib${name}.a]} then {
178                 return "$gp/$dir/lib${name}.la -L$gp/$dir/$sub"
179             }
180         }
181         set lib [findfile $base_dir/../../$dir/$sub/lib${name}.a \
182                    "$base_dir/../../$dir/lib${name}.la -L$base_dir/../../$dir/$sub" \
183                    ""]
184         if {$lib != ""} {
185             return $lib
186         }
187     }
188     return ""
189 }
190
191 # Remove a bunch of files.
192 proc gcj_cleanup {args} {
193     foreach file $args {
194         if {[string match *.o $file]} {
195             verbose "removing [file rootname $file].lo"
196             file delete -force [file rootname $file].lo
197         }
198         file delete -force -- $file
199         verbose "removing $file"
200     }
201     # It is simplest to do this instead of trying to figure out what
202     # bits in .libs ought to be removed.
203     catch {system "rm -rf .libs"}
204 }
205
206 # Compute arguments needed for compiler.  MODE is a libtool mode:
207 # either compile or link.
208 proc libjava_arguments {{mode compile}} {
209     global base_dir
210     global LIBJAVA
211     global LIBGC
212     global LIBQTHREADS
213     global LIBZ
214     global srcdir subdir objdir
215     global TOOL_OPTIONS
216     global GCJ_UNDER_TEST
217     global tmpdir
218     global runtests
219     global env
220     global tool_root_dir
221
222     if [info exists LIBJAVA] {
223         set libjava $LIBJAVA;
224     } else {
225         set libjava [libjava_find_lib libjava gcj]
226     }
227
228     if [info exists LIBGC] {
229         set libgc $LIBGC;
230     } else {
231         set libgc [libjava_find_lib boehm-gc gcjgc]
232     }
233
234     if [info exists LIBQTHREADS] {
235         set libqthreads $LIBQTHREADS
236     } else {
237         set libqthreads [libjava_find_lib qthreads gcjcoop]
238     }
239
240     if [info exists LIBZ] {
241         set libz $LIBZ
242     } else {
243         set libz [libjava_find_lib zlib zgcj]
244     }
245
246     # FIXME: there's no way to determine whether -lpthread is
247     # required.  We should get this info from configure, or it should
248     # just be in the compiler driver.
249
250     verbose "using LIBJAVA = $libjava" 2
251     verbose "using LIBGC = $libgc" 2
252     verbose "using LIBQTHREADS = $libqthreads" 2
253     verbose "using LIBZ = $libz" 2
254     set args ""
255
256     # Basically we want to build up a colon separated path list from
257     # the value of $libjava.
258
259     set lpath {}
260     foreach dir [list $libjava $libgc $libz] {
261         foreach item [split $dir " "] {
262             switch -glob -- $item {
263                 "-L*" {
264                     lappend lpath [string range $item 2 end]
265                 }
266             }
267         }
268     }
269
270     # Finally, add the gcc build directory so that we can find the
271     # shared libgcc.  This, like much of dejagnu, is hideous.
272     set gccdir [lookfor_file $tool_root_dir gcc/libgcc_s.so]
273     if {$gccdir != ""} {
274         lappend lpath [file dirname $gccdir]
275     }
276
277     set ld_library_path [join $lpath :]
278
279     # That's enough to make things work for the normal case.
280     # If we wanted to handle an arbitrary value of libjava,
281     # then we'd have to do a lot more work.
282
283     # Set variables the dynamic linker looks at.
284     global original_ld_library_path
285     setenv LD_LIBRARY_PATH "$ld_library_path:$original_ld_library_path"
286     setenv SHLIB_PATH "$ld_library_path:$original_ld_library_path"
287
288     verbose "LD_LIBRARY_PATH = $env(LD_LIBRARY_PATH)"
289
290     # Set the CLASSPATH environment variable
291     verbose "CLASSPATH is .:$srcdir/$subdir:$objdir:$objdir/../libgcj.jar"
292     global env
293     set env(CLASSPATH) ".:$srcdir/$subdir:$objdir:$objdir/../libgcj.jar"
294
295     global wrapper_file wrap_compile_flags;
296     lappend args "additional_flags=$wrap_compile_flags";
297     lappend args "libs=$wrapper_file";
298     lappend args "libs=$libjava";
299     lappend args "libs=$libgc";
300     lappend args "libs=$libqthreads"
301     lappend args "libs=$libz"
302     lappend args debug
303
304     if { [target_info needs_status_wrapper]!="" && [info exists gluefile] } {
305         lappend args "libs=${gluefile}"
306         lappend args "ldflags=$wrap_flags"
307     }
308
309     if [info exists TOOL_OPTIONS] {
310         lappend args "additional_flags=$TOOL_OPTIONS"
311     }
312
313     # Search for libtool.  We need it to link.
314     set found_compiler 0
315     set d [absolute $objdir]
316     foreach x {. .. ../.. ../../..} {
317         if {[file exists $d/$x/libtool]} then {
318             # We have to run silently to avoid DejaGNU lossage.
319             lappend args \
320               "compiler=$d/$x/libtool --silent --tag=GCJ --mode=$mode $GCJ_UNDER_TEST -B$objdir/../"
321             set found_compiler 1
322             break
323         }
324     }
325     if {! $found_compiler} {
326         # Append -B$objdir/../ so that we find libgcj.spec before it
327         # is installed.
328         lappend args "compiler=$GCJ_UNDER_TEST -B$objdir/../"
329     }
330
331     # Avoid libtool wrapper scripts when possible.
332     if {$mode == "link"} {
333         lappend args "additional_flags=-no-install"
334     }
335
336     return $args
337 }
338
339 # Link a bunch of objects into a program.  MAIN is the name of the
340 # class holding `main'.  Return 0 on failure.
341 proc gcj_link {program main files {options {}}} {
342     set arguments [libjava_arguments link]
343     if {[llength $options]} {
344         eval lappend arguments $options
345     }
346     lappend arguments "additional_flags=--main=$main"
347     set x [prune_warnings [libjava_tcompile $files $program executable \
348                              $arguments]]
349     if {$x != ""} {
350         verbose "link failure: $x" 2
351         fail "linking $program"
352         setup_xfail "*-*-*"
353         fail "running $program"
354         return 0
355     }
356
357     pass "linking $program"
358     return 1
359 }
360
361 #
362 # Run the test specified by srcfile and resultfile. compile_args and
363 # exec_args are options telling this proc how to work.
364 #
365 proc test_libjava_from_source { options srcfile compile_args inpfile resultfile exec_args } {
366     global base_dir
367     global LIBJAVA
368     global LIBGC
369     global srcdir subdir objdir
370     global TOOL_OPTIONS
371     global GCJ_UNDER_TEST
372     global tmpdir
373     global runtests
374
375     # Make opts into an array.
376     set opts(_) x
377     unset opts(_)
378     foreach item $exec_args {
379         set opts($item) x
380     }
381
382     # If we need threads and we don't have them then set the `no-exec'
383     # flag.  This is case is also handled specially later.
384     if {[info exists opts(need-threads)]} {
385         global libjava_uses_threads
386         if {! $libjava_uses_threads} {
387             set opts(no-exec) x
388         }
389     }
390
391     set errname [file rootname [file tail $srcfile]]
392     if {! [runtest_file_p $runtests $errname]} {
393         return
394     }
395
396     if {[info exists opts(no-link)]} {
397         set mode compile
398     } else {
399         set mode link
400     }
401     set args [libjava_arguments $mode]
402     if {! [info exists opts(no-link)]} {
403         # Add the --main flag
404         lappend args "additional_flags=--main=[file rootname [file tail $srcfile]]"
405         if { $compile_args != "" } {
406             lappend args "additional_flags=$compile_args"
407         }
408     }
409
410     regsub "^.*/(\[^/.\]+)\[.\]\[^/]*$" "$srcfile" "\\1" out
411     set executable "${objdir}/$out"
412     if {[info exists opts(no-link)]} {
413         append executable ".o"
414         set target object
415     } else {
416         set target executable
417     }
418     if { $compile_args != "" } {
419         set errname "$errname $compile_args"
420     }
421
422     set removeList [list $executable]
423
424     set x [prune_warnings \
425              [libjava_tcompile $srcfile "$executable" $target $args]]
426     if {[info exists opts(xfail-gcj)]} {
427         setup_xfail *-*-*
428     }
429     if { $x != "" } {
430         verbose "target_compile failed: $x" 2
431
432         if {[info exists opts(shouldfail)]} {
433             pass "$errname compilation from source"
434             eval gcj_cleanup $removeList
435             return
436         }
437
438         fail "$errname compilation from source"
439         if {[info exists opts(xfail-gcj)]
440             || ! [info exists opts(no-exec)]
441             || [info exists opts(need-threads)]} {
442             untested "$errname execution from source compiled test"
443             untested "$errname output from source compiled test"
444         }
445         return
446     }
447     if {[info exists opts(shouldfail)]} {
448         fail "$errname compilation from source"
449         return
450     }
451     pass "$errname compilation from source"
452
453     if {[info exists opts(no-exec)]} {
454         if {[info exists opts(need-threads)]} {
455             # This means we wanted to try to run it but we couldn't
456             # because threads aren't supported.  So we have to
457             # generate an `untested'.
458             untested "$errname execution from source compiled test"
459             untested "$errname output from source compiled test"
460         }
461         eval gcj_cleanup $removeList
462         return
463     }
464     if {[info exists opts(no-link)]} {
465         eval gcj_cleanup $removeList
466         return
467     }
468
469     set result [libjava_load $executable "" "$inpfile"];
470     set status [lindex $result 0];
471     set output [lindex $result 1];
472     if {[info exists opts(xfail-exec)]} then {
473         setup_xfail *-*-*
474     }
475     $status "$errname execution from source compiled test"
476     if { $status != "pass" } {
477         untested "$errname output from source compiled test"
478         return;
479     }
480
481     verbose "resultfile is $resultfile"
482     set id [open $resultfile r];
483     set expected ""
484     append expected [read $id];
485     regsub -all "\r" "$output" "" output;
486     regsub "\n*$" $expected "" expected
487     regsub "\n*$" $output "" output
488     regsub "^\n*" $expected "" expected
489     regsub "^\n*" $output "" output
490     regsub -all "\[ \t\]\[ \t\]*" $expected " " expected
491     regsub -all "\[ \t\]*\n\n*" $expected "\n" expected
492     regsub -all "\[ \t\]\[ \t\]*" $output " " output
493     regsub -all "\[ \t\]*\n\n*" $output "\n" output
494     verbose "expected is $expected"
495     verbose "actual is $output"
496     set passed 0;
497     if {$options == "regexp_match"} {
498         if [regexp $expected $output] {
499             set passed 1;
500         }
501     } else {
502         if { $expected == $output } {
503             set passed 1;
504         }
505     }
506     if {[info exists opts(xfail-output)]} {
507         setup_xfail *-*-*
508     }
509     if { $passed == 1 } {
510         pass "$errname output from source compiled test"
511         eval gcj_cleanup $removeList
512     } else {
513         clone_output "expected was $expected"
514         clone_output "output was $output"
515         fail "$errname output from source compiled test"
516     }
517     close $id;
518 }
519
520 #
521 # Run the test specified by srcfile and resultfile. compile_args and
522 # exec_args are options telling this proc how to work.
523 #
524 proc test_libjava_from_javac { options srcfile compile_args inpfile resultfile exec_args } {
525     global base_dir
526     global LIBJAVA
527     global LIBGC
528     global srcdir subdir objdir
529     global TOOL_OPTIONS
530     global GCJ_UNDER_TEST
531     global tmpdir
532     global runtests
533
534     # Make opts into an array.
535     set opts(_) x
536     unset opts(_)
537     foreach item $exec_args {
538         set opts($item) x
539     }
540
541     # If we need threads and we don't have them then set the `no-exec'
542     # flag.  This is case is also handled specially later.
543     if {[info exists opts(need-threads)]} {
544         global libjava_uses_threads
545         if {! $libjava_uses_threads} {
546             set opts(no-exec) x
547         }
548     }
549     set errname [file rootname [file tail $srcfile]]
550     if {! [runtest_file_p $runtests $errname]} {
551         return
552     }
553
554     # bytecompile files with Sun's compiler for now.
555     set bc_ok [bytecompile_file $srcfile $objdir]
556
557     set javac [find_javac]
558     # This is an ugly heuristic but it will have to do.
559     if {[string match *gcj* $javac]} {
560         set tag gcjC
561     } else {
562         set tag javac
563     }
564     if {[info exists opts(xfail-$tag)]} {
565         setup_xfail *-*-*
566     }
567     if {! $bc_ok} then {
568         if {[info exists opts(shouldfail)]} {
569             pass "$errname byte compilation"
570             return
571         }
572         fail "$errname byte compilation"
573         untested "$errname compilation from bytecode"
574         if {! [info exists opts(no-exec)]
575             || [info exists opts(need-threads)]} {
576             untested "$errname execution from bytecode->native test"
577             untested "$errname output from bytecode->native test"
578         }
579         return
580     }
581     if {[info exists opts(shouldfail)]} {
582         fail "$errname byte compilation"
583         return
584     }
585     pass "$errname byte compilation"
586
587     set removeList {}
588
589     # Find name to use for --main, and name of all class files.
590     set jvscan [find_jvscan]
591     verbose "jvscan is $jvscan"
592     set main_name [string trim \
593                      [prune_warnings \
594                         [lindex [local_exec "$jvscan --encoding=UTF-8 $srcfile --print-main" "" "" 300] 1]]]
595     verbose "main name is $main_name"
596     set class_out [string trim \
597                      [prune_warnings \
598                         [lindex [local_exec "$jvscan --encoding=UTF-8 $srcfile --list-class" "" "" 300] 1]]]
599     verbose "class list is $class_out"
600
601     if {[string match "*parse error*" $main_name]
602         || [string match "*parse error*" $class_out]} {
603         untested "$errname compilation from bytecode"
604         if {! [info exists opts(no-exec)]
605             || [info exists opts(need-threads)]} {
606             untested "$errname execution from bytecode->native test"
607             untested "$errname output from bytecode->native test"
608         }
609         return
610     }
611
612     # Turn "a b" into "a.class b.class".
613     # Also, turn "foo.bar" into "foo/bar.class".
614     set class_files {}
615     foreach file [split [string trim $class_out]] {
616         set file [join [split $file .] /]
617         lappend class_files $objdir/$file.class
618     }
619
620     eval lappend removeList $class_files
621
622     # Usually it is an error for a test program not to have a `main'
623     # method.  However, for no-exec tests it is ok.  Treat no-link
624     # like no-exec here.
625     if {[info exists opts(no-link)]} {
626         set opts(no-exec) x
627     }
628     set largs {}
629
630     if {[info exists opts(no-exec)]} {
631         set type object
632         set mode compile
633     } elseif {$main_name == ""} {
634         perror "No `main' given in program $errname"
635         return
636     } else {
637         set type executable
638         lappend largs "additional_flags=--main=$main_name"
639         set executable "${objdir}/$main_name"
640         set mode link
641     }
642
643     # Initial arguments.
644     set args [libjava_arguments $mode]
645     eval lappend args $largs
646
647     if { $compile_args != "" } {
648         lappend args "additional_flags=$compile_args"
649     }
650
651     if { $compile_args != "" } {
652         set errname "$errname $compile_args"
653     }
654
655     verbose "compilation command = $args" 2
656     # When compiling and not linking, we have to build each .o
657     # separately.  We do this because DejaGNU's target_compile won't
658     # accept an empty "destfile" argument when the mode is "compile".
659     if {$mode == "compile"} {
660         foreach c_file $class_files {
661             set executable [file rootname [file tail $c_file]].o
662             set x [prune_warnings \
663                      [libjava_tcompile $c_file "$executable" $type $args]]
664             lappend removeList $executable
665             if {$x != ""} {
666                 break
667             }
668         }
669     } else {
670         # This is so evil: we de-listify CLASS_FILES so that we can
671         # turn around and quote the `$' in it for the shell.  I really
672         # hate DejaGNU.  It is so !@#$!@# unpredictable.
673         set hack ""
674         foreach stupid $class_files {
675             set hack "$hack $stupid"
676         }
677         lappend removeList $executable
678         set x [prune_warnings \
679                  [libjava_tcompile $hack "$executable" $type $args]]
680     }
681     if {[info exists opts(xfail-byte)]} {
682         setup_xfail *-*-*
683     }
684     if { $x != "" } {
685         verbose "target_compile failed: $x" 2
686         fail "$errname compilation from bytecode"
687         if {! [info exists opts(no-exec)]
688             || [info exists opts(need-threads)]} {
689             untested "$errname execution from bytecode->native test"
690             untested "$errname output from bytecode->native test"
691         }
692         return;
693     }
694     pass "$errname compilation from bytecode"
695
696     if {[info exists opts(no-exec)]} {
697         if {[info exists opts(need-threads)]} {
698             untested "$errname execution from bytecode->native test"
699             untested "$errname output from bytecode->native test"
700         }
701         eval gcj_cleanup $removeList
702         return
703     }
704
705     set result [libjava_load $executable "" "$inpfile"];
706     set status [lindex $result 0];
707     set output [lindex $result 1];
708     if {[info exists opts(xfail-exec)]} {
709         setup_xfail *-*-*
710     }
711     $status "$errname execution from bytecode->native test"
712     if { $status != "pass" } {
713         untested "$errname output from bytecode->native test"
714         return
715     }
716
717     verbose "resultfile is $resultfile"
718     set id [open $resultfile r];
719     set expected ""
720     append expected [read $id];
721     regsub -all "\r" "$output" "" output;
722     regsub "\n*$" $expected "" expected
723     regsub "\n*$" $output "" output
724     regsub "^\n*" $expected "" expected
725     regsub "^\n*" $output "" output
726     regsub -all "\[ \t\]\[ \t\]*" $expected " " expected
727     regsub -all "\[ \t\]*\n\n*" $expected "\n" expected
728     regsub -all "\[ \t\]\[ \t\]*" $output " " output
729     regsub -all "\[ \t\]*\n\n*" $output "\n" output
730     verbose "expected is $expected"
731     verbose "actual is $output"
732     set passed 0;
733     if {[info exists opts(xfail-output)]} {
734         setup_xfail *-*-*
735     }
736     if {$options == "regexp_match"} {
737         if [regexp $expected $output] {
738             set passed 1;
739         }
740     } else {
741         if { $expected == $output } {
742             set passed 1;
743         }
744     }
745     if { $passed == 1 } {
746         pass "$errname output from bytecode->native test"
747         eval gcj_cleanup $removeList
748     } else {
749         clone_output "expected was $expected"
750         clone_output "output was $output"
751         fail "$errname output from bytecode->native test"
752     }
753     close $id;
754 }
755
756 #
757 # Run the test specified by srcfile and resultfile. compile_args and
758 # exec_args are options telling this proc how to work.
759 #   `no-link'     don't try to link the program
760 #   `no-exec'     don't try to run the test
761 #   `xfail-gcj'   compilation from source will fail
762 #   `xfail-javac' compilation with javac will fail
763 #   `xfail-gcjC'  compilation with gcj -C will fail
764 #   `shouldfail'  compilation from source is supposed to fail
765 #                 This is different from xfail, which marks a known
766 #                 failure that we just havne't fixed.
767 #                 A compilation marked this way should fail with any
768 #                 front end.
769 #   `xfail-byte'  compilation from bytecode will fail
770 #   `xfail-exec'  exec will fail
771 #   `xfail-output'
772 #                 output will be wrong
773 #   `need-threads'
774 #                 test relies on thread support
775 #
776 proc test_libjava { options srcfile compile_args inpfile resultfile exec_args } {
777     test_libjava_from_source $options $srcfile $compile_args $inpfile $resultfile $exec_args
778     test_libjava_from_javac $options $srcfile $compile_args $inpfile $resultfile $exec_args
779  }
780
781 #
782 # libjava_version -- extract and print the version number of libjavap
783 #
784 proc default_libjava_version {} {
785 }
786
787 proc default_libjava_start { } {
788 }
789
790 # Local Variables:
791 # tcl-indent-level:4
792 # End: