#! @SHELL@
# -*- coding: utf-8; mode: shell-script -*- vim:filetype=sh
CONFIG_SHELL="@SHELL@"  # mind the quoting, for args like -x.
# Creation of the Makefile used for compiling CLISP
# Bruno Haible 1991-2010
# Sam Steingold 1999-2011

# Simple usage:
#        ./makemake [--with-PACKAGE] > Makefile

HSDEFAULT="http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec"
hyperspec=${CLHSROOT:-${HSDEFAULT}}

fail () { echo "$0: $*" >&2; exit 1; }

info_help () {
cat << EOP
Usage: ./makemake [options] > Makefile
options:
    The following general options are recognized:
       --help                  print this message and exit
       --version               print the CLISP version and exit
       --verbose               print some config information to the stderr
    The following options set installation parameters:
       --srcdir=SRCDIR         sets the source directory to SRCDIR
       --prefix=PREFIX         sets the installation directory prefix to PREFIX
       --exec-prefix=EXECPREFIX  sets the architecture dependent installation
                                  directory prefix to EXECPREFIX
       --fsstnd=std            installation according to FileSystem Standards:
                               suse - SuSE-Linux conventions
                               redhat - RedHat
                               debian - Debian, Slackware
                               *bsd - NetBSD, OpenBSD, FreeBSD
       --hyperspec=URL         the path to the Common Lisp HyperSpec
           (the default is ${HSDEFAULT}
            or the value of the environment variable CLHSROOT, if set).
      Fine tuning of the installation directories:
       --bindir=DIR            user executables
       --libdir=DIR            object code libraries
       --includedir=DIR        C header files
       --datarootdir=DIR       read-only arch.-independent data root
       --datadir=DIR           read-only architecture-independent data
       --localedir=DIR         locale-dependent data
       --docdir=DIR            documentation root
       --mandir=DIR            man documentation
       --infodir=DIR           GNU Info documentation
       --htmldir=DIR           html documentation
       --dvidir=DIR            TeX DVI documentation
       --psdir=DIR             PostScript documentation
       --pdfdir=DIR            PDF documentation
       --elispdir=DIR          Emacs Lisp files
       --vimdir=DIR            VIM files
       --aclocaldir=DIR        autoconf files
    The following options add support for specific separate packages. See the
    main INSTALL file for how to get them.
       --with-noreadline       do not use readline library (even when present)
       --with-gettext          internationalization, needs GNU gettext
       --with-nogettext        static internationalization (en only)
       --without-unicode       no Unicode character set, only 8-bit characters
       --with-dynamic-ffi      a foreign language interface
       --without-dynamic-modules  no dynamic loading of foreign modules
       --with-threads=FLAVOR   MT [_experimental_!]
                      FLAVOR: POSIX_THREADS SOLARIS_THREADS WIN32_THREADS
       --with-jitc=FLAVOR      use a given Just-In-Time Compiler.
                The only flavor at this time is lightning
                  (GNU lightning must be installed in the standard place).
       --with-gmalloc          use the GNU malloc instead of the libc one
                               (needed on HP-UX and OpenBSD)
       --with-debug            will need to debug the C sources.
    See modules/ directory for available modules and add them to the full
    linking set using --with-module option, e.g.,
       --with-module=bindings/glibc
       --with-module=pari
Example:
       ./makemake --with-dynamic-ffi > Makefile
EOP
}

# Advanced usage:
#        ./makemake [--with-PACKAGE] TARGET COMPILER > Makefile
#  where PACKAGE is one of
#        noreadline       no readline library
#        gettext          internationalization, needs GNU gettext
#        nogettext        static internationalization (en only)
#        unicode          Unicode character set
#        dynamic-ffi      a dynamic foreign language interface
#        dynamic-modules  dynamic loading of foreign language modules
#        module=MODULE    an add-on module
#  where TARGET is one of
#        sun3
#        sun4
#        i386      (any other 386 machine, e.g. Linux boxes or Sun386i)
#        i486      (any other 486 machine)
#        mips
#  and COMPILER is one of
#        gcc       (GNU C under the name gcc)
#        cc        (any other ANSI C compliant cc)

# Examples:
#   makemake > Makefile
#   makemake --with-debug > Makefile
#   makemake --with-noreadline --with-debug > Makefile
#   makemake i386 gcc > make.gcc/makefile
#   makemake i486 gcc > make.gcc/makefile
#   makemake sun4 gcc > make.gcc/makefile
#   makemake --win32gcc gcc > make.win32gcc/makefile
#   makemake --with-dynamic-ffi win32msvc msvc4 > make.win32msvc/makefile.msvc4
#   makemake --with-dynamic-ffi win32msvc msvc5 > make.win32msvc/makefile.msvc5
#   makemake --with-dynamic-ffi win32msvc msvc6 > make.win32msvc/makefile.msvc6


# Fix the "echo" command. The SysV /bin/sh (and also ksh, and also bash if
# built with --enable-usg-echo-default, and also GNU sh-utils-1.16) are broken:
# They have an echo command which interprets backslashes in the string to be
# output. We cannot fix this by defining a function called "echo", because the
# HP/UX, OSF/1, AIX /bin/sh would nevertheless call the builtin, broken "echo".
# `echol' stands for "echo line".
if echo 'rs\tuv' | grep t > /dev/null 2> /dev/null; then
  # Uff. Found a BSD or POSIX compliant "echo" command.
  echol () {
    echo "$*"
  }
elif type printf >/dev/null 2>/dev/null; then
  # The "Single Unix Specification" (which also adheres to this broken
  # "echo") recommends the following workaround.
  echol () {
    printf '%s\n' "$*"
  }
else
  # This one looks harmless, but in Solaris /bin/sh, when called inside
  # shell backquote `...`, it prefixes every character with a backslash!
  # Therefore we use this only as a last resort, if `printf' is missing
  # (for example, on OpenStep V4.2).
echol () {
cat <<ECHOVAL_END
$*
ECHOVAL_END
}
fi

link_dep() {
  echol "$1 : $2"
  echotab "-\$(RM) $1"
  echotab "-\$(LN_S) ${3-$2} $1"
  echol
}

# Handle --help and --version arguments.
for arg do
  case "$arg" in
    --help | --hel | --he | --h)
      info_help
      exit 0 ;;
    --version | --versio | --versi | --vers | --ver | --ve | --v)
      echol "@PACKAGE_STRING@ (@PACKAGE_BUGREPORT@)"
      exit 0 ;;
  esac
done

# Save the argument list for reference.
makemake_args=''
for arg do
  # Approximate a shell-quote.
  case "$arg" in
    *" "* | *"	"* | *[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]* ) makemake_args="$makemake_args '$arg'" ;;
    * ) makemake_args="$makemake_args $arg" ;;
  esac
done
hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`

srcdir='@srcdir@'
prefix=''
exec_prefix=''
fsstnd='' # supported styles: gnu, gnu_ext, suse, redhat, debian, *bsd
bindir=''
libdir=''
includedir=''
datarootdir=''
datadir=''
localedir=''
docdir=''
mandir=''
infodir=''
htmldir=''
dvidir=''
psdir=''
pdfdir=''
MODULES=''
elispdir=''
vimdir=''
aclocaldir=''
CP='cp -p'
LN_S='ln -s'
HLN='ln'

# <http://thread.gmane.org/gmane.comp.sysutils.autoconf.general/13368>
# strip out -srcdir* & -cache-file*
keep_next=maybe
module_configure_flags=''
for arg in @module_configure_flags@; do
  case $arg in
    *\'*) arg=`$echo "$arg" | sed "s/'/'\\\\\\\\''/g"` ;;
  esac
  case $keep_next in
    yes ) module_configure_flags="$module_configure_flags '$arg'";
      keep_next=maybe; ;;
    no ) keep_next=maybe; ;;
    maybe ) case $arg in
      --cache-file=* | --srcdir=*) continue ;;
      --cache-file | --srcdir ) keep_next=no; ;;
      *=* ) module_configure_flags="$module_configure_flags '$arg'"; ;;
      *) module_configure_flags="$module_configure_flags '$arg'";
        keep_next=yes; ;;
    esac ;;
  esac
done
unset arg
unset keep_next

# NLS nuisances.
# Needed e.g. for some versions of `tr' so that character classes in `[]' work.
if test "${LC_ALL+set}" = 'set'; then LC_ALL=C ; export LC_ALL ; fi
if test "${LANG+set}"   = 'set'; then LANG=C   ; export LANG   ; fi
if [ `echo ABC | tr '[A-Z]' '[a-z]'` = "abc" ] ; then
  tolower="tr '[A-Z]' '[a-z]'"
else
  tolower="tr A-Z a-z"
fi
my_eval(){
  eval "$*"
  test "${verbose}" = true -o "${verbose}" = yes && echo "$*" >&2
}

# Set the defaults for the --with options.
with_termcap_ncurses=yes # no effect if missing termcap/ncurses
with_readline=ifpossible # no effect if no libreadline found
with_gettext=yes         # no effect if no glibc/libintl found
with_unicode=yes
with_dynamic_ffi=no      # often set to yes by the toplevel configure
with_dynamic_modules=default
with_threads=no
with_gmalloc=no
with_debug=no
# i18n: essential for internationalized programs
# syscalls: very useful for scripting
# regexp: useful for scripting and text processing
# readline: additional facilities for REPL, added later if appropriate
BASE_MODULES="i18n syscalls regexp"

verbose=${CLISP_MAKEMAKE_VERBOSE:-false}
# Handle --with-... arguments
while test -z "$endofargs"; do
  case "$1" in
    -verb* | --verb* )
      verbose=`echol "$1"|sed 's/-*v[^=]*=*//'`
      test -n "${verbose}" || verbose=true
      shift
      ;;
    -with-module=* | --with-module=*)
      module=`echol "$1"|sed 's/-*with-module=//'`
      # We don't need to add $module to MODULES if it's already contained
      # in BASE_MODULES.
      case " $BASE_MODULES readline " in
        *" $module "*) cat <<EOF >&2
$0: argument $1 is ignored because $module is a base module
$0: see http://clisp.org/impnotes/modules.html#base-modules
EOF
          ;;
        *) MODULES="$MODULES $module" ;;
      esac
      shift
      ;;
    # Accept --with and --without options like configure does.
    # Extensions:
    # - Accept --with-no-foo and --with-nofoo as synonyms of --without-foo.
    # - Accept --with-foo=off as synonym of --with-foo=no.
    # - Accept --with-foo=on as synonym of --with-foo=yes.
    # Testing for yes:   test "${with_foo}" != no
    # Testing for no:    test "${with_foo}" = no
    -without-* | --without-* | -with-no* | --with-no*)
      package=`echol "$1" | sed -e 's/^-*without-//' -e 's/^-*with-no-*//'`
      # Delete all the valid chars; see if any are left.
      test -n "`echol $package|sed 's/[-a-zA-Z0-9_]*//g'`" && \
        fail "$package: invalid package name"
      my_eval "with_`echol $package|sed s/-/_/g`=no"
      shift
      ;;
    -with-* | --with-*)
      package=`echol "$1"|sed 's/-*with-//'`
      case "$package" in
        *=*) packopt=`echol "${package}" | sed -e 's/^[^=]*=//'` ;;
        *) packopt=yes ;;
      esac
      package=`echol "${package}" | sed -e 's/=.*//'`
      # Delete all the valid chars; see if any are left.
      test -n "`echol $package|sed 's/[-a-zA-Z0-9_]*//g'`" && \
        fail "$package: invalid package name";
      if test "${packopt}" = "on"; then
        packopt=yes
      elif test "${packopt}" = "off"; then
        packopt=no
      fi
      my_eval "with_`echol $package|sed s/-/_/g`=${packopt}"
      shift
      ;;
    -disable-* | --disable-*)
      feature=`echol "$1"|sed 's/-*disable-//'`
      # Delete all the valid chars; see if any are left.
      test -n "`echol $feature|sed 's/[-a-zA-Z0-9_]*//g'`" && \
        fail "$feature: invalid feature name"
      feature=`echol $feature | sed 's/-/_/g'`
      my_eval "enable_$feature=no"
      shift
      ;;
    -enable-* | --enable-*)
      feature=`echol "$1"|sed 's/-*enable-//'`
      # Delete all the valid chars; see if any are left.
      test -n "`echol $feature|sed 's/[-a-zA-Z0-9_]*//g'`" && \
        fail "$feature: invalid feature name"
      feature=`echol $feature | sed 's/-/_/g'`
      my_eval "enable_$feature=yes"
      shift
      ;;
    -srcdir* | --srcdir*)
      srcdir=`echol "$1" | sed 's/-*srcdir=*//'`
      shift
      if test -z "$srcdir" ; then
        srcdir=$1
        shift
      fi
      ;;
    -prefix* | --prefix*)
      prefix=`echol "$1" | sed 's/-*prefix=*//'`
      shift
      if test -z "$prefix" ; then
        prefix=$1
        shift
      fi
      ;;
    -exec-prefix* | --exec-prefix*)
      exec_prefix=`echol "$1" | sed 's/-*exec-prefix=*//'`
      shift
      if test -z "$exec_prefix" ; then
        exec_prefix=$1
        shift
      fi
      ;;
    --fsstnd=*)
      fsstnd=`echol "$1" | sed 's/-*fsstnd=//'`
      shift
      ;;
    -bindir* | --bindir*)
      bindir=`echol "$1" | sed 's/-*bindir=*//'`
      shift
      if test -z "$bindir" ; then
        bindir=$1
        shift
      fi
      ;;
    -libdir* | --libdir*)
      libdir=`echol "$1" | sed 's/-*libdir=*//'`
      shift
      if test -z "$libdir" ; then
        libdir=$1
        shift
      fi
      ;;
    -includedir* | --includedir*)
      includedir=`echol "$1" | sed 's/-*includedir=*//'`
      shift
      if test -z "$includedir" ; then
        includedir=$1
        shift
      fi
      ;;
    -datarootdir* | --datarootdir*)
      datarootdir=`echol "$1" | sed 's/-*datarootdir=*//'`
      shift
      if test -z "$datarootdir" ; then
        datarootdir=$1
        shift
      fi
      ;;
    -datadir* | --datadir*)
      datadir=`echol "$1" | sed 's/-*datadir=*//'`
      shift
      if test -z "$datadir" ; then
        datadir=$1
        shift
      fi
      ;;
    -localedir* | --localedir*)
      localedir=`echol "$1" | sed 's/-*localedir=*//'`
      shift
      if test -z "$localedir" ; then
        localedir=$1
        shift
      fi
      ;;
    -docdir* | --docdir*)
      docdir=`echol "$1" | sed 's/-*docdir=*//'`
      shift
      if test -z "$docdir" ; then
        docdir=$1
        shift
      fi
      ;;
    -mandir* | --mandir*)
      mandir=`echol "$1" | sed 's/-*mandir=*//'`
      shift
      if test -z "$mandir" ; then
        mandir=$1
        shift
      fi
      ;;
    -infodir* | --infodir*)
      infodir=`echol "$1" | sed 's/-*infodir=*//'`
      shift
      if test -z "$infodir" ; then
        infodir=$1
        shift
      fi
      ;;
    -htmldir* | --htmldir*)
      htmldir=`echol "$1" | sed 's/-*htmldir=*//'`
      shift
      if test -z "$htmldir" ; then
        htmldir=$1
        shift
      fi
      ;;
    -dvidir* | --dvidir*)
      dvidir=`echol "$1" | sed 's/-*dvidir=*//'`
      shift
      if test -z "$dvidir" ; then
        dvidir=$1
        shift
      fi
      ;;
    -psdir* | --psdir*)
      psdir=`echol "$1" | sed 's/-*psdir=*//'`
      shift
      if test -z "$psdir" ; then
        psdir=$1
        shift
      fi
      ;;
    -pdfdir* | --pdfdir*)
      pdfdir=`echol "$1" | sed 's/-*pdfdir=*//'`
      shift
      if test -z "$pdfdir" ; then
        pdfdir=$1
        shift
      fi
      ;;
    -elispdir* | --elispdir*)
      elispdir=`echol "$1" | sed 's/-*elispdir=*//'`
      shift
      if test -z "$elispdir" ; then
        elispdir=$1
        shift
      fi
      ;;
    -vimdir* | --vimdir*)
      vimdir=`echol "$1" | sed 's/-*vimdir=*//'`
      shift
      if test -z "$vimdir" ; then
        vimdir=$1
        shift
      fi
      ;;
    -aclocaldir* | --aclocaldir*)
      aclocaldir=`echol "$1" | sed 's/-*aclocaldir=*//'`
      shift
      if test -z "$aclocaldir" ; then
        aclocaldir=$1
        shift
      fi
      ;;
    --win32gcc) HSYS="win32gcc"; shift; ;;
    --hyperspec=*)
      arg=`echol "$1" | sed 's/-*hyperspec=//'`
      case "$arg" in
        */FrontMatter/index.html ) arg=`echo "$arg" | sed -e 's,/FrontMatter/index.html$,,'` ;;
        */FrontMatter/ )           arg=`echo "$arg" | sed -e 's,/FrontMatter/$,,'` ;;
        */FrontMatter )            arg=`echo "$arg" | sed -e 's,/FrontMatter$,,'` ;;
        */ )                       arg=`echo "$arg" | sed -e 's,/*$,,'` ;;
        * ) ;;
      esac
      case "$arg" in
        *://*) hyperspec="$arg" ;;
        /*) if test -d "$arg" -a -d "$arg/FrontMatter" ; then
              hyperspec="file:${arg}"
            else
              echo "makemake: --hyperspec=${arg} argument ignored, does not point to the Common Lisp HyperSpec" 1>&2
            fi
            ;;
        *)  case "$arg" in
              file:*) arg=`echo "$arg" | sed -e 's,^file:,,'` ;;
            esac
            if test -d "$arg" -a -d "$arg/FrontMatter" ; then
              hyperspec="file:"`cd "$arg" > /dev/null && pwd`
            else
              echo "makemake: --hyperspec=${arg} argument ignored, does not point to the Common Lisp HyperSpec" 1>&2
            fi
            ;;
      esac
      shift
      ;;
    *) endofargs=1 ;;
  esac
done

# Remove trailing slash from hyperspec URL.
case "$hyperspec" in
  */) hyperspec=`echo "$hyperspec" | sed -e 's,/$,,'` ;;
esac

# HSYS, HSYSOS = host system
# HOS  = host operating system
# TSYS, TSYSOS = target system
# TOS  = target operating system
# CC, CPPFLAGS, CFLAGS, CLFLAGS, CPP = compiler on host, for host
# XCC, XCPPFLAGS, XCFLAGS, XCLFLAGS, XCPP = cross-compiler on host, for target

# These variables are set by configure:
# srcdir='@srcdir@'                 # either '.' or '../src', see above
CP='cp -p'                          # either 'cp -p' or 'cp'
LN_S='@LN_S@'                       # either 'ln -s' or 'ln' or 'cp -p'
LN='@LN@'                           # either 'ln' or ${CP}
HLN='@HLN@'                         # either 'ln' or 'hln'
CC="@CC@"                           # either 'gcc -O' or 'cc'
CPP="@CPP@"                         # either $CC' -E' or '/lib/cpp'
CPPFLAGS='@CPPFLAGS@'               # additional options for $CC and $CPP
CFLAGS='@CFLAGS@'                   # additional options for $CC
LDFLAGS='@LDFLAGS@'                 # additional options for linking
CC_GCC='@CC_GCC@'                   # either true or false
CC_SUNPRO='@CC_SUNPRO@'             # either true or false
CC_CPLUSPLUS='@CC_CPLUSPLUS@'       # either true or false
CC_NEED_DEEMA='@CC_NEED_DEEMA@'     # either true or false
AS_UNDERSCORE='@AS_UNDERSCORE@'     # either true or false
RANLIB='@RANLIB@'                   # either 'ranlib' or ':'
INSTALL='@INSTALL@'                 # either 'install -c' or 'cp'
INSTALL_PROGRAM='@INSTALL_PROGRAM@' # either 'install -c' or 'cp'
INSTALL_SCRIPT='@INSTALL_SCRIPT@'   # either 'install -c' or 'cp', avoid 'strip'
INSTALL_DATA='@INSTALL_DATA@'       # either 'install -c -m 644' or 'cp'
GROFF='@GROFF@'                     # either 'groff' or ''
PS2PDF='@PS2PDF@'                   # either 'ps2pdf' or ''
LIBS='@LIBS@'                       # list of system libraries
LIBTERMCAP='@LIBTERMCAP@'           # '-L/usr/??/lib' or 'broken' or ''
INCTERMCAP='@INCTERMCAP@'           # '-I/usr/??/include' or ''
LIBICONV='@LIBICONV@'               # either '-liconv' or ''
LIBSIGSEGV='@LTLIBSIGSEGV@'         # '-lsigsegv -L/usr/local/lib' or ''
LIBSOCKET='@LIBSOCKET@'             # '-lnet' or '-lsocket' or '-lws2_32' or ''
X_CFLAGS='@X_CFLAGS@'               # either '-I/usr/somewhere/include' or ''
X_LIBS='@X_LIBS@'                   # either '-L/usr/somewhere/lib -lX11' or ''
FFCALL_LIBS='@LIBAVCALL@ @LIBCALLBACK@' # libavcall.a libcallback.a
host='@host@'                       # something like 'sparc-sun-sunos4'
host_cpu='@host_cpu@'               # something like 'sparc'
host_cpu_c_abi='@HOST_CPU_C_ABI@'   # ditto
host_vendor='@host_vendor@'         # something like 'sun'
host_os='@host_os@'                 # something like 'sunos4'
GNU_MAKE='@GNU_MAKE_FALSE@'         # '#' if non-gnu; '' if gnu

if test -x ./libtool; then # normal autoconf-based build
  # -rdynamic or -Wl,-E or -Wl,--export-dynamic
  eval "`./libtool --tag=CC --config | grep '^wl='`"
  eval "`./libtool --tag=CC --config | grep '^export_dynamic_flag_spec='`"
  eval EXPORT_DYNAMIC_FLAG_SPEC=\"$export_dynamic_flag_spec\"
else # generating Makefiles for MS compiler from Makefile.devel
  :
fi

# Important: Don't rely on this host classification.
# 1. GNU's database config.guess is not always up to date.
# 2. New operating systems are emerging at every corner.
# 3. People tend to change their systems locally.
# Use this classification ONLY if we know no better way to check for a
# feature or bug than to look at various `uname ...` results and list
# the buggy systems explicitly. ONLY in this case!

UTILCOMPILE="\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS)"
case $# in
  0 | 1)
     # Assume we are on Unix (or win32gcc); target=host (not cross-compiling).
     CROSS=false
     if [ -z "$HSYS" ]; then # not win32gcc
       # some shells (A/UX and OSF/1) need the parentheses around "arch" below.
       HSYS=`((arch) 2>/dev/null || uname -m 2>/dev/null) | $tolower` # system name in lowercase
       HSYSOS=`((uname) 2>/dev/null || arch 2>/dev/null) | $tolower` # OS name in lowercase
       if [ "$HSYS" = 386bsd -o "$HSYS" = sun386 -o "$HSYS" = "386/at" -o "$HSYS" = i86pc ] ; then
         HSYS='i386'
       fi
       if [ "$HSYS" = sun4m ] ; then
         HSYS='sun4'
       fi
       case "$HSYSOS" in
         # Canonicalize cygwin32/nt and cygwin32/95 to plain cygwin.
         cygwin*) HSYSOS=cygwin ;;
       esac
       HOS='unix'
       COMPILER=??
     else                       # win32gcc
       HSYSOS=$HSYS
       HOS=win32
       COMPILER=gcc
       # is this mingw on msys or on cygwin?
       # this really is cross-compilation, so we must override the above
       # which would make utils win32, not cygwin
       UTILCOMPILE=gcc
     fi
     TSYS="$HSYS"
     TSYSOS="$HSYSOS"
     TOS="$HOS"
     ;;
  *) if [ "$1" = cross ] ; then
       CROSS=true
       shift
     else
       CROSS=false
     fi
     TSYS=$1
     COMPILER=$2
     module_configure_flags=${module_configure_flags}" --build=${TSYS}"
     # TSYS should be (master|sun3|sun4|i[3456]86|mips|vax|win32msvc).
     # COMPILER should be <host...>-gcc or cc
     case ${TSYS} in
       win32msvc ) TOS='win32' ;;
       *)          TOS='unix' ;;
     esac
     TSYSOS=$TSYS
     if [ $CROSS = true ] ; then
       HOS='unix'
       HSYS=irrelevant
       HSYSOS=irrelevant
     else
       HOS="$TOS"
       HSYS="$TSYS"
       HSYSOS="$TSYSOS"
     fi
     if [ $TSYS = win32msvc ] ; then
       CC='cl'
       CC_GCC=false
       CFLAGS='$(MFLAGS)'
       AS_UNDERSCORE=false
       CC_NEED_DEEMA=true
       FFCALL_LIBS='avcall.lib callback.lib'
     else
       CC=${COMPILER}
       case $COMPILER in
         *-gcc ) CC_GCC=true ;;
         *) CC_GCC=false ;;
       esac
       CFLAGS='-O'
       CPP="${CC} -E"
     fi
     shift 2
     ;;
