path: root/usr.sbin/httpd/src/Configure

#!/bin/sh
## ====================================================================
## Copyright (c) 1995-1999 The Apache Group.  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. All advertising materials mentioning features or use of this
##    software must display the following acknowledgment:
##    "This product includes software developed by the Apache Group
##    for use in the Apache HTTP server project (http://www.apache.org/)."
##
## 4. The names "Apache Server" and "Apache Group" must not be used to
##    endorse or promote products derived from this software without
##    prior written permission. For written permission, please contact
##    apache@apache.org.
##
## 5. Products derived from this software may not be called "Apache"
##    nor may "Apache" appear in their names without prior written
##    permission of the Apache Group.
##
## 6. Redistributions of any form whatsoever must retain the following
##    acknowledgment:
##    "This product includes software developed by the Apache Group
##    for use in the Apache HTTP server project (http://www.apache.org/)."
##
## THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
## EXPRESSED 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 APACHE GROUP OR
## ITS 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.
## ====================================================================
##
## This software consists of voluntary contributions made by many
## individuals on behalf of the Apache Group and was originally based
## on public domain software written at the National Center for
## Supercomputing Applications, University of Illinois, Urbana-Champaign.
## For more information on the Apache Group and the Apache HTTP server
## project, please see <http://www.apache.org/>.

# Uses 6 supplemental scripts located in ./helpers:
#	CutRule: Determines the value for a specified Rule
#	GuessOS: Uses uname to determine OS/platform
#	PrintPath: generic "type" or "whence" replacement
#	TestCompile: Can check for libs and if $(CC) is ANSI
#	 (i.e., a simple "sanity check")
#	mfhead:
#	fp2rp:
#	slo.sh:

exitcode=0
trap 'rm -f $tmpfile $tmpfile2 $tmpfile3 $tmpconfig $awkfile; exit $exitcode' 0 1 2 3 15

####################################################################
## Set up some defaults
##
file=Configuration
tmpfile=htconf.$$
tmpfile2=$tmpfile.2
tmpfile3=$tmpfile.3
awkfile=$tmpfile.4
tmpconfig=$tmpfile.5
SUBDIRS="ap main modules"

####################################################################
## Now handle any arguments, which, for now, is -file
## to select an alternate Configuration file
##
while [ "x$1" != "x" ]; do
  if [ "x$1" = "x-file" ] ; then
    shift 1; file=$1; shift 1
    if [ ! -r $file ]; then
      echo "$file does not exist or is not readable."
      exitcode=1
      exit 1
    fi
  elif [ "x$1" = "x-make" ] ; then
    shift 1; makefile_tmpl=$1; shift 1
    if [ ! -r $makefile_tmpl ]; then
      echo "$makefile_tmpl does not exist or is not readable."
      exit 1
    fi
  else
    echo "ERROR: Bad command line option '$1'"
    echo "  Please read the file INSTALL."
    exit 1
  fi
done
if [ ! -r $file ]; then
  echo "Can't see or read \"$file\""
  echo "Please copy Configuration.tmpl to $file, edit it for your platform,"
  echo "and re-run $0 again."
  exitcode=1
  exit 1
fi

####################################################################
## Now see if Configuration.tmpl is more recent than $file. If
## so, then we complain and bail out
##
if ls -lt Configuration.tmpl $file | head -1 | \
  grep 'Configuration.tmpl' > /dev/null
then
  echo "Configuration.tmpl is more recent than $file;"
  echo "Make sure that $file is valid and, if it is, simply"
  echo "'touch $file' and re-run $0 again."
  exitcode=1
  exit 1
fi

echo "Using config file: $file"

####################################################################
## From the Configuration file, create a "cleaned-up" version
## that's easy to scan
##

# Strip comments and blank lines, remove whitespace around
# "=" assignments, change Rules to comments and then remove whitespace
# before Module declarations
sed 's/#.*//' $file | \
 sed '/^[ 	]*$/d' | \
 sed 's/[ 	]*$//' | \
 sed 's/[ 	]*=[ 	]*/=/' | \
 sed '/^Rule[ 	]*/d' | \
 sed 's/^[ 	]*AddModule/AddModule/' | \
 sed 's/^[ 	]*%AddModule/%AddModule/' | \
 sed 's/^[ 	]*SharedModule/SharedModule/' | \
 sed 's/^[ 	]*Module/Module/' | \
 sed 's/^[ 	]*%Module/%Module/' > $tmpfile

# Determine if shared objects are used
using_shlib=`grep  '^SharedModule' $tmpfile >/dev/null && echo 1`

# But perhaps later via apxs when just mod_so is compiled in!
if [ "x$using_shlib" = "x" ]; then
    using_shlib=`grep  '^AddModule modules/standard/mod_so.o' $tmpfile >/dev/null && echo 1`
fi

# Only "assignment" ("=") statements and Module lines
# should be left at this point. If there is other stuff
# we bail out
if egrep -v '^%?Module[ 	]+[A-Za-z0-9_]+[ 	]+[^ 	]+$' $tmpfile \
 | egrep -v '^%?AddModule[ 	]+[^ 	]+$' \
 | egrep -v '^SharedModule[ 	]+[^ 	]+$' \
 | grep -v = > /dev/null
then
  echo "Syntax error --- The configuration file is used only to"
  echo "define the list of included modules or to set Makefile"
  echo "options or Configure rules, and I don't see that at all:"
  egrep -v '^%?Module[ 	]+[A-Za-z0-9_]+[ 	]+[^ 	]+$' $tmpfile \
   | egrep -v '^%?AddModule[ 	]+[^ 	]+$'  \
   | egrep -v '^%?SharedModule[ 	]+[^ 	]+$'  \
   | grep -v =
  exitcode=1
  exit 1
fi

####################################################################
## If we find the directory /usr/local/etc/httpd and there is
## no HTTPD_ROOT flag set in the Configuration file we assume
## that the user was using the old default root directory
## and issue a notice about it.
##
if [ $file != "Configuration.apaci" ]
then
  if [ -d /usr/local/etc/httpd/ ]
  then
    if egrep '^EXTRA_CFLAGS.*HTTPD_ROOT' $file >/dev/null
    then
      :
    else
      echo " | Please note that the default httpd root directory has changed"
      echo " | from '/usr/local/etc/httpd/' to '/usr/local/apache/.'"
      echo " | You may add '-DHTTPD_ROOT=\\\"/usr/local/etc/httpd\\\"' to EXTRA_CFLAGS"
      echo " | in your Configuration file (and re-run Configure) or start"
      echo " | httpd with the option '-d /usr/local/etc/httpd' if you still"
      echo " | want to use the old root directory for your server."
    fi
  fi
fi

####################################################################
## Start creating the Makefile. We add some comments and
## then fold in the modules that were included in Configuration
##
echo "Creating Makefile"
./helpers/mfhead . $file > Makefile

####################################################################
## Now we create a stub file, called Makefile.config, which
## just includes those assignments (eg: CC=gcc) in Configuration
##
awk >Makefile.config <$tmpfile '
    BEGIN {
	print "##"
	print "##  Inherited Makefile options from Configure script"
	print "##  (Begin of automatically generated section)"
	print "##"
	print "SRCDIR=."
    } 
    /\=/ { print } 
    '

####################################################################
## Extract the rules.
##
RULE_WANTHSREGEX=`./helpers/CutRule WANTHSREGEX $file`
RULE_STATUS=`./helpers/CutRule STATUS $file`
RULE_SOCKS4=`./helpers/CutRule SOCKS4 $file`
RULE_SOCKS5=`./helpers/CutRule SOCKS5 $file`
RULE_IRIXNIS=`./helpers/CutRule IRIXNIS $file`
RULE_IRIXN32=`./helpers/CutRule IRIXN32 $file`
RULE_PARANOID=`./helpers/CutRule PARANOID $file`
RULE_EAPI=`./helpers/CutRule EAPI $file`
RULE_SHARED_CORE=`./helpers/CutRule SHARED_CORE $file`
RULE_SHARED_CHAIN=`./helpers/CutRule SHARED_CHAIN $file`

####################################################################
## Rule SHARED_CORE implies required DSO support
##
if [ "$RULE_SHARED_CORE" = "yes" ]; then
	using_shlib=1
fi

####################################################################
## Preset some "constants";
## can be overridden on a per-platform basis below.
##
DBM_LIB="-ldbm"
DB_LIB="-ldb"
SHELL="/bin/sh"
SUBTARGET="target_static"
SHLIB_SUFFIX_NAME=""
SHLIB_SUFFIX_LIST=""
CAT="cat"

####################################################################
## Now we determine the OS/Platform automagically, thanks to
## GuessOS, a home-brewed OS-determiner ala config.guess
##
## We adjust CFLAGS, LIBS, LDFLAGS and INCLUDES (and other Makefile
## options) as required. Setting CC and OPTIM here has no effect
## if they were set in Configure.
##
## Also, we set DEF_WANTHSREGEX and to the appropriate
## value for each platform.
##
## As more PLATFORMs are added to Configuration.tmpl, be sure to
## add the required lines below.
##
PLAT=`./helpers/GuessOS`
SHELL="/bin/sh"
OSDIR="os/unix"

