#! /bin/sh

# local options:  ac_help is the help message that describes them
# and LOCAL_AC_OPTIONS is the script that interprets them.  LOCAL_AC_OPTIONS
# is a script that's processed with eval, so you need to be very careful to
# make certain that what you quote is what you want to quote.

ac_help='--filterdir=DIR		where to put printer filters (prefix/sbin/printers)
--traditional		build a more traditional sort of magicfilter
--use-local-magic	install a private magic file
--use-fifo		pipe the output from gs through a fifo
--with-lprng		build a stupid filter for use with lprng
--with-papersize=SIZE	set the default paper size for gs/pstext
--with-pcl		use hp2pcl or lj2ps to print pcl on non-pcl printers'

LOCAL_AC_OPTIONS='
case X"$1" in
X--filterdir=*)
	    AC_FILTER=`echo "$1" | sed -e "s/^[^=]*=//"`
	    shift 1
	    ;;
X--filterdir)
	    AC_FILTER=$2
	    shift 2
	    ;;
X--traditional)
	    TARGET=traditional
	    shift
	    ;;
*)	    ac_error=1
	    ;;
esac'

# load in the configuration file
#
TARGET=magicfilter
# #### configure.inc ####
#   @(#) configure.inc 1.28@(#)
#   Copyright (c) 1999 David Parsons. 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.
#  3. My name may not be used to endorse or promote products derived
#     from this software without specific prior written permission.
#     
#  THIS SOFTWARE IS PROVIDED BY DAVID PARSONS ``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 DAVID
#  PARSONS 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.
#


#
# this preamble code is executed when this file is sourced and it picks
# interesting things off the command line.
#
ac_default_path="/sbin:/usr/sbin:/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin"

ac_standard="--src=DIR		where the source lives (.)
--prefix=DIR		where to install the final product (/usr/local)
--execdir=DIR		where to put executables (prefix/bin)
--libdir=DIR		where to put libraries (prefix/lib)
--mandir=DIR		where to put manpages (prefix/man)
--confdir=DIR		where to put configuration information (/etc)"

__fail=exit

if dirname B/A 2>/dev/null >/dev/null; then
__ac_dirname() {
    dirname "$1"
}
else
__ac_dirname() {
    echo "$1" | sed -e 's:/[^/]*$::'
}
fi

ac_progname=$0
ac_configure_command="$*"

__d=`__ac_dirname "$ac_progname"`
if [ "$__d" = "$ac_progname" ]; then
    AC_SRCDIR=`pwd`
else
    AC_SRCDIR=`cd $__d;pwd`
fi

__ac_dir() {
    if test -d "$1"; then
	(cd "$1";pwd)
    else
	echo "$1";
    fi
}