esac

if [ "${with_gmalloc}" = yes ]; then GMALLOC=gmalloc; else GMALLOC=""; fi

if [ $CROSS = true ] ; then
  # We can cross-compile only with GCC
  XCC=${COMPILER}  # ${TSYS}-gcc
  XCPP="${XCC} -E"
  XCPPFLAGS=''
  XCFLAGS=''
  XLDFLAGS=''
  XCC_GCC=true
  XCC_NEED_DEEMA=false
else
  TSYS="$HSYS"
  TOS="$HOS"
  XCC="${CC}"
  XCPP="${CPP}"
  XCPPFLAGS="${CPPFLAGS}"
  XCFLAGS="${CFLAGS}"
  XLDFLAGS="${LDFLAGS}"
  XCC_GCC="${CC_GCC}"
  XCC_NEED_DEEMA="${CC_NEED_DEEMA}"
fi

if [ "${with_dynamic_modules}" = default ]; then
  # if --with-dynamic-modules is not supplied:
  # C=yes, C++=no because of symbol mangling:
  # ;; Loading module libsvm from lib-FOO.so
  # SYSTEM::DYNLOAD-MODULES: "dlsym"("module__FOO__init_function_1") ->
  # "lib-FOO.so: undefined symbol: module__FOO__init_function_1"
  # $ nm lib-FOO.so | grep module__FOO__init_function_1
  # 000008f8 T _Z31module__FOO__init_function_1P8module_t
  if [ "${CC_CPLUSPLUS}" = true ]; then
    with_dynamic_modules=no
  else
    with_dynamic_modules=yes
  fi
elif [ "${with_dynamic_modules}" = yes -a "${CC_CPLUSPLUS}" = true ]; then
  fail "dynamic modules do not work with C++ because of symbol mangling"
fi

# now set appropriate MSVC cflags
if [ $TSYS = win32msvc ] ; then
  # -G5 means to optimize for i586.
  # "-Od -Z7" means to compile for debugging.
  # "-O1" means to optimize on msvc4,
  # "-Os -Oy -Ob1 -Gs -Gf -Gy" means to optimize on msvc5+
  # ("-O1" and "-O2" are buggy in msvc5 ... msvc7).
  # -Zi - include debug info (-ZI for debug-and-continue)
  # -GZ - runtime debug checks
  case $COMPILER in
    msvc6 | msvc7)
      if [ "${with_debug}" = no ] ; then
        CFLAGS=${CFLAGS}" -G5 -Os -Oy -Ob1 -Gs -Gf -Gy"
      else
        CFLAGS=${CFLAGS}" -Zi -Od -GZ"
      fi
      ;;
    *) fail "unsupported compiler [${COMPILER}]"
      ;;
  esac
fi

if [ "$srcdir" = . ] ; then
  SRCDIR=''
else
  SRCDIR="${srcdir}/"
fi

# SRCTOPDIR is the parent directory of $srcdir, ending in a slash.
case "$srcdir" in
  *"/src" ) SRCTOPDIR=`echol "$srcdir" | sed -e 's,src$,,'` ;;
  "." )     SRCTOPDIR="../" ;;
  * )       SRCTOPDIR="$srcdir/../" ;;
esac
case "$SRCTOPDIR" in
  /*) PARENT_SRCTOPDIR="${SRCTOPDIR}" ;;
  *)  PARENT_SRCTOPDIR="../${SRCTOPDIR}" ;;
esac

RECOMPILEDIR=stage
TESTSDIR=tests
SACLATESTSDIR=sacla-tests
ANSITESTSDIR=ansi-tests
BENCHDIR=benchmarks

# Main host OS dependencies:

# DOS-style filenames and file utilities
H_DOS="false"
test $HOS = win32 -a $HSYS != win32gcc && H_DOS="true"

# HEXE = extension for executable files on host
if [ $HOS = win32 ] ; then
  HEXE='.exe'
else
  HEXE=''
fi

# HERE = prefix to ensure that executables are looked up in current directory
HERE='./'

# PREFIX = prefix for installation directories
# (This should not end in a backslash. Add a space to avoid this.)
if [ $HOS = unix ] ; then
  test -n "$prefix" ||
    prefix='@prefix@' # usually '/usr/local'
  PREFIX="${prefix}"
else
  PREFIX=''
fi

# EXEC_PREFIX = prefix for architecture dependent installation directories
brace_to_paren='s,\${\([^{}]*\)},$(\1),g'
if [ $HOS = unix ] ; then
  test -n "$exec_prefix" ||
    exec_prefix='@exec_prefix@' # usually '${prefix}'
  EXEC_PREFIX=`echo "$exec_prefix" | sed -e "$brace_to_paren"`
else
  EXEC_PREFIX='$(prefix)'
fi

# PARENT = piece of path for parent directory
# NEXT = piece of path for next subdirectory
# PARENT, NEXT: For interpretation by CLISP.
# PARENT_, NEXT_: For interpretation by the system's shell (called by make).
# PARENT_M, NEXT_M: For interpretation by the make program.
PARENT='../'
NEXT='/'
if [ $H_DOS = "true" ] ; then
  # Replace '/' with '\':
  PARENT_=`echol $PARENT | sed -e 's,/,\\\\,g'`
  NEXT_=`echol $NEXT | sed -e 's,/,\\\\,g'`
else
  PARENT_=$PARENT
  NEXT_=$NEXT
fi
# Replace '\' with '\\':
#PARENT_2=`echol $PARENT_ | sed -e 's,\\\\,\\\\\\\\,g'`
if [ $HSYS = win32gcc ] ; then
  PARENT_M="$PARENT"
  NEXT_M="$NEXT"
else
  PARENT_M="$PARENT_"
  NEXT_M="$NEXT_"
fi

# Various other installation directories.
if [ $HOS = unix ] ; then
  test -n "$bindir" || bindir='@bindir@' # usually '${exec_prefix}/bin'
  BINDIR=`echo "$bindir" | sed -e "$brace_to_paren"`
else
  bindir="\$(exec_prefix)${NEXT_}bin"
  BINDIR="$bindir"
fi
if [ $HOS = unix ] ; then
  test -n "$libdir" || libdir='@libdir@' # usually '${exec_prefix}/lib'
  LIBDIR=`echo "$libdir" | sed -e "$brace_to_paren"`
else
  libdir="\$(exec_prefix)${NEXT_}lib"
  LIBDIR="$libdir"
fi
if [ $HOS = unix ] ; then
  test -n "$includedir" || includedir='@includedir@' # '${prefix}/include'
  INCLUDEDIR=`echo "$includedir" | sed -e "$brace_to_paren"`
else
  includedir="\$(prefix)${NEXT_}include"
  INCLUDEDIR="$includedir"
fi
if [ $HOS = unix ] ; then
  test -n "$datarootdir" || datarootdir='@datarootdir@' # '${prefix}/share'
  DATAROOTDIR=`echo "$datarootdir" | sed -e "$brace_to_paren"`
else
  datarootdir="\$(prefix)${NEXT_}share"
  DATAROOTDIR="$datarootdir"
fi
if [ $HOS = unix ] ; then
  test -n "$localedir" || localedir='@localedir@' # '${datarootdir}/locale'
  LOCALEDIR=`echo "$localedir" | sed -e "$brace_to_paren"`
else
  localedir="\$(datarootdir)${NEXT_}locale"
  LOCALEDIR="$localedir"
fi
if [ -z "$fsstnd" ]; then       # default fsstnd depends on the OS
  case ${TSYSOS} in
    cygwin | win32gcc )  fsstnd=redhat; ;; # cygwin == redhat!
    *bsd ) fsstnd=bsd; ;;
    linux )
      if test -r /etc/lsb-release; then
        . /etc/lsb-release;
        case "${DISTRIB_ID}" in
          *buntu | Debian | Slackware ) fsstnd=debian; ;;
          Fedora | Redhat ) fsstnd=redhat; ;;
          SuSE ) fsstnd=suse; ;;
          * )  fsstnd=gnu_ext; ;;
        esac
      elif test -r /etc/redhat-release; then
        fsstnd=redhat
      else
        fsstnd=gnu_ext
      fi ;;
    * )  fsstnd=gnu_ext; ;;
  esac
  test "${verbose}" = true -o "${verbose}" = yes && \
    echo "inferred: fsstnd = $fsstnd" >&2
fi

# An explicitly given --docdir overrides the implied value from fsstnd,
# and the implied value from fsstnd overrides the default.
if [ -z "$docdir" ] ; then
  if [ $HOS = unix ] ; then
    docdir='@docdir@' # usually '${datarootdir}/doc/${PACKAGE_TARNAME}'
    if [ "$docdir" = '${datarootdir}/doc/${PACKAGE_TARNAME}' ] ; then
      docdir=
    else
      PACKAGE_TARNAME=clisp ; eval docdir=\"$docdir\"
    fi
    DOCDIR=`echo "$docdir" | sed -e "$brace_to_paren"`
  fi
  if [ -z "$docdir" ] ; then
    case "$fsstnd" in
      suse)
        docdir="\$(datarootdir)${NEXT_}doc${NEXT_}packages${NEXT_}clisp"
        ;;
      redhat)
        docdir="\$(datarootdir)${NEXT_}doc${NEXT_}\$(TOPDIR)"
        ;;
      debian | gnu_ext | *bsd)
        docdir="\$(datarootdir)${NEXT_}doc${NEXT_}clisp"
        ;;
    esac
    DOCDIR="$docdir"
  fi
else
  DOCDIR="$docdir"
fi
if [ $HOS = unix ] ; then
  test -n "$mandir" || mandir='@mandir@' # usually '${datarootdir}/man'
  MANDIR=`echo "$mandir" | sed -e "$brace_to_paren"`
else
  mandir="\$(datarootdir)${NEXT_}man"
  MANDIR="$mandir"
fi
if [ $HOS = unix ] ; then
  test -n "$htmldir" || htmldir='@htmldir@' # usually '${docdir}'
  HTMLDIR=`echo "$htmldir" | sed -e "$brace_to_paren"`
else
  htmldir="\$(docdir)"
  HTMLDIR="$htmldir"
fi
if [ $HOS = unix ] ; then
  test -n "$dvidir" || dvidir='@dvidir@'
  DVIDIR=`echo "$dvidir" | sed -e "$brace_to_paren"`
else
  dvidir="\$(docdir)"
  DVIDIR="$dvidir"
fi
if [ $HOS = unix ] ; then
  test -n "$psdir" || psdir='@psdir@' # usually '${docdir}'
  PSDIR=`echo "$psdir" | sed -e "$brace_to_paren"`
else
  psdir="\$(docdir)"
  PSDIR="$psdir"
fi
if [ $HOS = unix ] ; then
  test -n "$pdfdir" || pdfdir='@pdfdir@' # usually '${docdir}'
  PDFDIR=`echo "$pdfdir" | sed -e "$brace_to_paren"`
else
  pdfdir="\$(docdir)"
  PDFDIR="$pdfdir"
fi
if [ $HOS = unix ] ; then
  test -n "$elispdir" || elispdir='${datarootdir}/emacs/site-lisp'
  ELISPDIR=`echo "$elispdir" | sed -e "$brace_to_paren"`
else
  elispdir="\$(datarootdir)/emacs/site-lisp"
  ELISPDIR="$elispdir"
fi
vimdir_default='vim/vimfiles/after/syntax'
if [ $HOS = unix ] ; then
  test -n "$vimdir" || vimdir='${datarootdir}/'${vimdir_default}
  VIMDIR=`echo "$vimdir" | sed -e "$brace_to_paren"`
else
  vimdir="\$(datarootdir)/${vimdir_default}"
  VIMDIR="$vimdir"
fi
aclocaldir_default='aclocal'
if [ $HOS = unix ] ; then
  test -n "$aclocaldir" || aclocaldir='${datarootdir}/'${aclocaldir_default}
  ACLOCALDIR=`echo "$aclocaldir" | sed -e "$brace_to_paren"`
else
  aclocaldir="\$(datarootdir)/${aclocaldir_default}"
  ACLOCALDIR="$aclocaldir"
fi

if [ $H_DOS = "true" ] ; then
  # Replace '/' with '\':
  SRCTOPDIR_=`echol ${SRCTOPDIR} | sed -e 's,/,\\\\,g'`
  PARENT_SRCTOPDIR_=`echol ${PARENT_SRCTOPDIR} | sed -e 's,/,\\\\,g'`
else
  SRCTOPDIR_=$SRCTOPDIR
  PARENT_SRCTOPDIR_=${PARENT_SRCTOPDIR}
fi
if [ $HSYS = win32gcc ] ; then
  SRCTOPDIR_M="$SRCTOPDIR"
  PARENT_SRCTOPDIR_M="${PARENT_SRCTOPDIR}"
else
  SRCTOPDIR_M="$SRCTOPDIR_"
  PARENT_SRCTOPDIR_M="${PARENT_SRCTOPDIR_}"
fi
UTILDIR="${SRCTOPDIR}utils${NEXT}"
UTILDIR_="${SRCTOPDIR_}utils${NEXT_}"
UTILDIR_M="${SRCTOPDIR_M}utils${NEXT_M}"
SRCDOCDIR="${SRCTOPDIR}doc${NEXT}"
SRCDOCDIR_="${SRCTOPDIR_}doc${NEXT_}"
SRCDOCDIR_M="${SRCTOPDIR_M}doc${NEXT_M}"
MODULESDIR="${SRCTOPDIR}modules${NEXT}"
MODULESDIR_="${SRCTOPDIR_}modules${NEXT_}"
MODULESDIR_M="${SRCTOPDIR_M}modules${NEXT_M}"

if [ $CROSS = false -a $HSYS = win32msvc ] ; then
  NEXT_CC="$NEXT_"
  UTILDIR_CC="$UTILDIR_"
else
  NEXT_CC="$NEXT"
  UTILDIR_CC="$UTILDIR"
fi

# RM = command for deleting files; RMRF - recursively
if [ $H_DOS = "true" ] ; then
  RM='del /q'
  RMRF='del /q /s'
else
  RM='rm -f'
  RMRF='rm -rf'
fi

# CP = command for copying files
if [ $H_DOS = "true" ] ; then
  CP='copy'
# else see above
fi

# LN_S = command for copying read-only files
if [ $H_DOS = "true" ] ; then
  LN_S='copy'
# else see above
fi

# LN_HARD = command for copying files, saving disk space if possible
LN_HARD=${LN-ln}

# HLN = command for making hard links ($HOS = unix only)
if [ "$HLN" = hln ] ; then
  HLN="`pwd`/hln"
fi

# MV = command for renaming files
if [ $H_DOS = "true" ] ; then
  MV='ren'
else
  MV='mv'
fi

# CAT = command for typing files to stdout
if [ $H_DOS = "true" ] ; then
  CAT='type'
else
  CAT='cat'
fi

# TOUCH = command for pretending files are new
TOUCH='touch'

# GREP = command for filtering text according to regular expressions
GREP='grep'

# RANLIB = command for finishing libraries
if [ -z "${RANLIB}" ] ; then RANLIB='ranlib'; fi

# INSTALL = command for installing binaries/data
if [ -z "$INSTALL" ] ; then
  INSTALL=$CP
  INSTALL_PROGRAM='$(INSTALL)'
  INSTALL_DATA='$(INSTALL)'
fi

# Main target OS dependencies:

OS_INCLUDES=''
if [ "$TSYSOS" = osf1 ] ; then
  # On OSF/1 4.0, libtool adds -lc, but this -lc flag causes link errors when
  # comes anywhere except at the end of the link command line, complaining
  # about _OtsDivide32, __lc_ctype and others.
  LIBICONV=`echo " $LIBICONV " | sed -e 's, -lc ,,g' -e 's,^ ,,' -e 's, $,,'`
  LIBINTL=`echo " $LIBINTL " | sed -e 's, -lc ,,g' -e 's,^ ,,' -e 's, $,,'`
  LIBSIGSEGV=`echo " $LIBSIGSEGV " | sed -e 's, -lc ,,g' -e 's,^ ,,' -e 's, $,,'`
  LIBSOCKET=`echo " $LIBSOCKET " | sed -e 's, -lc ,,g' -e 's,^ ,,' -e 's, $,,'`
fi
if [ $TSYS = master -o $TOS = unix ] ; then
  OS_INCLUDES=$OS_INCLUDES' unix'
  LIBS=$LIBS' '$LIBICONV' '$LIBSIGSEGV
fi
if [ $TSYS = master -o $TOS = win32 ] ; then
  OS_INCLUDES=$OS_INCLUDES' win32'
  if [ $TSYS = win32gcc ] ; then
    LIBS=$LIBS' -luser32 -lole32 -loleaut32 -luuid '$LIBICONV' '$LIBSIGSEGV
  else
    if [ $TSYS = win32msvc ] ; then
      LIBS=$LIBS' user32.lib ws2_32.lib advapi32.lib '$LIBSIGSEGV
    fi
    LIBS=$LIBS' ole32.lib shell32.lib'
  fi
fi
if [ $TSYS = master -o $TOS = unix -o $TOS = win32 ] ; then
  OS_INCLUDES=$OS_INCLUDES' xthread'
fi

# TEXE = extension for executable files on target
# LEXE = extension for executable file LISP on target
# SHREXT = extension for shared object files (a.k.a. shared libraries) on target
PWD_POSTPROC=''
if [ ${TOS} = win32 -o ${HSYSOS} = cygwin ] ; then
  TEXE='.exe'
  LEXE='.exe'
  SHREXT='.dll'
  # no path conversion on msys
  # http://thread.gmane.org/gmane.comp.gnu.mingw.msys/1707/
  if cygpath -v > /dev/null 2>&1; then
    PWD_POSTPROC='cygpath -m'
  fi
else
  TEXE=''
  LEXE='.run'
  SHREXT='.so'
fi
HEREP=`pwd`
test -n "${PWD_POSTPROC}" && HEREP=`${PWD_POSTPROC} ${HEREP}`
HERE_="${HEREP}${NEXT_}"

# for systems that lack stdint (or have a broken stdint) (e.g., solaris[89])
# gllib path must be absolute because CPPFLAGS is passed on to module subdirs
# cf m4/clisp.m4: GNULIB_INCLUDE must contain no colons
x=${HEREP}; GNULIB_INCLUDE="-I$(@CLISP_DECOLONIZE@)/gllib"
if [ -n "${SRCDIR}" ] ; then
  x=`cd ${SRCDIR} && pwd`;
  test -n "${PWD_POSTPROC}" && x=`${PWD_POSTPROC} ${x}`
  x="$(@CLISP_DECOLONIZE@)"
  XCPPFLAGS="${XCPPFLAGS} -I$x"
  GNULIB_INCLUDE="${GNULIB_INCLUDE} -I$x/gllib"
fi
XCPPFLAGS="${XCPPFLAGS} ${GNULIB_INCLUDE}"

# TOBJ = extension for compiled modules on target
if [ $TSYS = win32msvc ] ; then
  TOBJ='.obj'
  OUT='/link /out:'
else
  TOBJ='.o'
  OUT='-o '
fi

# Main cpu dependencies:
cpu=$host_cpu_c_abi
if test -z "$cpu"; then
  echo "$0: WARNING: host_cpu_c_abi is void; using host_cpu=${host_cpu}" >&2
  case "$host_cpu" in
    hppa*) cpu=hppa ;;
    arm*)  cpu=arm  ;;
    mips64*) cpu=mips64 ;;
    * ) cpu=${host_cpu}
  esac
fi

test "${verbose}" = true -o "${verbose}" = yes && \
  cat <<EOF >&2
EXPORT_DYNAMIC_FLAG_SPEC=${EXPORT_DYNAMIC_FLAG_SPEC}
module_configure_flags=${module_configure_flags}
# host system:
 hostname = "${hostname}"
     HSYS = "${HSYS}"
   HSYSOS = "${HSYSOS}"
      HOS = "${HOS}"
 host_cpu = "${host_cpu}"
 host_ABI = "${host_cpu_c_abi}"
      cpu = "${cpu}"
  host_os = "${host_os}"
     host = "${host}"
# target system:
     TSYS = "${TSYS}"
   TSYSOS = "${TSYSOS}"
      TOS = "${TOS}"
EOF
# e.g.:
### msys/mingw
# # host system:
#   hostname = "stnt067"
#       HSYS = "win32gcc"
#     HSYSOS = "win32gcc"
#        HOS = "win32"
#   host_cpu = "i686"
#        cpu = "i386"
#    host_os = "mingw32"
#       host = "i686-pc-mingw32"
# # target system:
#       TSYS = "win32gcc"
#     TSYSOS = "win32gcc"
#        TOS = "win32"
### cygwin/--with-mingw
# # host system:
#  hostname = "nyc-qsv-term01"
#      HSYS = "win32gcc"
#    HSYSOS = "win32gcc"
#       HOS = "win32"
#  host_cpu = "i686"
#       cpu = "i386"
#   host_os = "cygwin"
#      host = "i686-pc-cygwin"
# # target system:
#      TSYS = "win32gcc"
#    TSYSOS = "win32gcc"
#       TOS = "win32"
### cygwin
# # host system:
#  hostname = "nyc-qsv-term01"
#      HSYS = "i686"
#    HSYSOS = "cygwin"
#       HOS = "unix"
#  host_cpu = "i686"
#       cpu = "i386"
#   host_os = "cygwin"
#      host = "i686-pc-cygwin"
# # target system:
#      TSYS = "i686"
#    TSYSOS = "cygwin"
#       TOS = "unix"
### linux
# # host system:
#  hostname = "nyc-qws-005"
#      HSYS = "x86_64"
#    HSYSOS = "linux"
#       HOS = "unix"
#  host_cpu = "x86_64"
#       cpu = "x86_64"
#   host_os = "linux-gnu"
#      host = "x86_64-unknown-linux-gnu"
# # target system:
#      TSYS = "x86_64"
#    TSYSOS = "linux"
#       TOS = "unix"

# Main compiler dependencies:

if [ $XCC_GCC = true ] ; then
  XCC_GCC_VERSION=`LC_ALL=C $XCC -v 2>&1 | grep version | sed -n -e '$p' | sed -e 's/.*version //g' -e 's/gcc //'`
  XCFLAGS=${XCFLAGS}' -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type'
  test ${CC_CPLUSPLUS} = false && XCFLAGS=${XCFLAGS}' -Wmissing-declarations -Wimplicit'
  if [ $CROSS = false ] ; then
    case "$XCC_GCC_VERSION" in
      # gcc 2.7 introduced an annoying warning, but gcc 2.8 has a workaround:
      2.[8-9]* | 3.* | 4.* | egcs-2.*)
        XCFLAGS=$XCFLAGS' -Wno-sign-compare -Wno-format-nonliteral'
        ;;
      * ) ;;
    esac
  fi
  if [ $CROSS = false -a $CC_CPLUSPLUS = true ] ; then
    case "$XCC_GCC_VERSION" in
      # g++ 3.4 introduced an annoying warning, but has a workaround:
      3.[4-9]* | 4.*)
        XCFLAGS=$XCFLAGS' -Wno-invalid-offsetof'
        ;;
      * ) ;;
    esac
  fi
  if [ "${with_debug}" = no ] ; then # select optimizations
    if [ "$cpu" = i386 ] ; then
      # gcc <= 2.3.2 may crash when compiling lisparit with -O2
      if [ $CROSS = false ] ; then
        case "$XCC_GCC_VERSION" in
          2.7.[0-2] )
            # gcc-2.7.2 has a strength-reduction bug (fixed in gcc-2.7.2.1,
            # also fixed through the specs file of some Linux distributions).
            XCFLAGS=$XCFLAGS' -O2 -fexpensive-optimizations -fno-strength-reduce' ;;
          2.3.[2-9]* | 2.[4-9]* | 3.* | 4.* | egcs-2.*)
            XCFLAGS=$XCFLAGS' -O2 -fexpensive-optimizations' ;;
          * )
            XCFLAGS=$XCFLAGS' -O' ;;
        esac
      else
        XCFLAGS=$XCFLAGS' -O'
      fi
    elif [ "$cpu" = hppa ] ; then
      # gcc-2.7.2 produces incorrect code when compiling spvw
      # (loadmem routine).
      XCFLAGS=$XCFLAGS' -O2 -fno-strength-reduce'
    elif [ "$cpu" = sparc ] ; then
      if [ $CROSS = false ] ; then
        case "$XCC_GCC_VERSION" in
          egcs-2.*)
            # egcs-1.0.3 and egcs-1.1.1 produce incorrect code when compiling
            # lisparit (function UDS_divide_).
            XCFLAGS=$XCFLAGS' -O2 -fno-schedule-insns' ;;
          2.9* | 3.* | 4.*)
            # gcc-2.95 produces incorrect code when compiling predtype
            # (function C_coerce).
            XCFLAGS=$XCFLAGS' -O2 -fno-schedule-insns -fno-gcse' ;;
          * )
            XCFLAGS=$XCFLAGS' -O2' ;;
        esac
      else
        XCFLAGS=$XCFLAGS' -O2'
      fi
    elif [ "$cpu" = sparc64 ] ; then
      # gcc-3.3.1 produces incorrect code when -O2 is used, even with
      # -fno-schedule-insns and -fno-gcse.
      XCFLAGS=$XCFLAGS' -O'
    elif [ "$cpu" = x86_64 ] ; then
      # gcc-3.2.2 produces incorrect code when -O2 is used.
      XCFLAGS=$XCFLAGS' -O'
    else
      XCFLAGS=$XCFLAGS' -O2'
    fi
    # For platforms that use global register variables...
    case "$cpu" in
      m68k | i386 | sparc | sparc64 | hppa | m88k | arm | alpha* | convex | s390*)
        if [ $CROSS = false ] ; then
          case "$XCC_GCC_VERSION" in
            3.1*)
              # gcc-3.1 produces incorrect code when compiling record
              # (function C_make_instance).
              XCFLAGS=$XCFLAGS' -fno-gcse' ;;
          esac
        fi
        ;;
    esac
  fi # with_debug
  case "$XCC_GCC_VERSION" in
    3* | 4*)
      # When not optimizing on linux, or with Apple's gcc 4 on MacOS X,
      # or with GCC 4 when "gcc -Os" is used:
      #   C_CODE_ALIGNMENT is wrong. &EVAL-WHEN = 0x806D512
      XCFLAGS=$XCFLAGS' -falign-functions=4'
  esac
  if [ $TSYS = win32gcc ] ; then
    XCFLAGS=$XCFLAGS' -D_WIN32'
  fi
  if [ $TSYS = sun4 ] ; then
    XCLFLAGS='-static'
  else
    XCLFLAGS=''
  fi
  # Override any "-x c++" options which may be present in $XCC or $XCFLAGS.
  XCLFLAGS="$XLDFLAGS $XCLFLAGS"
  XCC_NOOPTFLAGS=' -O0'

  if [ "${with_threads}" = "POSIX_THREADS" ]; then
    XCFLAGS=${XCFLAGS}" -pthread"
  fi

else

  if [ $TSYS = sun4 -a $CROSS = false ] ; then
    # Detect SUNWspro C compiler - defines __SUNPRO_C
    XCC_SUNPRO=${CC_SUNPRO}
  fi
  if [ $TSYS = win32msvc ] ; then
    XCPP="cl -E"
    case ${COMPILER} in
      msvc6) XCPP="$XCPP -D_MSC_VER=1200 -D_INTEGRAL_MAX_BITS=64"
        ;;
      msvc7) XCPP="$XCPP -D_MSC_VER=1300 -D_INTEGRAL_MAX_BITS=64 -I\$(MSVCDIR)/PlatformSDK/include"
        ;;
      *) fail "unsupported compiler [${COMPILER}]"
        ;;
    esac
    XCFLAGS="$CFLAGS -U__GNUC__ -DANSI -D_M_IX86=500 -D_WIN32 -I\$(MSVCDIR)/include"
  elif [ $TSYS = sun4 -a -n "$XCC_SUNPRO" ] ; then
    # SUNWspro cc flags:
    XCFLAGS=${XCFLAGS}' -xO3 -xstrconst'
  elif [ "$HSYSOS" = hp-ux -o $TSYS = sun4 ] ; then
    # HP's HPPA compilers crash when optimizing.
    # SUN's cc is buggy when optimizing spvw.d, even with only -O1.
    # we do not reset XCFLAGS so that the user can pass -xarch=v8 et ak
    # XCFLAGS=''
    :
  else
    XCFLAGS=${XCFLAGS}' -O'
  fi
  if [ "$TSYSOS" = ultrix ] ; then
    # Ultrix cc needs this for compiling spvw.d.
    XCFLAGS="$XCFLAGS -Olimit 1000"
  fi
  XCLFLAGS=''
  case $TSYS in mips | ip*)
    # IRIX 4 "cc -ansi" sometimes barfs when a string constant contains one
    # or more quotes('). They must be written as \047.
    TXT2CFLAGS="${TXT2CFLAGS} -DQUOTE_QUOTES"
  esac
  if [ $TSYS = sun4 ] ; then
    XCFLAGS=$XCFLAGS' -dalign'
    if [ $CC_CPLUSPLUS = false ] ; then
      XCFLAGS=$XCFLAGS' -fsingle'
    fi
    XCLFLAGS=$XCLFLAGS' -Bstatic'
  fi
  XCC_NOOPTFLAGS=''

fi

if [ "${with_dynamic_modules}" != no ]; then # not on msvc
  # Support for dynamic loading.
  eval "`./libtool --tag=CC --config | grep '^pic_flag='`"
  eval XCC_PICFLAG=\"${pic_flag}\"
  eval "`./libtool --tag=CC --config | grep '^archive_cmds='`"
  # http://article.gmane.org/gmane.comp.shells.bash.bugs:17158
  CC_set=${CC+set}
  CC_save=$CC
  CC='${CC}' libobjs='$libs' deplibs='${CLFLAGS}' compiler_flags='${CFLAGS}' \
    soname='$dll' lib='$lib' output_objdir='$dyndir' \
    eval XCC_CREATESHARED=\"${archive_cmds}\"
  if test "$CC_set" = set
  then CC=$CC_save
  else unset CC
  fi
  test "${verbose}" = true -o "${verbose}" = yes && \
    echo "XCC_CREATESHARED = ${XCC_CREATESHARED}" >&2
fi

if [ "${with_debug}" != no ] ; then
  if [ $TSYS = sun4 -a $XCC_GCC = true ] ; then
    XCFLAGS=$XCFLAGS' -gstabs'
  elif [ ${HSYS} != "win32msvc" ]; then
    XCFLAGS=$XCFLAGS' -g -O0'
  fi
  XCFLAGS=$XCFLAGS' -DDEBUG_OS_ERROR -DDEBUG_SPVW -DDEBUG_BYTECODE -DSAFETY=3'
  case "$CC" in
    *"g++"* ) XCFLAGS=$XCFLAGS' -DDEBUG_GCSAFETY'; ;;
  esac
fi

if [ $CC_CPLUSPLUS = true -a \( ${HSYSOS} = win32gcc -o ${HSYSOS} = cygwin \) ]
then # This is necessary for g++ to handle w32shell.c:
  # The member lpVtbl is not defined by the w32api include files if
  #   defined(__cplusplus) && !defined(CINTERFACE)
  # cf <http://article.gmane.org/gmane.comp.gnu.mingw.user/8213>
  XCFLAGS=$XCFLAGS' -DCINTERFACE'
fi

if [ "$cpu" = i386 -a "$TSYSOS" = "sinix-z" ] ; then # SINIX-Z V5.41
  XCFLAGS=$XCFLAGS' -DSNI -DSVR4' # maybe add -DUSL
fi
if [ "$cpu" = mips -a "$TSYSOS" = "sysv4" ] ; then # mips-sni-sysv4
  XCFLAGS=$XCFLAGS'' # maybe add -DUSL
fi
if [ "$cpu" = i386 -a "$TSYSOS" = "unix_sv" ] ; then # Onsite SVR4.2
  XCFLAGS=$XCFLAGS'' # maybe add -DUSL
fi
if [ "$cpu" = i386 -a "$TSYSOS" = "sunos" ] ; then # Solaris 2
  XCFLAGS=$XCFLAGS'' # maybe add -DUSL
fi

# uname -r may contain arbitrary junk not suitable for pathnames:
# cygwin: 1.5.18(0.132/4/2)
UNAME_R=`uname -r | $tolower | sed 's/[^A-Za-z0-9.].*//'`
if [ "$cpu" = i386 -a "$TSYSOS" = linux -a $CROSS = false ] ; then # Linux
  # Generational GC requires Linux 1.1.52 or newer
  case "$UNAME_R" in
    0.* | 1.0.* | 1.1.[0-9] | 1.1.[1-4][0-9] | 1.1.5[0-1] )
      XCFLAGS=$XCFLAGS' -DNO_GENERATIONAL_GC' ;;
    *) ;;
  esac
