Return to configure CVS log

Up to [cvsweb.bsd.lv] / mandoc

Various people (among others Maxim Belooussov and Carsten Kunze)
reported that the build system still assumed that ohash is only
needed if sqlite3 is also in use, which is no longer true:
The ohash library is now required no matter what.

Rework sqlite3 and ohash library autodetection
such that both work independently of each other.
Provide LDADD for additional linker flags.
Add some missing variables to configure.local.example.

#!/bin/sh
#
# Copyright (c) 2014, 2015, 2016 Ingo Schwarze <schwarze@openbsd.org>
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

set -e

[ -w config.log ] && mv config.log config.log.old
[ -w config.h   ] && mv config.h config.h.old

# Output file descriptor usage:
# 1 (stdout): config.h, Makefile.local
# 2 (stderr): original stderr, usually to the console
# 3: config.log

exec 3> config.log
echo "config.log: writing..."

# --- default settings -------------------------------------------------
# Initialize all variables here,
# such that nothing can leak in from the environment.

MANPATH_DEFAULT="/usr/share/man:/usr/X11R6/man:/usr/local/man"
OSNAME=

CC=`printf "all:\\n\\t@echo \\\$(CC)\\n" | make -f -`
CFLAGS="-g -W -Wall -Wstrict-prototypes -Wno-unused-parameter -Wwrite-strings"
LDADD=
LD_OHASH=
LD_SQLITE3=
STATIC="-static"

BUILD_DB=1
BUILD_CGI=0

HAVE_DIRENT_NAMLEN=
HAVE_ERR=
HAVE_FTS=
HAVE_GETLINE=
HAVE_GETSUBOPT=
HAVE_ISBLANK=
HAVE_MKDTEMP=
HAVE_MMAP=
HAVE_PLEDGE=
HAVE_PROGNAME=
HAVE_REALLOCARRAY=
HAVE_REWB_BSD=
HAVE_REWB_SYSV=
HAVE_STRCASESTR=
HAVE_STRINGLIST=
HAVE_STRLCAT=
HAVE_STRLCPY=
HAVE_STRPTIME=
HAVE_STRSEP=
HAVE_STRTONUM=
HAVE_VASPRINTF=
HAVE_WCHAR=

HAVE_SQLITE3=
HAVE_SQLITE3_ERRSTR=
HAVE_OHASH=
HAVE_MANPATH=

PREFIX="/usr/local"
BINDIR=
SBINDIR=
INCLUDEDIR=
LIBDIR=
MANDIR=
HOMEBREWDIR=

WWWPREFIX="/var/www"
HTDOCDIR=
CGIBINDIR=

BINM_APROPOS="apropos"
BINM_MAKEWHATIS="makewhatis"
BINM_MAN="man"
BINM_SOELIM="soelim"
BINM_WHATIS="whatis"
MANM_MAN="man"
MANM_MANCONF="man.conf"
MANM_MDOC="mdoc"
MANM_ROFF="roff"
MANM_EQN="eqn"
MANM_TBL="tbl"

INSTALL="install"
INSTALL_PROGRAM=
INSTALL_LIB=
INSTALL_MAN=
INSTALL_DATA=

# --- manual settings from configure.local -----------------------------

if [ -r ./configure.local ]; then
	echo "configure.local: reading..." 1>&2
	echo "configure.local: reading..." 1>&3
	cat ./configure.local 1>&3
	. ./configure.local
else
	echo "configure.local: no (fully automatic configuration)" 1>&2
	echo "configure.local: no (fully automatic configuration)" 1>&3
fi
echo 1>&3

# --- tests for config.h  ----------------------------------------------

COMP="${CC} ${CFLAGS} -Wno-unused -Werror"

# Check whether this HAVE_ setting is manually overridden.
# If yes, use the override, if no, do not decide anything yet.
# Arguments: lower-case test name, manual value
ismanual() {
	[ -z "${2}" ] && return 1
	echo "${1}: manual (${2})" 1>&2
	echo "${1}: manual (${2})" 1>&3
	echo 1>&3
	return 0
}

