source: trunk/third/tiff/configure @ 18174

#!/bin/sh
#       $Header: /afs/dev.mit.edu/source/repository/third/tiff/configure,v 1.1.1.1 2002-12-26 02:37:26 ghudson Exp $
#
# Tag Image File Format (TIFF) Software
#
# Copyright (c) 1988-1997 Sam Leffler
# Copyright (c) 1991-1997 Silicon Graphics, Inc.
# 
# Permission to use, copy, modify, distribute, and sell this software and 
# its documentation for any purpose is hereby granted without fee, provided
# that (i) the above copyright notices and this permission notice appear in
# all copies of the software and related documentation, and (ii) the names of
# Sam Leffler and Silicon Graphics may not be used in any advertising or
# publicity relating to the software without the specific, prior written
# permission of Sam Leffler and Silicon Graphics.
# 
# THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
# EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
# WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
# 
# IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
# ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
# OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
# LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
# OF THIS SOFTWARE.
#

# Configuration script for the TIFF Software

#
# Shell script to setup machine-dependent files in
# preparation for building TIFF source.
#

POSIXLY_CORRECT=1; export POSIXLY_CORRECT       # disable GNU extensions

QUIET=no                                # suppress messages to tty
NONINTERACTIVE=no                       # control prompting of config params
SITE=                                   # dir where config.site is located
TARGET=                                 # target system identity
SRCDIR=                                 # dir where source is located

#
# Setup general configuration parameters.
#
PREFIX=/usr/local                       # root of installation 
EPREFIX=${PREFIX}
DIRS_LIBINC=                            # dirs to search for ancillary includes
DIR_JPEGLIB=                            # dir for IJG -ljpeg
DIR_GZLIB=                              # dir for zlib -lgz
DSO=auto                                # auto-enable DSO support
LIBCOPTS=                               # library-specific C-compiler options
JPEG=no                                 # configure JPEG support
ZIP=no                                  # configure ZIP/Deflate support
PORT=auto                               # enable portability emulations
HTML=no                                 # install HTML documentation
LIBGL=auto                              # auto-enable build of SGI -lgl apps
LIBIMAGE=auto                           # auto-enable build of SGI -limage apps
: ${CC=}                                # name of C compiler to use
: ${CCOMPILER=}                         # full pathname of C compiler
: ${OPTIMIZER=-O}                       # Optimization flag
: ${ENVOPTS=}                           # CC opts for ANSI C compilation
: ${MAKE=make}                          # make to use

# screws up the test of `-f -'
: ${MAKEFLAGS=}                         # unset MAKEFLAGS
RM="rm -f"

#
# Error diagnostics that should go to the terminal are
# done with this interface (or cat).
#
bitch()
{
    echo "configure: $@" 1>&2
}

#
# This is the preferred interface for
# configure to terminate abnormally.
#
boom()
{
    bitch ""
    bitch "Unrecoverable error!  Once you've corrected the problem rerun this script."
    kill -1 $$                          # use kill so trap handler is called
}

usage()
{
    cat<<'EOF'
Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
  --help                  print this message
  --quiet                 do not print `Using ...' messages
  --verbose               opposite of --quiet
  --noninteractive        don't ask any questions
  --version               print the version of autoconf that created configure
  --prefix=PREFIX         root of installation [PREFIX=/usr/local]
  --exec-prefix=EPREFIX   root of installation [EPREFIX=PREFIX]
  --target=TARGET         configure for TARGET [TARGET=HOST]
  --srcdir=DIR            find the sources in DIR [configure dir or ..]
  --with-PARAM[=ARG]      set configuration PARAM [ARG=yes]
EOF
}

#
# Crack command line arguments.  We purposely
# use syntax and options that are compatible
# with GNU autoconf.
#
ac_prev=
for ac_option
do
    if [ -n "$ac_prev" ]; then          # assign the argument to previous option
        eval "$ac_prev=\$ac_option"
        ac_prev=
        continue
    fi
    case "$ac_option" in                # collect optional argument
    -*=*)       ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'`;;
    *)          ac_optarg=;;
    esac
    case "$ac_option" in
    -with-*|--with-*)
        ac_with=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
        # Reject names that are not valid shell variable names.
        if [ -n "`echo $ac_with| sed 's/[-_a-zA-Z0-9]//g'`" ]; then
            bitch "configure: $ac_with: invalid parameter name."
            kill -1 $$
        fi
        ac_with=`echo $ac_with| sed 's/-/_/g'`
        case "$ac_option" in
        *=*)    ;;
        *)      ac_optarg=yes;;
        esac
        eval "${ac_with}='$ac_optarg'"
        ;;
    -quiet|--quiet)             QUIET=yes;;
    -verbose|--verbose)         QUIET=no;;
    -noninteractive|--noninteractive) NONINTERACTIVE=yes;;
    -site|--site)               ac_prev=SITE;;
    -site=*|--site=*)           SITE="$ac_optarg";;
    -srcdir|--srcdir)           ac_prev=SRCDIR;;
    -srcdir=*|--srcdir=*)       SRCDIR="$ac_optarg";;
    --exec-prefix)              ac_prev=EPREFIX;;
    --exec-prefix=*)            EPREFIX="$ac_optarg" ;;
    --prefix)                   ac_prev=PREFIX;;
    --prefix=*)                 PREFIX="$ac_optarg";
                                EPREFIX=${PREFIX} ;;
    -target|--target)           ac_prev=TARGET;;
    -target=*|--target=*)       TARGET="$ac_optarg" ;;
    -version|--version)
        echo "This is TIFF configure $Revision: 1.1.1.1 $"
        exit 0
        ;;
    -help|--help)               usage; exit 0;;
    -*)
        bitch "configure: $ac_option: invalid option; use -help for usage."
        kill -1 $$
        ;;
    *)
        if [ x"$TARGET" != x ]; then
            bitch "configure: Can only configure for one target at a time."
            kill -1 $$
        fi
        TARGET="$ac_option"
        ;;
    esac
done

DIR_BIN=${EPREFIX}/bin          # destination for applications
DIR_LIB=${EPREFIX}/lib          # destination for library
DIR_INC=${PREFIX}/include               # destination for include files
DIR_HTML=${PREFIX}/doc/libtiff          # destination for HTML files

if [ -n "$ac_prev" ]; then
    bitch "configure: missing argument to --`echo $ac_prev | sed 's/_/-/g'`"
    kill -1 $$
fi

#
# Locate source directory by looking for the VERSION file.
# The directory must either be specified through the
# environment or be located in the current directory or a
# parent of the current directory.
#
test "$SRCDIR" || {
    configure=$0
    # NB: don't use dirname since it may not exist
    SRCDIR=`echo $configure | sed 's;/[^/][^/]*$;;'`
    if [ @"$SRCDIR" = @"$configure" ]; then
        SRCDIR=.
    fi
    while [ ! -r $SRCDIR/VERSION ]; do
        # strip last directory from pathname
        newdir=`echo $SRCDIR | sed 's;/[^/]*$;;'`
        if [ -z "$newdir" ] || [ "$newdir" = $SRCDIR ]; then
            break;
        fi
        SRCDIR=$newdir
    done
}
if [ ! -r $SRCDIR/VERSION ]; then
    bitch "Cannot locate sources in $SRCDIR."
    kill -1 $$
fi
SRCDIR=`echo "$SRCDIR" | sed 's;\([^/]\)/*$;\1;'`

if [ -r ${SRCDIR}/tif_version.c ] ; then
    SRCDIR_IS_LIBTIFF=yes
    PORTDOTH=port.h
else
    SRCDIR_IS_LIBTIFF=no
    PORTDOTH=libtiff/port.h
fi

