dnl Used by aclocal to generate configure

dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_WITH_JAVAH],
[
  AC_ARG_WITH([javah],
	      [AS_HELP_STRING(--with-javah,specify path or name of a javah-like program)],
  [
    if test "x${withval}" != x && test "x${withval}" != xyes && test "x${withval}" != xno; then
      CLASSPATH_CHECK_JAVAH(${withval})
    else
      CLASSPATH_CHECK_JAVAH
    fi
  ],
  [ 
    CLASSPATH_CHECK_JAVAH
  ])
  AC_SUBST(USER_JAVAH)
])

dnl -----------------------------------------------------------
dnl Checking for a javah like program 
dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_CHECK_JAVAH],
[
  if test "x$1" != x; then
    if test -f "$1"; then
      USER_JAVAH="$1"
    else
      AC_PATH_PROG(USER_JAVAH, "$1")
    fi
  else
    AC_PATH_PROGS([USER_JAVAH],[gjavah gjavah-4.3 gjavah-4.2 gjavah-4.1 gcjh-wrapper-4.1 gcjh-4.1 javah])
  fi
  
  if test "x${USER_JAVAH}" = x; then
    AC_MSG_ERROR([can not find javah])
  fi
])

dnl -----------------------------------------------------------
dnl CLASSPATH_WITH_CLASSLIB - checks for user specified classpath additions
dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_WITH_CLASSLIB],
[
  AC_ARG_WITH([vm-classes],
	      [AS_HELP_STRING(--with-vm-classes,specify path to VM override source files)], [vm_classes="$with_vm_classes"],
	      [vm_classes='${top_srcdir}/vm/reference'])
  AC_SUBST(vm_classes)
])

dnl -----------------------------------------------------------
dnl CLASSPATH_WITH_GLIBJ - specify what to install
dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_WITH_GLIBJ],
[
  AC_PATH_PROG(ZIP, zip)

  AC_MSG_CHECKING(for a jar-like tool)
  AC_ARG_WITH([jar],
	      [AS_HELP_STRING([--with-jar=PATH], [define to use a jar style tool])],
	      [
	        case "${withval}" in
      		  yes)
		    JAR=yes
        	    ;;
      		  no)
		    JAR=no
  		    AC_MSG_RESULT(${JAR})
		    ;;
		  *)
    		    if test -f "${withval}"; then
          	      JAR="${withval}"
		      AC_MSG_RESULT(${JAR})
        	    else
	  	      AC_MSG_RESULT([not found])
	              AC_MSG_ERROR([The jar tool ${withval} was not found.])
        	    fi
		    ;;
     		esac
  	      ],
	      [
		JAR=yes
	      ])
  if test x"${JAR}" = "xyes"; then
    AC_MSG_RESULT([trying fastjar, gjar and jar])
    AC_PATH_PROGS([JAR], [fastjar gjar jar])
    if test x"${RHINO_JAR}" = "xyes"; then
      AC_MSG_RESULT([not found])
    fi
  fi
  if test x"${JAR}" = "xno" && test x"${ZIP}" = ""; then
    AC_MSG_ERROR([No zip or jar tool found.])
  fi
  AM_CONDITIONAL(WITH_JAR, test x"${JAR}" != "xno" && test x"${JAR}" != "xyes")
  AC_SUBST(JAR)
  
  AC_ARG_WITH([glibj],
              [AS_HELP_STRING([--with-glibj],[define what to install (zip|flat|both|none|build) [default=zip]])],
              [
                if test "x${withval}" = xyes || test "x${withval}" = xzip; then
		  install_class_files=no
		  build_class_files=yes
		  use_zip=yes
		elif test "x${withval}" = xboth; then
		  install_class_files=yes
		  build_class_files=yes
		  use_zip=yes
		elif test "x${withval}" = xflat; then
		  install_class_files=yes
		  build_class_files=yes
		  use_zip=no
                elif test "x${withval}" = xno || test "x${withval}" = xnone; then
		  install_class_files=no
		  build_class_files=no
		  use_zip=no
		elif test "x${withval}" = xbuild; then
		  install_class_files=no
		  build_class_files=yes
		  use_zip=no
                else
		  AC_MSG_ERROR([unknown value given to --with-glibj])
                fi
	      ],
  	      [
		install_class_files=no
		use_zip=yes
	      ])
  AM_CONDITIONAL(INSTALL_GLIBJ_ZIP, test "x${use_zip}" = xyes)
  AM_CONDITIONAL(INSTALL_CLASS_FILES, test "x${install_class_files}" = xyes)
  AM_CONDITIONAL(BUILD_CLASS_FILES, test "x${build_class_files}" = xyes)

  AC_ARG_ENABLE([examples],
		[AS_HELP_STRING(--enable-examples,enable build of the examples [default=yes])],
		[case "${enableval}" in
		  yes) EXAMPLESDIR="examples" ;;
		  no) EXAMPLESDIR="" ;;
		  *) AC_MSG_ERROR(bad value ${enableval} for --enable-examples) ;;
		esac],
		[EXAMPLESDIR="examples"])
  if test "x${build_class_files}" = xno; then
    EXAMPLESDIR=""
  fi
  AC_SUBST(EXAMPLESDIR)

  AC_ARG_ENABLE([tools],
		[AS_HELP_STRING(--enable-tools,enable build of the tools [default=yes])],
		[case "${enableval}" in
		  yes) TOOLSDIR="tools" ;;
		  no) TOOLSDIR="" ;;
		  *) AC_MSG_ERROR(bad value ${enableval} for --enable-tools) ;;
		esac],
		[TOOLSDIR="tools"])
  if test "x${build_class_files}" = xno; then
    TOOLSDIR=""
  fi
  AC_SUBST(TOOLSDIR)
])