# Run a single autoconfiguration test.
# In case of success, enable the feature.
# In case of failure, do not decide anything yet.
# Arguments: lower-case test name, upper-case test name, additional CFLAGS
singletest() {
	cat 1>&3 << __HEREDOC__
${1}: testing...
${COMP} ${3} -o test-${1} test-${1}.c
__HEREDOC__

	if ${COMP} ${3} -o "test-${1}" "test-${1}.c" 1>&3 2>&3; then
		echo "${1}: ${CC} succeeded" 1>&3
	else
		echo "${1}: ${CC} failed with $?" 1>&3
		echo 1>&3
		return 1
	fi

	if ./test-${1} 1>&3 2>&3; then
		echo "${1}: yes" 1>&2
		echo "${1}: yes" 1>&3
		echo 1>&3
		eval HAVE_${2}=1
		rm "test-${1}"
		return 0
	else
		echo "${1}: execution failed with $?" 1>&3
		echo 1>&3
		rm "test-${1}"
		return 1
	fi
}

# Run a complete autoconfiguration test, including the check for
# a manual override and disabling the feature on failure.
# Arguments: lower case name, upper case name, additional CFLAGS
runtest() {
	eval _manual=\${HAVE_${2}}
	ismanual "${1}" "${_manual}" && return 0
	singletest "${1}" "${2}" "${3}" && return 0
	echo "${1}: no" 1>&2
	eval HAVE_${2}=0
	return 1
}

# --- library functions ---
runtest dirent-namlen	DIRENT_NAMLEN	|| true
runtest err		ERR		|| true
runtest fts		FTS		|| true
runtest getline		GETLINE		|| true
runtest getsubopt	GETSUBOPT	|| true
runtest isblank		ISBLANK		|| true
runtest mkdtemp		MKDTEMP		|| true
runtest mmap		MMAP		|| true
runtest pledge		PLEDGE		|| true
runtest progname	PROGNAME	|| true
runtest reallocarray	REALLOCARRAY	|| true
runtest rewb-bsd	REWB_BSD	|| true
runtest rewb-sysv	REWB_SYSV	|| true
runtest strcasestr	STRCASESTR	|| true
runtest stringlist	STRINGLIST	|| true
runtest strlcat		STRLCAT		|| true
runtest strlcpy		STRLCPY		|| true
runtest strptime	STRPTIME	|| true
runtest strsep		STRSEP		|| true
runtest strtonum	STRTONUM	|| true
runtest vasprintf	VASPRINTF	|| true
runtest wchar		WCHAR		|| true

# --- sqlite3 ---
if [ ${BUILD_DB} -eq 0 ]; then
	echo "BUILD_DB=0 (manual)" 1>&2
	echo "BUILD_DB=0 (manual)" 1>&3
	echo 1>&3
	HAVE_SQLITE3=0
elif ismanual sqlite3 "${HAVE_SQLITE3}"; then
	if [ -z "${LD_SQLITE3}" ]; then
		LD_SQLITE3="-lsqlite3"
	fi
elif [ -n "${LD_SQLITE3}" ]; then
	runtest sqlite3 SQLITE3 "${LD_SQLITE3}" || true
elif singletest sqlite3 SQLITE3 "-lsqlite3"; then
	LD_SQLITE3="-lsqlite3"
elif runtest sqlite3 SQLITE3 \
		"-I/usr/local/include -L/usr/local/lib -lsqlite3"; then
	LD_SQLITE3="-L/usr/local/lib -lsqlite3"
	CFLAGS="${CFLAGS} -I/usr/local/include"