while [ $# -gt 0 ]; do
    unset matched

    case X"$1" in
    X--src|X--srcdir)
	AC_SRCDIR=`__ac_dir "$2"`
	_set_srcdir=1
	shift 2;;

    X--src=*|X--srcdir=*)
	__d=`echo "$1" | sed -e 's/^[^=]*=//'`
	AC_SRCDIR=`__ac_dir "$__d"`
	_set_srcdir=1
	shift 1 ;;

    X--prefix)
	AC_PREFIX=`__ac_dir "$2"`
	_set_prefix=1
	shift 2;;

    X--prefix=*)
	__d=`echo "$1"| sed -e 's/^[^=]*=//'`
	AC_PREFIX=`__ac_dir "$__d"`
	_set_prefix=1
	shift 1;;

    X--confdir)
	AC_CONFDIR=`__ac_dir "$2"`
	_set_confdir=1
	shift 2;;

    X--confdir=*)
	__d=`echo "$1" | sed -e 's/^[^=]*=//'`
	AC_CONFDIR=`__ac_dir "$__d"`
	_set_confdir=1
	shift 1;;

    X--lib|X--libdir)
	AC_LIBDIR=`__ac_dir "$2"`
	_set_libdir=1
	shift 2;;

    X--lib=*|X--libdir=*)
	__d=`echo "$1" | sed -e 's/^[^=]*=//'`
	AC_LIBDIR=`__ac_dir "$__d"`
	_set_libdir=1
	shift 1;;

    X--exec|X--execdir)
	AC_EXECDIR=`__ac_dir "$2"`
	_set_execdir=1
	shift 2;;

    X--exec=*|X--execdir=*)
	__d=`echo "$1" | sed -e 's/^[^=]*=//'`
	AC_EXECDIR=`__ac_dir "$__d"`
	_set_execdir=1
	shift 1;;

    X--man|X--mandir)
	AC_MANDIR=`__ac_dir "$2"`
	_set_mandir=1
	shift 2;;

    X--man=*|X--mandir=*)
	__d=`echo "$1" | sed -e 's/^[^=]*=//'`
	AC_MANDIR=`__ac_dir "$__d"`
	_set_mandir=1
	shift 1;;

    X--use-*=*)
	_var=`echo "$1"| sed -n 's/^--use-\([A-Za-z][-A-Za-z0-9_]*\)=.*$/\1/p'`
	if [ "$_var" ]; then
	    _val=`echo "$1" | sed -e 's/^--use-[^=]*=\(.*\)$/\1/'`
	    _v=`echo $_var | tr '[a-z]' '[A-Z]' | tr '-' '_'`
	    case X"$_val" in
	    X[Yy][Ee][Ss]|X[Tt][Rr][Uu][Ee]) eval USE_${_v}=T ;;
	    X[Nn][Oo]|X[Ff][Aa][Ll][Ss][Ee]) eval unset USE_${_v} ;;
	    *) echo "Bad value for --use-$_var ; must be yes or no"
	       exit 1 ;;
	    esac
	else
	    echo "Bad option $1.   Use --help to show options" 1>&2
	    exit 1
	fi
	shift 1 ;;

    X--use-*)
        _var=`echo "$1"|sed -n 's/^--use-\([A-Za-z][-A-Za-z0-9_]*\)$/\1/p'`
	_v=`echo $_var | tr '[a-z]' '[A-Z]' | tr '-' '_'`
	eval USE_${_v}=T
	shift 1;;

    X--with-*=*)
	_var=`echo "$1"| sed -n 's/^--with-\([A-Za-z][-A-Za-z0-9_]*\)=.*$/\1/p'`
	if [ "$_var" ]; then
	    _val=`echo "$1" | sed -e 's/^--with-[^=]*=\(.*\)$/\1/'`
	    _v=`echo $_var | tr '[a-z]' '[A-Z]' | tr '-' '_'`
	    eval WITH_${_v}=$_val
	else
	    echo "Bad option $1.   Use --help to show options" 1>&2
	    exit 1
	fi
	shift 1 ;;

    X--with-*)
	_var=`echo "$1" | sed -n 's/^--with-\([A-Za-z][A-Za-z0-9_-]*\)$/\1/p'`
	if [ "$_var" ]; then
	    _v=`echo $_var | tr '[a-z]' '[A-Z]' | tr '-' '_'`
	    eval WITH_${_v}=1
	else
	    echo "Bad option $1.   Use --help to show options" 1>&2
	    exit 1
	fi
	shift 1 ;;

    X--help)
	echo "$ac_standard"
	test "$ac_help" && echo "$ac_help"
	exit 0;;

    *)	if [ "$LOCAL_AC_OPTIONS" ]; then
	    eval "$LOCAL_AC_OPTIONS"
	else
	    ac_error=T
	fi
	if [ "$ac_error" ]; then
	    echo "Bad option $1.   Use --help to show options" 1>&2
	    exit 1
	fi ;;
    esac
done


#
# echo w/o newline
#
echononl()
{
    ${ac_echo:-echo} "${@}$ac_echo_nonl"
}

#
# log something to the terminal and to a logfile.
#
LOG () {
    echo "$@"
    echo "$@" 1>&5
}

#
# log something to the terminal without a newline, and to a logfile with
# a newline
#
LOGN () {
    echononl "$@" 1>&5
    echo "$@"
}

#
# log something to the terminal
#
TLOG () {
    echo "$@" 1>&5
}

#
# log something to the terminal, no newline
#
TLOGN () {
    echononl "$@" 1>&5
}


#
# AC_CONTINUE tells configure not to bomb if something fails, but to
# continue blithely along
#
AC_CONTINUE () {
    __fail="return"
}

#
# Emulate gnu autoconf's AC_CHECK_HEADERS() function
#
AC_CHECK_HEADERS () {
    AC_PROG_CC

    echo "/* AC_CHECK_HEADERS */" > /tmp/ngc$$.c
    for hdr in $*; do
	echo "#include <$hdr>" >> /tmp/ngc$$.c
    done
    echo "main() { }" >> /tmp/ngc$$.c

    test "$_sssh" || LOGN "checking for header $hdr"

    if $AC_CC -o /tmp/ngc$$ /tmp/ngc$$.c; then
	AC_DEFINE 'HAVE_'`echo $hdr | tr 'a-z' 'A-Z' | tr './' '_'` 1
	test "$_sssh" || TLOG " (found)"
	rc=0
    else
	test "$_sssh" || TLOG " (not found)"
	rc=1
    fi
    unset _sssh
    rm -f /tmp/ngc$$.c /tmp/ngc$$
    return $rc
}


#
# emulate GNU autoconf's AC_CHECK_FUNCS function
#
AC_CHECK_FUNCS () {
    AC_PROG_CC

    cat >> /tmp/ngc$$.c << EOF
main()
{
    $1();
}
EOF

    test "$_sssh" || LOGN "checking for the $1 function"

    if $AC_CC -o /tmp/ngc$$ /tmp/ngc$$.c $LIBS; then
	AC_DEFINE `echo ${2:-HAVE_$1} | tr 'a-z' 'A-Z'` 1
	test "$_sssh" || TLOG " (found)"
	rc=0
    else
	echo "offending command was:"
	cat /tmp/ngc$$.c
	echo "$AC_CC -o /tmp/ngc$$ /tmp/ngc$$.c $LIBS"
	test "$_sssh" || TLOG " (not found)"
	rc=1
    fi
    rm -f /tmp/ngc$$.c /tmp/ngc$$
    unset _sssh
    return $rc
}