#
# Descriptor usage:
# 1: ???
# 2: errors that should be seen even if we're in the background.
# 3: [stdout from test runs]
# 4: verbose-style messages (Using ...)
# 5: compiler stderr when running tests
#
if [ $QUIET = yes ]; then
    exec 4>/dev/null                    # chuck messages
else
    exec 4>&1                           # messages got to stdout
fi
exec 5>./config.log                     # compiler messages and the like

capture()
{
    (eval "set -x; $*") >&5 2>&1
    return
}
captureX()
{
    (eval "set -x; $*") 2>&5
    return
}

date >&5
echo Running "$0" with arguments: "$@" >&5

cat 1>&5 <<'EOF'

This file contains information that is captured from running the configure
script.  Lines that begin with a "+" are command lines echoed by the
shell.  Other lines are the output of commands; usually the contents of
test case files or the output from compilers.  If configure does the
wrong thing, you can use the information captured here to aid in debugging.

EOF

VERSIONFILE=$SRCDIR/VERSION
DATE=`date`

eval `cat $VERSIONFILE |  sed 's/\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)\(.*\)/DIST_MAJOR=\1; DIST_MINOR=\2; DIST_POINT=\3/'`
VERSION="v${DIST_MAJOR}.${DIST_MINOR}.${DIST_POINT}"

RELEASE=`cat $VERSIONFILE |  sed -e 's/[0-9 \.]//g'`
Note()
{
    echo "$@" 1>&4
}

Note ""
if [ $SRCDIR_IS_LIBTIFF = yes ] ; then
  Note "Configuring TIFF Software (library only) $VERSION"
else
  Note "Configuring TIFF Software $VERSION"
fi

Note ""
Note "If configure does the wrong thing, check the file config.log for"
Note "information that may help you understand what went wrong."
Note ""

#
# Read site and local configuration parameters.
#
if [ -f $SITE/config.site ]; then
    Note "Reading site-wide parameters from $SITE/config.site."
    . $SITE/config.site
    capture . $SITE/config.site
elif [ -f $SRCDIR/config.site ]; then
    Note "Reading site-wide parameters from $SRCDIR/config.site."
    . $SRCDIR/config.site
    capture . $SRCDIR/config.site
fi
if [ -f config.local ]; then
    Note "Reading local parameters from config.local."
    . ./config.local
    capture . ./config.local
elif [ -f $SRCDIR/config.local ]; then
    Note "Reading local parameters from $SRCDIR/config.local."
    . $SRCDIR/config.local
    capture . $SRCDIR/config.local
fi

#
# Emulate old-style settups...
#
test -z "${DIR_JPEG-}"  || {
    DIRS_LIBINC="${DIRS_LIBINC} ${DIR_JPEG}"
    DIR_JPEGLIB="${DIR_JPEG}"
}
test -z "${DIR_LIBGZ-}" || {
    DIRS_LIBINC="${DIRS_LIBINC} ${DIR_LIBGZ}"
    DIR_GZLIB="${DIR_LIBGZ}"
}

identifyTarget()
{
    random=`date | awk '{print $4}' | sed -e 's/.*://'` 2>/dev/null
    case "$random" in
    *0) Note "Wow, you've got a $1 system!";;
    *1) Note "Hmm, looks like a $1 system.";;
    *2) Note "Oh no, not another $1 system...";;
    *3) Note "Well I'll be, a $1 system.";;
    *4) Note "Fee, fie, foe, this smells like a $1 system.";;
    *5) Note "Gosh, aren't you lucky to have a $1 system!";;
    *6) Note "YOW!!  Did something bad happen or am I on a $1 system?";;
    *7) Note "Do they really still make $1 systems?!";;
    *8) Note "I'm always happy to encounter another $1 system.";;
    *9) Note "Here we are again, this time on a $1 system.";;
esac
}

#
# If no target is specified, try to deduce the system.
# We use the GNU scripts for guessing and canonicalizing
# the system identification, if available.
#
if [ -z "$TARGET" ]; then
    test -f $SRCDIR/config.guess && TARGET=`sh $SRCDIR/config.guess` 2>/dev/null
    if [ -z "$TARGET" ]; then
        bitch "Sorry, no target specified on the command line and I don't seem"
        bitch "to have the GNU config.guess script that is used to deduce your"
        bitch "system type."
        kill -1 $$
    fi
    identifyTarget $TARGET
elif [ -f $SRCDIR/config.sub ]; then
    TARGET=`sh $SRCDIR/config.sub "$TARGET"`
else
    Note "Warning, I don't seem to have the GNU config.sub script to canonicalize"
    Note "your target specification; this may cause problems later on..."
fi
if [ -z "${FILLORDER-}" ]; then
    #
    # Host bit order within a word.
    #
    case $TARGET in
    mips-dec-*) FILLORDER=LSB2MSB;;
    i[345]86-*) FILLORDER=LSB2MSB;;
    *)          FILLORDER=MSB2LSB;;
    esac
fi