fi
if [ ${HAVE_SQLITE3} -eq 0 ]; then
	LD_SQLITE3=
	if [ ${BUILD_DB} -gt 0 ]; then
		echo "BUILD_DB=0 (no sqlite3)" 1>&2
		echo "BUILD_DB=0 (no sqlite3)" 1>&3
		echo 1>&3
		BUILD_DB=0
	fi
fi

# --- sqlite3_errstr ---
if [ ${BUILD_DB} -eq 0 ]; then
	HAVE_SQLITE3_ERRSTR=1
elif ismanual sqlite3_errstr "${HAVE_SQLITE3_ERRSTR}"; then
	:
else
	runtest sqlite3_errstr SQLITE3_ERRSTR "${LD_SQLITE3}" || true
fi

# --- ohash ---
if ismanual ohash "${HAVE_OHASH}"; then
	:
elif [ -n "${LD_OHASH}" ]; then
	runtest ohash OHASH "${LD_OHASH}" || true
elif singletest ohash OHASH; then
	:
elif runtest ohash OHASH "-lutil"; then
	LD_OHASH="-lutil"
fi
if [ "${HAVE_OHASH}" -eq 0 ]; then
	LD_OHASH=
fi

# --- LDADD ---
LDADD="${LDADD} ${LD_SQLITE3} ${LD_OHASH} -lz"
echo "LDADD=\"${LDADD}\"" 1>&2
echo "LDADD=\"${LDADD}\"" 1>&3
echo 1>&3

# --- manpath ---
if ismanual manpath "${HAVE_MANPATH}"; then
	:
elif manpath 1>&3 2>&3; then
	echo "manpath: yes" 1>&2
	echo "manpath: yes" 1>&3
	echo 1>&3
	HAVE_MANPATH=1
else
	echo "manpath: no" 1>&2
	echo "manpath: no" 1>&3
	echo 1>&3
	HAVE_MANPATH=0
fi

# --- write config.h ---

exec > config.h

cat << __HEREDOC__
#ifdef __cplusplus
#error "Do not use C++.  See the INSTALL file."
#endif

#ifndef MANDOC_CONFIG_H
#define MANDOC_CONFIG_H

#if defined(__linux__) || defined(__MINT__)
#define _GNU_SOURCE	/* See test-*.c what needs this. */
#endif

__HEREDOC__

[ ${HAVE_GETLINE} -eq 0 -o ${HAVE_REALLOCARRAY} -eq 0 -o \
  ${HAVE_STRLCAT} -eq 0 -o ${HAVE_STRLCPY} -eq 0 ] \
	&& echo "#include <sys/types.h>"
[ ${HAVE_VASPRINTF} -eq 0 ] && echo "#include <stdarg.h>"
[ ${HAVE_GETLINE} -eq 0 ] && echo "#include <stdio.h>"

echo
echo "#define MAN_CONF_FILE \"/etc/${MANM_MANCONF}\""
echo "#define MANPATH_DEFAULT \"${MANPATH_DEFAULT}\""
[ -n "${OSNAME}" ] && echo "#define OSNAME \"${OSNAME}\""
[ -n "${HOMEBREWDIR}" ] && echo "#define HOMEBREWDIR \"${HOMEBREWDIR}\""