fi

if [ "${enable_mmap}" = no ]; then
  XCFLAGS=${XCFLAGS}" -DNO_SINGLEMAP -DNO_TRIVIALMAP"
fi

if [ $TSYS = sun4 -a $CROSS = false ] ; then
  ARCH_K=`(arch -k) 2>/dev/null || uname -m 2>/dev/null` # kernel architecture, see arch(1)
  if [ "$ARCH_K" = sun4 -o "$ARCH_K" = sun4c -o "$ARCH_K" = sun4e ] ; then
    # sun4, sun4c, sun4e support only 29 bit addresses,
    # sun4m supports 32 bit addresses.
    XCFLAGS=$XCFLAGS' -DSUN4_29'
  fi
fi
# When to define BINARY_DISTRIB?
# There is no general pro or cons of distributing an executable versus a
# static library, except for the unavailability of the compiler and linker
# on some platforms.
# Other than that, it mostly depends on whether the host you are building
# on has a recent or an old set of system shared libraries. Old is better
# here, since vendors usually only add functions to libc and rarely remove
# some functions. If the host you use for the build is not the oldest OS
# version, then distributing the static library is better: when you distribute
# a Unix executable, it is _certain_ to not run on older versions of the OS
# (thanks to the shared library versioning check), whereas when you distribute
# a static library, it has good chances to link and work fine on older versions
# of the OS.
# So the general rule is:
#   IF platform frequently comes without compiler and linker
#     THEN use BINARY_DISTRIB
#     ELSE
#       IF platform has strict libc version checking
#         THEN use static library distribution
#         ELSE use BINARY_DISTRIB
# cf <http://article.gmane.org/gmane.lisp.clisp.devel:10411>
if [ $CROSS = false ] ; then
  case "$host_os" in
    solaris*)
      # Newer versions of Solaris (Solaris 2.2 and newer) don't have
      # libdl_stubs.a any more. This means that you cannot link -static !
      XCLFLAGS=`echol "$XCLFLAGS" | sed -e 's/-B*static//g'`
      SOLARIS_LINKING=1 # Even more hacks needed??
      BINARY_DISTRIB=1
    ;;
    hpux*)
      # Newer versions of HP-UX (HP-UX 10.20 and HP-UX 11) ship with no ANSI C
      # compiler, only with K&R "cc" whose only use may be to bootstrap gcc.
      BINARY_DISTRIB=1
    ;;
    darwin*)
      # Douglas Philips <dgou@mac.com>:
      # Mac OS/X does not come with developer tools
      BINARY_DISTRIB=1; ;;
  esac
fi
test -n "$BINARY_DISTRIB" && XCFLAGS=$XCFLAGS' -DUNIX_BINARY_DISTRIB'


# Other dependencies:

FILES=''

if [ "${with_unicode}" != no ]; then
  XCFLAGS="$XCFLAGS -DENABLE_UNICODE"
fi
if [ "${with_threads}" != no ]; then
  XCFLAGS="$XCFLAGS -DMULTITHREAD -D${with_threads}"
fi
if [ "${with_jitc}" != "" ]; then
  XCFLAGS="$XCFLAGS -DHEAPCODES -DUSE_JITC -D${with_jitc}"
fi

if [ "${with_termcap_ncurses}" = no -o "${LIBTERMCAP}" = "broken" ] ; then
  XCFLAGS=$XCFLAGS' -DNO_TERMCAP_NCURSES'
  LIBTERMCAP=""
fi
if [ "${LIBTERMCAP}" != "broken" -a -n "${LIBTERMCAP}" ]; then
  XCFLAGS=${XCFLAGS}" ${INCTERMCAP}"
  XLDFLAGS=${XLDFLAGS}" ${LIBTERMCAP}"
fi

test "${with_dynamic_ffi}" != no && XCFLAGS="$XCFLAGS -DDYNAMIC_FFI"

test "${with_dynamic_modules}" != no && XCFLAGS="$XCFLAGS -DDYNAMIC_MODULES"

if [ "${with_readline}" = no ]; then
  # --without-readline was supplied
  XCFLAGS=$XCFLAGS' -DNO_READLINE'
else
  FILES='libnoreadline.a '$FILES
  if grep "#undef HAVE_READLINE" config.h >/dev/null 2>&1; then
    # --with-readline was supplied ==> barf when readline is missing
    test "${with_readline}" != ifpossible && \
      fail "configure failed to detect readline"
  else                          # readline is present
    test "${with_dynamic_ffi}" != no && \
      BASE_MODULES=${BASE_MODULES}" readline"
  fi
fi

USE_GETTEXT=''
XCL_GETTEXTLIB=''
if [ "${with_gettext}" = no -o "@USE_NLS@" != yes ]; then
  XCFLAGS=$XCFLAGS' -DNO_GETTEXT'
else
  USE_GETTEXT=yes
  LIBS='@LIBINTL@ '$LIBS
  XCL_GETTEXTLIB=$XCL_GETTEXTLIB' locale'
fi

GLLIB_A=libgnu.a
# libgnu.a must come _before_ -lws2_32 -lintl &c
LIBS="${GLLIB_A} ${LIBS} ${LIBSOCKET}"
FILES="${GLLIB_A} "${FILES}

FILES='lisp.a '$FILES

CPARTS='        spvw spvwtabf spvwtabs spvwtabo'
CPARTS=$CPARTS' eval control'
CPARTS=$CPARTS' encoding pathname stream'
test $TSYS = master -o $TOS = unix -o $TOS = win32 && CPARTS=$CPARTS' socket'
CPARTS=$CPARTS' io funarg'
CPARTS=$CPARTS' array hashtabl list package record weak sequence'
CPARTS=$CPARTS' charstrg debug error misc time predtype symbol lisparit i18n'
test $TSYS = master -o "${with_dynamic_ffi}" != no && CPARTS=$CPARTS' foreign'
test $TSYS = master -o $TOS = unix && CPARTS=$CPARTS' unixaux'
test $TSYS = master -o $TOS = win32 && CPARTS=$CPARTS' win32aux'
test "${with_threads}" != no && CPARTS=$CPARTS' zthread'
CPARTS=$CPARTS' built'

EVERY_INCLUDES='lispbibl fsubr subr pseudofun constsym constobj constobj_tl '$OS_INCLUDES

EVERY_INCLUDES_C=''
for f in $EVERY_INCLUDES ; do
  EVERY_INCLUDES_C=$EVERY_INCLUDES_C' '$f'.c'
done

# on UNIX and MINGW PACKAGE_* (and OS capabilities!) is in config.h,
# otherwise PACKAGE_* is in version.h and OS capabilities are in win32.c
if [ ${TOS} = unix -o ${HSYS} = win32gcc ]; then
  EVERY_INCLUDES_H=' config.h'
  SPVW_VERSION=''
else
  EVERY_INCLUDES_H=''
  SPVW_VERSION=version.h
fi

OTHER_INCLUDES=' constpack avl sort bytecode'

SPVW_INCLUDES=' spvw_module spvw_debug spvw_alloca spvw_mmap spvw_singlemap spvw_page spvw_heap spvw_global spvw_gcstat spvw_space spvw_mark spvw_objsize spvw_update spvw_fault spvw_sigsegv spvw_sigcld spvw_sigpipe spvw_sigint spvw_sigwinch spvw_sigterm spvw_garcol spvw_garcol_old spvw_genera1 spvw_gcmark spvw_genera2 spvw_weak spvw_genera3 spvw_allocate spvw_typealloc spvw_circ spvw_walk spvw_ctype spvw_language spvw_memfile'

UNICODE_INCLUDES=''
if [ "${with_unicode}" != no ] ; then
  UNICODE_INCLUDES=$UNICODE_INCLUDES' uni_upcase uni_downcase uni_attribute'
fi

NLS_INCLUDES=''
if [ "${with_unicode}" != no ] ; then
  NLS_INCLUDES=$NLS_INCLUDES' nls_ascii'
  NLS_INCLUDES=$NLS_INCLUDES' nls_iso8859_1 nls_iso8859_2 nls_iso8859_3'
  NLS_INCLUDES=$NLS_INCLUDES' nls_iso8859_4 nls_iso8859_5 nls_iso8859_6'
  NLS_INCLUDES=$NLS_INCLUDES' nls_iso8859_7 nls_iso8859_8 nls_iso8859_9'
  NLS_INCLUDES=$NLS_INCLUDES' nls_iso8859_10 nls_iso8859_13 nls_iso8859_14'
  NLS_INCLUDES=$NLS_INCLUDES' nls_iso8859_15 nls_iso8859_16'
  NLS_INCLUDES=$NLS_INCLUDES' nls_koi8_r nls_koi8_u'
  NLS_INCLUDES=$NLS_INCLUDES' nls_mac_arabic nls_mac_centraleurope'
  NLS_INCLUDES=$NLS_INCLUDES' nls_mac_croatian nls_mac_cyrillic nls_mac_dingbat'
  NLS_INCLUDES=$NLS_INCLUDES' nls_mac_greek nls_mac_hebrew nls_mac_iceland'
  NLS_INCLUDES=$NLS_INCLUDES' nls_mac_roman nls_mac_romania nls_mac_symbol'
  NLS_INCLUDES=$NLS_INCLUDES' nls_mac_thai nls_mac_turkish nls_mac_ukraine'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp437_ms nls_cp437_ibm nls_cp737 nls_cp775'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp850 nls_cp852_ms nls_cp852_ibm nls_cp855'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp857 nls_cp860_ms nls_cp860_ibm nls_cp861_ms'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp861_ibm nls_cp862_ms nls_cp862_ibm'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp863_ms nls_cp863_ibm nls_cp864_ms'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp864_ibm nls_cp865_ms nls_cp865_ibm'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp866 nls_cp869_ms nls_cp869_ibm nls_cp874_ms'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp874_ibm'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp1250 nls_cp1251 nls_cp1252 nls_cp1253'
  NLS_INCLUDES=$NLS_INCLUDES' nls_cp1254 nls_cp1256 nls_cp1257'
  NLS_INCLUDES=$NLS_INCLUDES' nls_hp_roman8'
  NLS_INCLUDES=$NLS_INCLUDES' nls_jisx0201'
fi

if [ -n "${SRCDIR}" ] ; then
  INCLUDES="${UNICODE_INCLUDES}"
  UNICODE_INCLUDES=''
  for i in ${INCLUDES}; do
    UNICODE_INCLUDES="${UNICODE_INCLUDES} ${SRCDIR}${i}"
  done
  INCLUDES="${NLS_INCLUDES}"
  NLS_INCLUDES=''
  for i in ${INCLUDES}; do
    NLS_INCLUDES="${NLS_INCLUDES} ${SRCDIR}${i}"
  done
fi

ERROR_INCLUDES='errunix'
test $TSYS = master -o $TOS = win32 && ERROR_INCLUDES=$ERROR_INCLUDES' errwin32'

LISPARIT_SUBFILES=' aridecl arilev0 arilev1 intelem intlog intplus intcomp intbyte intmal intdiv intgcd int2adic intsqrt intprint intread intserial rational'
LISPARIT_SUBFILES=$LISPARIT_SUBFILES' sfloat ffloat dfloat lfloat flo_konv flo_rest realelem realrand realtran compelem comptran'
LISPARIT_INCLUDES=$LISPARIT_SUBFILES' arilev1c arilev1e arilev1i'

EXTRA_CPARTS='noreadline'

DFILES="$CPARTS $EVERY_INCLUDES $OTHER_INCLUDES $SPVW_INCLUDES $ERROR_INCLUDES $LISPARIT_INCLUDES genclisph $EXTRA_CPARTS"

ARI_ASMD=''
ARI_ASMC=''
ARI_ASMS=''
if [ "$cpu" = m68k ] ; then
  ARI_ASMD=$ARI_ASMD' ari68000 ari68020'
  if [ $TSYS = sun3 -o $TSYS = hp300 -o $TSYS = m68k -o $TSYS = mc68040 -a "$TSYSOS" = netbsd ] ; then
    ARI_ASMS=$ARI_ASMS' ari68020'
  else
    ARI_ASMS=$ARI_ASMS' ari68000'
  fi
  ARI_ASMC=$ARI_ASMS
fi
if [ "$cpu" = sparc ] ; then
  ARI_ASMD=$ARI_ASMD' arisparc'
  ARI_ASMS=$ARI_ASMS' arisparc'
fi
if [ "$cpu" = sparc64 ] ; then
  ARI_ASMD=$ARI_ASMD' arisparc64'
  ARI_ASMS=$ARI_ASMS' arisparc64'
fi
if [ "$cpu" = mips ] ; then
  ARI_ASMD=$ARI_ASMD' arimips'
  ARI_ASMS=$ARI_ASMS' arimips'
fi
if [ "$cpu" = mips64 ] ; then
  ARI_ASMD=$ARI_ASMD' arimips64'
  ARI_ASMS=$ARI_ASMS' arimips64'
fi
if [ "$cpu" = i386 ] ; then
  ARI_ASMD=$ARI_ASMD' ari80386'
  ARI_ASMS=$ARI_ASMS' ari80386'
fi
if [ "$cpu" = hppa ] ; then
  ARI_ASMD=$ARI_ASMD' arihppa'
  ARI_ASMS=$ARI_ASMS' arihppa'
fi
if [ "$cpu" = arm ] ; then
  ARI_ASMD=$ARI_ASMD' ariarm'
  ARI_ASMS=$ARI_ASMS' ariarm'
fi

SP_ASMD=''
SP_ASMS=''
if [ $XCC_GCC = false ] ; then
  if [ "$cpu" = m68k ] ; then
    SP_ASMD=$SP_ASMD' sp68000'
    SP_ASMS=$SP_ASMS' sp68000'
  fi
  if [ "$cpu" = sparc -o "$cpu" = sparc64 ] ; then
    SP_ASMD=$SP_ASMD" sp${cpu}"
    SP_ASMS=$SP_ASMS" sp${cpu}"
  fi
  if [ "$cpu" = mips -o "$cpu" = mips64 ] ; then
    SP_ASMD=$SP_ASMD' spmips'
    SP_ASMS=$SP_ASMS' spmips'
  fi
  if [ "$cpu" = i386 ] ; then
    SP_ASMD=$SP_ASMD' sp80386'
    SP_ASMS=$SP_ASMS' sp80386'
  fi
fi

COMMENTS=''

LPARTS='        init defseq backquote defmacro macros1 macros2 defs1'
test ${TOS} = unix -o ${TOS} = win32 || LPARTS=$LPARTS' timezone'
LPARTS=$LPARTS' lambdalist places floatprint defpackage type subtypep'
LPARTS=$LPARTS' clos-package clos-macros clos-class0 clos-metaobject1'
LPARTS=$LPARTS' clos-slotdef1 clos-stablehash1 clos-specializer1 clos-class1'
LPARTS=$LPARTS' clos-class2 clos-class3 defstruct format'
LPARTS=$LPARTS' international savemem functions trace cmacros compiler'
LPARTS=$LPARTS' defs2 loop clos'
LPARTS=$LPARTS' clos-stablehash2'
LPARTS=$LPARTS' clos-specializer2 clos-specializer3'
LPARTS=$LPARTS' clos-class4 clos-class5 clos-class6'
LPARTS=$LPARTS' clos-slotdef2 clos-slotdef3 clos-slots1 clos-slots2'
LPARTS=$LPARTS' clos-method1 clos-method2 clos-method3 clos-method4'
LPARTS=$LPARTS' clos-methcomb1 clos-methcomb2 clos-methcomb3 clos-methcomb4'
LPARTS=$LPARTS' clos-genfun1 clos-genfun2a clos-genfun2b clos-genfun3 clos-genfun4 clos-genfun5'
LPARTS=$LPARTS' clos-dependent clos-print clos-custom documentation'
LPARTS=$LPARTS' fill-out disassem condition loadform gstream xcharin keyboard'
LPARTS=$LPARTS' screen runprog query reploop dribble complete'
LPARTS=$LPARTS' pprint describe room edit macros3 clhs inspect gray'
test "${with_threads}" = no || LPARTS=$LPARTS' threads'
LPARTS=$LPARTS' case-sensitive'
test $TSYS = master -o "${with_dynamic_ffi}" != no && LPARTS=$LPARTS' foreign1'
LPARTS=$LPARTS' exporting '
test "${with_unicode}" = no -o "${with_gettext}" = no || \
  LPARTS=$LPARTS' german french spanish russian danish dutch'
