#!/bin/sh

ID='$Id: configure,v 1.429 2022-03-31 19:58:27 phil Exp $'

# Create config.m4, config.sno and config.h for SNOBOL4 compilation
#
# Phil Budne
# August 24, 1996

OPTIONS="$*"

# needed in Makefile2 and config.h
VERSION=2.3.1
VERSION_DATE="March 31, 2022"

# save any CFLAGS passed to us...
INITIAL_CFLAGS="$CFLAGS"

# largefile support OK
LARGEFILE_OK=true

# inline by default
INLINE_OK=true

VSIZE=32

# debug this script
DEBUG=

PREFIX=/usr/local

OS=`(uname -s || echo unknown) 2>/dev/null`
OSREL=`(uname -r || echo unknown) 2>/dev/null`
OSVERS=`(uname -v || echo unknown) 2>/dev/null`
MACHINE=`(uname -m || echo unknown) 2>/dev/null`

case "$OS" in
MINGW*)
    echo "MinGW detected; run make -f config/win32/mingw.mak"
    exit 1
    ;;
esac

DATE=`date`

# run hostname from subshell to redirect shell "not found message"
HOST=`(hostname) 2>/dev/null || uname -n`

VERSION_H=version.h.tmp
CONFIG_H=config.h.tmp
CONFIG_M4=config.m4.tmp
CONFIG_SNO=config.sno.tmp

# DANGER: It's no longer safe to try to grep include files
# (too many systems move them around), do not add new usage,
# use config/check instead!!
INCDIR=/usr/include

rm -f $CONFIG_H $CONFIG_M4 $VERSION_H $CONFIG_SNO
trap "rm -f $CONFIG_H $CONFIG_M4 $CONFIG_SNO; exit 1" 1 2 15

echo "# config generated "$DATE			>> $CONFIG_M4
echo "# on $HOST ($OS)"				>> $CONFIG_M4
echo "# by $ID"					>> $CONFIG_M4
if [ "x$OPTIONS" != x ]; then
   echo "# options: $OPTIONS"			>> $CONFIG_M4
fi
echo 'undefine([include])'			>> $CONFIG_M4

echo "# config generated "$DATE			>> $CONFIG_SNO

################
# most defines now in config.h so seperately compiled
# (LOAD()able) files can get the config information!!

echo 'ADD_CPPFLAGS([-DHAVE_CONFIG_H])'		>> $CONFIG_M4
echo '# see config.h for more defines'		>> $CONFIG_M4

echo '/*'					>> $VERSION_H
echo ' * generated '$DATE			>> $VERSION_H
echo ' * on '"$HOST ($OS)"			>> $VERSION_H
echo ' * by '"$ID"				>> $VERSION_H
echo ' */'					>> $VERSION_H
echo ''						>> $VERSION_H
echo '#define VERSION "'$VERSION'"'		>> $VERSION_H
echo '#define VERSION_DATE "'$VERSION_DATE'"'	>> $VERSION_H
echo "VERS=$VERSION"				>> $CONFIG_M4

echo '/*'					>> $CONFIG_H
echo ' * generated '$DATE			>> $CONFIG_H
echo ' * on '"$HOST ($OS)"			>> $CONFIG_H
echo ' * by '"$ID"				>> $CONFIG_H
echo ' */'					>> $CONFIG_H
echo ''						>> $CONFIG_H

# for windows install.bat
echo $VERSION					> version

if [ "x$OPTIONS" != x ]; then
    echo '#define CONFIG_OPTIONS "'"$OPTIONS"'"' >> $CONFIG_H
fi
if [ "x$HOST" != x ]; then
    echo '#define CONFIG_HOST "'"$HOST"'"'	>> $CONFIG_H
fi
echo '#define CONFIG_DATE "'$DATE'"'		>> $CONFIG_H

ADD_DEFINE_USED=
INSTALL_DOCS=yes
ALLOW_LIBREADLINE=true
ALLOW_LIBEDIT=true
while [ $# -gt 0 ]; do
    case "$1" in
    --add-cflags=*)
	STUFF=`echo "$1" | sed 's/--add-cflags=//'`
	echo 'ADD_CFLAGS(['"$STUFF"'])'		>> $CONFIG_M4
	;;
    --add-cppflags=*)
	STUFF=`echo "$1" | sed 's/--add-cppflags=//'`
	echo 'ADD_CPPFLAGS(['"$STUFF"'])'	>> $CONFIG_M4
	;;
    --add-define=*)
	if [ ! "$ADD_DEFINE_USED" ]; then
	    echo '/* from command line: */'	>> $CONFIG_H
	    ADD_DEFINE_USED=true
	fi
	STUFF=`echo "$1" | sed -e 's/--add-define=//' -e 's/=/ /'`
	echo '#define '"$STUFF"			>> $CONFIG_H
	;;
    --add-ldflags=*)
	# flags for snobol4 AND loadable modules
	STUFF=`echo "$1" | sed 's/--add-ldflags=//'`
	# make available to config/check script:
	LDFLAGS="$LDFLAGS $STUFF"
	export LDFLAGS
	;;
    --add-objs=*)
	STUFF=`echo "$1" | sed 's/--add-objs=//'`
	echo 'ADD_OBJS(['"$STUFF"'])'		>> $CONFIG_M4
	;;
    --add-opt=*)
	STUFF=`echo "$1" | sed 's/--add-opt=//'`
	echo 'ADD_OPT(['"$STUFF"'])'		>> $CONFIG_M4
	;;
    --add-snobol4-ldflags=*)
	STUFF=`echo "$1" | sed 's/--add-snobol4-ldflags=//'`
	echo 'ADD_SNOBOL4_LDFLAGS(['"$STUFF"'])' >> $CONFIG_M4
	;;
    --add-srcs=*)
	STUFF=`echo "$1" | sed 's/--add-srcs=//'`
	echo 'ADD_SRCS(['"$STUFF"'])'		>> $CONFIG_M4
    	;;
    --add-warn=*)
	# deprecated: exactly the same as --add-flags!
	STUFF=`echo "$1" | sed 's/--add-warn=//'`
	echo 'ADD_CFLAGS(['"$STUFF"'])'		>> $CONFIG_M4
	;;
    --bindir=*)
	STUFF=`echo "$1" | sed 's/--bindir=//'`
	echo "BINDIR=$STUFF"			>> $CONFIG_M4
    	;;
    --snolibdir=*)
	SNOLIB_BASE=`echo "$1" | sed 's/--snolibdir=//'`
    	;;
    --debug)
	DEBUG=true
	DEBUG_CHECK=true
	export DEBUG_CHECK
	set -x
	;;
    --double)
	DOUBLE=true
	;;
    --fast)
	FAST=true
	;;
    --force-sdbm)
	FORCE_SDBM=true
	;;
    --longlong)
	LONGLONG=true
	;;
    --lp64)
	LP64=true
	;;
    --mandir=*)
	MANDIR=`echo "$1" | sed 's/--mandir=//'`
    	;;
    --no-bitfields)
	NO_BITFIELDS=true
	;;
    --no-inline)
	INLINE_OK=
	;;
    --no-largefile)
	LARGEFILE_OK=
	;;
    --no-opt)
	NO_OPT=true
	;;
    --opt=*)
	# NOTE!! just sets shell variable
	UOPT=`echo "$1" | sed 's/--opt=//'`
	if [ "x$UOPT" = x ]; then
		NO_OPT=true
	else
		NO_OPT=
	fi
	;;
    --prefix=*)
	PREFIX=`echo "$1" | sed 's/--prefix=//'`
	;;
    --without-com)
	WITHOUT_COM=1
	;;
    --without-docs)
	INSTALL_DOCS=
	;;
    --without-modules)
	# breaks tests, sdb (debugger)!!!
	WITHOUT_MODULES=1
	;;
    --without-libedit)
	ALLOW_LIBEDIT=false
	;;
    --without-libreadline)
	ALLOW_LIBREADLINE=false
	;;
    --without-readline)
	WITHOUT_READLINE=1
	;;
    --without-blocks)
	WITHOUT_BLOCKS=1
	;;
    --with-docs)
	# symmetric, for FreeBSD ports
	INSTALL_DOCS=1
	;;
    --with-tcl=*)
	TCONF=`echo "$1" | sed 's/--with-tcl=//'`
	if [ "x$TCONF" = x ]; then
	    echo " --with-tcl requires path to tclConfig.sh" 1>&2
	elif [ -d "$TCONF" -a -f "$TCONF/tclConfig.sh" ]; then
	    TCONF="$TCONF/tclConfig.sh"
	elif [ ! -f "$TCONF" ]; then
	    echo "$TCONF is not a file or directory" 1>&2
	    exit 1
	fi
	;;
    --xxl)
	# EXPERIMENTAL (undocumented):
	# allow objects larger than 2^32 descriptors for Dani Richard.
	# 64-bit V field on 64-bit systems (24 byte descriptors)
	# Breaks loadable extension ABI (must recompile)
	XXL=true
	;;
    '')
	;;
    *)
	cat 1>&2 <<EOF
Unknown option $1

Makefile additions;
	--add-cflags=STR	--add-cppflags=STR	
	--add-define=NAME[=VALUE] --add-ldflags=STR
	--add-objs=STR		--add-srcs=STR
	--add-snobol4-ldflags=STR

C Compiler settings;
	--add-cflags=STR	--opt=STR
	--add-warn=STR		--fast
	--no-inline

SNOBOL4 Datatype selection;
	--double		--longlong
	--lp64			--no-bitfields

C Library support selection;
	--no-largefile

Install location;
	--prefix=PATH		[default: /usr/local]
	--bindir=PATH		[default: PREFIX/bin]
	--mandir=PATH		[default: PREFIX/share/man]
	--snolibdir=PATH	[default: PREFIX/lib/snobol4]

Optional items;
	--force-sdbm
	--with-tcl=/path/to/tclConfig.sh
	--with-docs		--without-docs
	--without-blocks	--without-com
	--without-libreadline	--without-libedit
	--without-modules	--without-readline
EOF

	rm -f $CONFIG_M4 $CONFIG_H
	exit 1
	;;
    esac
    shift
done

BINDIR="$PREFIX/bin"
if [ "x$MANDIR" = x ]; then
    # config filename varies:
    #	/etc/manpaths (OSX 10.6)
    #   /etc/manpath.config (FreeBSD 7)
    #	/etc/man.config (RHEL 6)
    # Thoughts: if both present in config file, check in that order
    # for existance of "man1" subdir.
    SD="$PREFIX/share/man"
    if grep "$SD" /etc/man* >/dev/null 2>&1; then
	MANDIR="$SD"
    else
	MANDIR="$PREFIX/man"
    fi
fi
MAN1DIR="$MANDIR/man1"
MAN3DIR="$MANDIR/man3"
MAN7DIR="$MANDIR/man7"
if [ "x$SNOLIB_BASE" = x ]; then
    SNOLIB_BASE="$PREFIX/lib/snobol4"
fi
SNOLIB="$SNOLIB_BASE/$VERSION"
SNOLIB_LIB="$SNOLIB/lib"
SNOLIB_LOCAL="$SNOLIB/local"
SNOLIB_DOC="$SNOLIB"
# XXX use $PREFIX/include/snobol4 ???
INCLUDE_DIR="$SNOLIB/include"

DOC_DIR="$PREFIX/share/doc/snobol4-$VERSION"

echo 'BINDIR=$(DESTDIR)'"$BINDIR"		>> $CONFIG_M4
echo 'MANDIR=$(DESTDIR)'"$MANDIR"		>> $CONFIG_M4
echo 'MAN1DIR=$(DESTDIR)'"$MAN1DIR"		>> $CONFIG_M4
echo 'MAN3DIR=$(DESTDIR)'"$MAN3DIR"		>> $CONFIG_M4
echo 'MAN7DIR=$(DESTDIR)'"$MAN7DIR"		>> $CONFIG_M4
echo 'SNOLIB=$(DESTDIR)'"$SNOLIB_BASE"		>> $CONFIG_M4
echo 'SNOLIB_LIB=$(DESTDIR)'"$SNOLIB_LIB"	>> $CONFIG_M4
echo 'SNOLIB_LOCAL=$(DESTDIR)'"$SNOLIB_LOCAL"	>> $CONFIG_M4
echo 'SNOLIB_DOC=$(DESTDIR)'"$SNOLIB_DOC"	>> $CONFIG_M4
echo 'INCLUDE_DIR=$(DESTDIR)'"$INCLUDE_DIR"	>> $CONFIG_M4
echo 'DOC_DIR=$(DESTDIR)'"$DOC_DIR"		>> $CONFIG_M4

echo "	MAN3DIR = '$MAN3DIR'"			>> $CONFIG_SNO