cat << __HEREDOC__
#define HAVE_DIRENT_NAMLEN ${HAVE_DIRENT_NAMLEN}
#define HAVE_ERR ${HAVE_ERR}
#define HAVE_FTS ${HAVE_FTS}
#define HAVE_GETLINE ${HAVE_GETLINE}
#define HAVE_GETSUBOPT ${HAVE_GETSUBOPT}
#define HAVE_ISBLANK ${HAVE_ISBLANK}
#define HAVE_MKDTEMP ${HAVE_MKDTEMP}
#define HAVE_MMAP ${HAVE_MMAP}
#define HAVE_PLEDGE ${HAVE_PLEDGE}
#define HAVE_PROGNAME ${HAVE_PROGNAME}
#define HAVE_REALLOCARRAY ${HAVE_REALLOCARRAY}
#define HAVE_REWB_BSD ${HAVE_REWB_BSD}
#define HAVE_REWB_SYSV ${HAVE_REWB_SYSV}
#define HAVE_STRCASESTR ${HAVE_STRCASESTR}
#define HAVE_STRINGLIST ${HAVE_STRINGLIST}
#define HAVE_STRLCAT ${HAVE_STRLCAT}
#define HAVE_STRLCPY ${HAVE_STRLCPY}
#define HAVE_STRPTIME ${HAVE_STRPTIME}
#define HAVE_STRSEP ${HAVE_STRSEP}
#define HAVE_STRTONUM ${HAVE_STRTONUM}
#define HAVE_VASPRINTF ${HAVE_VASPRINTF}
#define HAVE_WCHAR ${HAVE_WCHAR}
#define HAVE_SQLITE3 ${HAVE_SQLITE3}
#define HAVE_SQLITE3_ERRSTR ${HAVE_SQLITE3_ERRSTR}
#define HAVE_OHASH ${HAVE_OHASH}
#define HAVE_MANPATH ${HAVE_MANPATH}

#define BINM_APROPOS "${BINM_APROPOS}"
#define BINM_MAKEWHATIS "${BINM_MAKEWHATIS}"
#define BINM_MAN "${BINM_MAN}"
#define BINM_SOELIM "${BINM_SOELIM}"
#define BINM_WHATIS "${BINM_WHATIS}"

__HEREDOC__

if [ ${HAVE_ERR} -eq 0 ]; then
	echo "extern	void	  err(int, const char *, ...);"
	echo "extern	void	  errx(int, const char *, ...);"
	echo "extern	void	  warn(const char *, ...);"
	echo "extern	void	  warnx(const char *, ...);"
fi

[ ${HAVE_GETLINE} -eq 0 ] && \
	echo "extern	ssize_t	  getline(char **, size_t *, FILE *);"

[ ${HAVE_GETSUBOPT} -eq 0 ] && \
	echo "extern	int	  getsubopt(char **, char * const *, char **);"

[ ${HAVE_ISBLANK} -eq 0 ] && \
	echo "extern	int	  isblank(int);"

[ ${HAVE_MKDTEMP} -eq 0 ] && \
	echo "extern	char	 *mkdtemp(char *);"

if [ ${HAVE_PROGNAME} -eq 0 ]; then
	echo "extern 	const char *getprogname(void);"
	echo "extern	void	  setprogname(const char *);"
fi

[ ${HAVE_REALLOCARRAY} -eq 0 ] && \
	echo "extern	void	 *reallocarray(void *, size_t, size_t);"

[ ${BUILD_DB} -gt 0 -a ${HAVE_SQLITE3_ERRSTR} -eq 0 ] &&
	echo "extern	const char *sqlite3_errstr(int);"

[ ${HAVE_STRCASESTR} -eq 0 ] && \
	echo "extern	char	 *strcasestr(const char *, const char *);"

[ ${HAVE_STRLCAT} -eq 0 ] && \
	echo "extern	size_t	  strlcat(char *, const char *, size_t);"

[ ${HAVE_STRLCPY} -eq 0 ] && \
	echo "extern	size_t	  strlcpy(char *, const char *, size_t);"

[ ${HAVE_STRSEP} -eq 0 ] && \
	echo "extern	char	 *strsep(char **, const char *);"

[ ${HAVE_STRTONUM} -eq 0 ] && \
	echo "extern	long long strtonum(const char *, long long, long long, const char **);"

[ ${HAVE_VASPRINTF} -eq 0 ] && \
	echo "extern	int	  vasprintf(char **, const char *, va_list);"

echo
echo "#endif /* MANDOC_CONFIG_H */"

echo "config.h: written" 1>&2
echo "config.h: written" 1>&3

# --- tests for Makefile.local -----------------------------------------

exec > Makefile.local

