#! /bin/sh
# Usage: configure [options] [dirname [cc]]
# Examples:
#   configure obj
#   CC=gcc configure make.gcc
#   CC=cc configure make.cc
#   configure make.gcc gcc     (deprecated)
#   configure make.cc cc       (deprecated)

info_help () {
cat << \EOP
Usage: configure [options] [dirname]
dirname: Name of directory in which to build CLISP. This allows you to build
         CLISP with different compilers on the same machine or for different
         architectures in the same filesystem, sharing the same source.
         Default is "src".
options: The following options are recognized:
         --help                print this message and exit
         --version             print the CLISP version and exit
         --config              unix/INSTALL step 3: configuration only
         --build               unix/INSTALL steps 3-7: configure, build, check
         --install             unix/INSTALL step 8: install
         The following options set installation parameters:
         --srcdir=SRCDIR       sets the source directory to SRCDIR
         The following options are passed to subordinate `configure' scripts:
         --quiet, --silent     do not print `checking...' messages
         --prefix=PREFIX       base directory for files to be installed
         --exec-prefix=PREFIX  base directory for architecture-dependent
                               files to be installed
         --fsstnd=STYLE        specify file system standard for installation
         --host=HOST           specify host in CPU-VENDOR-OS format (just
                               in case config.guess guesses wrong)
         --with-PACKAGE        use PACKAGE
         --without-PACKAGE     do not use PACKAGE
         --with-module=MODULE  build with add-on MODULE
         --with-export-syscalls export some UNIX syscalls to Lisp
         --with-dir-key        dir-key access (win32 registry, LDAP, Gnome)
         --hyperspec=URL       the path to the Common Lisp HyperSpec
           (the default is http://www.lisp.org/HyperSpec/
            or the value of the environment variable CLHSROOT, if set).
Example:
         configure --build built-with-gcc
         su bin
         configure --install built-with-gcc
         exit
Specifying the C compiler:
         If you wish to specify the C compiler that will get used to build
         CLISP, set the environment variables CC, CFLAGS, LIBS.
         Put compiler flags that have to be passed to the preprocessor
         into the CC variable, not the CFLAGS variable.
         For example, if you want to use gcc in ANSI C mode,
         execute the following before calling `configure':
               setenv CC "gcc -ansi"                 if using csh
               export CC="gcc -ansi"                 if using bash or ksh
               CC="gcc -ansi"; export CC             if using sh
EOP
}

# Abort in case something fails.
set -e

srcdir=''
subdir_configure_args=''
makemake_args=''
do_config=''
do_build=''
do_install=''
argcount=0

prev=''
passnext=''
passnextm=''
for arg # in "$@"
do
  # If the previous option needs an argument, assign it.
  if test -n "$prev"; then
    # If the previous option needs an argument for subdir_configure_args, pass it.
    if test -n "$passnext"; then
      subdir_configure_args="$subdir_configure_args $arg"
      passnext=''
      # If the previous option needs an argument for makemake_args, pass it as well.
      if test -n "$passnextm"; then
        makemake_args="$makemake_args$arg"
        passnextm=''
      fi
    else
      eval "$prev=\$arg"
    fi
    prev=''
  else

    case "$arg" in

      --build | --buil | --bui | --bu | --b)
        do_config=1
        do_build=1 ;;

      --config | --confi | --conf | --con | --co | --c)
        do_config=1 ;;

      --help | --hel | --he | --h)
        info_help
        exit 0 ;;

      --install | --instal | --insta | --inst | --ins | --in | --i)
        do_install=1 ;;

      --version | --versio | --versi | --vers | --ver | --ve | --v)
        version="CLISP version "`cat src/VERSION`
        echo $version
        exit 0 ;;

      --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
        srcdir=`echo "$arg" | sed 's,^[-_a-zA-Z0-9]*=,,'` ;;

      --srcdir | --srcdi | --srcd | --src | --sr)
        prev=srcdir
        passnext=yes ;;

      --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
        subdir_configure_args="$subdir_configure_args $arg"
        makemake_args="$makemake_args --prefix="`echo "$arg" | sed 's,^[-_a-zA-Z0-9]*=,,'` ;;

      --prefix | --prefi | --pref | --pre | --pr | --p)
        subdir_configure_args="$subdir_configure_args $arg"
        makemake_args="$makemake_args --prefix="
        prev=prefix
        passnext=yes
        passnextm=yes ;;

      --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | -exec=* | --exe=* | --ex=* | --e=*)
        subdir_configure_args="$subdir_configure_args $arg"
        makemake_args="$makemake_args --exec-prefix="`echo "$arg" | sed 's,^[-_a-zA-Z0-9]*=,,'` ;;

      --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | -exec | --exe | --ex | --e)
        subdir_configure_args="$subdir_configure_args $arg"
        makemake_args="$makemake_args --exec-prefix="
        prev=exec_prefix
        passnext=yes
        passnextm=yes ;;

      --fsstnd=* | --fsstn=* | --fsst=* | --fss=* | --fs=* | --f=*)
        makemake_args="$makemake_args --fsstnd="`echo "$arg" | sed 's,^[-_a-zA-Z0-9]*=,,'` ;;

      --hyperspec=* | --hyperspe=* | --hypersp=* | --hypers=* | --hs=* | --hy=*)
        makemake_args="$makemake_args --hyperspec="`echo "$arg" | sed 's,^[-_a-zA-Z0-9]*=,,'` ;;

      --host=* | --hos=* | --ho=* | --h=* | \
      --quiet | --quie | --qui | --qu | --q | \
      --silent | --silen | --sile | --sil | --si)
        subdir_configure_args="$subdir_configure_args $arg" ;;

      --host | --hos | --ho | --h)
        subdir_configure_args="$subdir_configure_args $arg"
        prev=host
        passnext=yes ;;

      --with-export-syscalls)
        makemake_args="$makemake_args $arg" ;;

      --with-dir-key)
        makemake_args="$makemake_args $arg" ;;

      --with-* | --without-*)
        subdir_configure_args="$subdir_configure_args $arg"
        makemake_args="$makemake_args $arg" ;;

      --*)
        echo "$0: invalid argument $arg" 1>&2
        echo "$0: Try \`$0 --help'" 1>&2
        exit 1 ;;

      *) # Everything else counts as a positional argument
        argcount=`expr $argcount + 1`
        eval "POSARG$argcount=\$arg" ;;

    esac

  fi
done
if test -n "$prev"; then
  echo "$0: missing argument to $prev" 1>&2
  echo "$0: Try \`$0 --help'" 1>&2
  exit 1
fi

DIRNAME=$POSARG1
COMPILER=$POSARG2 # deprecated

if test -z "$do_config" -a -z "$do_build" -a -z "$do_install"; then
  # Default is --config
  do_config=1
fi

# checking how to copy files
echo "blabla" > conftest.x
err=`/bin/sh -c "cp -p conftest.x conftest.y 2>&1 ; exit 0"`
if test -z "$err"; then
  CP='cp -p'
else
  CP='cp'
fi
rm -f conftest*

# get the absolute pathname from a possibly relative one
abs_pwd () { cd "$1" > /dev/null; pwd; }

# link FILE1 FILE2  is like `ln', but chooses the cheapest alternative:
# hard link if FILE1 and FILE2 on the same disk, else symbolic link if the
# system supports that, else file copy.
link () {
rm -f "$2";
# Note: With some versions of "ln" this does not work if FILE2 is a symlink.
if ln "$1" "$2" 2>/dev/null; then
  :
else
  srcfile_dirname=`echo "$1" | sed -e 's,/[^/]*$,,'`
  test -n "$srcfile_dirname" || srcfile_dirname='/'
  srcfile_basename=`echo "$1" | sed -e 's,^.*/,,'`
  srcfile_absdirname=`abs_pwd "$srcfile_dirname"`
  if ln -s "$srcfile_absdirname/$srcfile_basename" "$2" 2>/dev/null; then
    :
  else
    $CP "$1" "$2"
  fi
fi
}

# Note that we would need to call `/bin/pwd` if we wanted to compare two
# directories for equality. But here we only need to get _some_ absolute
# pathnames, hence `pwd` is enough.

if test -f /bin/pwd ; then
  ABSPATHPWD=/bin/pwd
else
  ABSPATHPWD=pwd
fi

abs_path_pwd () { cd "$1" > /dev/null; ${ABSPATHPWD}; }

maybe_mkdir() { test -d "$1" || mkdir "$1"; }

INPLACE=''
if test -n "$srcdir" ; then
  if test ! -d "$srcdir" ; then
    echo "$0: srcdir: ($srcdir) nonexistent" 1>&2
    exit 1
  fi
  ABS_SRCDIR=`abs_pwd "$srcdir"`;
  if [ "$DIRNAME" = "" ] ; then
    DIRNAME='.'
  fi
  maybe_mkdir "${DIRNAME}";
  REL_SRCDIR="$ABS_SRCDIR"
else
  if test -f ./ANNOUNCE -a -f ./SUMMARY; then
    srcdir='.'
    ABS_SRCDIR=`abs_pwd "$srcdir"`
    if [ "$DIRNAME" = "" ] ; then
      DIRNAME=src
    fi
  else
    if test -f ../ANNOUNCE -a -f ../SUMMARY; then
      srcdir='..'
      ABS_SRCDIR=`abs_pwd "$srcdir"`
      if [ "$DIRNAME" = "" ] ; then
        DIRNAME='.'
      fi
    else
      echo "$0: source directory not found, use --srcdir option" 1>&2
      exit 1
    fi
  fi
  maybe_mkdir "${DIRNAME}";
  if test `abs_path_pwd "$DIRNAME"/..` = `abs_path_pwd "$srcdir"` ; then
    REL_SRCDIR='..'
  else
    REL_SRCDIR="$ABS_SRCDIR"
  fi
fi
ABS_DIRNAME=`abs_pwd "$DIRNAME"`;
if test `abs_path_pwd "$DIRNAME"` = `abs_path_pwd "$srcdir"/src` ; then
  INPLACE=yes
fi
case "$REL_SRCDIR" in
  /*) RREL_SRCDIR="$REL_SRCDIR";;
  *)  RREL_SRCDIR="../$REL_SRCDIR";;
esac

# srcdir        top level source directory
#               (i.e. this script is $srcdir/configure)
# ABS_SRCDIR    absolute srcdir
# REL_SRCDIR    srcdir, relative to $DIRNAME
# RREL_SRCDIR   srcdir, relative to $DIRNAME/anysubdir
# DIRNAME       directory in which to build
# ABS_DIRNAME   absolute DIRNAME
# INPLACE       set if DIRNAME is the source directory, hence no links needed

if test -n "$do_config"; then

  cd "$ABS_SRCDIR"

  if [ "$COMPILER" != "" ] ; then
    CC="$COMPILER"
    export CC
  fi
  if test -z "$INPLACE"; then
    # Create subdirectories for: readline gettext termcap,
    # and fill them.
    # - termcap: Because the Makefile carefully uses $(srcdir), only
    #   a few files need to be linked over.
    # - readline, gettext: The Makefiles use VPATH=$(srcdir), which
    #   is not portable, hence all files need to be linked over.
    for subdir in readline gettext termcap
    do
      if [ -d src/$subdir ] ; then
        maybe_mkdir "${ABS_DIRNAME}/${subdir}";
      fi
    done
    for f in readline readline/doc readline/examples readline/support readline/shlib \
             gettext gettext/autoconf gettext/intl gettext/po
    do
      if [ -d src/$f ] ; then
        maybe_mkdir "${ABS_DIRNAME}/${f}";
        ( cd src
          for g in $f/* ; do
            if [ -f $g ] ; then
              link $g $ABS_DIRNAME/$g
            fi
          done
        )
      fi
    done
    for f in configure unixconf.h.in makemake.in VERSION \
             termcap/configure termcap/Makefile.in
    do
      if [ -f src/$f ] ; then
        link src/$f $ABS_DIRNAME/$f
      fi
    done
  fi
  # Create subdirectories for the modules parts, and fill them.
  # The modules outright assumes that $(srcdir)='.', hence all files need to
  # be linked over.
  #for subdir in `cd modules > /dev/null ; find . -type d -print`
  #do
  #  maybe_mkdir "${ABS_DIRNAME}/${f}";
  #done
  #for f in `cd modules > /dev/null ; find . '!' -type d -print`
  #do
  #  link $f $ABS_DIRNAME/$f
  #done
  ( cd modules
    for d in *
    do
      if [ -d "$d" -a '!' "$d" = CVS ] ; then
        ../src/lndir "$d" "$ABS_DIRNAME/$d"
      fi
    done
  )
  # Create subdirectories for the ffcall parts, and fill them.
  # The Makefiles carefully use $(srcdir). Need to link over only a few files.
  for subdir in avcall callback
  do
    if [ -d ffcall/$subdir ] ; then
      maybe_mkdir "${ABS_DIRNAME}/${subdir}";
    fi
  done
  for subdir in avcall callback
  do
    f=$subdir/configure
    if [ -f ffcall/$f ] ; then
      link ffcall/$f $ABS_DIRNAME/$f
    fi
  done
  # Similarly for libiconv and sigsegv.
  for subdir in libiconv sigsegv
  do
    if [ -d $subdir ] ; then
      maybe_mkdir "${ABS_DIRNAME}/${subdir}";
    fi
  done
  for subdir in libiconv sigsegv
  do
    f=$subdir/configure
    if [ -f $f ] ; then
      link $f $ABS_DIRNAME/$f
    fi
  done
  # Prepare the configure files.
  chmod a+x $ABS_DIRNAME/configure
  for subdir in readline avcall callback libiconv sigsegv; do
    if test -d $ABS_DIRNAME/$subdir; then
      chmod a+x $ABS_DIRNAME/$subdir/configure
    fi
  done
  # Start the configurations.
  echo "executing $DIRNAME/configure ..."
  cd $ABS_DIRNAME
  if test -n "$INPLACE"; then
    subdir_srcdir_args=''
  else
    subdir_srcdir_args="--srcdir=$REL_SRCDIR/src"
  fi
  ${CONFIG_SHELL-/bin/sh} configure $subdir_srcdir_args $subdir_configure_args \
      --cache-file=config.cache
  # libiconv must be built before gettext is even configured. This is because
  # we want gettext to recognize libiconv as being present, even though we
  # do not install it publicly.
  for subdir in libiconv; do
    if test -d $subdir; then
      echo "executing $DIRNAME/$subdir/configure ..."
      cd $subdir
      ${CONFIG_SHELL-/bin/sh} configure --srcdir="$RREL_SRCDIR/$subdir" \
          $subdir_configure_args --cache-file=../config.cache \
          --enable-static --disable-shared
      make
      make install-lib libdir="$ABS_DIRNAME" includedir="$ABS_DIRNAME"
      cd ..
    fi
  done
  for subdir in readline gettext; do
    if test -d $subdir; then
      # readline is not even configurable in C++ mode.
      if test $subdir = readline; then
        if grep 'cl_cv_prog_cc_cplusplus.*yes' $ABS_DIRNAME/config.cache > /dev/null ; then
          continue;
        fi
      fi
      echo "executing $DIRNAME/$subdir/configure ..."
      (if test $subdir = gettext; then
         CPPFLAGS="$CPPFLAGS -I${ABS_DIRNAME}"
         export CPPFLAGS
         LDFLAGS="$LDFLAGS -L${ABS_DIRNAME}"
         export LDFLAGS
       fi
       cd $subdir
       if test -n "$INPLACE" -o $subdir = readline -o $subdir = gettext; then
         subdir_srcdir_args=''
       else
         subdir_srcdir_args="--srcdir=$RREL_SRCDIR/src/$subdir"
       fi
       if test $subdir = readline -o $subdir = gettext; then
         subdir_cache_args=''
       else
         subdir_cache_args="--cache-file=../config.cache"
       fi
       ${CONFIG_SHELL-/bin/sh} configure $subdir_srcdir_args \
          `if test $subdir = gettext; then echo "--with-included-gettext"; fi` \
          $subdir_configure_args $subdir_cache_args
       cd ..
      )
    fi
  done
  for subdir in avcall callback; do
    if test -d $subdir; then
      echo "executing $DIRNAME/$subdir/configure ..."
      cd $subdir
      ${CONFIG_SHELL-/bin/sh} configure --srcdir="$RREL_SRCDIR/ffcall/$subdir" \
          $subdir_configure_args --cache-file=../config.cache
    cd ..
    fi
  done
  for subdir in sigsegv; do
    if test -d $subdir; then
      echo "executing $DIRNAME/$subdir/configure ..."
      cd $subdir
      ${CONFIG_SHELL-/bin/sh} configure --srcdir="$RREL_SRCDIR/$subdir" \
          $subdir_configure_args --cache-file=../config.cache
    cd ..
    fi
  done
  cd ..

fi

# Determine recommended makemake arguments.
if grep 'ac_cv_func_tgetent.*no' $ABS_DIRNAME/config.cache > /dev/null \
   && grep 'ac_cv_lib_termcap_tgetent.*no' $ABS_DIRNAME/config.cache > /dev/null \
   && grep 'ac_cv_lib_ncurses_tgetent.*no' $ABS_DIRNAME/config.cache > /dev/null ; then
  # On Unix systems lacking libtermcap and libncurses (rarely seen), we do not
  # use our included termcap library because the user would have to install
  # /etc/termcap.  The user should better do that before compiling clisp.
  makemake_args="$makemake_args --with-no-termcap-ncurses --with-noreadline"
else
  if grep 'cl_cv_prog_cc_cplusplus.*yes' $ABS_DIRNAME/config.cache > /dev/null ; then
    makemake_args="$makemake_args --with-noreadline"
  else
    if test -d $ABS_DIRNAME/readline; then
      makemake_args="$makemake_args --with-readline"
    else
      makemake_args="$makemake_args --with-noreadline"
    fi
  fi
fi
if grep 'cl_cv_prog_cc_cplusplus.*yes' $ABS_DIRNAME/config.cache > /dev/null ; then
  makemake_args="$makemake_args --with-nogettext"
else
  if test -d $ABS_DIRNAME/gettext; then
    makemake_args="$makemake_args --with-gettext"
  else
    makemake_args="$makemake_args --with-nogettext"
  fi
fi
if test -d $ABS_DIRNAME/avcall -a -d $ABS_DIRNAME/callback; then
  (cd $ABS_DIRNAME/avcall && make) &&
  (cd $ABS_DIRNAME/callback && make) &&
  (cd $ABS_DIRNAME/avcall && make check) &&
  (cd $ABS_DIRNAME/callback && make check) &&
  makemake_args="$makemake_args --with-dynamic-ffi"
fi

if test -z "$do_build"; then

  echo
  echo "To continue building CLISP, the following commands are recommended"
  echo "(cf. unix/INSTALL step 4):"
  if test "$DIRNAME" != "."; then
    echo "    cd $DIRNAME"
  fi
  echo "    ./makemake $makemake_args > Makefile"
  echo "    make config.lisp"
  echo "    ${EDITOR:-vi} config.lisp"
  echo "    make"
  echo "    make check"

else

  cd $ABS_DIRNAME
  ./makemake $makemake_args > Makefile
  make
  make check
  cd ..

fi

if test -n "$do_install"; then

  cd $ABS_DIRNAME
  make install
  cd ..

fi

