#! @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-2024
# Sam Steingold 1999-2012, 2016

# 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).
       --enable-portability    favour portability over optimization: disable
                               optimizations that could lead to build failures
       --with-gmalloc          use the GNU malloc instead of the libc one
       --with-debug            if you 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] [cross] 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
#        master
#        win32msvc
#  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 master 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, 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'

# <https://lists.gnu.org/archive/html/autoconf/2010-09/msg00089.html>
# 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 and --enable 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
enable_portability=ifuseful
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* ) arg=`echo "$arg" | sed -e 's,FrontMatter.*$,,'` ;;
      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

# Ensure trailing slash in hyperspec URL.
case "$hyperspec" in
  */)  ;;
  *) hyperspec=${hyperspec}/ ;;
esac

# HSYS, HSYSOS = host system
# HOS  = host operating system
# TSYS, TSYSOS = target system
# TOS  = target operating system
# CC, CPPFLAGS, CFLAGS, LDFLAGS, CPP = compiler on host, for host
# A_CPPFLAGS, Z_CPPFLAGS = options that we add before, after $(CPPFLAGS).
# A_CFLAGS, Z_CFLAGS = options that we add before, after $(CFLAGS).
# A_LDFLAGS, Z_LDFLAGS = options that we add before, after $(LDFLAGS).
# XCC, XCPPFLAGS, XCFLAGS, XLDFLAGS, XCPP = cross-compiler on host, for target
# A_XCPPFLAGS, Z_XCPPFLAGS = options that we add before, after $(XCPPFLAGS).
# A_XCFLAGS, Z_XCFLAGS = options that we add before, after $(XCFLAGS).
# A_XLDFLAGS, Z_XLDFLAGS = options that we add before, after $(XLDFLAGS).

# 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
WINDRES='@WINDRES@'                 # something like i686-w64-mingw32-windres
LD='@LD@'                           # the linker used by $CC, such as 'ld' or '/usr/bin/ld -m elf_i386'
AR='@AR@'                           # usually 'ar'
RANLIB='@RANLIB@'                   # either 'ranlib' or ':'
DSYMUTIL='@DSYMUTIL@'               # either 'dsymutil' 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='@LIBSIGSEGV@'           # '-lsigsegv -L/usr/local/lib' or ''
LIBUNISTRING='@LIBUNISTRING@'       # '-lunistring ...' 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

# These variables are our additions to $(CPPFLAGS) or $(XCPPFLAGS).
A_CPPFLAGS=''
Z_CPPFLAGS=''
A_XCPPFLAGS=''
Z_XCPPFLAGS=''
# These variables are our additions to $(CFLAGS) or $(XCFLAGS).
A_CFLAGS=''
Z_CFLAGS=''
A_XCFLAGS=''
Z_XCFLAGS=''
# These variables are our additions to $(LDFLAGS) or $(XLDFLAGS).
A_LDFLAGS=''
Z_LDFLAGS=''
A_XLDFLAGS=''
Z_XLDFLAGS=''

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) \$(LDFLAGS)"
case $# in
  0 | 1)
     # Assume we are on Unix (or win32gcc); target=host (not cross-compiling).
     CROSS=false
     if [ -z "$HSYS" ]; then # not win32gcc
       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
       # Compile the utils as native Windows binaries, even on Cygwin.
       UTILCOMPILE="\$(CC) \$(CPPFLAGS)"
     fi
     TSYS="$HSYS"
     TSYSOS="$HSYSOS"
     case "$host_os" in
       mingw*) TOS=win32 ;;
       *)      TOS="$HOS" ;;
     esac
     ;;
  *) 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|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)'
       CC_NEED_DEEMA=true
       AS_UNDERSCORE=false
       LD='link'
       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"
       LD='ld'
     fi
     shift 2
     ;;
esac

# Like WIDE_HARD in lispbibl.d
if [ $CROSS = false ] ; then
  if grep 'define long_bitsize 64' intparam.h > /dev/null && grep 'define long_long_bitsize 64' intparam.h > /dev/null; then
    WIDE_HARD='true'
  else
    WIDE_HARD='false'
  fi
else
  WIDE_HARD='false' # just a guess
fi

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
    # - Don't enable dynamic modules by default on AIX.
    #   libtool's archive_cmds variable is empty on AIX.
    #   Cf. <https://sourceforge.net/p/clisp/bugs/726/>
    if [ $CROSS = false ] ; then
      case "$host_os" in
        aix* ) with_dynamic_modules=no ;;
        *)     with_dynamic_modules=yes ;;
      esac
    else
      with_dynamic_modules=yes
    fi
  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
        Z_CFLAGS="${Z_CFLAGS} -G5 -Os -Oy -Ob1 -Gs -Gf -Gy"
      else
        Z_CFLAGS="${Z_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

# make sure the Darwin foo.dSYM directories are removed by clean et al
# exefile: list of files generated by compilation
#   ("foo.exe" or "foo" or "foo foo.dSYM")
# EXERM: make variable that will remove the above
#   (RMRF on darwin because dSYM is a directory, RM otherwise)
if [ $HSYSOS = darwin ]; then
  exefiles () {
    echo $1 $1.dSYM
  }
  EXERM=RMRF
else
  exefiles () {
    echo $1${HEXE}
  }
  EXERM=RM
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
  # Set by configure, above.
  # On mingw in the Cygwin environment, the built native Windows programs don't
  # understand the symlinks created by Cygwin's 'ln -s'. Therefore avoid
  # creating such symlinks.
  case "$host_os" in
    mingw*) LN_S=${LN-ln} ;;
  esac
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'

# SED = command for filtering text according to a script
SED='sed'

# 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 [ $TSYS = master -o $TOS = unix ] ; then
  OS_INCLUDES=$OS_INCLUDES' unix'
  LIBS=$LIBS" $LIBICONV $LIBSIGSEGV $LIBUNISTRING"
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 $LIBUNISTRING"
  else
    if [ $TSYS = win32msvc ] ; then
      LIBS=$LIBS" user32.lib ws2_32.lib advapi32.lib $LIBSIGSEGV $LIBUNISTRING"
    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
  # https://sourceforge.net/p/mingw/mailman/mingw-msys/thread/4B9FD2A4.2050805@gnu.org/
  # http://stackoverflow.com/questions/12015348/msys-path-conversion-or-cygpath-for-msys
  if cygpath -v > /dev/null 2>&1; then
    PWD_POSTPROC='cygpath -m'
  fi