#
# check to see if some structure contains a field
#
# usage: AC_CHECK_FIELD structure field {include ...}
#
AC_CHECK_FIELD () {
    AC_PROG_CC

    struct=$1
    field=$2
    shift 2

    rm -f /tmp/ngc$$.c

    for include in $*;do
	echo "#include <$include>" >> /tmp/ngc$$.c
    done

    cat >> /tmp/ngc$$.c << EOF
main()
{
    struct $struct foo;

    foo.$field;
}
EOF

    test "$_sssh" || LOGN "checking that struct $struct has a $field field"

    if $AC_CC -o /tmp/ngc$$ /tmp/ngc$$.c $AC_LIBS 2>>config.log; then
	AC_DEFINE HAVE_`echo ${struct}_$field | tr 'a-z' 'A-Z'`
	test "$_sssh" || TLOG " (yes)"
	rc=0
    else
	test "$_sssh" || TLOG " (no)"
	rc=1
    fi
    unset _sssh
    rm -f /tmp/ngc$$.c /tmp/ngc$$
    return $rc
}


#
# check that the C compiler works
#
AC_PROG_CC () {
    test "$AC_CC" && return 0

    cat > /tmp/ngc$$.c << \EOF
#include <stdio.h>
main()
{
    puts("hello, sailor");
}
EOF

    TLOGN "checking the C compiler"

    AC_CC=${CC:-`acLookFor cc`}

    if [ ! "$AC_CC" ]; then
	TLOG " (no C compiler found)"
	$__fail 1
    fi
    echo "checking out the C compiler"

    $AC_CC -o /tmp/ngc$$ /tmp/ngc$$.c
    status=$?

    TLOGN " ($AC_CC)"
    if [ $status -eq 0 ]; then
	TLOG " ok"

	# check that the CFLAGS and LDFLAGS aren't bogus

	unset AC_CFLAGS AC_LDFLAGS

	if [ "$CFLAGS" ]; then
	    test "$CFLAGS" && echo "validating CFLAGS=${CFLAGS}"
	    if $AC_CC $CFLAGS -o /tmp/ngc$$.o /tmp/ngc$$.c ; then
		AC_CFLAGS=${CFLAGS:-"-g"}
		test "$CFLAGS" && echo "CFLAGS=\"${CFLAGS}\" are okay"
	    elif [ "$CFLAGS" ]; then
		echo "ignoring bogus CFLAGS=\"${CFLAGS}\""
	    fi
	else
	    AC_CFLAGS=-g
	fi
	if [ "$LDFLAGS" ]; then
	    test "$LDFLAGS" && echo "validating LDFLAGS=${LDFLAGS}"
	    if $AC_CC $LDFLAGS -o /tmp/ngc$$ /tmp/ngc$$.o; then
		AC_LDFLAGS=${LDFLAGS:-"-g"}
		test "$LDFLAGS" && TLOG "LDFLAGS=\"${LDFLAGS}\" are okay"
	    elif [ "$LDFLAGS" ]; then
		TLOG "ignoring bogus LDFLAGS=\"${LDFLAGS}\""
	    fi
	else
	    AC_LDFLAGS=${CFLAGS:-"-g"}
	fi
	AC_SUB 'CFLAGS' "$AC_CFLAGS"
	AC_SUB 'LDFLAGS' "$AC_LDFLAGS"
    else
	AC_SUB 'CFLAGS' ''
	AC_SUB 'LDFLAGS' ''
	AC_FAIL " does not compile code properly"
    fi

    AC_SUB 'CC' "$AC_CC"

    rm -f /tmp/ngc$$ /tmp/ngc$$.c /tmp/ngc$$.o

    return $status
}


#
# acLookFor actually looks for a program, without setting anything.
#
acLookFor () {
    path=${AC_PATH:-$ac_default_path}
    case "X$1" in
    X-[rx]) __mode=$1
	    shift
	    ;;
    *)	    __mode=-x
	    ;;
    esac
    oldifs="$IFS"
    for program in $*; do
	IFS=":"
	for x in $path; do
	    if [ $__mode $x/$program -a -f $x/$program ]; then
		echo $x/$program
		break 2
	    fi
	done
    done
    IFS="$oldifs"
    unset __mode
}