case "$PLAT" in
    *mint)
	OS="MiNT"
	CFLAGS="-DMINT"
	LIBS="$LIBS -lportlib -lsocket"
	DEF_WANTHSREGEX=yes
	;;
    *MPE/iX*)
	OS='MPE/iX'
	CFLAGS="$CFLAGS -DMPE -D_POSIX_SOURCE -D_SOCKET_SOURCE"
	LIBS="$LIBS -lsocket -lsvipc"
	LDFLAGS="$LDFLAGS -Xlinker \"-WL,cap=ia,ba,ph,pm;nmstack=1024000\""
	CAT="/bin/cat" # built-in cat is badly broken for stdin redirection
	;;
    *-apple-aux3*)
	OS='A/UX 3.1.x'
	CFLAGS="$CFLAGS -DAUX3 -D_POSIX_SOURCE"
	LIBS="$LIBS -lposix -lbsd"
	LDFLAGS="$LDFLAGS -s"
	DEF_WANTHSREGEX=no
	;;
    i386-ibm-aix*)
	OS='IBM AIX PS/2'
	CFLAGS="$CFLAGS -DAIX=1 -U__STR__ -DUSEBCOPY"
	DEF_WANTHSREGEX=no
	;;
    *-ibm-aix[1-2].*)
	OS='IBM AIX 1.x/2.x'
	CFLAGS="$CFLAGS -DAIX=1 -DNEED_RLIM_T -U__STR__"
	;;
    *-ibm-aix3.*)
	OS='IBM AIX 3.x'
	CFLAGS="$CFLAGS -DAIX=30 -DNEED_RLIM_T -U__STR__"
	;;
    *-ibm-aix4.1)
	OS='IBM AIX 4.1'
	CFLAGS="$CFLAGS -DAIX=41 -DNEED_RLIM_T -U__STR__"
	;;
    *-ibm-aix4.2)
	OS='IBM AIX 4.2'
	CFLAGS="$CFLAGS -DAIX=42 -U__STR__"
	LDFLAGS="$LDFLAGS -lm"
	;;
    *-ibm-aix4.3)
	OS='IBM AIX 4.3'
	CFLAGS="$CFLAGS -DAIX=43 -U__STR__"
	LDFLAGS="$LDFLAGS -lm"
	;;
    *-ibm-aix*)
	OS='IBM AIX'
	CFLAGS="$CFLAGS -DAIX=1 -U__STR__"
	LDFLAGS="$LDFLAGS -lm"
	;;
    *-apollo-*)
	OS='Apollo Domain'
	CFLAGS="$CFLAGS -DAPOLLO"
	;;
    *-dg-dgux*)
	OS='DG/UX 5.4'
	CFLAGS="$CFLAGS -DDGUX"
	DEF_WANTHSREGEX=yes
	;;
    *OS/2*)
	OSDIR="os/os2"
	DEF_WANTHSREGEX=yes
	OS='EMX OS/2'
	CFLAGS="$CFLAGS -DOS2 -Zbsd-signals -Zbin-files -DTCPIPV4 -g"
	LDFLAGS="$LDFLAGS -Zexe"
	LIBS="$LIBS -lsocket -lufc -lbsd"
	DBM_LIB="-lgdbm"
	SHELL=sh
	;;
    *-hi-hiux)
	OS='HI-UX'
	CFLAGS="$CFLAGS -DHIUX"
	;;
    *-hp-hpux11.*)
	OS='HP-UX 11'
	CFLAGS="$CFLAGS -DHPUX11"
	RANLIB="/bin/true"
	LIBS="$LIBS -lm -lpthread"
	DEF_WANTHSREGEX=yes
	;;
    *-hp-hpux10.*)
	OS='HP-UX 10'
	CFLAGS="$CFLAGS -DHPUX10"
	RANLIB="/bin/true"
 	case "$PLAT" in
 	  *-hp-hpux10.01)
	       # We know this is a problem in 10.01.
	       # Not a problem in 10.20.  Otherwise, who knows?
	       CFLAGS="$CFLAGS -DSELECT_NEEDS_CAST"
	       ;;	     
 	esac
	DEF_WANTHSREGEX=yes
	;;
    *-hp-hpux*)
	OS='HP-UX'
	CFLAGS="$CFLAGS -DHPUX"
	RANLIB="/bin/true"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lm"
	;;
    *-sgi-irix64)
	# Note: We'd like to see patches to compile 64-bit, but for now...
	echo "You are running 64-bit Irix. For now, we will compile 32-bit"
	echo "but if you would care to port to 64-bit, send us the patches."
	DEF_WANTHSREGEX=yes
	DBM_LIB=""
	if [ "$RULE_IRIXNIS" = "yes" ]; then
	    OS='SGI IRIX-64 w/NIS'
	    CFLAGS="$CFLAGS -DIRIX"
	    LIBS="$LIBS -lsun"
	else
	    OS='SGI IRIX-64'
	    CFLAGS="$CFLAGS -DIRIX"
	fi
	;;
    *-sgi-irix32)
	DEF_WANTHSREGEX=yes
	DBM_LIB=""
	if [ "$RULE_IRIXN32" = "yes" ]; then
	    if [ "$RULE_IRIXNIS" = "yes" ]; then
		OS='SGI IRIX-32 w/NIS'
	    else
		OS='SGI IRIX-32'
	    fi
	else
	    if [ "$RULE_IRIXNIS" = "yes" ]; then
		OS='SGI IRIX w/NIS'
	    else
		OS='SGI IRIX'
	    fi
	fi
	CC='cc'
	CFLAGS="$CFLAGS -DIRIX"
	;;
    *-sgi-irix)
	DEF_WANTHSREGEX=yes
	DBM_LIB=""
	if [ "$RULE_IRIXNIS" = "yes" ]; then
	    OS='SGI IRIX w/NIS'
	    CFLAGS="$CFLAGS -DIRIX"
	    LIBS="$LIBS -lsun"
	else
	    OS='SGI IRIX'
	    CFLAGS="$CFLAGS -DIRIX"
	fi
	;;
    *-linux2)
	DEF_WANTHSREGEX=yes
	OS='Linux'
	CFLAGS="$CFLAGS -DLINUX=2"
	LIBS="$LIBS -lm"
	;;
    *-linux1)
	DEF_WANTHSREGEX=yes
	OS='Linux'
	CFLAGS="$CFLAGS -DLINUX=1"
	;;
    *-lynx-lynxos)
	OS='LynxOS 2.x'
	CFLAGS="$CFLAGS -D__NO_INCLUDE_WARN__ -DLYNXOS"
	LIBS="$LIBS -lbsd -lcrypt"
	DEF_WANTHSREGEX=yes
	;;
    *486-*-bsdi*)
	OS='BSDI w/486'
	CFLAGS="$CFLAGS -m486"
	DBM_LIB=""
	DB_LIB=""
	;;
    *-bsdi*)
	OS='BSDI'
	DBM_LIB=""
	DB_LIB=""
	;;
    *-netbsd*)
	OS='NetBSD'
	CFLAGS="$CFLAGS -DNETBSD"
	LIBS="$LIBS -lcrypt"
	DBM_LIB=""
	DB_LIB=""
	DEF_WANTHSREGEX=no
	;;
    *-freebsd*)
    	PLATOSVERS=`echo $PLAT | sed 's/^.*freebsd//'`
	OS="FreeBSD $PLATOSVERS"
	case "$PLATOSVERS" in
	    [23]*)
		DEF_WANTHSREGEX=no
		CFLAGS="$CFLAGS -funsigned-char"
		;;
	esac
	LIBS="$LIBS -lcrypt"
	DBM_LIB=""
	DB_LIB=""
	;;
    *-openbsd*)
	OS='OpenBSD'
	DBM_LIB=""
	DB_LIB=""
	DEF_WANTHSREGEX=no
	;;
    *-next-nextstep*)
	OS='NeXTStep'
	OPTIM='-O'
	CFLAGS="$CFLAGS -DNEXT"
	DEF_WANTHSREGEX=yes
	;;
    *-next-openstep*)
	OS='OpenStep/Mach'
	CC='cc'
	OPTIM='-O'
	CFLAGS="$CFLAGS -DNEXT"
	CFLAGS_SHLIB='-dynamic -fno-common'
	LD_SHLIB='cc'
	LDFLAGS_SHLIB='-dynamiclib -undefined warning'
	DEF_WANTHSREGEX=yes
	;;
    *-apple-rhapsody*)
	OS='Mac OS X Server'
	CFLAGS="$CFLAGS -DRHAPSODY"
	DEF_WANTHSREGEX=yes
	;;
    *-dec-osf*)
	OS='DEC OSF/1'
	CFLAGS="$CFLAGS -DOSF1"
	LIBS="$LIBS -lm"
	;;
    *-qnx)
	OS='QNX'
	CFLAGS="$CFLAGS -DQNX"
	LIBS="$LIBS -N128k -lsocket -lunix"
	DEF_WANTHSREGEX=yes
	;;
    *-qnx32)
        CC='cc -F'
	OS='QNX32'
	CFLAGS="$CFLAGS -DQNX -mf -3"
	LIBS="$LIBS -N128k -lsocket -lunix"
	DEF_WANTHSREGEX=yes
	;;
    *-isc4*)
	OS='ISC 4'
	CC='gcc'
	CFLAGS="$CFLAGS -posix -DISC"
	LDFLAGS="$LDFLAGS -posix"
	LIBS="$LIBS -linet"
	DEF_WANTHSREGEX=yes
	;;
    *-sco3*)
	OS='SCO 3'
	CFLAGS="$CFLAGS -DSCO -Oacgiltz"
	LIBS="$LIBS -lPW -lsocket -lmalloc -lcrypt_i"
	DEF_WANTHSREGEX=yes
	;;
    *-sco5*)
	OS='SCO 5'
	CFLAGS="$CFLAGS -DSCO5"
	LIBS="$LIBS -lsocket -lmalloc -lprot -ltinfo -lx -lm"
	DEF_WANTHSREGEX=no
	;;
    *-sco_sv*|*-SCO_SV*)
	OS='SCO SV'
	CFLAGS="$CFLAGS -DSCO"
	LIBS="$LIBS -lPW -lsocket -lmalloc -lcrypt_i"
	DEF_WANTHSREGEX=yes
	;;
    *-solaris2*)
    	PLATOSVERS=`echo $PLAT | sed 's/^.*solaris2.//'`
	OS="Solaris $PLATOSVERS"
	CFLAGS="$CFLAGS -DSOLARIS2=$PLATOSVERS"
	LIBS="$LIBS -lsocket -lnsl"
	DBM_LIB=""
	case "$PLATOSVERS" in
	    2[01234]*)
		DEF_WANTHSREGEX=yes
		;;
	    *)
		DEF_WANTHSREGEX=no
		;;
	esac
	;;
    *-sunos4*)
	OS='SunOS 4'
	CFLAGS="$CFLAGS -DSUNOS4 -DUSEBCOPY"
	DEF_WANTHSREGEX=yes
	;;
    *-unixware1)
	DEF_WANTHSREGEX=yes
	OS='UnixWare 1.x'
	CFLAGS="$CFLAGS -DUW=100"
	LIBS="$LIBS -lsocket -lnsl -lcrypt"
	;;
    *-unixware2)
	DEF_WANTHSREGEX=yes
	OS='UnixWare 2.x'
	CFLAGS="$CFLAGS -DUW=200"
	LIBS="$LIBS -lsocket -lnsl -lcrypt -lgen"
	;;
    *-unixware211)
	OS='UnixWare 2.1.1'
	CFLAGS="$CFLAGS -DUW=211"
	LIBS="$LIBS -lsocket -lnsl -lcrypt -lgen"
	;;
    *-unixware212)
	OS='UnixWare 2.1.2'
	CFLAGS="$CFLAGS -DUW=212"
	LIBS="$LIBS -lsocket -lnsl -lcrypt -lgen"
	DBM_LIB=""
	;;
    *-unixware7)
	OS='UnixWare 7'
	CFLAGS="$CFLAGS -DUW=700"
	LIBS="$LIBS -lsocket -lnsl -lcrypt -lgen"
	DBM_LIB=""
	;;
    maxion-*-sysv4*)
    	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc -lgen"
	;;
    *-*-powermax*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lgen"
	LD_SHLIB='cc'
	LDFLAGS_SHLIB="-Zlink=so"
	LDFLAGS_SHLIB_EXPORT="-Zlink=dynamic -Wl,-Bexport"
	CFLAGS_SHLIB='-Zpic'
	;;
    TPF)
       OS='TPF'
       OSDIR='os/tpf'
       CC='c89'
       CFLAGS="$CFLAGS -DTPF -DCHARSET_EBCDIC -D_POSIX_SOURCE"
       DEF_WANTHSREGEX=yes
       LIBS="$LIBS"
       SUBTARGET="target_compile_only"
       ;;
    BS2000*-siemens-sysv4*)
	OS='BS2000'
	OSDIR='os/bs2000'
	CC='c89 -XLLML -XLLMK'
	CFLAGS="$CFLAGS -DCHARSET_EBCDIC -DSVR4 -D_XPG_IV"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc"
	DBM_LIB=""
	;;
    *-siemens-sysv4*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4 -D_XPG_IV -DHAS_DLFCN -DUSE_MMAP_FILES -DUSE_SYSVSEM_SERIALIZED_ACCEPT -DNEED_UNION_SEMUN"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc"
	DBM_LIB=""
	;;
    pyramid-pyramid-svr4)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4 -DNO_LONG_DOUBLE"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc"
	;;
    DS/90\ 7000-*-sysv4*)
	OS='UXP/DS'
	CFLAGS="$CFLAGS -DUXPDS"
	LIBS="$LIBS -lsocket -lnsl"
	DEF_WANTHSREGEX=yes
	;;
    *-tandem-sysv4*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	LIBS="$LIBS -lsocket -lnsl"
	DEF_WANTHSREGEX=yes
	;;
    *-ncr-sysv4)
	OS='NCR MP/RAS'
	CFLAGS="$CFLAGS -DSVR4 -DMPRAS"
	LIBS="$LIBS -lsocket -lnsl -lc -L/usr/ucblib -lucb"
	DEF_WANTHSREGEX=yes
	;;
    *-sysv4*)
	OS='SVR4'
	CFLAGS="$CFLAGS -DSVR4"
	LIBS="$LIBS -lsocket -lnsl -lc"
	;;
    88k-encore-sysv4)
	OS='Encore UMAX V'
	CFLAGS="$CFLAGS -DSVR4 -DENCORE"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lPW"
	;;
    *-uts*)
	OS='Amdahl UTS'
	CFLAGS="$CFLAGS -Xa -eft -DUTS21 -DUSEBCOPY"
	LIBS="$LIBS -lsocket -lbsd -la"
	DEF_WANTHSREGEX=yes
	;;
    *-ultrix)
	OS='ULTRIX'
	CFLAGS="-DULTRIX"
	DEF_WANTHSREGEX=yes
	SHELL="/bin/sh5"
	;;
    *powerpc-tenon-machten*)
	OS='MachTen PPC'
	LDFLAGS="$LDFLAGS -Xlstack=0x14000 -Xldelcsect"
	;;
    *-machten*)
	OS='MachTen 68K'
	LDFLAGS="$LDFLAGS -stack 0x14000"
	DEF_WANTHSREGEX=yes
	;;
    *convex-v11*)
	OS='CONVEXOS11'
	CFLAGS="$CFLAGS -ext -DCONVEXOS11"
	OPTIM="-O1" # scalar optimization only
	CC='cc'
	DEF_WANTHSREGEX=yes
	;;
    i860-intel-osf1)
	DEF_WANTHSREGEX=yes
	OS='Paragon OSF/1'
	CFLAGS="$CFLAGS -DPARAGON"
	;;
    *DYNIX*)
	DEF_WANTHSREGEX=yes
	OS='SEQUENT'
	CFLAGS="$CFLAGS -DSEQUENT"
	;;
    *NEWS-OS*)
	DEF_WANTHSREGEX=yes
	OS='SONY NEWS-OS'
	CFLAGS="$CFLAGS -DNEWSOS"
	;;
    *-riscix)
	OS='Acorn RISCix'
	CFLAGS="$CFLAGS -DRISCIX"
	OPTIM="-O"
	MAKE="make"
	DEF_WANTHSREGEX=yes
	;;
    *-BeOS*)
	OS='BeOS';
	CFLAGS="$CFLAGS -DBEOS"
	DEF_WANTHSREGEX=yes
	;;
    4850-*.*)
	OS='NCR MP/RAS'
	CFLAGS="$CFLAGS -DSVR4 -DMPRAS"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc -L/usr/ucblib -lucb"
	;;
    drs6000*)
	OS='DRS6000'
	CFLAGS="$CFLAGS -DSVR4"
	DEF_WANTHSREGEX=yes
	LIBS="$LIBS -lsocket -lnsl -lc -L/usr/ucblib -lucb"
	;;
    m88k-*-CX/SX|CYBER)
	OS='Cyberguard CX/SX'
	CFLAGS="$CFLAGS -D_CX_SX -Xa"
	DEF_WANTHSREGEX=yes
	CC='cc'
	RANLIB='true'
	;;
    *) # default: Catch systems we don't know about
	OS='Unknown and unsupported OS'
    	echo Sorry, but we cannot grok \"$PLAT\"
	echo uname -m
	uname -m
	echo uname -r
	uname -r
	echo uname -s
	uname -s
	echo uname -v
	uname -v
	echo uname -X
	uname -X
	echo Ideally, read the file PORTING, do what it says, and send the
	echo resulting patches to The Apache Group by filling out a report
	echo form at http://www.apache.org/bug_report.html. If you don\'t 
	echo wish to do the port yourself, please submit this output rather 
	echo than the patches. Thank you.
	echo
	echo Pressing on with the build process, but all bets are off.
	echo Do not be surprised if it fails. If it works, and even
	echo if it does not, please contact the above address.
	echo
	;;