#
# Find the full pathname of a file
# using the specified test operation.
#
findThing()
{
    t="$1"; app="$2"; path="$3";
    case "$app" in
    /*) eval "$t" "$app" && { echo "$app"; return; };;
    esac
    (IFS=:
    for i in $path; do
        eval "$t" "$i/$app" && { echo "$i/$app"; return 0; }
    done
    return 1
    )
}

#
# Find the full pathname of a plain file.
#
findFile()
{
    findThing "test -f" "$1" "$2"
}

#
# Find the full pathname of an executable.
#
findApp()
{
    findThing "test -x" $1 $2
}

#
# Find the full pathname of an executable;
# supply a default if nothing is found.
#
findAppDef()
{
    app=$1; path=$2; def=$3
    case $app in
    /*) test -x $app && { echo $app; return; };;
    esac
    IFS=:
    for i in $path; do
        test -x $i/$app && { echo $i/$app; return; }
    done
    echo $def
}

#
# Find the full pathname of a header file; in search-path $DIRS_LIBINC
#
findHeader()
{
    case "$1" in
    /*) echo "$1"; return ;;
    esac
    for i in ${DIRS_LIBINC} /usr/include; do
        test -r $i/$1 && {
            case "$i" in
            /*) echo "$i/$1"; return ;;
            esac
            if [ $SRCDIR_IS_LIBTIFF = yes ]; then
                echo "$i/$1";
            else
                echo "../$i/$1";
            fi
            return;
        }
    done
}

#
# Locate a C compiler that satisfies our needs (using assorted heuristics).
#
JUNK="
    a.out
    confsed
    conftestmmap
    confx confy
    confMakefile
    core
    dummy
    dummy.a
    dummy.c
    dummy.o
    foo
    so_locations
    t.c
    t.o
    t
    xMakedepend
    xdefs
    xgnu.c
    xmakeinc
    xport.h
"
trap "$RM \$JUNK; exit 1" 1 2 15

$RM $JUNK

cat>xgnu.c<<EOF
#ifdef __GNUC__
yes;
#endif
EOF

#
# Check if the specified compiler is from GNU 
#
isGNU()
{
    capture "cat xgnu.c; ($1 -E xgnu.c 2>&5 | egrep yes)"
}

#
# NB: use ANSI C prototype to weed out non-ANSI compilers.
#
cat>dummy.c<<EOF
main(int argc, char* argv) { exit(0); }
EOF

checkCompiler()
{
    compiler=$1
    if isGNU $compiler; then
        ISGCC=yes
    else
        ISGCC=no
    fi
    #
    # Guess special options needed to get an
    # ANSI C compiler and/or similar.  Must
    # be combined with above checks so we only
    # select an ANSI C compiler.
    #
    if [ -z "${ENVOPTS-}" ]; then
        case $ISGCC-$TARGET in
        no-*-irix*)     C_ANSI="-ansi";;
        no-*-hp*)       C_ANSI="-D_HPUX_SOURCE";;
        no-*-apollo-*)  C_ANSI="-A nansi";;
        no-*-aix*)      C_ANSI="-Dunix -qlanglvl=ansi -qsrcmsg -qmaxmem=8192";;
        *-sco*)         C_ANSI="-Dsco";;
        esac
    else
        C_ANSI="$ENVOPTS"
    fi
    $RM dummy dummy.o
    capture $compiler -o dummy ${C_ANSI} dummy.c && {
        CC=$compiler;
        test -z "${CCOMPILER-}" && CCOMPILER=`findApp $compiler $PATH`
        test -z "${ENVOPTS-}"   && ENVOPTS="${C_ANSI-}"
        return 0
    }
    return 1
}

CCtested=
capture cat dummy.c
if [ -z "${CC-}" ]; then
    CCOMPILER=
    for i in gcc cc ncc dcc xlc c89 gcc2; do
        CCtested="$CCtested $i"
        checkCompiler $i && break
    done
else
    CCtested="$CCtested $CC"
    checkCompiler $CC
fi
if [ -z "$CCOMPILER" ]; then
    cat<<EOF

Cannot locate a working ANSI C compiler.

We attempted to compile the following test program:

----------------------------------------------------------
EOF
    cat dummy.c
    cat<<EOF
----------------------------------------------------------

with these compilers:

    $CCtested

but none of them were successful.

If your compiler is in a non-standard location, you can specify its
location in several ways:

    o set the environment variable CC
    o create a config.local or config.site file that includes a
      definition for CC
    o supply it on the command line using -with-CC=<pathname>

If command line options are required for ANSI C compilation, set the
ENVOPTS parameter to these options in a similar way (either through
an environment variable or config.local/config.site) and then rerun
this script.
EOF
    boom
fi
Note "Using $CCOMPILER for a C compiler (use -with-CC=compilername to override)."

test "$ENVOPTS" && {
    Note "Using $ENVOPTS to get the appropriate compilation environment."
}

if [ ${ISGCC} = yes ] ; then
    GCCversion="`${CCOMPILER} -v 2>&1 | \
        sed -n -e '/version/s/.* \([0-9]*\)\.\([0-9]*\).\([0-9]*\)/\1.\2.\3/p'`"
fi


CheckForGandO()
{
   f=$1
   if test -s $f; then
        capture grep -i \(error\|warning\) $f || return 1
    fi
    return 0
}

if [ -z "${GCOPTS-}" ]; then
    if capture $CCOMPILER $ENVOPTS -g -c dummy.c; then
        Note "Looks like $CCOMPILER supports the -g option."
        # NB: cannot use captureX here 'cuz we lose stderr
        if $CCOMPILER $ENVOPTS -c -g $OPTIMIZER dummy.c >t 2>&1 && CheckForGandO t; then
            GCOPTS="-g"
        else
            Note "... but not together with the $OPTIMIZER option, not using it."
            GCOPTS=
        fi
    else
        GCOPTS=
    fi
fi
if [ ! -z "${GCOPTS}" ]; then
    Note "Using \"$GCOPTS\" for C compiler options."
fi

#
# Verify that $MAKE is accessible
#
PATHMAKE=`findApp ${MAKE} $PATH`
if [ "$PATHMAKE" ]; then
    Note "Using $PATHMAKE to configure the software."
    (echo 'all:') | ${MAKE} -f - all >/dev/null 2>&5 || {
        cat<<EOF

Something is wrong with "$MAKE" or $MAKE does not accept Makefiles
from stdin with "-f -".  If you have MAKE set in your environment,
verify it points to the right program you want to" use to build this
software.  Otherwise, verify that you have the make program installed
somewhere on your system and set the MAKE environment variable to the
pathname of the program.
EOF
        boom
    }
else
    cat<<EOF
No $MAKE located in the search path.

There was no $MAKE program in the restricted search used by this script
If $MAKE is in a non-standard location set the MAKE environment variable
to the pathname of the appropriate program.
EOF
    boom
fi

# Find sh (likely /bin/sh or /usr/bin/sh), and put in SCRIPT_SH

test -z "${SCRIPT_SH-}" && SCRIPT_SH=`findAppDef sh $PATH sh`

#
# Check whether or not $MAKE automatically sets MAKE
# in the Makefiles.  If not, we add an explicit define
# for places where recursive calls are made.
#
if [ -z "${SETMAKE-}" ]; then
    if (sed "s;@SHELL@;$SCRIPT_SH;" <<'EOF'
SHELL=@SHELL@
all:
        @if [ -n "${MAKE}" ] ; then echo "make sets make"  ; fi
EOF
) | $MAKE -f - | grep "make sets make" > /dev/null ; then
        SETMAKE=
    else
        Note "Looks like $MAKE does not setup MAKE in Makefiles, will compensate."
        SETMAKE="MAKE   = ${MAKE}"
    fi
fi

test -z "${AR-}" && AR=`findApp ar $PATH`
if [ -z "$AR" ]; then
    Note "*** Warning, could not locate a suitable ar command; using a default."
    AR=ar
fi
test -z "${AROPTS-}" && AROPTS=rc
test -z "${RANLIB-}" && RANLIB=`findApp ranlib $PATH`
if [ -z "$RANLIB" ]; then
    Note "Warning, no ranlib, assuming it's not needed."
    RANLIB=":"
    $RM dummy.a
    if $AR rcs dummy.a >/dev/null 2>&1; then
       AROPTS=crs
       Note "Looks like ar has an s option to build symbol tables."
    fi
fi

#
# runMake target rules ...
#
runMakeX()
{
    target="$1"; shift
    $RM $target
    (echo SRCDIR=.
       for i in "$@"; do
          echo "$i";
       done
    )>confMakefile
    captureX ${MAKE} -f confMakefile $target
    return
}
runMake()
{
    runMakeX "$@" >&5
    return
}

#
# Look for a library using a known (unique) function.
#
CheckForLibrary()
{
    f=$1; shift
    libs="$@";
    cat>t.c<<EOF
int t() { $f(); return 0; }
int main(){ t(); return 0; }
EOF
    runMake t "t:; ${CCOMPILER} ${ENVOPTS} t.c $libs"
}

#
# Look for an include file.
#
CheckForIncludeFile()
{
    (for i do
        echo "#include \"$i\""
     done)>t.c
    runMake t "t:; ${CCOMPILER} ${ENVOPTS} -E t.c"
}

#
# Figure out if certain system-specific interfaces are
# supported.  We craft a port.h file that has external
# declarations for missing routines that are required by
# the system and modify defs to reflect which optional
# interfaces are supported.
#

EmitCPlusPlusPrologue()
{
    echo '/*'
    echo ' * Warning, this file was automatically created by the TIFF configure script'
    echo ' * VERSION:   ' $VERSION
    echo ' * RELEASE:   ' $RELEASE
    echo ' * DATE:      ' $DATE
    echo ' * TARGET:    ' $TARGET
    if [ $ISGCC = yes ]; then
        echo ' * CCOMPILER:     ' ${CCOMPILER}-${GCCversion}
    else
        echo ' * CCOMPILER:     ' $CCOMPILER
    fi
    echo ' */'
    echo "#ifndef $1"
    echo "#define $1 1"
    echo '#ifdef __cplusplus'
    echo 'extern "C" {'
    echo '#endif'
}

EmitCPlusPlusEpilogue()
{
    echo '#ifdef __cplusplus'
    echo '}'
    echo '#endif'
    echo '#endif'
}

#
# Look for a function in one of the standard libraries
# or one of the machine-dependent libraries selected above.
#
CheckForFunc()
{
    echo "extern int $1(); main(){$1();exit(0);}" >t.c
    runMake t "t:; ${CCOMPILER} ${ENVOPTS} t.c ${MACHDEPLIBS}"
}

# 
# Verify that we have -lm.  Darwin (for instance) does not.  Add to 
# MACHDEPLIBS if required.
#