else
  TEXE=''
  LEXE='.run'
  case "$host_os" in
    darwin*) SHREXT='.dylib' ;;
    hpux*)   SHREXT='.sl' ;;
    *)       SHREXT='.so' ;;
  esac
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
Z_CPPFLAGS="${Z_CPPFLAGS} ${GNULIB_INCLUDE}"
Z_XCPPFLAGS="${Z_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
  cpu="${host_cpu}"
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_SUNPRO=false
  # Recognize clang. It disguises as GCC.
  if LC_ALL=C $XCC --version | grep 'Apple LLVM' > /dev/null; then
    XCC_BRAND=clang
  else
    XCC_BRAND=`LC_ALL=C $XCC --version | sed -e '2,$d' -e 's/ .*//'` # either gcc or clang
  fi
  XCC_GCC_VERSION=`LC_ALL=C $XCC -v 2>&1 | grep version | sed -n -e '$p' | sed -e 's/.*version //g' -e 's/gcc //'`
  # Assume gcc 2.95 or newer.
  # Diagnostic flags:
  # Syntax errors at identifiers that are produced by macro expansion
  # (e.g. at 'local', which expands to 'static') are shown with the
  # location of the macro only, in gcc 5.x at least, which is confusing.
  # Use option '-no-integrated-cpp' to provide better syntax error reporting.
  if [ "$XCC_BRAND" = gcc ] ; then
    case "$XCC_GCC_VERSION" in
      2.* | 3.* | 4.[0-7]*) ;;
      *)
        Z_XCFLAGS=$Z_XCFLAGS' -no-integrated-cpp'
        ;;
    esac
  fi
  # Warnings flags:
  Z_XCFLAGS=${Z_XCFLAGS}' -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type'
  if [ $CC_CPLUSPLUS = false ] ; then
    Z_XCFLAGS=${Z_XCFLAGS}' -Wmissing-declarations -Wimplicit'
  fi
  # gcc 2.7 introduced an annoying warning, but gcc 2.8 has a workaround:
  Z_XCFLAGS=$Z_XCFLAGS' -Wno-sign-compare -Wno-format-nonliteral'
  # clisp assumes two's complement arithmetic, therefore disable
  # "warning: left shift of negative value".
  # https://gcc.gnu.org/ml/gcc-patches/2015-04/msg01353.html
  if [ $CROSS = false ] ; then
    case "$XCC_GCC_VERSION" in
      2.* | 3.* | 4.* | 5.*) ;;
      *)
        Z_XCFLAGS=$Z_XCFLAGS' -Wno-shift-negative-value'
        ;;
    esac
  fi
  if [ $CROSS = false -a $CC_CPLUSPLUS = true ] ; then
    # g++ 3.4 introduced an annoying warning, but has a workaround:
    case "$XCC_GCC_VERSION" in
      2.* | 3.[1-3]*) ;;
      *)
        Z_XCFLAGS=$Z_XCFLAGS' -Wno-invalid-offsetof'
        ;;
    esac
  fi
  # Code generation flags:
  # Select optimizations.
  if [ "${with_debug}" = no ] ; then
    if [ "$cpu" = i386 ] ; then
      Z_XCFLAGS=$Z_XCFLAGS' -O2 -fexpensive-optimizations'
    elif [ "$cpu" = sparc ] ; then
      Z_XCFLAGS=$Z_XCFLAGS' -O2'
    elif [ "$cpu" = sparc64 ] ; then
      # gcc-3.3.1 produces incorrect code when -O2 is used, even with
      # -fno-schedule-insns and -fno-gcse.
      Z_XCFLAGS=$Z_XCFLAGS' -O'
    elif [ "$cpu" = x86_64 ] ; then
      # gcc-3.2.2 produces incorrect code when -O2 is used.
      Z_XCFLAGS=$Z_XCFLAGS' -O'
    else
      Z_XCFLAGS=$Z_XCFLAGS' -O2'
    fi
    # For platforms that use global register variables...
    case "$cpu" in
      m68k | i386 | sparc | sparc64 | hppa | arm | armhf | alpha | 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).
              Z_XCFLAGS=$Z_XCFLAGS' -fno-gcse' ;;
          esac
        fi
        ;;
    esac
  fi # with_debug
  # clisp assumes two's complement arithmetic. Therefore use -fwrapv.
  # No need to use -fno-strict-overflow, since we only need to disable
  # strict overflow rules for integer types, not for pointer types, and
  # for integer types it's already implied by -fwrapv.
  if [ $CROSS = false ] ; then
    case "$XCC_GCC_VERSION" in
      2.* | 3.[1-3]*) ;;
      *)
        Z_XCFLAGS=$Z_XCFLAGS' -fwrapv'
        ;;
    esac
  fi
  # On arm64, gcc 4.8.4 with binutils 2.24 produces code that, when TYPECODES
  # is used, leads to a link error when linking lisp.run:
  #   relocation truncated to fit: R_AARCH64_ADR_PREL_PG_HI21 against symbol `symbol_tab_data' defined in .data section in spvwtabs.o
  # The option -fPIC is a workaround.
  if [ "$cpu" = arm64 ] ; then
    Z_XCFLAGS=$Z_XCFLAGS' -fPIC'
  fi
  if [ $TSYS = win32gcc ] ; then
    Z_XCFLAGS=$Z_XCFLAGS' -D_WIN32'
  fi
  if [ $TSYS = sun4 ] ; then
    Z_XLDFLAGS=$Z_XLDFLAGS' -static'
  fi
  XCC_NOOPTFLAGS=' -O0'

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

else

  if [ $CROSS = false ] ; then
    # Detect SUNWspro C compiler - defines __SUNPRO_C
    XCC_SUNPRO=${CC_SUNPRO}
  else
    XCC_SUNPRO=false
  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
    Z_XCFLAGS="$Z_CFLAGS -U__GNUC__ -DANSI -D_M_IX86=500 -D_WIN32 -I\$(MSVCDIR)/include"
  elif "$XCC_SUNPRO" ; then
    # SUNWspro cc flags:
    Z_XCFLAGS=${Z_XCFLAGS}' -xO3 -xstrconst'
  elif [ $TSYS = sun4 ] ; then
    # 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 al
    # XCFLAGS=''
    :
  else
    Z_XCFLAGS=${Z_XCFLAGS}' -O'
  fi
  case "$host_os" in
    hpux*)
      # HP's C compiler (HP C B.11.11.24 on hppa) crashes when compiling
      # stream.d with -g. So remove -g if it was specified.
      XCFLAGS=`echo " $XCFLAGS " | sed -e 's/ -g //' -e 's/^ *//' -e 's/ *$//'`
      ;;
  esac
  if [ $TSYS = sun4 ] ; then
    Z_XCFLAGS=$Z_XCFLAGS' -dalign'
    if [ $CC_CPLUSPLUS = false ] ; then
      Z_XCFLAGS=$Z_XCFLAGS' -fsingle'
    fi
    Z_XLDFLAGS=$Z_XLDFLAGS' -Bstatic'
  fi
  XCC_NOOPTFLAGS=''

fi

# Relocatable machine pointers are machine pointers that are visible to the GC.
# In the HEAPCODES object representation, they must satisfy alignment
# constraints. When these constraints are not defined, we run into
#   C_CODE_ALIGNMENT is wrong. &equal = 0x4c8de7.
# This can happen
# - with gcc on Linux, when not optimizing,
# - with Apple's gcc 4 on MacOS X,
# - with gcc >= 4 when "gcc -Os" is used,
# - with clang when "clang -Os" is used.
# gcc has an option to fix this. clang 3.9 doesn't.
if [ $XCC_GCC = true ] && [ "$XCC_BRAND" != clang ] ; then
  if $WIDE_HARD; then
    # GENERIC64C_HEAPCODES requires an 8-byte alignment of all C functions
    # that are used as relocatable machine pointers.
    FALIGNFLAGS='-falign-functions=8'
  else
    if [ "$cpu" = arm -o "$cpu" = armhf ] ; then
      # On ARM, function pointer alignment depends on the arm/thumb mode:
      # C_CODE_ALIGNMENT is 4 with -marm, but only 1 with -mthumb.
      Z_XCFLAGS=${Z_XCFLAGS}' -marm'
      FALIGNFLAGS=''
    else
      FALIGNFLAGS='-falign-functions=4'
    fi
  fi
else
  FALIGNFLAGS=''
fi

# We access the same memory through pointers of different types, for example
# as TheVarobject(obj)->..., TheRecord(obj)->..., TheInstance(obj)->... .
# This violates the strict type-based aliasing rules of C. In other words, we
# still use C as a portable assembler, but now the compilers want to outsmart
# us. There are two ways to tell them not to do this: to use union types, or
# specific compiler options. I prefer to do it through compiler options.
if [ $XCC_GCC = true ] ; then
  Z_XCFLAGS=$Z_XCFLAGS' -fno-strict-aliasing'
else
  if [ "$HSYSOS" = aix ] ; then # for xlc
    Z_XCFLAGS=$Z_XCFLAGS' -qalias=noansi'
  fi
  if "$XCC_SUNPRO" ; then # for SUNWspro cc
    Z_XCFLAGS=$Z_XCFLAGS' -xalias_level=weak'
  fi
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}\"
  if [ "$HSYSOS" != cygwin ]; then
    eval "`./libtool --tag=CC --config | grep '^allow_undefined_flag='`"
    eval "`./libtool --tag=CC --config | grep '^archive_cmds='`"
  else
    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname'
  fi
  # http://lists.gnu.org/archive/html/bug-bash/2011-08/msg00280.html
  CC_set=${CC+set}
  CC_save=$CC
  CC='${CC}' libobjs='$libs' deplibs='${A_LDFLAGS} ${LDFLAGS} ${Z_LDFLAGS}' compiler_flags='${A_CFLAGS} ${CFLAGS} ${Z_CFLAGS}' \
    soname='$dll' lib='$lib' output_objdir='$dyndir' \
    eval XCC_CREATESHARED=\"${archive_cmds}\"
  # archive_cmds can contain several commands, separated by ~.
  # But here we need only the first one. The second command occurs only on
  # Mac OS X, and is a $DSYMUTIL invocation that merely extracts debugging
  # information to the file system.
  XCC_CREATESHARED=`echo "$XCC_CREATESHARED" | sed -e 's/~.*//'`
  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
    Z_XCFLAGS=$Z_XCFLAGS' -gstabs'
  elif [ ${HSYS} != "win32msvc" ]; then
    Z_XCFLAGS=$Z_XCFLAGS' -ggdb -O0'
  fi
  Z_XCFLAGS=$Z_XCFLAGS' -DDEBUG_OS_ERROR -DDEBUG_SPVW -DDEBUG_BYTECODE -DSAFETY=3'
  case "$CC" in
    *"g++"* ) Z_XCFLAGS=$Z_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 <https://sourceforge.net/p/mingw/mailman/message/14900754/>
  Z_XCFLAGS=$Z_XCFLAGS' -DCINTERFACE'
