configure.in

来自「RESIN 3.2 最新源码」· IN 代码 · 共 1,013 行 · 第 1/2 页

AC_INIT(src/c/plugin/apache/mod_caucho.c)
AC_PREFIX_DEFAULT(`pwd`)
AC_CONFIG_AUX_DIR(src/automake)	

dnl Get os info
AC_CANONICAL_SYSTEM

AM_INIT_AUTOMAKE(resin, 3.0.4)

FULL_VERSION="Resin $VERSION -- `date`"
AC_SUBST(FULL_VERSION)

dnl Checks for programs.
AC_PROG_CC
AC_PROG_LD

dnl Checks for poll.h
AC_CHECK_HEADER(sys/poll.h, [ CFLAGS="$CFLAGS -DPOLL" ])

AC_PROG_LIBTOOL			    
#
# libtool stuff
#  
if test -z "${LTFLAGS}"; then
  LTFLAGS="--silent"
fi
	
LIBTOOL_SCRIPT="`pwd`/libtool"
LIBTOOL="${LIBTOOL_SCRIPT} ${LTFLAGS}"    
libtoolversion=`${SHELL} ${LIBTOOL_SCRIPT} --version`
case $libtoolversion in
     *1.4*)
       SH_LIBTOOL="${LIBTOOL_SCRIPT}"
       SHLTCFLAGS="-prefer-pic"
       LTCFLAGS="-prefer-non-pic -static"
       ;;
     *)
       SH_LIBTOOL="${SHELL} ${LIBTOOL_SCRIPT} ${LTFLAGS}"
       SHLTCFLAGS=""
       LTCFLAGS=""
       ;;
esac

AC_SUBST(LTFLAGS)	
AC_SUBST(LIBTOOL_SCRIPT)	
AC_SUBST(LIBTOOL)	
AC_SUBST(SH_LIBTOOL)	
AC_SUBST(LTCFLAGS)	
     
INCLUDES=""
plugins=common
AC_SUBST(plugins)
dnl should be unnecessary
AC_SUBST(LD)
	
#
# --enable-64bit
#
AC_ARG_ENABLE(64bit,
[  --enable-64bit    Enable 64 bit],
[case "${enableval}" in
 yes) b64=true ;;
 no)  b64="" ;;
 *) AC_MSG_ERROR(bad value ${enableval} for --enable-64bit) ;;
 esac],[b64=""])

if test -n "${b64}"; then
   CFLAGS="$CFLAGS -DB64"
fi   

