Allow Xcos use compiled --without-gui.
[scilab.git] / scilab / m4 / java.m4
1 ##¬†Macros "stolen" from jacl (http://tcljava.sourceforge.net/)
2 ## They made a great job on this part !
3
4 #------------------------------------------------------------------------
5 # AC_MSG_LOG( MSG, ?LOGONLY? )
6 #
7 #       Write the message out to the config.log file and the console.
8 #       If 1 is passed as the second argument, then write to the
9 #       config.log file only.
10 #
11 # Arguments:
12 #       1. The message to log
13 #       2. Optional boolean, if true then write to config.log only
14 #------------------------------------------------------------------------
15
16 AC_DEFUN([AC_MSG_LOG], [
17     echo $1 >&AS_MESSAGE_LOG_FD
18     m4_ifval([$2],,[echo $1])
19 ])
20
21 #------------------------------------------------------------------------
22 # AC_GREP_FILE( PATTERN, FILE, ACTION-IF-FOUND, [ACTION-IF-NOT-FOUND])
23 #
24 #       Use grep to search for a pattern in a file. If the pattern
25 #       is not found then return a non zero exit status. No information
26 #       will be echoed to the screen by this macro.
27 #
28 # Arguments:
29 #       1. The pattern to search for
30 #       2. The name of the file to be grep'ed
31 #       3. The script to execute if PATTERN is found in FILE
32 #       4. The script to execute if PATTERN is not found in FILE (optional)
33 #------------------------------------------------------------------------
34
35 AC_DEFUN([AC_GREP_FILE], [
36     AC_MSG_LOG([grep in $2 for pattern '"$1"'], 1)
37     if (grep "$1" $2 > /dev/null 2>&1) ; then
38         AC_MSG_LOG([grep result : yes], 1)
39         $3
40     else
41         AC_MSG_LOG([grep result : no], 1)
42         m4_ifval([$4], [
43             $4
44         ])dnl
45     fi
46 ])
47
48
49 #------------------------------------------------------------------------
50 # AC_PROG_JAVAC
51 #
52 #       If JAVAC is not already defined, then search for "javac" on
53 #       the path. If a java compiler is found, then test it to make
54 #       sure it actually works.
55 #
56 # Arguments:
57 #       NONE
58 #
59 # VARIABLES SET:
60 #       JAVAC can be set to the path name of the java compiler
61 #       JAVAC_FLAGS can be set to compiler specific flags
62 #       ac_java_jvm_dir can be set to the jvm's root directory
63 #------------------------------------------------------------------------
64
65 AC_DEFUN([AC_PROG_JAVAC], [
66 # Mac OS X
67     if test "x$JAVAC" = "x" ; then
68         case "$host_os" in
69              *darwin* ) 
70              # Don't follow the symlink since Java under MacOS is messy
71                 JAVAC="/System/Library/Frameworks/JavaVM.framework/Home/bin/javac"
72                 DONT_FOLLOW_SYMLINK=yes
73                 ;;
74         esac
75         fi
76     if test "x$JAVAC" = "x" ; then
77         AC_PATH_PROG(JAVAC, javac)
78         if test "x$JAVAC" = "x" ; then
79             AC_MSG_ERROR([javac not found on PATH ... did you try with --with-jdk=DIR])
80         fi
81     fi
82     if test ! -f "$JAVAC" ; then
83         AC_MSG_ERROR([javac '$JAVAC' does not exist.
84         Perhaps Java is not installed or you passed a bad dir to a --with option.])
85     fi
86
87     # Check for installs which uses a symlink. If it is the case, try to resolve JAVA_HOME from it
88     if test -h "$JAVAC" -a "x$DONT_FOLLOW_SYMLINK" != "xyes"; then
89                 FOLLOW_SYMLINKS($JAVAC,"javac")
90                 JAVAC=$SYMLINK_FOLLOWED_TO
91         TMP=`dirname $SYMLINK_FOLLOWED_TO`
92         TMP=`dirname $TMP`
93         ac_java_jvm_dir=$TMP
94                 echo "Java base directory (probably) available here : $ac_java_jvm_dir"
95     fi
96
97
98
99     # If we were searching for javac, then set ac_java_jvm_dir
100     if test "x$ac_java_jvm_dir" = "x"; then
101         TMP=`dirname $JAVAC`
102         TMP=`dirname $TMP`
103         ac_java_jvm_dir=$TMP
104     fi
105
106     # Look for a setting for the CLASSPATH, we might need one to run JAVAC
107     AC_JAVA_CLASSPATH
108
109     # FIXME : add detection of command line arguments for JAVAC
110
111     JAVAC_FLAGS=-g
112     JAVAC_D_FLAG=-d
113
114     dnl Test out the Java compiler with an empty class
115     AC_MSG_CHECKING([to see if the java compiler works])
116     AC_JAVA_TRY_COMPILE(,,works=yes)
117     if test "$works" = "yes" ; then
118         AC_MSG_RESULT($works)
119     else
120         AC_MSG_ERROR([Could not compile simple Java program with '$JAVAC'. Try with the Sun JDK (1.5 or 6).])
121     fi
122
123     AC_MSG_LOG([Using JAVAC=$JAVAC], 1)
124 ])
125
126
127 #------------------------------------------------------------------------
128 # AC_JAVA_TRY_COMPILE(imports, main-body, action-if-worked, [action-if-failed])
129 #
130 #       Try to compile a Java program. This works a lot like AC_TRY_COMPILE
131 #       except is supports Java instead of C or C++. This macro will create
132 #       a file named Test.java and try to compile it.
133 #
134 # Arguments:
135 #       imports should contain Java import statements like [import java.util.*;]
136 #       main-body should contain the code to appear in the main() method
137 #       action-if-worked should contain the code to run if the compile worked
138 #       action-if-failed should contain the code to run if the compile failed (optional)
139 #------------------------------------------------------------------------
140
141 AC_DEFUN([AC_JAVA_TRY_COMPILE], [
142     cat << \EOF > conftest.java
143 // [#]line __oline__ "configure"
144 [$1]
145
146 public class conftest {
147     public static void main(String[[]] argv) {
148         [$2]
149     }
150 }
151 EOF
152
153     CLASSPATH=$ac_java_classpath
154     export CLASSPATH
155     cmd="$JAVAC ${JAVAC_FLAGS} conftest.java"
156     if (echo $cmd >&AS_MESSAGE_LOG_FD ; eval $cmd >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD) ; then
157         echo "yes" >&AS_MESSAGE_LOG_FD
158         $3
159     else
160         echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD
161         cat conftest.java >&AS_MESSAGE_LOG_FD
162         echo "configure: CLASSPATH was $CLASSPATH" >&AS_MESSAGE_LOG_FD
163         m4_ifval([$4],
164         [  $4
165         ])dnl
166     fi
167 ])
168
169
170 #------------------------------------------------------------------------
171 # AC_JAVA_DETECT_JVM
172 #
173 #       Figure out what JVM to build with. If no JVM was already defined
174 #       using a --with command line option then we search for one
175 #       by looking for the javac executable.
176 #
177 # Arguments:
178 #       NONE
179 #
180 # VARIABLES SET:
181 #       JAVAC
182 #       ac_java_jvm_version can be set to 1.4, or 1.5
183 #       ac_java_jvm_dir can be set to the jvm's root directory
184 #
185 # DEPENDS ON:
186 #       This macro can depend on the values set by the following macros:
187 #       AC_JAVA_WITH_JDK
188 #       AC_PROG_JAVAC
189 #------------------------------------------------------------------------
190
191 AC_DEFUN([AC_JAVA_DETECT_JVM], [
192         AC_MSG_CHECKING([JAVA_HOME variable]) 
193         # check if JAVA_HOME is set. If it is the case, try to use if first
194         if test ! -z "$JAVA_HOME" && test "x$ac_java_jvm_dir" == "x"; then
195                 if test -x $JAVA_HOME/bin/javac${EXEEXT}; then
196                     AC_MSG_RESULT([JAVA_HOME variable found, use it as JVM root directory])
197                     ac_java_jvm_dir=`cd $JAVA_HOME ; pwd`
198                         JAVAC=$ac_java_jvm_dir/bin/javac${EXEEXT}
199                 else
200                     AC_MSG_RESULT([JAVA_HOME variable found, but unable to find javac
201 Maybe JAVA_HOME is pointing to a JRE (Java Runtime Environment) instead of a JDK (Java Developement Kit) ? )])
202                 fi
203         else
204                 AC_MSG_RESULT([not defined])
205         fi
206
207 # Mac OS default path
208         if test "x$JAVAC" = "x" && test "x$ac_java_jvm_dir" != "x"; then
209                 case "$host_os" in
210                      *darwin* ) 
211                         AC_MSG_RESULT([Darwin (Mac OS X) found. Use the standard paths.])
212                         ac_java_jvm_dir="/System/Library/Frameworks/JavaVM.framework/Home/"
213                         JAVAC=$ac_java_jvm_dir/bin/javac
214                         ;;
215                 esac
216         fi
217
218     # if we do not know the jvm dir, javac will be found on the PATH
219     if test "x$JAVAC" = "x" && test "x$ac_java_jvm_dir" != "x"; then
220         ac_java_jvm_dir=`cd $ac_java_jvm_dir ; pwd`
221         JAVAC=$ac_java_jvm_dir/bin/javac${EXEEXT}
222     fi
223
224     # Search for and test the javac compiler
225     AC_PROG_JAVAC
226
227     AC_MSG_LOG([Java found in $ac_java_jvm_dir])
228
229     # Try to detect non JDK JVMs. If we can't, then just assume a jdk
230
231     AC_MSG_CHECKING([type of jvm]) 
232
233     if test "x$ac_java_jvm_name" = "x" ; then
234         AC_JAVA_TRY_COMPILE([import gnu.java.io.EncodingManager;],,ac_java_jvm_name=gcj)
235     fi
236
237     if test "x$ac_java_jvm_name" = "x" ; then
238        ac_java_jvm_name=jdk
239     fi
240
241     AC_MSG_RESULT([$ac_java_jvm_name])
242
243     case "$ac_java_jvm_name" in
244         gcj) DO=nothing ;;
245         jdk) DO=nothing ;;
246         *) AC_MSG_ERROR(['$ac_java_jvm_name' is not a supported JVM]) ;;
247     esac
248
249     # Try to detect the version of java that is installed
250
251     AC_MSG_CHECKING([java API version])
252
253     # The class java.nio.charset.Charset is new to 1.4
254
255     AC_JAVA_TRY_COMPILE([import java.nio.charset.Charset;], , ac_java_jvm_version=1.4)
256
257     # The class java.lang.StringBuilder is new to 1.5
258
259     AC_JAVA_TRY_COMPILE([import java.lang.StringBuilder;], , ac_java_jvm_version=1.5)
260
261     if test "x$ac_java_jvm_version" = "x" ; then
262         AC_MSG_ERROR([Could not detect Java version, 1.4 or newer is required])
263     fi
264
265     AC_MSG_RESULT([$ac_java_jvm_version])
266
267 ])
268
269
270 #------------------------------------------------------------------------
271 # AC_JAVA_CLASSPATH
272 #
273 #       Find out which .zip or .jar files need to be included on
274 #       the CLASSPATH if we are setting it via an env variable.
275 #
276 # Arguments:
277 #       NONE
278 #
279 # VARIABLES SET:
280 #       ac_java_classpath
281 #
282 # DEPENDS ON:
283 #       This macro is used by the AC_JAVA_DETECT_JVM macro.
284 #       It depends on the ac_java_jvm_dir variable.
285 #------------------------------------------------------------------------
286
287 AC_DEFUN([AC_JAVA_CLASSPATH], [
288     AC_MSG_CHECKING([for zip or jar files to include on CLASSPATH])
289
290     if test "x$ac_java_jvm_dir" = "x" ; then
291         AC_MSG_ERROR([jvm directory not set])
292     fi
293
294     # GNU gcj does not need to set the CLASSPATH.
295
296     # Assume that JDK 1.4 and newer systems will
297     # not need to explicitly set the CLASSPATH.
298
299     # Append CLASSPATH if env var is set. Avoid append
300     # under msys because CLASSPATH is in Win32 format
301     # and we can't combine it with a msys path.
302     if test "x$CLASSPATH" != "x" && test "$ac_cv_tcl_win32" != "yes" ; then
303         AC_MSG_LOG([Adding user supplied CLASSPATH env var])
304         ac_java_classpath="${ac_java_classpath}:${CLASSPATH}"
305     fi
306
307     AC_MSG_LOG([Using CLASSPATH=$ac_java_classpath], 1)
308     AC_MSG_RESULT($ac_java_classpath)
309 ])
310
311
312 #------------------------------------------------------------------------
313 # AC_JAVA_JNI_INCLUDE
314 #
315 #       Figure out where jni.h and jni_md.h include files are installed.
316 #
317 # Arguments:
318 #       NONE
319 #
320 # VARIABLES SET:
321 #       ac_java_jvm_jni_include_flags : Flags that we pass to the compiler
322 #           so that it can locate JNI headers. (for example: -I/usr/jdk/include)
323 #
324 # DEPENDS ON:
325 #       This macro must be run after the AC_JAVA_DETECT_JVM macro as
326 #       it depends on the ac_java_jvm_dir variable.
327 #------------------------------------------------------------------------
328
329 AC_DEFUN([AC_JAVA_JNI_INCLUDE], [
330
331         # JAVA_HOME specificed, check if we can find jni.h in this path
332         if test !  -z "$JAVA_HOME"; then
333                 ac_java_jvm_dir=$JAVA_HOME
334         fi
335     # Look for jni.h in the subdirectory $ac_java_jvm_dir/include
336
337     F=$ac_java_jvm_dir/include/jni.h
338     if test -f "$F" ; then
339          ac_java_jvm_jni_include_flags="-I`dirname $F`"
340     else
341          F=`ls $ac_java_jvm_dir/include/*/jni.h 2>/dev/null`
342          if test -f "$F" ; then
343              ac_java_jvm_jni_include_flags="-I`dirname $F`"
344          else
345                 case "$host_os" in
346                      *darwin* ) 
347                               ac_java_jvm_jni_include_flags="-I$ac_java_jvm_dir/Headers/"
348                               ;;
349                       *)
350                            AC_MSG_ERROR([Could not locate Java's jni.h include file])
351                            ;;
352                            esac
353          fi
354     fi
355
356     # Look for jni_md.h in an arch specific subdirectory
357     # we assume that there is only one arch subdirectory,
358     # if that is not the case we would need to use $host
359
360     F=`ls $ac_java_jvm_dir/include/*/jni_md.h 2>/dev/null`
361     if test -f "$F" ; then
362         ac_java_jvm_jni_include_flags="$ac_java_jvm_jni_include_flags -I`dirname $F`"
363     fi
364
365     AC_MSG_LOG([Using the following JNI include flags $ac_java_jvm_jni_include_flags])
366
367     # Make sure a simple #include <jni.h> will compile.
368
369     AC_REQUIRE([AC_PROG_CC])
370
371     AC_CACHE_CHECK(if jni.h can be included,
372         ac_cv_java_jvm_jni_working,[
373         AC_LANG_PUSH(C)
374         ac_saved_cflags=$CFLAGS
375         CFLAGS="$CFLAGS $ac_java_jvm_jni_include_flags"
376         AC_TRY_COMPILE([
377             #include <jni.h>
378         ],[return 0;],
379         ac_cv_java_jvm_jni_working=yes,
380         AC_MSG_ERROR([could not compile file that includes jni.h]))
381         AC_LANG_POP()
382         CFLAGS=$ac_saved_cflags
383     ])
384
385     # FIXME: should we look for or require a include/native_threads dir?
386 ])
387
388
389
390 #------------------------------------------------------------------------
391 # AC_JAVA_JNI_LIBS
392 #
393 #       Figure out where the native threads libraries for JNI live.
394 #
395 # Arguments:
396 #       NONE
397 #
398 # VARIABLES SET:
399 #       ac_java_jvm_ld_preload : list of libraries to include in LD_PRELOAD
400 #       ac_java_jvm_ld_bind_now : if set to 1, then use LD_BIND_NOW=1
401 #       ac_java_jvm_jni_lib_flags : library flags that we will pass to the compiler.
402 #           For instance, we might pass -L/usr/jdk/lib -ljava
403 #       ac_java_jvm_jni_lib_runtime_path : colon separated path of directories
404 #           that is typically passed to rld.
405 #
406 # DEPENDS ON:
407 #       This macro must be run after the AC_JAVA_DETECT_JVM macro as
408 #       it depends on the ac_java_jvm_dir variable.
409 #------------------------------------------------------------------------
410
411 AC_DEFUN([AC_JAVA_JNI_LIBS], [
412     machine=`uname -m`
413     case "$machine" in
414         i?86)
415           machine=i386
416           ;;
417         i86pc) 
418                 # Solaris 10 x86
419           machine=i386
420           ;;
421                 sun*)
422        # Sun
423           machine=sparc
424           ;;
425     esac
426
427     # Check for known JDK installation layouts
428
429     # Gives the name of the symbol we want to look for.
430     # Mac OS X add a trailing _Impl
431     libSymbolToTest="JNI_GetCreatedJavaVMs"
432
433     if test "$ac_java_jvm_name" = "jdk"; then
434         # Sun/Blackdown 1.4 for Linux (client JVM)
435
436         F=jre/lib/$machine/libjava.so
437         if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
438             AC_MSG_LOG([Looking for $ac_java_jvm_dir/$F], 1)
439             if test -f $ac_java_jvm_dir/$F ; then
440                 AC_MSG_LOG([Found $ac_java_jvm_dir/$F], 1)
441                 D=`dirname $ac_java_jvm_dir/$F`
442                 ac_java_jvm_jni_lib_runtime_path=$D
443                 ac_java_jvm_jni_lib_flags="-L$D -ljava -lverify"
444                 D=$ac_java_jvm_dir/jre/lib/$machine/client
445                 ac_java_jvm_jni_lib_runtime_path="${ac_java_jvm_jni_lib_runtime_path}:$D"
446                 ac_java_jvm_jni_lib_flags="$ac_java_jvm_jni_lib_flags -L$D -ljvm"
447                 D=$ac_java_jvm_dir/jre/lib/$machine/native_threads
448                 ac_java_jvm_jni_lib_runtime_path="${ac_java_jvm_jni_lib_runtime_path}:$D"
449                 ac_java_jvm_jni_lib_flags="$ac_java_jvm_jni_lib_flags -L$D -lhpi"
450             fi
451         fi
452
453         # Sun JDK 1.5 for AMD64 Linux (server JVM)
454
455         F=jre/lib/amd64/libjava.so
456         if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
457             AC_MSG_LOG([Looking for $ac_java_jvm_dir/$F], 1)
458             if test -f $ac_java_jvm_dir/$F ; then
459                 AC_MSG_LOG([Found $ac_java_jvm_dir/$F], 1)
460
461                 D=`dirname $ac_java_jvm_dir/$F`
462                 ac_java_jvm_jni_lib_runtime_path=$D
463                 ac_java_jvm_jni_lib_flags="-L$D -ljava -lverify"
464
465                 D=$ac_java_jvm_dir/jre/lib/amd64/server
466                 ac_java_jvm_jni_lib_runtime_path="${ac_java_jvm_jni_lib_runtime_path}:$D"
467                 ac_java_jvm_jni_lib_flags="$ac_java_jvm_jni_lib_flags -L$D -ljvm"
468             fi
469         fi
470
471         # Eclipse/IBM Java Compiler
472
473         F=jre/lib/i386/client/libjvm.so
474         if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
475             AC_MSG_LOG([Looking for $ac_java_jvm_dir/$F], 1)
476             if test -f $ac_java_jvm_dir/$F ; then
477                 AC_MSG_LOG([Found $ac_java_jvm_dir/$F], 1)
478
479                 D=`dirname $ac_java_jvm_dir/$F`
480                 ac_java_jvm_jni_lib_runtime_path=$D
481                 ac_java_jvm_jni_lib_flags="-L$D -ljvm"
482
483                 D=$ac_java_jvm_dir/jre/lib/i386/server
484                 ac_java_jvm_jni_lib_runtime_path="${ac_java_jvm_jni_lib_runtime_path}:$D"
485                 ac_java_jvm_jni_lib_flags="$ac_java_jvm_jni_lib_flags -L$D -ljvm"
486             fi
487         fi
488
489         # IBM Java Compiler under Suse (and probably others)
490
491         F=jre/bin/classic/libjvm.so
492         if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
493             AC_MSG_LOG([Looking for $ac_java_jvm_dir/$F], 1)
494             if test -f $ac_java_jvm_dir/$F ; then
495                 AC_MSG_LOG([Found $ac_java_jvm_dir/$F], 1)
496
497                 D=`dirname $ac_java_jvm_dir/$F`
498                 ac_java_jvm_jni_lib_runtime_path=$D
499                 ac_java_jvm_jni_lib_flags="-L$D -ljvm"
500
501                 D=$ac_java_jvm_dir/bin/
502                 ac_java_jvm_jni_lib_runtime_path="${ac_java_jvm_jni_lib_runtime_path}:$D"
503                 ac_java_jvm_jni_lib_flags="$ac_java_jvm_jni_lib_flags -L$D -ljava"
504             fi
505         fi
506
507         # Sun on MacOS X Java Compiler
508
509         F=../Libraries/libjava.jnilib
510         if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
511             AC_MSG_LOG([Looking for $ac_java_jvm_dir/$F], 1)
512             if test -f $ac_java_jvm_dir/$F ; then
513                 AC_MSG_LOG([Found $ac_java_jvm_dir/$F], 1)
514                 libSymbolToTest="JNI_GetCreatedJavaVMs_Impl"
515
516                 D=`dirname $ac_java_jvm_dir/$F`
517                 ac_java_jvm_jni_lib_runtime_path=$D
518                 ac_java_jvm_jni_lib_flags="-L$D -ljvm"
519
520                 D=$ac_java_jvm_dir/jre/lib/i386/server
521                 ac_java_jvm_jni_lib_runtime_path="${ac_java_jvm_jni_lib_runtime_path}:$D"
522                 ac_java_jvm_jni_lib_flags="$ac_java_jvm_jni_lib_flags -L$D -ljvm"
523             fi
524         fi
525
526         # Sun JDK 1.4 and 1.5 for Win32 (client JVM)
527
528         F=lib/jvm.lib
529         if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
530             AC_MSG_LOG([Looking for $ac_java_jvm_dir/$F], 1)
531             if test -f $ac_java_jvm_dir/$F ; then
532                 # jre/bin/client must contain jvm.dll
533                 # jre/bin/server directory could also contain jvm.dll,
534                 # just assume the user wants to use the client JVM.
535                 DLL=jre/bin/client/jvm.dll
536                 if test -f $ac_java_jvm_dir/$DLL ; then
537                     AC_MSG_LOG([Found $ac_java_jvm_dir/$F], 1)
538                     D1=$ac_java_jvm_dir/jre/bin
539                     D2=$ac_java_jvm_dir/jre/bin/client
540                     ac_java_jvm_jni_lib_runtime_path="${D1}:${D2}"
541                     ac_java_jvm_jni_lib_flags="$ac_java_jvm_dir/$F"
542                 fi
543             fi
544         fi
545     fi
546
547     # Generate error for unsupported JVM layout
548
549     if test "x$ac_java_jvm_jni_lib_flags" = "x" ; then
550         AC_MSG_ERROR([Could not detect the location of the Java
551             shared library. You will need to update java.m4
552             to add support for this JVM configuration.])
553     fi
554
555     AC_MSG_LOG([Using the following JNI library flags $ac_java_jvm_jni_lib_flags])
556     AC_MSG_LOG([Using the following runtime library path $ac_java_jvm_jni_lib_runtime_path])
557
558     AC_MSG_LOG([Using LD_PRELOAD=$ac_java_jvm_ld_preload], 1)
559     AC_MSG_LOG([Using LD_BIND_NOW=$ac_java_jvm_ld_bind_now], 1)
560
561     # Make sure we can compile and link a trivial JNI program
562
563     AC_REQUIRE([AC_PROG_CC])
564
565     AC_CACHE_CHECK(to see if we can link a JNI application,
566         ac_cv_java_jvm_working_jni_link,[
567         AC_LANG_PUSH(C)
568         ac_saved_cflags=$CFLAGS
569         ac_saved_libs=$LIBS
570         CFLAGS="$CFLAGS $ac_java_jvm_jni_include_flags"
571         LIBS="$LIBS $ac_java_jvm_jni_lib_flags"
572         AC_TRY_LINK([
573             #include <jni.h>
574         ],[$libSymbolToTest(NULL,0,NULL);],
575             ac_cv_java_jvm_working_jni_link=yes,
576             ac_cv_java_jvm_working_jni_link=no)
577         AC_LANG_POP()
578         CFLAGS=$ac_saved_cflags
579         LIBS=$ac_saved_libs
580     ])
581
582     # gcc can't link with some JDK .lib files under Win32.
583     # Work around this problem by linking with win/libjvm.dll.a
584
585     if test "$ac_cv_java_jvm_working_jni_link" != "yes" &&
586       test "$ac_cv_tcl_win32" = "yes"; then
587         AC_LANG_PUSH(C)
588         ac_saved_cflags=$CFLAGS
589         ac_saved_libs=$LIBS
590         CFLAGS="$CFLAGS $ac_java_jvm_jni_include_flags"
591         LIBS="$LIBS -L$srcdir/win -ljvm"
592         AC_TRY_LINK([
593             #include <jni.h>
594         ],[$libSymbolToTest(NULL,0,NULL);],
595             ac_cv_java_jvm_working_jni_link=yes,
596             ac_cv_java_jvm_working_jni_link=no)
597         AC_LANG_POP()
598         CFLAGS=$ac_saved_cflags
599         LIBS=$ac_saved_libs
600
601         if test "$ac_cv_java_jvm_working_jni_link" = "yes"; then
602             AC_MSG_LOG([Using custom JNI link lib])
603             ac_java_jvm_jni_lib_flags="-L$srcdir/win -ljvm"
604         fi
605     fi
606
607     if test "$ac_cv_java_jvm_working_jni_link" != "yes"; then
608         AC_MSG_ERROR([could not link file that includes jni.h
609         Either the configure script does not know how to deal with
610         this JVM configuration or the JVM install is broken or corrupted.])
611     fi
612 ])
613
614
615 #------------------------------------------------------------------------
616 # AC_JAVA_WITH_JDK
617 #
618 #       Check to see if the --with-jdk command line option is given.
619 #       If it was, then set ac_java_with_jdk to the DIR argument.
620 #
621 # Arguments:
622 #       NONE
623 #
624 # VARIABLES SET:
625 #       ac_java_with_jdk can be set to the directory where the jdk lives
626 #       ac_java_jvm_name can be set to "jdk"
627 #------------------------------------------------------------------------
628
629 AC_DEFUN([AC_JAVA_WITH_JDK], [
630     AC_ARG_WITH(jdk, 
631         AC_HELP_STRING([--with-jdk=DIR],[use JDK from DIR]), 
632         ok=$withval, ok=no)
633     if test "$ok" = "no" ; then
634         NO=op
635     elif test "$ok" = "yes" || test ! -d "$ok"; then
636         AC_MSG_ERROR([--with-jdk=DIR option, must pass a valid DIR])
637     elif test "$ok" != "no" ; then
638             AC_MSG_RESULT([Use JDK path specified ($ok)])
639         ac_java_jvm_dir=$ok
640         ac_java_jvm_name=jdk
641     fi
642 ])
643
644 #------------------------------------------------------------------------
645 # AC_JAVA_TOOLS
646 #
647 #       Figure out the paths of any Java tools we will need later on.
648 #
649 # Arguments:
650 #       NONE
651 #
652 # VARIABLES SET:
653 #       JAVA
654 #       JAVA_G
655 #       JAVAC
656 #       JAVAH
657 #       JAR
658 #       JDB
659 #
660 # DEPENDS ON:
661 #       This macro must be run after the AC_JAVA_DETECT_JVM macro as
662 #       it depends on the ac_java_jvm_name, ac_java_jvm_version and
663 #       ac_java_jvm_dir variables
664 #------------------------------------------------------------------------
665
666 AC_DEFUN([AC_JAVA_TOOLS], [
667         
668     AC_JAVA_TOOLS_CHECK(JAVA, java, $ac_java_jvm_dir/bin)
669
670     # Don't error if java_g can not be found
671     AC_JAVA_TOOLS_CHECK(JAVA_G, java_g, $ac_java_jvm_dir/bin, 1)
672
673     if test "x$JAVA_G" = "x" ; then
674         JAVA_G=$JAVA
675     fi
676
677     TOOL=javah
678     AC_JAVA_TOOLS_CHECK(JAVAH, $TOOL, $ac_java_jvm_dir/bin)  
679
680     AC_JAVA_TOOLS_CHECK(JAR, jar, $ac_java_jvm_dir/bin)
681
682     # Don't error if jdb can not be found
683     AC_JAVA_TOOLS_CHECK(JDB, jdb, $ac_java_jvm_dir/bin, 1)
684
685     case "$ac_java_jvm_version" in
686         *)
687             # JDK on Win32 does not allow connection with suspend=n
688             if test "$ac_cv_tcl_win32" = "yes"; then
689                 suspend="y"
690             else
691                 suspend="n"
692             fi
693             JDB_ATTACH_FLAGS="-attach 8757"
694             JAVA_G_FLAGS="-Xdebug -Xrunjdwp:transport=dt_socket,address=8757,server=y,suspend=$suspend"
695             JDB_ATTACH_FLAGS="-attach 8757"
696             ;;
697     esac
698 ])
699
700
701
702 #------------------------------------------------------------------------
703 # AC_JAVA_ANT
704 #
705 #       Figure out if ant is available and where
706 #
707 # Arguments:
708 #       PATH
709 #
710 # VARIABLES SET:
711 #       ANT
712 #
713 #------------------------------------------------------------------------
714
715 AC_DEFUN([AC_JAVA_ANT], [
716     AC_ARG_WITH(ant, 
717         AC_HELP_STRING([--with-ant=DIR],[Use ant from DIR]), 
718         ANTPATH=$withval, ANTPATH=no)
719     if test "$ANTPATH" = "no" ; then    
720             AC_JAVA_TOOLS_CHECK(ANT, ant)
721         elif test ! -d "$ANTPATH"; then
722         AC_MSG_ERROR([--with-ant=DIR option, must pass a valid DIR])
723         else
724                 AC_JAVA_TOOLS_CHECK(ANT, ant, $ANTPATH/bin $ANTPATH)
725         fi
726 ])
727
728 #------------------------------------------------------------------------
729 # AC_JAVA_CHECK_PACKAGE
730 #
731 # Check if the package (generally a jar file) is available and the class 
732 # usable
733 #
734 # Arguments:
735 #       1. name of the package
736 #   2. name of the class to test
737 #   3. used by (Comment)
738 #   4. Do not stop on error
739 # VARIABLES SET:
740 #       
741 #
742 #------------------------------------------------------------------------
743
744 AC_DEFUN([AC_JAVA_CHECK_PACKAGE], [
745         AC_MSG_CHECKING($1)
746         found_jar=no
747         saved_ac_java_classpath=$ac_java_classpath
748         DEFAULT_JAR_DIR="/usr/share/java/ /usr/lib/java/ /usr/share/java /usr/share/java/jar /opt/java/lib /usr/local/java /usr/local/java/jar /usr/local/share/java /usr/local/share/java/jar /usr/local/lib/java"
749     for jardir in "`pwd`/thirdparty" "`pwd`/jar" $DEFAULT_JAR_DIR "$_user_libdir"; do
750       for jar in "$jardir/$1.jar" "$jardir/lib$1.jar" "$jardir/lib$1-java.jar" "$jardir/$1*.jar"; do
751 #       jar=`echo $jar|sed -e 's/ /\\ /'`
752 #       echo "protected $jar"
753 #       jar_resolved=`ls $jar 2>/dev/null`
754 #       echo "looking for $jar_resolved"
755 # TODO check the behaviour when spaces
756         jar_resolved=`ls $jar 2>/dev/null`
757         if test -e "$jar_resolved"; then
758           export ac_java_classpath="$jar_resolved:$ac_java_classpath"
759           AC_JAVA_TRY_COMPILE([import $2;], , [
760             AC_MSG_RESULT([$jar_resolved])
761             found_jar=yes
762             PACKAGE_JAR_FILE=$jar_resolved
763             break
764           ], [
765             ac_java_classpath=$saved_ac_java_classpath
766                         
767           ])
768         fi
769       done
770       if test "$found_jar" = "yes"; then
771         break
772       fi
773     done
774     if test "$found_jar" = "no"; then
775       AC_MSG_RESULT([no])
776           if test "$4" == "yes"; then
777                 AC_MSG_WARN([Could not find or use the Java package/jar $1 used by $3 (looking for package $2)])
778           else
779                   AC_MSG_ERROR([Could not find or use the Java package/jar $1 used by $3 (looking for package $2)])
780           fi
781     fi
782 ])
783
784 #------------------------------------------------------------------------
785 # AC_JAVA_TOOLS_CHECK(VARIABLE, TOOL, PATH, NOERR)
786 #
787 #       Helper function that will look for the given tool on the
788 #       given PATH. If cross compiling and the tool can not
789 #       be found on the PATH, then search for the same tool
790 #       on the users PATH. If the tool still can not be found
791 #       then give up with an error unless NOERR is 1.
792 #
793 # Arguments:
794 #       1. The variable name we pass to AC_PATH_PROG
795 #       2. The name of the tool
796 #       3. The path to search on
797 #       4. Pass 1 if you do not want any error generated 
798 #------------------------------------------------------------------------
799
800 AC_DEFUN([AC_JAVA_TOOLS_CHECK], [
801     if test "$cross_compiling" = "yes" ; then
802         AC_PATH_PROG($1, $2)
803     else
804         AC_PATH_PROG($1, $2, , $3)
805     fi
806
807     # Check to see if $1 could not be found
808
809     m4_ifval([$4],,[
810     if test "x[$]$1" = "x" ; then
811         AC_MSG_ERROR([Cannot find $2])
812     fi
813     ])
814 ])