fi

if [ "$cpu" = i386 -a "$TSYSOS" = "sunos" ] ; then # Solaris 2
  Z_XCFLAGS=$Z_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 [ "${enable_mmap}" = no ]; then
  Z_XCFLAGS=${Z_XCFLAGS}" -DNO_SINGLEMAP -DNO_TRIVIALMAP"
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 <https://sourceforge.net/p/clisp/mailman/message/12562837/>
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 !
      XLDFLAGS=`echol "$XLDFLAGS" | sed -e 's/-B*static//g'`
      Z_XLDFLAGS=`echol "$Z_XLDFLAGS" | sed -e 's/-B*static//g'`
      SOLARIS_LINKING=1 # Even more hacks needed??
      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" && Z_XCFLAGS=$Z_XCFLAGS' -DUNIX_BINARY_DISTRIB'


# Handle --enable-portability:
# --enable-portability disables several optimizations.
# --disable-portability allows these optimizations.
# The default is to allow those optimizations that we have tested to work fine,
# on a per-platform basis.
if [ "${enable_portability}" = no ]; then
  :
else
  if [ "${enable_portability}" != yes ]; then
    case "$host_os--$host_cpu_c_abi" in
      # Sort order: Keep this list sorted by
      #   1. word size (32-bit before 64-bit),
      #   2. operating system (Linux, *BSD, Mac OS X, proprietary Unices, Windows)
      #   3. CPU and ABI (alphabetically, x86_64 mapping to amd64, like in
      #      lispbibl.d and Makefile.devel)

      # 32-bit platforms

      # Linux/x86_64 with 32-bit x32 ABI
      linux*--x86_64-x32)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/arm
      linux*--arm | linux*--armhf)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/hppa
      linux*--hppa)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/i386
      linux*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/m68k
      linux*--m68k)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/mipseb and Linux/mipsel with o32 ABI
      linux*--mips)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/mips64eb and Linux/mips64el with n32 ABI
      linux*--mipsn32)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/powerpc64 with 32-bit ABI
      linux*--powerpc)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/s390x with 32-bit ABI
      linux*--s390)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/sparc64 with 32-bit ABI
      linux*--sparc)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Hurd/i386
      gnu*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # FreeBSD/i386
      freebsd*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # GNU/kFreeBSD/i386
      kfreebsd*-gnu*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # DragonFly/i386
      dragonfly*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # NetBSD/i386
      netbsd*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # NetBSD/sparc
      netbsd*--sparc)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # OpenBSD/i386
      openbsd*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Mac OS X/x86_64 with 32-bit ABI
      darwin*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Mac OS X/PowerPC
      darwin*--powerpc)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # AIX/POWER with 32-bit ABI
      aix*--powerpc)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Solaris 10/x86_64 with 32-bit ABI
      solaris2.10--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Solaris 11/x86_64 with 32-bit ABI
      solaris2.11--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Solaris 10/sparc64 with 32-bit ABI
      solaris2.10--sparc)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Haiku (32-bit)
      haiku*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Minix/i386
      minix*--i386)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Cygwin, running on Windows 10 (64-bit)
      cygwin--i386) # TODO
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM -DNO_ARI_ASM -DNO_SP_ASM"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_DISPATCH"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_FLOAT -DNO_FAST_DOUBLE"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ALLOCA"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ADDRESS_SPACE_ASSUMPTIONS"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_GENERATIONAL_GC"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_SYMBOLFLAGS"
        ;;

      # mingw, running on Windows 10 (64-bit)
      mingw*--i386) # TODO
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM -DNO_ARI_ASM -DNO_SP_ASM"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_DISPATCH"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_FLOAT -DNO_FAST_DOUBLE"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ALLOCA"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ADDRESS_SPACE_ASSUMPTIONS"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_GENERATIONAL_GC"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_SYMBOLFLAGS"
        ;;

      # 64-bit platforms

      # Linux/x86_64
      linux*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/arm64
      linux*--arm64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/alpha
      linux*--alpha)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/ia64
      linux*--ia64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/mips64eb and Linux/mips64el with 64-bit ABI
      linux*--mips64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/powerpc64
      linux*--powerpc64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/powerpc64le
      linux*--powerpc64-elfv2)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/riscv64
      linux*--riscv64*)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/s390x
      linux*--s390x)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Linux/sparc64
      linux*--sparc64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # FreeBSD/x86_64
      freebsd*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # GNU/kFreeBSD/x86_64
      kfreebsd*-gnu*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM -DNO_ARI_ASM -DNO_SP_ASM"
        ;;

      # FreeBSD/arm64
      freebsd*--arm64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # NetBSD/x86_64
      netbsd*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # NetBSD/sparc64
      netbsd*--sparc64) # TODO
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM -DNO_ARI_ASM -DNO_SP_ASM"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_DISPATCH"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_FLOAT -DNO_FAST_DOUBLE"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ALLOCA"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ADDRESS_SPACE_ASSUMPTIONS"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_GENERATIONAL_GC"
        Z_XCFLAGS="$Z_XCFLAGS -DNO_SYMBOLFLAGS"
        ;;

      # OpenBSD/x86_64
      openbsd*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Mac OS X/x86_64
      darwin*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # macOS 11/arm64
      darwin*--arm64)
        ;;

      # AIX/POWER with 64-bit ABI
      aix*--powerpc64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Solaris 10/x86_64
      solaris2.10--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Solaris 11/x86_64
      solaris2.11--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Solaris 10/sparc64
      solaris2.10--sparc64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Haiku (64-bit)
      haiku*--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      # Cygwin, running on Windows 10
      cygwin--x86_64)
        Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM"
        ;;

      *) # On unknown platforms, use --enable-portability.
         enable_portability=yes
         ;;
    esac
  fi
  if [ "${enable_portability}" = yes ]; then
    # Do NOT enable -DSAFETY=3 here, because -DSAFETY=3 not only disables some
    # optimizations but also enables some debugging features (STACKCHECKs), which
    # is not in the scope of --enable-portability.
    Z_XCFLAGS="$Z_XCFLAGS -DNO_ASM -DNO_ARI_ASM -DNO_SP_ASM"
    Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_DISPATCH"
    Z_XCFLAGS="$Z_XCFLAGS -DNO_FAST_FLOAT -DNO_FAST_DOUBLE"
    Z_XCFLAGS="$Z_XCFLAGS -DNO_ALLOCA"
    Z_XCFLAGS="$Z_XCFLAGS -DNO_ADDRESS_SPACE_ASSUMPTIONS"
    Z_XCFLAGS="$Z_XCFLAGS -DNO_GENERATIONAL_GC"
    Z_XCFLAGS="$Z_XCFLAGS -DNO_SYMBOLFLAGS"
  fi
fi


# Other dependencies:

FILES=''

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

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

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

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

if [ "${with_readline}" = no ]; then
  # --without-readline was supplied
  Z_XCFLAGS=$Z_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
  Z_XCFLAGS=$Z_XCFLAGS' -DNO_GETTEXT'
else
  USE_GETTEXT=yes
  LIBS='@LIBINTL@ '$LIBS
  XCL_GETTEXTLIB=$XCL_GETTEXTLIB' locale'
fi

# For 32-bit builds, determine whether lispbibl.d will enable WIDE_SOFT.
USE_WIDE_SOFT=''
case " ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} " in
  *" -DWIDE "* | *" -DWIDE_SOFT "* | *" -DNO_ADDRESS_SPACE_ASSUMPTIONS "*)
    USE_WIDE_SOFT=yes
    ;;