if [ "$ADD_DEFINE_USED" ]; then
    echo '/* end defines from command line */'	>> $CONFIG_H
fi

# HOST() values (why didn't I just put them into an -INCLUDE file?)
echo '#define DIR_SEP "/"'			>> $CONFIG_H
echo '#define PATH_SEP ":"'			>> $CONFIG_H
echo '#define OBJECT_EXT ".o"'			>> $CONFIG_H
echo '#define SETUP_SYS "posix"'		>> $CONFIG_H
echo '#define SHARED_OBJ_SUBDIR "shared"'	>> $CONFIG_H

# safe on all Unix systems (requires "fork")
echo '#define PML_SERV'				>> $CONFIG_H

if [ "$CC" ]; then
    echo 'using CC environment variable' 1>&2
    CCPATH="$CC"
else
    CCPATH=cc
fi

TMP=conf$$

echo "checking $CCPATH" 1>&2
    # vanilla bsd43 systems can't use <<- AND EOF must be in col 0!
    cat << EOF > $TMP.c
#include <stdio.h>
int
main() {
/* before clang, gcc */
#if (defined(__ICC) || defined(__INTEL_COMPILER))
#define COMPILER "icc"
#endif

#if !defined(COMPILER) && defined(__clang__)
#define COMPILER "clang"
#endif

/* after anything that might imitate gcc for compatibility */
#if !defined(COMPILER) && (defined(__gcc__) || defined(__GNUC__))
#define COMPILER "gcc"
#endif

#ifdef __SUNPRO_C
#undef COMPILER
#define COMPILER "sunpro"
#endif

#ifndef COMPILER
#define COMPILER "unknown"
#endif
    /* clang bitches that puts() deprecated in C99! */
    printf("%s\n", COMPILER);
    return 0;
}
EOF
if $CCPATH -o $TMP $TMP.c; then
    CC_IS=`./$TMP`
    if [ "$CC_IS" ]; then
	echo "$CCPATH is $CC_IS" 1>&2
	echo "# $CCPATH is $CC_IS"		>> $CONFIG_M4
    fi
    rm -f $TMP $TMP.c $TMP.exe
else
    echo $CCPATH failed: status=$? 1>&2
    rm -f $TMP
    exit 1
fi

echo '#define CC_IS "'$CC_IS'"'			>> $CONFIG_H

# nearly generic gcc3 option for LP64
GCC64=-m64

# machine, os, release, version
MORV="${MACHINE}:${OS}:${OSREL}:${OSVERS}"

# library support, C compiler choice, flags
case "$MORV" in
*:Darwin:*:*)
    # includes MacOS X
    # libm integrated into libc
    echo 'MATHLIB='				>> $CONFIG_M4
    # symbol conflict with curses (also in libc)
    echo '#define GT GTX'			>> $CONFIG_H
    ;;

*:CYGWIN*|*:MSYS*)
    # Cygnus Unix emulation under Win32
    # and MSYS2 (fork of Cygwin)
    echo 'EXT=.exe'				>> $CONFIG_M4
    CYGWIN=1
    ;;
esac

################# compiler options

# make implicit function declaration fatal in "check"
case "$CC_IS" in
# NOTE! implicit-function-declaration not valid w/ C++!
gcc|clang) CFLAGS="$CFLAGS -Werror -Wimplicit-function-declaration"; export CFLAGS;;
# guessing here:
#icc)	   CFLAGS="$CFLAGS -Werror -Wall -Wno-unused-variable"; export CFLAGS;;
esac

case "$CC_IS" in
gcc|clang|icc)
    CCVERS=-v
    # was -M: -MM existed in gcc 3.4
    echo 'CCM=$(CC) -MM'			>> $CONFIG_M4
    OPT=-O3

    # on by default in clang??
    echo 'ADD_CFLAGS([-Wall])'			>> $CONFIG_M4

    # disable warnings enabled by default in code generated from SIL;
    # (unused-parameter enabled by -W(extra))
    echo 'SNOBOL4_C_CFLAGS=-Wno-return-type -Wno-switch' >> $CONFIG_M4

    case "$MORV" in
    *:Darwin:*:*)
        if cc -v 2>&1 | grep 19991024 >/dev/null; then
	    # "Apple gcc-934.3, based on gcc version 2.95.2 19991024"
	    # screws up data_init.c when compiled with -O2
	    echo 'DATA_INIT_CFLAGS=[]_CFLAGS $(MYCPPFLAGS) -O' >> $CONFIG_M4
	fi

	# MacOS has different file types for shared libraries (dylibs)
	# and dynamicly loaded extensions (bundles)
	# -fPIC is the default on macOS

	SO_EXT=.dylib
	SO_LD=$CCPATH
	SO_LDFLAGS=-dynamiclib

	DL_EXT=.bundle
	DL_LD=$CCPATH
	DL_LDFLAGS='-bundle -undefined dynamic_lookup'

	# don't strip installed binary; 
	# need symbols to find (m)getstring....
	echo "INSTALL_BIN_FLAGS="	>> $CONFIG_M4

	# try:
	# -exported_symbols_list filename
	# or
	# -exported_symbol getstring ......
	;;

    *:SunOS:4*:*)
	SO_EXT=.so
	SO_CFLAGS=-fPIC
	SO_LD=/usr/bin/ld
	SO_LDFLAGS="-assert nodefinitions $SO_CFLAGS"
	;;

    *:CYGWIN*|*:MSYS*)
	SO_EXT=.dll
	SO_CFLAGS=
	SO_LD=$CCPATH
	# make DLL file, is not PIC!
	SO_LDFLAGS=-shared
	echo 'ADD_SNOBOL4_LDFLAGS([-Wl,--out-implib,libsnobol4.a])' >> $CONFIG_M4

	# also available as  __attribute__ ((dll{im,ex}port))?
	echo '#define IMPORT(TYPE) __declspec(dllimport) TYPE' >> $CONFIG_H
	echo '#define EXPORT(TYPE) __declspec(dllexport) TYPE' >> $CONFIG_H

#	# Equivalent to -rdynamic? IMPORT/EXPORT seem to do the trick!
#	echo 'ADD_SNOBOL4_LDFLAGS([-Wl,--export-all-symbols])' >> $CONFIG_M4

	echo 'define([INSTALL_SYSDEP],[$(INSTALL) -m 644 libsnobol4.a $(SNOLIB_LIB)])' >> $CONFIG_M4
	;;

    *)
	SO_EXT=.so
	SO_CFLAGS=-fPIC
	SO_LD=$CCPATH
	# NOTE: LDFLAGS includes -fPIC on purpose:
	# https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Link-Options.html#index-shared
	#   "For predictable results, you must also specify the same set of
	#   options that were used to generate code (-fpic,-fPIC) when you
	#   specify -shared"
	# and
	# https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Link-Options.html#FOOT1
	#   "On some systems, ‘gcc -shared’ needs to build supplementary
	#   stub code for constructors to work. On multi-libbed systems,
	#   ‘gcc -shared’ must select the correct support libraries to link
	#   against. Failing to supply the correct flags may lead to subtle
	#   defects. Supplying them in cases where they are not necessary
	#   is innocuous."
	SO_LDFLAGS="-shared $SO_CFLAGS"
	;;
    esac # morv

    # -fstrength-reduce is no gain?
    # -fomit-frame-pointer can make debugging harder, so put it here
    #	(on systems where it's harmless, it's turned on by -O)
    FASTFLAGS=-fomit-frame-pointer
    # end gcc|clang|icc
    ;;
*)
    # not gcc, clang or icc
    # required options for native compilers
    case "$MORV" in
    9000/[34]*:HP-UX:*:*)
	# HP-UX 68K
	# bundled C compiler lacks -O flag??
	NO_OPT=true
	;;
    9000/[678]*:HP-UX:*:*)
	# HP-UX PA-RISC
	KERNEL_BITS=`(/usr/bin/getconf SC_KERNEL_BITS || echo 32) 2>/dev/null`
	if [ "$KERNEL_BITS" = 64 -a "$LP64" ]; then
	    ARCH_OPT=`getconf XBS5_LP64_OFF64_CFLAGS`
	fi
	if [ -x /bin/c89 -o -x /usr/bin/c89 ]; then
	    SO_EXT=.sl
	    # or +Z
	    SO_CFLAGS=+z
	    SO_LD=ld
	    SO_LDFLAGS=-b
	fi
	FASTFLAGS=-fast
	;;
    ia64:HP-UX:*:*)
	if [ "$LP64" ]; then
	    # +DA2.0W seen under B.11.22!!
	    ARCH_OPT=`getconf XBS5_LP64_OFF64_CFLAGS | sed 's/+DA2.0W/+DD64/'`
	fi
	if [ -x /bin/c89 -o -x /usr/bin/c89 ]; then
	    SO_EXT=.sl
	    # or +Z
	    SO_CFLAGS=+z
	    SO_LD=ld
	    SO_LDFLAGS=-b
	fi
	FASTFLAGS=-fast
	# works for unbundled compiler
	CCVERS=-V
	;;
    *:IRIX*:*:*)
	echo 'CCM=$(CC) -M'			>> $CONFIG_M4
	FASTFLAGS=-Ofast=$MACHINE
	CCVERS=-version

	# Kill warnings: only needed with n32 and 64bit ABI
	# compilers (but harmless with old compiler)?
	echo 'ADD_CFLAGS([-w])'			>> $CONFIG_M4

	# optional 64-bit world;
	# (only allow if "$OS" = IRIX64 ??
	if [ "$LP64" ]; then
	    ARCH_OPT=`getconf XBS5_LP64_OFF64_CFLAGS`
	    # XXX check if non-null?

	    ARCH_LDFLAGS=`getconf XBS5_LP64_OFF64_LDFLAGS`
	    if [ "x$ARCH_LDFLAGS" != x ]; then
		echo 'ADD_SNOBOL4_LDFLAGS(['$ARCH_LDFLAGS'])'>> $CONFIG_M4
	    fi
	    OPT=-O3
	else
	    # o32 compiler's -O3 wants all files on one line
	    # (to do interprocedural optimization).
	    # n32 compiler's -O3 beats o32 -O2
	    # To override this, use "configure --opt=whatever"
	    OPT='-n32 -O3'
	fi

	SO_EXT=.so
	# -KPIC is default
	SO_CFLAGS=
	# use LD?
	SO_LD=cc
	SO_LDFLAGS=-shared
	;;
    *:AIX:2:3)
	# AIX3 (not tested)
	# for data_init.o
	echo 'ADD_CFLAGS([-qmaxmem=32000])'	>> $CONFIG_M4
	;;
    *:AIX:*:[4-9])
	# AIX4/xlc
	# -M creates .u files
	# -v outputs man page!!
	# -qlonglong enables "long long"?
	# -Q! turns off inlining (C++ only?)
	CFLAGS_LONGLONG=-qlonglong
	if [ "$FAST" ]; then
	    OPT=-O4
	else
	    OPT=-O3
	fi
	# for data_init.o
	echo 'ADD_CFLAGS([-qmaxmem=32000])'	>> $CONFIG_M4

	# XXX check if available? (how?) check for getconf error??
	if [ "$LP64" ]; then
	    ARCH_OPT=`getconf XBS5_LP64_OFF64_CFLAGS`
	    echo 'ARXFLAGS=-X64'		>> $CONFIG_M4
	else
	    # XBS5 model to try if "getconf LFS_CFLAGS" fails
	    XBS5_MODEL=XBS5_ILP32_OFFBIG_CFLAGS
	    # on Sun this assumes native compiler, undefines stuff,
	    # and fiddles with ANSI mode (sets __STDC__ to zero), so
	    # we only use it when the obvious fails!
	fi

	# "AIX 4.3 and later"

	# -G == "-bM:SRE -berok -brtl -bnortllib -bnosymbolic -bnoautoexp"

	# http://www.ibm.com/developerworks/aix/library/au-gnu.html
	# gcc -shared == "-bM:SRE -bnoentry"

	# ftp://plasma-gate.weizmann.ac.il/pub/grace/aux/dlfcn-aix.README says:
	# If you want to reference symbols from the main part of the
	# program in a loaded module, you will have to link against
	# the export file of the main part:
	# cc -o main -bE:main.exp $(MAIN_OBJS)
	# cc -o module.so -bM:SRE -bI:main.exp -bE:module.exp -bnoentry $(OBJS)

	echo 'ADD_SNOBOL4_LDFLAGS([-bE:snobol4.exp])'	>> $CONFIG_M4
	SO_EXT=.so
	SO_LD=ld
	SO_LDFLAGS='-bM:SRE -bnoentry'
	;;
    *:OSF1:*:*)
	OPT=-O4
	if [ ! "$INLINE_OK" ]; then
	    echo 'ADD_OPT([-no_inline])'	>> $CONFIG_M4
	fi
	echo 'CCM=$(CC) -M'			>> $CONFIG_M4

	case "$OSREL" in
	V[1-3].*) ;;
	*) OPT="$OPT -fast" ;;
	esac

	CCVERS=-V

	# no cc flags needed
	SO_EXT=.so
	SO_LD=cc
	# NOTE! quoting make it useless in Makefile!
	SO_LDFLAGS="-shared -expect_unresolved '\\*'"
	;;

    *:SunOS:4*:*)
	# SunOS 4 cc
	echo 'CCM=$(CC) -M'			>> $CONFIG_M4
	OPT=-O2
	# cc can't optimize data_init.c at ALL
	echo 'DATA_INIT_CFLAGS=[]_CFLAGS $(MYCPPFLAGS)'	>> $CONFIG_M4

	SO_EXT=.so
	SO_CFLAGS=-pic
	SO_LD=/bin/ld
	SO_LDFLAGS='-assert nodefinitions'
	;;
    *:SunOS:5*:*)
	# SunPRO;
	if [ "$INLINE_OK" ]; then
	    OPT=-xO4
	else
	    OPT=-xO3
	fi
	echo 'CCM=$(CC) -xM'			>> $CONFIG_M4
	FASTFLAGS=-fast
	CCVERS=-V
	if [ "$LP64" -a -x /usr/bin/isainfo ] && \
	   /usr/bin/isainfo -v | grep '^64' >/dev/null; then
	    ARCH_OPT=`getconf XBS5_LP64_OFF64_CFLAGS`
	fi

	SO_EXT=.so
	SO_CFLAGS=-Kpic
	SO_LD=$CCPATH
	SO_LDFLAGS=-G
	;;
    esac # morv
    # not gcc|clang|icc
    ;;