LPARTS=$LPARTS' deprecated'

TXT_DOCS='LISP-tutorial.txt CLOS-guide.txt'

TXT_FILES='README README.de README.es clisp.c'
test $CROSS = false -a $HOS = unix && TXT_FILES=$TXT_FILES' distmakefile'
MANPAGES="clisp clisp-link"
for f in ${MANPAGES}; do
  TXT_FILES="$TXT_FILES $f.1 $f.html $f-1.html"
done

OBSOLETE=''

# Output the makefile:

# echotab line
# outputs a line, preceding it with a tab. cat is needed to output tabs.
if [ $HSYS != win32msvc ] ; then
echotab () {
cat <<!!
	$1
!!
}
else
# Win32 "nmake" stupidly passes the command lines through `printf', thus
# interpreting % characters.
echotab () {
cmd=`echol "$1" | sed -e 's,%,%%,g'`
cat <<!!
	$cmd
!!
}
fi

# echotabpipe line
# outputs a line, split along pipe symbols, preceding with tabs.
echotabpipe() {
echotab "$1"
}

# echolist prefix list suffix prefix
# outputs a list of items, prefixed by backslashes and newlines to break long
# lines.
echolist () {
line="$1"
suffix="$3"
prefix="$4"
for f in $2 ; do
  echol $line" \\"
  line="${prefix}${f}${suffix}"
done
echol $line
}

# echodummyrule target
# outputs a dummy rule for the given target.
case "$host_os" in
  aix*) # GNU make on AIX starts an interactive shell for every empty rule
echodummyrule () {
echotab "true"
}
  ;;
  *)
echodummyrule () {
:
}
  ;;
esac

echol "# -*- Makefile -*- for the CLISP binaries"
echol "# DO NOT EDIT! GENERATED AUTOMATICALLY!"
echol "# This file was created on host $hostname as the output of the command:"
echol "# $0$makemake_args"
echol
echol '# -------------- Start of configurable section --------------------'
echol "srcdir = ${srcdir}"
# cannot do this: "Circular ../src/build-aux <- ../src/build-aux dependency dropped."
#echol "VPATH = ${srcdir}"
echol
if [ $TSYS = win32msvc ] ; then
  echol "# Flags that can be set on the nmake command line:"
  echol "#   MFLAGS={-ML|-MT|-MD} for defining the compilation model"
  echol "#     MFLAGS=-ML (the default)  Single-threaded, statically linked - libc.lib"
  echol "#     MFLAGS=-MT                Multi-threaded, statically linked  - libcmt.lib"
  echol "#     MFLAGS=-MD                Multi-threaded, dynamically linked - msvcrt.lib"
  echol '!if !defined(MFLAGS)'
  echol 'MFLAGS='
  echol '!endif'
  echol
fi

PACKAGE_VERSION="@PACKAGE_VERSION@"
VERSION_NUMBER=`echo "${PACKAGE_VERSION}" | sed -e 's, .*,,'`
echol "# The official version number"
echol "PACKAGE_VERSION=${PACKAGE_VERSION}"
echol "VERSION=${VERSION_NUMBER}"
echol "# The official package name"
echol "PACKAGE_NAME=@PACKAGE_NAME@"
echol "# If you want to distribute a modified version of CLISP,"
echol "# use this to distinguish your distribution from the official one."
echol "# This can also be used for pre-test and post-release distributions:"
echol "#   make distrib VERSION_SUFFIX=pre"
echol "VERSION_SUFFIX="
echol "# The distribution's top directory"
echol 'TOPDIR=clisp-$(VERSION)$(VERSION_SUFFIX)'
echol
echol '# Directories used by "make install":'
echol "prefix = ${PREFIX}"
echol "exec_prefix = ${EXEC_PREFIX}"
echol "bindir  = ${BINDIR}"
echol "datarootdir = ${DATAROOTDIR}"
echol "mandir  = ${MANDIR}"
echol "docdir  = ${DOCDIR}"
echol "htmldir = ${HTMLDIR}"
echol "psdir   = ${PSDIR}"
echol "pdfdir  = ${PDFDIR}"
echol "libdir  = ${LIBDIR}"
echol "lisplibdir = \$(libdir)${NEXT_}\$(TOPDIR)"
test -n "$USE_GETTEXT" && echol "localedir = ${LOCALEDIR}"
echol "elispdir = ${ELISPDIR}"
echol "vimdir = ${VIMDIR}"
echol "aclocaldir = ${ACLOCALDIR}"
echol "# The value of following variable is prepended to all the paths for"
echol "# installation. This is useful when preparing a binary distribution."
echol "DESTDIR ="
echol
echol     "# (partial) list of available add-on modules"
echol     "# (see directory modules/ for the full list"
echol     "#  or pass --help-modules to top-level configure):"
echol     "# asdf                 Another System Definition Facility"
echol     "# queens               the queens function (a toy example)"
echol     "# dirkey               the directory access (LDAP, win32 registry)"
echol     "# berkeley-db          the Berkeley DB access"
echol     "# gdbm                 the GNU DataBase manager"
echol     "# rawsock              raw socket access"
echol     "# pcre                 Perl-compatible regular expressions"
if [ "${with_dynamic_ffi}" != no ]; then
  echol   "# libsvm               build Support Vector Machine models"
  echol   "# postgresql           interface to PostgreSQL ODBMS"
  echol   "# fastcgi              FastCGI (http://www.fastcgi.com/) interface"
  echol   "# oracle               Oracle (http://www.oracle.com/) interface"
  echol   "# netica               Netica (http://norsys.com/netica_c_api.htm)"
  echol   "# pari                 PARI/gp (http://pari.math.u-bordeaux.fr/)"
  echol   "# zlib                 ZLIB (http://www.zlib.org)"
  test "$cpu" = i386 -a "$TSYSOS" = linux && \
    echol "# bindings/glibc       Linux glibc bindings (GNU libc version 2)"
  test "$cpu" = i386 -a \( "$TSYSOS" = win32gcc -o "$TSYSOS" = cygwin \) && \
    echol "# bindings/win32       win32 bindings"
  echol   "# gtk2                 GTK2 interface"
fi
test $TOS = unix -o $TOS = win32 && \
  echol   "# clx/mit-clx          classical X11 interface"
test $TOS = unix && \
  echol   "# clx/new-clx          faster X11 interface (replaces clx/mit-clx)"
echol "MODULES = ${MODULES}"
echol
echol "# Command line options passed to the configure files of add-on modules"
echol "MODULE_CONFIGURE_FLAGS = ${module_configure_flags}"
echol
echol '# Programs used by "make":'
if [ $CROSS = true ] ; then
  echol "CC = ${CC}"
  echol "CPPFLAGS = ${CPPFLAGS}"
  echol "CFLAGS = ${CFLAGS}"
  echol "CLFLAGS = ${CLFLAGS}"
  echol "CPP = ${CPP}"
  echol "XCC = ${XCC}"
  echol "XCPPFLAGS = ${XCPPFLAGS}"
  echol "XCFLAGS = ${XCFLAGS}"
  echol "XCPP = ${XCPP}"
  echol "XCLFLAGS = ${XCLFLAGS}"
  echol "XLIBS = ${LIBS}"
  XCC="\$(XCC)"
  XCPPFLAGS="\$(XCPPFLAGS)"
  XCFLAGS="\$(XCFLAGS)"
  XCPP="\$(XCPP)"
  XCLFLAGS="\$(XCLFLAGS)"
  LIBS="\$(XLIBS)"
else
  echol "CC = ${XCC}"
  echol "CPPFLAGS = ${XCPPFLAGS}"
  echol "CFLAGS = ${XCFLAGS}"
  echol "CPP = ${XCPP}"
  echol "CLFLAGS = ${XCLFLAGS}"
  echol "LIBS = ${LIBS}"
  XCC="\$(CC)"
  XCPPFLAGS="\$(CPPFLAGS)"
  XCFLAGS="\$(CFLAGS)"
  XCPP="\$(CPP)"
  XCLFLAGS="\$(CLFLAGS)"
  LIBS="\$(LIBS)"
fi
echol "X_LIBS = ${X_LIBS}"
X_LIBS="\$(X_LIBS)"
echol 'MODULE_CPPFLAGS = $(CPPFLAGS)'" ${GNULIB_INCLUDE}"
if [ "${with_dynamic_modules}" != no ]; then
  echol 'MODULE_CFLAGS = $(CFLAGS) '"${XCC_PICFLAG}"
  echol 'MODULE_CLFLAGS = $(CLFLAGS) '"${EXPORT_DYNAMIC_FLAG_SPEC}"
  MODULE_CFLAGS_VAR='MODULE_CFLAGS'
  MODULE_CLFLAGS_VAR='MODULE_CLFLAGS'
  XCLFLAGS="\$(MODULE_CLFLAGS)"
else
  MODULE_CFLAGS_VAR='CFLAGS'
  MODULE_CLFLAGS_VAR='CLFLAGS'
fi
if [ $HSYS = win32msvc ] ; then
  echol "#MSVCDIR = d:/msdev"
  echol "#MSVCDIR = d:/devstudio/vc"
  echol "#MSVCDIR = c:/msvs/vc98"
  echol "#MSVCDIR = \"C:/Program Files/Microsoft Visual Studio/VC98\""
  echol '#MSVCDIR = "C:\Programme\Microsoft Visual Studio\VC98"'
fi
# echotab_to_HEXE command source target
# outputs a `make' statement that executes "command source" and creates
# target${HEXE}.
if [ $HSYS != win32msvc ] ; then
  echotab_to_HEXE () {
    echotab "$1 $2 -o $3${HEXE}"
  }
else
  echotab_to_HEXE () {
    echotab "$1 $2 /Fe$3${HEXE}"
  }
fi
if [ -n "$CHSCONVERT" ] ; then
  echol "CHARSETCONVERT = ${CHSCONVERT}"
  CHSCONVERT_FILTER=" | \$(CHARSETCONVERT)"
else
  CHSCONVERT_FILTER=''
fi
echol
if [ $HOS = win32 -a $HSYS != win32gcc ] ; then
  if [ $HSYS = win32msvc ] ; then
    echol "MAKE = nmake"
  else
    echol "MAKE = amake"
  fi
  echol "RM = -${RM}"
  echol "RMRF = -${RMRF}"
  echol "TOUCH = -${TOUCH}"
else
  SET_MAKE="@SET_MAKE@"
  test -n "${SET_MAKE}" && echol "${SET_MAKE}"
  echol "RM = ${RM}"
  echol "RMRF = ${RMRF}"
  echol "TOUCH = ${TOUCH}"
fi
echol "CP = ${CP}"
echol "LN_S = ${LN_S}"
echol "MV = ${MV}"
echol "CAT = ${CAT}"
echol "GREP = ${GREP}"
echol "AR = ar"
echol "RANLIB = ${RANLIB}"
echol
echol '# Programs used by "make install":'
echol "INSTALL = ${INSTALL}"
echol "INSTALL_PROGRAM = ${INSTALL_PROGRAM}"
echol "INSTALL_SCRIPT = ${INSTALL_SCRIPT}"
echol "INSTALL_DATA = ${INSTALL_DATA}"
echol
echol '# Programs used by "make distrib":'
echol
# Auxiliary routines for linking lisp.a:
if [ $HOS = unix -a $XCC_GCC = true ] ; then
  # We need the full libgcc.a in general. But we don't know its location.
  LIBGCC='`'"${XCC} -print-libgcc-file-name"'` # something like /usr/somewhere/libgcc.a'
  if [ $CROSS = false ] ; then
    if [ "$HSYSOS" = linux -o "$HSYSOS" = beos -o "$HSYSOS" = cygwin ] ; then
      # gcc2 is cc on Linux, BeOS and Cygwin. Don't need libgcc.a
      LIBGCC=''
    fi
  fi
else
  LIBGCC=''
fi
test -n "$LIBGCC" && echol "LIBGCC = ${LIBGCC}"
if test -n "$GROFF"; then
  ROFF_MAN="$GROFF -Tascii -mandoc"
  ROFF_PS="$GROFF -Tps -mandoc"
else
  ROFF_MAN="nroff -man"
  if [ $HSYS = sun4 -a $CROSS = false ] ; then
    if [ "$UNAME_S" = sunos ] ; then
      case "$UNAME_R" in 4*)
        # SunOS 4
        ROFF_MAN="nroff -a -man" ;;
      esac
    fi
  fi
fi
echol '# formatter for manual page'
echol "ROFF_MAN = ${ROFF_MAN}"' # try "groff -Tascii -mandoc" or "nroff -man"'
if test -n "$GROFF"; then
  echol "ROFF_PS  = ${ROFF_PS}"' # try "groff -Tps -mandoc"'
  test -n "$PS2PDF" && echol "PS2PDF = ${PS2PDF}"
fi
echol
echol '# -------------- End of configurable section --------------------'
echol
cat <<\!!
#
#                       Requirements for add-on modules
#                       -------------------------------
#
# The general layout of add-on modules is described in
#  <http://clisp.org/impnotes/modules.html>.
# The requirements made there (i.e. the existence of a "link.sh" file
# which defines certain variables) make sure that such an add-on module
# can be distributed with CLISP.
#
# If you want an add-on module to be _built_ automatically with CLISP,
# the following additional requirements have to be obeyed.
#
# 1. The module must be located in a subdirectory of clisp's build
#    directory.
#    Examples: clisp/build/regexp/
#              clisp/build/bindings/glibc/
#
# 2. If the module contains a file called "configure", it is assumed
#    to be a GNU autoconf generated configuration file, and is called
#    with a "--cache-file=..." argument. It should generate platform
#    dependent header files, Makefiles and the like.
#
# 3. The module should contain a Makefile (maybe generated by requirement 2),
#    which defines the following targets:
#
#     clisp-module
#
#      This target builds the file(s) mentioned by the link.sh file.
#      The following makefile variables can be used:
#        CC        the C compiler used to compile the CLISP source
#        CPPFLAGS  the C compiler flags when compiling some source
#        CFLAGS    the C compiler flags
#        CLFLAGS   the C compiler flags when linking an executable
#        LIBS      the libraries used when linking an executable
#        RANLIB    the name of the "ranlib" command
#        CLISP     a command which calls the already built "boot" clisp.
#        CLISP_LINKKIT  the directory containing the CLISP header file clisp.h
#                       (defaults to $$($(CLISP) -b)/linkkit)
#        SHREXT    the shared object extension (.so or .dll)
#      Typically, you will have rules like this in your Makefile:
#        foo.o : foo.c
#                $(CC) $(CPPFLAGS) $(CFLAGS) -I$(CLISP_LINKKIT) -c foo.c
#        foo.fas : foo.lisp
#                $(CLISP) -c foo.lisp
#
#     clisp-module-distrib
#
#      This target copies the module into a temporary distribution
#      directory, on the same disk.
#      The following makefile variables can be used:
#        distribdir  the name of temporary distribution directory
#        LN          command to make hard links (works also for symbolic links)
#      Typically, this target will look like this:
#        DISTRIBFILES = <the NEW_FILES mentioned in link.sh> <doc files>
#        clisp-module-distrib : clisp-module force
#               $(LN) $(DISTRIBFILES) $(distribdir)
#
# If these requirements are obeyed, this Makefile will automatically build
# the add-on module and make it part of the "full" distribution -- all you
# need to do is to add its name to the MODULES definition line above.
#
!!
echol
if [ $HOS = unix ] ; then
  # On some systems (IRIX SVR3 and others) the default shell is csh.
  # The sh and ksh on HP-UX 10 have severe bugs that cause
  #   1. Most invocations of lisp.run crash like this (from HP-UX make):
  #        ./lisp.run ...
  #        /bin/sh: 18546 Bus error
  #      or like this (from GNU make):
  #        ./lisp.run ...
  #        *** Termination signal 11
  #   2. A command such as  'grep -v "^ *$$"'  to be executed incorrectly.
  # As a workaround, we use GNU bash instead.
  case "$host_os" in
    hpux*) echol "SHELL = bash" ;;
    *)     echol "SHELL = ${CONFIG_SHELL-/bin/sh}" ;;
  esac
  # netbsd make ignores the SHELL macro, so we need to use a special
  # target to tell it to respect our shell setting
  # this is important because if configure uses bash and detects TEST_NT=yes,
  # but make uses sh that does not support "test -nt", modules will not build
  case "$host_os" in
    *bsd*) echol '.SHELL: name=sh path=$(SHELL)'
  esac
  echol
fi
echol "# Add-on modules that are present in all linking sets (including base)"
echol "# syscalls             export some POSIX (and other) system calls"
echol "# regexp               POSIX regular expressions"
echol "# i18n                 Lisp program internationalization"
echol "# readline             extra fine REPL controls"
echol "BASE_MODULES = ${BASE_MODULES}"
echol
echol "COMMENT5 = ${HERE}comment5"

if [ -n "$XCC_SUNPRO" ] ; then
  XASM_NEED_CCPAUX=true
else
  XASM_NEED_CCPAUX=false
fi

if [ $XASM_NEED_CCPAUX = true ] ; then
  NEED_CCPAUX=true
else
  NEED_CCPAUX=false
fi
XDECL_FILTER="| \$(GCTRIGGER) | \$(VARBRACE)"
XDECL_DEPENDENCIES=" gctrigger${HEXE} varbrace${HEXE}"

echol "GCTRIGGER = ${HERE}gctrigger"
echol "VARBRACE = ${HERE}varbrace"
if [ $XASM_NEED_CCPAUX = true ] ; then
  XASMCCPAUX='ccpaux'$HEXE
  XASMCCPAUX_FILTER=' | '$HERE'ccpaux'
else
  XASMCCPAUX=''
  XASMCCPAUX_FILTER=''
fi
if [ $XCC_NEED_DEEMA = true ] ; then
  if [ $HOS = unix ] ; then
    echol "DEEMA = sed -e 's/, *)/,_EMA_)/g' -e 's/, *,/,_EMA_,/g'"
  else
    echol "DEEMA = deema"
    XDECL_DEPENDENCIES="${XDECL_DEPENDENCIES} deema${HEXE}"
  fi
  XDECL_FILTER="${XDECL_FILTER} | \$(DEEMA)"
fi

if [ -n "${SRCDIR}" ] ; then
  TXT2CINCL="-I${SRCDIR}"
else
  TXT2CINCL=""
fi
echol "TXT2C = ${HERE}txt2c ${TXT2CINCL}"
if [ $CROSS = true ] ; then
  TXT2CFLAGS="${TXT2CFLAGS} -DCROSS"
  TXT_INCLUDES=' lispbibl.h'
else
  TXT2CFLAGS="${TXT2CFLAGS}"
  TXT_INCLUDES="${EVERY_INCLUDES_C}${EVERY_INCLUDES_H}"
fi

echol

echolist "CFILES =" "$DFILES $ARI_ASMD $ARI_ASMC $SP_ASMD gen.lispbibl" ".c"
echol

echolist "OBJECTS =" "$CPARTS $ARI_ASMS $SP_ASMS $GMALLOC" "${TOBJ}"
echol

echolist "LISPFILES =" "$LPARTS" ".lisp" "${SRCDIR}"
echol

echolist "FASFILES =" "$LPARTS config" ".fas"
echol

echolist "TXTFILES =" "$TXT_DOCS" ""
echol

echolist "TESTFASFILES =" "$LPARTS config" ".fas" "${RECOMPILEDIR}${NEXT_M}"
echol

echol

SUBDIRS=gllib
needs="${SUBDIRS} init allc allo lisp${LEXE} interpreted.mem halfcompiled.mem lispinit.mem manual"
if [ \( $HOS = unix -o ${HSYS} = win32gcc \) -a $CROSS = false ] ; then
  needs=".gdbinit "$needs' modular $(BASE_MODULES) $(MODULES) '"clisp${TEXE} boot base full"
fi
if [ $TSYS = win32msvc -a "${with_debug}" != no ] ; then
  needs=$needs" lisp.bsc"
fi
echol "all : $needs"
echodummyrule all
echol
echol "SUBDIRS = ${SUBDIRS}"
echol '.PHONY: subdirs $(SUBDIRS) clean0 clean1 clean2 clean3 clean4 clean5 clean6 clean7 clean8 mostlyclean distclean clean maintainer-clean clean-modules am--refresh'
echol
echol 'subdirs: $(SUBDIRS)'
echol
# gnulib cannot be compiled with C++, thus NO_CXX
echol 'SUBDIR_CFLAGS = $(CFLAGS) '"${XCC_PICFLAG} @NO_CXX@"
echol '$(SUBDIRS): config.status'
echotab 'mkdir -p $@'
echotab 'test -f $@/Makefile || sh config.status $@/Makefile depfiles'
top_srcdir=`cd "${SRCDIR}"; pwd`
echotab 'cd $@ && $(MAKE) CFLAGS="$(SUBDIR_CFLAGS)" top_srcdir="'"${top_srcdir}"'"'
echol
echol "${GLLIB_A}: gllib"
echotab "test -r ${GLLIB_A} || \$(LN_S) gllib/${GLLIB_A} ${GLLIB_A}"
echol

# in the toplevel Makefile.devel, makemake depends also on version.sh.
# we do not need that here because makemake depends on config.status -
# depends on src/configure - depends on version.sh in Makefile.devel
echol "makemake : ${SRCDIR}makemake.in config.status"
echotab "sh config.status --file=makemake"
echol
echol "config.h : ${SRCDIR}config.h.in config.status"
echotab "sh config.status --header=config.h"
# when config.status detects that it did not change config.h, it
# will not touch it, and on the next make config.h will be remade
# again and again ... - avoid it
echotab "touch config.h"
echol
echol "Makefile : makemake"
echotab "$0$makemake_args > Makefile.tmp"
echotab "\$(MV) Makefile Makefile~"
echotab "\$(MV) Makefile.tmp Makefile"
OBSOLETE="$OBSOLETE Makefile~"
echol
echol "config.status : ${SRCDIR}configure"
echotab "\$(RMRF) config.cache \$(SUBDIRS)"
echotab "sh config.status --recheck"
echol
echol "libtool : @LIBTOOL_DEPS@"
echotab "sh config.status --recheck"
echol
echol "am--refresh : config.status Makefile config.h"
echol

if [ $TSYS = win32msvc ] ; then
  # quote for command arguments when they are unnecessary on DOS
  ARGQ=""
  # .. when they are mandatory
  ARGQ1="\""
  # quotes to pass to a command escaped
  QQUOT="\\\""
else
  ARGQ="'"
  ARGQ1="'"
  QQUOT="\""
fi

# cf. ac_precious_vars in configure
PRECIOUS_VARS='CC CFLAGS LDFLAGS CLFLAGS LIBS CPPFLAGS CPP CXX CXXFLAGS X_LIBS'
# Do not touch cflags.h when the changes to Makefile do not modify it.
# Cost: maybe a few extra "echo"s on each make
# Benefit: lispinit.mem is not re-dumped when we add something to MODULES
echol "cflags.h : cflags.h.stamp"
echodummyrule "cflags.h"
echol
echol "cflags.h.stamp : Makefile"
echotab "echo $ARGQ/* generated from Makefile */$ARGQ > cflags.h.new"
for x in ${PRECIOUS_VARS}; do
  echotab "echo $ARGQ#define $x \"\$($x)\"$ARGQ >> cflags.h.new"
done
if [ $TSYS = win32msvc ] ; then
  echotab '$(RM) cflags.h'
  echotab '$(MV) cflags.h.new cflags.h'
else
  echotab 'if cmp cflags.h.new cflags.h > /dev/null 2>&1; then $(RM) cflags.h.new; else $(MV) cflags.h.new cflags.h; fi'
fi
echotab '$(TOUCH) cflags.h.stamp'
echol

UTILS=''
test $NEED_CCPAUX = true && UTILS=$UTILS' ccpaux'
UTILS=$UTILS' comment5'
UTILS=$UTILS' gctrigger'
UTILS=$UTILS' varbrace'
test $XCC_NEED_DEEMA = true -a $HOS != unix && UTILS=$UTILS' deema'
UTILS=$UTILS' txt2c'
UTILS=$UTILS' ccmp2c' # needed by clx module
test "$CHSCONVERT" = "./cv_lt_at" && UTILS=$UTILS' cv_lt_at'
LUTILS='modprep'