dnl -----------------------------------------------------------
dnl Enable generation of API documentation, with gjdoc if it
dnl has been compiled to an executable (or a suitable script
dnl is in your PATH) or using the argument as gjdoc executable.
dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_WITH_GJDOC],
[
  AC_ARG_WITH([gjdoc],
              AS_HELP_STRING([--with-gjdoc],
			     [generate documentation using gjdoc (default is NO)]),
              [if test "x${withval}" = xno; then
	         WITH_GJDOC=no;
	       elif test "x${withval}" = xyes -o "x{withval}" = x; then
	         WITH_GJDOC=yes;
	         AC_PATH_PROG(GJDOC, gjdoc, "no")
		 if test "x${GJDOC}" = xno; then
		   AC_MSG_ERROR("gjdoc executable not found");
		 fi
	       else
	         WITH_GJDOC=yes
		 GJDOC="${withval}"
		 AC_CHECK_FILE(${GJDOC}, AC_SUBST(GJDOC),
		               AC_MSG_ERROR("Cannot use ${withval} as gjdoc executable since it doesn't exist"))
	       fi],
              [WITH_GJDOC=no])
  AM_CONDITIONAL(CREATE_API_DOCS, test "x${WITH_GJDOC}" = xyes)
  if test "x${WITH_GJDOC}" = xyes; then
    AC_MSG_CHECKING([version of GJDoc])
    gjdoc_version=$(${GJDOC} --version|cut -d ' ' -f2)
    AC_MSG_RESULT(${gjdoc_version})
    case ${gjdoc_version} in
      0.7.9) ;;
      0.8*) ;;
      *) AC_MSG_ERROR([Building documentation requires GJDoc >= 0.7.9, ${gjdoc_version} found.]) ;;
    esac
  fi
])