esac # CC_IS

# sanity check 1/1/2015:
if [ "x$LDFLAGS" != x -a "SO_LD" = "" ]; then
    echo 'LDFLAGS set without SO_LD' 1>&2
    exit 1
fi

if [ "$CCPATH" ]; then
    echo "CC=$CCPATH"				>> $CONFIG_M4
    # for "check" script:
    CC=$CCPATH
    export CC
fi

# include C compiler version output in comments
if [ "x$CCVERS" != x ]; then
    echo '################'			>> $CONFIG_M4
    echo '# C Compiler:'			>> $CONFIG_M4
    echo '#' ${CCPATH-cc} $CCVERS		>> $CONFIG_M4
    ${CCPATH-cc} $CCVERS 2>&1 | sed 's/^/# /'	>> $CONFIG_M4
    echo '################'			>> $CONFIG_M4
fi

echo checking sizes of C types 1>&2
# detect compilers/architectures where LP64 is the default
# MUST be after compiler choice
cat << EOF > $TMP.c
#include <stdio.h>

struct foo {
    char c;
    double y;
};

int
main() {
    printf("%d %d %d %d %d %lu\n", (int)sizeof(void *),
	(int)sizeof(int), (int)sizeof(long),
	(int)sizeof(float), (int)sizeof(double),
	(unsigned long)&((struct foo *)0)->y);
    return 0;
}
EOF
if ${CCPATH-cc} $CFLAGS -o $TMP $TMP.c && ./$TMP > $TMP.out &&
  read SPTR SINT SLONG SFLOAT SDOUBLE ADOUBLE < $TMP.out; then
    echo 'sizeof(int) = '$SINT		1>&2
    echo '# sizeof(int) = '$SINT	>> $CONFIG_M4

    echo 'sizeof(void *) = '$SPTR	1>&2
    echo '# sizeof(void *) = '$SPTR	>> $CONFIG_M4

    echo 'sizeof(long) = '$SLONG	1>&2
    echo '# sizeof(long) = '$SLONG	>> $CONFIG_M4
    echo "#define SIZEOF_LONG $SLONG"	>> $CONFIG_H

    echo 'sizeof(float) = '$SFLOAT	1>&2
    echo '# sizeof(float) = '$SFLOAT	>> $CONFIG_M4

    echo 'sizeof(double) = '$SDOUBLE	1>&2
    echo '# sizeof(double) = '$SDOUBLE	>> $CONFIG_M4

    echo 'alignment(double) = '$ADOUBLE	1>&2
    echo '# alignment(double) = '$ADOUBLE	>> $CONFIG_M4

    # XXX ASSume sizeof(char) == 1 (8 bits)
    if [ "$SPTR" = 8 -a "$SLONG" = 8 ]; then
	echo 'native programming model is LP64' 1>&2
	LP64=true
	LP64_NATIVE=true
    elif [ "$SINT" = 4 -a "$SPTR" = 4 -a "$SLONG" = 4 ]; then
	echo 'native programming model is ILP32' 1>&2
    else
	echo 'odd programming model!!!' 1>&2
    fi
fi
if [ "$LONGLONG" -a "x$LP64_NATIVE" = x ]; then
cat << EOF > $TMP.c
#include <stdio.h>

int
main() {
    printf("%d\n", (int)sizeof(long long));
    return 0;
}
EOF
    if ${CCPATH} $CFLAGS $CFLAGS_LONGLONG -o $TMP $TMP.c && ./$TMP > $TMP.out; then
	SLONGLONG=`cat $TMP.out`
	echo 'sizeof(long long) = '$SLONGLONG		1>&2
	echo '# sizeof(long long) = '$SLONGLONG		>> $CONFIG_M4
    fi
fi
rm -f $TMP $TMP.c $TMP.out $TMP.exe

# after size checks;
case "$CC_IS" in
gcc)
    # avoid trying option where LP64 is the default, and the compiler could
    # be gcc2 -- there was no generic option back then!
    if [ "$LP64" -a ! "$LP64_NATIVE" ]; then
	ARCH_CFLAGS="$GCC64"
	# for "check" script
	CFLAGS="$CFLAGS $GCC64"
	export CFLAGS
    fi
    ;;
esac

# after size checks;
if [ "$LP64" ]; then
    # In 64-bit environments, alignment restrictions on int_t/pointer
    # data is likely to pad descriptors out to 16 bytes, so don't pack
    # DESCR "v" field into 24 bits. See also "xxl" (64-bit "v" field)
    NO_BITFIELDS=true

    # make real_t same size as int_t
    DOUBLE=true

    # make --longlong a noop
    LONGLONG=
elif [ "$DOUBLE" ]; then
    # if double in use for float_t, and would force 16 byte descriptors
    # (eg; on sparc or w/ -malign-double) don't pack "v" field into 24 bits
    if [ "$ADOUBLE" = "$SDOUBLE" ]; then
	NO_BITFIELDS=true
    fi
fi

if [ "$ARCH_CFLAGS" ]; then
    echo 'ADD_CFLAGS(['$ARCH_CFLAGS'])'		>> $CONFIG_M4
fi

if [ "$NO_OPT" ]; then
    echo OPT=					>> $CONFIG_M4
else
    if [ "x$UOPT" != x ]; then
	echo "OPT=$UOPT"			>> $CONFIG_M4
    elif [ "x$OPT" != x ]; then
	echo "OPT=$OPT"				>> $CONFIG_M4
    fi
    if [ "$FAST" -a "x$FASTFLAGS" != x ]; then
	echo 'ADD_OPT(['"$FASTFLAGS"'])'	>> $CONFIG_M4
    fi
fi

if [ ! "$INLINE_OK" ]; then
    # use non-reordered file
    echo 'SNOBOL4=snobol4'			>> $CONFIG_M4
fi

# moved to before first use of config/check
# detect GNU libc (glibc) -- run in subshell to redirect error output
# if --version not a valid option.  Future versions might not print
# version as last item on line (deal with it if any version than 2.1
# needs special handling):
GLIBC=`(getconf --version)2>&1 | awk '/GNU libc/ || /GLIBC/ { print $NF }'`
if [ "x$GLIBC" != x ]; then
    echo "# GLIBC version $GLIBC"		>> $CONFIG_M4
    echo '#define HAVE_GLIBC'			>> $CONFIG_H
    echo '#ifndef _GNU_SOURCE'			>> $CONFIG_H
    echo '#define _GNU_SOURCE'			>> $CONFIG_H
    echo '#endif'				>> $CONFIG_H
    CFLAGS="$CFLAGS -D_GNU_SOURCE"
    export CFLAGS
    echo "detected GNU libc version $GLIBC" 1>&2

    # glibc 2.1 is broken; fseeko() cannot be used
    case "$GLIBC" in
    2.1|2.1.*)
	LARGEFILE_OK=
	;;
    esac
fi

if [ "$LONGLONG" ]; then
    # Force use of 64-bit int and real types on ILP32 systems.
    # Not tested in all environments (some compilers
    # may require options to enable "long long" data type)
    if [ "$SLONGLONG" = '' ]; then
	echo 'FATAL: --longlong selected but no long long type available' 1>&2
	exit 1
    fi
    # make real_t same size as int_t
    DOUBLE=true

    # turn off bitfields
    NO_BITFIELDS=true

    echo using long long for SNOBOL4 INTEGER type 1>&2
    echo '#define INT_T long long'		>> $CONFIG_H
    SIZEOF_INT_T=$SLONGLONG

    if [ "x$CFLAGS_LONGLONG" != x ]; then
	# add any flags necessary to enable "long long"
	echo 'ADD_CFLAGS(['$CFLAGS_LONGLONG'])' >> $CONFIG_M4
    fi
    if config/check stdlib.h 'strtoll("", 0, 0)'; then
	# XXX try running a program to verify??
	echo 'using C99 printf %lld' 1>&2
	echo 'SPCINT_C=$(SRCDIR)lib/c99/spcint.c' >> $CONFIG_M4
	echo 'using C99 strtoll()' 1>&2
	echo 'INTSPC_C=$(SRCDIR)lib/c99/intspc.c' >> $CONFIG_M4
    else
	# here with gcc on SunOS4, for example
	echo 'using private string to integer' 1>&2
	echo 'SPCINT_C=$(SRCDIR)lib/longlong/spcint.c' >> $CONFIG_M4
	echo 'using private integer to string' 1>&2
	echo 'INTSPC_C=$(SRCDIR)lib/longlong/intspc.c' >> $CONFIG_M4
    fi

    case "$CC_IS" in
    gcc|clang)
	# keep gcc (& clang?) from screaming about copious warnings
        echo 'ADD_CFLAGS([-Wno-pointer-to-int-cast -Wno-int-to-pointer-cast])' >> $CONFIG_M4
	;;
    esac
else
    LONGLONG=
    SIZEOF_INT_T=$SLONG
fi

if [ "$NO_BITFIELDS" ]; then
    echo '#define NO_BITFIELDS'			>> $CONFIG_H
    if [ "$XXL" -a "$LP64" ]; then
	echo '#define VFLD_T unsigned long'	>> $CONFIG_H
	# avoids &MAXLNGTH displaying as -1:
	echo '#define SIZLIM 0x7fffffffffffffff' >> $CONFIG_H
    elif [ "$LONGLONG" -o "$LP64" ]; then
	# int_t is wide, so should be safe to use all 32-bits of "v" (int) field
	# (can't be confused for a negative int_t)
	# otherwise snotypes uses 2^31-1 if NO_BITFIELDS defined.
	echo '#define SIZLIM (~(VFLD_T)0)'	>> $CONFIG_H
    fi
fi

if [ "$DOUBLE" ]; then
    # sizeof(real_t) must be <= sizeof(int_t), or IDENT(REAL,REAL) won't work
    echo using double for SNOBOL4 REAL type 1>&2
    echo '#define REAL_T double'		>> $CONFIG_H
    # print lots of digits -- possibly suboptimal, but safe
    # wikipedia page on IEEE FP says binary64 format has 15.95 sig digs
    echo '#define REALST_FORMAT "%.15lg"'	>> $CONFIG_H
    SIZEOF_REAL_T=$SDOUBLE
else
    SIZEOF_REAL_T=$SFLOAT
fi

echo '#define SIZEOF_INT_T	'$SIZEOF_INT_T'	/* for use in ifdefs */' >> $CONFIG_H
echo '#define SIZEOF_REAL_T	'$SIZEOF_REAL_T'	/* for use in ifdefs */' >> $CONFIG_H

# size_t is C99, ssize_t from POSIX?
if [ "$SPTR" = "$SINT" ]; then
    # ILP32?
    SSIZE_T=int
elif [ "$SPTR" = "$SLONG" ]; then
    # LP64?
    SSIZE_T=long
else
    # LLP64???
    SSIZE_T='long long'
fi