if [ -z "${MACHDEPLIBS-}" ]; then
    MACHDEPLIBS=""
    if CheckForFunc cos ; then
        echo "Leaving MACHDEPLIBS empty, apparently you don't need -lm."
    else
        MACHDEPLIBS="-lm"
        echo "Defaulting MACHDEPLIBS to -lm."
    fi
fi

#
# Look for a function declaration in system include files.
#
AddFuncDecl()
{
    echo "$2";
    Note "... add function prototype for $1"
}
CheckForFuncDecl()
{
    f=$1; shift
    (for i do
        echo "#include \"$i\""
     done)>t.c
    capture cat t.c
    runMakeX t "t:; ${CCOMPILER} ${ENVOPTS} -E t.c" |\
     awk '{while($0~/[,(][ \t]*$/){printf"%s",$0;getline}print}' |\
     grep "$f[ ]*(.*)" >&5
    return
}
CheckFuncDecl()
{
    f=$1; shift
    decl=$1; shift
    CheckForFuncDecl "$f" "$@" || AddFuncDecl "$f" "$decl"
}

#
# Look for a variable declaration in system include files.
#
CheckForVarDecl()
{
    v="$1"; shift
    (for i do
        echo "#include \"$i\""
     done)>t.c
    capture cat t.c
    runMakeX t "t:; ${CCOMPILER} ${ENVOPTS} -E t.c" | grep "$v" >&5
    return
}
CheckVarDecl()
{
    v="$1"; shift
    decl="$1"; shift
    CheckForVarDecl "$v" "$@" || \
        (echo "$decl"; Note "... add declaration $decl")
}

#
# Look for a #define in system include files.
#
AddDefine()
{
   echo '#ifndef' $1
   echo '#define' "$2"
   echo '#endif'
   Note '... add #define for' "$1"
}
CheckForDefine()
{
    def=$1; shift
    (for i do
        echo "#include \"$i\""
     done
     echo "#ifdef $def"
     echo "FOUND();"
     echo "#endif"
    )>t.c
    capture cat t.c
    runMakeX t "t:; ${CCOMPILER} ${ENVOPTS} -E t.c" | grep FOUND >&5
}
CheckDefine()
{
    def=$1; shift
    decl=$1; shift
    CheckForDefine "$def" "$@" || AddDefine "$def" "$decl"
}

CheckForMMAP()
{
    if CheckForFunc getpagesize; then
        cat>t.c<<'EOF'
/* this was lifted from GNU autoconf */
/* Thanks to Mike Haertel and Jim Avera for this test. */
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>
EOF
    else
        cat>t.c<<'EOF'
/* this was lifted from GNU autoconf */
/* Thanks to Mike Haertel and Jim Avera for this test. */
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>

#ifdef BSD
# ifndef BSD4_1
#  define HAVE_GETPAGESIZE
# endif
#endif

#ifndef HAVE_GETPAGESIZE
# include <sys/param.h>
# ifdef EXEC_PAGESIZE
#  define getpagesize() EXEC_PAGESIZE
# else
#  ifdef NBPG
#   define getpagesize() NBPG * CLSIZE
#   ifndef CLSIZE
#    define CLSIZE 1
#   endif
#  else
#   ifdef NBPC
#    define getpagesize() NBPC
#   else
#    define getpagesize() PAGESIZE /* SVR4 */
#   endif
#  endif
# endif
#endif
EOF
    fi
cat>>t.c<<'EOF'
#if defined(__osf__) || defined(_AIX)
# define valloc malloc
#endif
char *valloc(), *malloc();

int
main()
{
  char *buf1, *buf2, *buf3;
  int i = getpagesize(), j;
  int i2 = getpagesize()*2;
  int fd;

  buf1 = (char *)valloc(i2);
  buf3 = (char *)malloc(i2);
  for (j = 0; j < i2; ++j)
    *(buf1 + j) = rand();
  fd = open("conftestmmap", O_CREAT | O_RDWR, 0666);
  write(fd, buf1, i2);
  buf2 = mmap(0, i, PROT_READ|PROT_WRITE, MAP_VARIABLE|MAP_PRIVATE, fd, 0);
  for (j = 0; j < i; ++j)
    if (*(buf1 + j) != *(buf2 + j))
      exit(1);
  lseek(fd, (long)i, 0);
  read(fd, buf2, i); /* read into mapped memory -- file should not change */
  /* (it does in i386 SVR4.0 - Jim Avera, jima@netcom.com) */
  lseek(fd, (long)0, 0);
  read(fd, buf3, i2);
  for (j = 0; j < i2; ++j)
    if (*(buf1 + j) != *(buf3 + j))
      exit(1);
  exit(0);
}
EOF
    capture cat t.c
    runMake t "t:; ${CCOMPILER} ${ENVOPTS} t.c ${MACHDEPLIBS}" && ./a.out
}

CheckForBigEndian()
{
    echo 'main() { int one = 1; char* cp = (char*)&one; exit(*cp!=0); }'>t.c
    capture cat t.c
    runMake t "t:; ${CCOMPILER} ${ENVOPTS} t.c" && ./a.out
}

#
# Check an existing port.h to see if it was created
# for the target and compiler we are using.
#
CheckPortDotH()
{
    getConfigTag()
    {
        param=`grep "$1:" $2 | sed -e 's/.*:[   ]*\([^  ]*\).*/\1/'`
    }
    getConfigTag TARGET $PORTDOTH; target="$param"
    getConfigTag CCOMPILER $PORTDOTH; ccompiler="$param"
    CCOMP=$CCOMPILER
    if [ $ISGCC = yes ]; then
        CCOMP="${CCOMP}-${GCCversion}"
    fi
    test "$target" = "$TARGET" && test "$ccompiler" = "$CCOMP"
}