#
# --with-apache-src
#
AC_ARG_WITH(apache-src,
[  --with-apache-src=DIR  Apache src static compilation
], [
apache_src=${withval}

if test -d "${apache_src}/modules"; then
  a=b
elif test -d "${apache_src}/src/modules"; then
  apache_src=${apache_src}/src
else
  AC_MSG_ERROR([Can't find valid Apache source ${apache_src}])
fi

echo "using Apache source in ${apache_src}"

mkdir ${apache_src}/modules/caucho 2> /dev/null
cp src/c/plugin/common/*.c ${apache_src}/modules/caucho
cp src/c/plugin/common/*.h ${apache_src}/modules/caucho
cp src/c/plugin/apache/*.c ${apache_src}/modules/caucho

cat > ${apache_src}/modules/caucho/Makefile.tmpl <<'END'
LIB=libcaucho.a
OBJS=mod_caucho.o stream.o config.o registry.o memory.o

OBJS_PIC=mod_caucho.lo stream.lo config.lo registry.lo memory.lo

$(OBJS) $(OBJS_PIC): Makefile

all: lib

lib: $(LIB)

libcaucho.a: $(OBJS)
	rm -f $@
	ar cr $@ $(OBJS)
	$(RANLIB) $@

libcaucho.o: $(OBJS)
	$(LD) $(LDFLAGS) -r -o $@ $(OBJS)

libcaucho.so: $(OBJS_PIC)
	rm -f $@
	$(LD_SHLIB) $(LDFLAGS_SHLIB) -o $@ $(OBJS_PIC) $(LIBS_SHLIB) 

.SUFFIXES: .o .lo

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

.c.lo:
	$(CC) -c $(INCLUDES) $(CFLAGS) $(CFLAGS_SHLIB) $< && mv $*.o $*.lo

# DO NOT REMOVE
mod_caucho.o: cse.h
mod_caucho.lo: cse.h
stream.o: cse.h
stream.lo: cse.h
config.o: cse.h
config.lo: cse.h
registry.o: cse.h
registry.lo: cse.h
memory.o: cse.h
memory.lo: cse.h

END

cat > ${apache_src}/modules/caucho/Makefile.libdir <<'END'
# dummy
END

#grep caucho ${apache_src}/src/Configuration.tmpl >/dev/null 2>/dev/null
#if test "$?" -ne 0; then
#  cat >> ${apache_src}/src/Configuration.tmpl <<'END'
## mod_caucho incorporates Resin into Apache.
#
## AddModule modules/caucho/libcaucho.a
#END
#fi

])
#
# --with-apache
#
AC_ARG_WITH(apache,
[  --with-apache=DIR  the Apache root directory
], [
apache_dir=${withval}

if test "${apache_dir}" = "yes"; then
  apache_dir=/usr/local/apache
fi

apache=1
])

#
# --with-apxs
#
AC_ARG_WITH(apxs,
[  --with-apxs=PATH  the Apache configuration utility
], [
apxs=${withval}

if test "${apxs}" = "yes"; then
  apxs=
fi

apache=1
])

#
# --with-apache-eapi
#
AC_ARG_WITH(apache-eapi,
[  --with-apache-eapi=DIR  Apache eapi support
], [
apache_eapi=${withval}
])

#
# --with-apache-include
#
AC_ARG_WITH(apache-include,
[  --with-apache-include=DIR  the Apache include directory
], [
apache_include=${withval}

if test "${apache_include}" = "yes"; then
    apache_include=
fi

apache=1
])

#
# --with-apache-libexec
#
AC_ARG_WITH(apache-libexec,
[  --with-apache-libexec=DIR  the Apache module directory
], [
apache_libexec=${withval}

if test "${apache_libexec}" = "yes"; then
    apache_libexec=
fi

apache=1
])

#
# --with-apache-conf
#
AC_ARG_WITH(apache-conf,
[  --with-apache-conf=DIR  the Apache configuration
], [
apache_conf=${withval}

if test "${apache_conf}" = "yes"; then
    apache_conf=
fi

apache=1
])

apache_cflags=

#
# --with-apache-cflags
#
AC_ARG_WITH(apache-cflags,
[  --with-apache-cflags=flags  flags for compiling mod_caucho
], [
apache_cflags=${withval}

apache=1
])

#
# check that apxs is okay
#
if test -n "${apxs}"; then
  ${apxs} -q PREFIX >/dev/null 2>/dev/null
  if test "$?" -ne 0; then
    AC_MSG_ERROR(bad apxs ${apxs})
  fi
fi

if test -z "${apxs}" -a -x "${apache_bin}/apxs"; then
  apxs=${apache_bin}/apxs 
elif test -z "${apxs}" -a -x "${apache_dir}/bin/apxs"; then
  apxs=${apache_dir}/bin/apxs 
elif test -z "${apxs}" -a -x "${apache_dir}/sbin/apxs"; then
  apxs=${apache_dir}/sbin/apxs 
elif test -z "${apxs}" -a -x "/sbin/apxs"; then
  apxs=/sbin/apxs 
elif test -z "${apxs}" -a -x "/usr/sbin/apxs"; then
  apxs=/usr/sbin/apxs 
fi

#
# heuristics for finding the Apache include directory
#
if test -z "${apache_include}" -a -n "${apxs}"; then
  apache_include=`${apxs} -q INCLUDEDIR`
fi

if test -z "${apache_include}" -a -r "${apache_dir}/include/httpd.h"; then
  apache_include=${apache_dir}/include
fi

APACHE_INC="-I${apache_include}"
#
# deal with stronghold
#
if test -z "${apache_include}" -a -r "${apache_dir}/src/include/httpd.h"; then
  apache_include=${apache_dir}/src/include

  APACHE_INC="-I${apache_dir}/src/include"
  APACHE_INC="-I${apache_dir}/ssl/include $APACHE_INC"
  APACHE_INC="-I${apache_dir}/src/os/unix $APACHE_INC"
fi

if test -n "$apache" -a ! -r ${apache_include}/httpd.h; then
  AC_MSG_ERROR([Can't find Apache include directory ${apache_include}])
fi

#
# heuristics for finding the Apache bin directory
#
if test -n "${apache_bin}"; then
  a=b
elif test -x "${apxs}"; then
  apache_bin=`${apxs} -q SBINDIR`
elif test -n "${apache_dir}"; then
  apache_bin="${apache_dir}/bin"
fi

if test -z "${apache_bin}"; then
 a=b;
elif test -x "${apache_bin}/httpd"; then
 apache_exe="${apache_bin}/httpd"   	
elif test -x "${apache_bin}/httpd2"; then
 apache_exe="${apache_bin}/httpd2"   	
else
  AC_MSG_ERROR([Can't find Apache binary in directory ${apache_bin}])
fi

#
# heuristics for finding the Apache module directory
#
if test -z "${apache_libexec}" -a -n "${apxs}"; then
  apache_libexec=`${apxs} -q LIBEXECDIR`
fi

if test -z "${apache_libexec}" -a -d "${apache_dir}/libexec"; then
  apache_libexec=${apache_dir}/libexec
fi

if test -z "${apache_libexec}" -a -d "${apache_dir}/modules"; then
  apache_libexec=${apache_dir}/modules
fi

if test -n "$apache" -a ! -d "${apache_libexec}"; then
  AC_MSG_ERROR([Can't find Apache module directory ${apache_libexec}])
fi

#
# Heuristics for finding the Apache configuration directory
#

if test -z "${apache_conf}" -a -n "${apxs}"; then
  apache_confdir=`${apxs} -q SYSCONFDIR`
  
  if test -r "${apache_confdir}"/httpd.conf; then
    apache_conf=${apache_confdir}/httpd.conf
  elif test -r "${apache_confdir}"/apache.conf; then
    apache_conf=${apache_confdir}/apache.conf
  elif test -r "${apache_confdir}"/httpsd.conf; then
    apache_conf=${apache_confdir}/httpsd.conf
  fi
fi

if test -z "${apache_conf}" -a -r "${apache_dir}/conf/httpd.conf"; then
  apache_conf=${apache_dir}/conf/httpd.conf
fi

if test -z "${apache_conf}" -a -r "${apache_dir}/etc/httpd.conf"; then
  apache_conf=${apache_dir}/etc/httpd.conf
fi

if test -n "$apache" -a ! -r "${apache_conf}"; then
  AC_MSG_ERROR([Can't find Apache module configuration ${apache_conf}])
fi
#
# Apache CFLAGS
#

if test -z "$apache_cflags" -a -n "${apxs}"; then
   apache_cflags=`${apxs} -q CFLAGS`
fi

if test -z "$apache_cflags" -a -x "${apache_exe}"; then
   flags=`${apache_exe} -V | grep EAPI`
   if test -n "$flags"; then
     apache_cflags=-DEAPI
   fi
fi

if test -z "$apache_dir" -a -x "${apxs}"; then
   apache_dir=`${apxs} -q PREFIX`
fi

#
# check for apr
#
if test -x "${apxs}"; then
   apr_bin=`${apxs} -q APR_BINDIR 2> /dev/null`
   if test -x "${apr_bin}/apr-config"; then
     apr_inc=`"${apr_bin}/apr-config" --includes`
     APACHE_INC="${APACHE_INC} ${apr_inc}"
   fi
fi

AC_SUBST(APACHE_INC)
AC_SUBST(apache_libexec)
AC_SUBST(apache_conf)
AC_SUBST(apache_dir)
AC_SUBST(apache_cflags)
#
# fill in compilation stuff
#
SO=so

is_gcc=`${CC} -v 2>&1 | grep gcc`
is_gnu_ld=`${LD} -v 2>&1 | grep GNU`

#
# Use apxs if it's available
#
if test -z "${LD_SHLIB}"; then
  if test -n "${apxs}"; then
    CFLAGS_SHLIB=`${apxs} -q CFLAGS_SHLIB`
    LD_SHLIB=`${apxs} -q LD_SHLIB`
    LDFLAGS_SHLIB=`${apxs} -q LDFLAGS_SHLIB`
    LIBS_SHLIB=`${apxs} -q LIBS_SHLIB`

    echo "Using shared library flags from ${apxs}"
  fi
fi

#
# fill in based on known configurations
#
if test -z "${LD_SHLIB}"; then
  LD_SHLIB=${LD}	
  CFLAGS_SHLIB="-fpic"
  LDFLAGS_SHLIB="-shared"

  case "$target_os" in
    linux*)
	LD_SHLIB=${CC}
	
	if test -n "$b64"; then
  	  CFLAGS="$CFLAGS -m64"
	  LDFLAGS_SHLIB="-shared -fPIC"
   	fi
	;;
	
    solaris*)
	if test -n "$is_gcc"; then
	    CFLAGS_SHLIB="-fPIC"
	    
	   if test -n "$b64"; then
  	     CFLAGS="$CFLAGS -m64"
   	   fi
	else
	    CFLAGS_SHLIB="-KPIC"
	    
	   if test -n "$b64"; then
  	     CFLAGS="$CFLAGS -xarch=v9"
   	   fi
	fi

	if test -n "$is_gnu_ld"; then
	    LDFLAGS_SHLIB="-shared"
        else
	    LDFLAGS_SHLIB="-G"
	fi


	;;

    darwin*)
        CFLAGS_SHLIB="-DSHARED_MODULE"
	LD_SHLIB=${CC}
 	LDFLAGS_SHLIB="-bundle -undefined suppress -flat_namespace"
        ;;

    *aix*)
	if test -z "$is_gcc"; then
	   CFLAGS_SHLIB="-bexpall"
	else
	    CFLAGS_SHLIB="-fpic"
	fi
	LDFLAGS_SHLIB=""
	;;

    *hpux*)
	if test -z "$is_gcc"; then
	    CFLAGS_SHLIB="+z"
	else
	    CFLAGS_SHLIB="-fpic"
	fi
	LDFLAGS_SHLIB="-b"
	;;
  esac
fi

if test -z "$apache"; then
  a=b
elif test -r "${apache_include}/apr_thread_mutex.h"; then
  echo "Using Apache 2.0 configuration ${apache_conf}"

  plugins="$plugins apache2"
elif test -n "${apache_include}/ap.h"; then
  echo "Using Apache configuration ${apache_conf}"

  plugins="$plugins apache"
else
  AC_MSG_ERROR([Can't find valid Apache directory ${apache_inc}])
fi

if test -n "$apache_cflags"; then
  echo "Using Apache CFLAGS: $apache_cflags"