# check stddef.h?
if ! config/check stdio.h 'size_t x = sizeof(int)'; then
    echo "using own size_t" 1>&2
    echo "typedef unsigned $SSIZE_T size_t;"	>> $CONFIG_H
fi

if ! config/check unistd.h 'ssize_t x = 1234'; then
    echo "using own ssize_t" 1>&2
    echo "typedef $SSIZE_T ssize_t;"		>> $CONFIG_H
fi

if config/check unistd.h; then
    echo 'using POSIX unistd.h' 1>&2
    echo '#define HAVE_UNISTD_H'		>> $CONFIG_H
    HAVE_UNISTD_H=1
fi

if config/check stdint.h; then
    echo 'using C99 stdint.h' 1>&2
    echo '#define HAVE_STDINT_H'		>> $CONFIG_H
elif config/check inttypes.h; then
    # present on FreeBSD 4.9 w/o stdint
    echo 'using SUSv2 inttypes.h' 1>&2
    echo '#define HAVE_INTTYPES_H'		>> $CONFIG_H
fi

# prefer C99 "isfinite" function:
# hpux9 and hpux10 have finite(). hpux11 has isfinite().
if config/check math.h 'float f; isfinite(f)'; then
    echo 'using C99 isfinite()' 1>&2
    echo '#define HAVE_ISFINITE'		>> $CONFIG_H
    HAVE_ISFINITE=1
elif config/check math.h 'double d; finite(x)'; then
    echo 'using finite() from math.h' 1>&2
elif [ "${OS}" = SunOS ] && config/check ieeefp.h 'double d; finite(x)'; then
    # SunOS4?
    echo 'using finite() from ieeefp.h' 1>&2
    echo '#define FINITE_IN_IEEEFP_H'	>> $CONFIG_H
# XXX else use dummy version???
fi 

# clock_gettime() reports combined user/system time, so removed it
if [ "x$CYGWIN" != x ]; then
    # Cygwin has getrusage(), but it only works under NT, so use the
    # Win32 native mstime.c, which will fall back to Win9x compatibility
    # XXX but I no longer care about non NT systems!!!
    echo 'using Win32 native calls for runtimes' 1>&2
    echo 'MSTIME_C=$(SRCDIR)lib/win32/mstime.c'	>> $CONFIG_M4
elif config/check "sys/time.h sys/resource.h" \
    "struct rusage r; getrusage(RUSAGE_SELF, &r)"; then
    echo 'using getrusage() for runtimes' 1>&2
    echo 'MSTIME_C=$(SRCDIR)lib/bsd/mstime.c'	>> $CONFIG_M4

    # user time can run backwards for processes with small
    # runtimes on BSD44 based systems; time deltas in &TRACE can
    # appear negative!!
    case "$OS" in
    FreeBSD|NetBSD|BSD/OS|BSD/386|Darwin|4.4BSD|OpenBSD|DragonFly)
	echo '#define GETRUSAGE_BUG'		>> $CONFIG_H
	;;
    esac
elif [ "$HAVE_UNISTD_H" ]; then
    echo 'using times() + sysconf() for runtimes' 1>&2
    echo 'MSTIME_C=$(SRCDIR)lib/posix/mstime.c'	>> $CONFIG_M4
elif config/check sys/times.h "struct tms tt; times(&tt)"; then
    # V7 had times(), but not times.h!!!
    echo 'using times() for runtimes' 1>&2
    # XXX warning????
    # XXX message about presumed HZ value??
    echo 'MSTIME_C=$(SRCDIR)lib/generic/mstime.c' >> $CONFIG_M4
    case "$MORV" in
    9000/[34]??:HP-UX:*:*)
	# HPUX on 68040 (hp4xx) and HPUX 9
	echo '#define HZ 50'			>> $CONFIG_H
	;;
    esac
elif check time.h 'clock_t t = clock()'; then
    echo 'using clock() for runtimes' 1>&2
    # least preferable; includes system time (or may be wall clock time)
    # may need to guess tick size
    echo 'MSTIME_C=$(SRCDIR)lib/ansi/mstime.c'	>> $CONFIG_M4
else
    echo 'using dummy mstime.c' 1>&2	
    echo 'MSTIME_C=$(SRCDIR)lib/dummy/mstime.c'	>> $CONFIG_M4
fi


# prefer uname(2/3)
# NeXT/Open Step have $INCDIR/bsd/sys/utsname.h?? transparent??
if config/check sys/utsname.h "struct utsname u; uname(&u)"; then
    echo 'using uname() for system name information' 1>&2
else
    # XXX only source for MACHINE & OSNAME is uname command!!
    #	(haven't used config.guess since 2003!)
    # so unlikely to get here with anything but "unknown"!!!
    # add command line options to allow setting them?? force it???
    OSNAME="$OS $OSREL"
    if [ "$OSNAME" = 'unknown unknown' ]; then
	OSNAME='unknown'
    fi
    echo 'using "'$MACHINE'" for hardware name' 1>&2
    echo '#define HWNAME "'$MACHINE'"'		>> $CONFIG_H
    echo 'using "'$OSNAME'" for system name' 1>&2
    echo '#define OSNAME "'$OSNAME'"'		>> $CONFIG_H
    echo 'SYS_C=$(SRCDIR)lib/generic/sys.c'	>> $CONFIG_M4
fi

if config/check string.h 'char d; memmove(&d, "", 0)'; then
    echo 'using system memmove()/memset() functions' 1>&2
    echo '#define USE_MEMMOVE'		>> $CONFIG_H
elif config/check strings.h 'char d; bcopy("", &d, 0)'; then
    echo 'using system bcopy()/bzero() functions' 1>&2
    echo '#define HAVE_BCOPY'		>> $CONFIG_H
else
    echo 'using private bcopy()/zero() functions' 1>&2
    echo 'ADD_OBJS([bcopy.o bzero.o])'	>> $CONFIG_M4
    echo 'ADD_SRCS([$(BCOPY_C) $(BZERO_C)])' >> $CONFIG_M4
    echo '#define NEED_BCOPY'		>> $CONFIG_H
fi

if config/check 'sys/types.h sys/socket.h' ""; then
    # check if network libraries needed
    # XXX don't check for gethostbyname unless getaddrinfo not available?!
    SOCKINC='sys/types.h sys/socket.h netdb.h'
    SOCKFRAG='int s = socket(AF_INET, SOCK_STREAM, 0); struct hostent *hp = gethostbyname("")'
    if config/check "$SOCKINC" "$SOCKFRAG"; then
	echo 'using sockets for TCP/IP support' 1>&2
	NETLIBS=
    elif config/check "$SOCKINC" "$SOCKFRAG" -lsocket; then
	echo 'using sockets for TCP/IP support w/ -lsocket' 1>&2
	echo 'ADD_SNOBOL4_LDFLAGS([-lsocket])'	>> $CONFIG_M4
	NETLIBS=-lsocket
    elif config/check "$SOCKINC" "$SOCKFRAG" '-lsocket -lnsl'; then
	echo 'using sockets for TCP/IP support w/ -lsocket & -lnsl' 1>&2
	echo 'ADD_SNOBOL4_LDFLAGS([-lsocket])'	>> $CONFIG_M4
	echo 'ADD_SNOBOL4_LDFLAGS([-lnsl])'	>> $CONFIG_M4
	NETLIBS='-lsocket -lnsl'
    fi

    if config/check "$SOCKINC" \
	'struct addrinfo aa[2], *ap; getaddrinfo("", "", aa, &ap)' \
	"$NETLIBS"; then
	echo 'using getaddrinfo() for IPv6' 1>&2
	echo 'INET_O=inet6.o'			>> $CONFIG_M4
	if config/check 'sys/types.h rpc/rpc.h' 'struct sockaddr sa; bindresvport_sa(0, &sa);' >/dev/null 2>&1; then
	    # FreeBSD 4-7, NetBSD, MacOS
	    echo 'using system bindresvport_sa() function (with rpc/rpc.h)' 1>&2
	    echo '#define BINDRESVPORT_IN_RPC_H' >> $CONFIG_H
	    # OpenBSD 5.6
	elif config/check 'sys/types.h sys/socket.h netinet/in.h unistd.h' 'struct sockaddr sa; bindresvport_sa(0, &sa);' >/dev/null 2>&1; then
	    echo 'using system bindresvport_sa() function' 1>&2
	else
	    echo 'using private bindresvport_sa() function' 1>&2
	    echo '#define NEED_BINDRESVPORT_SA'	>> $CONFIG_H
	    AUX_BINDRESVPORT=true
	fi
    else # no getaddrinfo/IPv6
	BINDRESVTEST='struct sockaddr_in sin; bindresvport(0, &sin)'
	if config/check 'sys/types.h rpc/rpc.h' "$BINDRESVTEST" >/dev/null 2>&1; then
	    # FreeBSD 3.x
	    echo 'using system bindresvport() function (with rpc/rpc.h)' 1>&2
	    echo '#define BINDRESVPORT_IN_RPC_H' >> $CONFIG_H
	elif config/check 'netinet/in.h unistd.h' "$BINDRESVTEST" >/dev/null 2>&1; then
	    echo 'using system bindresvport() function' 1>&2
	else
	    echo 'using private bindresvport() function' 1>&2
	    echo '#define NEED_BINDRESVPORT' >> $CONFIG_H
	    AUX_BINDRESVPORT=true
	fi
    fi
    if [ "$AUX_BINDRESVPORT" ]; then
	echo 'ADD_OBJS([bindresvport.o])'	>> $CONFIG_M4
	echo 'ADD_SRCS([$(BINDRESVPORT_C)])'	>> $CONFIG_M4
    fi

    if config/check netinet/in.h 'struct sockaddr_in6 in6' || \
	config/check netinet6/in.h 'struct sockaddr_in6 in6'; then
	echo '#define HAVE_SOCKADDR_IN6' >> $CONFIG_H
    fi

    # use socklen_t if avaialble
    if config/check sys/socket.h 'socklen_t len'; then
	echo '#define SOCKLEN_T socklen_t'	>> $CONFIG_H
    else
	echo '#define SOCKLEN_T int'		>> $CONFIG_H
    fi

    # use BSD bidirectional popen if socketpair available
    if config/check sys/socket.h \
	'int s[2]; socketpair(AF_UNIX, SOCK_STREAM, 0, s)'; then
	echo 'using private popen() function' 1>&2
	echo 'ADD_OBJS([popen.o])'		>> $CONFIG_M4
	echo 'ADD_SRCS([$(POPEN_C)])'		>> $CONFIG_M4
	NEED_PATHS_H=1
	if config/check unistd.h 'vfork()'; then
	    echo 'using vfork() (with unistd.h)' 1>&2
	    echo '/* vfork() in unistd.h */'	>> $CONFIG_H
	elif config/check vfork.h 'vfork()'; then
	    echo 'using vfork() from vfork.h' 1>&2
	    echo '#define HAVE_VFORK_H'		>> $CONFIG_H
	else
	    echo 'using fork() for vfork()' 1>&2
	    echo '#define vfork fork'		>> $CONFIG_H
	fi
    fi

    if config/check 'openssl/ssl.h openssl/bio.h' \
		    'BIO_new_ssl(SSL_CTX_new(0), 1)' \
		    '-lssl -lcrypto'; then
	echo 'using OpenSSL BIO API for TLS I/O' 1>&2
	# XXX test if OpenSSL (or some other API) available!!!
	echo 'TLSIO_OBJ_C=$(SRCDIR)lib/openssl/tlsio_obj.c' >> $CONFIG_M4
	echo 'ADD_OBJS([tlsio_obj.o])'		>> $CONFIG_M4
	echo 'ADD_SRCS([$(TLSIO_OBJ_C)])'	>> $CONFIG_M4   
	echo '#define TLS_IO'			>> $CONFIG_H
	echo 'ADD_SNOBOL4_LDFLAGS([-lssl -lcrypto])' >> $CONFIG_M4
    fi
else
    echo 'no sockets; TCP not available' 1>&2
    echo 'INET_C=$(SRCDIR)lib/dummy/inet.c'	>> $CONFIG_M4
fi

FORKPTY="int f; pid_t pid = forkpty(&f, 0, 0, 0);"
if config/check "sys/types.h libutil.h" "$FORKPTY" -lutil; then
    # FreeBSD, DragonFly
    echo 'using forkpty() with libutil.h and -lutil' 1>&2
    echo '#define HAVE_LIBUTIL_H'	>> $CONFIG_H
    echo "ADD_SNOBOL4_LDFLAGS([-lutil])" >> $CONFIG_M4
    NEED_PATHS_H=1
    HAVE_FORKPTY=1
elif config/check "sys/types.h util.h" "$FORKPTY"; then
    # OSX
    echo 'using forkpty() with util.h' 1>&2
    echo '#define HAVE_UTIL_H'		>> $CONFIG_H
    NEED_PATHS_H=1
    HAVE_FORKPTY=1