#
# Built port.h based on the system and compiler setup.
#
BuildPortDotH()
{
    Note ""
    Note "Creating $PORTDOTH with necessary definitions."

    (EmitCPlusPlusPrologue _PORT_

    CheckForIncludeFile sys/types.h && echo '#include <sys/types.h>'
    CheckVarDecl off_t 'typedef long off_t;' sys/types.h stdlib.h
    CheckVarDecl size_t 'typedef unsigned size_t;' sys/types.h stdlib.h
    CheckVarDecl u_char 'typedef unsigned char u_char;' sys/types.h
    CheckVarDecl u_short 'typedef unsigned short u_short;' sys/types.h
    CheckVarDecl u_int 'typedef unsigned int u_int;' sys/types.h
    CheckVarDecl u_long 'typedef unsigned long u_long;' sys/types.h

    echo "#define HOST_FILLORDER FILLORDER_${FILLORDER}"
    CPU=`echo $TARGET | sed 's/-.*//'`
    Note "... using $FILLORDER bit order for your $CPU cpu"
    if CheckForBigEndian; then
        echo "#define HOST_BIGENDIAN    1"
        Note "... using big-endian byte order for your $CPU cpu"
    else
        echo "#define HOST_BIGENDIAN    0"
        Note "... using little-endian byte order for your $CPU cpu"
    fi

    CheckForMMAP && {
        echo '#define HAVE_MMAP 1'
        Note "... configure use of mmap for memory-mapped files"
        CheckFuncDecl mmap \
            'extern void* mmap(void*, size_t, int, int, int, off_t);' sys/mman.h
    }

    CheckForIncludeFile stdio.h         && echo '#include <stdio.h>'
    CheckForIncludeFile unistd.h        && echo '#include <unistd.h>'
    CheckForIncludeFile string.h        && echo '#include <string.h>'
    CheckForIncludeFile stdlib.h        && echo '#include <stdlib.h>'
    if CheckForDefine O_RDONLY fcntl.h; then
        echo '#include <fcntl.h>'
        Note "... O_RDONLY is in <fcntl.h>"
    elif CheckForDefine O_RDONLY sys/file.h; then
        echo '#include <sys/file.h>'
        Note "... O_RDONLY is in <sys/file.h>"
    else
        AddDefine O_RDONLY "O_RDONLY    0"
        AddDefine O_WRONLY "O_WRONLY    1"
        AddDefine O_RDWR   "O_RDWR      2"
    fi

    echo 'typedef double dblparam_t;'
        Note "... using double for promoted floating point parameters"

    if [ -z "${INLINE-}" ]; then
        if [ $ISGCC = yes ]; then
            echo '#ifdef __STRICT_ANSI__'
            echo '#define       INLINE  __inline__'
            echo '#else'
            echo '#define       INLINE  inline'
            echo '#endif'
            Note "... enabling use of inline functions"
        else
            echo '#define       INLINE'
            Note "... disabling use of inline functions"
        fi
    else
        echo "#define INLINE $INLINE"
        Note "... using \"$INLINE\" to control inline function usage"
    fi

    echo '#define GLOBALDATA(TYPE,NAME) extern TYPE NAME'

    CheckFuncDecl memset 'extern void* memset(void*, int, size_t);' string.h
    CheckFuncDecl floor 'extern double floor(double);' math.h
    CheckFuncDecl ceil 'extern double ceil(double);' math.h
    CheckFuncDecl exp 'extern double exp(double);' math.h
    CheckFuncDecl pow 'extern double pow(double, double);' math.h
    CheckFuncDecl read 'extern int read(int, const void*, unsigned int);' unistd.h
    CheckFuncDecl malloc 'extern void* malloc(size_t);' stdlib.h
    CheckFuncDecl realloc 'extern void* realloc(void*, size_t);' stdlib.h
    CheckFuncDecl free 'extern void free(void*);' stdlib.h
    EmitCPlusPlusEpilogue
    )>xport.h
    if [ $SRCDIR_IS_LIBTIFF = no -a ! -d libtiff ]; then
        Note "Creating libtiff directory"
        mkdir libtiff
    fi
    mv xport.h $PORTDOTH; chmod 444 $PORTDOTH
    Note "Done creating $PORTDOTH."
}

if [ "$PORT" != no ] && test -f $PORTDOTH && CheckPortDotH; then
    Note ""
    Note "Using previously created $PORTDOTH."
else
    $RM xport.h t.c a.out $PORTDOTH
    BuildPortDotH
fi

if [ "$PORT" = auto ]; then
    Note ""
    Note "Checking system libraries for functionality to emulate."

    FUNCS="
        strcasecmp
        strtoul
        getopt
    "

    for i in $FUNCS; do
        CheckForFunc $i || {
            Note "... emulate $i"
            PORTFUNCS="${PORTFUNCS-} $i.c"
        }
    done
    if [ "${PORTFUNCS-}" ]; then
        LIBPORT='../port/libport.a'
        PORT=yes
    else
        PORT=no
    fi
fi
if [ $PORT != yes ] ; then
   LIBPORT=
   PORTFUNCS=
fi
Note "Done checking system libraries."

Note ""
Note "Checking for Dynamic Shared Object (DSO) support."
if [ "$DSO" = auto ]; then
    DSO=no
    DSOSUF_VERSION=
    DSOLD='${LD}'
    TIFFLIBREF=
    case $TARGET-$CC-$ISGCC in
    *-irix5.2*)
        if (findApp rld /lib:/usr/lib:$PATH) >/dev/null 2>&1; then
            DSOSUF=so
            DSOOPTS='-elf -shared -no_unresolved -all'
            DSO=IRIX52
            TIFFLIBREF='-L${DEPTH}/libtiff -rpath '${DIR_LIB}' -ltiff'
        fi
        ;;
    *-irix*)
        if (findApp rld /lib:/usr/lib:$PATH) >/dev/null 2>&1; then
            DSOSUF=so
            DSOLD="${CCOMPILER} ${ENVOPTS}"
            if [ $ISGCC = yes ]; then
               LIBCOPTS="-fpic"
               DSOOPTS='-shared -rdata_shared'
            else
               LIBCOPTS="-KPIC"
               DSOOPTS='-shared -rdata_shared -check_registry ${SRCDIR}/port/irix/so_locations -quickstart_info'
            fi
            DSO=IRIX
            TIFFLIBREF='-L${DEPTH}/libtiff -rpath '${DIR_LIB}' -ltiff'
        fi
        ;;
    *-aix*)
        DSOSUF=a
        DSOOPTS='-r'
        LIBCOPTS="-bM\:SRE"
        DSO=AIX
        TIFFLIBREF='-L${DEPTH}/libtiff -ltiff'
        ;;
    *-hpux*yes)
        DSOSUF=sl
        DSOLD=gcc
        DSOOPTS='-fpic -shared'
        LIBCOPTS=-fpic
        DSO=HPUX
        TIFFLIBREF="-Wl,+s,+b${DIR_LIB}"' -L${DEPTH}/libtiff -ltiff'
        ;;               
    *-hpux*)
        DSOSUF=sl
        DSOSUF_VERSION=${DIST_MAJOR}.${DIST_MINOR}${DIST_POINT}
        DSOOPTS='-b'
        LIBCOPTS="+z"
        DSO=HPUX
        TIFFLIBREF='-L$(DEPTH)/libtiff -ltiff'
        ;;
    *-solaris*)
        DSOSUF=so
        DSOOPTS='-G'
        if [ $ISGCC = yes ]; then
            LIBCOPTS="-fpic"
        else
            LIBCOPTS="-K PIC"
        fi
        DSO=SOLARIS
        TIFFLIBREF='-L${DEPTH}/libtiff -R'${DIR_LIB}' -ltiff'
        ;;
    *-netbsd*)
        DSOSUF=so.${DIST_MAJOR}.0
        LIBCOPTS='-fPIC'
        DSO=NETBSD
        TIFFLIBREF='-L${DEPTH}/libtiff -ltiff'
        ;;
    *-freebsd*)
        DSOSUF=so.${DIST_MAJOR}
        DSOSUF_VERSION=${DSOSUF}.${DIST_MINOR}.${DIST_POINT}
        LIBCOPTS='-fPIC'
        DSOOPTS='-shared'
        DSO=GNULD
        ;;
    *-openbsd*)
        DSOSUF=so.${DIST_MAJOR}.${DIST_MINOR}
        LIBCOPTS='-fpic'
        TIFFLIBREF='-L${DEPTH}/libtiff -ltiff'
        case "$TARGET" in
           *-openbsd[01].* | *-openbsd2.[0-7] | *-openbsd2.[0-7].*)
              DSO=oldOPENBSD
           ;;
           *)
              DSO=OPENBSD
              DSOLD="${CCOMPILER} ${ENVOPTS}"
              DSOOPTS='-shared ${LIBCOPTS}'
           ;;
        esac
        ;;
    *-darwin*)
        DSOSUF=${DIST_MAJOR}.dylib
        DSOSUF_VERSION=${DIST_MAJOR}.${DIST_MINOR}.${DIST_POINT}.dylib
        LIBCOPTS='-fno-common'
          DSOLD=gcc
        DSOOPTS='-dynamiclib -undefined suppress'
        DSO=DARWIN
        ;;
    *-linux*)
        DSOSUF=so.${DIST_MAJOR}
        DSOSUF_VERSION=${DSOSUF}.${DIST_MINOR}.${DIST_POINT}
        LIBCOPTS='-fPIC'
        DSOOPTS='-shared'
        DSO=GNULD
        ;;
    *-osf3*|*-osf4*)
        DSOSUF=so
        DSOOPTS='-shared'
        DSO=OSF
        ;;

    esac
