#!/bin/sh
#
# Do not edit!
# This file was generated from configure.in by BSDbuild 2.1.
#
# To regenerate this file, get the latest BSDbuild release from
# http://hypertriton.com/bsdbuild/, and use the command:
#
#     $ cat configure.in | mkconfigure > configure
#
# Copyright (c) 2001-2007 Hypertriton, Inc. <http://hypertriton.com/>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

optarg=
for arg
do
	case "$arg" in
	-*=*)
	    optarg=`echo "$arg" | sed 's/[-_a-zA-Z0-9]*=//'`
	    ;;
	*)
	    optarg=
	    ;;
	esac

	case "$arg" in
	--prefix=*)
	    prefix=$optarg
	    ;;
	--sysconfdir=*)
	    sysconfdir=$optarg
	    ;;
	--bindir=*)
	    bindir=$optarg
	    ;;
	--libdir=*)
	    libdir=$optarg
	    ;;
	--sharedir=*)
	    sharedir=$optarg
	    ;;
	--localedir=*)
	    localedir=$optarg
	    ;;
	--mandir=*)
	    mandir=$optarg
	    ;;
	--infodir=*)
	    infodir=$optarg
	    ;;
	--enable-*)
	    option=`echo $arg | sed -e 's/--enable-//' -e 's/=.*//'`
	    option=`echo $option | sed 's/-/_/g'`
	    case "$arg" in
	        *=*)
	            eval "enable_${option}='$optarg'"
		    ;;
		*)
	            eval "enable_${option}=yes"
		    ;;
	    esac
	    ;;
	--disable-*)
	    option=`echo $arg | sed -e 's/--disable-//'`;
	    option=`echo $option | sed 's/-/_/g'`
	    eval "enable_${option}=no"
	    ;;
	--with-*)
	    option=`echo $arg | sed -e 's/--with-//' -e 's/=.*//'`
	    option=`echo $option | sed 's/-/_/g'`
	    case "$arg" in
	        *=*)
	            eval "with_${option}='$optarg'"
		    ;;
		*)
	            eval "with_${option}=yes"
		    ;;
	    esac
	    ;;
	--without-*)
	    option=`echo $arg | sed -e 's/--without-//'`;
	    option=`echo $option | sed 's/-/_/g'`
	    eval "with_${option}=no"
	    ;;
	--help)
	    help=yes
	    ;;
	--srcdir=*)
	    srcdir=$optarg
	    ;;
	--testdir=*)
	    testdir=$optarg
	    ;;
	*)
	    echo "invalid argument: $arg"
	    echo "try ./configure --help"
	    exit 1
	    ;;
	esac
done

if [ -e "/bin/echo" ]; then
    /bin/echo -n ""
    if [ $? = 0 ]; then
    	ECHO_N="/bin/echo -n"
    else
    	ECHO_N="echo -n"
    fi
else
    ECHO_N="echo -n"
fi

if [ "${prefix}" != "" ]; then
    PREFIX="$prefix"
else
    PREFIX="/usr/local"
fi

if [ "${srcdir}" != "" ]; then
	echo "concurrent build (source in ${srcdir})"
	SRC=${srcdir}
	perl ${SRC}/mk/mkconcurrent.pl ${SRC}
	if [ $? != 0 ]; then
		exit 1;
	fi
else
	SRC=`pwd`
fi

if [ "${testdir}" != "" ]; then
	echo "Configure tests will be executed in ${testdir}"
	if [ ! -e "${testdir}" ]; then
		echo "Creating ${testdir}"
		mkdir ${testdir}
	fi
else
	testdir="."
fi
if [ "${help}" = "yes" ]; then
echo "Usage: ./configure [args]"
echo "    --prefix                  Installation prefix [/usr/local]"
echo "    --sysconfdir              System-wide configuration prefix [/etc]"
echo "    --bindir                  Executable directory [$PREFIX/bin]"
echo "    --libdir                  Library directory [$PREFIX/lib]"
echo "    --sharedir                Share directory [$PREFIX/share]"
echo "    --localedir               Locale directory [$PREFIX/share/locale]"
echo "    --mandir                  Manpage directory [$PREFIX/share/man]"
echo "    --infodir                 Info directory [$PREFIX/share/info]"
echo "    --srcdir                  Source tree for concurrent build [.]"
echo "    --testdir                 Directory in which to execute tests [.]"
echo "    --help                    Display this message"
echo "    --enable-nls              Native Language Support [no]"
echo "    --with-gettext            Use gettext tools (msgmerge, ...) [check]"
echo "    --with-libtool            Specify path to libtool [bundled]"
echo "    --with-cygwin             Add cygwin dependencies under cygwin [no]"
echo "    --with-manpages           Manual pages (-mdoc) [yes]"
echo "    --with-manlinks           Manual pages links for functions [no]"
echo "    --with-docs               Printable docs (-me/tbl/eqn/pic/refer) [no]"
echo "    --enable-debug            Include debugging code [no]"
echo "    --enable-lockdebug        Expensive threads debugging [default: no]"
echo "    --enable-warnings         Suggested compiler warnings [default: no]"
echo "    --enable-threads          Thread safety [default: check]"
echo "    --enable-gui              Build Agar-GUI [default: yes]"
echo "    --enable-utf8             Unicode text/input support [default: yes]"
echo "    --enable-8bpp             Support for 8 bpp display [default: yes]"
echo "    --enable-16bpp            Support for 16 bpp display [default: yes]"
echo "    --enable-24bpp            Support for 24 bpp display [default: yes]"
echo "    --enable-32bpp            Support for 32 bpp display [default: yes]"
echo "    --enable-network          Build network client library [default: check]"
echo "    --enable-server           Build network server library [default: no]"
echo "    --with-gl                 OpenGL rendering support [default: check]"
echo "    --with-jpeg               JPEG screenshot support [default: check]"
echo "    --with-freetype           GUI: Enable FreeType support [default: check]"
exit 1
fi

MACHINE=`uname -m 2>/dev/null` || MACHINE=unknown
OSRELEASE=`uname -r 2>/dev/null` || OSRELEASE=unknown
SYSTEM=`uname -s 2>/dev/null` || SYSTEM=unknown
HOST="$SYSTEM-$OSRELEASE-$MACHINE"
echo "Host: $HOST"

echo "# File generated by configure script (BSDbuild 2.1)." > Makefile.config
echo "Machine: $MACHINE" > config.log
echo "Release: $OSRELEASE" >> config.log
echo "System: $SYSTEM" >> config.log
for arg
do
	echo "Argument: $arg" >> config.log
done
mkdir config 1>/dev/null 2>&1

HAVE_MANDOC="no"
NROFF=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/nroff" ]; then
		NROFF="${path}/nroff"
	fi
done
if [ "${NROFF}" != "" ]; then
	echo | ${NROFF} -Tmandoc >/dev/null
	if [ "$?" = "0" ]; then
		HAVE_MANDOC="yes"
	fi
fi
if [ "${HAVE_MANDOC}" = "no" ]; then
	if [ "${with_manpages}" = "yes" ]; then
		echo "*"
		echo "* --with-manpages was requested, but either the nroff(1)"
		echo "* utility or the mdoc(7) macro package was not found."
		echo "*"
		exit 1
	fi
	echo "HAVE_MANDOC=no" >> Makefile.config
	echo "NOMAN=yes" >> Makefile.config
	echo "NOMANLINKS=yes" >> Makefile.config
else
	echo "HAVE_MANDOC=yes" >> Makefile.config
	if [ "${with_manpages}" = "no" ]; then
		echo "NOMAN=yes" >> Makefile.config
		echo "NOMANLINKS=yes" >> Makefile.config
	else
		if [ "${with_manlinks}" != "yes" ]; then
			echo "NOMANLINKS=yes" >> Makefile.config
		fi
	fi
fi

if [ "${with_docs}" = "no" ]; then
	echo "NODOC=yes" >> Makefile.config
fi
if [ "${enable_debug}" = "yes" ]; then
	echo "LDFLAGS+=-g" >> Makefile.config
	echo "#ifndef DEBUG" > config/debug.h
	echo "#define DEBUG 1" >> config/debug.h
	echo "#endif /* DEBUG */" >> config/debug.h
else
	echo "#undef DEBUG" > config/debug.h
fi

if [ "${enable_nls}" = "yes" ]; then
	ENABLE_NLS="yes"
	echo "#ifndef ENABLE_NLS" > config/enable_nls.h
	echo "#define ENABLE_NLS 1" >> config/enable_nls.h
	echo "#endif /* ENABLE_NLS */" >> config/enable_nls.h
	msgfmt=""
	for path in `echo $PATH | sed 's/:/ /g'`; do
		if [ -x "${path}/msgfmt" ]; then
			msgfmt=${path}/msgfmt
		fi
	done
	if [ "${msgfmt}" != "" ]; then
		HAVE_GETTEXT="yes"
	else
		HAVE_GETTEXT="no"
	fi
else
	ENABLE_NLS="no"
	HAVE_GETTEXT="no"
	echo "#undef ENABLE_NLS" > config/enable_nls.h
fi
echo "ENABLE_NLS=${ENABLE_NLS}" >> Makefile.config
echo "HAVE_GETTEXT=${HAVE_GETTEXT}" >> Makefile.config

LIBTOOL_BUNDLED="yes"
LIBTOOL=\${TOP}/mk/libtool/libtool
echo "LIBTOOL=${LIBTOOL}" >> Makefile.config

echo "PREFIX?=${PREFIX}" >> Makefile.config
echo "#ifndef PREFIX" > config/prefix.h
echo "#define PREFIX \"${PREFIX}\"" >> config/prefix.h
echo "#endif /* PREFIX */" >> config/prefix.h

if [ "${bindir}" != "" ]; then
	BINDIR="${bindir}"
else
	BINDIR="${PREFIX}/bin"
fi
echo "BINDIR=${BINDIR}" >> Makefile.config
echo "#ifndef BINDIR" > config/bindir.h
echo "#define BINDIR \"${BINDIR}\"" >> config/bindir.h
echo "#endif /* BINDIR */" >> config/bindir.h

if [ "${libdir}" != "" ]; then
	LIBDIR="${libdir}"
else
	LIBDIR="${PREFIX}/lib"
fi
echo "LIBDIR=${LIBDIR}" >> Makefile.config
echo "#ifndef LIBDIR" > config/libdir.h
echo "#define LIBDIR \"${LIBDIR}\"" >> config/libdir.h
echo "#endif /* LIBDIR */" >> config/libdir.h

if [ "${sharedir}" != "" ]; then
	SHAREDIR="${sharedir}"
else
	SHAREDIR="${PREFIX}/share"
fi
echo "SHAREDIR=${SHAREDIR}" >> Makefile.config
echo "#ifndef SHAREDIR" > config/sharedir.h
echo "#define SHAREDIR \"${SHAREDIR}\"" >> config/sharedir.h
echo "#endif /* SHAREDIR */" >> config/sharedir.h

if [ "${localedir}" != "" ]; then
	LOCALEDIR="${localedir}"
else
	LOCALEDIR="${SHAREDIR}/locale"
fi
echo "LOCALEDIR=${LOCALEDIR}" >> Makefile.config
echo "#ifndef LOCALEDIR" > config/localedir.h
echo "#define LOCALEDIR \"${LOCALEDIR}\"" >> config/localedir.h
echo "#endif /* LOCALEDIR */" >> config/localedir.h

if [ "${mandir}" != "" ]; then
	MANDIR="${mandir}"
else
	MANDIR="${SHAREDIR}/man"
fi
echo "MANDIR=${MANDIR}" >> Makefile.config
echo "#ifndef MANDIR" > config/mandir.h
echo "#define MANDIR \"${MANDIR}\"" >> config/mandir.h
echo "#endif /* MANDIR */" >> config/mandir.h

if [ "${infodir}" != "" ]; then
	INFODIR="${infodir}"
else
	INFODIR="${SHAREDIR}/info"
fi
echo "INFODIR=${INFODIR}" >> Makefile.config
echo "#ifndef INFODIR" > config/infodir.h
echo "#define INFODIR \"${INFODIR}\"" >> config/infodir.h
echo "#endif /* INFODIR */" >> config/infodir.h

if [ "${sysconfdir}" != "" ]; then
	SYSCONFDIR="${sysconfdir}"
else
	SYSCONFDIR="${PREFIX}/etc"
fi
echo "SYSCONFDIR=${SYSCONFDIR}" >> Makefile.config
echo "#ifndef SYSCONFDIR" > config/sysconfdir.h
echo "#define SYSCONFDIR \"${SYSCONFDIR}\"" >> config/sysconfdir.h
echo "#endif /* SYSCONFDIR */" >> config/sysconfdir.h

VERSION="1.3.2"
echo "#ifndef VERSION" > config/version.h
echo "#define VERSION \"$VERSION\"" >> config/version.h
echo "#endif" >> config/version.h
echo "hdefs[\"VERSION\"] = \"$VERSION\"" >>configure.lua
RELEASE="Landscapes Turn To Ash"
echo "#ifndef RELEASE" > config/release.h
echo "#define RELEASE \"$RELEASE\"" >> config/release.h
echo "#endif" >> config/release.h
echo "hdefs[\"RELEASE\"] = \"$RELEASE\"" >>configure.lua
SHAREDIR="\${PREFIX}/share/agar"
echo "SHAREDIR=$SHAREDIR" >>Makefile.config
echo "mdefs[\"SHAREDIR\"] = \"$SHAREDIR\"" >>configure.lua
SHAREDIR="$PREFIX/share/agar"
echo "#ifndef SHAREDIR" > config/sharedir.h
echo "#define SHAREDIR \"$SHAREDIR\"" >> config/sharedir.h
echo "#endif" >> config/sharedir.h
echo "hdefs[\"SHAREDIR\"] = \"$SHAREDIR\"" >>configure.lua
LOCALEDIR="\${PREFIX}/share/agar/locale"
echo "LOCALEDIR=$LOCALEDIR" >>Makefile.config
echo "mdefs[\"LOCALEDIR\"] = \"$LOCALEDIR\"" >>configure.lua
LOCALEDIR="$PREFIX/share/agar/locale"
echo "#ifndef LOCALEDIR" > config/localedir.h
echo "#define LOCALEDIR \"$LOCALEDIR\"" >> config/localedir.h
echo "#endif" >> config/localedir.h
echo "hdefs[\"LOCALEDIR\"] = \"$LOCALEDIR\"" >>configure.lua
TTFDIR="\${PREFIX}/share/agar/fonts"
echo "TTFDIR=$TTFDIR" >>Makefile.config
echo "mdefs[\"TTFDIR\"] = \"$TTFDIR\"" >>configure.lua
TTFDIR="$PREFIX/share/agar/fonts"
echo "#ifndef TTFDIR" > config/ttfdir.h
echo "#define TTFDIR \"$TTFDIR\"" >> config/ttfdir.h
echo "#endif" >> config/ttfdir.h
echo "hdefs[\"TTFDIR\"] = \"$TTFDIR\"" >>configure.lua
INCLDIR="\${PREFIX}/include/agar"
echo "INCLDIR=$INCLDIR" >>Makefile.config
echo "mdefs[\"INCLDIR\"] = \"$INCLDIR\"" >>configure.lua
INCLDIR="$PREFIX/include/agar"
echo "#ifndef INCLDIR" > config/incldir.h
echo "#define INCLDIR \"$INCLDIR\"" >> config/incldir.h
echo "#endif" >> config/incldir.h
echo "hdefs[\"INCLDIR\"] = \"$INCLDIR\"" >>configure.lua
$ECHO_N "checking for a usable C compiler..."
$ECHO_N "checking for a usable C compiler..." >> config.log
if [ "$CC" = "" ]; then
	for i in `echo $PATH |sed 's/:/ /g'`; do
		if [ -x "${i}/cc" ]; then
			CC="${i}/cc"
		elif [ -x "${i}/gcc" ]; then
			CC="${i}/gcc"
		fi
	done
	if [ "$CC" = "" ]; then
		echo "Could not find a C compiler, try setting CC."
		echo "CC is unset and cc/gcc is not in PATH." >> config.log
		exit 1
	fi
fi

cat << 'EOT' > cc-test.c
int
main(int argc, char *argv[])
{
	return (0);
}
EOT

$CC -o cc-test cc-test.c 2>>config.log
if [ $? != 0 ]; then
    echo "no"
	echo "The test C program failed to compile."
	rm -f cc-test cc-test.c
    exit 1
fi
echo "yes"
rm -f cc-test cc-test.c
TEST_CFLAGS=""
$ECHO_N "checking for compiler warnings..."
$ECHO_N "checking for compiler warnings..." >> config.log
cat << EOT > conftest.c
int main(int argc, char *argv[]) { return (0); }