#
# check that a program exists and set its path
#
MF_PATH_INCLUDE () {
    SYM=$1; shift

    case X$1 in
    X-[rx]) __mode=$1
	    shift
	    ;;
    *)      unset __mode
	    ;;
    esac

    TLOGN "looking for $1"

    DEST=`acLookFor $__mode $*`

    __sym=`echo "$SYM" | tr '[a-z]' '[A-Z]'`
    if [ "$DEST" ]; then
	TLOG " ($DEST)"
	echo "$1 is $DEST"
	AC_MAK $SYM
	AC_DEFINE PATH_$__sym \""$DEST"\"
	AC_SUB $__sym "$DEST"
	eval CF_$SYM=$DEST
	return 0
    else
	#AC_SUB $__sym ''
	echo "$1 is not found"
	TLOG " (not found)"
	return 1
    fi
}


#
# AC_INIT starts the ball rolling
#
# After AC_INIT, fd's 1 and 2 point to config.log
# and fd 5 points to what used to be fd 1
#
AC_INIT () {
    __config_files="config.cmd config.sub config.h config.mak config.log"
    rm -f $__config_files
    __cwd=`pwd`
    exec 5>&1 1>$__cwd/config.log 2>&1
    AC_CONFIGURE_FOR=__AC_`echo $1 | sed -e 's/\..$//' | tr 'a-z' 'A-Z' | tr ' ' '_'`_D

    # check to see whether to use echo -n or echo ...\c
    #
    echo -n hello > $$
    echo world >> $$
    if grep "helloworld" $$ >/dev/null; then
	ac_echo="echo -n"
	echo "[echo -n] works"
    else
	ac_echo="echo"
	echo 'hello\c' > $$
	echo 'world' >> $$
	if grep "helloworld" $$ >/dev/null; then
	    ac_echo_nonl='\c'
	    echo "[echo ...\\c] works"
	fi
    fi
    rm -f $$

    LOG "Configuring for [$1]"

    cat > $__cwd/config.h << EOF
/*
 * configuration for $1${2:+" ($2)"}, generated `date`
 * by ${LOGNAME:-`whoami`}@`hostname`
 */
#ifndef $AC_CONFIGURE_FOR
#define $AC_CONFIGURE_FOR 1


EOF

    AC_PREFIX=${AC_PREFIX:-/usr/local}
    AC_EXECDIR=${AC_EXECDIR:-$AC_PREFIX/bin}
    AC_LIBDIR=${AC_LIBDIR:-$AC_PREFIX/lib}
    AC_MANDIR=${AC_MANDIR:-$AC_PREFIX/man}
    AC_CONFDIR=${AC_CONFDIR:-/etc}

    AC_PATH=${WITH_PATH:-$PATH}
    AC_PROG_CPP
    AC_PROG_INSTALL

    ac_os=`uname -s`
    _os=`echo $ac_os | tr '[a-z]' '[A-Z]'`
    AC_DEFINE OS_$_os	1
    eval OS_${_os}=1
    unset _os
}


#
# AC_LIBRARY checks to see if a given library exists and contains the
# given function.
# usage: AC_LIBRARY function library [alternate ...]
#
AC_LIBRARY() {
    SRC=$1
    shift

    # first see if the function can be found in any of the
    # current libraries
    _sssh=T
    AC_CHECK_FUNCS $SRC && return 0

    # then search through the list of libraries
    __libs="$LIBS"
    for x in $*; do
	_sssh=T
	LIBS="$__libs $x"
	if AC_CHECK_FUNCS $SRC; then
	    AC_LIBS="$AC_LIBS $x"
	    return 0
	fi
    done
    return 1
}


#
# AC_PROG_LEX checks to see if LEX exists, and if it's lex or flex.
#
AC_PROG_LEX() {
    TLOGN "looking for lex "

    DEST=`acLookFor lex`
    if [ "$DEST" ]; then
	AC_MAK LEX
	AC_DEFINE PATH_LEX \"$DEST\"
	AC_SUB 'LEX' "$DEST"
	echo "lex is $DEST"
    else
	DEST=`acLookFor flex`
	if [ "$DEST" ]; then
	    AC_MAK FLEX
	    AC_DEFINE 'LEX' \"$DEST\"
	    AC_SUB 'LEX', "$DEST"
	    echo "lex is $DEST"
	else
	    AC_SUB LEX ''
	    echo "neither lex or flex found"
	    TLOG " (not found)"
	    return 1
	fi
    fi

    if AC_LIBRARY yywrap -ll -lfl; then
	TLOG "($DEST)"
	return 0
    fi
    TLOG "(no lex library found)"
    return 1
}


#
# AC_PROG_YACC checks to see if YACC exists, and if it's bison or
# not.
#
AC_PROG_YACC () {

    TLOGN "looking for yacc "

    DEST=`acLookFor yacc`
    if [ "$DEST" ]; then
	AC_MAK YACC
	AC_DEFINE PATH_YACC \"$DEST\"
	AC_SUB 'YACC' "$DEST"
	TLOG "($DEST)"
	echo "yacc is $DEST"
    else
	DEST=`acLookFor bison`
	if [ "$DEST" ]; then
	    AC_MAK BISON
	    AC_DEFINE 'YACC' \"$DEST\"
	    AC_SUB 'YACC' "$DEST -y"
	    echo "yacc is $DEST -y"
	    TLOG "($DEST -y)"
	else
	    AC_SUB 'YACC' ''
	    echo "neither yacc or bison found"
	    TLOG " (not found)"
	    return 1
	fi
    fi
    return 0
}