esac

####################################################################
## set this if we haven't
##
if [ "x${MAKE}" = "x" ]; then
    MAKE='make'; export MAKE
fi

####################################################################
## Show user what OS we came up with
##
echo " + configured for $OS platform"
SUBDIRS="$OSDIR $SUBDIRS"

####################################################################
# Continue building the stub file
# Set variables as soon as possible so that TestCompile can use them
##
echo >>Makefile.config "OSDIR=\$(SRCDIR)/$OSDIR"
echo >>Makefile.config "INCDIR=\$(SRCDIR)/include"
echo >>Makefile.config "INCLUDES0=-I\$(OSDIR) -I\$(INCDIR)"
echo >>Makefile.config "SHELL=$SHELL"

####################################################################
## And adjust/override WANTHSREGEX as needed
##
if [ "$RULE_WANTHSREGEX" = "default" ]; then
	if [ "x$DEF_WANTHSREGEX" = "x" ]; then
		RULE_WANTHSREGEX=yes
	else
		RULE_WANTHSREGEX=$DEF_WANTHSREGEX
	fi
fi

####################################################################
## Now we determine the C-compiler and optimization level
## to use. Settings of CC and OPTIM in Configuration have
## the highest precedence; next comes any settings from
## the above "OS-specific" section. If still unset,
## then we look for a known compiler somewhere in PATH
##