[ -z "${BINDIR}"     ] && BINDIR="${PREFIX}/bin"
[ -z "${SBINDIR}"    ] && SBINDIR="${PREFIX}/sbin"
[ -z "${INCLUDEDIR}" ] && INCLUDEDIR="${PREFIX}/include/mandoc"
[ -z "${LIBDIR}"     ] && LIBDIR="${PREFIX}/lib/mandoc"
[ -z "${MANDIR}"     ] && MANDIR="${PREFIX}/man"

[ -z "${HTDOCDIR}"   ] && HTDOCDIR="${WWWPREFIX}/htdocs"
[ -z "${CGIBINDIR}"  ] && CGIBINDIR="${WWWPREFIX}/cgi-bin"

[ -z "${INSTALL_PROGRAM}" ] && INSTALL_PROGRAM="${INSTALL} -m 0555"
[ -z "${INSTALL_LIB}"     ] && INSTALL_LIB="${INSTALL} -m 0444"
[ -z "${INSTALL_MAN}"     ] && INSTALL_MAN="${INSTALL} -m 0444"
[ -z "${INSTALL_DATA}"    ] && INSTALL_DATA="${INSTALL} -m 0444"

if [ ${BUILD_DB} -eq 0 -a ${BUILD_CGI} -gt 0 ]; then
	echo "BUILD_CGI=0 (no BUILD_DB)" 1>&2
	echo "BUILD_CGI=0 (no BUILD_DB)" 1>&3
	BUILD_CGI=0
fi

BUILD_TARGETS="base-build"
[ ${BUILD_CGI} -gt 0 ] && BUILD_TARGETS="${BUILD_TARGETS} cgi-build"
INSTALL_TARGETS="base-install"
[ ${BUILD_DB}  -gt 0 ] && INSTALL_TARGETS="${INSTALL_TARGETS} db-install"
[ ${BUILD_CGI} -gt 0 ] && INSTALL_TARGETS="${INSTALL_TARGETS} cgi-install"

cat << __HEREDOC__
BUILD_TARGETS	= ${BUILD_TARGETS}
INSTALL_TARGETS	= ${INSTALL_TARGETS}
CC		= ${CC}
CFLAGS		= ${CFLAGS}
LDADD		= ${LDADD}
STATIC		= ${STATIC}
PREFIX		= ${PREFIX}
BINDIR		= ${BINDIR}
SBINDIR		= ${SBINDIR}
INCLUDEDIR	= ${INCLUDEDIR}
LIBDIR		= ${LIBDIR}
MANDIR		= ${MANDIR}
WWWPREFIX	= ${WWWPREFIX}
HTDOCDIR	= ${HTDOCDIR}
CGIBINDIR	= ${CGIBINDIR}
BINM_APROPOS	= ${BINM_APROPOS}
BINM_MAKEWHATIS	= ${BINM_MAKEWHATIS}
BINM_MAN	= ${BINM_MAN}
BINM_SOELIM	= ${BINM_SOELIM}
BINM_WHATIS	= ${BINM_WHATIS}
MANM_MAN	= ${MANM_MAN}
MANM_MANCONF	= ${MANM_MANCONF}
MANM_MDOC	= ${MANM_MDOC}
MANM_ROFF	= ${MANM_ROFF}
MANM_EQN	= ${MANM_EQN}
MANM_TBL	= ${MANM_TBL}
INSTALL		= ${INSTALL}
INSTALL_PROGRAM	= ${INSTALL_PROGRAM}
INSTALL_LIB	= ${INSTALL_LIB}
INSTALL_MAN	= ${INSTALL_MAN}
INSTALL_DATA	= ${INSTALL_DATA}
__HEREDOC__

[ ${BUILD_DB} -gt 0 ] && \
	echo "MAIN_OBJS	= \$(BASE_OBJS) \$(DB_OBJS)"

echo "Makefile.local: written" 1>&2
echo "Makefile.local: written" 1>&3

exit 0