esac

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_heap_old spvw_global spvw_global_old spvw_gcstat spvw_space spvw_mark spvw_objsize spvw_update spvw_fault spvw_fault_old spvw_sigsegv spvw_sigcld spvw_sigpipe spvw_sigint spvw_sigwinch spvw_sigterm spvw_garcol spvw_garcol_old spvw_genera1 spvw_genera1_old spvw_gcmark spvw_genera2 spvw_weak spvw_genera3 spvw_genera3_old spvw_allocate spvw_allocate_old spvw_typealloc spvw_circ spvw_circ_old 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 arilev1dbg'

EXTRA_CPARTS='arilev1_asm_proto noreadline'

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

ARI_ASMD=''
ARI_ASMC=''
ARI_ASMS=''
case " ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} " in
  *" -DNO_ARI_ASM "*) ;;
  *)
    if [ "$cpu" = sparc ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_sparc'
      ARI_ASMS=$ARI_ASMS' ari_asm_sparc'
    fi
    if [ "$cpu" = sparc64 ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_sparc64'
      ARI_ASMS=$ARI_ASMS' ari_asm_sparc64'
    fi
    if [ "$cpu" = mips -o "$cpu" = mipsn32 ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_mips'
      ARI_ASMS=$ARI_ASMS' ari_asm_mips'
    fi
    if [ "$cpu" = mips64 ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_mips64'
      ARI_ASMS=$ARI_ASMS' ari_asm_mips64'
    fi
    if [ "$cpu" = i386 ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_i386'
      ARI_ASMS=$ARI_ASMS' ari_asm_i386'
    fi
    if [ "$cpu" = hppa ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_hppa'
      ARI_ASMS=$ARI_ASMS' ari_asm_hppa'
    fi
    if [ "$cpu" = arm -o "$cpu" = armhf ] ; then
      ARI_ASMD=$ARI_ASMD' ari_asm_arm'
      ARI_ASMS=$ARI_ASMS' ari_asm_arm'
    fi
    ;;
esac

SP_ASMD=''
SP_ASMS=''
case " ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} " in
  *" -DNO_SP_ASM "*) ;;
  *)
    if [ "$cpu" = m68k ] ; then
      SP_ASMD=$SP_ASMD' sp_asm_m68k'
      SP_ASMS=$SP_ASMS' sp_asm_m68k'
    fi
    if [ "$cpu" = sparc ] ; then
      SP_ASMD=$SP_ASMD" sp_asm_sparc"
      SP_ASMS=$SP_ASMS" sp_asm_sparc"
    fi
    if [ "$cpu" = sparc64 ] ; then
      SP_ASMD=$SP_ASMD" sp_asm_sparc64"
      SP_ASMS=$SP_ASMS" sp_asm_sparc64"
    fi
    if [ "$cpu" = mips -o "$cpu" = mipsn32 -o "$cpu" = mips64 ] ; then
      SP_ASMD=$SP_ASMD' sp_asm_mips'
      SP_ASMS=$SP_ASMS' sp_asm_mips'
    fi
    if [ "$cpu" = i386 ] ; then
      SP_ASMD=$SP_ASMD' sp_asm_i386'
      SP_ASMS=$SP_ASMS' sp_asm_i386'
    fi
    ;;
esac

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

# 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 "A_CPPFLAGS = ${A_CPPFLAGS}"
  echol "Z_CPPFLAGS = ${Z_CPPFLAGS}"
  echol "CFLAGS = ${CFLAGS}"
  echol "A_CFLAGS = ${A_CFLAGS}"
  echol "Z_CFLAGS = ${Z_CFLAGS}"
  echol "LDFLAGS = ${LDFLAGS}"
  echol "A_LDFLAGS = ${A_LDFLAGS}"
  echol "Z_LDFLAGS = ${Z_LDFLAGS}"
  echol "CPP = ${CPP}"
  echol "XCC = ${XCC}"
  echol "XCPPFLAGS = ${XCPPFLAGS}"
  echol "A_XCPPFLAGS = ${A_XCPPFLAGS}"
  echol "Z_XCPPFLAGS = ${Z_XCPPFLAGS}"
  echol "XCFLAGS = ${XCFLAGS}"
  echol "A_XCFLAGS = ${A_XCFLAGS}"
  echol "Z_XCFLAGS = ${Z_XCFLAGS}"
  echol "XCPP = ${XCPP}"
  echol "XLDFLAGS = ${XLDFLAGS}"
  echol "A_XLDFLAGS = ${A_XLDFLAGS}"
  echol "Z_XLDFLAGS = ${Z_XLDFLAGS}"
  echol "XLIBS = ${LIBS}"
  XCC="\$(XCC)"
  XCPPFLAGS="\$(XCPPFLAGS)"
  A_XCPPFLAGS="\$(A_XCPPFLAGS)"
  Z_XCPPFLAGS="\$(Z_XCPPFLAGS)"
  XCFLAGS="\$(XCFLAGS)"
  A_XCFLAGS="\$(A_XCFLAGS)"
  Z_XCFLAGS="\$(Z_XCFLAGS)"
  XCPP="\$(XCPP)"
  XLDFLAGS="\$(XLDFLAGS)"
  A_XLDFLAGS="\$(A_XLDFLAGS)"
  Z_XLDFLAGS="\$(Z_XLDFLAGS)"
  LIBS="\$(XLIBS)"
else
  echol "CC = ${XCC}"
  echol "CPPFLAGS = ${XCPPFLAGS}"
  echol "A_CPPFLAGS = ${A_XCPPFLAGS}"
  echol "Z_CPPFLAGS = ${Z_XCPPFLAGS}"
  echol "CFLAGS = ${XCFLAGS}"
  echol "A_CFLAGS = ${A_XCFLAGS}"
  echol "Z_CFLAGS = ${Z_XCFLAGS}"
  echol "CPP = ${XCPP}"
  echol "LDFLAGS = ${XLDFLAGS}"
  echol "A_LDFLAGS = ${A_XLDFLAGS}"
  echol "Z_LDFLAGS = ${Z_XLDFLAGS}"
  echol "LIBS = ${LIBS}"
  XCC="\$(CC)"
  XCPPFLAGS="\$(CPPFLAGS)"
  A_XCPPFLAGS="\$(A_CPPFLAGS)"
  Z_XCPPFLAGS="\$(Z_CPPFLAGS)"
  XCFLAGS="\$(CFLAGS)"
  A_XCFLAGS="\$(A_CFLAGS)"
  Z_XCFLAGS="\$(Z_CFLAGS)"
  XCPP="\$(CPP)"
  XLDFLAGS="\$(LDFLAGS)"
  A_XLDFLAGS="\$(A_LDFLAGS)"
  Z_XLDFLAGS="\$(Z_LDFLAGS)"
  LIBS="\$(LIBS)"
fi
echol "X_LIBS = ${X_LIBS}"
X_LIBS="\$(X_LIBS)"
echol "FALIGNFLAGS = ${FALIGNFLAGS}"
FALIGNFLAGS="\$(FALIGNFLAGS)"
echol "LD = ${LD}"
LD="\$(LD)"
echol 'MODULE_CPPFLAGS = $(A_CPPFLAGS) $(CPPFLAGS) $(Z_CPPFLAGS)' # this includes ${GNULIB_INCLUDE}
if [ "${with_dynamic_modules}" != no ]; then
  echol 'MODULE_CFLAGS = $(A_CFLAGS) $(CFLAGS) $(Z_CFLAGS) '"${XCC_PICFLAG}"
  echol 'MODULE_LDFLAGS = $(A_LDFLAGS) $(LDFLAGS) $(Z_LDFLAGS) '"${EXPORT_DYNAMIC_FLAG_SPEC}"
else
  echol 'MODULE_CFLAGS = $(A_CFLAGS) $(CFLAGS) $(Z_CFLAGS)'
  echol 'MODULE_LDFLAGS = $(A_LDFLAGS) $(LDFLAGS) $(Z_LDFLAGS)'
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
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 "SED = ${SED}"
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"
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
#        LDFLAGS   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 (SVR3 and others) the default shell is csh.
  echol "SHELL = ${CONFIG_SHELL-/bin/sh}"
  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 "$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="gllib/libgnu.a init allc allo lisp${LEXE} marc.out 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 clean0 clean1 clean2 clean3 clean4 clean5 clean6 clean7 clean8 mostlyclean distclean clean maintainer-clean clean-modules am--refresh'
echol
echol 'subdirs: gllib/libgnu.a'
echol
# gnulib cannot be compiled with C++, thus NO_CXX
echol 'SUBDIR_CFLAGS = $(A_CFLAGS) $(CFLAGS) $(Z_CFLAGS) '"${XCC_PICFLAG} @NO_CXX@"
echol 'gllib/libgnu.a: config.status build-aux'
echotab 'mkdir -p gllib'
echotab 'test -f gllib/Makefile || sh config.status gllib/Makefile depfiles'
top_srcdir=`cd "${SRCDIR}"; pwd`
echotab 'cd gllib && $(MAKE) CFLAGS="$(SUBDIR_CFLAGS)" top_srcdir="'"${top_srcdir}"'"'
echol
echol "${GLLIB_A}: gllib/libgnu.a"
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 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
  case $x in
    CPPFLAGS | CFLAGS | LDFLAGS)
      echotab "echo $ARGQ#define $x \"\$(A_$x) \$($x) \$(Z_$x)\"$ARGQ >> cflags.h.new"
      ;;
    *)
      echotab "echo $ARGQ#define $x \"\$($x)\"$ARGQ >> cflags.h.new"
      ;;
  esac
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
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\"' && cat '${SRCDIR}${parf}.c'; } > gen-${parf}.c"
    echotab_to_HEXE "\$(CC)" "gen-${parf}.c" "${parf}"
    echotab "${HERE}${parf}${HEXE} ${parf}.h"
    echotab "\$($EXERM) $(exefiles ${parf}) gen-${parf}.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
  echotab "\$(COMMENT5) ${SRCDIR}${f}.d${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}"
  echotab "\$(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
  # The assembly-language syntax processing is CPU specific.
  # Makefile.devel uses asm-${asmsyntax}.sh and asm-${asmsyntax}.h (if present).
  # Keep this computation of asmsyntax consistent with Makefile.devel!
  case "$cpu" in
    arm | armhf | arm64)
      asmsyntax=arm ;;
    mips | mipsn32 | mips64)
      asmsyntax=mips ;;
    powerpc | powerpc64 | powerpc64-elfv2)
      asmsyntax=powerpc ;;
    s390 | s390x)
      asmsyntax=s390 ;;
    sparc | sparc64)
      asmsyntax=sparc ;;
    *)
      asmsyntax="$cpu" ;;
  esac
  for f in $ARI_ASMS $SP_ASMS ; do
    # The preprocessor barfs on ari_asm_hppa: "unterminated character constant".
    # This gets ignored, because it occurs in a pipe.
    echol "${f}.s : ${SRCDIR}${f}-macro.c"
    # Preprocess, then remove the line number information etc. and convert
    # "% ecx" back to "%ecx" and ". align" to ".align" and ". Lxxx" to ".Lxxx":
    if test -n "${SRCDIR}"; then
      i_option="-I${SRCDIR} "
    else
      i_option=''
    fi
    case "$asmsyntax" in
      i386 | x86_64 | sparc)
        # Use "- <" because the Sun Studio 11 compiler should not assume C syntax of the input.
        cpp_from='- < '
        ;;
      *)
        cpp_from=''
        ;;
    esac
    case "$asmsyntax" in
      arm)
        asmfilter2="\$(SED) -e 's,% ,%,g' -e 's,//,@,g' -e 's,\\\$\$,#,g'"
        ;;
      hppa)
        asmfilter2="\$(SED) -e \"s,!,',g\""
        ;;
      i386 | x86_64)
        asmfilter2="\$(SED) -e 's,% ,%,g' -e 's,\\. ,.,g' -e 's,@ ,@,g' -e 's,//.*\$\$,,' -e 's/##//g'"
        ;;
      m68k)
        if [ $AS_UNDERSCORE = true ] ; then
          final_sed_invocation="\$(SED) -e 's/\\\$\$//g'"
        else
          final_sed_invocation="\$(SED) -e 's/\\\$\$/%/g'"
        fi
        asmfilter2="\$(SED) -e 's,% ,%,g' -e 's,//.*\$\$,,' | ${final_sed_invocation}"
        ;;
      sparc)
        asmfilter2="\$(SED) -e 's,% ,%,g' -e 's,\\. ,.,g' -e 's,//.*\$\$,,' -e 's,\\\$\$,#,g' -e 's,# ,#,g'"
        ;;
      *)
        asmfilter2="\$(SED) -e 's,% ,%,g' -e 's,//.*\$\$,,'"
        ;;
    esac
    echotab "${XCPP}${ASMFLAGS} ${i_option}${cpp_from}${SRCDIR}${f}-macro.c | \$(GREP) -v '^ *#line' | \$(GREP) -v '^#' | ${asmfilter2} > ${f}.s"
    echol
  done