EOT
echo "$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_CC_WARNINGS="yes"
echo "HAVE_CC_WARNINGS=$HAVE_CC_WARNINGS" >>Makefile.config
echo "mdefs[\"HAVE_CC_WARNINGS\"] = \"$HAVE_CC_WARNINGS\"" >>configure.lua
echo "#ifndef HAVE_CC_WARNINGS" > config/have_cc_warnings.h
echo "#define HAVE_CC_WARNINGS \"$HAVE_CC_WARNINGS\"" >> config/have_cc_warnings.h
echo "#endif" >> config/have_cc_warnings.h
echo "hdefs[\"HAVE_CC_WARNINGS\"] = \"$HAVE_CC_WARNINGS\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_CC_WARNINGS="no"
echo "HAVE_CC_WARNINGS=$HAVE_CC_WARNINGS" >>Makefile.config
echo "mdefs[\"HAVE_CC_WARNINGS\"] = \"$HAVE_CC_WARNINGS\"" >>configure.lua
echo "#undef HAVE_CC_WARNINGS" >config/have_cc_warnings.h
echo "hdefs[\"HAVE_CC_WARNINGS\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_CC_WARNINGS}" = "yes" ]; then
TEST_CFLAGS="-Wall -Werror"
fi;
$ECHO_N "checking for IEEE754 floating point..."
$ECHO_N "checking for IEEE754 floating point..." >> config.log
cat << EOT > conftest.c
int
main(int argc, char *argv[])
{
	float f = 1.5;
	double d = 2.5;
	f = 0;
	d = 0;
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_IEEE754="yes"
echo "HAVE_IEEE754=$HAVE_IEEE754" >>Makefile.config
echo "mdefs[\"HAVE_IEEE754\"] = \"$HAVE_IEEE754\"" >>configure.lua
echo "#ifndef HAVE_IEEE754" > config/have_ieee754.h
echo "#define HAVE_IEEE754 \"$HAVE_IEEE754\"" >> config/have_ieee754.h
echo "#endif" >> config/have_ieee754.h
echo "hdefs[\"HAVE_IEEE754\"] = \"$HAVE_IEEE754\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_IEEE754="no"
echo "HAVE_IEEE754=$HAVE_IEEE754" >>Makefile.config
echo "mdefs[\"HAVE_IEEE754\"] = \"$HAVE_IEEE754\"" >>configure.lua
echo "#undef HAVE_IEEE754" >config/have_ieee754.h
echo "hdefs[\"HAVE_IEEE754\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking __bounded__ attribute..."
$ECHO_N "checking __bounded__ attribute..." >> config.log
cat << EOT > conftest.c
void foo(char *, int) __attribute__ ((__bounded__(__string__,1,2)));
void foo(char *a, int c) { }
int main(int argc, char *argv[])
{
	char buf[32];
	foo(buf, sizeof(buf));
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_BOUNDED_ATTRIBUTE="yes"
echo "HAVE_BOUNDED_ATTRIBUTE=$HAVE_BOUNDED_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_BOUNDED_ATTRIBUTE\"] = \"$HAVE_BOUNDED_ATTRIBUTE\"" >>configure.lua
echo "#ifndef HAVE_BOUNDED_ATTRIBUTE" > config/have_bounded_attribute.h
echo "#define HAVE_BOUNDED_ATTRIBUTE \"$HAVE_BOUNDED_ATTRIBUTE\"" >> config/have_bounded_attribute.h
echo "#endif" >> config/have_bounded_attribute.h
echo "hdefs[\"HAVE_BOUNDED_ATTRIBUTE\"] = \"$HAVE_BOUNDED_ATTRIBUTE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_BOUNDED_ATTRIBUTE="no"
echo "HAVE_BOUNDED_ATTRIBUTE=$HAVE_BOUNDED_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_BOUNDED_ATTRIBUTE\"] = \"$HAVE_BOUNDED_ATTRIBUTE\"" >>configure.lua
echo "#undef HAVE_BOUNDED_ATTRIBUTE" >config/have_bounded_attribute.h
echo "hdefs[\"HAVE_BOUNDED_ATTRIBUTE\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking __format__ attribute..."
$ECHO_N "checking __format__ attribute..." >> config.log
cat << EOT > conftest.c
#include <stdarg.h>
void foo1(char *, ...)
     __attribute__((__format__ (printf, 1, 2)));
void foo2(char *, ...)
     __attribute__((__format__ (__printf__, 1, 2)))
     __attribute__((__nonnull__ (1)));
void foo1(char *a, ...) {}
void foo2(char *a, ...) {}
int main(int argc, char *argv[])
{
	foo1("foo %s", "bar");
	foo2("foo %d", 1);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_FORMAT_ATTRIBUTE="yes"
echo "HAVE_FORMAT_ATTRIBUTE=$HAVE_FORMAT_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_FORMAT_ATTRIBUTE\"] = \"$HAVE_FORMAT_ATTRIBUTE\"" >>configure.lua
echo "#ifndef HAVE_FORMAT_ATTRIBUTE" > config/have_format_attribute.h
echo "#define HAVE_FORMAT_ATTRIBUTE \"$HAVE_FORMAT_ATTRIBUTE\"" >> config/have_format_attribute.h
echo "#endif" >> config/have_format_attribute.h
echo "hdefs[\"HAVE_FORMAT_ATTRIBUTE\"] = \"$HAVE_FORMAT_ATTRIBUTE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_FORMAT_ATTRIBUTE="no"
echo "HAVE_FORMAT_ATTRIBUTE=$HAVE_FORMAT_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_FORMAT_ATTRIBUTE\"] = \"$HAVE_FORMAT_ATTRIBUTE\"" >>configure.lua
echo "#undef HAVE_FORMAT_ATTRIBUTE" >config/have_format_attribute.h
echo "hdefs[\"HAVE_FORMAT_ATTRIBUTE\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking __nonnull__ attribute..."
$ECHO_N "checking __nonnull__ attribute..." >> config.log
cat << EOT > conftest.c
void foo(char *) __attribute__((__nonnull__ (1)));
void foo(char *a) { }
int main(int argc, char *argv[])
{
	foo("foo");
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_NONNULL_ATTRIBUTE="yes"
echo "HAVE_NONNULL_ATTRIBUTE=$HAVE_NONNULL_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_NONNULL_ATTRIBUTE\"] = \"$HAVE_NONNULL_ATTRIBUTE\"" >>configure.lua
echo "#ifndef HAVE_NONNULL_ATTRIBUTE" > config/have_nonnull_attribute.h
echo "#define HAVE_NONNULL_ATTRIBUTE \"$HAVE_NONNULL_ATTRIBUTE\"" >> config/have_nonnull_attribute.h
echo "#endif" >> config/have_nonnull_attribute.h
echo "hdefs[\"HAVE_NONNULL_ATTRIBUTE\"] = \"$HAVE_NONNULL_ATTRIBUTE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_NONNULL_ATTRIBUTE="no"
echo "HAVE_NONNULL_ATTRIBUTE=$HAVE_NONNULL_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_NONNULL_ATTRIBUTE\"] = \"$HAVE_NONNULL_ATTRIBUTE\"" >>configure.lua
echo "#undef HAVE_NONNULL_ATTRIBUTE" >config/have_nonnull_attribute.h
echo "hdefs[\"HAVE_NONNULL_ATTRIBUTE\"] = nil" >>configure.lua
fi;
$ECHO_N "checking __aligned__ attribute..."
$ECHO_N "checking __aligned__ attribute..." >> config.log
cat << EOT > conftest.c
int main(int argc, char *argv[])
{
	struct s1 { int x,y,z; } __attribute__ ((aligned(16)));
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_ALIGNED_ATTRIBUTE="yes"
echo "HAVE_ALIGNED_ATTRIBUTE=$HAVE_ALIGNED_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_ALIGNED_ATTRIBUTE\"] = \"$HAVE_ALIGNED_ATTRIBUTE\"" >>configure.lua
echo "#ifndef HAVE_ALIGNED_ATTRIBUTE" > config/have_aligned_attribute.h
echo "#define HAVE_ALIGNED_ATTRIBUTE \"$HAVE_ALIGNED_ATTRIBUTE\"" >> config/have_aligned_attribute.h
echo "#endif" >> config/have_aligned_attribute.h
echo "hdefs[\"HAVE_ALIGNED_ATTRIBUTE\"] = \"$HAVE_ALIGNED_ATTRIBUTE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_ALIGNED_ATTRIBUTE="no"
echo "HAVE_ALIGNED_ATTRIBUTE=$HAVE_ALIGNED_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_ALIGNED_ATTRIBUTE\"] = \"$HAVE_ALIGNED_ATTRIBUTE\"" >>configure.lua
echo "#undef HAVE_ALIGNED_ATTRIBUTE" >config/have_aligned_attribute.h
echo "hdefs[\"HAVE_ALIGNED_ATTRIBUTE\"] = nil" >>configure.lua
fi;
$ECHO_N "checking __packed__ attribute..."
$ECHO_N "checking __packed__ attribute..." >> config.log
cat << EOT > conftest.c
int main(int argc, char *argv[])
{
	struct s1 { char c; int x,y,z; } __attribute__ ((packed));
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -Wall -Werror -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_PACKED_ATTRIBUTE="yes"
echo "HAVE_PACKED_ATTRIBUTE=$HAVE_PACKED_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_PACKED_ATTRIBUTE\"] = \"$HAVE_PACKED_ATTRIBUTE\"" >>configure.lua
echo "#ifndef HAVE_PACKED_ATTRIBUTE" > config/have_packed_attribute.h
echo "#define HAVE_PACKED_ATTRIBUTE \"$HAVE_PACKED_ATTRIBUTE\"" >> config/have_packed_attribute.h
echo "#endif" >> config/have_packed_attribute.h
echo "hdefs[\"HAVE_PACKED_ATTRIBUTE\"] = \"$HAVE_PACKED_ATTRIBUTE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_PACKED_ATTRIBUTE="no"
echo "HAVE_PACKED_ATTRIBUTE=$HAVE_PACKED_ATTRIBUTE" >>Makefile.config
echo "mdefs[\"HAVE_PACKED_ATTRIBUTE\"] = \"$HAVE_PACKED_ATTRIBUTE\"" >>configure.lua
echo "#undef HAVE_PACKED_ATTRIBUTE" >config/have_packed_attribute.h
echo "hdefs[\"HAVE_PACKED_ATTRIBUTE\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for long double..."
$ECHO_N "checking for long double..." >> config.log
cat << EOT > conftest.c
int
main(int argc, char *argv[])
{
	long double ld = 0.1;

	ld = 0;
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_LONG_DOUBLE="yes"
echo "#ifndef HAVE_LONG_DOUBLE" > config/have_long_double.h
echo "#define HAVE_LONG_DOUBLE \"$HAVE_LONG_DOUBLE\"" >> config/have_long_double.h
echo "#endif" >> config/have_long_double.h
echo "hdefs[\"HAVE_LONG_DOUBLE\"] = \"$HAVE_LONG_DOUBLE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_LONG_DOUBLE="no"
echo "#undef HAVE_LONG_DOUBLE" >config/have_long_double.h
echo "hdefs[\"HAVE_LONG_DOUBLE\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for long long..."
$ECHO_N "checking for long long..." >> config.log
cat << EOT > conftest.c
int
main(int argc, char *argv[])
{
	long long ll = 0.0;
	unsigned long long ull = 0.0;
	ll = 1.0;
	ull = 1.0;
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_LONG_LONG="yes"
echo "#ifndef HAVE_LONG_LONG" > config/have_long_long.h
echo "#define HAVE_LONG_LONG \"$HAVE_LONG_LONG\"" >> config/have_long_long.h
echo "#endif" >> config/have_long_long.h
echo "hdefs[\"HAVE_LONG_LONG\"] = \"$HAVE_LONG_LONG\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_LONG_LONG="no"
echo "#undef HAVE_LONG_LONG" >config/have_long_long.h
echo "hdefs[\"HAVE_LONG_LONG\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for cygwin environment..."
$ECHO_N "checking for cygwin environment..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <sys/stat.h>
#include <windows.h>

int
main(int argc, char *argv[]) {
	struct stat sb;
	DWORD rv;
	rv = GetFileAttributes("foo");
	stat("foo", &sb);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -mcygwin -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -mcygwin -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_CYGWIN="yes"
echo "HAVE_CYGWIN=$HAVE_CYGWIN" >>Makefile.config
echo "mdefs[\"HAVE_CYGWIN\"] = \"$HAVE_CYGWIN\"" >>configure.lua
echo "#ifndef HAVE_CYGWIN" > config/have_cygwin.h
echo "#define HAVE_CYGWIN \"$HAVE_CYGWIN\"" >> config/have_cygwin.h
echo "#endif" >> config/have_cygwin.h
echo "hdefs[\"HAVE_CYGWIN\"] = \"$HAVE_CYGWIN\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_CYGWIN="no"
echo "HAVE_CYGWIN=$HAVE_CYGWIN" >>Makefile.config
echo "mdefs[\"HAVE_CYGWIN\"] = \"$HAVE_CYGWIN\"" >>configure.lua
echo "#undef HAVE_CYGWIN" >config/have_cygwin.h
echo "hdefs[\"HAVE_CYGWIN\"] = nil" >>configure.lua
fi;
if [ "${compile}" = "ok" ]; then
	if [ "${with_cygwin}" != "yes" ]; then
		CFLAGS="$CFLAGS -mno-cygwin"
		echo "CFLAGS=$CFLAGS" >> Makefile.config
	fi
fi
$ECHO_N "checking for <sys/types.h>..."
$ECHO_N "checking for <sys/types.h>..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
int main(int argc, char *argv[]) {
	size_t len = 1;
	len++;
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
_MK_HAVE_SYS_TYPES_H="yes"
echo "_MK_HAVE_SYS_TYPES_H=$_MK_HAVE_SYS_TYPES_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_SYS_TYPES_H\"] = \"$_MK_HAVE_SYS_TYPES_H\"" >>configure.lua
echo "#ifndef _MK_HAVE_SYS_TYPES_H" > config/_mk_have_sys_types_h.h
echo "#define _MK_HAVE_SYS_TYPES_H \"$_MK_HAVE_SYS_TYPES_H\"" >> config/_mk_have_sys_types_h.h
echo "#endif" >> config/_mk_have_sys_types_h.h
echo "hdefs[\"_MK_HAVE_SYS_TYPES_H\"] = \"$_MK_HAVE_SYS_TYPES_H\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
_MK_HAVE_SYS_TYPES_H="no"
echo "_MK_HAVE_SYS_TYPES_H=$_MK_HAVE_SYS_TYPES_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_SYS_TYPES_H\"] = \"$_MK_HAVE_SYS_TYPES_H\"" >>configure.lua
echo "#undef _MK_HAVE_SYS_TYPES_H" >config/_mk_have_sys_types_h.h
echo "hdefs[\"_MK_HAVE_SYS_TYPES_H\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${_MK_HAVE_SYS_TYPES_H}" = "yes" ]; then
$ECHO_N "checking for 64-bit types..."
$ECHO_N "checking for 64-bit types..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
int main(int argc, char *argv[]) {
	int64_t i64 = 0;
	u_int64_t u64 = 0;
	i64 = 1;
	u64 = 1;
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_64BIT="yes"
echo "HAVE_64BIT=$HAVE_64BIT" >>Makefile.config
echo "mdefs[\"HAVE_64BIT\"] = \"$HAVE_64BIT\"" >>configure.lua
echo "#ifndef HAVE_64BIT" > config/have_64bit.h
echo "#define HAVE_64BIT \"$HAVE_64BIT\"" >> config/have_64bit.h
echo "#endif" >> config/have_64bit.h
echo "hdefs[\"HAVE_64BIT\"] = \"$HAVE_64BIT\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_64BIT="no"
echo "HAVE_64BIT=$HAVE_64BIT" >>Makefile.config
echo "mdefs[\"HAVE_64BIT\"] = \"$HAVE_64BIT\"" >>configure.lua
echo "#undef HAVE_64BIT" >config/have_64bit.h
echo "hdefs[\"HAVE_64BIT\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking for conflicting typedefs..."
$ECHO_N "checking for conflicting typedefs..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
int main(int argc, char *argv[]) {
	Uchar foo = 0;
	Uint bar = 0;
	Ulong baz = 0;
	foo = 1; bar = 2; baz = 3;
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
_MK_HAVE_UNSIGNED_TYPEDEFS="yes"
echo "_MK_HAVE_UNSIGNED_TYPEDEFS=$_MK_HAVE_UNSIGNED_TYPEDEFS" >>Makefile.config
echo "mdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >>configure.lua
echo "#ifndef _MK_HAVE_UNSIGNED_TYPEDEFS" > config/_mk_have_unsigned_typedefs.h
echo "#define _MK_HAVE_UNSIGNED_TYPEDEFS \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >> config/_mk_have_unsigned_typedefs.h
echo "#endif" >> config/_mk_have_unsigned_typedefs.h
echo "hdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
_MK_HAVE_UNSIGNED_TYPEDEFS="no"
echo "_MK_HAVE_UNSIGNED_TYPEDEFS=$_MK_HAVE_UNSIGNED_TYPEDEFS" >>Makefile.config
echo "mdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >>configure.lua
echo "#undef _MK_HAVE_UNSIGNED_TYPEDEFS" >config/_mk_have_unsigned_typedefs.h
echo "hdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
else
echo "#undef HAVE_64BIT" >config/have_64bit.h
echo "hdefs[\"HAVE_64BIT\"] = nil" >>configure.lua
$ECHO_N "checking for conflicting typedefs..."
$ECHO_N "checking for conflicting typedefs..." >> config.log
cat << EOT > conftest.c
int main(int argc, char *argv[]) {
	Uchar foo = 0;
	Uint bar = 0;
	Ulong baz = 0;
	foo = 1; bar = 2; baz = 3;
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
_MK_HAVE_UNSIGNED_TYPEDEFS="yes"
echo "_MK_HAVE_UNSIGNED_TYPEDEFS=$_MK_HAVE_UNSIGNED_TYPEDEFS" >>Makefile.config
echo "mdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >>configure.lua
echo "#ifndef _MK_HAVE_UNSIGNED_TYPEDEFS" > config/_mk_have_unsigned_typedefs.h
echo "#define _MK_HAVE_UNSIGNED_TYPEDEFS \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >> config/_mk_have_unsigned_typedefs.h
echo "#endif" >> config/_mk_have_unsigned_typedefs.h
echo "hdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
_MK_HAVE_UNSIGNED_TYPEDEFS="no"
echo "_MK_HAVE_UNSIGNED_TYPEDEFS=$_MK_HAVE_UNSIGNED_TYPEDEFS" >>Makefile.config
echo "mdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = \"$_MK_HAVE_UNSIGNED_TYPEDEFS\"" >>configure.lua
echo "#undef _MK_HAVE_UNSIGNED_TYPEDEFS" >config/_mk_have_unsigned_typedefs.h
echo "hdefs[\"_MK_HAVE_UNSIGNED_TYPEDEFS\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
fi;
$ECHO_N "checking for <stdlib.h>..."
$ECHO_N "checking for <stdlib.h>..." >> config.log
cat << EOT > conftest.c
#include <stdlib.h>
int main(int argc, char *argv[]) {
	void *foo = malloc(1);
	free(foo);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
_MK_HAVE_STDLIB_H="yes"
echo "_MK_HAVE_STDLIB_H=$_MK_HAVE_STDLIB_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_STDLIB_H\"] = \"$_MK_HAVE_STDLIB_H\"" >>configure.lua
echo "#ifndef _MK_HAVE_STDLIB_H" > config/_mk_have_stdlib_h.h
echo "#define _MK_HAVE_STDLIB_H \"$_MK_HAVE_STDLIB_H\"" >> config/_mk_have_stdlib_h.h
echo "#endif" >> config/_mk_have_stdlib_h.h
echo "hdefs[\"_MK_HAVE_STDLIB_H\"] = \"$_MK_HAVE_STDLIB_H\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
_MK_HAVE_STDLIB_H="no"
echo "_MK_HAVE_STDLIB_H=$_MK_HAVE_STDLIB_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_STDLIB_H\"] = \"$_MK_HAVE_STDLIB_H\"" >>configure.lua
echo "#undef _MK_HAVE_STDLIB_H" >config/_mk_have_stdlib_h.h
echo "hdefs[\"_MK_HAVE_STDLIB_H\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking for <unistd.h>..."
$ECHO_N "checking for <unistd.h>..." >> config.log
cat << EOT > conftest.c
#include <unistd.h>
int main(int argc, char *argv[]) {
	uid_t uid = 0;
	pid_t pid = 0;

	uid = getuid();
	pid = getpid();
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
_MK_HAVE_UNISTD_H="yes"
echo "_MK_HAVE_UNISTD_H=$_MK_HAVE_UNISTD_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_UNISTD_H\"] = \"$_MK_HAVE_UNISTD_H\"" >>configure.lua
echo "#ifndef _MK_HAVE_UNISTD_H" > config/_mk_have_unistd_h.h
echo "#define _MK_HAVE_UNISTD_H \"$_MK_HAVE_UNISTD_H\"" >> config/_mk_have_unistd_h.h
echo "#endif" >> config/_mk_have_unistd_h.h
echo "hdefs[\"_MK_HAVE_UNISTD_H\"] = \"$_MK_HAVE_UNISTD_H\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
_MK_HAVE_UNISTD_H="no"
echo "_MK_HAVE_UNISTD_H=$_MK_HAVE_UNISTD_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_UNISTD_H\"] = \"$_MK_HAVE_UNISTD_H\"" >>configure.lua
echo "#undef _MK_HAVE_UNISTD_H" >config/_mk_have_unistd_h.h
echo "hdefs[\"_MK_HAVE_UNISTD_H\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking for <limits.h>..."
$ECHO_N "checking for <limits.h>..." >> config.log
cat << EOT > conftest.c
#include <limits.h>

int main(int argc, char *argv[]) {
	int i;
	unsigned u;
	long l;
	unsigned long ul;

	i = INT_MIN;	i = INT_MAX;	u = UINT_MAX;
	l = LONG_MIN;	l = LONG_MAX;	ul = ULONG_MAX;
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
_MK_HAVE_LIMITS_H="yes"
echo "_MK_HAVE_LIMITS_H=$_MK_HAVE_LIMITS_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_LIMITS_H\"] = \"$_MK_HAVE_LIMITS_H\"" >>configure.lua
echo "#ifndef _MK_HAVE_LIMITS_H" > config/_mk_have_limits_h.h
echo "#define _MK_HAVE_LIMITS_H \"$_MK_HAVE_LIMITS_H\"" >> config/_mk_have_limits_h.h
echo "#endif" >> config/_mk_have_limits_h.h
echo "hdefs[\"_MK_HAVE_LIMITS_H\"] = \"$_MK_HAVE_LIMITS_H\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
_MK_HAVE_LIMITS_H="no"
echo "_MK_HAVE_LIMITS_H=$_MK_HAVE_LIMITS_H" >>Makefile.config
echo "mdefs[\"_MK_HAVE_LIMITS_H\"] = \"$_MK_HAVE_LIMITS_H\"" >>configure.lua
echo "#undef _MK_HAVE_LIMITS_H" >config/_mk_have_limits_h.h
echo "hdefs[\"_MK_HAVE_LIMITS_H\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking for the __progname variable..."
$ECHO_N "checking for the __progname variable..." >> config.log
cat << EOT > conftest.c
#include <stdio.h>
int
main(int argc, char *argv[])
{
	extern char *__progname;
	printf("%s\n", __progname);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_PROGNAME="yes"
echo "#ifndef HAVE_PROGNAME" > config/have_progname.h
echo "#define HAVE_PROGNAME \"$HAVE_PROGNAME\"" >> config/have_progname.h
echo "#endif" >> config/have_progname.h
echo "hdefs[\"HAVE_PROGNAME\"] = \"$HAVE_PROGNAME\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_PROGNAME="no"
echo "#undef HAVE_PROGNAME" >config/have_progname.h
echo "hdefs[\"HAVE_PROGNAME\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for free(NULL) is a no-op..."
$ECHO_N "checking for free(NULL) is a no-op..." >> config.log
cat << EOT > conftest.c
#include <stdlib.h>
int main(int argc, char *argv[]) {
	free(NULL);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ $? != 0 ]; then
echo "no (compile failed)"
echo "no (compile failed)" >> config.log
compile="failed"
FREE_NULL_IS_A_NOOP="no"
echo "FREE_NULL_IS_A_NOOP=$FREE_NULL_IS_A_NOOP" >>Makefile.config
echo "mdefs[\"FREE_NULL_IS_A_NOOP\"] = \"$FREE_NULL_IS_A_NOOP\"" >>configure.lua
echo "#undef FREE_NULL_IS_A_NOOP" >config/free_null_is_a_noop.h
echo "hdefs[\"FREE_NULL_IS_A_NOOP\"] = nil" >>configure.lua
else
compile="ok"
(cd $testdir && ./conftest) >> config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
FREE_NULL_IS_A_NOOP="yes"
echo "FREE_NULL_IS_A_NOOP=$FREE_NULL_IS_A_NOOP" >>Makefile.config
echo "mdefs[\"FREE_NULL_IS_A_NOOP\"] = \"$FREE_NULL_IS_A_NOOP\"" >>configure.lua
echo "#ifndef FREE_NULL_IS_A_NOOP" > config/free_null_is_a_noop.h
echo "#define FREE_NULL_IS_A_NOOP \"$FREE_NULL_IS_A_NOOP\"" >> config/free_null_is_a_noop.h
echo "#endif" >> config/free_null_is_a_noop.h
echo "hdefs[\"FREE_NULL_IS_A_NOOP\"] = \"$FREE_NULL_IS_A_NOOP\"" >>configure.lua
else
echo "no (exec failed)"
echo "no (exec failed)" >> config.log
FREE_NULL_IS_A_NOOP="no"
echo "FREE_NULL_IS_A_NOOP=$FREE_NULL_IS_A_NOOP" >>Makefile.config
echo "mdefs[\"FREE_NULL_IS_A_NOOP\"] = \"$FREE_NULL_IS_A_NOOP\"" >>configure.lua
echo "#undef FREE_NULL_IS_A_NOOP" >config/free_null_is_a_noop.h
echo "hdefs[\"FREE_NULL_IS_A_NOOP\"] = nil" >>configure.lua
fi;
fi;
rm -f $testdir/conftest conftest.c
$ECHO_N "checking for the C math library..."
$ECHO_N "checking for the C math library..." >> config.log
MATH_LIBS="-lm"
MATH_CFLAGS=""
cat << EOT > conftest.c
#include <math.h>

int
main(int argc, char *argv[])
{
	double d = 1.0;
	d = fabs(d);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${CFLAGS} ${MATH_CFLAGS} -o $testdir/conftest conftest.c ${MATH_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${CFLAGS} ${MATH_CFLAGS} -o $testdir/conftest conftest.c ${MATH_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_MATH="yes"
echo "HAVE_MATH=$HAVE_MATH" >>Makefile.config
echo "mdefs[\"HAVE_MATH\"] = \"$HAVE_MATH\"" >>configure.lua
echo "#ifndef HAVE_MATH" > config/have_math.h
echo "#define HAVE_MATH \"$HAVE_MATH\"" >> config/have_math.h
echo "#endif" >> config/have_math.h
echo "hdefs[\"HAVE_MATH\"] = \"$HAVE_MATH\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_MATH="no"
echo "HAVE_MATH=$HAVE_MATH" >>Makefile.config
echo "mdefs[\"HAVE_MATH\"] = \"$HAVE_MATH\"" >>configure.lua
echo "#undef HAVE_MATH" >config/have_math.h
echo "hdefs[\"HAVE_MATH\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_MATH}" = "yes" ]; then
echo "MATH_CFLAGS=$MATH_CFLAGS" >>Makefile.config
echo "mdefs[\"MATH_CFLAGS\"] = \"$MATH_CFLAGS\"" >>configure.lua
echo "MATH_LIBS=$MATH_LIBS" >>Makefile.config
echo "mdefs[\"MATH_LIBS\"] = \"$MATH_LIBS\"" >>configure.lua
echo "#ifndef MATH_CFLAGS" > config/math_cflags.h
echo "#define MATH_CFLAGS \"$MATH_CFLAGS\"" >> config/math_cflags.h
echo "#endif" >> config/math_cflags.h
echo "hdefs[\"MATH_CFLAGS\"] = \"$MATH_CFLAGS\"" >>configure.lua
echo "#ifndef MATH_LIBS" > config/math_libs.h
echo "#define MATH_LIBS \"$MATH_LIBS\"" >> config/math_libs.h
echo "#endif" >> config/math_libs.h
echo "hdefs[\"MATH_LIBS\"] = \"$MATH_LIBS\"" >>configure.lua
else
echo "#undef MATH_LIBS" >config/math_libs.h
echo "hdefs[\"MATH_LIBS\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a gethostname() function..."
$ECHO_N "checking for a gethostname() function..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <unistd.h>

int
main(int argc, char *argv[])
{
	char hostname[64];
	int rv;

	rv = gethostname(hostname, sizeof(hostname));
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_GETHOSTNAME="yes"
echo "#ifndef HAVE_GETHOSTNAME" > config/have_gethostname.h
echo "#define HAVE_GETHOSTNAME \"$HAVE_GETHOSTNAME\"" >> config/have_gethostname.h
echo "#endif" >> config/have_gethostname.h
echo "hdefs[\"HAVE_GETHOSTNAME\"] = \"$HAVE_GETHOSTNAME\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_GETHOSTNAME="no"
echo "#undef HAVE_GETHOSTNAME" >config/have_gethostname.h
echo "hdefs[\"HAVE_GETHOSTNAME\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a getpwuid() function..."
$ECHO_N "checking for a getpwuid() function..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <pwd.h>

int
main(int argc, char *argv[])
{
	struct passwd *pwd;
	uid_t uid = 0;

	pwd = getpwuid(uid);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_GETPWUID="yes"
echo "#ifndef HAVE_GETPWUID" > config/have_getpwuid.h
echo "#define HAVE_GETPWUID \"$HAVE_GETPWUID\"" >> config/have_getpwuid.h
echo "#endif" >> config/have_getpwuid.h
echo "hdefs[\"HAVE_GETPWUID\"] = \"$HAVE_GETPWUID\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_GETPWUID="no"
echo "#undef HAVE_GETPWUID" >config/have_getpwuid.h
echo "hdefs[\"HAVE_GETPWUID\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a getuid() function..."
$ECHO_N "checking for a getuid() function..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <unistd.h>

int
main(int argc, char *argv[])
{
	uid_t uid;

	uid = getuid();
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_GETUID="yes"
echo "#ifndef HAVE_GETUID" > config/have_getuid.h
echo "#define HAVE_GETUID \"$HAVE_GETUID\"" >> config/have_getuid.h
echo "#endif" >> config/have_getuid.h
echo "hdefs[\"HAVE_GETUID\"] = \"$HAVE_GETUID\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_GETUID="no"
echo "#undef HAVE_GETUID" >config/have_getuid.h
echo "hdefs[\"HAVE_GETUID\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a getenv() function..."
$ECHO_N "checking for a getenv() function..." >> config.log
cat << EOT > conftest.c
#include <stdlib.h>
int
main(int argc, char *argv[])
{
	(void)getenv("PATH");
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_GETENV="yes"
echo "#ifndef HAVE_GETENV" > config/have_getenv.h
echo "#define HAVE_GETENV \"$HAVE_GETENV\"" >> config/have_getenv.h
echo "#endif" >> config/have_getenv.h
echo "hdefs[\"HAVE_GETENV\"] = \"$HAVE_GETENV\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_GETENV="no"
echo "#undef HAVE_GETENV" >config/have_getenv.h
echo "hdefs[\"HAVE_GETENV\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for setenv() and unsetenv()..."
$ECHO_N "checking for setenv() and unsetenv()..." >> config.log
cat << EOT > conftest.c
#include <stdlib.h>
int
main(int argc, char *argv[])
{
	(void)setenv("BSDBUILD_SETENV_TEST", "foo", 1);
	unsetenv("BSDBUILD_SETENV_TEST");

	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_SETENV="yes"
echo "#ifndef HAVE_SETENV" > config/have_setenv.h
echo "#define HAVE_SETENV \"$HAVE_SETENV\"" >> config/have_setenv.h
echo "#endif" >> config/have_setenv.h
echo "hdefs[\"HAVE_SETENV\"] = \"$HAVE_SETENV\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_SETENV="no"
echo "#undef HAVE_SETENV" >config/have_setenv.h
echo "hdefs[\"HAVE_SETENV\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a strsep() function..."
$ECHO_N "checking for a strsep() function..." >> config.log
cat << EOT > conftest.c
#include <string.h>
int
main(int argc, char *argv[])
{
	(void)strsep(NULL, NULL);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_STRSEP="yes"
echo "#ifndef HAVE_STRSEP" > config/have_strsep.h
echo "#define HAVE_STRSEP \"$HAVE_STRSEP\"" >> config/have_strsep.h
echo "#endif" >> config/have_strsep.h
echo "hdefs[\"HAVE_STRSEP\"] = \"$HAVE_STRSEP\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_STRSEP="no"
echo "#undef HAVE_STRSEP" >config/have_strsep.h
echo "hdefs[\"HAVE_STRSEP\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for the snprintf() function..."
$ECHO_N "checking for the snprintf() function..." >> config.log
cat << EOT > conftest.c
#include <stdio.h>

int
main(int argc, char *argv[])
{
	char buf[16];
	(void)snprintf(buf, sizeof(buf), "foo");
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_SNPRINTF="yes"
echo "#ifndef HAVE_SNPRINTF" > config/have_snprintf.h
echo "#define HAVE_SNPRINTF \"$HAVE_SNPRINTF\"" >> config/have_snprintf.h
echo "#endif" >> config/have_snprintf.h
echo "hdefs[\"HAVE_SNPRINTF\"] = \"$HAVE_SNPRINTF\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_SNPRINTF="no"
echo "#undef HAVE_SNPRINTF" >config/have_snprintf.h
echo "hdefs[\"HAVE_SNPRINTF\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for the vsnprintf() function..."
$ECHO_N "checking for the vsnprintf() function..." >> config.log
cat << EOT > conftest.c
#include <stdio.h>
#include <stdarg.h>

static void
testfmt(const char *fmt, ...)
{
	char buf[16];
	va_list ap;
	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof(buf), fmt, ap);
	va_end(ap);
}
int
main(int argc, char *argv[])
{
	testfmt("foo", 1, 2, 3);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_VSNPRINTF="yes"
echo "#ifndef HAVE_VSNPRINTF" > config/have_vsnprintf.h
echo "#define HAVE_VSNPRINTF \"$HAVE_VSNPRINTF\"" >> config/have_vsnprintf.h
echo "#endif" >> config/have_vsnprintf.h
echo "hdefs[\"HAVE_VSNPRINTF\"] = \"$HAVE_VSNPRINTF\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_VSNPRINTF="no"
echo "#undef HAVE_VSNPRINTF" >config/have_vsnprintf.h
echo "hdefs[\"HAVE_VSNPRINTF\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a vasprintf() function..."
$ECHO_N "checking for a vasprintf() function..." >> config.log
cat << EOT > conftest.c
#ifdef __linux__
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <stdarg.h>

int
testprintf(const char *fmt, ...)
{
	va_list args;
	char *buf;

	va_start(args, fmt);
	if (vasprintf(&buf, "%s", args) == -1) {
		return (-1);
	}
	va_end(args);
	return (0);
}
int
main(int argc, char *argv[])
{
	return (testprintf("foo %s", "bar"));
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_VASPRINTF="yes"
echo "#ifndef HAVE_VASPRINTF" > config/have_vasprintf.h
echo "#define HAVE_VASPRINTF \"$HAVE_VASPRINTF\"" >> config/have_vasprintf.h
echo "#endif" >> config/have_vasprintf.h
echo "hdefs[\"HAVE_VASPRINTF\"] = \"$HAVE_VASPRINTF\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_VASPRINTF="no"
echo "#undef HAVE_VASPRINTF" >config/have_vasprintf.h
echo "hdefs[\"HAVE_VASPRINTF\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for the arc4random() random number generator..."
$ECHO_N "checking for the arc4random() random number generator..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <stdlib.h>
int
main(int argc, char *argv[])
{
	u_int32_t i;

	i = arc4random();
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_ARC4RANDOM="yes"
echo "#ifndef HAVE_ARC4RANDOM" > config/have_arc4random.h
echo "#define HAVE_ARC4RANDOM \"$HAVE_ARC4RANDOM\"" >> config/have_arc4random.h
echo "#endif" >> config/have_arc4random.h
echo "hdefs[\"HAVE_ARC4RANDOM\"] = \"$HAVE_ARC4RANDOM\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_ARC4RANDOM="no"
echo "#undef HAVE_ARC4RANDOM" >config/have_arc4random.h
echo "hdefs[\"HAVE_ARC4RANDOM\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for MD5 functions..."
$ECHO_N "checking for MD5 functions..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <md5.h>

int
main(int argc, char *argv[])
{
	MD5_CTX md5;

	MD5Init(&md5);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_MD5="yes"
echo "#ifndef HAVE_MD5" > config/have_md5.h
echo "#define HAVE_MD5 \"$HAVE_MD5\"" >> config/have_md5.h
echo "#endif" >> config/have_md5.h
echo "hdefs[\"HAVE_MD5\"] = \"$HAVE_MD5\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_MD5="no"
echo "#undef HAVE_MD5" >config/have_md5.h
echo "hdefs[\"HAVE_MD5\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for SHA1 functions..."
$ECHO_N "checking for SHA1 functions..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <sha1.h>

int
main(int argc, char *argv[])
{
	SHA1_CTX sha1;

	SHA1Init(&sha1);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_SHA1="yes"
echo "#ifndef HAVE_SHA1" > config/have_sha1.h
echo "#define HAVE_SHA1 \"$HAVE_SHA1\"" >> config/have_sha1.h
echo "#endif" >> config/have_sha1.h
echo "hdefs[\"HAVE_SHA1\"] = \"$HAVE_SHA1\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_SHA1="no"
echo "#undef HAVE_SHA1" >config/have_sha1.h
echo "hdefs[\"HAVE_SHA1\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for RMD160 functions..."
$ECHO_N "checking for RMD160 functions..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <rmd160.h>

int
main(int argc, char *argv[])
{
	RMD160_CTX rmd160;

	RMD160Init(&rmd160);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_RMD160="yes"
echo "#ifndef HAVE_RMD160" > config/have_rmd160.h
echo "#define HAVE_RMD160 \"$HAVE_RMD160\"" >> config/have_rmd160.h
echo "#endif" >> config/have_rmd160.h
echo "hdefs[\"HAVE_RMD160\"] = \"$HAVE_RMD160\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_RMD160="no"
echo "#undef HAVE_RMD160" >config/have_rmd160.h
echo "hdefs[\"HAVE_RMD160\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for the X window system..."
$ECHO_N "checking for the X window system..." >> config.log
X11_CFLAGS=""
X11_LIBS=""
if [ -d /usr/include/X11/X11 ]; then
X11_CFLAGS="-I/usr/include/X11"
fi;
if [ -d /usr/include/X11R6/X11 ]; then
X11_CFLAGS="-I/usr/include/X11R6"
fi;
if [ -d /usr/local/X11/include/X11 ]; then
X11_CFLAGS="-I/usr/local/X11/include"
fi;
if [ -d /usr/local/X11R6/include/X11 ]; then
X11_CFLAGS="-I/usr/local/X11R6/include"
fi;
if [ -d /usr/local/include/X11/X11 ]; then
X11_CFLAGS="-I/usr/local/include/X11"
fi;
if [ -d /usr/local/include/X11R6/X11 ]; then
X11_CFLAGS="-I/usr/local/include/X11R6"
fi;
if [ -d /usr/X11/include/X11 ]; then
X11_CFLAGS="-I/usr/X11/include"
fi;
if [ -d /usr/X11R6/include/X11 ]; then
X11_CFLAGS="-I/usr/X11R6/include"
fi;
if [ -d /usr/local/X11/lib ]; then
X11_LIBS="-L/usr/local/X11/lib"
fi;
if [ -d /usr/local/X11R6/lib ]; then
X11_LIBS="-L/usr/local/X11R6/lib"
fi;
if [ -d /usr/X11/lib ]; then
X11_LIBS="-L/usr/X11/lib"
fi;
if [ -d /usr/X11R6/lib ]; then
X11_LIBS="-L/usr/X11R6/lib"
fi;
cat << EOT > conftest.c
#include <X11/Xlib.h>
int main(int argc, char *argv[])
{
	Display *disp;
	disp = XOpenDisplay(NULL);
	XCloseDisplay(disp);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${X11_CFLAGS} -o $testdir/conftest conftest.c ${X11_LIBS} -lX11" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${X11_CFLAGS} -o $testdir/conftest conftest.c ${X11_LIBS} -lX11 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_X11="yes"
echo "HAVE_X11=$HAVE_X11" >>Makefile.config
echo "mdefs[\"HAVE_X11\"] = \"$HAVE_X11\"" >>configure.lua
echo "#ifndef HAVE_X11" > config/have_x11.h
echo "#define HAVE_X11 \"$HAVE_X11\"" >> config/have_x11.h
echo "#endif" >> config/have_x11.h
echo "hdefs[\"HAVE_X11\"] = \"$HAVE_X11\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_X11="no"
echo "HAVE_X11=$HAVE_X11" >>Makefile.config
echo "mdefs[\"HAVE_X11\"] = \"$HAVE_X11\"" >>configure.lua
echo "#undef HAVE_X11" >config/have_x11.h
echo "hdefs[\"HAVE_X11\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_X11}" != "" ]; then
echo "#ifndef X11_CFLAGS" > config/x11_cflags.h
echo "#define X11_CFLAGS \"$X11_CFLAGS\"" >> config/x11_cflags.h
echo "#endif" >> config/x11_cflags.h
echo "hdefs[\"X11_CFLAGS\"] = \"$X11_CFLAGS\"" >>configure.lua
echo "#ifndef X11_LIBS" > config/x11_libs.h
echo "#define X11_LIBS \"$X11_LIBS\"" >> config/x11_libs.h
echo "#endif" >> config/x11_libs.h
echo "hdefs[\"X11_LIBS\"] = \"$X11_LIBS\"" >>configure.lua
echo "X11_CFLAGS=$X11_CFLAGS" >>Makefile.config
echo "mdefs[\"X11_CFLAGS\"] = \"$X11_CFLAGS\"" >>configure.lua
echo "X11_LIBS=$X11_LIBS" >>Makefile.config
echo "mdefs[\"X11_LIBS\"] = \"$X11_LIBS\"" >>configure.lua
else
echo "#undef X11_CFLAGS" >config/x11_cflags.h
echo "hdefs[\"X11_CFLAGS\"] = nil" >>configure.lua
echo "#undef X11_LIBS" >config/x11_libs.h
echo "hdefs[\"X11_LIBS\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for the signal() function..."
$ECHO_N "checking for the signal() function..." >> config.log
cat << EOT > conftest.c
#include <signal.h>

void
sighandler(int sig)
{
}

int
main(int argc, char *argv[])
{
	signal(SIGTERM, sighandler);
	signal(SIGILL, sighandler);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
_MK_HAVE_SIGNAL="yes"
echo "#ifndef _MK_HAVE_SIGNAL" > config/_mk_have_signal.h
echo "#define _MK_HAVE_SIGNAL \"$_MK_HAVE_SIGNAL\"" >> config/_mk_have_signal.h
echo "#endif" >> config/_mk_have_signal.h
echo "hdefs[\"_MK_HAVE_SIGNAL\"] = \"$_MK_HAVE_SIGNAL\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
_MK_HAVE_SIGNAL="no"
echo "#undef _MK_HAVE_SIGNAL" >config/_mk_have_signal.h
echo "hdefs[\"_MK_HAVE_SIGNAL\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for setjmp() and longjmp()..."
$ECHO_N "checking for setjmp() and longjmp()..." >> config.log
cat << EOT > conftest.c
#include <setjmp.h>

jmp_buf jmpbuf;

int
main(int argc, char *argv[])
{
	longjmp(jmpbuf, 1);
	setjmp(jmpbuf);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
_MK_HAVE_SETJMP="yes"
echo "#ifndef _MK_HAVE_SETJMP" > config/_mk_have_setjmp.h
echo "#define _MK_HAVE_SETJMP \"$_MK_HAVE_SETJMP\"" >> config/_mk_have_setjmp.h
echo "#endif" >> config/_mk_have_setjmp.h
echo "hdefs[\"_MK_HAVE_SETJMP\"] = \"$_MK_HAVE_SETJMP\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
_MK_HAVE_SETJMP="no"
echo "#undef _MK_HAVE_SETJMP" >config/_mk_have_setjmp.h
echo "hdefs[\"_MK_HAVE_SETJMP\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a strtoll() function..."
$ECHO_N "checking for a strtoll() function..." >> config.log
cat << EOT > conftest.c
#include <stdlib.h>

int
main(int argc, char *argv[])
{
	long long int lli;
	char *ep = NULL;
	char *foo = "1234";

	lli = strtoll(foo, &ep, 10);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
_MK_HAVE_STRTOLL="yes"
echo "#ifndef _MK_HAVE_STRTOLL" > config/_mk_have_strtoll.h
echo "#define _MK_HAVE_STRTOLL \"$_MK_HAVE_STRTOLL\"" >> config/_mk_have_strtoll.h
echo "#endif" >> config/_mk_have_strtoll.h
echo "hdefs[\"_MK_HAVE_STRTOLL\"] = \"$_MK_HAVE_STRTOLL\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
_MK_HAVE_STRTOLL="no"
echo "#undef _MK_HAVE_STRTOLL" >config/_mk_have_strtoll.h
echo "hdefs[\"_MK_HAVE_STRTOLL\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for a strtold() function..."
$ECHO_N "checking for a strtold() function..." >> config.log
cat << EOT > conftest.c
#define _XOPEN_SOURCE 600
#include <stdlib.h>

int
main(int argc, char *argv[])
{
	long double ld;
	char *ep = NULL;
	char *foo = "1234";

	ld = strtold(foo, &ep);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
_MK_HAVE_STRTOLD="yes"
echo "#ifndef _MK_HAVE_STRTOLD" > config/_mk_have_strtold.h
echo "#define _MK_HAVE_STRTOLD \"$_MK_HAVE_STRTOLD\"" >> config/_mk_have_strtold.h
echo "#endif" >> config/_mk_have_strtold.h
echo "hdefs[\"_MK_HAVE_STRTOLD\"] = \"$_MK_HAVE_STRTOLD\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
_MK_HAVE_STRTOLD="no"
echo "#undef _MK_HAVE_STRTOLD" >config/_mk_have_strtold.h
echo "hdefs[\"_MK_HAVE_STRTOLD\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for AltiVec (with <altivec.h>)..."
$ECHO_N "checking for AltiVec (with <altivec.h>)..." >> config.log
if [ "$SYSTEM" = "Darwin" ]; then
ALTIVEC_CFLAGS="-faltivec -maltivec"
ALTIVEC_CHECK_CFLAGS="-D_DARWIN_C_SOURCE"
echo "ALTIVEC_CHECK_CFLAGS=$ALTIVEC_CHECK_CFLAGS" >>Makefile.config
echo "mdefs[\"ALTIVEC_CHECK_CFLAGS\"] = \"$ALTIVEC_CHECK_CFLAGS\"" >>configure.lua
else
ALTIVEC_CFLAGS="-mabi=altivec -maltivec"
ALTIVEC_CHECK_CFLAGS=""
echo "ALTIVEC_CHECK_CFLAGS=$ALTIVEC_CHECK_CFLAGS" >>Makefile.config
echo "mdefs[\"ALTIVEC_CHECK_CFLAGS\"] = \"$ALTIVEC_CHECK_CFLAGS\"" >>configure.lua
fi;
cat << EOT > conftest.c
#include <altivec.h>
float a[4] = { 1,2,3,4 };
float b[4] = { 5,6,7,8 };
float c[4];

int
main(int argc, char *argv[])
{
	vector float *va = (vector float *)a;
	vector float *vb = (vector float *)b;
	vector float *vc = (vector float *)c;

	*vc = vec_add(*va, *vb);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${CFLAGS} ${ALTIVEC_CFLAGS} -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS ${CFLAGS} ${ALTIVEC_CFLAGS} -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_ALTIVEC="yes"
echo "HAVE_ALTIVEC=$HAVE_ALTIVEC" >>Makefile.config
echo "mdefs[\"HAVE_ALTIVEC\"] = \"$HAVE_ALTIVEC\"" >>configure.lua
echo "#ifndef HAVE_ALTIVEC" > config/have_altivec.h
echo "#define HAVE_ALTIVEC \"$HAVE_ALTIVEC\"" >> config/have_altivec.h
echo "#endif" >> config/have_altivec.h
echo "hdefs[\"HAVE_ALTIVEC\"] = \"$HAVE_ALTIVEC\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_ALTIVEC="no"
echo "HAVE_ALTIVEC=$HAVE_ALTIVEC" >>Makefile.config
echo "mdefs[\"HAVE_ALTIVEC\"] = \"$HAVE_ALTIVEC\"" >>configure.lua
echo "#undef HAVE_ALTIVEC" >config/have_altivec.h
echo "hdefs[\"HAVE_ALTIVEC\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_ALTIVEC}" = "yes" ]; then
echo "ALTIVEC_CFLAGS=$ALTIVEC_CFLAGS" >>Makefile.config
echo "mdefs[\"ALTIVEC_CFLAGS\"] = \"$ALTIVEC_CFLAGS\"" >>configure.lua
HAVE_ALTIVEC_H=""
echo "#ifndef ALTIVEC_CFLAGS" > config/altivec_cflags.h
echo "#define ALTIVEC_CFLAGS \"$ALTIVEC_CFLAGS\"" >> config/altivec_cflags.h
echo "#endif" >> config/altivec_cflags.h
echo "hdefs[\"ALTIVEC_CFLAGS\"] = \"$ALTIVEC_CFLAGS\"" >>configure.lua
echo "#ifndef HAVE_ALTIVEC_H" > config/have_altivec_h.h
echo "#define HAVE_ALTIVEC_H \"$HAVE_ALTIVEC_H\"" >> config/have_altivec_h.h
echo "#endif" >> config/have_altivec_h.h
echo "hdefs[\"HAVE_ALTIVEC_H\"] = \"$HAVE_ALTIVEC_H\"" >>configure.lua
else
$ECHO_N "checking for AltiVec (without <altivec.h>)..."
$ECHO_N "checking for AltiVec (without <altivec.h>)..." >> config.log
cat << EOT > conftest.c
float a[4] = { 1,2,3,4 };
float b[4] = { 5,6,7,8 };
float c[4];

int
main(int argc, char *argv[])
{
	vector float *va = (vector float *)a;
	vector float *vb = (vector float *)b;
	vector float *vc = (vector float *)c;

	*vc = vec_add(*va, *vb);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${CFLAGS} ${ALTIVEC_CFLAGS} -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS ${CFLAGS} ${ALTIVEC_CFLAGS} -o $testdir/conftest conftest.c  2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_ALTIVEC="yes"
echo "HAVE_ALTIVEC=$HAVE_ALTIVEC" >>Makefile.config
echo "mdefs[\"HAVE_ALTIVEC\"] = \"$HAVE_ALTIVEC\"" >>configure.lua
echo "#ifndef HAVE_ALTIVEC" > config/have_altivec.h
echo "#define HAVE_ALTIVEC \"$HAVE_ALTIVEC\"" >> config/have_altivec.h
echo "#endif" >> config/have_altivec.h
echo "hdefs[\"HAVE_ALTIVEC\"] = \"$HAVE_ALTIVEC\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_ALTIVEC="no"
echo "HAVE_ALTIVEC=$HAVE_ALTIVEC" >>Makefile.config
echo "mdefs[\"HAVE_ALTIVEC\"] = \"$HAVE_ALTIVEC\"" >>configure.lua
echo "#undef HAVE_ALTIVEC" >config/have_altivec.h
echo "hdefs[\"HAVE_ALTIVEC\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_ALTIVEC}" = "yes" ]; then
echo "ALTIVEC_CFLAGS=$ALTIVEC_CFLAGS" >>Makefile.config
echo "mdefs[\"ALTIVEC_CFLAGS\"] = \"$ALTIVEC_CFLAGS\"" >>configure.lua
echo "#ifndef ALTIVEC_CFLAGS" > config/altivec_cflags.h
echo "#define ALTIVEC_CFLAGS \"$ALTIVEC_CFLAGS\"" >> config/altivec_cflags.h
echo "#endif" >> config/altivec_cflags.h
echo "hdefs[\"ALTIVEC_CFLAGS\"] = \"$ALTIVEC_CFLAGS\"" >>configure.lua
else
echo "#undef ALTIVEC_CFLAGS" >config/altivec_cflags.h
echo "hdefs[\"ALTIVEC_CFLAGS\"] = nil" >>configure.lua
ALTIVEC_CFLAGS=""
echo "ALTIVEC_CFLAGS=$ALTIVEC_CFLAGS" >>Makefile.config
echo "mdefs[\"ALTIVEC_CFLAGS\"] = \"$ALTIVEC_CFLAGS\"" >>configure.lua
fi;
echo "#undef HAVE_ALTIVEC_H" >config/have_altivec_h.h
echo "hdefs[\"HAVE_ALTIVEC_H\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for byte order..."
$ECHO_N "checking for byte order..." >> config.log
echo ""
echo "" >> config.log
$ECHO_N "checking for BIG_ENDIAN..."
$ECHO_N "checking for BIG_ENDIAN..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <sys/param.h>
int
main(int argc, char *argv[])
{
#if BYTE_ORDER == BIG_ENDIAN
	return (0);
#else
	return (1);
#endif
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ $? != 0 ]; then
echo "no (compile failed)"
echo "no (compile failed)" >> config.log
compile="failed"
_MK_BIG_ENDIAN="no"
echo "_MK_BIG_ENDIAN=$_MK_BIG_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_BIG_ENDIAN\"] = \"$_MK_BIG_ENDIAN\"" >>configure.lua
echo "#undef _MK_BIG_ENDIAN" >config/_mk_big_endian.h
echo "hdefs[\"_MK_BIG_ENDIAN\"] = nil" >>configure.lua
else
compile="ok"
(cd $testdir && ./conftest) >> config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
_MK_BIG_ENDIAN="yes"
echo "_MK_BIG_ENDIAN=$_MK_BIG_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_BIG_ENDIAN\"] = \"$_MK_BIG_ENDIAN\"" >>configure.lua
echo "#ifndef _MK_BIG_ENDIAN" > config/_mk_big_endian.h
echo "#define _MK_BIG_ENDIAN \"$_MK_BIG_ENDIAN\"" >> config/_mk_big_endian.h
echo "#endif" >> config/_mk_big_endian.h
echo "hdefs[\"_MK_BIG_ENDIAN\"] = \"$_MK_BIG_ENDIAN\"" >>configure.lua
else
echo "no (exec failed)"
echo "no (exec failed)" >> config.log
_MK_BIG_ENDIAN="no"
echo "_MK_BIG_ENDIAN=$_MK_BIG_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_BIG_ENDIAN\"] = \"$_MK_BIG_ENDIAN\"" >>configure.lua
echo "#undef _MK_BIG_ENDIAN" >config/_mk_big_endian.h
echo "hdefs[\"_MK_BIG_ENDIAN\"] = nil" >>configure.lua
fi;
fi;
rm -f $testdir/conftest conftest.c
if [ "${_MK_BIG_ENDIAN}" = "yes" ]; then
_MK_LITTLE_ENDIAN="no"
echo "#undef _MK_LITTLE_ENDIAN" >config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = nil" >>configure.lua
else
$ECHO_N "checking for LITTLE_ENDIAN..."
$ECHO_N "checking for LITTLE_ENDIAN..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <sys/param.h>
int
main(int argc, char *argv[])
{
#if BYTE_ORDER == LITTLE_ENDIAN
	return (0);
#else
	return (1);
#endif
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ $? != 0 ]; then
echo "no (compile failed)"
echo "no (compile failed)" >> config.log
compile="failed"
_MK_LITTLE_ENDIAN="no"
echo "_MK_LITTLE_ENDIAN=$_MK_LITTLE_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
echo "#undef _MK_LITTLE_ENDIAN" >config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = nil" >>configure.lua
else
compile="ok"
(cd $testdir && ./conftest) >> config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
_MK_LITTLE_ENDIAN="yes"
echo "_MK_LITTLE_ENDIAN=$_MK_LITTLE_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
echo "#ifndef _MK_LITTLE_ENDIAN" > config/_mk_little_endian.h
echo "#define _MK_LITTLE_ENDIAN \"$_MK_LITTLE_ENDIAN\"" >> config/_mk_little_endian.h
echo "#endif" >> config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
else
echo "no (exec failed)"
echo "no (exec failed)" >> config.log
_MK_LITTLE_ENDIAN="no"
echo "_MK_LITTLE_ENDIAN=$_MK_LITTLE_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
echo "#undef _MK_LITTLE_ENDIAN" >config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = nil" >>configure.lua
fi;
fi;
rm -f $testdir/conftest conftest.c
if [ "${_MK_LITTLE_ENDIAN}" = "yes" ]; then
_MK_BIG_ENDIAN="no"
echo "#undef _MK_BIG_ENDIAN" >config/_mk_big_endian.h
echo "hdefs[\"_MK_BIG_ENDIAN\"] = nil" >>configure.lua
else
$ECHO_N "checking for little endian byte order..."
$ECHO_N "checking for little endian byte order..." >> config.log
cat << EOT > conftest.c
int
main(int argc, char *argv[])
{
	union {
		long l;
		char c[sizeof (long)];
	} u;
	u.l = 1;
	return (u.c[sizeof (long) - 1] == 1);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c " >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c  2>>config.log
if [ $? != 0 ]; then
echo "no (compile failed)"
echo "no (compile failed)" >> config.log
compile="failed"
_MK_LITTLE_ENDIAN="no"
echo "_MK_LITTLE_ENDIAN=$_MK_LITTLE_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
echo "#undef _MK_LITTLE_ENDIAN" >config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = nil" >>configure.lua
else
compile="ok"
(cd $testdir && ./conftest) >> config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
_MK_LITTLE_ENDIAN="yes"
echo "_MK_LITTLE_ENDIAN=$_MK_LITTLE_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
echo "#ifndef _MK_LITTLE_ENDIAN" > config/_mk_little_endian.h
echo "#define _MK_LITTLE_ENDIAN \"$_MK_LITTLE_ENDIAN\"" >> config/_mk_little_endian.h
echo "#endif" >> config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
else
echo "no (exec failed)"
echo "no (exec failed)" >> config.log
_MK_LITTLE_ENDIAN="no"
echo "_MK_LITTLE_ENDIAN=$_MK_LITTLE_ENDIAN" >>Makefile.config
echo "mdefs[\"_MK_LITTLE_ENDIAN\"] = \"$_MK_LITTLE_ENDIAN\"" >>configure.lua
echo "#undef _MK_LITTLE_ENDIAN" >config/_mk_little_endian.h
echo "hdefs[\"_MK_LITTLE_ENDIAN\"] = nil" >>configure.lua
fi;
fi;
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "failed" ]; then
echo "Unable to determine byte order"
exit 1
fi;
if [ "${_MK_LITTLE_ENDIAN}" = "no" ]; then
_MK_BIG_ENDIAN="yes"
echo "#ifndef _MK_BIG_ENDIAN" > config/_mk_big_endian.h
echo "#define _MK_BIG_ENDIAN \"$_MK_BIG_ENDIAN\"" >> config/_mk_big_endian.h
echo "#endif" >> config/_mk_big_endian.h
echo "hdefs[\"_MK_BIG_ENDIAN\"] = \"$_MK_BIG_ENDIAN\"" >>configure.lua
fi;
fi;
fi;
CFLAGS="$CFLAGS -D_AGAR_INTERNAL"
CXXFLAGS="$CXXFLAGS -D_AGAR_INTERNAL"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
CFLAGS="$CFLAGS -D_BSD_SOURCE"
CXXFLAGS="$CXXFLAGS -D_BSD_SOURCE"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
CFLAGS="$CFLAGS -I$SRC"
CXXFLAGS="$CXXFLAGS -I$SRC"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
if [ "${enable_warnings}" = "yes" ]
 then
CFLAGS="$CFLAGS -Wall"
CXXFLAGS="$CXXFLAGS -Wall"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
CFLAGS="$CFLAGS -Werror"
CXXFLAGS="$CXXFLAGS -Werror"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
CFLAGS="$CFLAGS -Wmissing-prototypes"
CXXFLAGS="$CXXFLAGS -Wmissing-prototypes"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
WNO_UNINITIALIZED="-Wno-uninitialized"
echo "WNO_UNINITIALIZED=$WNO_UNINITIALIZED" >>Makefile.config
echo "mdefs[\"WNO_UNINITIALIZED\"] = \"$WNO_UNINITIALIZED\"" >>configure.lua
else
WNO_UNINITIALIZED=""""
echo "WNO_UNINITIALIZED=$WNO_UNINITIALIZED" >>Makefile.config
echo "mdefs[\"WNO_UNINITIALIZED\"] = \"$WNO_UNINITIALIZED\"" >>configure.lua
fi
if [ "${enable_lockdebug}" = "yes" ]
 then
LOCKDEBUG="1"
echo "#ifndef LOCKDEBUG" > config/lockdebug.h
echo "#define LOCKDEBUG \"$LOCKDEBUG\"" >> config/lockdebug.h
echo "#endif" >> config/lockdebug.h
echo "hdefs[\"LOCKDEBUG\"] = \"$LOCKDEBUG\"" >>configure.lua
else
echo "#undef LOCKDEBUG" >config/lockdebug.h
echo "hdefs[\"LOCKDEBUG\"] = nil" >>configure.lua
fi
$ECHO_N "checking for SDL (http://www.libsdl.org)..."
$ECHO_N "checking for SDL (http://www.libsdl.org)..." >> config.log
if [ "${SYSTEM}" = "Darwin" ]; then
SDL_VERSION=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_VERSION=`${path}/sdl-config --version`
	fi
done
SDL_CFLAGS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_CFLAGS=`${path}/sdl-config --cflags`
	fi
done
SDL_LIBS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_LIBS=`${path}/sdl-config --libs`
	fi
done
elif [ "${SYSTEM}" = "FreeBSD" ]; then
SDL_VERSION=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl11-config" ]; then
		SDL_VERSION=`${path}/sdl11-config --version`
	fi
done
if [ "${SDL_VERSION}" != "" ]; then
SDL_CFLAGS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl11-config" ]; then
		SDL_CFLAGS=`${path}/sdl11-config --cflags`
	fi
done
SDL_LIBS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl11-config" ]; then
		SDL_LIBS=`${path}/sdl11-config --libs`
	fi
done
else
SDL_VERSION=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_VERSION=`${path}/sdl-config --version`
	fi
done
SDL_CFLAGS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_CFLAGS=`${path}/sdl-config --cflags`
	fi
done
SDL_LIBS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_LIBS=`${path}/sdl-config --libs`
	fi
done
fi;
else
SDL_VERSION=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_VERSION=`${path}/sdl-config --version`
	fi
done
SDL_CFLAGS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_CFLAGS=`${path}/sdl-config --cflags`
	fi
done
SDL_LIBS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/sdl-config" ]; then
		SDL_LIBS=`${path}/sdl-config --libs`
	fi
done
fi;
if [ "${SDL_VERSION}" != "" ]; then
echo "yes"
echo "yes" >> config.log
$ECHO_N "checking whether SDL works..."
$ECHO_N "checking whether SDL works..." >> config.log
cat << EOT > conftest.c
#include <stdio.h>
#include <SDL.h>
int main(int argc, char *argv[]) {
	SDL_Surface *su;
	if (SDL_Init(SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) != 0) {
		return (1);
	}
	su = SDL_CreateRGBSurface(0, 16, 16, 32, 0, 0, 0, 0);
	SDL_FreeSurface(su);
	SDL_Quit();
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${SDL_CFLAGS} -o $testdir/conftest conftest.c ${SDL_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${SDL_CFLAGS} -o $testdir/conftest conftest.c ${SDL_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_SDL="yes"
echo "HAVE_SDL=$HAVE_SDL" >>Makefile.config
echo "mdefs[\"HAVE_SDL\"] = \"$HAVE_SDL\"" >>configure.lua
echo "#ifndef HAVE_SDL" > config/have_sdl.h
echo "#define HAVE_SDL \"$HAVE_SDL\"" >> config/have_sdl.h
echo "#endif" >> config/have_sdl.h
echo "hdefs[\"HAVE_SDL\"] = \"$HAVE_SDL\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_SDL="no"
echo "HAVE_SDL=$HAVE_SDL" >>Makefile.config
echo "mdefs[\"HAVE_SDL\"] = \"$HAVE_SDL\"" >>configure.lua
echo "#undef HAVE_SDL" >config/have_sdl.h
echo "hdefs[\"HAVE_SDL\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_SDL}" != "no" ]; then
echo "SDL_CFLAGS=$SDL_CFLAGS" >>Makefile.config
echo "mdefs[\"SDL_CFLAGS\"] = \"$SDL_CFLAGS\"" >>configure.lua
echo "SDL_LIBS=$SDL_LIBS" >>Makefile.config
echo "mdefs[\"SDL_LIBS\"] = \"$SDL_LIBS\"" >>configure.lua
echo "#ifndef SDL_CFLAGS" > config/sdl_cflags.h
echo "#define SDL_CFLAGS \"$SDL_CFLAGS\"" >> config/sdl_cflags.h
echo "#endif" >> config/sdl_cflags.h
echo "hdefs[\"SDL_CFLAGS\"] = \"$SDL_CFLAGS\"" >>configure.lua
echo "#ifndef SDL_LIBS" > config/sdl_libs.h
echo "#define SDL_LIBS \"$SDL_LIBS\"" >> config/sdl_libs.h
echo "#endif" >> config/sdl_libs.h
echo "hdefs[\"SDL_LIBS\"] = \"$SDL_LIBS\"" >>configure.lua
else
$ECHO_N "checking whether SDL works (with X11 libs)..."
$ECHO_N "checking whether SDL works (with X11 libs)..." >> config.log
SDL_LIBS="${SDL_LIBS} -L/usr/X11R6/lib -lX11 -lXext -lXrandr -lXrender"
cat << EOT > conftest.c
#include <stdio.h>
#include <SDL.h>
int main(int argc, char *argv[]) {
	SDL_Surface *su;
	if (SDL_Init(SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) != 0) {
		return (1);
	}
	su = SDL_CreateRGBSurface(0, 16, 16, 32, 0, 0, 0, 0);
	SDL_FreeSurface(su);
	SDL_Quit();
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${SDL_CFLAGS} -o $testdir/conftest conftest.c ${SDL_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${SDL_CFLAGS} -o $testdir/conftest conftest.c ${SDL_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_SDL="yes"
echo "HAVE_SDL=$HAVE_SDL" >>Makefile.config
echo "mdefs[\"HAVE_SDL\"] = \"$HAVE_SDL\"" >>configure.lua
echo "#ifndef HAVE_SDL" > config/have_sdl.h
echo "#define HAVE_SDL \"$HAVE_SDL\"" >> config/have_sdl.h
echo "#endif" >> config/have_sdl.h
echo "hdefs[\"HAVE_SDL\"] = \"$HAVE_SDL\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_SDL="no"
echo "HAVE_SDL=$HAVE_SDL" >>Makefile.config
echo "mdefs[\"HAVE_SDL\"] = \"$HAVE_SDL\"" >>configure.lua
echo "#undef HAVE_SDL" >config/have_sdl.h
echo "hdefs[\"HAVE_SDL\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_SDL}" != "no" ]; then
echo "SDL_CFLAGS=$SDL_CFLAGS" >>Makefile.config
echo "mdefs[\"SDL_CFLAGS\"] = \"$SDL_CFLAGS\"" >>configure.lua
echo "SDL_LIBS=$SDL_LIBS" >>Makefile.config
echo "mdefs[\"SDL_LIBS\"] = \"$SDL_LIBS\"" >>configure.lua
echo "#ifndef SDL_CFLAGS" > config/sdl_cflags.h
echo "#define SDL_CFLAGS \"$SDL_CFLAGS\"" >> config/sdl_cflags.h
echo "#endif" >> config/sdl_cflags.h
echo "hdefs[\"SDL_CFLAGS\"] = \"$SDL_CFLAGS\"" >>configure.lua
echo "#ifndef SDL_LIBS" > config/sdl_libs.h
echo "#define SDL_LIBS \"$SDL_LIBS\"" >> config/sdl_libs.h
echo "#endif" >> config/sdl_libs.h
echo "hdefs[\"SDL_LIBS\"] = \"$SDL_LIBS\"" >>configure.lua
else
echo "#undef SDL_CFLAGS" >config/sdl_cflags.h
echo "hdefs[\"SDL_CFLAGS\"] = nil" >>configure.lua
echo "#undef SDL_LIBS" >config/sdl_libs.h
echo "hdefs[\"SDL_LIBS\"] = nil" >>configure.lua
fi;
fi;
else
echo "no"
echo "no" >> config.log
echo "#undef HAVE_SDL" >config/have_sdl.h
echo "hdefs[\"HAVE_SDL\"] = nil" >>configure.lua
echo "#undef SDL_CFLAGS" >config/sdl_cflags.h
echo "hdefs[\"SDL_CFLAGS\"] = nil" >>configure.lua
echo "#undef SDL_LIBS" >config/sdl_libs.h
echo "hdefs[\"SDL_LIBS\"] = nil" >>configure.lua
fi;
if [ "${HAVE_SDL}" != "yes" ]
 then
	echo "*"
	echo "* Agar-GUI requires the SDL library. You can download it "
	echo "* from: http://www.libsdl.org/"
	echo "*"
	exit 1
fi
if [ "${enable_gui}" != "no" ]
 then
ENABLE_GUI="1"
echo "#ifndef ENABLE_GUI" > config/enable_gui.h
echo "#define ENABLE_GUI \"$ENABLE_GUI\"" >> config/enable_gui.h
echo "#endif" >> config/enable_gui.h
echo "hdefs[\"ENABLE_GUI\"] = \"$ENABLE_GUI\"" >>configure.lua
	if [ "${with_freetype}" != "no" ]
 then
$ECHO_N "checking for FreeType (http://www.freetype.org)..."
$ECHO_N "checking for FreeType (http://www.freetype.org)..." >> config.log
FREETYPE_VERSION=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/freetype-config" ]; then
		FREETYPE_VERSION=`${path}/freetype-config --version`
	fi
done
FREETYPE_CFLAGS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/freetype-config" ]; then
		FREETYPE_CFLAGS=`${path}/freetype-config --cflags`
	fi
done
FREETYPE_LIBS=""
for path in `echo $PATH | sed 's/:/ /g'`; do
	if [ -x "${path}/freetype-config" ]; then
		FREETYPE_LIBS=`${path}/freetype-config --libs`
	fi
done
if [ -d /usr/freeware/include ]; then
FREETYPE_CFLAGS="${FREETYPE_CFLAGS} -I/usr/freeware/include"
fi;
if [ "${FREETYPE_VERSION}" != "" ]; then
echo "yes"
echo "yes" >> config.log
$ECHO_N "checking whether FreeType works..."
$ECHO_N "checking whether FreeType works..." >> config.log
cat << EOT > conftest.c
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_OUTLINE_H
int
main(int argc, char *argv[])
{
	FT_Library library;
	FT_Face face;
	FT_Init_FreeType(&library);
	FT_New_Face(library, "foo", 0, &face);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${FREETYPE_CFLAGS} -o $testdir/conftest conftest.c ${FREETYPE_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${FREETYPE_CFLAGS} -o $testdir/conftest conftest.c ${FREETYPE_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_FREETYPE="yes"
echo "HAVE_FREETYPE=$HAVE_FREETYPE" >>Makefile.config
echo "mdefs[\"HAVE_FREETYPE\"] = \"$HAVE_FREETYPE\"" >>configure.lua
echo "#ifndef HAVE_FREETYPE" > config/have_freetype.h
echo "#define HAVE_FREETYPE \"$HAVE_FREETYPE\"" >> config/have_freetype.h
echo "#endif" >> config/have_freetype.h
echo "hdefs[\"HAVE_FREETYPE\"] = \"$HAVE_FREETYPE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_FREETYPE="no"
echo "HAVE_FREETYPE=$HAVE_FREETYPE" >>Makefile.config
echo "mdefs[\"HAVE_FREETYPE\"] = \"$HAVE_FREETYPE\"" >>configure.lua
echo "#undef HAVE_FREETYPE" >config/have_freetype.h
echo "hdefs[\"HAVE_FREETYPE\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_FREETYPE}" = "yes" ]; then
echo "#ifndef FREETYPE_CFLAGS" > config/freetype_cflags.h
echo "#define FREETYPE_CFLAGS \"$FREETYPE_CFLAGS\"" >> config/freetype_cflags.h
echo "#endif" >> config/freetype_cflags.h
echo "hdefs[\"FREETYPE_CFLAGS\"] = \"$FREETYPE_CFLAGS\"" >>configure.lua
echo "#ifndef FREETYPE_LIBS" > config/freetype_libs.h
echo "#define FREETYPE_LIBS \"$FREETYPE_LIBS\"" >> config/freetype_libs.h
echo "#endif" >> config/freetype_libs.h
echo "hdefs[\"FREETYPE_LIBS\"] = \"$FREETYPE_LIBS\"" >>configure.lua
echo "FREETYPE_CFLAGS=$FREETYPE_CFLAGS" >>Makefile.config
echo "mdefs[\"FREETYPE_CFLAGS\"] = \"$FREETYPE_CFLAGS\"" >>configure.lua
echo "FREETYPE_LIBS=$FREETYPE_LIBS" >>Makefile.config
echo "mdefs[\"FREETYPE_LIBS\"] = \"$FREETYPE_LIBS\"" >>configure.lua
else
echo "#undef FREETYPE_CFLAGS" >config/freetype_cflags.h
echo "hdefs[\"FREETYPE_CFLAGS\"] = nil" >>configure.lua
echo "#undef FREETYPE_LIBS" >config/freetype_libs.h
echo "hdefs[\"FREETYPE_LIBS\"] = nil" >>configure.lua
fi;
else
echo "#undef HAVE_FREETYPE" >config/have_freetype.h
echo "hdefs[\"HAVE_FREETYPE\"] = nil" >>configure.lua
echo "no"
echo "no" >> config.log
fi;
		if [ "${HAVE_FREETYPE}" != "yes" ]
 then
			echo "*"
			echo "* Agar needs FreeType to display vector fonts"
			echo "* (http://www.freetype.org/)."
			echo "*"
			echo "* If you really want to use Agar's built-in low"
			echo "* quality bitmap font engine, run the configure"
			echo "* script again using the --without-freetype flag."
			echo "*"
			echo "* Note that the bundled bitmap font only includes"
			echo "* the basic US-ASCII characters and is not meant"
			echo "* to be used except for porting to new platforms."
			echo "*"
			exit 1
		fi
	else
echo "#undef HAVE_FREETYPE" >config/have_freetype.h
echo "hdefs[\"HAVE_FREETYPE\"] = nil" >>configure.lua
FREETYPE_CFLAGS=""""
echo "FREETYPE_CFLAGS=$FREETYPE_CFLAGS" >>Makefile.config
echo "mdefs[\"FREETYPE_CFLAGS\"] = \"$FREETYPE_CFLAGS\"" >>configure.lua
FREETYPE_LIBS=""""
echo "FREETYPE_LIBS=$FREETYPE_LIBS" >>Makefile.config
echo "mdefs[\"FREETYPE_LIBS\"] = \"$FREETYPE_LIBS\"" >>configure.lua
	fi
	if [ "${with_gl}" != "no" ]
 then
$ECHO_N "checking for OpenGL (http://www.opengl.org)..."
$ECHO_N "checking for OpenGL (http://www.opengl.org)..." >> config.log
GL_CFLAGS=""
GL_LIBS=""
if [ -d "/usr/include/X11/GL" ]; then
GL_CFLAGS="-I/usr/include/X11"
fi;
if [ -d "/usr/include/X11R6/GL" ]; then
GL_CFLAGS="-I/usr/include/X11R6"
fi;
if [ -d "/usr/local/X11/include/GL" ]; then
GL_CFLAGS="-I/usr/local/X11/include"
fi;
if [ -d "/usr/local/X11R6/include/GL" ]; then
GL_CFLAGS="-I/usr/local/X11R6/include"
fi;
if [ -d "/usr/local/include/X11/GL" ]; then
GL_CFLAGS="-I/usr/local/include/X11"
fi;
if [ -d "/usr/local/include/X11R6/GL" ]; then
GL_CFLAGS="-I/usr/local/include/X11R6"
fi;
if [ -d "/usr/X11/include/GL" ]; then
GL_CFLAGS="-I/usr/X11/include"
fi;
if [ -d "/usr/X11R6/include/GL" ]; then
GL_CFLAGS="-I/usr/X11R6/include"
fi;
if [ -d "/usr/local/X11/lib" ]; then
GL_LIBS="-L/usr/local/X11/lib"
fi;
if [ -d "/usr/local/X11R6/lib" ]; then
GL_LIBS="-L/usr/local/X11R6/lib"
fi;
if [ -d "/usr/X11/lib" ]; then
GL_LIBS="-L/usr/X11/lib"
fi;
if [ -d "/usr/X11R6/lib" ]; then
GL_LIBS="-L/usr/X11R6/lib"
fi;
if [ "$SYSTEM" = "Darwin" ]; then
OPENGL_CFLAGS=""
OPENGL_LIBS="-framework OpenGL"
elif [ "$HAVE_MINGW" = "yes" ]; then
OPENGL_CFLAGS=""
OPENGL_LIBS="-lopengl32"
else
OPENGL_CFLAGS="${GL_CFLAGS}"
OPENGL_LIBS="${GL_LIBS} -lGL"
fi;
cat << EOT > conftest.c
#ifdef __APPLE__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
int main(int argc, char *argv[]) {
	glFlush();
	glLoadIdentity();
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${OPENGL_CFLAGS} -o $testdir/conftest conftest.c ${OPENGL_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${OPENGL_CFLAGS} -o $testdir/conftest conftest.c ${OPENGL_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_OPENGL="yes"
echo "HAVE_OPENGL=$HAVE_OPENGL" >>Makefile.config
echo "mdefs[\"HAVE_OPENGL\"] = \"$HAVE_OPENGL\"" >>configure.lua
echo "#ifndef HAVE_OPENGL" > config/have_opengl.h
echo "#define HAVE_OPENGL \"$HAVE_OPENGL\"" >> config/have_opengl.h
echo "#endif" >> config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = \"$HAVE_OPENGL\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_OPENGL="no"
echo "HAVE_OPENGL=$HAVE_OPENGL" >>Makefile.config
echo "mdefs[\"HAVE_OPENGL\"] = \"$HAVE_OPENGL\"" >>configure.lua
echo "#undef HAVE_OPENGL" >config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_OPENGL}" = "yes" ]; then
echo "OPENGL_CFLAGS=$OPENGL_CFLAGS" >>Makefile.config
echo "mdefs[\"OPENGL_CFLAGS\"] = \"$OPENGL_CFLAGS\"" >>configure.lua
echo "OPENGL_LIBS=$OPENGL_LIBS" >>Makefile.config
echo "mdefs[\"OPENGL_LIBS\"] = \"$OPENGL_LIBS\"" >>configure.lua
echo "#ifndef OPENGL_CFLAGS" > config/opengl_cflags.h
echo "#define OPENGL_CFLAGS \"$OPENGL_CFLAGS\"" >> config/opengl_cflags.h
echo "#endif" >> config/opengl_cflags.h
echo "hdefs[\"OPENGL_CFLAGS\"] = \"$OPENGL_CFLAGS\"" >>configure.lua
echo "#ifndef OPENGL_LIBS" > config/opengl_libs.h
echo "#define OPENGL_LIBS \"$OPENGL_LIBS\"" >> config/opengl_libs.h
echo "#endif" >> config/opengl_libs.h
echo "hdefs[\"OPENGL_LIBS\"] = \"$OPENGL_LIBS\"" >>configure.lua
else
$ECHO_N "checking whether -lGL requires -lm..."
$ECHO_N "checking whether -lGL requires -lm..." >> config.log
OPENGL_LIBS="${OPENGL_LIBS} -lm"
cat << EOT > conftest.c
#ifdef __APPLE__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
int main(int argc, char *argv[]) {
	glFlush();
	glLoadIdentity();
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${OPENGL_CFLAGS} -o $testdir/conftest conftest.c ${OPENGL_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${OPENGL_CFLAGS} -o $testdir/conftest conftest.c ${OPENGL_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_OPENGL="yes"
echo "HAVE_OPENGL=$HAVE_OPENGL" >>Makefile.config
echo "mdefs[\"HAVE_OPENGL\"] = \"$HAVE_OPENGL\"" >>configure.lua
echo "#ifndef HAVE_OPENGL" > config/have_opengl.h
echo "#define HAVE_OPENGL \"$HAVE_OPENGL\"" >> config/have_opengl.h
echo "#endif" >> config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = \"$HAVE_OPENGL\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_OPENGL="no"
echo "HAVE_OPENGL=$HAVE_OPENGL" >>Makefile.config
echo "mdefs[\"HAVE_OPENGL\"] = \"$HAVE_OPENGL\"" >>configure.lua
echo "#undef HAVE_OPENGL" >config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_OPENGL}" = "yes" ]; then
echo "OPENGL_CFLAGS=$OPENGL_CFLAGS" >>Makefile.config
echo "mdefs[\"OPENGL_CFLAGS\"] = \"$OPENGL_CFLAGS\"" >>configure.lua
echo "OPENGL_LIBS=$OPENGL_LIBS" >>Makefile.config
echo "mdefs[\"OPENGL_LIBS\"] = \"$OPENGL_LIBS\"" >>configure.lua
echo "#ifndef OPENGL_CFLAGS" > config/opengl_cflags.h
echo "#define OPENGL_CFLAGS \"$OPENGL_CFLAGS\"" >> config/opengl_cflags.h
echo "#endif" >> config/opengl_cflags.h
echo "hdefs[\"OPENGL_CFLAGS\"] = \"$OPENGL_CFLAGS\"" >>configure.lua
echo "#ifndef OPENGL_LIBS" > config/opengl_libs.h
echo "#define OPENGL_LIBS \"$OPENGL_LIBS\"" >> config/opengl_libs.h
echo "#endif" >> config/opengl_libs.h
echo "hdefs[\"OPENGL_LIBS\"] = \"$OPENGL_LIBS\"" >>configure.lua
else
echo "#undef OPENGL_CFLAGS" >config/opengl_cflags.h
echo "hdefs[\"OPENGL_CFLAGS\"] = nil" >>configure.lua
echo "#undef OPENGL_LIBS" >config/opengl_libs.h
echo "hdefs[\"OPENGL_LIBS\"] = nil" >>configure.lua
fi;
fi;
		if [ "${HAVE_OPENGL}" = "yes" ]
 then
SDL_CFLAGS="$SDL_CFLAGS $OPENGL_CFLAGS"
echo "SDL_CFLAGS=$SDL_CFLAGS" >>Makefile.config
echo "mdefs[\"SDL_CFLAGS\"] = \"$SDL_CFLAGS\"" >>configure.lua
		else
			if [ "${with_gl}" = "yes" ]
 then
				echo "*"
				echo "* --with-gl was requested, but no OpenGL"
				echo "* library was found. Try running the"
				echo "* configure script again without this"
				echo "* option."
				echo "*"
				exit 1
			else
echo "#undef HAVE_OPENGL" >config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = nil" >>configure.lua
			fi
		fi
	else
echo "#undef HAVE_OPENGL" >config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = nil" >>configure.lua
OPENGL_CFLAGS=""""
echo "OPENGL_CFLAGS=$OPENGL_CFLAGS" >>Makefile.config
echo "mdefs[\"OPENGL_CFLAGS\"] = \"$OPENGL_CFLAGS\"" >>configure.lua
OPENGL_LIBS=""""
echo "OPENGL_LIBS=$OPENGL_LIBS" >>Makefile.config
echo "mdefs[\"OPENGL_LIBS\"] = \"$OPENGL_LIBS\"" >>configure.lua
	fi
	if [ "${with_jpeg}" != "no" ]
 then
$ECHO_N "checking for libjpeg (ftp://ftp.uu.net/graphics/jpeg/)..."
$ECHO_N "checking for libjpeg (ftp://ftp.uu.net/graphics/jpeg/)..." >> config.log
JPEG_CFLAGS=""
if [ -f "/usr/local/include/jpeglib.h" ]; then
JPEG_CFLAGS="-I/usr/local/include"
JPEG_LIBS="-L/usr/local/lib -ljpeg"
fi;
if [ -f "/usr/X11R6/include/jpeglib.h" ]; then
JPEG_CFLAGS="-I/usr/X11R6/include"
JPEG_LIBS="-L/usr/X11R6/lib -ljpeg"
fi;
if [ -f "/usr/include/jpeglib.h" ]; then
JPEG_CFLAGS="-I/usr/include"
JPEG_LIBS="-L/usr/lib -ljpeg"
fi;
if [ -f "/opt/local/include/jpeglib.h" ]; then
JPEG_CFLAGS="-I/opt/local/include"
JPEG_LIBS="-L/opt/local/lib -ljpeg"
fi;
if [ -f "/opt/include/jpeglib.h" ]; then
JPEG_CFLAGS="-I/opt/include"
JPEG_LIBS="-L/opt/lib -ljpeg"
fi;
if [ "${JPEG_CFLAGS}" != "" ]; then
echo "ok"
echo "ok" >> config.log
$ECHO_N "checking whether libjpeg works..."
$ECHO_N "checking whether libjpeg works..." >> config.log
cat << EOT > conftest.c
#include <stdio.h>
#include <jpeglib.h>

struct jpeg_error_mgr		jerr;
struct jpeg_compress_struct	jcomp;

int
main(int argc, char *argv[])
{
	jcomp.err = jpeg_std_error(&jerr);

	jpeg_create_compress(&jcomp);
	jcomp.image_width = 32;
	jcomp.image_height = 32;
	jcomp.input_components = 3;
	jcomp.in_color_space = JCS_RGB;

	jpeg_set_defaults(&jcomp);
	jpeg_set_quality(&jcomp, 75, TRUE);

	jpeg_destroy_compress(&jcomp);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${JPEG_CFLAGS} -o $testdir/conftest conftest.c ${JPEG_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${JPEG_CFLAGS} -o $testdir/conftest conftest.c ${JPEG_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_JPEG="yes"
echo "HAVE_JPEG=$HAVE_JPEG" >>Makefile.config
echo "mdefs[\"HAVE_JPEG\"] = \"$HAVE_JPEG\"" >>configure.lua
echo "#ifndef HAVE_JPEG" > config/have_jpeg.h
echo "#define HAVE_JPEG \"$HAVE_JPEG\"" >> config/have_jpeg.h
echo "#endif" >> config/have_jpeg.h
echo "hdefs[\"HAVE_JPEG\"] = \"$HAVE_JPEG\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_JPEG="no"
echo "HAVE_JPEG=$HAVE_JPEG" >>Makefile.config
echo "mdefs[\"HAVE_JPEG\"] = \"$HAVE_JPEG\"" >>configure.lua
echo "#undef HAVE_JPEG" >config/have_jpeg.h
echo "hdefs[\"HAVE_JPEG\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_JPEG}" != "" ]; then
echo "JPEG_CFLAGS=$JPEG_CFLAGS" >>Makefile.config
echo "mdefs[\"JPEG_CFLAGS\"] = \"$JPEG_CFLAGS\"" >>configure.lua
echo "JPEG_LIBS=$JPEG_LIBS" >>Makefile.config
echo "mdefs[\"JPEG_LIBS\"] = \"$JPEG_LIBS\"" >>configure.lua
echo "#ifndef JPEG_CFLAGS" > config/jpeg_cflags.h
echo "#define JPEG_CFLAGS \"$JPEG_CFLAGS\"" >> config/jpeg_cflags.h
echo "#endif" >> config/jpeg_cflags.h
echo "hdefs[\"JPEG_CFLAGS\"] = \"$JPEG_CFLAGS\"" >>configure.lua
echo "#ifndef JPEG_LIBS" > config/jpeg_libs.h
echo "#define JPEG_LIBS \"$JPEG_LIBS\"" >> config/jpeg_libs.h
echo "#endif" >> config/jpeg_libs.h
echo "hdefs[\"JPEG_LIBS\"] = \"$JPEG_LIBS\"" >>configure.lua
else
echo "#undef JPEG_CFLAGS" >config/jpeg_cflags.h
echo "hdefs[\"JPEG_CFLAGS\"] = nil" >>configure.lua
echo "#undef JPEG_LIBS" >config/jpeg_libs.h
echo "hdefs[\"JPEG_LIBS\"] = nil" >>configure.lua
fi;
else
echo "#undef HAVE_JPEG" >config/have_jpeg.h
echo "hdefs[\"HAVE_JPEG\"] = nil" >>configure.lua
echo "no"
echo "no" >> config.log
fi;
		if [ "${HAVE_JPEG}" != "yes" ]
 then
			if [ "${with_jpeg}" = "yes" ]
 then
				echo "*"
				echo "* --with-jpeg was requested, but libjpeg"
				echo "* was not found. Try running configure"
				echo "* again without this option."
				echo "*"
				exit 1
			else
echo "#undef HAVE_JPEG" >config/have_jpeg.h
echo "hdefs[\"HAVE_JPEG\"] = nil" >>configure.lua
			fi
		fi
	else
echo "#undef HAVE_JPEG" >config/have_jpeg.h
echo "hdefs[\"HAVE_JPEG\"] = nil" >>configure.lua
JPEG_CFLAGS=""""
echo "JPEG_CFLAGS=$JPEG_CFLAGS" >>Makefile.config
echo "mdefs[\"JPEG_CFLAGS\"] = \"$JPEG_CFLAGS\"" >>configure.lua
JPEG_LIBS=""""
echo "JPEG_LIBS=$JPEG_LIBS" >>Makefile.config
echo "mdefs[\"JPEG_LIBS\"] = \"$JPEG_LIBS\"" >>configure.lua
	fi
else
echo "#undef ENABLE_GUI" >config/enable_gui.h
echo "hdefs[\"ENABLE_GUI\"] = nil" >>configure.lua
echo "#undef HAVE_FREETYPE" >config/have_freetype.h
echo "hdefs[\"HAVE_FREETYPE\"] = nil" >>configure.lua
FREETYPE_CFLAGS=""""
echo "FREETYPE_CFLAGS=$FREETYPE_CFLAGS" >>Makefile.config
echo "mdefs[\"FREETYPE_CFLAGS\"] = \"$FREETYPE_CFLAGS\"" >>configure.lua
FREETYPE_LIBS=""""
echo "FREETYPE_LIBS=$FREETYPE_LIBS" >>Makefile.config
echo "mdefs[\"FREETYPE_LIBS\"] = \"$FREETYPE_LIBS\"" >>configure.lua
echo "#undef HAVE_OPENGL" >config/have_opengl.h
echo "hdefs[\"HAVE_OPENGL\"] = nil" >>configure.lua
OPENGL_CFLAGS=""""
echo "OPENGL_CFLAGS=$OPENGL_CFLAGS" >>Makefile.config
echo "mdefs[\"OPENGL_CFLAGS\"] = \"$OPENGL_CFLAGS\"" >>configure.lua
OPENGL_LIBS=""""
echo "OPENGL_LIBS=$OPENGL_LIBS" >>Makefile.config
echo "mdefs[\"OPENGL_LIBS\"] = \"$OPENGL_LIBS\"" >>configure.lua
echo "#undef HAVE_JPEG" >config/have_jpeg.h
echo "hdefs[\"HAVE_JPEG\"] = nil" >>configure.lua
JPEG_CFLAGS=""""
echo "JPEG_CFLAGS=$JPEG_CFLAGS" >>Makefile.config
echo "mdefs[\"JPEG_CFLAGS\"] = \"$JPEG_CFLAGS\"" >>configure.lua
JPEG_LIBS=""""
echo "JPEG_LIBS=$JPEG_LIBS" >>Makefile.config
echo "mdefs[\"JPEG_LIBS\"] = \"$JPEG_LIBS\"" >>configure.lua
fi
if [ "${enable_network}" = "yes" ]
 then
$ECHO_N "checking for the getaddrinfo() function..."
$ECHO_N "checking for the getaddrinfo() function..." >> config.log
cat << EOT > conftest.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int
main(int argc, char *argv[])
{
	struct addrinfo hints, *res0;
	const char *s;
	int rv;

	hints.ai_family = PF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;
	rv = getaddrinfo("hostname", "port", &hints, &res0);
	s = gai_strerror(rv);
	freeaddrinfo(res0);
	return (0);
}

EOT
compile="ok"
echo "$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c" >>config.log
$CC $CFLAGS $TEST_CFLAGS -o $testdir/conftest conftest.c 2>>config.log
if [ $? != 0 ]; then
	echo "-> failed ($?)" >> config.log
	compile="failed"
fi
rm -f $testdir/conftest conftest.c
if [ "${compile}" = "ok" ]; then
echo "yes"
echo "yes" >> config.log
HAVE_GETADDRINFO="yes"
echo "#ifndef HAVE_GETADDRINFO" > config/have_getaddrinfo.h
echo "#define HAVE_GETADDRINFO \"$HAVE_GETADDRINFO\"" >> config/have_getaddrinfo.h
echo "#endif" >> config/have_getaddrinfo.h
echo "hdefs[\"HAVE_GETADDRINFO\"] = \"$HAVE_GETADDRINFO\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
HAVE_GETADDRINFO="no"
echo "#undef HAVE_GETADDRINFO" >config/have_getaddrinfo.h
echo "hdefs[\"HAVE_GETADDRINFO\"] = nil" >>configure.lua
fi;
	if [ "${HAVE_GETADDRINFO}" = "yes" ]
 then
NETWORK="1"
echo "#ifndef NETWORK" > config/network.h
echo "#define NETWORK \"$NETWORK\"" >> config/network.h
echo "#endif" >> config/network.h
echo "hdefs[\"NETWORK\"] = \"$NETWORK\"" >>configure.lua
	else
		if [ "${enable_network}" = "yes" ]
 then
			echo "*"
			echo "* --enable-network was requested, but this system"
			echo "* does not support getaddrinfo(). Try running the"
			echo "* configure script again without this option."
			echo "*"
			exit 1
		else
echo "#undef NETWORK" >config/network.h
echo "hdefs[\"NETWORK\"] = nil" >>configure.lua
		fi
	fi
else
echo "#undef NETWORK" >config/network.h
echo "hdefs[\"NETWORK\"] = nil" >>configure.lua
echo "#undef HAVE_GETADDRINFO" >config/have_getaddrinfo.h
echo "hdefs[\"HAVE_GETADDRINFO\"] = nil" >>configure.lua
fi
if [ "${enable_server}" = "yes" ]
 then
	if [ "${HAVE_GETADDRINFO}" = "yes" ]
 then
SERVER="1"
echo "#ifndef SERVER" > config/server.h
echo "#define SERVER \"$SERVER\"" >> config/server.h
echo "#endif" >> config/server.h
echo "hdefs[\"SERVER\"] = \"$SERVER\"" >>configure.lua
	else
		if [ "${enable_server}" = "yes" ]
 then
			echo "*"
			echo "* --enable-server was requested, but this system"
			echo "* does not support getaddrinfo(). Try running the"
			echo "* configure script again without this option."
			echo "*"
			exit 1
		else
echo "#undef SERVER" >config/server.h
echo "hdefs[\"SERVER\"] = nil" >>configure.lua
		fi
	fi
else
echo "#undef SERVER" >config/server.h
echo "hdefs[\"SERVER\"] = nil" >>configure.lua
echo "#undef HAVE_GETADDRINFO" >config/have_getaddrinfo.h
echo "hdefs[\"HAVE_GETADDRINFO\"] = nil" >>configure.lua
fi
if [ "${enable_threads}" != "no" ]
 then
$ECHO_N "checking for POSIX threads..."
$ECHO_N "checking for POSIX threads..." >> config.log
PTHREADS_CFLAGS=""
PTHREADS_LIBS="-lpthread"
cat << EOT > conftest.c
#include <pthread.h>
#include <signal.h>
static void *start_routine(void *arg) { return (NULL); }
int main(int argc, char *argv[])
{
	pthread_mutex_t mutex;
	pthread_t thread;
	pthread_mutex_init(&mutex, NULL);
	pthread_mutex_lock(&mutex);
	pthread_mutex_unlock(&mutex);
	pthread_mutex_destroy(&mutex);
	pthread_create(&thread, NULL, start_routine, NULL);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c ${PTHREADS_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c ${PTHREADS_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_PTHREADS="yes"
echo "HAVE_PTHREADS=$HAVE_PTHREADS" >>Makefile.config
echo "mdefs[\"HAVE_PTHREADS\"] = \"$HAVE_PTHREADS\"" >>configure.lua
echo "#ifndef HAVE_PTHREADS" > config/have_pthreads.h
echo "#define HAVE_PTHREADS \"$HAVE_PTHREADS\"" >> config/have_pthreads.h
echo "#endif" >> config/have_pthreads.h
echo "hdefs[\"HAVE_PTHREADS\"] = \"$HAVE_PTHREADS\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_PTHREADS="no"
echo "HAVE_PTHREADS=$HAVE_PTHREADS" >>Makefile.config
echo "mdefs[\"HAVE_PTHREADS\"] = \"$HAVE_PTHREADS\"" >>configure.lua
echo "#undef HAVE_PTHREADS" >config/have_pthreads.h
echo "hdefs[\"HAVE_PTHREADS\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_PTHREADS}" = "yes" ]; then
CFLAGS="${CFLAGS} ${PTHREADS_CFLAGS}"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "PTHREADS_CFLAGS=$PTHREADS_CFLAGS" >>Makefile.config
echo "mdefs[\"PTHREADS_CFLAGS\"] = \"$PTHREADS_CFLAGS\"" >>configure.lua
echo "PTHREADS_LIBS=$PTHREADS_LIBS" >>Makefile.config
echo "mdefs[\"PTHREADS_LIBS\"] = \"$PTHREADS_LIBS\"" >>configure.lua
echo "#ifndef PTHREADS_CFLAGS" > config/pthreads_cflags.h
echo "#define PTHREADS_CFLAGS \"$PTHREADS_CFLAGS\"" >> config/pthreads_cflags.h
echo "#endif" >> config/pthreads_cflags.h
echo "hdefs[\"PTHREADS_CFLAGS\"] = \"$PTHREADS_CFLAGS\"" >>configure.lua
echo "#ifndef PTHREADS_LIBS" > config/pthreads_libs.h
echo "#define PTHREADS_LIBS \"$PTHREADS_LIBS\"" >> config/pthreads_libs.h
echo "#endif" >> config/pthreads_libs.h
echo "hdefs[\"PTHREADS_LIBS\"] = \"$PTHREADS_LIBS\"" >>configure.lua
else
$ECHO_N "checking for -pthread..."
$ECHO_N "checking for -pthread..." >> config.log
PTHREADS_LIBS="-pthread"
cat << EOT > conftest.c
#include <pthread.h>
#include <signal.h>
static void *start_routine(void *arg) { return (NULL); }
int main(int argc, char *argv[])
{
	pthread_mutex_t mutex;
	pthread_t thread;
	pthread_mutex_init(&mutex, NULL);
	pthread_mutex_lock(&mutex);
	pthread_mutex_unlock(&mutex);
	pthread_mutex_destroy(&mutex);
	pthread_create(&thread, NULL, start_routine, NULL);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c ${PTHREADS_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS  -o $testdir/conftest conftest.c ${PTHREADS_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_PTHREADS="yes"
echo "HAVE_PTHREADS=$HAVE_PTHREADS" >>Makefile.config
echo "mdefs[\"HAVE_PTHREADS\"] = \"$HAVE_PTHREADS\"" >>configure.lua
echo "#ifndef HAVE_PTHREADS" > config/have_pthreads.h
echo "#define HAVE_PTHREADS \"$HAVE_PTHREADS\"" >> config/have_pthreads.h
echo "#endif" >> config/have_pthreads.h
echo "hdefs[\"HAVE_PTHREADS\"] = \"$HAVE_PTHREADS\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_PTHREADS="no"
echo "HAVE_PTHREADS=$HAVE_PTHREADS" >>Makefile.config
echo "mdefs[\"HAVE_PTHREADS\"] = \"$HAVE_PTHREADS\"" >>configure.lua
echo "#undef HAVE_PTHREADS" >config/have_pthreads.h
echo "hdefs[\"HAVE_PTHREADS\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_PTHREADS}" = "yes" ]; then
CFLAGS="${CFLAGS} ${PTHREADS_CFLAGS}"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "PTHREADS_CFLAGS=$PTHREADS_CFLAGS" >>Makefile.config
echo "mdefs[\"PTHREADS_CFLAGS\"] = \"$PTHREADS_CFLAGS\"" >>configure.lua
echo "PTHREADS_LIBS=$PTHREADS_LIBS" >>Makefile.config
echo "mdefs[\"PTHREADS_LIBS\"] = \"$PTHREADS_LIBS\"" >>configure.lua
echo "#ifndef PTHREADS_CFLAGS" > config/pthreads_cflags.h
echo "#define PTHREADS_CFLAGS \"$PTHREADS_CFLAGS\"" >> config/pthreads_cflags.h
echo "#endif" >> config/pthreads_cflags.h
echo "hdefs[\"PTHREADS_CFLAGS\"] = \"$PTHREADS_CFLAGS\"" >>configure.lua
echo "#ifndef PTHREADS_LIBS" > config/pthreads_libs.h
echo "#define PTHREADS_LIBS \"$PTHREADS_LIBS\"" >> config/pthreads_libs.h
echo "#endif" >> config/pthreads_libs.h
echo "hdefs[\"PTHREADS_LIBS\"] = \"$PTHREADS_LIBS\"" >>configure.lua
fi;
fi;
$ECHO_N "checking for the X/Open Threads Extension..."
$ECHO_N "checking for the X/Open Threads Extension..." >> config.log
if [ "${SYSTEM}" = "FreeBSD" ]; then
PTHREADS_XOPEN_CFLAGS=""
else
PTHREADS_XOPEN_CFLAGS="-U_XOPEN_SOURCE -D_XOPEN_SOURCE=600"
fi;
PTHREADS_XOPEN_LIBS="-lpthread"
cat << EOT > conftest.c
#include <pthread.h>
#include <signal.h>

int main(int argc, char *argv[])
{
	pthread_mutex_t mutex;
	pthread_mutexattr_t mutexattr;
	pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex, &mutexattr);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${PTHREADS_XOPEN_CFLAGS} -o $testdir/conftest conftest.c ${PTHREADS_XOPEN_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${PTHREADS_XOPEN_CFLAGS} -o $testdir/conftest conftest.c ${PTHREADS_XOPEN_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_PTHREADS_XOPEN="yes"
echo "HAVE_PTHREADS_XOPEN=$HAVE_PTHREADS_XOPEN" >>Makefile.config
echo "mdefs[\"HAVE_PTHREADS_XOPEN\"] = \"$HAVE_PTHREADS_XOPEN\"" >>configure.lua
echo "#ifndef HAVE_PTHREADS_XOPEN" > config/have_pthreads_xopen.h
echo "#define HAVE_PTHREADS_XOPEN \"$HAVE_PTHREADS_XOPEN\"" >> config/have_pthreads_xopen.h
echo "#endif" >> config/have_pthreads_xopen.h
echo "hdefs[\"HAVE_PTHREADS_XOPEN\"] = \"$HAVE_PTHREADS_XOPEN\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_PTHREADS_XOPEN="no"
echo "HAVE_PTHREADS_XOPEN=$HAVE_PTHREADS_XOPEN" >>Makefile.config
echo "mdefs[\"HAVE_PTHREADS_XOPEN\"] = \"$HAVE_PTHREADS_XOPEN\"" >>configure.lua
echo "#undef HAVE_PTHREADS_XOPEN" >config/have_pthreads_xopen.h
echo "hdefs[\"HAVE_PTHREADS_XOPEN\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_PTHREADS_XOPEN}" = "yes" ]; then
echo "PTHREADS_XOPEN_CFLAGS=$PTHREADS_XOPEN_CFLAGS" >>Makefile.config
echo "mdefs[\"PTHREADS_XOPEN_CFLAGS\"] = \"$PTHREADS_XOPEN_CFLAGS\"" >>configure.lua
echo "PTHREADS_XOPEN_LIBS=$PTHREADS_XOPEN_LIBS" >>Makefile.config
echo "mdefs[\"PTHREADS_XOPEN_LIBS\"] = \"$PTHREADS_XOPEN_LIBS\"" >>configure.lua
echo "#ifndef HAVE_PTHREADS_XOPEN" > config/have_pthreads_xopen.h
echo "#define HAVE_PTHREADS_XOPEN \"$HAVE_PTHREADS_XOPEN\"" >> config/have_pthreads_xopen.h
echo "#endif" >> config/have_pthreads_xopen.h
echo "hdefs[\"HAVE_PTHREADS_XOPEN\"] = \"$HAVE_PTHREADS_XOPEN\"" >>configure.lua
echo "#ifndef PTHREADS_XOPEN_CFLAGS" > config/pthreads_xopen_cflags.h
echo "#define PTHREADS_XOPEN_CFLAGS \"$PTHREADS_XOPEN_CFLAGS\"" >> config/pthreads_xopen_cflags.h
echo "#endif" >> config/pthreads_xopen_cflags.h
echo "hdefs[\"PTHREADS_XOPEN_CFLAGS\"] = \"$PTHREADS_XOPEN_CFLAGS\"" >>configure.lua
echo "#ifndef PTHREADS_XOPEN_LIBS" > config/pthreads_xopen_libs.h
echo "#define PTHREADS_XOPEN_LIBS \"$PTHREADS_XOPEN_LIBS\"" >> config/pthreads_xopen_libs.h
echo "#endif" >> config/pthreads_xopen_libs.h
echo "hdefs[\"PTHREADS_XOPEN_LIBS\"] = \"$PTHREADS_XOPEN_LIBS\"" >>configure.lua
else
echo "#undef HAVE_PTHREADS_XOPEN" >config/have_pthreads_xopen.h
echo "hdefs[\"HAVE_PTHREADS_XOPEN\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for PTHREAD_MUTEX_RECURSIVE..."
$ECHO_N "checking for PTHREAD_MUTEX_RECURSIVE..." >> config.log
cat << EOT > conftest.c
#include <pthread.h>
#include <signal.h>
int main(int argc, char *argv[])
{
	pthread_mutex_t mutex;
	pthread_mutexattr_t mutexattr;
	pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex, &mutexattr);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${PTHREADS_CFLAGS} -o $testdir/conftest conftest.c ${PTHREADS_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${PTHREADS_CFLAGS} -o $testdir/conftest conftest.c ${PTHREADS_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_PTHREAD_MUTEX_RECURSIVE="yes"
echo "HAVE_PTHREAD_MUTEX_RECURSIVE=$HAVE_PTHREAD_MUTEX_RECURSIVE" >>Makefile.config
echo "mdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE\"" >>configure.lua
echo "#ifndef HAVE_PTHREAD_MUTEX_RECURSIVE" > config/have_pthread_mutex_recursive.h
echo "#define HAVE_PTHREAD_MUTEX_RECURSIVE \"$HAVE_PTHREAD_MUTEX_RECURSIVE\"" >> config/have_pthread_mutex_recursive.h
echo "#endif" >> config/have_pthread_mutex_recursive.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_PTHREAD_MUTEX_RECURSIVE="no"
echo "HAVE_PTHREAD_MUTEX_RECURSIVE=$HAVE_PTHREAD_MUTEX_RECURSIVE" >>Makefile.config
echo "mdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE\"" >>configure.lua
echo "#undef HAVE_PTHREAD_MUTEX_RECURSIVE" >config/have_pthread_mutex_recursive.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_PTHREAD_MUTEX_RECURSIVE}" = "yes" ]; then
echo "#ifndef HAVE_PTHREAD_MUTEX_RECURSIVE" > config/have_pthread_mutex_recursive.h
echo "#define HAVE_PTHREAD_MUTEX_RECURSIVE \"$HAVE_PTHREAD_MUTEX_RECURSIVE\"" >> config/have_pthread_mutex_recursive.h
echo "#endif" >> config/have_pthread_mutex_recursive.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE\"" >>configure.lua
else
echo "#undef HAVE_PTHREAD_MUTEX_RECURSIVE" >config/have_pthread_mutex_recursive.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE\"] = nil" >>configure.lua
fi;
$ECHO_N "checking for PTHREAD_MUTEX_RECURSIVE_NP..."
$ECHO_N "checking for PTHREAD_MUTEX_RECURSIVE_NP..." >> config.log
cat << EOT > conftest.c
#include <pthread.h>
#include <signal.h>
int main(int argc, char *argv[])
{
	pthread_mutex_t mutex;
	pthread_mutexattr_t mutexattr;
	pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);
	pthread_mutex_init(&mutex, &mutexattr);
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${PTHREADS_CFLAGS} -o $testdir/conftest conftest.c ${PTHREADS_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${PTHREADS_CFLAGS} -o $testdir/conftest conftest.c ${PTHREADS_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_PTHREAD_MUTEX_RECURSIVE_NP="yes"
echo "HAVE_PTHREAD_MUTEX_RECURSIVE_NP=$HAVE_PTHREAD_MUTEX_RECURSIVE_NP" >>Makefile.config
echo "mdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"" >>configure.lua
echo "#ifndef HAVE_PTHREAD_MUTEX_RECURSIVE_NP" > config/have_pthread_mutex_recursive_np.h
echo "#define HAVE_PTHREAD_MUTEX_RECURSIVE_NP \"$HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"" >> config/have_pthread_mutex_recursive_np.h
echo "#endif" >> config/have_pthread_mutex_recursive_np.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_PTHREAD_MUTEX_RECURSIVE_NP="no"
echo "HAVE_PTHREAD_MUTEX_RECURSIVE_NP=$HAVE_PTHREAD_MUTEX_RECURSIVE_NP" >>Makefile.config
echo "mdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"" >>configure.lua
echo "#undef HAVE_PTHREAD_MUTEX_RECURSIVE_NP" >config/have_pthread_mutex_recursive_np.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_PTHREAD_MUTEX_RECURSIVE_NP}" = "yes" ]; then
echo "#ifndef HAVE_PTHREAD_MUTEX_RECURSIVE_NP" > config/have_pthread_mutex_recursive_np.h
echo "#define HAVE_PTHREAD_MUTEX_RECURSIVE_NP \"$HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"" >> config/have_pthread_mutex_recursive_np.h
echo "#endif" >> config/have_pthread_mutex_recursive_np.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"] = \"$HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"" >>configure.lua
else
echo "#undef HAVE_PTHREAD_MUTEX_RECURSIVE_NP" >config/have_pthread_mutex_recursive_np.h
echo "hdefs[\"HAVE_PTHREAD_MUTEX_RECURSIVE_NP\"] = nil" >>configure.lua
fi;
	if [ "${HAVE_PTHREADS}" = "yes" ]
	then
		if [ "${HAVE_PTHREADS_XOPEN}" = "no" ]
 then
		if [ "${HAVE_PTHREAD_MUTEX_RECURSIVE}" = "no" ]
 then
		if [ "${HAVE_PTHREAD_MUTEX_RECURSIVE_NP}" = "no" ]
 then
			if [ "${enable_threads}" = "yes" ]
 then
				echo "*"
				echo "* --enable-threads was given, but your"
				echo "* pthreads library lacks support for"
				echo "* recursive mutexes. Try running the"
				echo "* configure script again without this"
				echo "* option."
				echo "*"
				exit 1
			fi
		fi
		fi
		fi
THREADS="1"
echo "#ifndef THREADS" > config/threads.h
echo "#define THREADS \"$THREADS\"" >> config/threads.h
echo "#endif" >> config/threads.h
echo "hdefs[\"THREADS\"] = \"$THREADS\"" >>configure.lua
	else
		if [ "${enable_threads}" = "yes" ]
 then
			echo "*"
			echo "* --enable-threads was given, but no pthreads"
			echo "* library was found on your system. Try running"
			echo "* the configure script again without this option."
			echo "*"
			exit 1
		fi
	fi
else
echo "#undef THREADS" >config/threads.h
echo "hdefs[\"THREADS\"] = nil" >>configure.lua
echo "#undef HAVE_PTHREADS" >config/have_pthreads.h
echo "hdefs[\"HAVE_PTHREADS\"] = nil" >>configure.lua
echo "#undef HAVE_PTHREADS_XOPEN" >config/have_pthreads_xopen.h
echo "hdefs[\"HAVE_PTHREADS_XOPEN\"] = nil" >>configure.lua
PTHREADS_CFLAGS=""""
echo "PTHREADS_CFLAGS=$PTHREADS_CFLAGS" >>Makefile.config
echo "mdefs[\"PTHREADS_CFLAGS\"] = \"$PTHREADS_CFLAGS\"" >>configure.lua
PTHREADS_LIBS=""""
echo "PTHREADS_LIBS=$PTHREADS_LIBS" >>Makefile.config
echo "mdefs[\"PTHREADS_LIBS\"] = \"$PTHREADS_LIBS\"" >>configure.lua
PTHREADS_XOPEN_CFLAGS=""""
echo "PTHREADS_XOPEN_CFLAGS=$PTHREADS_XOPEN_CFLAGS" >>Makefile.config
echo "mdefs[\"PTHREADS_XOPEN_CFLAGS\"] = \"$PTHREADS_XOPEN_CFLAGS\"" >>configure.lua
PTHREADS_XOPEN_LIBS=""""
echo "PTHREADS_XOPEN_LIBS=$PTHREADS_XOPEN_LIBS" >>Makefile.config
echo "mdefs[\"PTHREADS_XOPEN_LIBS\"] = \"$PTHREADS_XOPEN_LIBS\"" >>configure.lua
	if [ "${enable_warnings}" = "yes" ]
 then
CFLAGS="$CFLAGS -Wno-unused"
CXXFLAGS="$CXXFLAGS -Wno-unused"
echo "CFLAGS=$CFLAGS" >>Makefile.config
echo "mdefs[\"CFLAGS\"] = \"$CFLAGS\"" >>configure.lua
echo "CXXFLAGS=$CXXFLAGS" >>Makefile.config
echo "mdefs[\"CXXFLAGS\"] = \"$CXXFLAGS\"" >>configure.lua
	fi
fi
if [ "${enable_utf8}" != "no" ]
 then
UTF8="1"
echo "#ifndef UTF8" > config/utf8.h
echo "#define UTF8 \"$UTF8\"" >> config/utf8.h
echo "#endif" >> config/utf8.h
echo "hdefs[\"UTF8\"] = \"$UTF8\"" >>configure.lua
else
echo "#undef UTF8" >config/utf8.h
echo "hdefs[\"UTF8\"] = nil" >>configure.lua
fi
echo "#undef ASTRONOMICAL_UNITS" >config/astronomical_units.h
echo "hdefs[\"ASTRONOMICAL_UNITS\"] = nil" >>configure.lua
HISTORICAL_UNITS="1"
echo "#ifndef HISTORICAL_UNITS" > config/historical_units.h
echo "#define HISTORICAL_UNITS \"$HISTORICAL_UNITS\"" >> config/historical_units.h
echo "#endif" >> config/historical_units.h
echo "hdefs[\"HISTORICAL_UNITS\"] = \"$HISTORICAL_UNITS\"" >>configure.lua
if [ "${enable_8bpp}" != "no" ]
 then
VIEW_8BPP="1"
echo "#ifndef VIEW_8BPP" > config/view_8bpp.h
echo "#define VIEW_8BPP \"$VIEW_8BPP\"" >> config/view_8bpp.h
echo "#endif" >> config/view_8bpp.h
echo "hdefs[\"VIEW_8BPP\"] = \"$VIEW_8BPP\"" >>configure.lua
else
echo "#undef VIEW_8BPP" >config/view_8bpp.h
echo "hdefs[\"VIEW_8BPP\"] = nil" >>configure.lua
fi
if [ "${enable_16bpp}" != "no" ]
 then
VIEW_16BPP="1"
echo "#ifndef VIEW_16BPP" > config/view_16bpp.h
echo "#define VIEW_16BPP \"$VIEW_16BPP\"" >> config/view_16bpp.h
echo "#endif" >> config/view_16bpp.h
echo "hdefs[\"VIEW_16BPP\"] = \"$VIEW_16BPP\"" >>configure.lua
else
echo "#undef VIEW_16BPP" >config/view_16bpp.h
echo "hdefs[\"VIEW_16BPP\"] = nil" >>configure.lua
fi
if [ "${enable_24bpp}" != "no" ]
 then
VIEW_24BPP="1"
echo "#ifndef VIEW_24BPP" > config/view_24bpp.h
echo "#define VIEW_24BPP \"$VIEW_24BPP\"" >> config/view_24bpp.h
echo "#endif" >> config/view_24bpp.h
echo "hdefs[\"VIEW_24BPP\"] = \"$VIEW_24BPP\"" >>configure.lua
else
echo "#undef VIEW_24BPP" >config/view_24bpp.h
echo "hdefs[\"VIEW_24BPP\"] = nil" >>configure.lua
fi
if [ "${enable_32bpp}" != "no" ]
 then
VIEW_32BPP="1"
echo "#ifndef VIEW_32BPP" > config/view_32bpp.h
echo "#define VIEW_32BPP \"$VIEW_32BPP\"" >> config/view_32bpp.h
echo "#endif" >> config/view_32bpp.h
echo "hdefs[\"VIEW_32BPP\"] = \"$VIEW_32BPP\"" >>configure.lua
else
echo "#undef VIEW_32BPP" >config/view_32bpp.h
echo "hdefs[\"VIEW_32BPP\"] = nil" >>configure.lua
fi
if [ "${enable_nls}" = "yes" ]
 then
$ECHO_N "checking for a gettext library..."
$ECHO_N "checking for a gettext library..." >> config.log
GETTEXT_CFLAGS=""
GETTEXT_LIBS=""
cat << EOT > conftest.c
#include <libintl.h>
int main(int argc, char *argv[])
{
	char *s;
	bindtextdomain("foo", "/foo");
	textdomain("foo");
	s = gettext("string");
	s = dgettext("foo","string");
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${GETTEXT_CFLAGS} -o $testdir/conftest conftest.c ${GETTEXT_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${GETTEXT_CFLAGS} -o $testdir/conftest conftest.c ${GETTEXT_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_GETTEXT="yes"
echo "HAVE_GETTEXT=$HAVE_GETTEXT" >>Makefile.config
echo "mdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
echo "#ifndef HAVE_GETTEXT" > config/have_gettext.h
echo "#define HAVE_GETTEXT \"$HAVE_GETTEXT\"" >> config/have_gettext.h
echo "#endif" >> config/have_gettext.h
echo "hdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_GETTEXT="no"
echo "HAVE_GETTEXT=$HAVE_GETTEXT" >>Makefile.config
echo "mdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
echo "#undef HAVE_GETTEXT" >config/have_gettext.h
echo "hdefs[\"HAVE_GETTEXT\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_GETTEXT}" = "no" ]; then
$ECHO_N "checking whether gettext requires -lintl..."
$ECHO_N "checking whether gettext requires -lintl..." >> config.log
if [ -e /usr/include/libintl.h ]; then
GETTEXT_CFLAGS="-I/usr/include"
GETTEXT_LIBS="-L/usr/lib -lintl"
fi;
if [ -e /usr/local/include/libintl.h ]; then
GETTEXT_CFLAGS="-I/usr/local/include"
GETTEXT_LIBS="-L/usr/local/lib -lintl"
fi;
if [ -e /opt/include/libintl.h ]; then
GETTEXT_CFLAGS="-I/opt/include"
GETTEXT_LIBS="-L/opt/lib -lintl"
fi;
if [ -e /opt/local/include/libintl.h ]; then
GETTEXT_CFLAGS="-I/opt/local/include"
GETTEXT_LIBS="-L/opt/local/lib -lintl"
fi;
cat << EOT > conftest.c
#include <libintl.h>
int main(int argc, char *argv[])
{
	char *s;
	bindtextdomain("foo", "/foo");
	textdomain("foo");
	s = gettext("string");
	s = dgettext("foo","string");
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${GETTEXT_CFLAGS} -o $testdir/conftest conftest.c ${GETTEXT_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${GETTEXT_CFLAGS} -o $testdir/conftest conftest.c ${GETTEXT_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_GETTEXT="yes"
echo "HAVE_GETTEXT=$HAVE_GETTEXT" >>Makefile.config
echo "mdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
echo "#ifndef HAVE_GETTEXT" > config/have_gettext.h
echo "#define HAVE_GETTEXT \"$HAVE_GETTEXT\"" >> config/have_gettext.h
echo "#endif" >> config/have_gettext.h
echo "hdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_GETTEXT="no"
echo "HAVE_GETTEXT=$HAVE_GETTEXT" >>Makefile.config
echo "mdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
echo "#undef HAVE_GETTEXT" >config/have_gettext.h
echo "hdefs[\"HAVE_GETTEXT\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_GETTEXT}" = "yes" ]; then
echo "#ifndef GETTEXT_CFLAGS" > config/gettext_cflags.h
echo "#define GETTEXT_CFLAGS \"$GETTEXT_CFLAGS\"" >> config/gettext_cflags.h
echo "#endif" >> config/gettext_cflags.h
echo "hdefs[\"GETTEXT_CFLAGS\"] = \"$GETTEXT_CFLAGS\"" >>configure.lua
echo "#ifndef GETTEXT_LIBS" > config/gettext_libs.h
echo "#define GETTEXT_LIBS \"$GETTEXT_LIBS\"" >> config/gettext_libs.h
echo "#endif" >> config/gettext_libs.h
echo "hdefs[\"GETTEXT_LIBS\"] = \"$GETTEXT_LIBS\"" >>configure.lua
echo "GETTEXT_CFLAGS=$GETTEXT_CFLAGS" >>Makefile.config
echo "mdefs[\"GETTEXT_CFLAGS\"] = \"$GETTEXT_CFLAGS\"" >>configure.lua
echo "GETTEXT_LIBS=$GETTEXT_LIBS" >>Makefile.config
echo "mdefs[\"GETTEXT_LIBS\"] = \"$GETTEXT_LIBS\"" >>configure.lua
else
$ECHO_N "checking whether -lintl requires -liconv..."
$ECHO_N "checking whether -lintl requires -liconv..." >> config.log
if [ -e /usr/include/iconv.h ]; then
GETTEXT_CFLAGS="${GETTEXT_CFLAGS} -I/usr/include"
GETTEXT_LIBS="${GETTEXT_LIBS} -L/usr/lib -liconv"
fi;
if [ -e /usr/local/include/iconv.h ]; then
GETTEXT_CFLAGS="${GETTEXT_CFLAGS} -I/usr/local/include"
GETTEXT_LIBS="${GETTEXT_LIBS} -L/usr/local/lib -liconv"
fi;
if [ -e /opt/include/iconv.h ]; then
GETTEXT_CFLAGS="${GETTEXT_CFLAGS} -I/opt/include"
GETTEXT_LIBS="${GETTEXT_LIBS} -L/opt/lib -liconv"
fi;
if [ -e /opt/local/include/iconv.h ]; then
GETTEXT_CFLAGS="${GETTEXT_CFLAGS} -I/opt/local/include"
GETTEXT_LIBS="${GETTEXT_LIBS} -L/opt/local/lib -liconv"
fi;
cat << EOT > conftest.c
#include <libintl.h>
int main(int argc, char *argv[])
{
	char *s;
	bindtextdomain("foo", "/foo");
	textdomain("foo");
	s = gettext("string");
	s = dgettext("foo","string");
	return (0);
}

EOT
echo "$CC $CFLAGS $TEST_CFLAGS ${GETTEXT_CFLAGS} -o $testdir/conftest conftest.c ${GETTEXT_LIBS}" >>config.log
$CC $CFLAGS $TEST_CFLAGS ${GETTEXT_CFLAGS} -o $testdir/conftest conftest.c ${GETTEXT_LIBS} 2>>config.log
if [ "$?" = "0" ]; then
echo "yes"
echo "yes" >> config.log
compile="ok"
HAVE_GETTEXT="yes"
echo "HAVE_GETTEXT=$HAVE_GETTEXT" >>Makefile.config
echo "mdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
echo "#ifndef HAVE_GETTEXT" > config/have_gettext.h
echo "#define HAVE_GETTEXT \"$HAVE_GETTEXT\"" >> config/have_gettext.h
echo "#endif" >> config/have_gettext.h
echo "hdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
else
echo "no"
echo "no" >> config.log
compile="failed"
HAVE_GETTEXT="no"
echo "HAVE_GETTEXT=$HAVE_GETTEXT" >>Makefile.config
echo "mdefs[\"HAVE_GETTEXT\"] = \"$HAVE_GETTEXT\"" >>configure.lua
echo "#undef HAVE_GETTEXT" >config/have_gettext.h
echo "hdefs[\"HAVE_GETTEXT\"] = nil" >>configure.lua
fi;
rm -f $testdir/conftest conftest.c
if [ "${HAVE_GETTEXT}" != "" ]; then
echo "#ifndef GETTEXT_CFLAGS" > config/gettext_cflags.h
echo "#define GETTEXT_CFLAGS \"$GETTEXT_CFLAGS\"" >> config/gettext_cflags.h
echo "#endif" >> config/gettext_cflags.h
echo "hdefs[\"GETTEXT_CFLAGS\"] = \"$GETTEXT_CFLAGS\"" >>configure.lua
echo "#ifndef GETTEXT_LIBS" > config/gettext_libs.h
echo "#define GETTEXT_LIBS \"$GETTEXT_LIBS\"" >> config/gettext_libs.h
echo "#endif" >> config/gettext_libs.h
echo "hdefs[\"GETTEXT_LIBS\"] = \"$GETTEXT_LIBS\"" >>configure.lua
echo "GETTEXT_CFLAGS=$GETTEXT_CFLAGS" >>Makefile.config
echo "mdefs[\"GETTEXT_CFLAGS\"] = \"$GETTEXT_CFLAGS\"" >>configure.lua
echo "GETTEXT_LIBS=$GETTEXT_LIBS" >>Makefile.config
echo "mdefs[\"GETTEXT_LIBS\"] = \"$GETTEXT_LIBS\"" >>configure.lua
fi;
fi;
else
echo "#ifndef GETTEXT_CFLAGS" > config/gettext_cflags.h
echo "#define GETTEXT_CFLAGS \"$GETTEXT_CFLAGS\"" >> config/gettext_cflags.h
echo "#endif" >> config/gettext_cflags.h
echo "hdefs[\"GETTEXT_CFLAGS\"] = \"$GETTEXT_CFLAGS\"" >>configure.lua
echo "#ifndef GETTEXT_LIBS" > config/gettext_libs.h
echo "#define GETTEXT_LIBS \"$GETTEXT_LIBS\"" >> config/gettext_libs.h
echo "#endif" >> config/gettext_libs.h
echo "hdefs[\"GETTEXT_LIBS\"] = \"$GETTEXT_LIBS\"" >>configure.lua
echo "GETTEXT_CFLAGS=$GETTEXT_CFLAGS" >>Makefile.config
echo "mdefs[\"GETTEXT_CFLAGS\"] = \"$GETTEXT_CFLAGS\"" >>configure.lua
echo "GETTEXT_LIBS=$GETTEXT_LIBS" >>Makefile.config
echo "mdefs[\"GETTEXT_LIBS\"] = \"$GETTEXT_LIBS\"" >>configure.lua
fi;
	if [ "${HAVE_GETTEXT}" != "yes" ]
 then
		echo "*"
		echo "* --enable-nls was given but gettext was not found. Try"
		echo "* running configure again without this option."
		echo "*"
		exit 1
	fi
fi
echo "Don't forget to run \"make depend\"."
echo "Don't forget to run \"make depend\"." >> config.log