PARAMS="intparam floatparam"
PARAMS_H=""
line="init :"
for parf in ${PARAMS}; do
  test ${TOS} != win32 && line=$line" "${parf}.h
  PARAMS_H=${PARAMS_H}" "${parf}.h
done
test $CROSS = true && line=$line" config.h"
for util in ${UTILS} ; do line=$line" ${util}${HEXE}"; done
line=$line" modules.h"
echol $line
echodummyrule init
echol
for parf in ${PARAMS}; do
  if [ $CROSS = true ]; then
    # everything is in config.h
    echol "${parf}.h : ${SRCDIR}${parf}.c config.h"
    echotab '$(TOUCH) '"${parf}.h"
  else
    echol "${parf}.h : ${SRCDIR}${parf}.c config.h"
    echotab "echo '#include \"config.h\"' > tmp.c"
    echotab "cat '${SRCDIR}${parf}.c' >> tmp.c"
    echotab_to_HEXE "\$(CC)" "tmp.c" "${parf}"
    echotab "${HERE}${parf}${HEXE} ${parf}.h"
    echotab "\$(RM) ${parf}${HEXE} tmp.c"
  fi
  echol
done
for util in ${UTILS} ; do
      echol "${util}${HEXE} : ${UTILDIR_M}${util}.c"
      echotab_to_HEXE "${UTILCOMPILE}" "${UTILDIR_CC}${util}.c" "${util}"
      echol
done

echol

echol "modules.h :"
echotab "touch modules.h"
echol

if [ -n "${SRCDIR}" ] ; then
  if [ ${HSYS} = win32gcc ] ; then
    # install.lisp requires dirkey module which is built by mingw but not msvc
    for f in install.lisp install.bat ; do
      link_dep "${f}" "${SRCDIR}${f}"
    done
  fi
fi

if [ ${HOS} = win32 ]; then
  for f in env_var_update.nsh is_user_admin.nsh; do
    link_dep "${f}" "${SRCTOPDIR_}win32msvc/nsis/${f}"
  done
  echol "install.nsi : ${SRCTOPDIR_}win32msvc/nsis/install.nsi config.status"
  # comma used as separator in patterns below to allow embedded
  # slashes in module names (e.g., bindings/win32)
  echotab "sed -e 's/\@NAME\@/\$(PACKAGE_NAME)/g' -e 's/\@VERSION\@/\$(VERSION)/g' -e 's,\@BASE_MODULES\@,\$(BASE_MODULES),g' -e 's,\@MODULES\@,\$(MODULES),g' ${SRCTOPDIR_}win32msvc/nsis/install.nsi > install.nsi"
  echol
  echol "COPYRIGHT.rtf : COPYRIGHT ${SRCTOPDIR_}win32msvc/nsis/text_to_rtf.lisp config.status"
  echotab "\$(RUN) -M lispinit.mem -q ${SRCTOPDIR_}win32msvc/nsis/text_to_rtf.lisp COPYRIGHT COPYRIGHT.tmp"
  echotab "sed -e 's/\@NAME\@/\$(PACKAGE_NAME)/g' -e 's/\@VERSION\@/\$(VERSION)/g' COPYRIGHT.tmp > COPYRIGHT.rtf"
  echotab '$(RM) COPYRIGHT.tmp'
  echol
fi

echol "allc : init \$(CFILES)"
echodummyrule allc
echol

for f in $DFILES ; do
  echol "${f}.c : ${SRCDIR}${f}.d comment5${HEXE}${XDECL_DEPENDENCIES}"
  gen_filter=
  case "${f}" in
    lispbibl) gen_filter=" | sed -e 's/^\\(%% .*\\)//'" ;;
  esac
  echotabpipe "\$(COMMENT5) ${SRCDIR}${f}.d${CHSCONVERT_FILTER}${gen_filter} ${XDECL_FILTER} > ${f}.c"
  echol
done

for f in $ARI_ASMD $SP_ASMD ; do
  echol "${f}.c : ${SRCDIR}${f}.d comment5${HEXE} ${XASMCCPAUX}"
  echotabpipe "\$(COMMENT5) ${SRCDIR}${f}.d${XASMCCPAUX_FILTER} > ${f}.c"
  echol
done

if [ $TSYS != win32msvc ] ; then
  if [ $AS_UNDERSCORE = true ] ; then
    ASMFLAGS=' -DASM_UNDERSCORE'
  else
    ASMFLAGS=''
  fi
  if [ -n "$XCC_SUNPRO" ] ; then
    # SUNPRO cc preprocessor does too much checking in ANSI C mode, choose K&R mode
    ASMFLAGS="$ASMFLAGS"' -Xs'
  fi
  if [ $XCC_GCC = false ] ; then
    # Remove the line number information etc. and convert "% ecx" back to "%ecx"
    # and ". align" to ".align" and ". Lxxx" to ".Lxxx":
    ASM_FILTER=" | \$(GREP) -v '^#' | \$(GREP) -v '^ *#line' | sed -e 's,% ,%,g' -e 's,\\. ,.,g'"
  else
    if [ $AS_UNDERSCORE = false ] ; then
      # These are the less modern assemblers or SYSV assemblers.
      # Remove the line number information etc.
      ASM_FILTER=" | \$(GREP) -v '^#'"
    else
      ASM_FILTER=''
    fi
    if [ "$cpu" = m68k ] ; then
      # SunOS 4.0 "as" doesn't understand ! comments.
      ASM_FILTER="$ASM_FILTER | sed -e 's,!.*\$\$,,'"
    fi
  fi
  for f in $ARI_ASMS $SP_ASMS ; do
    # The preprocessor barfs on arihppa: "unterminated character constant".
    # We ignore this:
    case $f in
      *hppa) g='-' ;;
      *)     g='' ;;
    esac
    # In ari68020.d the dollars must be replaced, and \# replaced with # :
    case $f in
      ari68020*)
        if [ $AS_UNDERSCORE = false ] ; then
          h=' | sed -e '"'"'s/\\#/#/g'"'"' -e '"'"'s/\$$/%/g'"'"
        else
          h=' | sed -e '"'"'s/\\#/#/g'"'"' -e '"'"'s/\$$//g'"'"
        fi
        ;;
      *) h='' ;;
    esac
    echol "${f}.s : ${f}.c"
    echotabpipe "${g}${XCPP}${ASMFLAGS} ${f}.c${h}${ASM_FILTER} > ${f}.s"
    echol
  done
fi

for f in lispbibl; do
  echol "gen.${f}.c : ${SRCDIR}${f}.d comment5${HEXE}"
  echotabpipe "\$(COMMENT5) ${SRCDIR}${f}.d${CHSCONVERT_FILTER} | sed -e '/^%% /{s///p;d;}' -e '/^#line /!s/.*//' > gen.${f}.c"
  echol
done

line="allo : allc"
for f in $CPARTS ; do
  line=$line" ${f}${TOBJ}"
done
echol $line
echodummyrule allo
echol

line="alls : allc"
for f in $CPARTS ; do
  line=$line" ${f}.s"
done
echol $line
echodummyrule alls
echol

echol "# Normally not used (just for debugging)."
line="alli : allc"
for f in $CPARTS ; do
  line=$line" ${f}.i"
done
echol $line
echodummyrule alli
echol

for f in $CPARTS genclisph modules $EXTRA_CPARTS ; do
  depends=$EVERY_INCLUDES
  dependsc=''
  c=${f}.c
  test $f = spvw -o $f = package && depends=$depends' constpack'
  test $f = spvw -o $f = predtype && depends=$depends' avl'
  test $f = spvw && depends=$depends''$SPVW_INCLUDES" sort ${SRCDIR}spvw_calendar"
  test $f = eval && depends=$depends' bytecode '${with_jitc}
  test $f = array -o $f = hashtabl -o $f = io -o $f = time -o $f = package -o $f = spvw -o $f = stream -o $f = foreign && depends=$depends' arilev0'
  test $f = spvw -o $f = hashtabl && depends=$depends' aridecl'
  if [ $f = charstrg -a "${with_unicode}" != no ] ; then
    depends=$depends${UNICODE_INCLUDES}
    dependsc=${dependsc}' '${GLLIB_A}
  fi
  test $f = encoding && depends=$depends''$NLS_INCLUDES
  test $f = error && depends=$depends' '$ERROR_INCLUDES
  test $f = lisparit && depends=$depends''$LISPARIT_INCLUDES''$ARI_ASMS
  test $f = genclisph && depends=$depends' gen.lispbibl'
  for g in $depends ; do
    dependsc=$dependsc' '$g'.c'
  done
  dependsc=$dependsc''$EVERY_INCLUDES_H
  test $f = spvw -a -n "${SPVW_VERSION}" && dependsc=$dependsc' '${SPVW_VERSION}
  if [ $f = pathname ] ; then
    dependsc=$dependsc" ${SRCDIR}execname.c"
    test ${TOS} = win32 && dependsc=$dependsc" ${SRCDIR}w32shell.c"
  fi
  test $f = built && dependsc=${dependsc}' cflags.h'
  flags="$XCPPFLAGS $XCFLAGS"
  test $f = foreign -a $HOS = win32 && flags=$flags" -I${SRCTOPDIR}ffcall"
  test $f = genclisph && flags=$flags" -DCOMPILE_STANDALONE"
  if [ $f = modules ] ; then
    c=${SRCDIR}${c}
    if [ $HOS = unix -a $CROSS = false ] ; then
      dependsc=$dependsc' clisp.h'
    else
      flags=$flags' -DNO_CLISP_H'
    fi
    flags="${flags} -I."
    dependsc=$dependsc' modules.h'
  fi
  flags2=$flags
  if [ $f = eval -a "$cpu" = ia64 -a $XCC_GCC = true ] ; then
    # gcc-2.96 on Linux/ia64 miscompiles eval.d when -O is used.
    flags2=$flags2' -O0'
  fi
  if [ $f = eval -a "${with_jitc}" = lightning ]; then
    flags2=$flags2' -Wno-unused' # should be gone - eventually...
  fi
  test $f = genclisph -a $XCC_GCC = true && \
    flags2=$flags2' -O0' # no need to optimize this
  echol "${f}.i : ${c}${dependsc}"
  echotab "${XCPP} ${flags} ${c} > ${f}.i"
  echol
  echol "${f}.s : ${c}${dependsc}"
  echotab "${XCC} ${flags2} -S ${c}"
  echol
  echol "${f}${TOBJ} : ${c}${dependsc}"
  echotab "${XCC} ${flags2} -c ${c}"
  echol
done

if [ "${with_gmalloc}" = yes ]; then
  for f in $GMALLOC ; do
    echol "${f}${TOBJ} : ${SRCDIR}${f}.c"
    # gmalloc.c needs -DUSG on Solaris and then needs -DMEMMOVE_MISSING for SunOS 4.
    echotab "${XCC} ${XCPPFLAGS} ${XCFLAGS} -DUSG -DMEMMOVE_MISSING -c ${SRCDIR}${f}.c -o ${f}${TOBJ}"
    echol
  done
fi

for f in $ARI_ASMS $SP_ASMS ; do
  if [ $TSYS = win32msvc ] ; then
    echol "${f}.i : ${f}.msvc.c"
    echotab "${XCPP} ${XCPPFLAGS} ${XCFLAGS} ${f}.msvc.c > ${f}.i"
    echol
    echol "${f}.s : ${f}.msvc.c"
    echotab "${XCPP} ${XCPPFLAGS} ${XCFLAGS} ${f}.msvc.c > ${f}.i.c"
    echotab "${XCC} ${XCFLAGS} -c ${f}.i.c /FAs /Fa${f}.s"
    echotab "\$(RM) ${f}.i${TOBJ}"
    echotab "\$(RM) ${f}.i.c"
    echol
    echol "${f}${TOBJ} : ${f}.msvc.c"
    echotab "${XCPP} ${XCPPFLAGS} ${XCFLAGS} ${f}.msvc.c > ${f}.i.c"
    echotab "${XCC} ${XCFLAGS} -c ${f}.i.c"
    echotab "\$(RM) ${f}${TOBJ}"
    echotab "\$(MV) ${f}.i${TOBJ} ${f}${TOBJ}"
    echotab "\$(RM) ${f}.i.c"
    echol
  else
    echol "${f}${TOBJ} : ${f}.s"
    # Call the assembler, preferrably through the C compiler:
    if [ $f = arihppa ] ; then
      # Only the native as groks the .SHORTDATA statements in arihppa.d
      echotab "${XCC} ${XCPPFLAGS} ${XCFLAGS} -c ${f}.s || /usr/ccs/bin/as ${f}.s -o ${f}${TOBJ} || /bin/as ${f}.s -o ${f}${TOBJ}"
    elif [ $f = arimips -a "$TSYSOS" != linux ] ; then
      # Avoid problem during incremental linking of lisp.o.
      echotab "/bin/as -KPIC ${f}.s -o ${f}${TOBJ} || /usr/ccs/bin/as -KPIC ${f}.s -o ${f}${TOBJ}"
    elif [ $XCC_GCC = true ] ; then
      echotab "${XCC} ${XCPPFLAGS} ${XCFLAGS} -x assembler -c ${f}.s"
    else
      echotab "${XCC} ${XCPPFLAGS} ${XCFLAGS} -c ${f}.s"
    fi
    echol
  fi
done

if [ $HOS = unix -o $HSYS = win32gcc ] ; then
  # on w32 -g, using lisp.o leads to a crash on the first statement in main()
  test $HSYSOS = win32gcc -o $HSYSOS = cygwin; no_lisp_o=$?
  echol "lisp.a : \$(OBJECTS)"
  if [ $no_lisp_o = 1 ]; then
    echotab "ld -r -o lisp.o \$(OBJECTS)"
    echotab "chmod a-x lisp.o"
  fi
  if test -z "$LIBGCC"; then
    if [ $no_lisp_o = 1 ]; then
      echotab "\$(AR) rcv lisp.a lisp.o"
    else
      echotab "\$(AR) rcv lisp.a \$(OBJECTS)"
    fi
  else
    # Test for libgcc.a because NeXT cc does not have it.
    echotab "if test -f \$(LIBGCC) ; then mkdir libgcc ; (cd libgcc ; \$(AR) xv \$(LIBGCC)) ; \$(AR) rcv lisp.a lisp.o libgcc/*.o* ; \$(RM) -r libgcc ; else \$(AR) rcv lisp.a lisp.o ; fi"
  fi
  test $no_lisp_o = 1 && echotab "\$(RM) lisp.o"
  echotab "\$(RANLIB) lisp.a"
  echol
  echol "libnoreadline.a : noreadline.o"
  echotab "\$(AR) rcv libnoreadline.a noreadline.o"
  echotab "\$(RANLIB) libnoreadline.a"
  echol
fi
if [ ${SHREXT} = .dll -a "${with_dynamic_modules}" != no ]; then
  # win32 (SHREXT=.dll) requires all accessed libraries when linking a DLL.
  # i.e. when creating a dynamic module dll, we must give lisp.dll to the
  # linker, and when creating lisp.dll, we must give $(LIBS) to it.
  # Some unixes (SHREXT=.so) need -fPIC when compiling clisp core for a DLL,
  # which loses performance; besides, we do not need lisp.so on unix anyway.
  echol "lisp${SHREXT} : ${GLLIB_A} \$(OBJECTS) modules.o"
  CLISP_DEF=" lisp.def"
  XCC_CREATESHARED_=`echo ${XCC_CREATESHARED} | sed -e 's/\\${/\\\\$\\\\(/g' -e 's/}/\\\\)/g'`
  echotab "`eval \"lib=\$\@; libs=\$^\ \$\(LIBS\); echo ${XCC_CREATESHARED_}\"`"
  echol
else
  CLISP_DEF=""
fi
FILES="${FILES}${CLISP_DEF}"

if [ -n "$USE_GETTEXT" ] ; then
  echol "po : config.status ${SRCDIR}po/LINGUAS ${SRCDIR}po/Makefile.in.in"
  echotab "mkdir -p po"
  echotab "test -f po/Makefile.in || sh config.status po/Makefile.in po-directories"
  echol
  echol "LN_HARD=${LN_HARD}"
  echol "locale : po"
  if [ $HOS = unix ] ; then
    echotab "if test -d locale; then \$(RMRF) locale; fi"
    echotab "mkdir locale"
    echotab "(cd po && \$(MAKE) && \$(MAKE) install datarootdir=.. localedir='\$\$(datarootdir)/locale' INSTALL_DATA='\$(LN_HARD)') || (\$(RMRF) locale ; exit 1)"
  else
    echotab "mkdir locale"
    if test -f ${SRCDIR}po/LINGUAS; then
      LINGUAS=`sed 's/#.*//' ${SRCDIR}po/LINGUAS`
    else fail "missing ${SRCDIR}po/LINGUAS"
    fi
    for lang in ${LINGUAS}; do
      echotab "mkdir -p locale${NEXT_}${lang}${NEXT_}LC_MESSAGES"
      echotab "\$(LN_S) ${SRCDIR}po${NEXT_}${lang}.gmo locale${NEXT_}${lang}${NEXT_}LC_MESSAGES${NEXT_}clisp.mo"
    done
  fi
  echol
fi

DATA_FILES="UnicodeDataFull.txt Symbol-Table.text"
DATA_FILES_TOP_PATH="utils${NEXT_}unicode${NEXT_}UnicodeDataFull.txt doc${NEXT_}Symbol-Table.text"
data_target="data :"
for f in ${DATA_FILES_TOP_PATH}; do
  data_target="${data_target} ${SRCTOPDIR_}${f}"
done
echol "${data_target}"
echotab "\$(RMRF) data"
echotab "mkdir data"
for f in ${DATA_FILES_TOP_PATH}; do
  echotab "cd data && \$(LN_S) ${PARENT_SRCTOPDIR_}${f} ."
done
echol

if [ ${HSYS} = win32gcc -a "${with_debug}" = no ]; then
finish_runtime () {
  # woe32 users do not have gcc, so they cannot disassemble CAR anyway
  echotab "strip -s lisp${LEXE}"
  echol
}
else
finish_runtime () {
  echol
}
fi

echol "lisp${LEXE} : ${GLLIB_A} \$(OBJECTS) modules${TOBJ} ${XCL_GETTEXTLIB} data"
if [ $HOS != win32 ] ; then
  if [ $XCC_GCC = true -a -n "$SOLARIS_LINKING" ] ; then
    # Dynamically linking on Solaris 2.[23] is a pain.
    LIBGCC_DIR='`'"${XCC} -print-libgcc-file-name"' | sed -e '"'"'s,[^/]*$$,,'"'"'`'
    echotab "${XCC} ${XCFLAGS} ${XCLFLAGS} \$(OBJECTS) modules${TOBJ} ${LIBS} -o lisp${LEXE} || /usr/ccs/bin/ld -V -dy -Bdynamic -Y P,/usr/ccs/lib:/usr/lib -Qy -o lisp${LEXE} ${LIBGCC_DIR}crt1.o ${LIBGCC_DIR}crti.o /usr/ccs/lib/values-Xa.o ${LIBGCC_DIR}crtbegin.o \$(OBJECTS) modules${TOBJ} -L${LIBGCC_DIR} -L/usr/ccs/bin ${LIBS} -lgcc -lc ${LIBGCC_DIR}crtend.o ${LIBGCC_DIR}crtn.o -lgcc"
  else
    echotab "${XCC} ${XCFLAGS} ${XCLFLAGS} \$(OBJECTS) modules${TOBJ} ${LIBS} ${OUT}lisp${LEXE}"
  fi
else
  # MSVC's incremental linking is buggy, avoid it.
  if [ $HSYS = win32msvc ] ; then echotab "\$(RM) lisp.ilk"; fi
  echotab "${XCC} ${XCFLAGS} ${XCLFLAGS} \$(OBJECTS) modules${TOBJ} ${LIBS} ${OUT}lisp${LEXE}"
  # With msvc4/5, need at least 1200 KB stack for creating the first
  # interpreted.mem, but the default stack size is only 1 MB.
  # With msvc6, need more than 2 MB for compiling compiler.lisp.
  if [ $HSYS = win32msvc -a ${COMPILER} != msvc7 ]; then
    # Jay Kint <jkint@icosahedron.org> says that msvc7(.NET) does not need this
    echotab "editbin /stack:3145728 lisp${LEXE}"
  fi
fi
finish_runtime lisp${LEXE}

if [ $TSYS = win32msvc -a "${with_debug}" != no ] ; then
  echol "${SRCDIR}lisp.bsc : lisp${LEXE}"
  echotab "bscmake /n /o lisp *.sbr"
  echol
fi

CONFIG=cfg${TOS}
echol "config.lisp : ${SRCDIR}${CONFIG}.lisp"
echotab "\$(CP) ${SRCDIR}${CONFIG}.lisp config.lisp"
if [ $TOS = unix ] ; then
  echotab "chmod +w config.lisp"
  echotab "echo '(setq *clhs-root-default* \"${hyperspec}/\")' >> config.lisp"
  if [ ${TSYSOS} = cygwin ]; then
    # maybe convert the cygwin cygdrive pathnames
    # http://article.gmane.org/gmane.os.cygwin:67868
    DEVPREFIX=`mount -p | sed -nr '2s,/([^ ]+) +\S+ +\S+$,\1,p'`
    echotab "echo '(setq *device-prefix* \"${DEVPREFIX}\")' >> config.lisp"
  fi
fi
echol

if [ -n "$USE_GETTEXT" ] ; then
  localeflags='-B . -N locale'
else
  localeflags='-B .'
fi
if [ "${with_unicode}" != no ] ; then
  # make sure that no encoding is left as ASCII (the C locale encoding)
  # The first "-E" sets all encodings to UTF-8, so that we can read
  #   CLISP source files and dump everything to the terminal;
  #   this is also important for the regexp test suite.
  # The second "-E" ensures that syscalls tests pass (user names may be 8bit)
  encflags=' -E UTF-8 -Emisc 1:1'
  if [ "${TSYSOS}" != darwin ]; then # utf-8 on Darwin is good enough
    # The last "-E" ensures that we can parse all pathnames.
    encflags=${encflags}' -Epathname 1:1'
  fi
else
  encflags=''
fi
someflags=${encflags}' -norc'
echol "RUN= ${HERE}lisp${LEXE} ${localeflags}${someflags}"
echol

for f in ${LUTILS} ; do
  echol "${f}.fas : ${UTILDIR_M}${f}.lisp lisp${LEXE} lispinit.mem"
  echotab "\$(RUN) -M lispinit.mem -q -c ${UTILDIR}${f}.lisp -o ./"
  echol
done

# The strict minimum needed for building interpreted.mem is between 1400KW
# and 1500KW. To reduce GCs, we spend 30% more than this. 8MB is not a big deal.
MEMOPT="-m 2MW"

if [ $CROSS = false ] ; then

  if [ "$HSYS" = win32gcc ]; then
    # work around an msys "feature": ":" after "/" is converted to a ";"
    # <http://article.gmane.org/gmane.comp.gnu.mingw.msys/4281>
    # <http://article.gmane.org/gmane.lisp.clisp.devel/17589>
    # <http://article.gmane.org/gmane.lisp.clisp.devel/17895>
    SAFE_SRCDIR=`echo ${SRCDIR} | sed 's,/,\\\\\\\\,g'`
  else
    SAFE_SRCDIR=${SRCDIR}
  fi

  echol "interpreted.mem : lisp${LEXE} \$(LISPFILES) config.lisp"
  test $HOS != unix && echotab "-\$(RM) interpreted.mem"
  if [ $HSYSOS = beos ] ; then
    # Work around BeOS 5 kernel bug which causes subsequent invocations
    # of lisp${LEXE} to be incorrectly relocated. On BeOS, executables and
    # shared libraries are relocated page-by-page by a kernel routine.
    echotab "cp -p lisp${LEXE} lisp.tmp"
    echotab "mv lisp.tmp lisp${LEXE}"
  fi
  echotab "\$(RUN) ${MEMOPT} -lp ${SAFE_SRCDIR} -x '(and (load \"${SAFE_SRCDIR}init.lisp\") (sys::%saveinitmem) (ext::exit)) (ext::exit t)'"
  echotab "\$(MV) lispimag.mem interpreted.mem"
  echol

fi