fi

for f in lispbibl; do
  echol "gen.${f}.c : ${SRCDIR}${f}.d comment5${HEXE}"
  echotab "\$(COMMENT5) ${SRCDIR}${f}.d | sed -e '/^%% /{s///;p;d;}' -e '/^#line /!s/.*//' | sed -e 's/puts(/fprintf(header_f,\"%s\\\\n\",/g' -e 's/print(\"/fprint(header_f,\"/g' -e 's/printf(\"/fprintf(header_f,\"/g' > 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 -o $f = arilev1_asm_proto && 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="$A_XCPPFLAGS $XCPPFLAGS $Z_XCPPFLAGS $A_XCFLAGS $XCFLAGS $Z_XCFLAGS"
  # Sun cc doesn't look for include files in the current directory
  # any more after a preprocessor directive '#line 1 "../src/file.d"'.
  flags=$flags" -I."
  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
  # Reduce optimizations in special cases.
  if [ $XCC_GCC = true ] ; then
    case " $A_XCFLAGS $XCFLAGS $Z_XCFLAGS " in
      *" -O0 "*) ;;
      *)
        if [ $f = eval -a "$cpu" = ia64 ] ; then
          # gcc-2.96 on Linux/ia64 miscompiles eval.d when -O is used.
          flags2=$flags2' -O0'
        fi
        if [ $f = eval -a "$cpu" = sparc ] ; then
          # gcc-7.2.0 on Linux/sparc appears to miscompile eval.d when -O2 is used.
          flags2=$flags2' -O1'
        fi
        if [ $f = eval -a "$cpu" = sparc64 ] ; then
          # gcc-4.6.3 on Linux/sparc64 miscompiles eval.d when -O is used.
          flags2=$flags2' -O0'
        fi
        if [ "$cpu" = mips -a -n "$USE_WIDE_SOFT" ] ; then
          # gcc-4.9.2 on Linux/mips (o32 ABI) miscompiles spvw.o, eval.o,
          # control.o, list.o and others when -DWIDE and -O is used.
          flags2=$flags2' -O0'
        fi
        if [ "$cpu" = i386 -a -n "$USE_WIDE_SOFT" ] ; then
          # gcc-6.3.0 on Hurd/i386 miscompiles something when -DWIDE is in use
          # and -O2 is used on all of spvw.o eval.o control.o encoding.o stream.o io.o
          # array.o hashtabl.o list.o record.o sequence.o charstrg.o predtype.o symbol.o.
          # The effect is a crash in loadmem_from_handle.
          # Also, clang 3.8.0 on FreeBSD/i386 miscompiles stream.o when -DWIDE is in
          # use and -O2.
          flags2=$flags2' -O1'
        fi
        if [ $f = hashtabl ] ; then
          case "$cpu" in
            riscv64*)
              # gcc-7.3.1 on Linux/riscv64 miscompiles hash_table_iterate in hashtabl.d
              # when -O2 is used. <https://bugzilla.redhat.com/show_bug.cgi?id=1567505>
              flags2=$flags2' -O1'
              ;;
          esac
        fi
        if [ $f = lisparit -a "$cpu" = s390x ] ; then
          # gcc-4.9.2 on Linux/s390x miscompiles lisparit.d when -O2 is used.
          flags2=$flags2' -O1'
        fi
        ;;
    esac
  else
    case "$host_os" in
      aix*)
        if [ $f = lisparit -a -n "$USE_WIDE_SOFT" ] ; then
          # xlc 12.01 on AIX/powerpc miscompiles lisparit.o when -DWIDE is in use
          # and -O.
          flags2=$flags2' -O0'
        fi
        ;;
    esac
  fi
  if [ $f = eval -a "${with_jitc}" = lightning ]; then
    flags2=$flags2' -Wno-unused' # should be gone - eventually...
  fi
  if [ $f = arilev1_asm_proto -a $XCC_GCC = true ]; then
    # We don't want debugging information in arilev1_asm_proto.s.
    flags2=$flags2' -g0 -fno-dwarf2-cfi-asm'
  fi
  # Files that define C functions that are used as argument of make_machine_code
  # (such as the PSEUDOFUNs) need to make sure to align them properly for the
  # HEAPCODES object representation. Fortunately, modules cannot define
  # PSEUDOFUNs, therefore we don't need to apply this to the MODULE_CFLAGS.
  # encoding.d, stream.d, hashtabl.d, predtype.d define PSEUDOFUNs.
  # funarg.d defines test functions for list.d.
  # socket.d needs this flag, too, for ONE_FREE_BIT_HEAPCODES on Linux/x86_64. Very bizarre.
  if [ $f = encoding -o $f = stream -o $f = hashtabl -o $f = predtype -o $f = funarg -o $f = socket ] ; then
    flags2=$flags2" ${FALIGNFLAGS}"
  fi
  if [ $f = genclisph -a $XCC_GCC = true ] ; then
    # When using -O2 or higher, the compilation of genclisph.c takes several
    # minutes, which is unnecessary since it gets run only once.
    # When using -O0, the compilation of genclisph.c fails on AIX:
    # "1252-171 The displacement must be greater than or equal to -32768 and less than or equal to 32767."
    flags2=$flags2' -O1'
  fi
  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.
    echotab "${XCC} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -DUSG -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 : ${SRCDIR}${f}-macro.c"
    echotab "${XCPP} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} ${SRCDIR}${f}-macro.c > ${f}.i"
    echol
    echol "${f}.s : ${SRCDIR}${f}-macro.c"
    if false; then # old
      echotab "${XCPP} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} ${SRCDIR}${f}-macro.c > ${f}.i.c"
      echotab "${XCC} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -c ${f}.i.c /FAs /Fa${f}.s"
      echotab "\$(RM) ${f}.i${TOBJ}"
      echotab "\$(RM) ${f}.i.c"
    else
      echotab "${XCC} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -c ${SRCDIR}${f}-macro.c /FAs /Fa${f}.s"
      echotab "\$(RM) ${f}-macro${TOBJ}"
    fi
    echol
    echol "${f}${TOBJ} : ${SRCDIR}${f}-macro.c"
    if false; then # old
      echotab "${XCPP} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} ${SRCDIR}${f}-macro.c > ${f}.i.c"
      echotab "${XCC} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -c ${f}.i.c /Fo${f}${TOBJ}"
      echotab "\$(RM) ${f}.i.c"
    else
      echotab "${XCC} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -c ${SRCDIR}${f}-macro.c /Fo${f}${TOBJ}"
    fi
    echol
  else
    echol "${f}${TOBJ} : ${f}.s"
    # Call the assembler, preferrably through the C compiler:
    if [ $f = ari_asm_hppa ] ; then
      # Only the native as groks the .SHORTDATA statements in ari_asm_hppa.d
      echotab "${XCC} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -c ${f}.s || /usr/ccs/bin/as ${f}.s -o ${f}${TOBJ} || /bin/as ${f}.s -o ${f}${TOBJ}"
    elif [ $XCC_GCC = true ] ; then
      echotab "${XCC} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -x assembler -c ${f}.s"
    else
      echotab "${XCC} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_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)"
    case "$host_os" in
      solaris*)
        # The non-GNU dgettext() function in Solaris libc needs symbolic links.
        # For the list of locale names, see spvw_language:init_language().
        for localename in en_US de_DE fr_FR es_ES nl_NL ru_RU da_DK sv_SE; do
          ll=`echo "${localename}" | sed -e 's/_.*//'`
          echotab "test -d 'locale/${localename}.UTF-8/LC_MESSAGES' || ln -s '${ll}' 'locale/${localename}.UTF-8'"
        done
        ;;
    esac
  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} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} ${A_XLDFLAGS} ${XLDFLAGS} ${Z_XLDFLAGS} \$(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} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} ${A_XLDFLAGS} ${XLDFLAGS} ${Z_XLDFLAGS} \$(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} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} ${A_XLDFLAGS} ${XLDFLAGS} ${Z_XLDFLAGS} \$(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

echol "marc.out : lisp${LEXE}"
echotab "${HERE}lisp${LEXE} -marc > marc.out"
echol

case "$host_os" in
  haiku*) CONFIG=cfghaiku ;;
  *)      CONFIG=cfg${TOS} ;;