fi
if [ "$DSO" != no ]; then
    JUNK="$JUNK t.${DSOSUF}"
    #
    # Check to make sure the compilers process
    # the DSO options in the expected way.
    #
    CheckCCDSO()
    {
    $RM t.c t.o t.${DSOSUF}
    cat>t.c<<EOF
int f() { return 0; }
EOF
    capture cat t.c
    runMake t \
        "t.o:; ${CCOMPILER} ${ENVOPTS} ${LIBCOPTS} -c t.c" \
        "t: t.o; ${DSOLD} ${DSOOPTS} -o t.${DSOSUF} t.o"
    }
    if CheckCCDSO; then
        Note "Looks like your system supports $DSO-style DSOs."
    else
        cat 1>&4 <<EOF
Looks like your system supports $DSO-style DSOs...
... sigh, but $CCOMPILER does not support DSOs in the expected way.
EOF
        DSO=no
    fi
fi
if [ "$DSO" = no ]; then
    DSOSUF=a DSOOPTS= LIBCOPTS= 
    DSOSUF_VERSION=$DSOSUF
fi
test -z "$TIFFLIBREF" && TIFFLIBREF="\${DEPTH}/libtiff/libtiff.${DSOSUF}"
test -z "$DSOSUF_VERSION" && DSOSUF_VERSION=${DSOSUF}
Note "Done checking for DSO support."

Note ""
if [ "$LIBIMAGE" = auto ]; then
    if CheckForLibrary iopen -limage && CheckForIncludeFile gl/image.h; then
        Note "Looks like there is support for SGI RGB images."
        LIBIMAGE=yes
    else
        LIBIMAGE=no
    fi
fi
if [ "$LIBGL" = auto ]; then
    if CheckForLibrary winopen -lgl && CheckForIncludeFile gl.h; then
        Note "Looks like there is support for IRIS GL."
        LIBGL=yes
    else
        LIBGL=no
    fi
fi

test $LIBGL = no -a $LIBIMAGE = no || Note ""
Note "Selecting programs used during installation."


#
# Miscellaneous ``little'' programs.
#
test -z "${CHMOD-}"     && CHMOD=`findAppDef chmod $PATH chmod`
test -z "${LN-}"        && LN=`findAppDef ln $PATH ln`
test -z "${SED-}"       && SED=`findAppDef sed $PATH sed`
test -z "${STRIP-}"     && STRIP=`findAppDef strip $PATH strip`

#
# Check if mv -f is supported
#
if [ -z "${MV_F-}" ]; then
    $RM t.c; echo "">t.c
    if mv -f t.c t.o; then
        Note "Looks like mv supports the -f option to force a move."
        MV_F=-f
    else
        Note "Warning, looks like mv has no -f option to force move operations;"
        Note "... this may cause problems during installation."
        MV_F=
    fi
fi

#
# Check if ln -s creates a symbolic link.
#
if [ -z "${LN_S-}" ]; then
    $RM t.c; $LN -s foo t.c && LN_S=-s
fi
if [ -n "$LN_S" ]; then
    Note "Looks like $LN supports the -s option to create a symbolic link."
else
    Note "Warning, looks like $LN has no -s option to create symbolic links;"
    Note "... this may cause problems during installation."
fi

#
# Pick install mechanism.
#
if [ -z "${INSTALL-}" ]; then
    case $TARGET in
    *-irix*)    INSTALL=`findApp install /sbin:$PATH`;;
    *)          INSTALL='${SCRIPT_SH} ../port/install.sh';;
    esac
fi

Note "Done selecting programs."

#
# User-changable configuration parameters section.
# Anything selected here is presented to the user
# and may be interactively changed.
#

Note ""
Note "Selecting default TIFF configuration parameters."
Note ""

#
# Fill in any other configuration parameters not
# setup in the site and local files.
#

bitchExecutable()
{
    echo ""
    echo "Warning, $1 does not seem to be an executable program;"
    echo "you'll need to correct this before starting up the fax server."
    echo ""
}

#
# Setup manual page-related stuff.
#
# Manual pages are processed according to:
# 1. Section organization (BSD or System V)
# 2. Pre-formatted (w/ nroff) or source.
# 3. Compressed (compress, gzip, pack) or uncompressed.
# 4. Whether or not the FlexFAX ``F'' suffix must be
#    stripped for pages to be found (only for 4F pages).
#
if [ -z "${DIR_MAN-}" ]; then
    MANPATH="
        $MANPATH
        /usr/local/man
        /usr/contrib/man
        /usr/catman/local
    "
    DIR_MAN=
    for i in $MANPATH; do
        test -d $i && { DIR_MAN=$i; break; }
    done
    test -z "$DIR_MAN" && DIR_MAN=${PREFIX}/man
fi
Note "Looks like manual pages go in $DIR_MAN."
if [ -z "${MANSCHEME-}" ]; then
    case $TARGET in
    *-bsdi*|*-netbsd*)          MANSCHEME=bsd-nroff-gzip-0.gz;;
    *-freebsd*)                 MANSCHEME=bsd-source-cat;;
    *-linux*)                   MANSCHEME=bsd-source-cat;;
    *-ultrix*)                  MANSCHEME=bsd-source-cat;;
    *-sunos*)                   MANSCHEME=bsd-source-cat-strip;;
    *-sysv[234]*)               MANSCHEME=sysv-source-cat-strip;;
    *-hpux*)                    MANSCHEME=sysv-source-cat;;
    *-solaris*)                 MANSCHEME=sysv-source-cat-strip;;
    *-aix*)                     MANSCHEME=sysv-source-strip;;
    *-isc*|*-sco*)              MANSCHEME=sysv-source-cat;;
    *-irix*)                    MANSCHEME=sysv-nroff-compress-Z;;
    *)
        #
        # Try to deduce the setup from existing manual pages.
        # XXX needs more work XXX
        #
        MANSCHEME=sysv-source-cat
        if [ -d /usr/share/man ]; then
            if [ -d /usr/share/man/u_man ]; then
               MANSCHEME=sysv-source-cat
            elif [ -d /usr/share/man/man8 ]; then
               MANSCHEME=bsd-source-cat
            fi
        elif [ -d /usr/share/catman ]; then
            if [ -d /usr/share/catman/u_man ]; then
               MANSCHEME=sysv-nroff-cat
            elif [ -d /usr/share/catman/man8 ]; then
               MANSCHEME=bsd-nroff-cat
            fi
        fi
        ;;
    esac
fi
Note "Looks like manual pages should be installed with $MANSCHEME."

#
# Figure out which brand of echo we have and define
# prompt and print shell functions accordingly.
#
if [ `echo foo\\\c`@ = "foo@" ]; then
    prompt()
    {
        echo "$* \\c"
    }
elif [ "`echo -n foo`@" = "foo@" ]; then
    prompt()
    {
        echo -n "$* "
    }
else
    prompt()
    {
        echo "$*"
    }
fi

#
# Prompt the user for a string that can not be null.
#
promptForNonNullStringParameter()
{
    x="" val="$1" desc="$2"
    while [ -z "$x" ]; do
        prompt "$desc [$val]?"; read x
        if [ "$x" ]; then
            # strip leading and trailing white space
            x=`echo "$x" | sed -e 's/^[         ]*//' -e 's/[   ]*$//'`
        else
            x="$val"
        fi
    done
    param="$x"
}

promptForManPageScheme()
{
    x=""
    while [ -z "$x" ]; do
        prompt "Manual page installation scheme [$MANSCHEME]?"; read x
        if [ "$x" ]; then
            # strip leading and trailing white space
            x=`echo "$x" | sed -e 's/^[         ]*//' -e 's/[   ]*$//'`
            # XXX do a better job of validating...
            case "$x" in
            bsd-nroff-cat*|sysv-nroff-cat*)     ;;
            bsd-nroff-gzip*|sysv-nroff-gzip*)   ;;
            bsd-nroff-comp*|sysv-nroff-comp*)   ;;
            bsd-nroff-pack*|sysv-nroff-pack*)   ;;
            bsd-source-cat*|sysv-source-cat*)   ;;
            bsd-source-gzip*|sysv-source-gzip*) ;;
            bsd-source-comp*|sysv-source-comp*) ;;
            bsd-source-pack*|sysv-source-pack*) ;;
            *)