elif config/check "sys/types.h util.h" "$FORKPTY" -lutil; then
    # NetBSD, OpenBSD
    echo 'using forkpty() with util.h and -lutil' 1>&2
    echo '#define HAVE_UTIL_H'		>> $CONFIG_H
    echo "ADD_SNOBOL4_LDFLAGS([-lutil])" >> $CONFIG_M4
    NEED_PATHS_H=1
    HAVE_FORKPTY=1
elif config/check "sys/types.h pty.h" "$FORKPTY" -lutil; then
    # Linux
    echo 'using forkpty() with pty.h and -lutil' 1>&2
    echo '#define HAVE_PTY_H'		>> $CONFIG_H
    echo "ADD_SNOBOL4_LDFLAGS([-lutil])" >> $CONFIG_M4
    NEED_PATHS_H=1
    HAVE_FORKPTY=1
elif config/check 'fcntl.h stdlib.h' 'int fd = posix_openpt(O_RDWR|O_NOCTTY); int x = grantpt(fd), y = unlockpt(fd); char *name = ptsname(fd)'; then
    echo 'using private forkpty()' 1>&2
    # our own(!):
    echo '#define HAVE_LIBPTY_H'	>> $CONFIG_H
    echo 'ADD_OBJS([pty.o])'		>> $CONFIG_M4
    echo 'ADD_SRCS([$(SRCDIR)lib/posix/pty.c])'	>> $CONFIG_M4
    NEED_PATHS_H=1
    HAVE_FORKPTY=1
fi    

if [ "$NEED_PATHS_H" ]; then
    if config/check paths.h 'char *foo = _PATH_BSHELL'; then
	echo 'using paths.h for shell path' 1>&2
	echo '#define HAVE_PATHS_H'	>> $CONFIG_H
    else
	# XXX outer loop for sh, ksh, bash, csh, tcsh?
	for DIR in /usr/bin /bin `echo $PATH | tr ':' ' '`; do
	    if [ -x $DIR/sh ]; then
		BSHELL=$DIR/sh
		break
	    fi
	done
	if [ "$BSHELL" ]; then
	    echo "using $BSHELL for shell" 1>&2
	    echo '#define _PATH_BSHELL "'$BSHELL'"'	>> $CONFIG_H
	else
	    echo 'WARNING: could not find shell!' 1>&2
	fi
    fi
fi

# uncomment to debug win32/ptyio_obj.c under cygwin
#HAVE_FORKPTY=

if [ "x$HAVE_FORKPTY" != x ]; then
    echo 'PTYIO_OBJ_C=$(SRCDIR)lib/bsd/ptyio_obj.c'	>> $CONFIG_M4
    if config/check "unistd.h" "closefrom(3);"; then
	# FreeBSD, OpenBSD
	echo 'using closefrom() from unistd.h' 1>&2
    elif config/check "stdlib.h" "closefrom(3);"; then
	# Solaris
	echo 'using closefrom() from stdlib.h' 1>&2
	echo '#define CLOSEFROM_IN_STDLIB_H'	>> $CONFIG_H
    else
	echo 'using private closefrom() function' 1>&2
	echo '#define NEED_CLOSEFROM'	>> $CONFIG_H
	echo 'ADD_OBJS([closefrom.o])'	>> $CONFIG_M4
	echo 'ADD_SRCS([$(SRCDIR)lib/bsd/closefrom.c])'	>> $CONFIG_M4
	if config/check "unistd.h" 'getdtablesize();'; then
	    echo 'using getdtablesize() from unistd.h' 1>&2
	else
	    echo '#define NEED_GETDTABLESIZE'	>> $CONFIG_H
	    if config/check "unistd.h" 'sysconf(_SC_OPEN_MAX)'; then
		echo 'using private getdtablesize() with sysconf()' 1>&2
		echo 'ADD_OBJS([getdtablesize.o])'	>> $CONFIG_M4
		echo 'GETDTABLESIZE_C=$(SRCDIR)lib/posix/getdtablesize.c' >> $CONFIG_M4
	    else
		echo 'using dummy getdtablesize()' 1>&2
		echo 'ADD_OBJS([getdtablesize.o])'	>> $CONFIG_M4
		echo 'GETDTABLESIZE_C=$(SRCDIR)lib/dummy/getdtablesize.c' >> $CONFIG_M4
	    fi
	fi
    fi
elif [ "x$CYGWIN" != x ]; then
    # cygwin64 3.1.7 has working forkpty (in pty.h)
    # so this is here only for debugging!
    # XXX may need to set NTDDI &c?
    echo 'using Win32 ptyio_obj.c' 1>&2
    echo 'PTYIO_OBJ_C=$(SRCDIR)lib/win32/ptyio_obj.c'	>> $CONFIG_M4
    NEED_BUFIO=1
fi

if config/check termios.h 'struct termios t; tcgetattr(0, &t)'; then
    echo 'using termios.h for tty modes' 1>&2
    echo 'TTY_C=$(SRCDIR)lib/posix/tty.c'	>> $CONFIG_M4
elif config/check termio.h 'struct termio t; ioctl(0, TCGETA, &t)'; then
    echo 'using termio.h for tty modes' 1>&2
    echo '#define USE_TERMIO'			>> $CONFIG_H
    echo 'TTY_C=$(SRCDIR)lib/posix/tty.c'	>> $CONFIG_M4
elif config/check sgtty.h 'struct sgtty s; gtty(0, &s)'; then
    # systems with both termio/termios and sgtty usually
    # are simulating sgtty, so it's the last check.
    echo 'using sgtty.h for tty modes' 1>&2
    echo 'TTY_C=$(SRCDIR)lib/bsd/tty.c'		>> $CONFIG_M4
elif config/check sys/ttyio.h 'struct sgtty s; gtty(0, &s)'; then
    # Bell Research Unix
    echo 'using sys/ttyio.h for tty modes' 1>&2
    echo 'TTY_C=$(SRCDIR)lib/bsd/tty.c'		>> $CONFIG_M4
    echo '#define USE_TTYIO'			>> $CONFIG_H
else
    echo 'no tty support found' 1>&2
    echo 'TTY_C=$(SRCDIR)lib/dummy/tty.c'	>> $CONFIG_M4
fi

# Look for getopt definition in stdio.h include file which might
# conflict with our K&R getopt.c causing warnings, and even compile
# failure.  If none found compile our own getopt.o into snolib.a.
# An alternative would be to try compiling a small program which uses
# getopt() (using $CCPATH as compiler), but grep seems faster!

# getopt() now in POSIX.2; check stdlib.h and unistd.h (our getopt.c
# doesn't include them, but avoid compiling our own if system version
# available).

if config/check unistd.h 'int x = getopt(argc, argv, "t"), y=optind'; then
    # cygwin gcc10 unhappy with externs. Only checking POSIX location.
    echo 'using system getopt() function' 1>&2
elif config/check stdio.h 'getopt(argc, argv, "")'; then
    # here on SunOS4
    # illumos (SunOS 5.11) without _XPG4 or __EXTENSIONS__
    #	but hardly worth detecting/setting for just this!
    echo 'using system getopt() function w/ externs' 1>&2
    echo '#define NEED_GETOPT_EXTERNS'		>> $CONFIG_H
else
    # may not be needed, but should compile without error!
    echo 'using private getopt() function' 1>&2
    echo 'ADD_OBJS([getopt.o])'			>> $CONFIG_M4
    echo 'ADD_SRCS([$(GETOPT_C)])'		>> $CONFIG_M4
    echo '#define NEED_GETOPT'			>> $CONFIG_H
    echo '#define NEED_GETOPT_EXTERNS'		>> $CONFIG_H
fi

# POSIX-1.2008 (via glibc)
GETLINE_TEST='char *buf; size_t len; getline(&buf, &len, stdin)'
if config/check stdio.h "$GETLINE_TEST"; then
    echo 'using system getline() function' 1>&2
else
    echo 'using private getline() function' 1>&2
    echo 'ADD_OBJS([getline.o])'		>> $CONFIG_M4
    echo 'ADD_SRCS([$(GETLINE_C)])'		>> $CONFIG_M4
    echo '#define NEED_GETLINE'			>> $CONFIG_H
fi

# look for dynamic library support for "load";
# overrides "dummy" and "bsd" style
# look for sun/unix98 style dlopen()
if config/check dlfcn.h 'dlopen("", 0)' || \
	  config/check dlfcn.h 'dlopen("", 0)' -ldl; then
	LOAD=unix98
	echo 'using dlopen() for LOAD() support' 1>&2
	HAVE_DLOPEN=1
	echo 'LOAD_C=$(SRCDIR)lib/unix98/load.c' >> $CONFIG_M4

	case "${OS}${OSREL}" in
	Darwin*)
	    # darwin dlopen() support in cctools/libdyld??
	    if [ -f /usr/lib/libdl.dylib ]; then
		# Darwin 7.9 (OS X 10.3) and later??
		echo 'ADD_SNOBOL4_LDFLAGS([-ldl])' >> $CONFIG_M4
	    elif [ -f /sw/lib/libdl.dylib ]; then
		echo 'ADD_SNOBOL4_LDFLAGS([-L/sw/lib -ldl])' >> $CONFIG_M4
	    fi
	    TRY_UNDERSCORE=true
	    ;;
	*BSD*|DragonFly*)
	    if file /bin/ls | grep -i elf >/dev/null; then
		# only on ELF systems
		# (make all symbols visible to dynamically loaded code)
		SNOBOL4_LDFLAGS=-rdynamic
	    else
		# old a.out systems:
		# COFF may not, but this should be mostly harmless
		TRY_UNDERSCORE=true
	    fi
	    ;;
	Linux*)
	    # XXX detect a.out systems?
	    echo 'ADD_SNOBOL4_LDFLAGS([-ldl])'	>> $CONFIG_M4
	    # only on ELF systems with GNU ld
	    # (make all symbols visible to dynamically loaded code)
	    SNOBOL4_LDFLAGS=-rdynamic
	    ;;
	SunOS4*)
	    echo 'ADD_SNOBOL4_LDFLAGS([-ldl])'	>> $CONFIG_M4
	    # a.out system; need underscore
	    TRY_UNDERSCORE=true
	    ;;
	SunOS5*)
	    echo 'ADD_SNOBOL4_LDFLAGS([-ldl])'	>> $CONFIG_M4
	    ;;
	esac
	if [ "$TRY_UNDERSCORE" ]; then
	    echo '#define TRY_UNDERSCORE'	>> $CONFIG_H
	fi
elif config/check dl.h 'shl_load("", BIND_DEFERRED, 0L)'; then
	LOAD=hpux
	echo 'using HP-UX shl_load() for LOAD() support' 1>&2
	echo 'undefine([hpux])'			>> $CONFIG_M4
	echo 'LOAD_C=$(SRCDIR)lib/hpux/load.c'	>> $CONFIG_M4
	# export all symbols
	echo 'ADD_SNOBOL4_LDFLAGS([-Wl,-E])'	>> $CONFIG_M4
	echo 'ADD_SNOBOL4_LDFLAGS([-ldld])'	>> $CONFIG_M4
elif config/check mach-o/dyld.h 'NSObjectFileImage ofi'; then
	LOAD=next
	echo 'using NextStep/Darwin LOAD() support' 1>&2
	echo 'LOAD_C=$(SRCDIR)lib/next/load.c'	>> $CONFIG_M4
	if [ "$OS" = Darwin ]; then
	    echo '#define TRY_UNDERSCORE'	>> $CONFIG_H
	fi
elif config/check a.out.h 'struct exec a; int x = OMAGIC'; then
	LOAD=aout
	echo 'using a.out ld for LOAD() support' 1>&2
	echo 'LOAD_C=$(SRCDIR)lib/bsd/load.c'	>> $CONFIG_M4
	if [ -f /usr/bin/ld ]; then
	    echo 'found /usr/bin/ld' 1>&2
	elif [ -f /bin/ld ]; then
	    echo 'found /bin/ld' 1>&2
	    echo '#define LD_PATH "/bin/ld"'	>> $CONFIG_H
	fi
fi

# used to construct default SNOPATH
echo '#define SNOLIB_BASE "'"$SNOLIB_BASE"'"'	>> $CONFIG_H
# host.c:
echo '#define SNOLIB_DIR "'"$SNOLIB_LIB"'"'	>> $CONFIG_H
echo '#define INCLUDE_DIR "'"$INCLUDE_DIR"'"'	>> $CONFIG_H

if [ ! "$LOAD" ]; then
    echo 'using dummy LOAD() support' 1>&2
    echo 'LOAD_C=$(SRCDIR)lib/dummy/load.c'	>> $CONFIG_M4