#
# AC_PROG_LN_S checks to see if ln exists, and, if so, if ln -s works
#
AC_PROG_LN_S () {
    test "$AC_FIND_PROG" || AC_PROG_FIND

    test "$AC_FIND_PROG" || return 1
    
    TLOGN "looking for \"ln -s\""
    DEST=`acLookFor ln`

    if [ "$DEST" ]; then
	rm -f /tmp/b$$
	$DEST -s /tmp/a$$ /tmp/b$$
	if [ "`$AC_FIND_PROG /tmp/b$$ -type l -print`" ]; then
	    TLOG " ($DEST)"
	    echo "$DEST exists, and ln -s works"
	    AC_SUB 'LN_S' "$DEST -s"
	    rm -f /tmp/b$$
	else
	    AC_SUB 'LN_S' ''
	    TLOG " ($DEST exists, but -s does not seem to work)"
	    echo "$DEST exists, but ln -s doesn't seem to work"
	    rm -f /tmp/b$$
	    return 1
	fi
    else
	AC_SUB 'LN_S' ''
	echo "ln not found"
	TLOG " (not found)"
	return 1
    fi
}


#
# AC_PROG_FIND looks for the find program and sets the FIND environment
# variable
#
AC_PROG_FIND () {
    if test -z "$AC_FIND_PROG"; then
	MF_PATH_INCLUDE FIND find
	rc=$?
	AC_FIND_PROG=$DEST
	return $rc
    fi
    return 0
}


#
# AC_PROG_SED looks for the sed program and sets the SED environment
# variable
#
AC_PROG_SED () {
    if test -z "$AC_SED_PROG"; then
	MF_PATH_INCLUDE SED sed
	rc=$?
	AC_SED_PROG=$DEST
	return $rc
    fi
    return 0
}


#
# AC_HEADER_SYS_WAIT looks for sys/wait.h
#
AC_HEADER_SYS_WAIT () {
    AC_CHECK_HEADERS sys/wait.h || return 1
}

#
# AC_TYPE_PID_T checks to see if the pid_t type exists
#
AC_TYPE_PID_T () {
    cat > /tmp/pd$$.c << EOF
#include <sys/types.h>
main() { pid_t me; }
EOF

    LOGN "checking for pid_t"

    if $AC_CC -c /tmp/pd$$.c -o /tmp/pd$$.o; then
	TLOG " (found)"
	rc=0
    else
	echo "typedef int pid_t;" >> $__cwd/config.h
	TLOG " (not found)"
	rc=1
    fi
    rm -f /tmp/pd$$.o /tmp/pd$$.c
    return $rc
}


#
# AC_C_CONST checks to see if the compiler supports the const keyword
#
AC_C_CONST () {
    cat > /tmp/pd$$.c << EOF
const char me=1;
EOF
    LOGN "checking for \"const\" keyword"

    if $AC_CC -c /tmp/pd$$.c -o /tmp/pd$$.o; then
	TLOG " (yes)"
	rc=0
    else
	AC_DEFINE 'const' '/**/'
	TLOG " (no)"
	rc=1
    fi
    rm -f /tmp/pd$$.o /tmp/pd$$.c
    return $rc
}


#
# AC_OUTPUT generates makefiles from makefile.in's
#
AC_OUTPUT () {
    cd $__cwd
    AC_SUB 'LIBS' "$AC_LIBS"
    AC_SUB 'CONFIGURE_FILES' "$__config_files"
    AC_SUB 'GENERATED_FILES' "$*"
    AC_SUB 'srcdir'  "$AC_SRCDIR"
    AC_SUB 'prefix'  "$AC_PREFIX"
    AC_SUB 'exedir'  "$AC_EXECDIR"
    AC_SUB 'libdir'  "$AC_LIBDIR"
    AC_SUB 'confdir' "$AC_CONFDIR"
    AC_SUB 'mandir'  "$AC_MANDIR"

    if [ -r config.sub ]; then
	test "$AC_SED_PROG" || AC_PROG_SED
	test "$AC_SED_PROG" || return 1

	echo                                   >> config.h
	echo "#endif/* ${AC_CONFIGURE_FOR} */" >> config.h

	rm -f config.cmd
	Q=\'
	cat - > config.cmd << EOF
#! /bin/sh
${CC:+CC=${Q}${CC}${Q}} ${CFLAGS:+CFLAGS=${Q}${CFLAGS}${Q}} $ac_progname $ac_configure_command
EOF
	chmod +x config.cmd

	__d=$AC_SRCDIR
	for makefile in $*;do
	    if test -r $__d/${makefile}.in; then
		LOG "generating $makefile"
		./config.md `__ac_dirname ./$makefile` 2>/dev/null
		$AC_SED_PROG -f config.sub < $__d/${makefile}.in > $makefile
		__config_files="$__config_files $makefile"
	    else
		LOG "WARNING: ${makefile}.in does not exist!"
	    fi
	done
	unset __d

    else
	echo 
    fi
}