cat <<EOF

"$x" is not a valid manual page installation scheme.  Schemes are
constructed according to:

    <organization>-<formatting>-<compression>[-<suffix>]

where:

<organization>  is either "bsd" for BSD-style section organization (e.g.
                file formats in section 5) or "sysv" for System V-style
                organization (e.g. file formats in section 4).

<formatting>    is either "nroff" to force installation of formatted
                materials (using nroff) or "source" to get the nroff
                source installed.

<compression>   is either the name of a program to compress the manual
                pages (gipz, compress, pack) or "cat" for uncompressed data.

<suffix>        is either the file suffix to convert installed pages to
                (e.g. 0.gz for gzip-compressed pages under BSD) or "strip"
                to force the normal ".4f" suffix to be converted to ".4"
                (or ".5" if using the BSD organization).  If no -<suffix>
                is specified then filenames are not converted when they
                are installed.

Common schemes are:

bsd-nroff-gzip-0.gz     compressed formatted pages for BSD 
bsd-source-cat          nroff source w/ BSD organization
sysv-source-cat-strip   nroff source for SysV w/o .4f suffix
sysv-source-cat         nroff source for SysV as-is

EOF
                x="";;
            esac
        else
            x="$MANSCHEME"
        fi
    done
    MANSCHEME="$x"
}

printConfig()
{
    cat<<EOF

TIFF configuration parameters are:

[ 1] Directory for tools:               $DIR_BIN
[ 2] Directory for libraries:           $DIR_LIB
[ 3] Directory for include files:       $DIR_INC
[ 4] Directory for manual pages:        $DIR_MAN
[ 5] Directory for HTML documents:      $DIR_HTML
[ 6] Manual page installation scheme:   $MANSCHEME

EOF
}

promptForParameter()
{
    case $1 in
    1)  promptForNonNullStringParameter "$DIR_BIN" \
            "Directory to install tools";               DIR_BIN="$param"
        ;;
    2)  promptForNonNullStringParameter "$DIR_LIB" \
            "Directory to install libraries";           DIR_LIB="$param"
        ;;
    3)  promptForNonNullStringParameter "$DIR_INC" \
            "Directory to install include files";       DIR_INC="$param"
        ;;
    4)  promptForNonNullStringParameter "$DIR_MAN" \
            "Directory to install manual pages";        DIR_MAN="$param"
        ;;
    5)  promptForNonNullStringParameter "$DIR_HTML" \
            "Directory to install HTML documents";      DIR_HTML="$param"
        ;;
    6)  promptForManPageScheme;;
    esac
}

checkJPEG()
{
    if [ "${JPEG}" = yes ]; then
        test "`findHeader jpeglib.h`" || {
            cat<<EOF

The set of libtiff include directories,

    DIRS_LIBINC=${DIRS_LIBINC}

does not seem to be setup correctly; "jpeglib.h" was not found.
This must be corrected if the JPEG support is to be enabled.
Either fix the pathname or disable the JPEG support.

EOF
        }
        test $SRCDIR_IS_LIBTIFF = yes || \
          test -d "${DIR_JPEGLIB:-/dev/null/no-such-file}" || {
            cat<<EOF

The JPEG library directory, "${DIR_JPEGLIB}", does not seem to exist.
This must be corrected if the JPEG support is to be enabled.
Either fix the pathname or disable the JPEG support.

EOF
        }
    fi
}

checkZIP()
{
    if [ "${ZIP}" = yes ]; then
        test "`findHeader zlib.h`" || {
            cat<<EOF

The set of libtiff include directories,

    DIRS_LIBINC=${DIRS_LIBINC}

does not seem to be setup correctly; "zlib.h" was not found.
This must be corrected if the (G)ZIP support is to be enabled.
Either fix the pathname or disable the (G)ZIP support.

EOF
        }
        test $SRCDIR_IS_LIBTIFF = yes \
          || test -d "${DIR_GZLIB:-/dev/null/no-such-file}" || {
            cat<<EOF

The libgz library directory, "${DIR_GZLIB}", does not seem to exist.
This must be corrected if the ZIP support is to be enabled.
Either fix the pathname or disable the ZIP support.

EOF
        }
    fi
}

if [ $NONINTERACTIVE = no ] ; then
    ok=skip
    while [ "$ok" != y ] && [ "$ok" != yes ]; do
        if [ "$ok" != skip ]; then
            for i in 1 2 3 4 5 6; do
                promptForParameter $i;
            done
        fi
        printConfig; prompt "Are these ok [yes]?"; read ok
        test -z "$ok" && ok=yes
        case "$ok" in
        [1-9]|1[0-7])   promptForParameter $ok;;
        [yY]*|[nN]*)    continue;;
        ?*)
            echo ""
            echo "\"y\", \"yes\", or <RETURN> accepts the displayed parameters."
            echo "A number lets you change the numbered parameter."
            echo ""
            ;;
        esac
        ok=skip
    done
    checkJPEG
    checkZIP
else
    checkJPEG
    checkZIP
fi

case $MANSCHEME in
*-source-*)     MANAPPS=man1 MANLIB=man3;;
*-nroff-*)      MANAPPS=cat1 MANLIB=cat3;;
esac
case $MANSCHEME in
*-strip)        MANSEDLOCAL="-e s/3T/3/g";;
*)              MANSEDLOCAL="";;
esac
case $MANSCHEME in
*-source-*)     MANCVT='${MANSED} $? >$@';;
*-nroff-gzip-*) MANCVT='${MANSED} $? | nroff -man | gzip > $@';;
*-nroff-pack-*) MANCVT='${MANSED} $? | nroff -man | pack > $@';;
*-nroff-com*-*) MANCVT='${MANSED} $? | nroff -man | compress > $@';;
*-nroff-cat-*)  MANCVT='${MANSED} $? | nroff -man > $@';;
esac
case $MANSCHEME in
*-0|*-0.gz|*-0.Z|*-gz|*-Z|*-z)
    suf=`echo $MANSCHEME | sed 's/.*-/./'`
    A='`echo $$i | sed' B='`'           # workaround shell bugs
    MANAPPNAME="$A s/\\\\.1\$\$/$suf/$B"
    MANLIBNAME="$A s/\\\\.3t\$\$/$suf/$B"
    ;;
*-strip)
    MANAPPNAME='$$i'
    MANLIBNAME='`echo $$i | sed s/\\.3t$$/.3/`'
    ;;
*)
    MANAPPNAME='$$i' MANLIBNAME='$$i'
    ;;
esac

if [ "${JPEG}" = yes ]; then
    test -z "${CONF_JPEG-}"     && CONF_JPEG="-DJPEG_SUPPORT"
    if test -z "${LIBJPEG-}" ; then
      LIBJPEG="-ljpeg"
      test -z "${DIR_JPEGLIB-}" || LIBJPEG="-L${DIR_JPEGLIB} ${LIBJPEG}"
    fi
else
    CONF_JPEG=
    LIBJPEG=
fi
if [ "${ZIP}" = yes ]; then
    test -z "${CONF_ZIP-}"      && CONF_ZIP="-DZIP_SUPPORT"
    if test -z "${LIBGZ-}" ; then
      LIBGZ="-lz"
      test -z "${DIR_GZLIB-}" || LIBGZ="-L${DIR_GZLIB} ${LIBGZ}"
    fi
else
    CONF_ZIP=
    LIBGZ=
fi

Note ""