# First, look for a CC=<whatever> setting in Configuration (recall, we
# copied these to Makefile.config)
#
# If $TCC is null, then no such line exists in Configuration
#
TCC=`egrep '^CC=' Makefile.config | tail -1 | awk -F= '{print $2}'`
if [ "x$TCC" = "x" ]; then
    if [ "x$CC" = "x" ]; then
	# At this point, CC is not set in Configuration or above, so we
	# try to find one
	for compilers in "gcc" "cc" "acc" "c89"
	do
	    lookedfor="$lookedfor $compilers"
	    if ./helpers/PrintPath -s $compilers; then
		COMPILER="$compilers"
		break
	    fi
	done
	if [ "x$COMPILER" = "x" ]; then
	    echo "Error: could not find any of these C compilers"
	    echo " anywhere in your PATH: $lookedfor"
	    echo "Configure terminated"
	    exitcode=1
	    exit 1
	fi
	CC=$COMPILER
    fi
    echo " + setting C compiler to $CC"
fi

####################################################################
## Write the value of $CC to Makefile.config... We only do this
## is not done already (ie: a 'CC=' line was in Configuration).
## If there was an entry for it, then set $CC for our own internal
## use.
##
if [ "x$TCC" = "x" ]; then
    echo "CC=$CC" >> Makefile.config
else
    CC=$TCC
fi

####################################################################
## Now check how we can _directly_ run the C pre-processor
##
TCPP=`egrep '^CPP=' Makefile.config | tail -1 | awk -F= '{print $2}'`
if [ "x$TCPP" != "x" ]; then
    CPP=`CC=$CC CPP=$TCPP ./helpers/findcpp.sh`
else
    CPP=`CC=$CC ./helpers/findcpp.sh`
fi
if [ "x$TCPP" = "x" ]; then
    echo "CPP=$CPP" >> Makefile.config
fi 
echo " + setting C pre-processor to $CPP"

####################################################################
## Now check for existance of non-standard system header files
## and start generation of the ap_config_auto.h header
##
AP_CONFIG_AUTO_H="include/ap_config_auto.h"
echo "/*" >$AP_CONFIG_AUTO_H
echo " *  ap_config_auto.h -- Automatically determined configuration stuff" >>$AP_CONFIG_AUTO_H
echo " *  THIS FILE WAS AUTOMATICALLY GENERATED - DO NOT EDIT!" >>$AP_CONFIG_AUTO_H
echo " */" >>$AP_CONFIG_AUTO_H
echo "" >>$AP_CONFIG_AUTO_H
echo "#ifndef AP_CONFIG_AUTO_H" >>$AP_CONFIG_AUTO_H
echo "#define AP_CONFIG_AUTO_H" >>$AP_CONFIG_AUTO_H

echo " + checking for system header files"
CHECK_FOR_HEADERS="dlfcn.h dl.h bstring.h crypt.h unistd.h sys/resource.h sys/select.h sys/processor.h"
for header in $CHECK_FOR_HEADERS; do
    echo "" >>$AP_CONFIG_AUTO_H
    echo "/* check: #include <$header> */" >>$AP_CONFIG_AUTO_H
    name="`echo $header | sed -e 's:/:_:g' -e 's:\.:_:g' | tr '[a-z]' '[A-Z]'`"
    CPP=$CPP ./helpers/checkheader.sh $header
    if [ $? -eq 0 ]; then
	echo "#ifndef HAVE_${name}" >>$AP_CONFIG_AUTO_H
	echo "#define HAVE_${name} 1" >>$AP_CONFIG_AUTO_H
	echo "#endif" >>$AP_CONFIG_AUTO_H
    else
	echo "#ifdef HAVE_${name}" >>$AP_CONFIG_AUTO_H
	echo "#undef HAVE_${name}" >>$AP_CONFIG_AUTO_H
	echo "#endif" >>$AP_CONFIG_AUTO_H
    fi
done

####################################################################
# Special AIX 4.x support: need to check for sys/processor.h
# to decide whether the Processor Binding can be used or not
case "$PLAT" in
    *-ibm-aix*)
	CPP=$CPP ./helpers/checkheader.sh sys/processor.h
	if [ $? -eq 0 ]; then
	    CFLAGS="$CFLAGS -DAIX_BIND_PROCESSOR"
	fi
	;;
esac

####################################################################
## Look for OPTIM and save for later
##
TOPTIM=`egrep '^OPTIM=' Makefile.config | tail -1 | awk -F= '{print $2}'`
TRANLIB=`egrep '^RANLIB=' Makefile.config | tail -1 | awk -F= '{print $2}'`
TTARGET=`egrep '^TARGET=' Makefile.config | tail -1 | awk -F= '{print $2}'`

####################################################################
## Check for user provided flags for shared object support
##
TLD_SHLIB=`egrep '^LD_SHLIB=' Makefile.config | tail -1 | awk -F= '{print $2}'`
TLDFLAGS_SHLIB=`egrep '^LDFLAGS_SHLIB=' Makefile.config | tail -1 | awk -F= '{print $2}'`
TLDFLAGS_SHLIB_EXPORT=`egrep '^LDFLAGS_SHLIB_EXPORT=' Makefile.config | tail -1 | awk -F= '{print $2}'`
TCFLAGS_SHLIB=`egrep '^CFLAGS_SHLIB=' Makefile.config | tail -1 | awk -F= '{print $2}'`

####################################################################
## Handle TARGET name
##
if [ "x$TTARGET" = "x" ]; then
    TARGET=httpd
    echo "TARGET=$TARGET" >> Makefile.config
else
    TARGET=$TTARGET
fi
if [ "x$TARGET" != "xhttpd" ]; then
    echo " + using custom target name: $TARGET"
    CFLAGS="$CFLAGS -DTARGET=\\\"$TARGET\\\""
fi