#
# AC_PROG_INSTALL finds the install program and guesses whether it's a 
# Berkeley or GNU install program
#
AC_PROG_INSTALL () {

    DEST=`acLookFor install`

    LOGN "checking for install"
    unset IS_BSD
    if [ "$DEST" ]; then
	# BSD install or GNU install?  Let's find out...
	touch /tmp/a$$

	$DEST /tmp/a$$ /tmp/b$$

	if test -r /tmp/a$$; then
	    LOG " ($DEST)"
	else
	    IS_BSD=1
	    LOG " ($DEST) bsd install"
	fi
	rm -f /tmp/a$$ /tmp/b$$
    else
	DEST=`acLookFor ginstall`
	if [ "$DEST" ]; then
	    LOG " ($DEST)"
	else
	    DEST="false"
	    LOG " (not found)"
	fi
    fi

    if [ "$IS_BSD" ]; then
	PROG_INSTALL="$DEST -c"
    else
	PROG_INSTALL="$DEST"
    fi

    AC_SUB 'INSTALL' "$PROG_INSTALL"
    AC_SUB 'INSTALL_PROGRAM' "$PROG_INSTALL -s -m 755"
    AC_SUB 'INSTALL_DATA' "$PROG_INSTALL -m 444"

    # finally build a little directory installer
    # if mkdir -p works, use that, otherwise use install -d,
    # otherwise build a script to do it by hand.
    # in every case, test to see if the directory exists before
    # making it.

    if mkdir -p $$a/b; then
	# I like this method best.
	__mkdir="mkdir -p"
	rmdir $$a/b
	rmdir $$a
    elif $PROG_INSTALL -d $$a/b; then
	__mkdir="$PROG_INSTALL -d"
	rmdir $$a/b
	rmdir $$a
    fi

    __generated_files="$__generated_files $__cwd/config.md"
    AC_SUB 'INSTALL_DIR' "$__cwd/config.md"
    echo "#! /bin/sh"                                   > $__cwd/config.md
    echo "# script generated" `date` "by configure.sh" >> $__cwd/config.md
    echo                                               >> $__cwd/config.md
    if [ "$__mkdir" ]; then
	echo "test -d \"\$1\" || $__mkdir \"\$1\""     >> $__cwd/config.md
	echo "exit $?"                                 >> $__cwd/config.md
    else
	cat - >> $__cwd/config.md << \EOD
pieces=`IFS=/; for x in $1; do echo $x; done`
dir=
for x in $pieces; do
    dir="$dir$x"
    mkdir $dir || exit 1
    dir="$dir/"
done
exit 0
EOD
    fi
    chmod +x $__cwd/config.md
}

#
# acCheckCPP is a local that runs a C preprocessor with a given set of
# compiler options
#
acCheckCPP () {
	cat > /tmp/ngc$$.c << EOF
#define FOO BAR

FOO
EOF

    if $1 $2 /tmp/ngc$$.c > /tmp/ngc$$.o; then
	if grep -v '#define' /tmp/ngc$$.o | grep -s BAR >/dev/null; then
	    echo "CPP=[$1], CPPFLAGS=[$2]"
	    AC_SUB 'CPP' "$1"
	    AC_SUB 'CPPFLAGS' "$2"
	    rm /tmp/ngc$$.c /tmp/ngc$$.o
	    return 0
	fi
    fi
    rm /tmp/ngc$$.c /tmp/ngc$$.o
    return 1
}


#
# AC_PROG_CPP checks for cpp, then checks to see which CPPFLAGS are needed
# to run it as a filter.
#
AC_PROG_CPP () {
    if [ "$AC_CPP_PROG" ]; then
	DEST=$AC_CPP_PROG
    else
	__ac_path="$AC_PATH"
	AC_PATH="/lib:/usr/lib:${__ac_path:-$ac_default_path}"
	DEST=`acLookFor cpp`
	AC_PATH="$__ac_path"
    fi

    unset fail
    LOGN "Looking for cpp"
    if [ "$DEST" ]; then
	TLOGN " ($DEST)"
	acCheckCPP $DEST "$CPPFLAGS" || \
		 acCheckCPP $DEST -traditional-cpp -E || \
		 acCheckCPP $DEST -E || \
		 acCheckCPP $DEST -traditional-cpp -pipe || \
	         acCheckCPP $DEST -pipe || fail=1

	if [ "$fail" ]; then
	    AC_FAIL " (can't run cpp as a pipeline)"
	else
	    TLOG " ok"
	    return 0
	fi
    fi
    AC_FAIL " (not found)"
}