#
# Fixup a list of potentially relative pathnames so
# that they work when used in a subdirectory.  The
# string sent to stdout has no extraneous spaces so
# it can be used, for example, in building pathnames.
#
# NB: There's an extra echo done here so we get a
#     \n-terminated string passed to sed.
#
relativize()
{
    echo `if [ $SRCDIR_IS_LIBTIFF = no ]; then
        (for i do
            case "$i" in
            /*|-l*)     echo "$i" ;;
            -[LR])      ;;                              # XXX???
            -[LR]/*)    echo "$i" ;;
            -L*)        echo "$i" | sed 's;^-L;-L../;' ;;
            -R*)        echo "$i" | sed 's;^-R;-R../;' ;;
            *)          echo "../$i" ;;
            esac
        done) | tr '\012' ' '
    else
        echo "$@"
    fi` | sed -e 's;[ ][ ]*$;;' -e 's;/[.]$;;'
}
#
# Generate a list of compiler include options,
# prepending ``../'' to any relative pathnames.
#
makeIncArgs()
{
    (for i do
        case "$i" in
        /*)  echo "-I$i" ;;
        *)
            if [ $SRCDIR_IS_LIBTIFF = yes ]; then
                echo "-I$i" 
            else
                echo "-I../$i" 
            fi ;;
        esac
    done) | tr '\012' ' '
}

#
# Setup parameters needed below.
#
if [ $SRCDIR_IS_LIBTIFF = yes ]; then
    CONFIGDIR="."
    LIBSRCDIR="${SRCDIR}"
else
    CONFIGDIR=".."
    LIBSRCDIR=`relativize ${SRCDIR}`/libtiff
fi

# NB: these should be sorted alphabetically
cat>>confsed<<EOF
s;@AR@;${AR};g
s;@AROPTS@;${AROPTS};g
s;@CONFIGDIR@;${CONFIGDIR};g
s;@CCOMPILER@;${CCOMPILER};g
s;@CHMOD@;${CHMOD};g
s;@CONF_JPEG@;${CONF_JPEG};g
s;@CONF_ZIP@;${CONF_ZIP};g
s;@COPT_LIBINC@;`makeIncArgs ${DIRS_LIBINC}`;g
s;@DATE@;${DATE};g
s;@DEPEND_JPEGLIB@;${CONF_JPEG:+`findHeader jpeglib.h` `findHeader jerror.h`};g
s;@DEPEND_ZLIB@;${CONF_ZIP:+`findHeader zlib.h`};g
s;@DIR_BIN@;${DIR_BIN};g
s;@DIR_JPEGLIB@;`relativize ${DIR_JPEGLIB}`;g
s;@DIR_GZLIB@;`relativize ${DIR_GZLIB}`;g
s;@DIR_HTML@;${DIR_HTML};g
s;@DIR_INC@;${DIR_INC};g
s;@DIR_LIB@;${DIR_LIB};g
s;@DIR_MAN@;${DIR_MAN};g
s;@DIRS_LIBINC@;`relativize ${DIRS_LIBINC}`;g
s;@DIST_POINT@;${DIST_POINT};g
s;@DIST_MAJOR@;${DIST_MAJOR};g
s;@DIST_MINOR@;${DIST_MINOR};g
s;@DSO@;${DSO};g
s;@DSOSUF@;${DSOSUF};g
s;@DSOSUF_VERSION@;${DSOSUF_VERSION};g
s;@ENVOPTS@;${ENVOPTS};g
s;@FILLORDER@;${FILLORDER};g
s;@GCOPTS@;${GCOPTS};g
s;@HTML@;${HTML};g
s;@INSTALL@;${INSTALL};g
s;@LIBJPEG@;`relativize ${LIBJPEG}`;g
s;@LIBGL@;${LIBGL};g
s;@LIBGZ@;`relativize ${LIBGZ}`;g
s;@LIBSRCDIR@;${LIBSRCDIR};g
s;@LIBIMAGE@;${LIBIMAGE};g
s;@LIBCOPTS@;${LIBCOPTS};g
s;@LIBPORT@;${LIBPORT};g
s;@LN@;${LN};g
s;@LN_S@;${LN_S};g
s;@MACHDEPLIBS@;${MACHDEPLIBS};g
s;@MANAPPS@;${MANAPPS};g
s;@MANAPPNAME@;${MANAPPNAME};g
s;@MANLIBNAME@;${MANLIBNAME};g
s;@MANCVT@;${MANCVT};g
s;@MANSEDLOCAL@;${MANSEDLOCAL};g
s;@MANLIB@;${MANLIB};g
s;@MV_F@;${MV_F};g
s;@OPTIMIZER@;${OPTIMIZER};g
s;@PORT@;${PORT};g
s;@PORTFUNCS@;${PORTFUNCS};g
s;@RANLIB@;${RANLIB};g
s;@SCRIPT_SH@;${SCRIPT_SH};g
s;@SED@;${SED};g
s;@SETMAKE@;${SETMAKE};g
s;@SRCDIR@;${SRCDIR};g
s;@RELSRCDIR@;`relativize ${SRCDIR}`;g
s;@STRIP@;${STRIP};g
s;@TARGET@;${TARGET};g
s;@TIFFLIBREF@;${TIFFLIBREF};g
s;@VERSION@;${VERSION};g
s;@RELEASE@;${RELEASE};g
s;@VERSIONFILE@;`relativize ${VERSIONFILE}`;g
s;@WARNING@;Warning, this file was automatically created by the TIFF configure script;g
EOF

SedConfigFiles()
{
    for F do
        test -f $SRCDIR/$F.in || {
            bitch "$SRCDIR/$F.in is missing; this should be part of the distribution."
            boom
        }
        dir=`echo $F | $SED 's;/[^/]*$;;'`
        if [ $dir != $F ] && [ ! -d $dir ]; then
            Note "Creating $dir directory"
            mkdir $dir
        fi
        suffix=`echo $F | $SED 's/.*\.//'`
        if [ "$suffix" = h ]; then
            #
            # Compare old and new versions so that include files
            # are only updated when something has changed--this
            # saves time for subsequent makes.  Note we screen
            # out use of @DATE@ 'cuz otherwise that'll mess up
            # the comparison (this assumes dates are used in lines
            # of the form DATE: @DATE@).
            #
            $RM $F.new; $SED -f confsed $SRCDIR/$F.in > $F.new
            $RM confx; $SED '/DATE:/d' $F.new >confx
            $RM confy; $SED '/DATE:/d' $F >confy 2>/dev/null
            if cmp -s confx confy >/dev/null 2>&1; then
                $RM $F.new
            else
                Note "Creating $F from $SRCDIR/$F.in"
                $RM $F; mv $F.new $F; $CHMOD 444 $F
            fi
        else
            Note "Creating $F from $SRCDIR/$F.in"
            if $SED -f confsed $SRCDIR/$F.in >$F.new; then
                $RM $F; mv $F.new $F; $CHMOD 444 $F
            else
                cat 1>&2 <<EOF
Help, there was a problem crafting $F from $F.in.
The command:

    $SED -f confsed $SRCDIR/$F.in >$F.new

failed.  Aborting without cleaning up files so you can take a look...
EOF
                exit 1
            fi
        fi
    done
}

#
# port/install.sh is the SGI install program emulator script.
#
CONF_FILES="Makefile"
if [ $SRCDIR_IS_LIBTIFF != yes ] ; then
    CONF_FILES="$CONF_FILES
        libtiff/Makefile
        man/Makefile
        tools/Makefile
        port/install.sh
        "
    test $HTML = yes &&         CONF_FILES="$CONF_FILES html/Makefile"
    test $PORT = yes &&         CONF_FILES="$CONF_FILES port/Makefile"
fi
SedConfigFiles $CONF_FILES

Note "Done."

$RM $JUNK
exit 0