####################################################################
## We adjust now CFLAGS_SHLIB, LDFLAGS_SHLIB and LDFLAGS_SHLIB_EXPORT as
## required.  For more platforms just add the required lines below.
##
if [ "x$using_shlib" = "x1" ] ; then
    LD_SHLIB="ld"
    DEF_SHARED_CORE=no
    DEF_SHARED_CHAIN=no
    SHLIB_SUFFIX_NAME=so
    SHLIB_SUFFIX_DEPTH=all
    SHLIB_EXPORT_FILES=no
    case "$PLAT" in
	*-linux1)
	    CFLAGS_SHLIB="-fpic"
	    LDFLAGS_SHLIB="-Bshareable"
	    LDFLAGS_SHLIB_EXPORT="-rdynamic"
	    ;;
	*-linux2)
	    CFLAGS_SHLIB="-fpic"
	    LDFLAGS_SHLIB="-Bshareable"
	    LDFLAGS_SHLIB_EXPORT="-rdynamic"
	    SHLIB_SUFFIX_DEPTH=0
	    ;;
	*-freebsd2*)
	    CFLAGS_SHLIB="-fpic"
	    LDFLAGS_SHLIB="-Bshareable"
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=2
	    ;;
	*-freebsd3*)
	    CFLAGS_SHLIB="-fpic"
	    LDFLAGS_SHLIB="-Bshareable"
	    OBJFORMAT=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` 
	    if [ "x$OBJFORMAT" = "xelf" ]; then
		LDFLAGS_SHLIB_EXPORT="-Wl,-E"
		SHLIB_SUFFIX_DEPTH=0
	    else
		LDFLAGS_SHLIB_EXPORT=""
		SHLIB_SUFFIX_DEPTH=2
	    fi  
	    ;;
	*-openbsd*)
	    CFLAGS_SHLIB="-fPIC"
	    LDFLAGS_SHLIB="-Bforcearchive -Bshareable"
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=2
	    ;;
	alpha-*-netbsd*|mips-*-netbsd*|powerpc-*-netbsd*)
	    CFLAGS_SHLIB="-fpic -DPIC"
	    LDFLAGS_SHLIB="-shared"
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=2
	    ;;
	*-netbsd*)
	    CFLAGS_SHLIB="-fpic -DPIC"
	    LDFLAGS_SHLIB="-Bshareable"
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=2
	    ;;
	*-bsdi)
	    CFLAGS_SHLIB="-fPIC"
	    LDFLAGS_SHLIB="-shared"
	    LDFLAGS_SHLIB_EXPORT="-rdynamic"
	    ;;
	*-apple-rhapsody*)
	    LD_SHLIB="cc"
	    CFLAGS_SHLIB=""
	    LDFLAGS_SHLIB='$(EXTRA_LDFLAGS) -bundle -undefined suppress'
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=0
	    ;;
	*-solaris2*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="-KPIC" ;;
	    esac
	    LDFLAGS_SHLIB="-G"
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=1
	    ;;
	*-sunos4*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/acc|acc ) CFLAGS_SHLIB="-pic" ;;
	    esac
	    LDFLAGS_SHLIB="-assert pure-text"
	    LDFLAGS_SHLIB_EXPORT=""
	    ;;
	*-sgi-irix32)
	    case $CC in
		*/gcc|gcc )
		    CFLAGS_SHLIB="-fpic"
		    N32FLAG=""
		    ;;
		*/cc|cc )
		    CFLAGS_SHLIB="-KPIC"
		    N32FLAG="-n32"
		    ;;
	    esac
	    if [ "$RULE_IRIXN32" = "yes" ]; then
		LDFLAGS_SHLIB="$N32FLAG -shared"
	    else
		LDFLAGS_SHLIB="-shared"
	    fi
	    LDFLAGS_SHLIB_EXPORT=""
	    ;;
	*-sgi-irix64)
	    case $CC in
		*/gcc|gcc )
		    CFLAGS_SHLIB="-fpic"
		    N32FLAG=""
		    ;;
		*/cc|cc )
		    CFLAGS_SHLIB="-KPIC"
		    N32FLAG="-n32"
		    ;;
	    esac
	    if [ "$RULE_IRIXN32" = "yes" ]; then
		LDFLAGS_SHLIB="$N32FLAG -shared"
	    else
		LDFLAGS_SHLIB="-shared"
	    fi
	    LDFLAGS_SHLIB_EXPORT=""
	    ;;
	*-sgi-irix)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="-KPIC" ;;
	    esac
	    LDFLAGS_SHLIB="-shared"
	    LDFLAGS_SHLIB_EXPORT=""
	    ;;
	*-dec-osf*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="" ;;
	    esac
	    LDFLAGS_SHLIB="-shared -expect_unresolved '*' -s"
	    LDFLAGS_SHLIB_EXPORT=""
	    ;;
	*-unixware*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="-KPIC" ;;
	    esac
	    LDFLAGS_SHLIB="-Bdynamic -G"
	    LDFLAGS_SHLIB_EXPORT="-Wl,-Bexport"
	    ;;
	 *-sco5*)
	     case $CC in
		 */gcc*|gcc* ) CFLAGS_SHLIB="-fpic" ;;
		 */cc*|cc*   ) CFLAGS_SHLIB="-KPIC" ;;
	     esac
	     LDFLAGS_SHLIB="-G"
	     LDFLAGS_SHLIB_EXPORT="-Wl,-Bexport"
	     SHLIB_SUFFIX_DEPTH=1
	     ;;
	RM*-siemens-sysv4*)
	    # MIPS hosts can take advantage of the LDFLAGS_SHLIB_EXPORT switch
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="-KPIC" ;;
	    esac
	    LDFLAGS_SHLIB="-G"
	    LDFLAGS_SHLIB_EXPORT="-Wl,-Blargedynsym"
	    ;;
	*-siemens-sysv4*)
	    # Older SINIX machines must be linked as "shared core"-Apache
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="-KPIC" ;;
	    esac
	    LDFLAGS_SHLIB="-G"
	    LDFLAGS_SHLIB_EXPORT=""
	    SHLIB_SUFFIX_DEPTH=0
	    DEF_SHARED_CORE=yes
	    ;;
	*-sysv4*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="-KPIC" ;;
	    esac
	    LDFLAGS_SHLIB="-G"
	    LDFLAGS_SHLIB_EXPORT=""
	    DEF_SHARED_CORE=yes
	    ;;
	*-hp-hpux9.*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="+z" ;;
	    esac
	    LDFLAGS_SHLIB="-b"
	    LDFLAGS_SHLIB_EXPORT="-Wl,-E -Wl,-B,deferred"
	    SHLIB_SUFFIX_NAME=sl
	    ;;
	*-hp-hpux10.*|*-hp-hpux11.*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="+z" ;;
	    esac
	    LDFLAGS_SHLIB="-b"
	    LDFLAGS_SHLIB_EXPORT="-Wl,-E -Wl,-B,deferred -Wl,+s"
	    SHLIB_SUFFIX_NAME=sl
	    ;;
	*-ibm-aix*)
	    case $CC in
		*/gcc|gcc ) CFLAGS_SHLIB="-fpic" ;;
		*/cc|cc   ) CFLAGS_SHLIB="" ;;
	    esac
	    case $PLAT in
		*-ibm-aix4*)
		    LDFLAGS_SHLIB="-H512 -T512 -bhalt:4 -bM:SRE -bnoentry"
		    ;;
		*-ibm-aix*)
		    LDFLAGS_SHLIB="-H512 -T512 -bhalt:4 -bM:SRE -e _nostart"
		    ;;
	    esac
	    LDFLAGS_SHLIB="$LDFLAGS_SHLIB -bI:\$(SRCDIR)/support/httpd.exp "
	    LDFLAGS_SHLIB="$LDFLAGS_SHLIB -bE:\`echo \$@|sed -e 's:\.so\$\$:.exp:'\`"
	    LDFLAGS_SHLIB="$LDFLAGS_SHLIB -lc"
	    LDFLAGS_SHLIB_EXPORT="-Wl,-bE:\$(SRCDIR)/support/httpd.exp"
	    SHLIB_EXPORT_FILES=yes
	    ;;
	*-*-powermax*)
	    LD_SHLIB='cc'
	    LDFLAGS_SHLIB="-Zlink=so"
	    LDFLAGS_SHLIB_EXPORT="-Zlink=dynamic -Wl,-Bexport"
	    CFLAGS_SHLIB='-Zpic'
	    ;;
	*)
	    ##  ok, no known explict support for shared objects
	    ##  on this platform, but we give not up immediately.
	    ##  We take a second chance by guessing the compiler
	    ##  and linker flags from the Perl installation
	    ##  if it exists.
	    PERL=
	    for dir in `echo $PATH | sed -e 's/:/ /g'`
	    do
		if [ -f "$dir/perl5" ]; then
		    PERL="$dir/perl5"
		    break
		fi
		if [ -f "$dir/perl" ]; then
		    PERL="$dir/perl"
		    break
		fi
	    done
	    if [ "x$PERL" != "x" ]; then
		#   cool, Perl is installed on this platform...
		if [ "x`$PERL -V:dlsrc 2>/dev/null | grep dlopen`" != "x" ]; then
		    #   ...and actually uses the dlopen-style interface,
		    #   so we can guess the flags from its knowledge
		    CFLAGS_SHLIB="`$PERL -V:cccdlflags | cut -d\' -f2`"
		    LDFLAGS_SHLIB="`$PERL -V:lddlflags | cut -d\' -f2`"
		    LDFLAGS_SHLIB_EXPORT="`$PERL -V:ccdlflags | cut -d\' -f2`"
		    #   but additionally we have to inform the
		    #   user that we are just guessing the flags
		    echo ""
		    echo "** WARNING: We have no explicit knowledge about shared object"
		    echo "** support for your particular platform. But perhaps you have"
		    echo "** luck: We were able to guess the compiler and linker flags"
		    echo "** for creating shared objects from your Perl installation."
		    echo "** If they actually work, please send the following information"
		    echo "** for inclusion into later releases to new-httpd@apache.org or make"
		    echo "** a suggestion report at http://www.apache.org/bug_report.html:"
		    echo "**     PLATFORM=$PLAT"
		    echo "**     CFLAGS_SHLIB=$CFLAGS_SHLIB"
		    echo "**     LDFLAGS_SHLIB=$LDFLAGS_SHLIB"
		    echo "**     LDFLAGS_SHLIB_EXPORT=$LDFLAGS_SHLIB_EXPORT"
		    echo ""
		fi
	    fi
	    ;;
    esac
fi

####################################################################
## Check if we really have some information to compile
## the shared objects if SharedModule was used.
##
if [ "x$using_shlib" = "x1" ] ; then
    if [ "x$TCFLAGS_SHLIB"  = "x" -a "x$CFLAGS_SHLIB"  = "x"  -a \
	 "x$TLDFLAGS_SHLIB" = "x" -a "x$LDFLAGS_SHLIB" = "x" ]; then
	echo ""
	echo "** FAILURE: Sorry, no shared object support available."
	echo "** Either compile all modules statically (use AddModule instead"
	echo "** of SharedModule in the Configuration file) or at least provide"
	echo "** us with the appropriate compiler and linker flags via the"
	echo "** CFLAGS_SHLIB, LDFLAGS_SHLIB and LDFLAGS_SHLIB_EXPORT entries"
	echo "** in the Configuration file."
	echo ""
	exit 1
    fi
fi

####################################################################
## Now we do some OS specific adjustments... for some OSs, we need
## to adjust CFLAGS and/or OPTIM depending on which compiler we
## are going to use. This is easy, since this can be gleamed from
## Makefile.config
##
case "$OS" in
    'ULTRIX')
	case "$CC" in
	    */cc|cc ) CFLAGS="$CFLAGS -std" ;;
	esac
	;;
    'SCO 5')
	case "$CC" in
	    */cc|cc ) CFLAGS="$CFLAGS -K noinline" ;;
	esac
	;;
    'HI-UX')
	case "$CC" in
	    */cc|cc )
		CFLAGS="$CFLAGS -Aa -D_HIUX_SOURCE"
		OPTIM=" "
		TOPTIM=""
	    ;;
	esac
	;;
    'HP-UX'|'HP-UX 10'|'HP-UX 11')
	case "$CC" in
	    */cc|cc )
		CFLAGS="$CFLAGS -Aa -D_HPUX_SOURCE"
		OPTIM=" "
		TOPTIM=""
	    ;;
	esac
	;;
    *IRIX-64*)
	if [ "$RULE_IRIXN32" = "yes" ]; then
	    case "$CC" in
		*/cc|cc )
		    CFLAGS="$CFLAGS -n32"
		    LDFLAGS="$LDFLAGS -n32"
		;;
	    esac
	fi
	;;
    *IRIX-32*)
	if [ "$RULE_IRIXN32" = "yes" ]; then
	    case "$CC" in
		*/cc|cc )
		    CFLAGS="$CFLAGS -n32"
		    LDFLAGS="$LDFLAGS -n32"
		;;
	    esac
	fi
	;;
    IBM?AIX?4.[123])
	case $CC in
	    */cc|cc ) 
		CFLAGS="$CFLAGS -qnogenpcomp -qnousepcomp"
	    ;;
	esac
	;;