#
# AC_FAIL spits out an error message, then __fail's 
AC_FAIL() {
    LOG "$*" 
    $__fail 1
}

#
# AC_SUB writes a substitution into config.sub
AC_SUB() {
    (   echononl "s;@$1@;"
	_subst=`echo $2 | sed -e 's/;/\\;/g'`
	echononl "$_subst"
	echo ';g' ) >> $__cwd/config.sub
}

#
# AC_MAK writes a define into config.mak
AC_MAK() {
    echo "HAVE_$1 = 1" >> $__cwd/config.mak
}

#
# AC_DEFINE adds a #define to config.h
AC_DEFINE() {
    echo "#define $1 ${2:-1}" >> $__cwd/config.h
}

#
# AC_CONFIG adds a configuration setting to all the config files
AC_CONFIG() {
    AC_DEFINE "PATH_$1" \""$2"\"
    AC_MAK "$1"
    AC_SUB "$1" "$2"
}
# #### configure.sh #####

# and away we go
#
AC_INIT magicfilter

AC_PROG_CC

AC_SUB filterdir ${AC_FILTER:-$AC_PREFIX/sbin/printers}

if [ "$USE_FIFO" = "T" ]; then
    AC_SUB GSOUT '${FIFO}'
else
    AC_SUB GSOUT '-'
fi

BUILD_MAGIC=T
if [ "$USE_LOCAL_MAGIC" ]; then
    LOG "Using private magic file $AC_CONFDIR/mf.magic"
else
    if AC_LIBRARY magic_open -lmagic; then
	LOG "Your system has a modern libmagic.  We'll use it."
	unset BUILD_MAGIC
    elif AC_LIBRARY magic_open -lmagic -lz; then
	LOG "Your system has a modern libmagic.  We'll use it."
	AC_LIBS="$AC_LIBS -lz"
	unset BUILD_MAGIC
    fi
    unset BUILD_MAGIC

    if [ "$BUILD_MAGIC" ]; then
	case $ac_os in
	[Ff]ree[Bb][Ss][Dd])magicpath=/etc:/usr/etc:/usr/share/misc ;;
	*)			magicpath=/etc:/usr/etc: ;;
	esac

	# check to see if the system magic file is moderately recent
	#
	trap "rm -f $$" 1 2 3 9 15
	echo "@PJL JOB" > $$
	F=`file $$ 2>/dev/null | grep -i pjl`
	echo "%PDF-1.1" > $$
	G=`file $$ 2>/dev/null | grep -i pdf`

	if [ "$F" -a "$G" ]; then
	    save_AC_PATH=$AC_PATH
	    AC_PATH=$magicpath MF_PATH_INCLUDE MAGIC -r magic || USE_LOCAL_MAGIC=T
	    AC_PATH=$save_AC_PATH
	else
	    LOG "file(1) is too old -- using private magic file"
	    USE_LOCAL_MAGIC=T
	fi
    fi
fi
rm -f $$
trap 1 2 3 9 15

if [ "$USE_LOCAL_MAGIC" ]; then
    # if we're using local magic, manually write the substitution
    # information into the config files
    AC_CONFIG MAGIC "$AC_CONFDIR"/mf.magic
    AC_SUB INSTALL_MAGIC "$PROG_INSTALL"
else
    AC_DEFINE PATH_MAGIC 0
    AC_SUB INSTALL_MAGIC ":"
fi
if [ "$BUILD_MAGIC" ]; then
    AC_SUB LIBMAGIC file/libmagic.a
    AC_SUB MAGIC_HEADER "-I$AC_SRCDIR/file"
    AC_SUB MAGIC_LIB    "-Lfile"
    AC_SUB MAKE_MAGIC	"cd file \&\& make"
    AC_SUB CFMAGIC	"cfmagic"
else
    AC_SUB LIBMAGIC ""
    AC_SUB MAGIC_HEADER "-I${LOCALBASE}/include"
    AC_SUB MAGIC_LIB "-L${LOCALBASE}/lib -Wl,-rpath -Wl,${LOCALBASE}/lib"
    AC_SUB MAKE_MAGIC ":"
    AC_SUB CFMAGIC	""
fi

AC_SUB DO_WHAT install-$TARGET

# AC_PROG_LN_S
# AC_PROG_YACC

if [ ! "$WITH_LPRNG" ]; then
    S=`lpq -V 2>/dev/null | head -1 | grep -i lprng`

    if [ "$S" ]; then
	LOG "Found LPRng -- building stupid filters"
	WITH_LPRNG=1
    fi
fi
if [ "$WITH_LPRNG" ]; then
    AC_SUB    "LPD_OPTS" "'s/^LPNG//p'"
    AC_DEFINE "WITH_LPRNG" "1"
else
    AC_SUB    "LPD_OPTS" "'s/^LPR //p'"

    # don't bother to check for options.h unless we're not
    # being built against lprng -- remember that magicfilter
    # for lprng doesn't have any options.
    #
    if AC_CHECK_HEADERS basis/options.h; then
	if LIBS="-lbasis" AC_CHECK_FUNCS x_getopt; then
	    AC_LIBS="$AC_LIBS -lbasis"
	    HAVE_XGETOPT=T
	fi
    fi