if [ $CROSS = false ] ; then

  for f in $LPARTS ; do
    if [ $f = "compiler" ]; then
      image=interpreted.mem
    else
      image=halfcompiled.mem
    fi
    echol "${f}.fas : ${SRCDIR}${f}.lisp lisp${LEXE} $image"
    echotab "\$(RUN) ${MEMOPT} -M ${image} -q -c ${SRCDIR}${f}.lisp -o ./"
    echol
  done
  echol "config.fas : config.lisp lisp${LEXE} halfcompiled.mem"
  echotab "\$(RUN) ${MEMOPT} -M ${image} -q -c config.lisp"
  echol

  echol "halfcompiled.mem : lisp${LEXE} \$(LISPFILES) config.lisp compiler.fas"
  test $HOS != unix && echotab "-\$(RM) halfcompiled.mem"
  if [ $HSYSOS = beos ] ; then
    # Workaround BeOS 5 kernel bug, see explanation above.
    echotab "cp -p lisp${LEXE} lisp.tmp"
    echotab "mv lisp.tmp lisp${LEXE}"
  fi
  echotab "\$(RUN) ${MEMOPT} -lp ${SAFE_SRCDIR} -x '(and (load \"${SAFE_SRCDIR}init.lisp\") (sys::%saveinitmem) (ext::exit)) (ext::exit t)'"
  echotab "\$(MV) lispimag.mem halfcompiled.mem"
  echol

  echol "lispinit.mem : lisp${LEXE} \$(FASFILES)"
  test $HOS != unix && echotab "-\$(RM) lispinit.mem"
  if [ $HSYSOS = beos ] ; then
    # Workaround BeOS 5 kernel bug, see explanation above.
    echotab "cp -p lisp${LEXE} lisp.tmp"
    echotab "mv lisp.tmp lisp${LEXE}"
  fi
  echotab '$(RUN) -x "(and (load \"init.fas\") (ext::saveinitmem) (ext::exit)) (ext::exit t)"'
  echol

fi

echol

if [ -n "$USE_GETTEXT" ] ; then
  localeflags="-B ${HEREP} -N ${HERE_}locale"
else
  localeflags="-B ${HEREP}"
fi
CLISP_="${HERE_}lisp${LEXE} -M ${HERE_}lispinit.mem ${localeflags}${someflags}"

if [ $CROSS = false ] ; then
  CHECK_DEPS="check-recompile check-fresh-line check-script check-exec-image check-tests"

  echol "# check the sources:"
  echol "# 1. subr.d, fsubr.d and all the LISPFUNs must add up"
  echol "# 2. no variables of type gcv_object_t - only pointers to it"
  echol "check-sources : # lisp${LEXE} lispinit.mem"
  echotab '$(RUN) -M lispinit.mem -C -i '"${SRCDIR}"'check-lispfun.lisp -x "(check-lisp-defs \"'"${SRCDIR}"'\")"'
  echotab "if egrep ' var gcv_object_t *[^* ]' ${SRCDIR}*.d; then false; else true; fi"
  echol

  echol "# Test: recompile \$(LISPFILES) and compare their contents."
  echol "check-recompile : lispinit.mem ${RECOMPILEDIR} \$(TESTFASFILES)"
  if [ $HOS = unix -o $HSYS = win32gcc ] ; then
    for f in $LPARTS config; do
      echotab "cmp -s ${f}.fas ${RECOMPILEDIR}/${f}.fas "' || (echo "Test failed." ; exit 1)'
    done
    echotab 'echo "Test passed."'
    echol
  elif [ $HSYS = win32msvc ] ; then
    echotab "comp *.fas ${RECOMPILEDIR}"
    echotab "echo The test passed if only GENSYM differences were found."
    echol
  else
    echotab 'echo "Compare the .fas files by hand."'
    echol
  fi

  echol "${RECOMPILEDIR} :"
  echotab "-mkdir ${RECOMPILEDIR}"
  echol

  for f in $LPARTS; do
    echol "${RECOMPILEDIR}${NEXT_M}${f}.fas : ${SRCDIR}${f}.lisp lisp${LEXE} lispinit.mem"
    echotab "\$(RUN) -m 1MW -M lispinit.mem -q -d -c ${SRCDIR}${f}.lisp -o ${RECOMPILEDIR}${NEXT_}"
    echol
  done
  echol "${RECOMPILEDIR}${NEXT_M}config.fas : config.lisp lisp${LEXE} lispinit.mem"
  echotab "\$(RUN) -m 1MW -M lispinit.mem -q -d -c config.lisp -o ${RECOMPILEDIR}${NEXT_}"
  echol

  echol "lispinit2.mem : lisp${LEXE} \$(TESTFASFILES)"
  if [ $HSYSOS = beos ] ; then
    # Workaround BeOS 5 kernel bug, see explanation above.
    echotab "cp -p lisp${LEXE} lisp.tmp"
    echotab "mv lisp.tmp lisp${LEXE}"
  fi
  echotab '$(RUN) -x "(and (cd \"'"${RECOMPILEDIR}${NEXT}"'\") (load \"init.fas\") (cd \"'"${PARENT}"'\") (sys::%saveinitmem) (ext::exit)) (ext::exit t)"'
  echotab "-\$(RM) lispinit2.mem"
  echotab "\$(MV) lispimag.mem lispinit2.mem"
  echol

  echol

  # Check that fresh-line works, when clisp is used in batch mode (option -x)
  # and when the stdout and stderr are the same (2>&1), even when this output
  # is a pipe.
  # On win32, this test fails, and we cannot fix it, because given two pipe
  # handle for stdout and stderr, we cannot determine equality. Instead test
  # only the (easier) case of stdout and stderr going to a file.
  echol "check-fresh-line : lisp${LEXE} lispinit.mem"
  OBSOLETE="$OBSOLETE fresh-line.out"
  echotab "-\$(RM) fresh-line.out"
  if [ "$HOS" = win32 -o "$HSYS" = win32gcc ] ; then
    echotab "\$(RUN) -q -M lispinit.mem -x '(progn (dolist (s (quote (*terminal-io* *standard-output* *error-output* *query-io* *debug-io* *trace-output*))) (format t \"~S = ~S~%\" s (symbol-value s))) (values))' 2>&1 > fresh-line.out"
    for stream1 in '*terminal-io*' '*standard-output*' '*error-output*' '*query-io*' '*debug-io*' '*trace-output*'; do
      for stream2 in '*terminal-io*' '*standard-output*' '*error-output*' '*query-io*' '*debug-io*' '*trace-output*'; do
        echotab "\$(RUN) -q -M lispinit.mem -x '(progn (format ${stream1} \"~&Line1 to ${stream1}\") (format ${stream2} \"~&Line2 to ${stream2}\") (values))' 2>&1 >> fresh-line.out"
      done
    done
  else
    echotab "\$(RUN) -q -M lispinit.mem -x '(progn (dolist (s (quote (*terminal-io* *standard-output* *error-output* *query-io* *debug-io* *trace-output*))) (format t \"~S = ~S~%\" s (symbol-value s))) (values))' 2>&1 | cat > fresh-line.out"
    for stream1 in '*terminal-io*' '*standard-output*' '*error-output*' '*query-io*' '*debug-io*' '*trace-output*'; do
      for stream2 in '*terminal-io*' '*standard-output*' '*error-output*' '*query-io*' '*debug-io*' '*trace-output*'; do
        echotab "\$(RUN) -q -M lispinit.mem -x '(progn (format ${stream1} \"~&Line1 to ${stream1}\") (format ${stream2} \"~&Line2 to ${stream2}\") (values))' 2>&1 | cat >> fresh-line.out"
      done
    done
  fi
  echotab "if grep 'Line1.*Line2' fresh-line.out > /dev/null; then exit 1; fi"
  echotab "\$(RM) fresh-line.out"
  echol

  # check that the scripting works
  echol "check-script : lisp${LEXE} lispinit.mem"
  echotab "\$(RUN) -q -M lispinit.mem 0>/dev/null" # bug #[ 2805778 ]
  TRCR="| tr -d '\r'"; TRLF="| tr '\n' '_'"
  echotab "test \`echo '(princ (+ 11 99))' | \$(RUN) -q -M lispinit.mem - ${TRCR}\` = 110 || exit 1"
  echotab "test \"\`echo '(+ foo bar)' | \$(RUN) -q -M lispinit.mem -x '(setq foo 11 bar 99)' -repl ${TRCR}${TRLF}\`\" = '99_[1]> _110_' || exit 1"
  echotab "\$(RM) script.lisp; echo '(error \"loading script.lisp\")' > script.lisp"
  echotab "if \$(RUN) -q -M lispinit.mem -x '(load \"script.lisp\")' -repl < /dev/null; then exit 1; else :; fi"
  if [ "$HOS" != win32 ]; then # woe32 has unpredictable exit codes
    # http://article.gmane.org/gmane.lisp.clisp.devel/18967
    echotab "(echo '(progn (setf (stream-element-type *standard-input*) (quote (unsigned-byte 8))) (exit 42))' | \$(RUN) -q -M lispinit.mem -; test \$\$? = 42) || exit 1"
  fi
  if [ "${with_unicode}" = no ]; then
    seq42="(map (quote (vector (unsigned-byte 8))) (function char-code) \"42\")"
  else
    seq42='(convert-string-to-bytes "42" charset:ascii)'
  fi
  echotab "test \`echo '(setf (stream-element-type *standard-output*) (quote (unsigned-byte 8))) (write-sequence ${seq42} *standard-output*) (setf (stream-element-type *standard-output*) (quote character)) (terpri)' | \$(RUN) -q -M lispinit.mem - ${TRCR}\` = 42 || exit 1"
  echotab "\$(RM) script.lisp; echo '(+ 11 99)' > script.lisp"
  echotab "test \`\$(RUN) -q -M lispinit.mem < script.lisp ${TRCR}\` = 110 || exit 1"
  echotab "\$(RM) script.lisp; echo '(princ (+ 11 99))' > script.lisp"
  echotab "test \`\$(RUN) -q -M lispinit.mem script.lisp ${TRCR}\` = 110 || exit 1"
  echotab "\$(RM) script.lisp; echo '(+ foo bar)' > script.lisp"
  echotab "test \`\$(RUN) -q -M lispinit.mem -x '(setq foo 11 bar 99)' -repl < script.lisp ${TRCR}${TRLF}\` = 99_110_ || exit 1"
  # "-x with lisp-file is invalid"
  # echotab "\$(RM) script.lisp; echo '(princ (+ foo bar))' > script.lisp"
  # echotab "test \`\$(RUN) -q -M lispinit.mem -x '(setq foo 11 bar 99)' -repl script.lisp ${TRCR}${TRLF}\` = 99_110_ || exit 1"
  if [ "$HOS" != win32 ]; then # woe32 has unpredictable exit codes
    # http://article.gmane.org/gmane.lisp.clisp.devel/18967
    echotab "\$(RM) script.lisp; echo '(progn (setf (stream-element-type *standard-input*) (quote (unsigned-byte 8))) (exit 42))' > script.lisp"
    echotab "(\$(RUN) -q -M lispinit.mem < script.lisp; test \$\$? = 42) || exit 1"
    echotab "(\$(RUN) -q -M lispinit.mem script.lisp; test \$\$? = 42) || exit 1"
  fi
  echotab "\$(RM) script.lisp; echo '(setf (stream-element-type *standard-output*) (quote (unsigned-byte 8))) (write-sequence ${seq42} *standard-output*) (setf (stream-element-type *standard-output*) (quote character)) (terpri)' > script.lisp"
  # ??? echotab "test \`\$(RUN) -q -M lispinit.mem < script.lisp ${TRCR}\` = 42 || exit 1"
  echotab "test \`\$(RUN) -q -M lispinit.mem script.lisp ${TRCR}\` = 42 || exit 1"
  echotab "\$(RM) script.lisp; echo '(with-open-stream (s (make-stream :output :element-type (quote (unsigned-byte 8)))) (write-sequence ${seq42} s) (values))' > script.lisp"
  echotab "test \`\$(RUN) -q -M lispinit.mem < script.lisp ${TRCR}\` = 42 || exit 1"
  echotab "test \`\$(RUN) -q -M lispinit.mem script.lisp ${TRCR}\` = 42 || exit 1"
  echotab "\$(RM) script.lisp; nohup \$(RUN) -q -M lispinit.mem -x 42 2>&1 > script.lisp; test \`tail -n 1 script.lisp ${TRCR}\` = 42 || exit 1 "
  echotab "\$(RM) script.lisp"
  echol

  # check that the executable images work
  EXEIMG=foo
  OBSOLETE="$OBSOLETE ${EXEIMG}${HEXE} ${EXEIMG}.mem"
  echol "check-exec-image: lisp${LEXE} lispinit.mem"
  echotab '$(RUN) -M lispinit.mem -x "(saveinitmem \"'"${EXEIMG}"'\" :executable t :norc t)"'
  echotab "${HERE}${EXEIMG}${HEXE}"' -x "(setq zz 10) (saveinitmem \"'"${EXEIMG}"'\")"'
  # check that the executable image still honors -M
  echotab "${HERE}${EXEIMG}${HEXE} -norc -M ${EXEIMG}.mem -x zz"
  # check that *ARGS* do not seep from image to image (bug #[ 2788209 ])
  echotab '$(RUN) -M lispinit.mem -x "(saveinitmem \"'"${EXEIMG}"'\" :executable t :norc t :quiet t :init-function (lambda () (prin1 *args*) (exit)))" -- a 1'
  echotab "test \"\`${HERE}${EXEIMG}${HEXE} b ${TRCR}\`\" = '(\"b\")' || exit 1"
  echotab "test \"\`${HERE}${EXEIMG}${HEXE} b 2 ${TRCR}\`\" = '(\"b\" \"2\")' || exit 1"
  echotab "-ls -l lisp${LEXE} lispinit.mem ${EXEIMG}${HEXE} ${EXEIMG}.mem"
  echotab "\$(RM) ${EXEIMG}${HEXE} ${EXEIMG}.mem"
  echol

  echol "check-tests : ${TESTSDIR} lisp${LEXE} lispinit.mem"
  echotab "cd ${TESTSDIR} && \$(MAKE) SHELL='\$(SHELL)' LEXE=${LEXE}"
  echol
  echol "check-tests-all : ${TESTSDIR} lisp${LEXE} lispinit.mem"
  echotab "cd ${TESTSDIR} && \$(MAKE) SHELL='\$(SHELL)' LEXE=${LEXE} clean complete compare"
  echol
  if [ "${with_threads}" != no ]; then
    CHECK_DEPS=${CHECK_DEPS}" check-tests-parallel"
    echol "check-tests-parallel : ${TESTSDIR} lisp${LEXE} lispinit.mem"
    echotab "cd ${TESTSDIR} && \$(MAKE) SHELL='\$(SHELL)' LEXE=${LEXE} clean parallel compare"
    echol
  fi
  echol "${TESTSDIR} :"
  echotab "-mkdir ${TESTSDIR}"
  # on win32, LN_S=copy and it accepts exactly 2 arguments
  for f in Makefile '*.lisp' '*.tst'; do
    echotab "cd ${TESTSDIR} && \$(LN_S) ${PARENT_SRCTOPDIR_}tests${NEXT_}${f} ."
  done
  echol

  # sacla-tests are not included in the source distribution
  if test -d "${SRCTOPDIR_}sacla-tests"; then
    CHECK_DEPS=${CHECK_DEPS}" check-sacla-tests"
    SACLA_CLISP="../lisp${LEXE} -ansi -B .. -M ../lispinit.mem -N ../locale ${someflags} -i tests.lisp"
    echol "check-sacla-tests : ${SACLATESTSDIR} lisp${LEXE} lispinit.mem"
    echotab "cd ${SACLATESTSDIR} && ${SACLA_CLISP} -x '(ext:exit (plusp (run-all-tests)))'"
    echol
    echol "${SACLATESTSDIR} :"
    echotab "-mkdir ${SACLATESTSDIR}"
    # on win32, LN_S=copy and it accepts exactly 2 arguments
    for f in '*.lisp'; do
      echotab "cd ${SACLATESTSDIR} && \$(LN_S) ${PARENT_SRCTOPDIR_}sacla-tests${NEXT_}${f} ."
    done
    echol
  fi

  # ansi-tests are not included in the source distribution
  if test -d "${SRCTOPDIR_}ansi-tests"; then
    CHECK_DEPS=${CHECK_DEPS}" check-ansi-tests check-ansi-tests-compiled"
    ANSI_CLISP="../lisp${LEXE} -B .. -M ../lispinit.mem -N ../locale ${someflags} -m 30000KW -ansi -i clispload.lsp -p CL-TEST"
    echol "check-ansi-tests : ${ANSITESTSDIR} lisp${LEXE} lispinit.mem"
    echotab "cd ${ANSITESTSDIR} && ${ANSI_CLISP} -x '(time (regression-test:do-tests)) (ext:exit (regression-test:pending-tests))' 2>&1 | tee ../ansi-tests-log"
    echol
    echol "check-ansi-tests-debug : ${ANSITESTSDIR} lisp${LEXE} lispinit.mem"
    echotab "cd ${ANSITESTSDIR} && ${ANSI_CLISP}"
    echol
    echol "check-ansi-tests-compiled : ${ANSITESTSDIR} lisp${LEXE} lispinit.mem"
    echotab "cd ${ANSITESTSDIR} && ${ANSI_CLISP} -x '(setq regression-test::*compile-tests* t) (time (regression-test:do-tests)) (ext:exit (regression-test:pending-tests))' 2>&1 | tee ../ansi-tests-compiled-log"
    echol
    echol "check-ansi-tests-compiled-debug : ${ANSITESTSDIR} lisp${LEXE} lispinit.mem"
    echotab "cd ${ANSITESTSDIR} && ${ANSI_CLISP} -x '(setq regression-test::*compile-tests* t)' -repl"
    echol
    echol "${ANSITESTSDIR} :"
  # Do NOT update the ansi-tests directory automatically, because
  # 1. "make check-ansi-tests" would fail as soon as Paul Dietz adds a test
  #    that happens to fail in clisp. But we don't want to put out new releases
  #    on a weekly or monthly basis, nor do we want to get flooded by reports
  #    of failing "make check".
  # 2. 'svn' does not work on machines that are not connected to the internet.
  # 3. Makefile.devel does not work if 'make' is not GNU make.
  # echotab "cd ${SRCTOPDIR_} && \$(MAKE) -f Makefile.devel update-ansi-tests"
    echotab "-mkdir ${ANSITESTSDIR}"
    # on win32, LN_S=copy and it accepts exactly 2 arguments
    for f in Makefile '*.lsp'; do
      echotab "cd ${ANSITESTSDIR} && \$(LN_S) ${PARENT_SRCTOPDIR_}ansi-tests${NEXT_}${f} ."
    done
    echotab "cd ${ANSITESTSDIR} && \$(LN_S) ${PARENT_SRCTOPDIR_}utils${NEXT_}clispload.lsp ."
    echol
  fi

  # benchmarks are not included in the source distribution
  if [ -d "${SRCTOPDIR_}benchmarks" -a -n "${GNU_MAKE}" ]; then
    CHECK_DEPS=${CHECK_DEPS}" bench"
    echol "bench : ${BENCHDIR}"
    echotab "CLISP=\"`pwd`/clisp -norc\"; export CLISP; cd ${BENCHDIR}; \$(MAKE) CLISP=\"\$\$CLISP\" clisp"
    echol
    echol "${BENCHDIR} :"
    echotab "-mkdir ${BENCHDIR}"
    for f in Makefile '*.lisp'; do
      echotab "cd ${BENCHDIR} && \$(LN_S) ${PARENT_SRCTOPDIR_}benchmarks${NEXT_}${f} ."
    done
    echol
  fi

  # have .hg + developer with a network connection => check id-href.map
  # Try wget, lynx, curl in order. wget is common, but MacOS X only has curl.
  # use beta pages for the latest id-href.map
  # NB: keep in sync with doc/Makefile:DIST
  MYIMPROOT=http://clisp.podval.org/impnotes/
  # MYIMPROOT=http://clisp.org/beta/impnotes/
  MYTESTURL=${MYIMPROOT}id-href.map
  if test -d "${SRCTOPDIR_}.hg" \
     && { if wget --version >/dev/null 2>/dev/null ; then \
            wget --execute netrc=off --tries=1 --timeout=10 -q ${MYTESTURL}; \
          elif lynx --version >/dev/null 2>/dev/null ; then \
            lynx -connect_timeout=10 -source ${MYTESTURL} > id-href.map; \
          elif curl --version >/dev/null 2>/dev/null ; then \
            curl --max-time 10 --silent ${MYTESTURL} > id-href.map; \
          else false; \
          fi; \
        }; then
    rm -f id-href.map
    CHECK_DEPS=${CHECK_DEPS}" check-doc"
    echol "check-doc: clisp${TEXE} base"
    echotab "IMPNOTES=\"${MYIMPROOT}\" ./clisp ${someflags} -x '(sys::ensure-impnotes-map t)'"
    echol
  fi

  echol "# Perform self-tests."
  echol "check : ${CHECK_DEPS}"
  echodummyrule check
  echol
  echol
fi

if [ $XCC_GCC = true ] ; then
  echol "lispbibl.h :${EVERY_INCLUDES_C}${EVERY_INCLUDES_H}"
  echotab "((${XCPP} ${XCPPFLAGS} ${XCFLAGS} -P lispbibl.c | \$(GREP) -v \"^ *\$\$\") ; (${XCPP} ${XCPPFLAGS} ${XCFLAGS} -P -dM lispbibl.c | sort) ) > lispbibl.h"
  echol
  echol "gc : lispbibl.h # show GC-related definitions"
  echotab "egrep '[^[:alpha:]](MEMORY|SPVW|GC|SIGSEGV|SAFETY|ASM|FAST|DEBUG)[^[:alpha:]]' lispbibl.h | grep -v 'define _' | egrep '^#define'"
  echol
  echol
fi


echol "clisp.h clisp-test.c${CLISP_DEF} : genclisph.o config.h ${PARAMS_H}"
echotab_to_HEXE "\$(CC) \$(CFLAGS) \$(CLFLAGS)" "genclisph.o" "genclisph"
echotab "(echo '#ifndef _CLISP_H' ; echo '#define _CLISP_H' ; echo; echo '/* ==== config.h ==== */' ; cat config.h ) > clisp.h"
for parf in ${PARAMS_H}; do
  echotab "(echo; echo '/* '${parf}' */' ; grep '^#' ${parf} ) >> clisp.h"
done
echotab "(echo; echo '/* genclisph */' ; ${HERE}genclisph clisp-test.c ${CLISP_DEF}; echo ; echo '#endif /* _CLISP_H */') >> clisp.h"
echotab_to_HEXE "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS) -DUSE_CLISP_H=1 -DCOMPILE_STANDALONE" "clisp-test.c" "clisp-test-clisp"
echotab_to_HEXE "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS) -DUSE_CLISP_H=0 -DCOMPILE_STANDALONE" "clisp-test.c" "clisp-test-lispbibl"
echotab "${HERE}clisp-test-clisp > clisp-test-clisp.out"
echotab "${HERE}clisp-test-lispbibl > clisp-test-lispbibl.out"
if [ $HOS = unix -o $HSYS = win32gcc ]; then
  echotab  "cmp clisp-test-clisp.out clisp-test-lispbibl.out"
else
  echotab "comp clisp-test-clisp.out clisp-test-lispbibl.out"
fi
echotab "if grep lispbibl.d clisp.h; then false; else true; fi"
echotab "\$(RM) genclisph${HEXE} clisp-test-clisp${HEXE} clisp-test-lispbibl${HEXE} clisp-test-clisp.out clisp-test-lispbibl.out"
OBSOLETE="$OBSOLETE clisp-test.c genclisph${HEXE}"
echol
LINKKIT_SOURCES="${SRCDIR}modules.c clisp.h ${UTILDIR}modprep.lisp"
LINKKIT=''
echol "linkkit : ${LINKKIT_SOURCES}"
echotab "-\$(RMRF) linkkit"
echotab "mkdir linkkit"
for f in ${LINKKIT_SOURCES}; do
  b=`basename $f`
  d=`dirname $f`; d=`cd $d; pwd`
  LINKKIT="${LINKKIT} ${b}"
  echotab "cd linkkit && \$(LN_S) ${d}/${b} ${b}"
done
echol

# scripts in build-aux
MODULE_CONFIGURES=`find ${MODULESDIR_} -name configure`
BUILD_AUX_ALL=`grep '$ac_aux_dir/' ${MODULE_CONFIGURES} | sed 's,.*$ac_aux_dir/\([a-z.-]*\).*,\1,' | sort -u`
BUILD_AUX=''
# must have build-aux in build directory because it is the lisplibdir for
# building modules, see src/m4/general.m4:CL_MODULE_COMMON_CHECKS:
#   AC_CONFIG_AUX_DIR([$cl_cv_clisp_libdir/build-aux])
test -n "${SRCDIR}" && case "${LN_S}" in
  cp* )                         # ln is not available
    echol "build-aux : ${SRCDIR}build-aux"
    echotab "-\$(RMRF) build-aux"
    echotab "-cp -r ${SRCDIR}build-aux build-aux"
    echol
    ;;
  * ) link_dep "build-aux" "${SRCDIR}build-aux"
    ;;