dnl -----------------------------------------------------------
dnl Enable regeneration of parsers using jay
dnl http://www.informatik.uni-osnabrueck.de/alumni/bernd/jay/
dnl -----------------------------------------------------------
AC_DEFUN([REGEN_WITH_JAY],
[
  AC_ARG_WITH([jay],
              [AS_HELP_STRING(--with-jay[=DIR|PATH],Regenerate the parsers with jay)],
  [
    AC_MSG_CHECKING([whether to regenerate parsers with jay])
    JAY_FOUND=no
    JAY_DIR_PATH=
    if test "x${withval}" = xno; then
      AC_MSG_RESULT(no)
    elif test "x${withval}" = xyes; then
      AC_MSG_RESULT(yes)
      JAY_DIR_PATH="/usr/share/jay"
    elif test -d "${withval}"; then
      AC_MSG_RESULT(yes)
      JAY_DIR_PATH="${withval}"
    elif test -f "${withval}"; then
      AC_MSG_RESULT(yes)
      JAY_DIR_PATH=`dirname "${withval}"`
      JAY="${withval}"
    else
        AC_MSG_ERROR(jay not found at ${withval})
    fi

    if test "x${JAY_DIR_PATH}" != x; then
      AC_PATH_PROG(JAY, jay, "no", ${JAY_DIR_PATH}:${PATH})
      if test "x${JAY}" = xno; then
        AC_MSG_ERROR(jay executable not found);
      fi
      JAY_SKELETON="${JAY_DIR_PATH}/skeleton"
      AC_CHECK_FILE(${JAY_SKELETON}, AC_SUBST(JAY_SKELETON),
          AC_MSG_ERROR(Expected skeleton file in ${JAY_DIR_PATH}))
      JAY_FOUND=yes
    fi
  ],
  [
    AC_MSG_CHECKING([whether to regenerate parsers with jay])
    AC_MSG_RESULT(no)
    JAY_FOUND=no
  ])
  AM_CONDITIONAL(REGEN_PARSERS, test "x${JAY_FOUND}" = xyes)
])

dnl -----------------------------------------------------------
dnl GCJ LOCAL: Calculate toolexeclibdir
dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_TOOLEXECLIBDIR],
[
  multi_os_directory=`$CC -print-multi-os-directory`
  case $multi_os_directory in
    .) toolexeclibdir=${libdir} ;; # Avoid trailing /.
    *) toolexeclibdir=${libdir}/${multi_os_directory} ;;
  esac
  AC_SUBST(toolexeclibdir)
])

dnl -----------------------------------------------------------
AC_DEFUN([CLASSPATH_JAVAC_MEM_CHECK],
[
  JAVA_TEST=Test.java
  CLASS_TEST=Test.class
  cat << \EOF > $JAVA_TEST
  /* [#]line __oline__ "configure" */
  public class Test 
  {
    public static void main(String[] args)
    {
      System.out.println("Hello World");
    }
  }
EOF
  if test x$JAVAC_IS_GCJ != xyes; then
    AC_MSG_CHECKING([whether javac supports -J])
    $JAVAC $JAVACFLAGS -J-Xmx768M -sourcepath '' $JAVA_TEST
    javac_result=$?
    if test "x$javac_result" = "x0"; then
      AC_MSG_RESULT([yes])
      JAVAC_MEM_OPT="-J-Xmx768M"
    else
      AC_MSG_RESULT([no])
    fi
  fi
  rm -f $JAVA_TEST $CLASS_TEST
  AC_SUBST(JAVAC_MEM_OPT)
])

dnl ---------------------------------------------------------------
dnl CLASSPATH_COND_IF(COND, SHELL-CONDITION, [IF-TRUE], [IF-FALSE])
dnl ---------------------------------------------------------------
dnl Automake 1.11 can emit conditional rules for AC_CONFIG_FILES,
dnl using AM_COND_IF.  This wrapper uses it if it is available,
dnl otherwise falls back to code compatible with Automake 1.9.6.
AC_DEFUN([CLASSPATH_COND_IF],
[m4_ifdef([AM_COND_IF],
  [AM_COND_IF([$1], [$3], [$4])],
  [if $2; then
     m4_default([$3], [:])
   else
     m4_default([$4], [:])
   fi
])])