esac

####################################################################
## OK, now we can write OPTIM
##
if [ "x$TOPTIM" = "x" ]; then
    echo "OPTIM=$OPTIM" >> Makefile.config
fi

####################################################################
## OK, now handle RANLIB
##
if [ "x$RANLIB" = "x" ]; then
    if [ "x$TRANLIB" != "x" ]; then
	RANLIB=$TRANLIB
    else
	if ./helpers/PrintPath -s ranlib; then
	    RANLIB="ranlib"
	else
	    RANLIB="true"
	fi
    fi
fi

####################################################################
## Now we do some general checks and some intelligent Configuration
## control.

# Use TestCompile to look for various LIBS
case "$PLAT" in
    *-linux*)
	# newer systems using glibc 2.x need -lcrypt
	if ./helpers/TestCompile lib crypt; then
	    LIBS="$LIBS -lcrypt"
	fi
	;;

    *-dg-dgux*)
	# R4.11MU02 requires -lsocket -lnsl ... no idea if it's earlier or
	# later than what we already knew about.  PR#732
	if ./helpers/TestCompile lib socket; then
	    LIBS="$LIBS -lsocket"
	fi
	if ./helpers/TestCompile lib nsl; then
	    LIBS="$LIBS -lnsl"
	fi
	;;
esac

# SOCKS4 support:
# We assume that if they are using SOCKS4, then they've
# adjusted EXTRA_LIBS and/or EXTRA_LDFLAGS as required,
# otherwise we assume "-L/usr/local/lib -lsocks"
if [ "$RULE_SOCKS4" = "yes" ]; then
    echo " + enabling SOCKS4 support"
    CFLAGS="$CFLAGS -DSOCKS -DSOCKS4"
    CFLAGS="$CFLAGS -Dconnect=Rconnect -Dselect=Rselect"
    CFLAGS="$CFLAGS -Dgethostbyname=Rgethostbyname"
    if [ "x`egrep '^EXTRA_L' Makefile.config | grep lsocks`" = "x" ]; then
	LIBS="$LIBS -L/usr/local/lib -lsocks"
    fi
    case $PLAT in
	*-solaris2* )
	    LIBS="$LIBS -lresolv"
	    ;;
    esac
fi

# SOCKS5 support:
# We assume that if they are using SOCKS5, then they've
# adjusted EXTRA_LIBS and/or EXTRA_LDFLAGS as required,
# otherwise we assume "-L/usr/local/lib -lsocks5"
if [ "$RULE_SOCKS5" = "yes" ]; then
    echo " + enabling SOCKS5 support"
    CFLAGS="$CFLAGS -DSOCKS -DSOCKS5"
    CFLAGS="$CFLAGS -Dconnect=SOCKSconnect -Dselect=SOCKSselect"
    CFLAGS="$CFLAGS -Dgethostbyname=SOCKSgethostbyname -Dclose=SOCKSclose"
    if [ "x`egrep '^EXTRA_L' Makefile.config | grep lsocks5`" = "x" ]; then
	LIBS="$LIBS -L/usr/local/lib -lsocks5"
    fi
    case $PLAT in
	*-solaris2* )
	    LIBS="$LIBS -lresolv"
	    ;;
    esac
fi

####################################################################
## Find out what modules we want and try and configure things for them
## Module lines can look like this:
##
##  Module  name_module    some/path/mod_name[.[oa]]
##  AddModule              some/path/mod_name[.[oa]]
##
## In both cases, the some/path can either be an arbitrary path (including
## an absolute path), or a path like "modules/DIR", in which case we _might_
## auto-generate a Makefile in modules/DIR (see later).
##
## The first case is the original style, where we give the module's
## name as well as it's binary file location - either a .o or .a.
##
## The second format is new, and means we do not repeat the module
## name, which is already part of the module source or definition.
## The way we find the module name (and other optional information about
## the module) is like this:
##
##  1 If extension is not given or is .c, assume .o was given and goto 3
##  2 If extension is .module, go to D1
##  3 If extension is .o, look for a corresponding .c file and if
##      found, go to C1
##  4 If no .c file was found, look for a .module file (Apache module
##      definition file). If found, go to D1
##  5 Assume module name is the "name" part of "mod_name", as in
##      name_module.
##
## If a C file is found:
##
## C1 Look for module name given by an MODULE: line (e.g. MODULE: name_module)
##      If found assume module contains a definition, and go to D1
## C2 If not found, look for a module name given on the declaration of the
##      module structure (e.g. module name_module).
## C3 If neither given, go to 4 above.
##
## If a definition file is found, or a .c file includes a module definition:
##
## D1 Get the module name from the MODULE: name= line
## D2 Get other module options (libraries etc). To be done later.
##
##
## For now, we will convert the AddModule lines into Module format
## lines, so the rest of Configure can do its stuff without too much
## additional hackery. It would be nice to reduce the number of times
## we have to awk the $tmpfile, though.

## MODFILES contains a list of module filenames (could be .c, .o, .so, .a
##    or .module files) from AddModule lines only
## MODDIRS contains a list of subdirectories under 'modules' which
##    contain modules we want to build from both AddModule and Module
##    lines

echo " + adding selected modules"

MODFILES=`awk <$tmpfile '($1 == "AddModule" || $1 == "SharedModule") { printf "%s ", $2 }'`
MODDIRS=`awk < $tmpfile '
	($1 == "Module" && $3 ~ /^modules\//) {
	    split ($3, pp, "/")
	    if (! SEEN[pp[2]]) {
		printf "%s ", pp[2]
		SEEN[pp[2]] = 1
	    }
    	}
	(($1 == "AddModule" || $1 == "SharedModule") && $2 ~ /^modules\//) { 
	    split ($2, pp, "/")
	    if (! SEEN[pp[2]]) {
		printf "%s ", pp[2]
		SEEN[pp[2]] = 1
	    } 
    	}'`
MODDIRS_NO_SO=`awk < $tmpfile '
	($1 == "Module" && $3 ~ /^modules\//) {
	    split ($3, pp, "/")
	    if (! SEEN[pp[2]]) {
		printf "%s ", pp[2]
		SEEN[pp[2]] = 1
	    }
    	}
	(($1 == "AddModule") && $2 ~ /^modules\//) { 
	    split ($2, pp, "/")
	    if (! SEEN[pp[2]]) {
		printf "%s ", pp[2]
		SEEN[pp[2]] = 1
	    } 
    	}'`

# Now autoconfigure each of the modules specified by AddModule.
# Use tmpfile2 for the module definition file, and tmpfile3 for the
# shell commands to be executed for this module.

for modfile in $MODFILES ; do
	rm -f $tmpfile2 $tmpfile3
	modname=''

	ext=`echo $modfile | sed 's/^.*\.//'`
	modbase=`echo $modfile | sed 's/\.[^.]*$//'`
	if [ "x$ext" = "x$modfile" ]; then ext=o; modbase=$modfile; modfile=$modbase.o; fi
	if [ "x$ext" = "x" ] ; then ext=o; modbase=$modfile; fi
	if [ "x$ext" = "xc" ] ; then ext=o; fi

	# modbase is the path+filename without extension, ext is the
	# extension given, or if none, o
	if [ -r $modbase.module ] ; then
		$CAT $modbase.module > $tmpfile2
	else
	    if [ -f $modbase.c ] ; then
		# Guess module structure name in case there is no
		# module definition in this file
		modname=`egrep '^module .*;' $modbase.c | head -1 |\
			sed 's/^module.*[ 	][ 	]*//' | \
			sed 's/[ 	]*;[ 	]*$//'`
		# Get any module definition part
		if grep "MODULE-DEFINITION-" $modbase.c > /dev/null; then
		$CAT $modbase.c | \
		sed '1,/MODULE-DEFINITION-START/d;/MODULE-DEFINITION-END/,$d' \
			> $tmpfile2
		fi
	    fi
	fi		
	if [ -r $tmpfile2 ] ; then
		# Read a module definition from .module or .c
		modname=`grep "Name:" $tmpfile2 | sed 's/^.*Name:[ 	]*//'`
		if grep "ConfigStart" $tmpfile2 > /dev/null \
		 && grep "ConfigEnd" $tmpfile2 > /dev/null; then
		    sed '1,/ConfigStart/d;/ConfigEnd/,$d' $tmpfile2 > \
		     $tmpfile3
		    echo "    o $modname uses ConfigStart/End"
		    if [ "$RULE_PARANOID" = "yes" ]; then
			sed 's/^/>> /' $tmpfile3
		    fi
		    . ./$tmpfile3
		fi
		rm -f $tmpfile2 $tmpfile3
		if [ "$ext" != "so" ]; then
		    ext=o
		fi
	fi
	if [ "x$modname" = "x" ] ; then
		modname=`echo $modbase | sed 's/^.*\///' | \
			sed 's/^mod_//' | sed 's/^lib//' | sed 's/$/_module/'`
	fi
	if [ "$ext" != "so" ]; then
		echo "Module $modname $modbase.$ext" >>$tmpfile
	fi
	#   optionally generate export file for some linkers 
	if [ "$ext" = "so" -a "$SHLIB_EXPORT_FILES" = "yes" ]; then
		echo "$modname" >$modbase.exp
	fi
done
# $tmpfile now contains Module lines for all the modules we want