esac
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
    # https://cygwin.com/ml/cygwin/2005-08/msg00460.html
    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 ";"
    # <https://sourceforge.net/p/mingw/mailman/message/18351247/>
    # <https://sourceforge.net/p/clisp/mailman/message/18541077/>
    # <https://sourceforge.net/p/clisp/mailman/message/18996399/>
    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-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"
  # Check for decent behaviour when stdin is not readable
  # (cf. https://sourceforge.net/p/clisp/bugs/523/)
  case "$host_os" in
    aix*)
      # On AIX 7.1, inside 'make' or 'gmake', a command that has stdin with
      # mode O_RDWR gets the current stdin or tty assigned to stdin instead.
      # This would make the test hang. 'bash -c' is the workaround. Whereas
      # 'sh -c' would not help.
      if type bash >/dev/null 2>/dev/null; then
        echotab "bash -c '\$(RUN) -q -M lispinit.mem 0>/dev/null'"
      fi
      ;;
    *)
      echotab "\$(RUN) -q -M lispinit.mem 0>/dev/null"
      ;;
  esac
  TRCR="| tr -d '\r'"; TRLF="| tr '\n' '_'"
  echotab "output=\`echo '(princ (+ 11 99))' | \$(RUN) -q -M lispinit.mem - ${TRCR}\`; test \"\$\$output\" = 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"
  echotab "\$(RM) script.lisp; echo '(eval-when (:compile-toplevel) (princ *args*))' > script.lisp"
  echotab "output=\`\$(RUN) -q -q -M lispinit.mem -c script.lisp foo bar\`; test \"\$\$output\" = '(foo bar)' || exit 1"
  if [ "$HOS" != win32 ]; then # woe32 has unpredictable exit codes
    # https://sourceforge.net/p/clisp/mailman/message/20318073/
    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 "output=\`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}\`; test \"\$\$output\" = 42 || exit 1"
  echotab "\$(RM) script.lisp; echo '(+ 11 99)' > script.lisp"
  echotab "output=\`\$(RUN) -q -M lispinit.mem < script.lisp ${TRCR}\`; test \"\$\$output\" = 110 || exit 1"
  echotab "\$(RM) script.lisp; echo '(princ (+ 11 99))' > script.lisp"
  echotab "output=\`\$(RUN) -q -M lispinit.mem script.lisp ${TRCR}\`; test \"\$\$output\" = 110 || exit 1"
  echotab "\$(RM) script.lisp; echo '(+ foo bar)' > script.lisp"
  echotab "output=\`\$(RUN) -q -M lispinit.mem -x '(setq foo 11 bar 99)' -repl < script.lisp ${TRCR}${TRLF}\`; test \"\$\$output\" = 99_110_ || exit 1"
  # "-x with lisp-file is invalid"
  # echotab "\$(RM) script.lisp; echo '(princ (+ foo bar))' > script.lisp"
  # echotab "output=\`\$(RUN) -q -M lispinit.mem -x '(setq foo 11 bar 99)' -repl script.lisp ${TRCR}${TRLF}\`; test \"\$\$output\" = 99_110_ || exit 1"
  if [ "$HOS" != win32 ]; then # woe32 has unpredictable exit codes (see above)
    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 "output=\`\$(RUN) -q -M lispinit.mem < script.lisp ${TRCR}\`; test \"\$\$output\" = 42 || exit 1"
  echotab "output=\`\$(RUN) -q -M lispinit.mem script.lisp ${TRCR}\`; test \"\$\$output\" = 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 "output=\`\$(RUN) -q -M lispinit.mem < script.lisp ${TRCR}\`; test \"\$\$output\" = 42 || exit 1"
  echotab "output=\`\$(RUN) -q -M lispinit.mem script.lisp ${TRCR}\`; test \"\$\$output\" = 42 || exit 1"
  case "$host_os"  in
    darwin* )
      # http://stackoverflow.com/questions/29112446/nohup-doesnt-work-with-os-x-yosmite-get-error-cant-detach-from-console-no-s
      # http://stackoverflow.com/questions/23898623/nohup-cant-detach-from-console
      ;;
    * )
      echotab "\$(RM) script.lisp; nohup \$(RUN) -q -M lispinit.mem -x 42 2>&1 > script.lisp; output_last_line=\`sed -n -e '\$\$p' script.lisp ${TRCR}\`; test \"\$\$output_last_line\" = 42 || exit 1 "
      ;;
  esac
  echotab "\$(RM) script.lisp script.fas script.lib"
  RAISE='(setq *error-output* *standard-output*) (error "myerror")'
  echotab "output=\"\`\$(RUN) -q -M lispinit.mem -x '(progn ${RAISE})' ${TRCR}\`\"; test \"\$\$output\" = '*** - myerror' || exit 1"
  echotab "if \$(RUN) -q -M lispinit.mem -x '(progn ${RAISE})'; then exit 1; fi"
  case "$host_os" in
    aix* | hpux* | beos* | haiku* | minix* | mingw*)
      # On these platforms, there is no /dev/fd/1.
      ;;
    *)
      echotab "\$(RUN) -q -M lispinit.mem -x '(truename (make-stream :output))'"
      echotab "\$(RUN) -q -M lispinit.mem -x '(truename (make-stream :output))'|cat"
      ;;
  esac
  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.lisp -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.lisp ."
    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 .git + 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
  # FIXME: temp hack to work around:
  #  * clisp.org redirects to SourceForge which is HTTPS-only
  #  * CLISP does not support HTTPS yet
  #MYIMPROOT=http://clisp.org/beta/impnotes/
  MYIMPROOT=http://www.gnu.org/software/clisp/impnotes/
  MYTESTURL=${MYIMPROOT}id-href.map
  if test -d "${SRCTOPDIR_}.git" \
     && { 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 "IMPNOTES = \"${MYIMPROOT}\""
    echol "CLHSROOT = \"${hyperspec}\""
    echol "check-doc: clisp${TEXE} base"
    echotab 'IMPNOTES=$(IMPNOTES) ./clisp'" ${someflags} -x '(sys::ensure-impnotes-map t)'"
    echotab 'CLHSROOT=$(CLHSROOT) ./clisp'" ${someflags} -x '(sys::ensure-clhs-map)'"
    echol
  fi

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

  EXTRACHECK_DEPS=
  # TODO: Enable this check only on those platforms where it is
  # supported (Linux, FreeBSD, etc.), or disable it on those platforms
  # where it is known to be not supported (OpenBSD, etc.).
  EXTRACHECK_DEPS="${EXTRACHECK_DEPS} check-exec-image"

  # check that the executable images work
  EXEIMG=image
  OBSOLETE="$OBSOLETE $(exefiles ${EXEIMG}) ${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 (https://sourceforge.net/p/clisp/bugs/519/)
  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 '$(RUN) -M lispinit.mem -x "(saveinitmem \"'"${EXEIMG}"'\" :executable t :norc t :quiet t :init-function (function exit))"'
  echotab ${HERE}${EXEIMG}${HEXE}
  echotab "test -z \"\`${HERE}${EXEIMG}${HEXE}\`\" || exit 1"
  echotab '$(RUN) -M lispinit.mem -x '"'"'(saveinitmem "'"${EXEIMG}"'" :executable t :norc t :quiet t :init-function (lambda () '"${RAISE}))'"
  echotab "output=\"\`${HERE}${EXEIMG}${HEXE} -on-error exit ${TRCR}\`\"; test \"\$\$output\" = '*** - myerror' || exit 1"
  echotab "if ${HERE}${EXEIMG}${HEXE} -on-error exit; then exit 1; fi"
  echotab '$(RUN) -M lispinit.mem -x '"'"'(saveinitmem "'"${EXEIMG}"'" :executable t :norc t :quiet t :init-function (lambda () (exit-on-error '"${RAISE})))'"
  echotab "output=\"\`${HERE}${EXEIMG}${HEXE} ${TRCR}\`\"; test \"\$\$output\" = '*** - myerror' || exit 1"
  echotab "if ${HERE}${EXEIMG}${HEXE}; then exit 1; fi"
  echotab "-ls -l lisp${LEXE} lispinit.mem ${EXEIMG}${HEXE} ${EXEIMG}.mem"
  echotab "\$(RM) ${EXEIMG}${HEXE} ${EXEIMG}.mem"
  echol

  echol "# Perform extra tests."
  echol "# Failure of these does not indicate that the built clisp is unusable,"
  echol "# but rather than some non-vital features are not supported."
  echol "extracheck : ${EXTRACHECK_DEPS}"
  echodummyrule extracheck
  echol
  echol
fi

if [ $XCC_GCC = true ] ; then
  echol "lispbibl.h :${EVERY_INCLUDES_C}${EVERY_INCLUDES_H}"
  echotab "( (${XCPP} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_XCFLAGS} -P lispbibl.c | \$(GREP) -v \"^ *\$\$\") ; (${XCPP} ${A_XCPPFLAGS} ${XCPPFLAGS} ${Z_XCPPFLAGS} ${A_XCFLAGS} ${XCFLAGS} ${Z_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} ${GLLIB_A}"
echotab_to_HEXE "\$(CC) \$(A_CFLAGS) \$(CFLAGS) \$(Z_CFLAGS) \$(A_LDFLAGS) \$(LDFLAGS) \$(Z_LDFLAGS)" "genclisph.o" "genclisph"
if test -z "${CLISP_DEF}"; then
  echotab "${HERE}genclisph clisp.h.tmp clisp-test.c"
else
  echotab "${HERE}genclisph clisp.h.tmp clisp-test.c ${CLISP_DEF}"
  # new-clx depends on the symbol "hostent_to_lisp", which is defined in the
  # syscalls module and therefore doesn't get put into lisp.def on Cygwin.
  # So we just force it.
  echotab "echo -e \"\tlisp.exe.hostent_to_lisp\" >> ${CLISP_DEF}"
fi
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 */' ; cat clisp.h.tmp; echo ; echo '#endif /* _CLISP_H */') >> clisp.h"
echotab_to_HEXE "\$(CC) \$(A_CPPFLAGS) \$(CPPFLAGS) \$(Z_CPPFLAGS) \$(A_CFLAGS) \$(CFLAGS) \$(Z_CFLAGS) \$(A_LDFLAGS) \$(LDFLAGS) \$(Z_LDFLAGS) -I. -DUSE_CLISP_H=1 -DCOMPILE_STANDALONE" "clisp-test.c ${GLLIB_A}" "clisp-test-clisp"
echotab_to_HEXE "\$(CC) \$(A_CPPFLAGS) \$(CPPFLAGS) \$(Z_CPPFLAGS) \$(A_CFLAGS) \$(CFLAGS) \$(Z_CFLAGS) \$(A_LDFLAGS) \$(LDFLAGS) \$(Z_LDFLAGS) -I. -DUSE_CLISP_H=0 -DCOMPILE_STANDALONE" "clisp-test.c ${GLLIB_A}" "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 "\$($EXERM) $(exefiles genclisph) clisp.h.tmp $(exefiles clisp-test-clisp) $(exefiles clisp-test-lispbibl) clisp-test-clisp.out clisp-test-lispbibl.out"
OBSOLETE="$OBSOLETE clisp-test.c $(exefiles genclisph)"
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)'\"'\" ;\\"
echotab " echo 'LDFLAGS='\"'\"'\$(MODULE_LDFLAGS)'\"'\" ;\\"
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%@''SHELL''@%/bin/sh%' \\"
  echotab "    -e 's%@with_dynamic_modules@%${with_dynamic_modules}%' \\"
  echotab "    -e 's%@createsharedlib@%$XCC_CREATESHARED_%' \\"
  echotab "    -e 's%@LEXE@%${LEXE}%' -e 's%@SHREXT@%${SHREXT}%' \\"
  # On Cygwin, "-L$sourcedir$" is not enough for the linker to find
  # lisp.def.  So just give the absolute path to lisp.def.
  if test -z "${CLISP_DEF}"; then
    echotab "    -e 's%@CLISP_DEF@%%' \\"
  elif [ "${HSYSOS}" = cygwin ]; then
    echotab "    -e 's%@CLISP_DEF@%\$\$absolute_sourcedir/lisp.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
make_modules() {
  MODULES_VAR=$1
  LINKING_SET=$2
  MODULE_NAME=$3         # Some "make"s don't support empty target lists
  echol "${MODULE_NAME} \$(${MODULES_VAR}) : ${LINKING_SET} clisp${TEXE} linkkit force"
  echotab 'mkdir -p $@'
  echotab "m=\`cd ${MODULESDIR_}\$@; pwd\`; \\"
  # 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.
  # The 'if' condition here tests whether $$m/configure is newer than $@/config.status.
  echotab "if test -f \$\$m/configure && { test ! -f \$@/config.status || test -n \"\`find \$\$m/configure -prune -newer \$@/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 ${LINKING_SET} ${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.
  # The 'if' condition here tests whether $$m/Makefile is newer than $@/Makefile.
  echotab "if test -f \$\$m/Makefile && { test ! -f \$@/Makefile || test -n \"\`find \$\$m/Makefile -prune -newer \$@/Makefile\`\"; } ; then \\"
  echotab "  sed \"s,srcdir = .,srcdir = \$\$m,\" \"\$\$m/Makefile\" > \$@/Makefile ; \\"
  echotab "fi ; \\"
  echotab "CLISP=\"${HEREP}/clisp -K ${LINKING_SET} ${someflags}\" ; \\"
  echotab "cd \$@ ; \$(MAKE) clisp-module CC=\"\$(CC)\" CPPFLAGS=\"\$(MODULE_CPPFLAGS)\" CFLAGS=\"\$(MODULE_CFLAGS)\" LDFLAGS=\"\$(MODULE_LDFLAGS)\" LIBS=\"\$(LIBS)\" RANLIB=\"\$(RANLIB)\" CLISP=\"\$\$CLISP -q\" SHREXT=${SHREXT}"
  echol
}
make_modules BASE_MODULES boot basemodule
make_modules MODULES base fullmodule

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="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=' -I. -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} ${GLLIB_A}"
  g="gen-${f}"
  # The naïve choice of the executable name g would lead to the error
  # "xlc: 1501-218 (S) file gen-clisp.c contains an incorrect file suffix" on AIX.
  g=`echo "${g}" | sed -e 's/[.]//g'`
  echotab "\$(TXT2C) < ${sourcedir}_${f} > ${g}.c"
  echotab_to_HEXE "\$(CC) \$(A_CPPFLAGS) \$(CPPFLAGS) \$(Z_CPPFLAGS) \$(A_CFLAGS) \$(CFLAGS) \$(Z_CFLAGS)${flags} \$(A_LDFLAGS) \$(LDFLAGS) \$(Z_LDFLAGS)${XCC_NOOPTFLAGS}" "${g}.c ${GLLIB_A}" "${g}"
  line="${HERE}${g}"
  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
  echotab "${line} > ${f}"
  echotab "\$($EXERM) ${g}.c $(exefiles ${g})"
  echol
  OBSOLETE=$OBSOLETE" ${g}.c $(exefiles ${g})"
done

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/\./,/g' -e 's/\+//g'`
    case "${PRODUCTVERSION}" in
      *,*,*,* ) ;;
      *,*,* ) PRODUCTVERSION="${PRODUCTVERSION},0" ;;
      *,* ) PRODUCTVERSION="${PRODUCTVERSION},0,0" ;;
    esac
    FILEFLAGS="0"
    if [ "${with_debug}" != no ] ; then
      FILEFLAGS="${FILEFLAGS}|VS_FF_DEBUG"
    fi
    case "${VERSION_NUMBER}" in
      *++) FILEFLAGS="${FILEFLAGS}|VS_FF_PRERELEASE|VS_FF_PATCHED" ;;
      *+)  FILEFLAGS="${FILEFLAGS}|VS_FF_PATCHED" ;;
    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
  echol "clisp${TEXE} : clisp.c${DRIVER_DEP}"
  echotab "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(LDFLAGS) -DENABLE_RELOCATABLE clisp.c${DRIVER_RES} ${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)"
    if test -n "$USE_GETTEXT"; then
      echotab "cd po && \$(MAKE) installdirs DESTDIR='\$(DESTDIR)' prefix='\$(prefix)' exec_prefix='\$(exec_prefix)'"
      case "$host_os" in
        solaris*)
          # The non-GNU dgettext() function in Solaris libc needs symbolic links.
          # For the list of locale names, see spvw_language:init_language().
          echotab "mkdir -p \$(DESTDIR)\$(prefix)/share/locale"
          for localename in en_US de_DE fr_FR es_ES nl_NL ru_RU da_DK sv_SE; do
            ll=`echo "${localename}" | sed -e 's/_.*//'`
            echotab "test -d '\$(DESTDIR)\$(prefix)/share/locale/${localename}.UTF-8/LC_MESSAGES' || ln -s '${ll}' '\$(DESTDIR)\$(prefix)/share/locale/${localename}.UTF-8'"
          done
          ;;
      esac
    fi
    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}"
    if test -n "$USE_GETTEXT"; then
      echotab "cd po && \$(MAKE) install DESTDIR='\$(DESTDIR)' prefix='\$(prefix)' exec_prefix='\$(exec_prefix)'"
      case "$host_os" in
        solaris*)
          # The non-GNU dgettext() function in Solaris libc needs symbolic links.
          # For the list of locale names, see spvw_language:init_language().
          echotab "mkdir -p \$(DESTDIR)\$(prefix)/share/locale"
          for localename in en_US de_DE fr_FR es_ES nl_NL ru_RU da_DK sv_SE; do
            ll=`echo "${localename}" | sed -e 's/_.*//'`
            echotab "test -d '\$(DESTDIR)\$(prefix)/share/locale/${localename}.UTF-8/LC_MESSAGES' || ln -s '${ll}' '\$(DESTDIR)\$(prefix)/share/locale/${localename}.UTF-8'"
          done
          ;;
      esac
    fi
    echotab "\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(LDFLAGS) -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 https://www.gnu.org/software/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) \$(A_CPPFLAGS) \$(CPPFLAGS) \$(Z_CPPFLAGS) \$(A_CFLAGS) \$(CFLAGS) \$(Z_CFLAGS) \$(A_LDFLAGS) \$(LDFLAGS) \$(Z_LDFLAGS) -DLISPLIBDIR='\"\$(lisplibdir)\"' -DLOCALEDIR='\"\$(localedir)\"'" "clisp.c ${GLLIB_A}" "\$(TOPDIR)/clisp"
  echotab_to_HEXE "\$(CC) \$(A_CPPFLAGS) \$(CPPFLAGS) \$(Z_CPPFLAGS) \$(A_CFLAGS) \$(CFLAGS) \$(Z_CFLAGS) \$(A_LDFLAGS) \$(LDFLAGS) \$(Z_LDFLAGS) -I." "${UTILDIR_CC}hardcode.c ${GLLIB_A}" "\$(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
	-\$($EXERM) 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} marc.out clisp-link makevars ansi-tests-log ${CLISP_DEF}
	for m in "" \$(BASE_MODULES) \$(MODULES); do test -n "\$\$m" && \$(RM) \$\$m/*${TOBJ}; done
	-\$(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="$(exefiles clisp) clisp.rc"
for f in ${UTILS}; do line=$line" $(exefiles ${f})"; done
echotab "-\$($EXERM) ${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 "if test -d ${dir}; then cd ${dir} && \$(MAKE) clean; fi"
done
echol
# this must be run before clean7 because it runs "cd ..; make am--refresh"
echol "distclean-subdirs :"
for dir in ${SUBDIRS}; do
  echotab "if test -d ${dir}; then cd ${dir} && \$(MAKE) distclean; fi"
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