fi

# Seperate from LARGEFILE;  BSD4.4 systems have large file
# support by default, without any LARGEFILE define chicanery.

# fseeko isn't needed if "long" (the offset type used by fseek)
# is 64 bits, but should be safe in any case (famous last words).
if config/check stdio.h 'fseeko(stdout, 0, 0)'; then
    echo 'using fseeko() for file positioning' 1>&2
    echo '#define HAVE_FSEEKO'			>> $CONFIG_H
fi

# if using a native 64bit data model no options should be needed
# for large file support
if [ "$LP64" ]; then
    LARGEFILE_OK=
fi

if [ "$LARGEFILE_OK" ] &&
   egrep 'LARGEFILE|LARGE_FILE' $INCDIR/stdio.h >/dev/null 2>&1; then
    echo 'using large file support' 1>&2
    if [ "x$GLIBC" = x -a -f /usr/bin/getconf ]; then
	if getconf LFS_CFLAGS >/dev/null 2>&1; then
	    USE_FLAGS=LFS_CFLAGS
	elif [ "$XBS5_MODEL" ]; then
	    if getconf $XBS5_MODEL >/dev/null 2>&1; then
		USE_FLAGS="$XBS5_MODEL"
	    fi
	fi
    fi
    if [ "$USE_FLAGS" ]; then
	FLAGS=`getconf $USE_FLAGS`
	echo "using getconf ${USE_FLAGS}: $FLAGS" 1>&2
	for X in $FLAGS; do
	    case "$X" in
	    -D*)
		echo "X$X" | \
		    sed -e 's/^X-D/#define /' -e 's/=/ /' >> $CONFIG_H
		;;
	    -U*)
		echo "X$X" | \
		    sed -e 's/^X-U/#undef /' -e 's/=/ /' >> $CONFIG_H
		;;
	    *)
		echo 'ADD_CFLAGS(['$X'])'		>> $CONFIG_M4
		;;
	    esac
	done
    else
	# gnu libc getconf LFS_CFLAGS leaves out _LARGEFILE_SOURCE!!
	# so does HP-UX getconf XBS5_ILP32_OFFBIG_CFLAGS
	echo 'using default LARGEFILE defines' 1>&2
	echo '#define _LARGEFILE_SOURCE'	>> $CONFIG_H
	echo '#define _FILE_OFFSET_BITS 64'	>> $CONFIG_H
    fi
fi

# RedHat 6.0 has mman.h, but not madvise()
if config/check sys/mman.h 'madvise(0, 0, MADV_RANDOM)' || \
    config/check sys/mman.h 'posix_madvise(0, 0, POSIX_MADV_RANDOM)'; then
    echo 'using madvise() during GC' 1>&2
    echo 'DYNAMIC_C=$(SRCDIR)lib/posix/dynamic.c' >> $CONFIG_M4
elif config/check sys/vadvise.h 'vadvise(VA_ANOM)'; then
    echo 'using vadvise() during GC' 1>&2
    echo 'DYNAMIC_C=$(SRCDIR)lib/bsd/dynamic.c'	>> $CONFIG_M4
else
    echo 'using generic dynamic.c' 1>&2
    echo 'DYNAMIC_C=$(SRCDIR)lib/generic/dynamic.c' >> $CONFIG_M4
fi

# just give in & compile a little program that uses SIGTSTP??
if config/check signal.h 'int i = SIGTSTP'; then
    if config/check signal.h 'sigset_t ss; sigemptyset(&ss)'; then
	echo 'using POSIX suspend.c' 1>&2
    elif config/check signal.h 'sigmask(0)'; then
	echo 'using BSD suspend.c' 1>&2
	echo 'SUSPEND_C=$(SRCDIR)lib/bsd/suspend.c'	>> $CONFIG_M4
    else
	# can't figure out how to unblock SIGTSTP in handler; use SIGSTOP
	echo 'using generic suspend.c' 1>&2
	echo 'SUSPEND_C=$(SRCDIR)lib/generic/suspend.c' >> $CONFIG_M4
    fi
else
    echo 'using dummy suspend.c' 1>&2
    echo 'SUSPEND_C=$(SRCDIR)lib/dummy/suspend.c' >> $CONFIG_M4
fi

# used in date.c as well as time module
if config/check "time.h" 'char buf[1024]; time_t t = time(0); strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&t));'; then
    echo 'using strftime()' 1>&2
    echo '#define HAVE_STRFTIME'		>> $CONFIG_H
fi

# currently only used in Native windows builds/installs
#if config/check "libgen.h" 'char path[] = "/a/b/c"; char *s = dirname(path)'; then
#    echo 'using XPG4.2 dirname()' 1>&2
#    echo '#define HAVE_DIRNAME'		>> $CONFIG_H
#else
#    echo 'using private dirname()' 1>&2
#    echo '#define NEED_DIRNAME'		>> $CONFIG_H
#    echo 'ADD_OBJS([dirname.o])'		>> $CONFIG_M4
#fi

if [ "x$SNOBOL4_LDFLAGS" != x ]; then
    echo "SNOBOL4_LDFLAGS=$SNOBOL4_LDFLAGS"	>> $CONFIG_M4
fi

# output SO/DL defines
# on everything except Darwin, one format suffices

# "Dynamic Library" -- code LOADed by user request
if [ "x$SO_EXT" != x -a "x$DL_EXT" = x ]; then
    DL_EXT="$SO_EXT"
    DL_CFLAGS="$SO_CFLAGS"
    DL_LD="$SO_LD"
    DL_LDFLAGS="$SO_LDFLAGS"
fi

# check if GNU C visibility available (silently for now) for shared library.
# Harder to detect if pragma form available.
# NOTE! AFTER above defaulting of DL_CFLAGS, because not used for LOADable code.
if [ "x$CYGWIN" = x ]; then
    DEFVIS='__attribute__ ((__visibility__("default")))'
    if config/check 'stdio.h' "$DEFVIS extern int foo(void)"; then
	# first available in gcc 4.0?
	SO_CFLAGS="$SO_CFLAGS -fvisibility=hidden"
	echo "#define EXPORT(TYPE) $DEFVIS TYPE" >> $CONFIG_H
    fi
fi

# "Shared Object" -- Dynamically Loaded Library loaded at startup
if [ "x$SO_EXT" != x ]; then
    echo '# Shared Object Libraries (in config.h too)' >> $CONFIG_M4
    echo "SO_EXT=$SO_EXT"		>> $CONFIG_M4
    echo "SO_CFLAGS=$SO_CFLAGS"		>> $CONFIG_M4
    echo "SO_LD=$SO_LD"			>> $CONFIG_M4
    echo "SO_LDFLAGS=$SO_LDFLAGS"	>> $CONFIG_M4

    echo '/* Shared Object Libraries (in config.m4 too) */' >> $CONFIG_H
    echo "#define SO_EXT \"$SO_EXT\""	>> $CONFIG_H
    echo "#define SO_CFLAGS \"$SO_CFLAGS\"" >> $CONFIG_H
    echo "#define SO_LD \"$SO_LD\""	>> $CONFIG_H
    echo "#define SO_LDFLAGS \"$SO_LDFLAGS\"" >> $CONFIG_H
fi

if [ "x$DL_EXT" != x ]; then
    echo '# Dynamicly Loaded Extensions (in config.h too)' >> $CONFIG_M4
    echo "DL_EXT=$DL_EXT"		>> $CONFIG_M4
    echo "DL_CFLAGS=$DL_CFLAGS"		>> $CONFIG_M4
    echo "DL_LD=$DL_LD"			>> $CONFIG_M4
    echo "DL_LDFLAGS=$DL_LDFLAGS"	>> $CONFIG_M4
    echo '/* Dynamicly Loaded Extensions (in config.m4 too) */' >> $CONFIG_H
    echo "#define DL_EXT \"$DL_EXT\""	>> $CONFIG_H
    echo "#define DL_CFLAGS \"$DL_CFLAGS\"" >> $CONFIG_H
    echo "#define DL_LD \"$DL_LD\""	>> $CONFIG_H
    echo "#define DL_LDFLAGS \"$DL_LDFLAGS\"" >> $CONFIG_H
fi

# Include readline support, if found
if [ ! "$WITHOUT_READLINE" ]; then
    RL_INC='stdio.h readline/readline.h readline/history.h'
    RL_FRAG='readline("?")'
    if $ALLOW_LIBREADLINE && \
	    config/check "$RL_INC" "$RL_FRAG" -lreadline; then
	RL_LIBS="-lreadline"
    elif $ALLOW_LIBREADLINE && config/check "$RL_INC" "$RL_FRAG" '-lreadline -lncurses'; then
	RL_LIBS="-lreadline -lncurses"
    elif $ALLOW_LIBREADLINE && \
	    config/check "$RL_INC" "$RL_FRAG" '-lreadline -lncursesw'; then
	RL_LIBS="-lreadline -lncursesw"
    elif $ALLOW_LIBEDIT && config/check "$RL_INC" "$RL_FRAG" '-ledit'; then
	RL_LIBS="-ledit"
    elif $ALLOW_LIBEDIT && \
	   config/check "$RL_INC" "$RL_FRAG" '-ledit -I/usr/include/edit'; then
	# FreeBSD 12
	RL_LIBS="-ledit"
	RL_INCDIR="/usr/include/edit"
    fi

    if [ "x$RL_LIBS" != x ]; then
	echo "using readline (with $RL_LIBS)" 1>&2
	echo '#define HAVE_READLINE'		>> $CONFIG_H
	echo "	READLINE_LDFLAGS = '$RL_LIBS'" >> $CONFIG_SNO
	echo "ADD_SNOBOL4_LDFLAGS([$RL_LIBS])"	>> $CONFIG_M4
	if [ "x$RL_INCDIR" != x ]; then
	    echo "ADD_CPPFLAGS([-I$RL_INCDIR])"	>> $CONFIG_M4
	    echo "	READLINE_INCLUDE = '$RL_INCDIR'" >> $CONFIG_SNO
	fi
	# Make optional?
	echo '#define COMPILER_READLINE'	>> $CONFIG_H
	# NetBSD/OSX have rl_[gs]et_keymap, but they're noops,
	# rl_copy_keymap() isn't even faked.
	if config/check "$RL_INC" "Keymap m; rl_copy_keymap(m)" $RL_LIBS; then
	    echo "using rl_set_keymap()" 1>&2
	    echo '#define HAVE_RL_SET_KEYMAP'	>> $CONFIG_H
	fi
    fi
fi

# XXX could have --with-zlib=basepath
if config/check zlib.h 'z_stream z; inflate(&z, Z_NO_FLUSH)' -lz; then
    echo 'using zlib to read/write .gz format files' 1>&2
    echo '#define USE_ZLIB'			>> $CONFIG_H
    echo 'ADD_SNOBOL4_LDFLAGS([-lz])'		>> $CONFIG_M4
    NEED_COMPIO=1
    NEED_BUFIO=1
    HAVE_ZLIB=1
fi

# XXX could have --with-bzlib=basepath
if config/check bzlib.h 'bz_stream bz; BZ2_bzCompressInit(&bz,5,0,0)' -lbz2; then
    echo 'using bzlib to read/write .bz2 format files' 1>&2
    echo '#define USE_BZLIB'			>> $CONFIG_H
    echo 'ADD_SNOBOL4_LDFLAGS([-lbz2])'		>> $CONFIG_M4
    NEED_COMPIO=1
    NEED_BUFIO=1
fi

# XXX could have --with-liblzma=basepath
if config/check lzma.h \
	'lzma_stream lz; int x = lzma_code(&lz, LZMA_RUN)' -llzma; then
    echo 'using lzmalib to read/write .xz format files' 1>&2
    echo '#define USE_LZMA'			>> $CONFIG_H
    echo 'ADD_SNOBOL4_LDFLAGS([-llzma])'	>> $CONFIG_M4
    NEED_COMPIO=1
    NEED_BUFIO=1
fi

# support for shared library: silent for now. make a configure option?
if config/check stdio.h 'FILE *f = fmemopen("hello", 5, "r")'; then
#   echo 'using POSIX.1-2008 fmemopen'		1>&2
    echo 'MEMIO_OBJ_C=$(SRCDIR)lib/posix/memio_obj.c' >> $CONFIG_M4
    echo 'MEMIO_OBJ=memio_obj.o'		>> $CONFIG_M4
    echo 'MEMIO_SRC=$(MEMIO_OBJ_C)'		>> $CONFIG_M4