####################################################################
## Now HS's POSIX regex implementation if needed/wanted. We do it
## now since AddModule may have changed it
##
if [ "$RULE_WANTHSREGEX" = "yes" ]; then
    REGLIB="regex/libregex.a"
    SUBDIRS="regex $SUBDIRS"
    CFLAGS="$CFLAGS -DUSE_HSREGEX"
fi

####################################################################
# Extended API support:
if [ "$RULE_EAPI" = "yes" ]; then
    echo " + enabling Extended API (EAPI)"
    CFLAGS="$CFLAGS -DEAPI"
    #   some vendor compilers are too restrictive
    case "$OS:$CC" in
        *IRIX-32*:*/cc|*IRIX-32*:cc )
            CFLAGS="$CFLAGS -woff 1048,1110,1164"
            ;;
    esac
fi

####################################################################
## Now the SHARED_CHAIN stuff
##
LIBS_SHLIB=''
if [ "x$using_shlib" = "x1" ] ; then
    if [ "$RULE_SHARED_CHAIN" = "default" ] ; then
	RULE_SHARED_CHAIN=$DEF_SHARED_CHAIN
    fi
    if [ "$RULE_SHARED_CHAIN" = "yes" ]; then
	echo " + enabling DSO files to be linked against others"
	#   determine libraries which can be safely linked
	#   to our DSO files, i.e. PIC libraries and shared libraries
	extra_ldflags="`grep EXTRA_LDFLAGS= Makefile.config`"
	extra_libs="`grep EXTRA_LIBS= Makefile.config`"
	eval "`./helpers/slo.sh $LDFLAGS $LIBS $extra_ldflags $extra_libs`"
	LIBS_SHLIB="$SLO_DIRS_PIC $SLO_LIBS_PIC $SLO_DIRS_DSO $SLO_LIBS_DSO"
    fi
fi

####################################################################
## Now the SHARED_CORE stuff
##
if [ "x$using_shlib" = "x1" ] ; then
    if [ "$RULE_SHARED_CORE" = "default" ] ; then
	RULE_SHARED_CORE=$DEF_SHARED_CORE
    fi
    if [ "$RULE_SHARED_CORE" = "yes" ]; then
	echo " + enabling generation of Apache core as DSO"
	#    shuffle compiler flags from shlib variant to standard
	CFLAGS="$CFLAGS $CFLAGS_SHLIB"
	CFLAGS_SHLIB=""
	#    indicate that Rule SHARED_CORE is active
	CFLAGS="$CFLAGS -DSHARED_CORE"
	#    select the special subtarget for shared core generation
	SUBTARGET=target_shared
	#    determine additional suffixes for libhttpd.so
	V=1 R=3 P=4
	if [ "$SHLIB_SUFFIX_DEPTH" = "0" ]; then
	    SHLIB_SUFFIX_LIST=""
	fi
	if [ "$SHLIB_SUFFIX_DEPTH" = "1" ]; then
	    SHLIB_SUFFIX_LIST="$V"
	fi
	if [ "$SHLIB_SUFFIX_DEPTH" = "2" ]; then
	    SHLIB_SUFFIX_LIST="$V.$R"
	fi
	if [ "$SHLIB_SUFFIX_DEPTH" = "3" ]; then
	    SHLIB_SUFFIX_LIST="$V.$R.$P"
	fi
	if [ "$SHLIB_SUFFIX_DEPTH" = "all" ]; then
	    SHLIB_SUFFIX_LIST="$V $V.$R $V.$R.$P"
	fi
    fi
fi

####################################################################
## Set the value of the shared libary flags, if they aren't explicitly
## set in the configuration file
##
if [ "x$using_shlib" = "x1" ] ; then
    if [ "x$TCFLAGS_SHLIB" = "x" ]; then
	echo "CFLAGS_SHLIB=$CFLAGS_SHLIB -DSHARED_MODULE" >> Makefile.config
    fi
    if [ "x$TLD_SHLIB" = "x" ]; then
	echo "LD_SHLIB=$LD_SHLIB" >> Makefile.config
    fi
    if [ "x$TLDFLAGS_SHLIB" = "x" ]; then
	echo "LDFLAGS_SHLIB=$LDFLAGS_SHLIB" >> Makefile.config
    fi
    if [ "x$TLDFLAGS_SHLIB_EXPORT" = "x" ]; then
	echo "LDFLAGS_SHLIB_EXPORT=$LDFLAGS_SHLIB_EXPORT" >> Makefile.config
    fi
fi

####################################################################
## Now create modules.c
##
$CAT > $awkfile <<'EOFM'
    BEGIN {
	modules[n++] = "core"
	pmodules[pn++] = "core"
    } 
    /^Module/ { modules[n++] = $2 ; pmodules[pn++] = $2 } 
    /^%Module/ { pmodules[pn++] = $2 } 
    END {
	print "/*"
	print " * modules.c --- automatically generated by Apache"
	print " * configuration script.  DO NOT HAND EDIT!!!!!"
	print " */"
	print ""
	print "#include \"httpd.h\""
	print "#include \"http_config.h\""
	print ""
	for (i = 0; i < pn; ++i) {
	    printf ("extern module %s_module;\n", pmodules[i])
	}
	print ""
	print "/*"
	print " *  Modules which implicitly form the"
	print " *  list of activated modules on startup,"
	print " *  i.e. these are the modules which are"
	print " *  initially linked into the Apache processing"
	print " *  [extendable under run-time via AddModule]"
	print " */"
	print "module *ap_prelinked_modules[] = {"
	for (i = 0; i < n; ++i) {
	    printf "  &%s_module,\n", modules[i]
	}
	print "  NULL"
	print "};"
	print ""
	print "/*"
	print " *  Modules which initially form the"
	print " *  list of available modules on startup,"
	print " *  i.e. these are the modules which are"
	print " *  initially loaded into the Apache process"
	print " *  [extendable under run-time via LoadModule]"
	print " */"
	print "module *ap_preloaded_modules[] = {"
	for (i = 0; i < pn; ++i) {
	    printf "  &%s_module,\n", pmodules[i]
	}
	print "  NULL"
	print "};"
	print ""
    }
EOFM
$CAT $tmpfile | sed 's/_module//' | awk -f $awkfile > modules.c 

####################################################################
## figure out which module dir require use to autocreate a Makefile.
## for these dirs we must not list the object files from the AddModule
## lines individually since the auto-generated Makefile will create
## a library called libMODDIR.a for it (MODDIR is the module dir
## name). We create two variable here:
##
##   AUTODIRS   Space separated list of module directories, relative to
##              src
##   AUTOLIBS   Space separated list of auto-generated library files
##
for moddir in $MODDIRS 
do
	if [ -f modules/$moddir/Makefile.tmpl ] ; then
		AUTODIRS="$AUTODIRS modules/$moddir"
	fi
done
for moddir in $MODDIRS_NO_SO
do
	if [ -f modules/$moddir/Makefile.tmpl ] ; then
		AUTOLIBS="$AUTOLIBS modules/$moddir/lib$moddir.a"
	fi
done

####################################################################
## Add the module targets to the Makefile. Do not add individual object
## targets for auto-generated directories.
##
$CAT > $awkfile <<EOF1
    BEGIN {
	split ("$AUTODIRS", tmp, " ")
EOF1
$CAT >> $awkfile <<'EOF2'
	for ( key in tmp ) {
	    autodirs[tmp[key]] = 1
	}
     }
    /^Module/ { modules[n++] = $3 }
    /^%Module/ { modules[n++] = $3 }
    END {
	print "MODULES= \\"
	for (i = 0; i < n; ++i) {
	    split (modules[i], pp, "/")
	    dir = pp[1] "/" pp[2] 
	    inthere = 0
	    for ( tdir in autodirs ) {
		if (tdir == dir) 
		    inthere = 1
	    }
	    if (inthere == 1)
		continue
	    else
		printf ("  %s \\\n", modules[i])
	}
    }
EOF2
awk -f $awkfile >>Makefile <$tmpfile

####################################################################
## Now add the auto-generated library targets.  Need to use awk so we
## don't hang a continuation on the last line.
##
$CAT > $awkfile <<'EOF4'
    {
	z = 0
	split ($0, libs)
	for ( lib in libs ) {
	    if (z != 0)
		printf (" \\\n")
	    z++
	    printf ("  %s", libs[lib])
	}
    }
    END {
	printf ("\n")
    }
EOF4
echo "$AUTOLIBS" | awk -f $awkfile >>Makefile
echo "" >>Makefile

####################################################################
## Now add the target for the main Makefile
##
echo "SUBDIRS=$SUBDIRS" >> Makefile
echo "SUBTARGET=$SUBTARGET" >> Makefile
echo "SHLIB_SUFFIX_NAME=$SHLIB_SUFFIX_NAME" >> Makefile
echo "SHLIB_SUFFIX_LIST=$SHLIB_SUFFIX_LIST" >> Makefile
echo "" >> Makefile

####################################################################
## Determine GNU Make variant because
## it uses ugly looking built-in directory walk messages
## while we are already using our own messages
##
if [ "x`${MAKE} -v 2>/dev/null | grep 'GNU Make'`" = "x" ]; then
	MFLAGS_STATIC=
else
	MFLAGS_STATIC=--no-print-directory
fi