fi
if [ "$WITH_LPRNG" -o "$HAVE_XGETOPT" ]; then
    AC_SUB XGETOPT ''
else
    AC_SUB XGETOPT options.o
fi

AC_CHECK_HEADERS malloc.h || AC_CHECK_HEADERS sys/malloc.h

AC_CHECK_FUNCS basename

MF_PATH_INCLUDE RANLIB ranlib true || AC_CONFIG RANLIB ':'
MF_PATH_INCLUDE M4 m4 || AC_FAIL "magicfilter requires m4"

MF_PATH_INCLUDE GS gs
if MF_PATH_INCLUDE NENSCRIPT nenscript enscript; then
    TLOGN "checking if $CF_NENSCRIPT supports the -q flag..."
    __v=`$CF_NENSCRIPT -q -p - </dev/null`

    if [ \( "$?" -ne 0 \) -o "$__v" ]; then
	TLOG " no"
	AC_SUB NENSCRIPT_QUIET ''
    else
	TLOG " yes"
	AC_SUB NENSCRIPT_QUIET -q
    fi
else
    AC_SUB NENSCRIPT_QUIET ''
    MF_PATH_INCLUDE PSTEXT pstext
fi

# if the user is brave, look for a pcl to generic format converter
#
test "$WITH_PCL" && MF_PATH_INCLUDE UNPCL hp2pbm lj2ps

case X"$CF_UNPCL" in
X*hp2pbm)  AC_SUB UNPCL_FLAGS '-p' ;;
X*)        AC_SUB UNPCL_FLAGS '' ;;
esac

paper=$WITH_PAPERSIZE

if [ "$CF_GS" -a "$paper" ]; then
    if ! echo "quit" | $CF_GS -sPAPERSIZE=$paper -dNODISPLAY -; then
	AC_FAIL "$CF_GS cannot write to $paper sized paper"
	unset paper
    fi
fi

if [ "${CF_PSTEXT:-$CF_NENSCRIPT}" -a "$paper" ]; then
    PROG=${CF_PSTEXT:-$CF_NENSCRIPT}
    if ! $PROG -T$paper </dev/null; then
	AC_FAIL "$PROG cannot write to $paper sized paper"
	unset paper
    fi
fi

test "$paper" && AC_DEFINE PAPERSIZE \"$WITH_PAPERSIZE\"

MF_PATH_INCLUDE GZIP gzip gzcat || MF_PATH_INCLUDE ZCAT zcat
MF_PATH_INCLUDE BZIP bzip2
MF_PATH_INCLUDE UNCOMPRESS uncompress
MF_PATH_INCLUDE DVIPS dvips
MF_PATH_INCLUDE PNMTOPS pnmtops
MF_PATH_INCLUDE GIFTOPPM giftopnm giftoppm
MF_PATH_INCLUDE G3TOPBM g3topbm
MF_PATH_INCLUDE DJPEG djpeg
MF_PATH_INCLUDE PNGTOPNM pngtopnm
MF_PATH_INCLUDE SGITOPNM sgitopnm
MF_PATH_INCLUDE TIFFTOPNM tifftopnm
MF_PATH_INCLUDE BMPTOPPM bmptopnm bmptoppm
MF_PATH_INCLUDE RASTTOPNM rasttopnm
MF_PATH_INCLUDE FIG2DEV fig2dev
MF_PATH_INCLUDE ACROREAD acroread
 
# MF_PROG_GNU_ZCAT($ZCAT)

#save_AC_PATH=$AC_PATH
#AC_PATH=/usr/lib:/usr/sbin:/usr/bin:/bin:/sbin MF_PATH_INCLUDE SENDMAIL sendmail smail mail Mail
#AC_PATH=$save_AC_PATH

AC_CHECK_HEADERS memory.h
AC_CHECK_HEADERS paths.h
AC_CHECK_HEADERS stdlib.h
AC_CHECK_HEADERS unistd.h
AC_HEADER_SYS_WAIT

AC_C_CONST
AC_TYPE_PID_T
AC_CHECK_FUNCS dup2
AC_CHECK_FUNCS tmpnam
AC_CHECK_FUNCS waitpid
AC_CHECK_FUNCS wait4
AC_CHECK_FUNCS unsetenv
AC_CHECK_FUNCS setenv
AC_CHECK_FUNCS setlinebuf

AC_SUB MAGICFILTER ${AC_EXEC}/magicfilter
AC_SUB VERSION `test -f VERSION && cat VERSION`
AC_DEFINE STD_PATH "\"${AC_PATH}\""

AC_OUTPUT Makefile file/Makefile magicfilter.8templ magicfilter.5 magicfilter.h magicfilter-t.5 magic.m4 contrib/mfconfig.pl args.c