else
#   echo 'using memio_obj.c'			1>&2
    echo 'MEMIO_OBJ=memio_obj.o'		>> $CONFIG_M4
    echo 'MEMIO_SRC=$(MEMIO_OBJ_C)'		>> $CONFIG_M4
    if [ "x$NEED_BUFIO" = x ]; then
	# this may lose.
	echo 'MEMIO_OBJ+=bufio_obj.o'		>> $CONFIG_M4
	echo 'MEMIO_SRC+=$(MEMIO_OBJ_C)'	>> $CONFIG_M4
    fi
fi

if [ "x$WITHOUT_MODULES" = x ]; then
    MODULES="base64 dirs logic random stat time sprintf fork readline"
    # if other compression modules created, have COMP_MODULES?
    if [ "x$HAVE_ZLIB" != x ]; then
	MODULES="$MODULES zlib"
    fi

    ################################################################
    echo "checking features for modules:"	1>&2

    TIME_CFLAGS="$TIME_CFLAGS -DHAVE_SLEEP"
    SLEEP_C=bsd/sleep.c

    # what a PITA! TRY to hide the birthtime mess.
    # FreeBSD/NetBSD/Cygwin have st_birthtim
    # FreeBSD/NetBSD/MacOS have st_birthtimespec
    # Put defines in config.h (so FILE_NEWER can use them?)
    #   would mean moving this outside "modules" tests
    # TESTS:
    ACMNSEC_TEST='struct stat st; st.st_atimensec = st.st_ctimensec = st.st_mtimensec = 0'
    BIRTHNSEC_TEST='struct stat st; st.st_birthtimensec = 0'
    # DEFINES:
    MTIM_NSEC='-Dst_atimensec=st_mtim.tv_nsec -Dst_ctimensec=st_ctim.tv_nsec -Dst_mtimensec=st_mtim.tv_nsec'
    BIRTHTIM_NSEC='-Dst_birthtimensec=st_birthtim.tv_nsec'
    # MacOS
    TIMESPEC_NSEC='-Dst_atimensec=st_mtimespec.tv_nsec -Dst_ctimensec=st_ctimespec.tv_nsec -Dst_mtimensec=st_mtimespec.tv_nsec'

    OPENBSD_BIRTH='-Dst_birthtime=__st_birthtim.tv_sec -Dst_birthtimensec=__st_birthtim.tv_nsec'

    if config/check sys/stat.h "$ACMNSEC_TEST"; then
	# NetBSD 9, FreeBSD 13(will?) have st_mtimensec
	echo 'using stat st_[acm]timensec'		1>&2
	if config/check sys/stat.h "$BIRTHNSEC_TEST"; then
	    echo 'using stat st_birthtimensec'		1>&2
	elif config/check sys/stat.h "$BIRTHNSEC_TEST" "$OPENBSD_BIRTH"; then
	    # __st_birthtim present since OpenBSD 3.6, but always zero in 6.8?!
	    echo 'using stat __st_birthtim'		1>&2
	    STAT_CFLAGS="$OPENBSD_BIRTH"
	fi
    elif config/check sys/stat.h "$ACMNSEC_TEST" "$MTIM_NSEC"; then
	# FreeBSD 12, Cygwin, Linux
	echo 'using stat st_[acm]tim.tv_nsec'		1>&2
	STAT_CFLAGS="$MTIM_NSEC"
	BIRTHTIM_NSEC='-Dst_birthtimensec=st_birthtim.tv_nsec'
	if config/check sys/stat.h "$BIRTHNSEC_TEST" "$BIRTHTIM_NSEC"; then
	    # FreeBSD 12, Cygwin
	    echo 'using stat st_birthtim.tv_nsec'		1>&2
	    STAT_CFLAGS="$STAT_CFLAGS $BIRTHTIM_NSEC"
	fi
    elif config/check sys/stat.h "$ACMNSEC_TEST" "$TIMESPEC_NSEC"; then
	# macOS 10.15
	echo 'using stat st_[acm]timespec.tv_nsec'	1>&2
	STAT_CFLAGS="$TIMESPEC_NSEC"
	BIRTHTIMESPEC_NSEC='-Dst_birthtimensec=st_birthtimespec.tv_nsec'
	if config/check sys/stat.h "$BIRTHNSEC_TEST" "$BIRTHTIMESPEC_NSEC"; then
	    echo 'using stat st_birthtimespec.tv_nsec'	1>&2
	    STAT_CFLAGS="$STAT_CFLAGS $BIRTHTIMESPEC_NSEC"
	fi
    fi

    # UGH! time-of-day code in both "time" and "random" modules!
    # need a common library for modules?!
    CLOCK_REALTIME='struct timespec ts; long x; clock_gettime(CLOCK_REALTIME, &ts); x = ts.tv_nsec'
    if config/check time.h "$CLOCK_REALTIME" "$TR_LDFLAGS"; then
	echo 'using POSIX.1b clock_gettime(CLOCK_REALTIME,..) for time of day' 1>&2
	TR_CFLAGS="$TR_CFLAGS -DHAVE_CLOCK_GETTIME_REALTIME"
    elif config/check time.h "$CLOCK_REALTIME" -lrt; then
	# glibc 2.5 (on RHEL5), for example...
	echo 'using POSIX.1b clock_gettime(CLOCK_REALTIME,..) w/ -lrt for TOD' 1>&2
	TR_CFLAGS="$TR_CFLAGS -DHAVE_CLOCK_GETTIME_REALTIME"
	TR_LDFLAGS="$TR_LDFLAGS -lrt"
    elif config/check time.h \
	'struct timespec ts; long x; timespec_get(&ts,TIME_UTC); x = ts.tv_nsec'; then
	echo 'using C11 timespec_get(..,TIME_UTC) for time of day' 1>&2
	TR_CFLAGS="$TR_CFLAGS -DHAVE_TIMESPEC_GET"
    elif config/check sys/time.h \
	'struct timeval tv; int x; gettimeofday(&tv,0); x = tv.tv_sec'; then
	echo 'using gettimeofday()' 1>&2
	TR_CFLAGS="$TR_CFLAGS -DHAVE_GETTIMEOFDAY"
    else
	echo 'using time()' 1>&2
    fi

    if config/check time.h 'struct tm tm; int i = tm.tm_gmtoff' "$TR_CFLAGS"; then
	echo 'using tm_gmtoff' 1>&2
	TIME_CFLAGS="$TIME_CFLAGS -DHAVE_TM_GMTOFF"
    fi

    if config/check time.h 'struct tm tm; strptime("", "", &tm)'; then
	echo 'using strptime()' 1>&2
	TIME_CFLAGS="$TIME_CFLAGS -DHAVE_STRPTIME"
    else
	for DEF in _DEFAULT_SOURCE _XOPEN_SOURCE; do
	    if config/check time.h 'struct tm tm; strptime("", "", &tm)' -D$DEF; then
		echo "using strptime() w/ -D$DEF" 1>&2
		TIME_CFLAGS="$TIME_CFLAGS -DHAVE_STRPTIME -D$DEF"
		break
	    fi
	done
    fi

    if config/check time.h 'struct tm tm; timegm(&tm)'; then
	echo 'using timegm()' 1>&2
	TIME_CFLAGS="$TIME_CFLAGS -DHAVE_TIMEGM"
    else
	for DEF in _DEFAULT_SOURCE _BSD_SOURCE __USE_MISC; do
	    if config/check time.h 'struct tm tm; timegm(&tm)' -D$DEF; then
		echo 'using timegm() with -DDEF' 1>&2
		TIME_CFLAGS="$TIME_CFLAGS -DHAVE_TIMEGM -D$DEF"
		break
	    fi
	done
    fi

    SELECT_FRAG='fd_set x; struct timeval tv; select(0,&x,&x,&x,&tv);'
    if config/check time.h 'struct timespec ts; nanosleep(&ts,0)' "$TR_CFLAGS $TIME_CFLAGS"; then
	echo 'using POSIX nanosleep()' 1>&2
	SLEEP_C=posix/sleep.c
    elif config/check sys/select.h "$SELECT_FRAG"; then
	echo 'using posix select() for sleep'	1>&2
	TIME_CFLAGS="$TIME_CFLAGS -DHAVE_SELECT_H"
    elif config/check 'sys/time.h sys/types.h' "$SELECT_FRAG"; then
	echo 'using select() for sleep' 1>&2
    else
	echo 'using generic sleep()' 1>&2
	SLEEP_C=generic/sleep.c			>> $CONFIG_M4
    fi
    echo 'SLEEP_C=$(SRCDIR)'$SLEEP_C			>> $CONFIG_M4
    echo "	SLEEP_C = '$SLEEP_C'"			>> $CONFIG_SNO

    if [ "x$STAT_CFLAGS" != x ]; then
	echo "	STAT_CFLAGS = '$STAT_CFLAGS'"		>> $CONFIG_SNO
    fi
    if [ "x$TIME_CFLAGS$TR_CFLAGS" != x ]; then
	echo "	TIME_CFLAGS = '$TIME_CFLAGS $TR_CFLAGS'"	>> $CONFIG_SNO
    fi
    if [ "x$TIME_LDFLAGS$TR_LDFLAGS" != x ]; then
	echo "	TIME_LDFLAGS = '$TIME_LDFLAGS $TR_LDFLAGS'"	>> $CONFIG_SNO
    fi
    if [ "x$RANDOM_CFLAGS$TR_CFLAGS" != x ]; then
	echo "	RANDOM_CFLAGS = '$RANDOM_CFLAGS $TR_CFLAGS'"	>> $CONFIG_SNO
    fi
    if [ "x$RANDOM_LDFLAGS$TR_LDFLAGS" != x ]; then
	echo "	RANDOM_LDFLAGS = '$RANDOM_LDFLAGS $TR_LDFLAGS'"	>> $CONFIG_SNO
    fi
    ################################################################
    # stcl
    if [ "x$TCONF" = x ]; then
	for X in /usr/lib/tclConfig.sh \
		 /System/Library/Frameworks/Tcl.framework/tclConfig.sh; do
	    if [ -f $X ]; then
		echo found $X 1>&2
		TCONF=$X
		break
	    fi
	done
    fi

    # Include STCL (tcl) support, if available/requested
    # (Tk loads as package in 8.4+)
    if [ "$TCONF" -a -f "$TCONF" ]; then
	. "$TCONF"
	if [ "$TCL_VERSION" ]; then
	    echo "using Tcl version $TCL_VERSION" 1>&2
	    MODULES="$MODULES stcl"
	    echo "	TCL_LIB_SPEC = '$TCL_LIB_SPEC'" >> $CONFIG_SNO
	    echo "	TCL_INCLUDE_SPEC = '$TCL_INCLUDE_SPEC'" >> $CONFIG_SNO
	fi
    fi

    ################################################################
    # ndbm module

    NDBM_LIBS=
    DBM_FRAG='DBM *db = dbm_open("", 0, 0)'
    if [ "$FORCE_SDBM" ]; then
	# bypass checks
	USE_SDBM=1
    elif config/check ndbm.h "$DBM_FRAG"; then
	echo "using ndbm.h for DBM support" 1>&2
	echo '#define HAVE_NDBM_H'		>> $CONFIG_H
    elif config/check ndbm.h "$DBM_FRAG" -ldb; then
	echo "using ndbm.h for DBM support (with -ldb)" 1>&2
	echo '#define HAVE_NDBM_H'		>> $CONFIG_H
	NDBM_LIBS='-ldb'
    elif config/check db.h "$DBM_FRAG" '-DDB_DBM_HSEARCH'; then
	# check for Berkeley DB in libc
	echo "using db.h for DBM support" 1>&2
	echo '#define DB_DBM_HSEARCH 1'		>> $CONFIG_H
	echo '#define HAVE_DB_H'		>> $CONFIG_H
    elif config/check db.h "$DBM_FRAG" '-ldb -DDB_DBM_HSEARCH'; then
	# works with libdb4.8
	echo "using db.h for DBM support (with -ldb)" 1>&2
	echo '#define DB_DBM_HSEARCH 1'		>> $CONFIG_H
	echo '#define HAVE_DB_H'		>> $CONFIG_H
	NDBM_LIBS='-ldb'
    else
	# not force sdbm, or ndbm.h w/o libs, or db.h
	# (ie; here on most Linux systems w/o Berkeley DB)
	# Some Linux distributions fraction off ndbm compatibility:
	# many different names/locations for compat header file: try them all.

	# *BUT* will still fail (and silently use SDBM) if *all*
	# the right (dev) packages not installed!!!
	for COMPAT in '' ' -lgdbm_compat'; do
	    NDBM_LIBS="-lgdbm$COMPAT"
	    if config/check ndbm.h "$DBM_FRAG" "$NDBM_LIBS"; then
		# cygwin
		USE_GDBM=1
		echo "using ndbm.h for DBM support (with $NDBM_LIBS)" 1>&2
		echo '#define HAVE_NDBM_H'	>> $CONFIG_H
		break
	    elif config/check gdbm/ndbm.h "$DBM_FRAG" "$NDBM_LIBS"; then
		USE_GDBM=1
		echo "using gdbm/ndbm.h for DBM support (with $NDBM_LIBS)" 1>&2
		echo '#define HAVE_GDBM_SLASH_NDBM_H'	>> $CONFIG_H
		break
	    elif config/check gdbm-ndbm.h "$DBM_FRAG" "$NDBM_LIBS"; then
		USE_GDBM=1
		echo "using gdbm-ndbm.h for DBM support (with $NDBM_LIBS)" 1>&2
		echo '#define HAVE_GDBM_DASH_NDBM_H'	>> $CONFIG_H	
		break
	    fi
	    NDBM_LIBS=""
	done
	if [ ! "$USE_GDBM" ]; then
	    echo 'WARNING: no ndbm support found: using sdbm' 1>&2
	    USE_SDBM=1
	fi
    fi

    MODULES="$MODULES ndbm"
    if [ "$USE_SDBM" ]; then
	echo "using SDBM for DBM support" 1>&2
	# for modules/ndbm/setup.sno:
	echo '	NDBM_INCLUDE = "sdbm"' >> $CONFIG_SNO
	echo '	NDBM_SRCS = ",sdbm/sdbm.c,sdbm/sdbm_hash.c,sdbm/sdbm_pair.c"' >> $CONFIG_SNO
	echo "	NDBM_CFLAGS = '-DHAVE_SDBM_H -DDUFF'" >> $CONFIG_SNO
    fi
    if [ "x$NDBM_LIBS" != x ]; then
	echo "	NDBM_LDFLAGS = '$NDBM_LIBS'" >> $CONFIG_SNO
    fi

    ################################################################
    # stat module
    # test lstat() for "stat" package
    if config/check 'sys/types.h sys/stat.h' 'struct stat st; lstat("foo", &st)'; then
	echo '#define HAVE_LSTAT'	>> $CONFIG_H
	echo 'using lstat()' 1>&2
    fi

    # places to look for sqlite and ffi
    # /opt/local on MacPorts
    SEARCH_DIRS='/usr/local /opt/local'

    if [ "x$RL_LIBS" = x ]; then
	# XXX build in if WITHOUT_MODULES (for sdb)???
	echo "using dummy readline (for sdb)" 1>&2
	MODULES="$MODULES readline"
    fi

    SQLITE_FRAG='sqlite3 *db; sqlite3_open("foo", &db)'
    if [ -f modules/sqlite3/sqlite3.c -a -f modules/sqlite3/sqlite3.h ]; then
	echo 'using sqlite3 amalgamation sources' 1>&2
	MODULES="$MODULES sqlite3"
    elif config/check 'sqlite3.h' "$SQLITE_FRAG" '-lsqlite3'; then
	echo 'using sqlite3' 1>&2
	MODULES="$MODULES sqlite3"
    else
	for DIR in $SEARCH_DIRS; do
	    if config/check sqlite3.h "$SQLITE3_FRAG" "-I$DIR/include -L$DIR/lib -lsqlite3"; then
	        echo "using sqlite3 from $DIR" 1>&2
		echo "	SQLITE_INCLUDE = '$DIR/include'" >> $CONFIG_SNO
		echo "	SQLITE_LIBDIR = '$DIR/lib'" >> $CONFIG_SNO
		MODULES="$MODULES sqlite3"
		break
	    fi
	done
    fi

    if config/check 'openssl/evp.h' 'EVP_get_digestbyname("md5")' -lcrypto; then
	echo 'using OpenSSL libcrypto for message digests' 1>&2
	MODULES="$MODULES digest"
    fi

    if [ "$HAVE_DLOPEN" ]; then
	FFI_FRAG='ffi_cif cif; ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 0, 0, 0)'
	if config/check 'ffi.h' "$FFI_FRAG" '-lffi'; then
	    echo 'using ffi' 1>&2
	    MODULES="$MODULES ffi"
	    FFI_INCLUDE=
	    FFI_LIBDIR=
	else
	    for DIR in $SEARCH_DIRS; do
		if config/check ffi.h "$FFI_FRAG" "-I$DIR/include -L$DIR/lib -lffi"; then
		    echo "using ffi from $DIR" 1>&2
		    echo "	FFI_INCLUDE = '$DIR/include'" >> $CONFIG_SNO
		    echo "	FFI_LIBDIR = '$DIR/lib'" >> $CONFIG_SNO
		    MODULES="$MODULES ffi"
		    break
		fi
	    done
	fi
    fi

    ################################################################
    # Include COM support under Cygwin!
    if [ "x$CYGWIN" != x ]; then
	cat << EOF > $TMP.cpp