####################################################################
## Continue building Makefile.config. Fill in all entries except
## for $LIBS at this point. This implies that anything below
## can only alter $LIBS
##
echo "CFLAGS1=$CFLAGS" >>Makefile.config
echo "INCLUDES1=$INCLUDES" >>Makefile.config
echo "LIBS_SHLIB=$LIBS_SHLIB" >>Makefile.config
echo "LDFLAGS1=$LDFLAGS" >>Makefile.config
echo "MFLAGS_STATIC=$MFLAGS_STATIC" >>Makefile.config
echo "REGLIB=$REGLIB" >>Makefile.config
echo "RANLIB=$RANLIB" >>Makefile.config

####################################################################
## Some OS-related stuff for the DSO mechanism:
## Finding the vendor DSO functions
##
if [ "x$using_shlib" = "x1" ] ; then
    DL_LIB=""
    case $PLAT in
	*-ibm-aix* )
	    DL_LIB="-lld"
	    ;;
	*-hp-hpux*)
	    if ./helpers/TestCompile func shl_load; then
		:
	    else
		if ./helpers/TestCompile lib dld; then
		    DL_LIB="-ldld"
		fi
	    fi
	    ;;
	* )
	    if ./helpers/TestCompile func dlopen; then
		:
	    else
		if ./helpers/TestCompile lib dl; then
		    DL_LIB="-ldl"
		fi
	    fi
	    ;;
    esac
    if [ "x$DL_LIB" != "x" ]; then
	LIBS="$LIBS $DL_LIB"
	echo " + using $DL_LIB for vendor DSO support"
    fi
fi

####################################################################
## Finish building ap_config_auto.h
##
## We pick out all -D's from CFLAGS and insert them as defines into
## ap_config_auto.h so they are available to external modules needing to
## include Apache header files.
##
TEXTRA_CFLAGS=`egrep '^EXTRA_CFLAGS=' Makefile.config | tail -1 |\
	       sed -e 's;^EXTRA_CFLAGS=;;' -e 's;\`.*\`;;'`
tmpstr=`echo $CFLAGS $TEXTRA_CFLAGS |\
	sed -e 's;[ 	]-;!-;g' -e 's/\\\"/\"/g' -e 's/\([^\\]\)"/\1/g'`
OIFS="$IFS"
IFS='!'
for cflag in $tmpstr; do
    echo "$cflag" >>$tmpconfig
done
IFS="$OIFS"
if [ -r $tmpconfig ]; then
awk >>$AP_CONFIG_AUTO_H <$tmpconfig '
    /^-D.*/ {
	i = index($0, "=")
	if (i > 0) {
	    define = substr($0, 3, i-3)
	    value  = substr($0, i+1, length($0)-i)
	}
	else {
	    define = substr($0, 3, length($0)-2)
	    value  = "1";
	}
	printf ("\n/* build flag: %s */\n", $0)
	printf ("#ifndef %s\n#define %s %s\n#endif\n", define, define, value)
    }
'
fi

# finish header file
echo "" >>$AP_CONFIG_AUTO_H
echo "#endif /* AP_CONFIG_AUTO_H */" >>$AP_CONFIG_AUTO_H

####################################################################
## Finish creating the Makefile.config file
##
echo "LIBS1=$LIBS">> Makefile.config
echo "##" >> Makefile.config
echo "##  (End of automatically generated section)">> Makefile.config
echo "##" >> Makefile.config
echo "" >> Makefile.config

####################################################################
## Use TestCompile to see if $(CC) is ANSI and as a "final" sanity
## check
##

if [ "$OS" = "TPF" ] ; then
    :
else
   echo " + doing sanity check on compiler and options"
   if ./helpers/TestCompile sanity; then
      :
   else
   echo "** A test compilation with your Makefile configuration"
   echo "** failed. This is most likely because your C compiler"
   echo "** is not ANSI. Apache requires an ANSI C Compiler, such"
   echo "** as gcc. The above error message from your compiler"
   echo "** will also provide a clue."
   echo " Aborting!"
   exitcode=1
   exit 1
   fi
fi

####################################################################
## Now (finish) creating the makefiles
##

# ./Makefile
$CAT Makefile.config >> Makefile
sed -e "s#@@Configuration@@#$file#" "Makefile.tmpl" >>Makefile

# xxx/Makefile
MAKEDIRS="support main ap regex $OSDIR"
for dir in $MAKEDIRS ; do
	echo Creating Makefile in $dir
	./helpers/mfhead $dir $file > $dir/Makefile
	$CAT Makefile.config $dir/Makefile.tmpl |\
	sed -e "s:^SRCDIR=.*:SRCDIR=`./helpers/fp2rp $dir`:" >> $dir/Makefile
done

####################################################################
## Now create the modules/Makefile
##
./helpers/mfhead modules $file > modules/Makefile
$CAT Makefile.config | sed -e 's:^SRCDIR=.*:SRCDIR=..:' >> modules/Makefile

$CAT << EOF >> modules/Makefile
MODULES=$MODDIRS
CFLAGS=\$(OPTIM) \$(CFLAGS1) \$(EXTRA_CFLAGS)

default: all

all clean distclean depend :: 
	@for i in \$(MODULES); do \\
	    echo "===> \$(SDP)modules/\$\$i"; \\
		(cd \$\$i && \$(MAKE) \$(MFLAGS_STATIC) SDP='\$(SDP)' CC='\$(CC)' AUX_CFLAGS='\$(CFLAGS)' RANLIB='\$(RANLIB)' \$@) || exit 1; \\
		echo "<=== \$(SDP)modules/\$\$i"; \\
	done

EOF

####################################################################
## Now create modules/xxx/Makefile
##
for moddir in $AUTODIRS ; do
	echo "Creating Makefile in $moddir"

    ./helpers/mfhead $moddir $file > $moddir/Makefile
	$CAT Makefile.config |\
	sed -e "s:^SRCDIR=.*:SRCDIR=`./helpers/fp2rp $moddir`:" >> $moddir/Makefile
	$CAT << 'EOF' >> $moddir/Makefile
##
##  Default Makefile options from Configure script
##  (Begin of automatically generated section)
##
CFLAGS=$(OPTIM) $(CFLAGS1) $(EXTRA_CFLAGS)
LIBS=$(EXTRA_LIBS) $(LIBS1)
INCLUDES=$(INCLUDES1) $(INCLUDES0) $(EXTRA_INCLUDES)
LDFLAGS=$(LDFLAGS1) $(EXTRA_LDFLAGS)
INCDIR=$(SRCDIR)/include
EOF
	if [ -f $moddir/Makefile.libdir ]; then
	    basedir=`echo $moddir | sed 's@^[^/]*/@@g'`
	    awk >> $moddir/Makefile < $tmpfile '
		($2 ~ /^modules\/'$basedir'\//) {
		    split($2, pp, "/");
		    split(pp[3], parts, ".");
		    libext=parts[2];
		}
		END { 
		    printf "LIBEXT=%s\n", libext;
		}'
	    # it's responsible for the rest of its Makefile...
	else
	    basedir=`echo $moddir | sed 's@^[^/]*/@@g'`
	    OBJS=`awk < $tmpfile '
		($1 == "Module" && $3 ~ /^modules\/'$basedir'\//) { 
		    split ($3, pp, "/")
		    printf "%s ", pp[3] 
		} 
		'`
	    echo "OBJS=$OBJS" >> $moddir/Makefile
	    if [ "x$OBJS" != "x" ]; then
		echo "LIB=lib$basedir.a" >> $moddir/Makefile
	    else
		#   essential!
		echo "LIB=" >> $moddir/Makefile
	    fi
	    awk >> $moddir/Makefile < $tmpfile '
	    ($1 == "SharedModule" && $2 ~ /^modules\/'$basedir'\//) {
		split($2, pp, "/")
		shlibs=shlibs " " pp[3]
		so=pp[3]
		split(pp[3], parts, ".")
		base=parts[1]
		objspic=objspic " " base ".lo"
	    }
	    END { 
		printf "SHLIBS=%s\n", shlibs;
		printf "OBJS_PIC=%s\n", objspic;
	    }'

	    $CAT << 'EOF' >> $moddir/Makefile

all: lib shlib

lib:	$(LIB) 

shlib:	$(SHLIBS)

dummy $(LIB): $(OBJS)
	rm -f $@
	ar cr $@ $(OBJS)
	$(RANLIB) $@

.SUFFIXES: .o .so

.c.o:
	$(CC) -c $(INCLUDES) $(CFLAGS) $<

.c.so:
	$(CC) -c $(INCLUDES) $(CFLAGS) $(CFLAGS_SHLIB) $< && mv $*.o $*.lo
	$(LD_SHLIB) $(LDFLAGS_SHLIB) -o $@ $*.lo $(LIBS_SHLIB)

clean:
	rm -f $(LIB) $(OBJS) $(SHLIBS) $(OBJS_PIC)

distclean: clean
	rm -f Makefile

#   NOT FOR END USERS!
depend:
	cp Makefile.tmpl Makefile.tmpl.bak \
	    && sed -ne '1,/^# DO NOT REMOVE/p' Makefile.tmpl > Makefile.new \
	    && gcc -MM $(INCLUDES) $(CFLAGS) *.c >> Makefile.new \
	    && sed -e '1,$$s: $(INCDIR)/: $$(INCDIR)/:g' \
		   -e '1,$$s: $(OSDIR)/: $$(OSDIR)/:g' Makefile.new \
		> Makefile.tmpl \
	    && rm Makefile.new

EOF
	fi

	$CAT << 'EOF' >> $moddir/Makefile
##
##  (End of automatically generated section)
##
EOF
    $CAT >> $moddir/Makefile < $moddir/Makefile.tmpl

done