esac
for f in ${BUILD_AUX_ALL}; do
  test -r ${SRCDIR}build-aux/$f && BUILD_AUX="${BUILD_AUX} $f"
done

test "${verbose}" = true -o "${verbose}" = yes && \
  echo "BUILD_AUX =${BUILD_AUX}" >&2

echol "modular : ${FILES} clisp-link linkkit modules.h modules.o makevars build-aux"
echodummyrule modular
echol
# while the top-level makevars can contain arbitrary paths in LIBS and FILES,
# makevars in each linking set (boot/base/full) must point to local files only
echol "makevars : Makefile"
echotab "(echo 'CC='\"'\"'\$(CC)'\"'\" ;\\"
echotab " echo 'CPPFLAGS='\"'\"'\$(MODULE_CPPFLAGS)'\"'\" ;\\"
echotab " echo 'CFLAGS='\"'\"'\$(${MODULE_CFLAGS_VAR})'\"'\" ;\\"
echotab " echo 'CLFLAGS='\"'\"'\$(${MODULE_CLFLAGS_VAR})'\"'\" ;\\"
echotab " echo 'LIBS='\"'\"'lisp.a${CLISP_DEF} \$(LIBS)'\"'\" ;\\"
echotab " echo 'X_LIBS='\"'\"'\$(X_LIBS)'\"'\" ;\\"
echotab " echo 'RANLIB='\"'\"'\$(RANLIB)'\"'\" ;\\"
echotab " echo 'FILES='\"'\"'${FILES}'\"'\") > makevars"
echol
for f in clisp-link ; do
  echol "${f} : ${SRCDIR}${f}.in"
  XCC_CREATESHARED_=`echo "$XCC_CREATESHARED" | sed -e 's,\\$,$$,g'`
  echotab "sed -e 's%@with_dynamic_modules@%${with_dynamic_modules}%' \\"
  echotab "    -e 's%@createsharedlib@%$XCC_CREATESHARED_%' \\"
  echotab "    -e 's%@LEXE@%${LEXE}%' -e 's%@SHREXT@%${SHREXT}%' \\"
  if test -z "${CLISP_DEF}"; then
    echotab "    -e 's%@CLISP_DEF@%%' \\"
  else
    echotab "    -e 's%@CLISP_DEF@%-L\$\$sourcedir${CLISP_DEF}%' \\"
  fi
  echotab "  < ${SRCDIR}${f}.in > ${f}"
  echotab "chmod a+x ${f}"
  echol
done
echol "boot : modular lispinit.mem"
echotab "test -d boot || (mkdir boot && cd boot && for f in ${FILES} modules.h modules.o lisp${LEXE} lispinit.mem; do \$(LN_S) ${PARENT_}\$\$f .; done && (\$(GREP) -v '^FILES=' ${PARENT_}makevars; fl=''; for f in ${FILES}; do fl=\$\$fl' '\`basename \$\$f\`; done; echo 'FILES='\"'\"\$\$fl\"'\") > makevars) || (\$(RMRF) boot ; exit 1)"
echol
# Some "make"s don't support empty target lists. Hence the "anymodule".
echol "anymodule \$(BASE_MODULES) \$(MODULES) : boot clisp${TEXE} linkkit force"
echotab 'mkdir -p $@'
echotab "m=\`cd ${MODULESDIR_}\$@; pwd\`; \\"
if [ "@TEST_NT@" = no ]; then # re-making a module requires rm -rf module
  newer(){ echo 'test -f $$m/'$1' -a '"'!'"' -f $@/'$2; }
else # re-making a module just works
  newer(){ echo 'test -f $$m/'$1' -a $$m/'$1' -nt $@/'$2; }
fi
# srcdir has to be passed to ./configure because it must be able to find
# src/build-aux/install-sh _AND_ also its own sources, thus we must
# point it to modules/... in the original source tree
echotab "if `newer configure config.status` ; then ( cd \$@ ;\\"
echotab "    cache="'`'"echo \$@/ | sed -e 's,[^/][^/]*//*,../,g'"'`'"config.cache; \\"
echotab "    if test -f \$\${cache} ; then \\"
echotab "      . \$\${cache}; \\"
for var in ${PRECIOUS_VARS}; do
  echotab "      if test \"\$\${ac_cv_env_${var}_set}\" = set; then ${var}=\"\$\${ac_cv_env_${var}_value}\"; export ${var}; fi; \\"
done
# we must use $(SHELL) for sub-configures because when the top CONFIG_SHELL
# is bash, config.cache may be unparsable with sh on Solaris
echotab "      \$(SHELL) \$\$m/configure --with-clisp=\"${HEREP}/clisp -K boot ${someflags}\" --cache-file=\$\${cache} --srcdir=\$\$m \$(MODULE_CONFIGURE_FLAGS);\\"
echotab "    else \\"
echotab "      \$(SHELL) \$\$m/configure --srcdir=\$\$m \$(MODULE_CONFIGURE_FLAGS); \\"
echotab "    fi ) ;\\"
echotab "fi; \\"
# srcdir must be correct in Makefile because clisp-link calls link.sh
# which cannot pass srcdir to make on the command line
echotab "`newer Makefile Makefile` && sed \"s,srcdir = .,srcdir = \$\$m,\" \"\$\$m/Makefile\" > \$@/Makefile ; \\"
echotab "CLISP=\"${HEREP}/clisp -K boot ${someflags}\" ; \\"
echotab "cd \$@ ; \$(MAKE) clisp-module CC=\"\$(CC)\" CPPFLAGS=\"\$(MODULE_CPPFLAGS)\" CFLAGS=\"\$(${MODULE_CFLAGS_VAR})\" CLFLAGS=\"\$(${MODULE_CLFLAGS_VAR})\" LIBS=\"\$(LIBS)\" RANLIB=\"\$(RANLIB)\" CLISP=\"\$\$CLISP -q\" SHREXT=${SHREXT}"
echol

cygwin_finish() {
  # make sure no cygwin libraries crept into the mingw distribution
  if [ "$host_os" = cygwin -a "${TSYS}" = win32gcc ]; then
    # cygcheck can fail with symlinks so resolve them
    # 'cyg[^/\\\\]*\$\$' here should look as 'cyg[^/\]*$' for grep
    echotab "if cygcheck \`realpath $1/lisp.exe | cygpath --windows -f -\` | grep 'cyg[^/\\\\]*\$\$'; then false; else true; fi"
  fi
  finish_runtime $1/lisp${LEXE}
}

# base is always linked statically
echol "base : modular boot \$(BASE_MODULES)"
echotab "\$(RMRF) base"
echotab "MAKE=\$(MAKE) CLISP=\"${HEREP}/clisp -K boot ${someflags}\" with_dynamic_modules=no ${HERE}clisp-link add boot base \$(BASE_MODULES) || (\$(RMRF) base ; exit 1)"
cygwin_finish base

# full is built dynamically unless explicitly requested otherwise
echol "full : modular base \$(MODULES)"
echotab "\$(RMRF) full"
test "${with_dynamic_modules}" = no || echotab "rm -rf dynmod; mkdir dynmod"
echotab "MAKE=\$(MAKE) CLISP=\"${HEREP}/clisp ${someflags}\" ${HERE}clisp-link add base full \$(MODULES) || (\$(RMRF) full ; exit 1)"
# show which system supplied functionality is replaced by gnulib
test "${verbose}" = true -o "${verbose}" = yes && \
  echotab 'grep "^REPLACE_.*='"'1'"'" `find . -name config.log` || true'
cygwin_finish full

echol "mod-check : base-mod-check full-mod-check"
echol
modcheck(){                     # $1=clisp command; $2=MODULES variable
  echotab 'for m in "" $('$2'); do test -n "$$m" && $(RM) $$m/*.erg; done'
  echotab 'z=""; for m in "" $('$2'); do test -n "$$m" && z=$$z" \""$$m/\"; done; '"$1${someflags} -C -i ${TESTSDIR}/tests"' -x "(ext:exit (plusp (or (run-some-tests :dirlist '"'"'($$z) :srcdir \"'${MODULESDIR_}'\" :outdir \"./\") 0)))"'
  echol
}
echol "base-mod-check : clisp${TEXE} ${TESTSDIR} # base"
modcheck "./clisp" BASE_MODULES
echol "full-mod-check : clisp${TEXE} ${TESTSDIR} # full"
if [ "${with_dynamic_modules}" = no ]; then
  modcheck "./clisp -K full" MODULES
else
  modcheck "./clisp" MODULES
fi

manual_print=''
if test -n "$GROFF"; then
  for f in ${MANPAGES}; do
    manual_print="${manual_print} $f.ps"
    test -n "$PS2PDF" && manual_print="$manual_print $f.pdf"
  done
fi
TOP_DOC="ANNOUNCE COPYRIGHT GNU-GPL SUMMARY"
READMES="${TOP_DOC} NEWS README README.de README.es"
test $TOS = unix && READMES=${READMES}' MAGIC.add'
test ${HSYSOS} = cygwin && READMES=${READMES}' cygwin.README'
echol "READMES = ${READMES}"
IMPNOTES_FILES="impnotes.html impnotes.css clisp.png"
test ${HOS} = win32 && IMPNOTES_FILES=${IMPNOTES_FILES}" clisp.ico"
echol "IMPNOTES_FILES = ${IMPNOTES_FILES}"
manpages1html=''
manpages_less=''
for f in ${MANPAGES}; do
  manpages1html="${manpages1html} $f.1 $f.html";
  manpages_less="${manpages_less} $f.man";
done
echol "MANUALS =${manpages1html} \$(TXTFILES) \$(IMPNOTES_FILES)"
echol
for f in ${IMPNOTES_FILES} ${TXT_DOCS}; do
  link_dep "${f}" "${SRCDOCDIR_M}${f}" "${SRCDOCDIR_}${f}"
done
EMACS_FILES="clhs.el clisp-coding.el clisp-indent.el clisp-indent.lisp clisp-ffi.el"
VIM_FILES="lisp.vim"
ACLOCAL_FILES="clisp.m4"

# On Unix, clisp.ps & clisp.pdf must be built by "make all",
# because "make install" needs it and "make install" must not create files in
# the current directory, for compliance with the GNU standards.
# On other OSes, clisp.ps & clisp.pdf must be built manually on another
# machine, so don't make it part of "make all".
if [ $HOS = unix ] ; then
  echol "manual : \$(READMES) \$(MANUALS) ${manual_print}"
  echodummyrule manual
  echol
  echol "manualx : manual${manpages_less}"
  echodummyrule manualx
  echol
else
  echol "manual : \$(READMES) \$(MANUALS)"
  echodummyrule manual
  echol
  echol "manualx : manual${manpages_less} ${manual_print}"
  echodummyrule manualx
  echol
fi

for f in ${TOP_DOC} ; do
  link_dep "${f}" "${SRCTOPDIR_M}${f}" "${SRCTOPDIR_}${f}"
done

if [ -n "${SRCDIR}" ] ; then
  for f in NEWS .gdbinit ; do
    echol "${f} : ${SRCDIR}${f}"
    if [ $f = .gdbinit -a $LEXE != ".run" ]; then
      echotab "sed 's/lisp.run/lisp$LEXE/g' ${SRCDIR}${f} > ${f}"
    else
      echotab "-\$(LN_S) ${SRCDIR}${f} ${f}"
    fi
    echol
  done
fi

if [ $TOS = unix ] ; then
  for f in MAGIC.add ; do
    link_dep "${f}" "${SRCTOPDIR}unix${NEXT}${f}"
  done
fi

for f in $TXT_FILES ; do
  depends=''
  flags=' -DCOMPILE_STANDALONE'
  test $f = README && depends=$depends" ${SRCDIR}_${f}.de ${SRCDIR}_${f}.en"
  platform_line=""
  case $f in
    clisp.html | clisp.1 | clisp-1.html | \
    clisp-link.html | clisp-link.1 | clisp-link-1.html )
      if [ $HOS = win32 ]; then
        platform_line=" | sed -e \"s,@PLATFORM@,${TSYS},g\""
      else
        platform_line=" | sed -e \"s,@PLATFORM@,${host},g\""
      fi
      sourcedir=${SRCDOCDIR} ;;
    *) sourcedir=${SRCDIR} ;;
  esac
  echol "${f} : ${sourcedir}_${f}${TXT_INCLUDES}${depends} txt2c${HEXE}"
  echotab "\$(TXT2C) < ${sourcedir}_${f} > txt.c"
  echotab_to_HEXE "\$(CC) \$(CPPFLAGS) \$(CFLAGS)${flags} \$(CLFLAGS)${XCC_NOOPTFLAGS}" "txt.c" "txt"
  line="${HERE}txt"
  test $f = clisp.1 -o $f = clisp-link.1 && \
    line=$line" | \$(GREP) -v ${ARGQ1}^ *\$\$${ARGQ1}"
  # *-1.html is for chunked impnotes and does not depend on user hyperspec
  test \( $f = clisp.html -o $f = clisp-link.html \) \
       -a "${HSDEFAULT}" != "${hyperspec}" && \
    line=$line" | sed -e ${ARGQ}s,=${QQUOT}${HSDEFAULT}/,=${QQUOT}${hyperspec}/,${ARGQ}"
  test $f = distmakefile && line=$line" | sed -e \"s,@@LEXE@@,${LEXE},g\" -e \"s:@@EXPORT_DYNAMIC_FLAG_SPEC@@:${EXPORT_DYNAMIC_FLAG_SPEC}:g\""
  line=$line$platform_line
  echotabpipe "${line} > ${f}"
  echotab "\$(RM) txt.c"
  echotab "\$(RM) txt${HEXE}"
  echol
done
OBSOLETE=$OBSOLETE" txt.c txt${HEXE}"

for f in ${MANPAGES}; do
  if test -n "$GROFF"; then
    echol "$f.ps : $f.1"
    echotab "-\$(ROFF_PS) $f.1 > $f.ps"
    echol
    if test -n "$PS2PDF"; then
      echol "$f.pdf : $f.ps"
      echotab "-\$(PS2PDF) $f.ps $f.pdf"
      echol
    fi
  fi
  echol "$f.man : $f.1"
  echotab "\$(ROFF_MAN) $f.1 > $f.man"
  echol
done

if [ $CROSS = false ] ; then
  DRIVER_DEP=''; DRIVER_RES=''
  if [ $HOS = win32 ]; then
    DRIVER_RES=" clispres${TOBJ}"
    DRIVER_DEP=${DRIVER_RES}" ${SRCDIR}w32shell.c ${SRCDIR}execname.c"
    echol "clispres${TOBJ} : clisp.rc clisp.ico"
    if [ ${TSYS} = win32gcc ]; then
      echotab "windres -i clisp.rc -o clispres.o"
    else
      echotab "rc /v /foclisp.res clisp.rc"
      echotab "cvtres /verbose /out:clispres.obj clisp.res"
      echotab "-\$(RM) clisp.res"
    fi
    echol
    # NB: we link clisp.rc into the driver clisp.exe but _not_ into the
    #     run-time lisp.exe because then the latter does not have an icon
    #     and the users are less likely to run it without the memory image
    echol "clisp.rc : ${SRCDIR}clisp.rc.in Makefile"
    PRODUCTVERSION=`echo ${VERSION_NUMBER} | sed -e 's/\./,/' -e 's/\+/,1/g'`
    if [ "${with_debug}" != no ]
    then FILEFLAGS="VS_FF_DEBUG|"
    else FILEFLAGS=""
    fi
    case "${PRODUCTVERSION}" in
      *,1,1 ) FILEFLAGS=${FILEFLAGS}"VS_FF_PRERELEASE|VS_FF_PATCHED" ;;
      *,1 ) PRODUCTVERSION=${PRODUCTVERSION}',0'
        FILEFLAGS=${FILEFLAGS}"VS_FF_PATCHED" ;;
      * ) PRODUCTVERSION=${PRODUCTVERSION}',0,0' ;;
    esac
    if [ "${with_unicode}" != no ];
    then CHARSET=04B0           # Unicode
    else CHARSET=0000           # 7-bit ASCII
    fi
    echotab "sed -e 's/\@CLISP_PRODUCTVERSION\@/${PRODUCTVERSION}/g' \\"
    echotab "    -e 's/\@CLISP_FILEFLAGS\@/${FILEFLAGS}/g' \\"
    echotab "    -e 's/\@CLISP_CHARSET\@/${CHARSET}/g' \\"
    echotab "    -e 's/\@CLISP_NAME\@/\$(PACKAGE_NAME)/g' \\"
    echotab "    -e 's/\@CLISP_VERSION\@/\$(PACKAGE_VERSION)/g' \\"
    echotab "    ${SRCDIR}clisp.rc.in > clisp.rc"
    echol
  fi
  DRIVERFLAGS=''
  case "$host_os" in
    hpux*)
      # gcc-2.95.2 on HP-UX 10 miscompiles clisp.c when optimization -O is used.
      test $XCC_GCC = true && DRIVERFLAGS=' -O0'
      ;;
  esac
  echol "clisp${TEXE} : clisp.c${DRIVER_DEP}"
  echotab "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS)${DRIVERFLAGS} -DENABLE_RELOCATABLE clisp.c${DRIVER_RES} ${LIBS} ${OUT}clisp${TEXE}"
  echol
  if [ $HOS = unix ] ; then
    echol "install : install-bin install-man install-doc"
    echodummyrule install
    echol
    echol "installdirs : force"
    echotab "mkdir -p \$(DESTDIR)\$(prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(exec_prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(libdir)"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/data"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/linkkit"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/base"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/full"
    echotab "mkdir -p \$(DESTDIR)\$(bindir)"
    test -n "$USE_GETTEXT" && \
      echotab "cd po && \$(MAKE) installdirs DESTDIR='\$(DESTDIR)' prefix='\$(prefix)' exec_prefix='\$(exec_prefix)'"
    echotab "mkdir -p \$(DESTDIR)\$(datarootdir)"
    echotab "mkdir -p \$(DESTDIR)\$(elispdir)"
    echotab "mkdir -p \$(DESTDIR)\$(vimdir)"
    echotab "mkdir -p \$(DESTDIR)\$(aclocaldir)"
    echotab "mkdir -p \$(DESTDIR)\$(mandir)"
    echotab "mkdir -p \$(DESTDIR)\$(mandir)/man1"
    case "$fsstnd" in
      gnu_ext)
        echotab "mkdir -p \$(DESTDIR)\$(htmldir)"
        echotab "mkdir -p \$(DESTDIR)\$(psdir)"
        echotab "mkdir -p \$(DESTDIR)\$(pdfdir)"
        ;;
      *bsd)
        echotab "mkdir -p \$(DESTDIR)\$(docdir)"
        ;;
    esac
    echotab "mkdir -p \$(DESTDIR)\$(docdir)"
    case "$fsstnd" in
      *bsd)
        ;;
      *)
        echotab "mkdir -p \$(DESTDIR)\$(docdir)/doc"
        ;;
    esac
    echol
    if [ "${with_dynamic_modules}" != no ]; then
      depends="full install-modules force"
      line='linkkit base'
      echol "install-modules : full force"
      echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/dynmod"
      echotab "DESTDIR=\`cd \"\$(DESTDIR)\$(lisplibdir)\"; pwd\` CLISP='./clisp -q -norc' ./clisp-link install \$(MODULES)"
      echol
    else
      depends="full force"
      line='linkkit base full'
    fi
    echol "install-bin : ${depends}"
    echotab "mkdir -p \$(DESTDIR)\$(prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(exec_prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(libdir)"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/data"
    for f in ${DATA_FILES}; do
      echotab "\$(INSTALL_DATA) data/${f} \$(DESTDIR)\$(lisplibdir)/data/${f}"
    done
    echotab "(cd \$(DESTDIR)\$(lisplibdir) && \$(RMRF) base full)"
    echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/build-aux"
    echotab "for f in ${BUILD_AUX}; do \$(INSTALL_DATA) build-aux/\$\$f \$(DESTDIR)\$(lisplibdir)/build-aux/\$\$f; done"
    echotab "for d in ${line}; do for f in \$\$d/*; do \\"
    echotab "  mkdir -p \$(DESTDIR)\$(lisplibdir)/\$\$d; \\"
    echotab "  case \$\$f in \\"
    echotab "    */lisp${LEXE}) \$(INSTALL_PROGRAM) \$\$f \$(DESTDIR)\$(lisplibdir)/\$\$f;; \\"
    echotab "    *) \$(INSTALL_DATA) \$\$f \$(DESTDIR)\$(lisplibdir)/\$\$f;; \\"
    echotab "  esac; \\"
    echotab "done; done"
    echotab "mkdir -p \$(DESTDIR)\$(bindir)"
    echotab "\$(INSTALL_SCRIPT) clisp-link \$(DESTDIR)\$(bindir)/clisp-link"
    # Don't strip the executables, otherwise (disassemble #'cons)
    # and saveinitmem/:executable won't work.
    # echotab "strip \$(DESTDIR)\$(lisplibdir)/base/lisp${LEXE}"
    test -n "$USE_GETTEXT" && \
      echotab "cd po && \$(MAKE) install DESTDIR='\$(DESTDIR)' prefix='\$(prefix)' exec_prefix='\$(exec_prefix)'"
    echotab "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS)${DRIVERFLAGS} -DLISPLIBDIR='\"\$(lisplibdir)\"' -DLOCALEDIR='\"\$(localedir)\"' clisp.c -o \$(DESTDIR)\$(bindir)/clisp"
    echotab "mkdir -p \$(DESTDIR)\$(elispdir)"
    for f in ${EMACS_FILES}; do
      echotab "\$(INSTALL_DATA) ${SRCTOPDIR}emacs/$f \$(DESTDIR)\$(elispdir)/$f"
    done
    echotab "mkdir -p \$(DESTDIR)\$(vimdir)"
    for f in ${VIM_FILES}; do
      echotab "\$(INSTALL_DATA) ${SRCTOPDIR}emacs/$f \$(DESTDIR)\$(vimdir)/$f"
    done
    echotab "mkdir -p \$(DESTDIR)\$(aclocaldir)"
    for f in ${ACLOCAL_FILES}; do
      echotab "\$(INSTALL_DATA) ${SRCDIR}m4/$f \$(DESTDIR)\$(aclocaldir)/$f"
    done
    echol
    echol "install-man : ${manpages1html} ${manual_print} force"
    echotab "mkdir -p \$(DESTDIR)\$(prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(exec_prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(datarootdir)"
    echotab "mkdir -p \$(DESTDIR)\$(mandir)"
    echotab "mkdir -p \$(DESTDIR)\$(mandir)/man1"
    for f in ${MANPAGES}; do
      echotab "\$(INSTALL_DATA) $f.1 \$(DESTDIR)\$(mandir)/man1/$f.1"
    done
    case "$fsstnd" in
      gnu_ext)
        echotab "mkdir -p \$(DESTDIR)\$(htmldir)"
        echotab "mkdir -p \$(DESTDIR)\$(psdir)"
        echotab "mkdir -p \$(DESTDIR)\$(pdfdir)"
        for f in ${MANPAGES}; do
          echotab "\$(INSTALL_DATA) $f.html \$(DESTDIR)\$(htmldir)/$f.html"
          if test -n "$GROFF"; then
            echotab "\$(INSTALL_DATA) $f.ps  \$(DESTDIR)\$(psdir)/$f.ps"
            test -n "$PS2PDF" && \
              echotab "\$(INSTALL_DATA) $f.pdf \$(DESTDIR)\$(pdfdir)/$f.pdf"
          fi
        done
        ;;
      *bsd)
        echotab "mkdir -p \$(DESTDIR)\$(docdir)"
        for f in ${MANPAGES}; do
          echotab "\$(INSTALL_DATA) $f.html \$(DESTDIR)\$(docdir)/$f.html"
        done
        ;;
    esac
    echol
    echol "install-doc : \$(READMES) \$(MANUALS) ${manual_print} force"
    echotab "mkdir -p \$(DESTDIR)\$(prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(exec_prefix)"
    echotab "mkdir -p \$(DESTDIR)\$(docdir)"
    echotab "\$(INSTALL_DATA) \$(READMES) \$(DESTDIR)\$(docdir)/"
    case "$fsstnd" in
      *bsd)
        echotab "\$(INSTALL_DATA) \$(MANUALS) ${manual_print} \$(DESTDIR)\$(docdir)/"
        ;;
      *)
        echotab "mkdir -p \$(DESTDIR)\$(docdir)/doc"
        echotab "\$(INSTALL_DATA) \$(MANUALS) ${manual_print} \$(DESTDIR)\$(docdir)/doc/"
        ;;
    esac
    if [ ${HSYSOS} = cygwin ]; then
      echotab "mkdir -p \$(DESTDIR)\$(docdir)/../Cygwin"
      echotab "\$(INSTALL_DATA) cygwin.README \$(DESTDIR)\$(docdir)/../Cygwin/clisp-\$(VERSION).README"
    fi
    echol
    echol
    echol "installcheck : ${TESTSDIR} force"
    echotab "cd ${TESTSDIR} && \$(MAKE) LISP=\"\$(bindir)/clisp ${someflags}\""
    echol
    echol
    echol "uninstall : uninstall-bin uninstall-man"
    echodummyrule uninstall
    echol
    echol "uninstall-bin : force"
    echotab "\$(RMRF) \$(DESTDIR)\$(lisplibdir)"
    if [ ${HSYSOS} = cygwin ]; then
      echotab "\$(RM) \$(DESTDIR)\$(docdir)/Cygwin/clisp-\$(VERSION).README"
      echotab "\$(RM) \$(DESTDIR)\$(bindir)/clisp.exe"
    else
      echotab "\$(RM) \$(DESTDIR)\$(bindir)/clisp"
    fi
    echotab "\$(RM) \$(DESTDIR)\$(bindir)/clisp-link"
    test -n "$USE_GETTEXT" && \
      echotab "cd po && \$(MAKE) uninstall DESTDIR='\$(DESTDIR)' prefix='\$(prefix)' exec_prefix='\$(exec_prefix)'"
    echol
    echol "uninstall-man : force"
    for f in ${MANPAGES}; do
      echotab "\$(RM) \$(DESTDIR)\$(mandir)/man1/$f.1"
      case "$fsstnd" in
        gnu_ext)
          echotab "\$(RM) \$(DESTDIR)\$(htmldir)/$f.html"
          echotab "\$(RM) \$(DESTDIR)\$(psdir)/$f.ps"
          echotab "\$(RM) \$(DESTDIR)\$(pdfdir)/$f.pdf"
          ;;
      esac
    done
    echotab "\$(RMRF) \$(DESTDIR)\$(docdir)"
    for f in ${EMACS_FILES}; do
      echotab "\$(RMRF) \$(DESTDIR)\$(elispdir)/$f*"
    done
    for f in ${VIM_FILES}; do
      echotab "\$(RMRF) \$(DESTDIR)\$(vimdir)/$f"
    done
    for f in ${ACLOCAL_FILES}; do
      echotab "\$(RMRF) \$(DESTDIR)\$(aclocaldir)/$f"
    done
    echol
    echol
  fi