#include <iostream>

int
main() {
    std::cout << "Hello\n";
    return 0;
}
EOF
	if g++ -o $TMP $TMP.cpp 2>/dev/null && [ `./$TMP` = 'Hello' ]; then
	    true
	else
	    echo 'could not find C++ compiler: Win32 COM support disabled' 1>&2
	    WITHOUT_COM=1
	fi
	rm -f $TMP $TMP.exe $TMP.cpp
	# XXX use config/check for include file?
	if [ "x$WITHOUT_COM" = x -a -f $INCDIR/w32api/objbase.h ]; then
	    echo 'using Win32 COM support' 1>&2
	    MODULES="$MODULES com"

	    # -L/usr/lib/w32api needed on Windows 7 (thanks to Robert Shanley!)
	    echo '	COM_LIBDIRS = "/usr/lib/w32api"' >> $CONFIG_SNO

	    # COM_LIBS defaulted in modules/com/setup.sno
	fi
    fi # cygwin
fi # modules

if [ "x$NEED_BUFIO" != x ]; then
    echo 'ADD_OBJS([bufio_obj.o])'		>> $CONFIG_M4
    echo 'ADD_SRCS([$(BUFIO_OBJ_C)])'		>> $CONFIG_M4
fi

if [ "x$NEED_COMPIO" != x ]; then
    echo '#define USE_COMPIO'			>> $CONFIG_H
    echo 'ADD_OBJS([compio_obj.o])'		>> $CONFIG_M4
    echo 'ADD_SRCS([$(COMPIO_OBJ_C)])'		>> $CONFIG_M4
fi

if [ "x$INITIAL_CFLAGS" != x ]; then
     # stolen from getconf handling... make into function?
     echo 'using CFLAGS environment variable' 1>&2
     echo '/* from CFLAGS: */' >> $CONFIG_H
     for X in $INITIAL_CFLAGS; do
	 case "$X" in
	 -D*)
	     echo "X$X" | \
		 sed -e 's/^X-D/#define /' -e 's/=/ /' >> $CONFIG_H
	     ;;
	 -U*)
	     echo "X$X" | \
		 sed -e 's/^X-U/#undef /' -e 's/=/ /' >> $CONFIG_H
	     ;;
	 *)
	     echo 'ADD_CFLAGS(['$X'])'		>> $CONFIG_M4
	     ;;
	 esac
     done
fi
# C preprocessor flags (not C++ flags) [make uses as the latter?]
if [ "$CPPFLAGS" ]; then
    # stolen from getconf handling... make into function?
    echo 'using CPPFLAGS environment variable' 1>&2
    echo '/* from CPPFLAGS: */' >> $CONFIG_H
    for X in $CPPFLAGS; do
	case "$X" in
	-D*)
	    echo "X$X" | \
		sed -e 's/^X-D/#define /' -e 's/=/ /' >> $CONFIG_H
	    ;;
	-U*)
	    echo "X$X" | \
		sed -e 's/^X-U/#undef /' -e 's/=/ /' >> $CONFIG_H
	    ;;
	*)
	    echo 'ADD_CPPFLAGS(['$X'])'		>> $CONFIG_M4
	    ;;
	esac
    done
fi
if [ "x$LDFLAGS" != x ]; then
	echo 'ADD_LDFLAGS(['$LDFLAGS'])'	>> $CONFIG_M4
fi
if [ "x$LIBRT" != x ]; then
	echo 'ADD_SNOBOL4_LDFLAGS(['$LIBRT'])'	>> $CONFIG_M4
fi
## check if pow() available? use dummy/expops.c if not?

# avoid:
# Solaris 8 /usr/sbin/install
# AIX /bin/install
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install

# should always find ./install-sh
for DIR in /usr/bin /usr/ucb /usr/local/bin /bin .; do
    for INSTALL in install ginstall scoinst install-sh; do
	IPATH=$DIR/$INSTALL
	if [ -d $IPATH ]; then
	    continue
	fi
	if [ -x $IPATH ]; then
	    # avoid broken AIX installer
	    # this test blows on cygwin, where -x /usr/bin/install
	    # succeeds for /usr/bin/install.exe, but grep on
	    # /usr/bin/install fails, so send stderr to /dev/null
	    if grep dspmsg $IPATH >/dev/null 2>&1; then
		continue
	    fi
	    echo "using $IPATH for make install" 1>&2
	    echo "INSTALL=$IPATH"		>> $CONFIG_M4
	    break 2
	fi
    done
done

# FreeBSD and Linux...
if [ -f /usr/share/man/man1/ls.1.gz ]; then
    for DIR in `echo $PATH | tr ':' ' '`; do
	if [ -x $DIR/gzip ]; then
	    echo "using $DIR/gzip to compress man pages" 1>&2
	    echo "MAN_COMPRESS=$DIR/gzip -f"	>> $CONFIG_M4
	    echo 'define([COMPRESS_MAN_PAGES],)' >> $CONFIG_M4
	    echo "	MAN_COMPRESS = '$DIR/gzip -f'" >> $CONFIG_SNO
	    break
	fi
    done
fi

#### Android

if [ ! -d /tmp ]; then
    echo '#define TMP_DIR "."'			>> $CONFIG_H
fi

if [ "x$INSTALL_DOCS" != x ]; then
    echo 'define([INSTALL_DOCS],)'		>> $CONFIG_M4
fi

################################
# construct new "with" file

WITH=with.new
rm -f $WITH
touch $WITH
if [ ! "$WITHOUT_BLOCKS" ]; then
    echo "BLOCKS=1"				>> $CONFIG_M4
    echo '#define BLOCKS'			>> $CONFIG_H
    echo ' --with BLOCKS'			>> $WITH
fi

echo "MODULES=$MODULES"				>> $CONFIG_M4

# build a SNOPATH that includes all module dirs, for module tests
# (allow module tests to use other modules).  Not currently used.
# for host.sno:
TEST_SNOPATH=..
#
for M in $MODULES; do
    TEST_SNOPATH="$TEST_SNOPATH:../modules/$M"
done
TEST_SNOPATH="$TEST_SNOPATH:../snolib:."
echo "TEST_SNOPATH=$TEST_SNOPATH"		>> $CONFIG_M4

if [ -f local-config ]; then
    echo 'using local-config' 1>&2
    echo '################'			>> $CONFIG_M4
    echo '# local-config:'			>> $CONFIG_M4
    cat local-config				>> $CONFIG_M4
    echo '# end local-config'			>> $CONFIG_M4
    echo '################'			>> $CONFIG_M4
else
    echo '# if the file local-config existed it would have been incorporated here' >> $CONFIG_M4
fi

################

if [ -f local-defines ]; then
    echo 'using local-defines' 1>&2
    echo '/********************'		>> $CONFIG_H
    echo ' * local-defines:'			>> $CONFIG_H
    echo ' */'					>> $CONFIG_H
    cat local-defines				>> $CONFIG_H
    echo '/*'					>> $CONFIG_H
    echo ' * end local-defines'			>> $CONFIG_H
    echo ' ********************/'		>> $CONFIG_H
else

    echo ''					>> $CONFIG_H
    echo '/* if the file local-defines existed it would have been incorporated here */' >> $CONFIG_H
fi

if [ ! "$DEBUG" ]; then
    if [ $CONFIG_H != config.h ]; then
	mv -f $CONFIG_H config.h
    fi
    if [ $CONFIG_M4 != config.m4 ]; then
	mv -f $CONFIG_M4 config.m4
    fi
    if [ $CONFIG_SNO != config.sno ]; then
	mv -f $CONFIG_SNO config.sno
    fi
    if [ $VERSION_H != version.h ]; then
	mv -f $VERSION_H version.h
    fi
    # updating "with" file causes regeneration of .sno files
    # which requires an installed snobol4 binary
    if [ $WITH != with ]; then
	if cmp $WITH with >/dev/null 2>&1; then
	    rm -f $WITH
	else
	    # XXX check if snobol4 executable can be found???
	    mv $WITH with
	fi
    fi
fi