fi

echo_dist_modules () {
  echotab "for module in '' \$(BASE_MODULES) \$(MODULES); do if test -n \"\$\$module\"; then \\"
  echotab "  (dir=$1/ ; for subdir in "'`'"echo \$\$module/ | sed -e 's,/, ,g'"'`'" ; do dir=\$\${dir}\$\${subdir} ; test -d \$\${dir} || mkdir \$\${dir} ; dir=\$\${dir}/ ; done ; cd \$\$module ; \$(MAKE) SHREXT=${SHREXT} clisp-module-distrib distribdir=$1/\$\$module/ LN="$2") \\"
  echotab "fi; done$3"
}
if [ ${HSYSOS} = cygwin ]; then
  echol "full/lisp.exe : full"
  echol
  echol "# Makefile: \$(MODULES)"
  echol "# full/lisp.exe: dependencies"
  echol "setup.hint : SUMMARY # Makefile full/lisp.exe"
  echotab "\$(RM) setup.hint"
  echol "# normally curr/prev/test are not needed"
  echol "# but if one is present, at least curr+prev are required"
  echol "# echo 'curr : \$(VERSION)-1' >> setup.hint"
  echol "# echo 'prev : \$(VERSION)-1' >> setup.hint"
  echol "# echo 'test : \$(VERSION)-1' >> setup.hint"
  echotab "echo 'sdesc: \"an ANSI Common Lisp implementation\"' >> setup.hint"
  echotab "echo 'category: Devel Interpreters Math Shells' >> setup.hint"
  echotab 'REQ=""; for f in `cygcheck full/lisp.exe`; do echo "* "$$f; f=`cygpath -u $$f`; REQ=$${REQ}" "`cygcheck -f $$f|sed "s/-.*//"`; done; REQ=`echo $${REQ} | tr " " "\012" | sort -u`; echo "="$${REQ}; echo "requires: "$${REQ} >> setup.hint'
  echotab "echo 'ldesc: \"' >> setup.hint"
  echotab "cat SUMMARY >> setup.hint"
  echotab "echo >> setup.hint"
  echotab "echo 'This binary distribution was built with the following modules:' >> setup.hint"
  echotab "echo ' '\$(MODULES) >> setup.hint"
  echotab "echo '\"' >> setup.hint"
  echol
  echol "cygwin.README : setup.hint makemake"
  echotab "echo 'CLISP: an ANSI Common Lisp implementation' > cygwin.README"
  echotab "echo '' >> cygwin.README"
  echotab "grep requires setup.hint >> cygwin.README"
  echotab "echo 'recommended: libsigsegv http://sourceforge.net/projects/libsigsegv' >> cygwin.README"
  echotab "echo '' >> cygwin.README"
  echotab "echo 'builds \"out of the box\" on cygwin:' >> cygwin.README"
  echotab "echo './configure$makemake_args --cbc --install build-cygwin' >> cygwin.README"
  echotab "echo 'will configure, build and install CLISP' >> cygwin.README"
  echotab "echo 'see unix/INSTALL for details' >> cygwin.README"
  echotab "echo '' >> cygwin.README"
  echotab "cat SUMMARY >> cygwin.README"
  echol
  echol "CLISP_VR=\$(TOPDIR)-1"
  echol "CLISP_SCRIPT=\$(CLISP_VR).sh"
  echol "CLISP_CYGWIN=\$(TOPDIR)-cygwin-${UNAME_R}.tar.bz2"
  echol "DEST_TMP=/tmp/clisp-install"
  echol "distrib : setup.hint cygwin.README force"
  echotab "\$(RMRF) \$(DEST_TMP) \$(CLISP_VR).tar.bz2; mkdir -p \$(DEST_TMP)"
  echotab "\$(MAKE) install prefix=/usr DESTDIR=\$(DEST_TMP)"
  echotab "builddir=\"\`pwd\`\"; cd \$(DEST_TMP); tar cvfj \"\$\$builddir\"/\$(CLISP_CYGWIN) *"
  echotab "ln \$(CLISP_CYGWIN) \$(CLISP_VR).tar.bz2"
  echotab "\$(RMRF) \$(DEST_TMP)"
  echol
  echol "TAR_SRC=\"../../archives/\$(VERSION)/\$(TOPDIR).tar.bz2\""
  echol "cygwin-src : setup.hint force"
  echotab "touch \$(CLISP_VR).patch"
  echotab "echo '#!/bin/sh' > \$(CLISP_SCRIPT)"
  echotab "echo './configure$makemake_args --cbc build-cygwin' >> \$(CLISP_SCRIPT)"
  echotab "echo 'cd build-cygwin' >> \$(CLISP_SCRIPT)"
  echotab "echo 'make distrib' >> \$(CLISP_SCRIPT)"
  echotab "ln -s \$(TAR_SRC) ."
  echotab "tar cvfjh \$(CLISP_VR)-src.tar.bz2 \$(CLISP_SCRIPT) \$(CLISP_VR).patch setup.hint cygwin.README \$(TOPDIR).tar.bz2"
  echotab "\$(RMRF) \$(TOPDIR).tar.bz2 \$(CLISP_SCRIPT) \$(CLISP_VR).patch"
  echol
elif [ ${HOS} = unix ] ; then   # but not cygwin!
COMPRESS=@COMPRESS@
if [ -z "${COMPRESS}" ]; then
  echol "# tar"
  echol "PACKEXT=.tar"
else
  echol "# tar+gzip"
  echol "PACKEXT=.tar.gz"
  echol "COMPRESS=${COMPRESS}"
fi
echol
echol "# Temporary directory for packing"
echol "PACKDIR = ."
echol
echol "# Distribution file"
echol "DISTFILE=\$(PACKDIR)/\$(TOPDIR)-${host}-${UNAME_R}\$(PACKEXT)"
echol
needs='all'
if test "$HLN" != ln; then
  needs=$needs' hln'
  echol "hln : ${SRCTOPDIR}utils/hln.lisp"
  echotab "-\$(RM) hln"
  echotab "sed 's,@''CLISP''@,`pwd`/clisp,' ${SRCTOPDIR}utils/hln.lisp > hln"
  echotab "chmod +x hln"
  echol
fi
# hln merges pathnames, which means that if the source pathname is absolute,
# the destination must be absolute as well!
echol "FULLTOPDIR = `pwd`/\$(TOPDIR)"
echol "distrib : force $needs modular manualx clisp.c distmakefile"
echotab "\$(RMRF) \$(TOPDIR) \$(DISTFILE) clisp\$(PACKEXT)"
echotab "mkdir \$(TOPDIR)"
# General documentation files.
echotab "${HLN} ${READMES} \$(TOPDIR)/"
# The linking sets: base and full.
for dir in base full; do
  echotab "mkdir \$(TOPDIR)/${dir}"
  echotab "${HLN} "'`'". ${dir}/makevars ; for f in \$\$FILES modules.h modules.o makevars lispinit.mem ; do echo ${dir}/\$\$f ; done"'`'" \$(TOPDIR)/${dir}/"
  # make sure base & full do not link to anything outside
  echotab ". ./makevars; for f in \$\$LIBS ; do case \$\$f in -*) ;; \\"
  echotab "   *) b=\`basename \$\$f\`; \\"
  echotab "      if test ! -f ${dir}/\$\$b; then \\"
  if [ "${dir}" = base ]; then
    echotab "        ${HLN} \$\$f \$(FULLTOPDIR)/${dir}/; fi; \\"
  else
    echotab "        if test -f base/\$\$b; then \\"
    echotab "          ${HLN} base/\$\$b \$(FULLTOPDIR)/${dir}/; \\"
    echotab "        else \\"
    echotab "          ${HLN} \$\$f \$(FULLTOPDIR)/${dir}/; fi; \\"
    echotab "        fi ;; \\"
  fi
  echotab "esac ; done"
  if test -n "$BINARY_DISTRIB"; then
    echotab "cp ${dir}/lisp${LEXE} \$(TOPDIR)/${dir}/lisp${LEXE}"
    # Don't strip the executable, otherwise (disassemble #'cons)
    # and (saveinitmem ... :executable t) won't work.
    # echotab "strip \$(TOPDIR)/${dir}/lisp${LEXE}"
    echotab "chmod a+x \$(TOPDIR)/${dir}/lisp${LEXE}"
  fi
done
# The Makefile, generated from distmakefile.
if test -z "$BINARY_DISTRIB"; then
  echotab "cat distmakefile \\"
  for dir in base full; do
    DIR=`echo "${dir}" | tr '[a-z]' '[A-Z]'`
    echotab "| { . ${dir}/makevars ; ${dir}_files='' ; \\"
    echotab " for f in modules.o \$\$FILES ; do \\"
    echotab "   ${dir}_files=\"\$\$${dir}_files\"' ${dir}/'\"\$\$f\" ; \\"
    echotab " done ; \\"
    echotab " ${dir}_libs='' ; \\"
    echotab " for f in modules.o \$\$LIBS ; do \\"
    echotab "   case \$\$f in \\"
    echotab "     -*) ${dir}_libs=\"\$\$${dir}_libs \$\$f\";; \\"
    echotab "     *) ${dir}_libs=\"\$\$${dir}_libs\"' ${dir}/'\"\`basename \$\$f\`\";; \\"
    echotab "   esac ; \\"
    echotab " done ; \\"
    echotab " sed_escape_commas='s/,/\\\\,/g' ; \\"
    echotab " ${dir}_libs=\`echo \"\$\$${dir}_libs\" | sed -e \"\$\$sed_escape_commas\"\` ; \\"
    echotab " sed -e \"s,@@${DIR}_FILES@@,\$\$${dir}_files,\" -e \"s,@@${DIR}_LIBS@@,\$\$${dir}_libs,\"; } \\"
  done
  echotab "   > \$(TOPDIR)/Makefile"
else
  echotab "${HLN} distmakefile \$(TOPDIR)/Makefile"
fi
# Architecture independent data files.
if [ -n "$USE_GETTEXT" ] ; then
  echotab "for f in \`find locale -type d -print\`; do mkdir \$(TOPDIR)/\$\$f; done"
  echotab "for f in \`find locale -type f -print\`; do ${HLN} \$\$f \$(TOPDIR)/\$\$f; done"
fi
if [ "${with_dynamic_modules}" != no ]; then
  echotab "mkdir \$(TOPDIR)/dynmod"
  echotab "${HLN} dynmod/* \$(TOPDIR)/dynmod/"
fi
echotab "mkdir \$(TOPDIR)/data"
echotab "${HLN} data/* \$(TOPDIR)/data/"
echotab "mkdir \$(TOPDIR)/doc"
echotab "${HLN} ${manpages1html} ${manpages_less} ${manual_print} \$(TXTFILES) \$(IMPNOTES_FILES) \$(TOPDIR)/doc/"
echotab "mkdir \$(TOPDIR)/emacs"
line="${HLN}";
for f in ${EMACS_FILES} ${VIM_FILES}; do
  line="${line} ${SRCTOPDIR}emacs/${f}"
done
echotab "${line} \$(FULLTOPDIR)/emacs/"
echotab "mkdir \$(TOPDIR)/misc"
line="${HLN}";
for f in ${ACLOCAL_FILES}; do line="${line} ${SRCDIR}m4/$f"; done
echotab "${line} \$(FULLTOPDIR)/misc/"
echotab "mkdir \$(TOPDIR)/src"
echotab "${HLN} \$(LISPFILES) \$(FASFILES) \$(FULLTOPDIR)/src/"
echotab "${HLN} clisp-link \$(TOPDIR)/"
echotab "mkdir \$(TOPDIR)/linkkit"
echotab "for f in ${LINKKIT}; do ${HLN} linkkit/\$\$f \$(TOPDIR)/linkkit/; done"
echotab "mkdir \$(TOPDIR)/build-aux"
echotab "cd build-aux && ${HLN} ${BUILD_AUX} \$(FULLTOPDIR)/build-aux"
echo_dist_modules "\$(FULLTOPDIR)" ${HLN} ""
# For building the `clisp' executable.
if test -z "$BINARY_DISTRIB"; then
  echotab "${HLN} clisp.c ${SRCDIR}execname.c \$(TOPDIR)/src/"
else
  echotab_to_HEXE "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS) -DLISPLIBDIR='\"\$(lisplibdir)\"' -DLOCALEDIR='\"\$(localedir)\"'" clisp.c "\$(TOPDIR)/clisp"
  echotab_to_HEXE "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(CLFLAGS)" "${UTILDIR_CC}hardcode.c" "\$(TOPDIR)/hardcode"
fi
# Final packing.
echotab "chmod a+r \$(TOPDIR) \$(TOPDIR)/* \$(TOPDIR)/*/*"
echotab "chmod a+x \$(TOPDIR)/. \$(TOPDIR)/*/."
if [ -z "${COMPRESS}" ]; then
  echotab "tar cvfh \$(DISTFILE) \$(TOPDIR)"
else
  echotab "tar cvfh - \$(TOPDIR) | \$(COMPRESS) > \$(DISTFILE)"
fi
echotab "${HLN} \$(DISTFILE) clisp\$(PACKEXT)"
echotab "\$(RMRF) \$(TOPDIR)"
echol
echol
elif [ $HOS = win32 ] ; then
  echol "# Distribution, to be executed on a Unix host or using Cygwin."
  echol "distrib : install.lisp install.bat config.lisp ${manpages_less} clisp.html COPYRIGHT.rtf env_var_update.nsh install.nsi is_user_admin.nsh force"
  echotab "version=\$(VERSION) ; \\"
  echotab "distdir=clisp-\$\$version ; \\"
  echotab "rm -rf \$\$distdir; \\"
  echotab "mkdir \$\$distdir ; \\"
  echotab "for f in ${READMES} install.bat ; do \\"
  echotab "  if test -f \$\$f ; then cp -p \$\$f \$\$distdir/\$\$f ; else cp -p \`echo \$\$f | tr '[A-Z]' '[a-z]'\` \$\$distdir/\$\$f ; fi ; \\"
  echotab "done ; \\"
  if [ $TSYS = win32msvc ] ; then
    echotab "distfile=clisp-\$\$version-msvc-win32.zip ; \\"
    echotab "for f in lisp.exe lispinit.mem install.bat clisp.exe ; do \\"
    echotab "  cp -p \$\$f \$\$distdir/\$\$f ; \\"
    echotab "done ; \\"
  else
    echotab "distfile=clisp-\$\$version-win32.zip ; \\"
    echotab "installfile=clisp-\$\$version-win32-install.exe ; \\"
    echotab "for d in base full ; do \\"
    echotab "  mkdir \$\$distdir/\$\$d ; \\"
    echotab "  for f in lisp.exe lispinit.mem ; do \\"
    echotab "    cp -p \$\$d/\$\$f \$\$distdir/\$\$d/\$\$f ; \\"
    echotab "  done ; \\"
    echotab "done ; \\"
    echotab "mkdir \$\$distdir/linkkit; \\"
    echotab "for f in ${LINKKIT}; do \\"
    echotab "  cp -p linkkit/\$\$f \$\$distdir/linkkit/\$\$f; \\"
    echotab "done ; \\"
    echotab "mkdir \$\$distdir/build-aux; \\"
    echotab "for f in ${BUILD_AUX}; do \\"
    echotab "  cp -p build-aux/\$\$f \$\$distdir/build-aux/\$\$f; \\"
    echotab "done ; \\"
    echotab "cp clisp-link clisp.exe \$\$distdir/; \\"
    echo_dist_modules `pwd`/"\$\$distdir" ln "; \\"
  fi
  test -n "${USE_GETTEXT}" && echotab "cp -r locale/ \$\$distdir/; \\"
  test "${with_dynamic_modules}" != no && \
    echotab "cp -r dynmod/ \$\$distdir/; \\"
  echotab "mkdir \$\$distdir/data ; \\"
  for f in ${DATA_FILES}; do
    echotab "cp -p data/${f} \$\$distdir/data/${f} ; \\"
  done
  echotab "mkdir \$\$distdir/doc ; \\"
  echotab "for f in ${manpages1html} ${manpages_less} \$(TXTFILES) \$(IMPNOTES_FILES) ; do \\"
  echotab "  if test -f \$\$f ; then cp -p \$\$f \$\$distdir/doc/\$\$f ; else cp -p \`echo \$\$f | tr '[A-Z]' '[a-z]'\` \$\$distdir/doc/\$\$f ; fi ; \\"
  echotab "done ; \\"
  echotab "mkdir \$\$distdir/emacs; \\"
  for f in ${EMACS_FILES} ${VIM_FILES}; do
    echotab "cp -p ${SRCTOPDIR}emacs/${f} \$\$distdir/emacs/${f} ; \\"
  done
  echotab "mkdir \$\$distdir/misc; \\"
  for f in ${ACLOCAL_FILES}; do
    echotab "cp -p ${SRCDIR}m4/${f} \$\$distdir/misc/${f} ; \\"
  done
  echotab "mkdir \$\$distdir/src ; \\"
  echotab "cp -p \$(LISPFILES) config.lisp install.lisp install.bat \$\$distdir/src/ ; \\"
  echotab "chmod 755 \$\$distdir/. \$\$distdir/*/. ; \\"
  echotab "find \$\$distdir -type f -exec chmod 664 {} ';' ; \\"
  echotab "rm -f \$\$distfile \$\$installfile ; \\"
  echotab "(echo \"\$(PACKAGE_NAME) version \$(PACKAGE_VERSION) for Win32.\"; echo \".\") | zip -r -9 -z \$\$distfile \$\$distdir ; \\"
  echotab "cd \$\$distdir; cp ../*.ns[hi] ../COPYRIGHT.rtf .; makensis install.nsi; mv \$\$installfile .. ; cd ..; \\"
  echotab "rm -rf \$\$distdir"
  echol
fi

cat <<!!
# clean0 is harmless: removes only superfluous things: temporary files.
clean0 : force
	-\$(RM) core *.core *.stackdump${OBSOLETE}

# clean1 removes everything that becomes obsolete once lisp${LEXE} is recompiled
# without changing the bytecode format and the tables in
# constobj.d, constpack.d, constsym.d, subr.d, fsubr.d, pseudofun.d.
clean1 : clean0
	-\$(RM) lispbibl.h clisp.h *.i *.s *${TOBJ} *.a lisp${LEXE} clisp-link makevars ansi-tests-log ${CLISP_DEF}
	-\$(RMRF) ${RECOMPILEDIR}
	-\$(RMRF) ${TESTSDIR}
	-\$(RMRF) ${ANSITESTSDIR}
	-\$(RMRF) ${SACLATESTSDIR}
	-\$(RMRF) boot base full linkkit dynmod
	-\$(RM) ${TXT_FILES} ${manpages_less} ${manual_print} \$(IMPNOTES_FILES) \$(TXTFILES) COPYRIGHT.rtf install.nsi

# clean2 removes everything that becomes obsolete once lisp${LEXE}
# is recompiled without changing the bytecode format.
clean2 : clean1
	-\$(RM) interpreted.mem halfcompiled.mem lispinit.mem lispinit2.mem

# clean3 removes everything that becomes obsolete once lisp${LEXE}
# is recompiled. It leaves everything generated by "make allc".
clean3 : clean2
	-\$(RM) \$(FASFILES) *.lib
!!
line="-\$(RM)"
for f in ${LUTILS}; do line=$line" ${f}.fas"; done
echotab "$line"
echotab 'for m in "" $(BASE_MODULES) $(MODULES); do test -n "$$m" && $(RM) $$m/*.fas $$m/*.lib $$m/*.erg; done'
cat <<!!

# clean4 removes everything that becomes obsolete
# when switching to a new version of the C compiler.
# It leaves everything generated by "make init".
clean4 : clean3
	-\$(RM) cflags.h cflags.h.stamp
	-\$(RM) \$(CFILES)
!!
test -n "$USE_GETTEXT" && \
  cat <<!!
	cd po && \$(MAKE) clean
	-\$(RMRF) locale
!!

echol '# clean5 even undoes "make init".'
echol "clean5 : clean4"
echotab "-\$(RM) ${TOP_DOC} modules.h"
if [ -n "${SRCDIR}" ] ; then
  line="-\$(RM) NEWS clisp.png"
  test ${HOS} = win32 && line="$line clisp.ico"
  echotab "$line"
  test $HOS = unix -a $CROSS = false && echotab "-\$(RM) .gdbinit"
  echotab "-\$(RMRF) build-aux"
fi
test $TOS = unix && echotab "-\$(RM) MAGIC.add"
echotab "-\$(RMRF) data"
line="clisp${HEXE} clisp.rc"
for f in ${UTILS}; do line=$line" ${f}${HEXE}"; done
echotab "-\$(RM) ${line}"
echol
cat <<!!
# clean6 lets us go back to "makemake > Makefile".
clean6 : clean5
	-\$(RM) config.lisp

# clean-modules remove the copies of modules, do it if you change modprep and such
clean-modules :
	-\$(RMRF) \`ls -d ${MODULESDIR_}*/. | sed -e 's,/\.\$\$,,' -e 's,^.*/,,'\`

# clean7 lets us go back to the main "configure".
clean7 : clean6 clean-modules distclean-subdirs
	-\$(RM) config.status config.log config.cache ${PARAMS_H} config.h stamp-h1 libtool makemake Makefile
!!
test -n "$USE_GETTEXT" && \
  cat <<!!
	cd po && \$(MAKE) distclean
	-\$(RMRF) locale
!!
echol
echol "clean-subdirs :"
for dir in ${SUBDIRS}; do
  echotab "test -d ${dir} && \$(MAKE) -C ${dir} clean"
done
echol
# this must be run before clean7 because it runs "cd ..; make am--refresh"
echol "distclean-subdirs :"
for dir in ${SUBDIRS}; do
  echotab "test -d ${dir} && \$(MAKE) -C ${dir} distclean"
done
echol
cat <<!!

# clean8 moreover cleans up the SRCDIR.
clean8 : clean7

# The normal "start over" command:
mostlyclean : clean4

# Clear all files that are built by "make ...":
clean : clean5 clean-subdirs

# Make "clear for distribution":
distclean : clean7

# Remove everything that can be generated otherwise:
maintainer-clean : clean8

!!

echol

# Without this NeXT's make program tries to compile via c -> s -> o
echol ".SUFFIXES:"
echodummyrule .SUFFIXES
echol

echol "force:"
echodummyrule force

echol