AC_INIT(rc.h)

dnl Automake stuff.
AM_INIT_AUTOMAKE(rc, 1.5b3)
AM_CONFIG_HEADER(config.h)

AC_ARG_PROGRAM

AC_DEFINE(RELDATE, "1998-02-16")

AC_PROG_CC
case "$GCC" in
yes)	CFLAGS="-Wall $CFLAGS" ;;
esac

AC_PROG_CPP
AC_PROG_INSTALL
AC_PROG_YACC
AC_CHECK_PROGS(LN, ln cp)

AC_CHECK_HEADERS(sys/resource.h sys/time.h sys/types.h unistd.h)
AC_HEADER_DIRENT
AC_HEADER_STDC

dnl At some point, we might attempt to parse the output of saying
dnl `#include <signal.h>' using something like
dnl rc_cv_full_signal_h=`$CPP temp.c |sed -n 's/.*"\(.*signal.h\)".*/\1/p' |sort -u |sed 'y/\n/ /'`
dnl (but that doesn't work quite right).
rc_cv_full_signal_h='/usr/include/signal.h /usr/include/sys/signal.h /usr/include/asm/signal.h'

AC_CACHE_CHECK(for signal names, rc_cv_signal_h,
	for i in $rc_cv_full_signal_h; do
		if grep SIGINT $i >/dev/null 2>&1; then
			rc_cv_signal_h=$i
		fi
	done
)
case "$rc_cv_signal_h" in
'') AC_MSG_ERROR(Can't find signal names in $rc_cv_full_signal_h) ;;
*) SIGNAL_H=$rc_cv_signal_h ;;
esac
AC_SUBST(SIGNAL_H)

AC_TYPE_GETGROUPS
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_TYPE_UID_T

AC_CHECK_FUNCS(getgroups setpgrp setrlimit)


dnl sigsetjmp() isn't a real function in some places.
AC_CACHE_CHECK(for sigsetjmp, rc_cv_sigsetjmp,
	AC_TRY_LINK([
#include <setjmp.h>
	], [
jmp_buf e;
setjmp(e);
	], rc_cv_sigsetjmp=yes, rc_cv_sigsetjmp=no))
case "$rc_cv_sigsetjmp" in
yes)	AC_DEFINE(HAVE_SIGSETJMP) ;;
esac


AC_FUNC_SETPGRP


dnl HPUX needs _KERNEL defined to pick up RLIMIT_foo defines.  (Why?)
AC_CACHE_CHECK(if _KERNEL is required for RLIMIT defines, rc_cv_kernel_rlimit,
	AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/resource.h>
	], [
int f;
f = RLIMIT_DATA;
	], rc_cv_kernel_rlimit=no, [ AC_TRY_COMPILE([
#include <sys/types.h>
#define _KERNEL
#include <sys/resource.h>
#undef _KERNEL
		], [
int f;
f = RLIMIT_DATA;
		], rc_cv_kernel_rlimit=yes, rc_cv_kernel_rlimit=no)]))
case "$rc_cv_kernel_rlimit" in
yes)	AC_DEFINE(RLIMIT_NEEDS_KERNEL) ;;
esac


dnl Look for rlim_t in sys/types.h and sys/resource.h
AC_CACHE_CHECK(for rlim_t, rc_cv_have_rlim_t,
	AC_EGREP_CPP(rlim_t, [
#include <sys/types.h>
#if RLIMIT_NEEDS_KERNEL
#define _KERNEL
#endif
#include <sys/resource.h>
	], rc_cv_have_rlim_t=yes, rc_cv_have_rlim_t=no))

case "$rc_cv_have_rlim_t" in
yes)	AC_DEFINE(HAVE_RLIM_T) ;;
no)	AC_CACHE_CHECK(for native quad_t, rc_cv_have_quad_t,
		AC_TRY_COMPILE([
#include <sys/types.h>
		], [
typedef quad_t align_t;
align_t a;
a = (quad_t)0;
		], rc_cv_have_quad_t=yes, rc_cv_have_quad_t=no))

	case "$rc_cv_have_quad_t" in
	yes)	AC_DEFINE(HAVE_QUAD_T)
		AC_CACHE_CHECK(if rlimit values are quad_t, rc_cv_rlim_t_is_quad_t,
			AC_TRY_RUN([
#include <sys/types.h>
#include <sys/time.h>
#include <sys/types.h>
#if RLIMIT_NEEDS_KERNEL
#define _KERNEL
#endif
#include <sys/resource.h>
#if RLIMIT_NEEDS_KERNEL
#undef _KERNEL
#endif
main(){
	struct rlimit rl;
	exit(sizeof rl.rlim_cur != sizeof(quad_t));
}
			], rc_cv_rlim_t_is_quad_t=yes, rc_cv_rlim_t_is_quad_t=no, $ac_cv_type_quad_t))

		case "$rc_cv_rlim_t_is_quad_t" in
		yes)	AC_DEFINE(RLIM_T_IS_QUAD_T) ;;
		esac
		;;
	esac
	;;
esac

AC_SYS_RESTARTABLE_SYSCALLS
AM_CONDITIONAL(H_R_S, test "$ac_cv_sys_restartable_syscalls" = yes)

dnl Do we have SysV SIGCLD semantics?  In other words, if we set the
dnl action for SIGCLD to SIG_IGN does wait() always say ECHILD?
AC_CACHE_CHECK(for SysV SIGCLD semantics, rc_cv_sysv_sigcld,
	AC_TRY_RUN([
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main(void) {
	int i;
	sigset(SIGCLD, SIG_IGN);
	switch (fork()) {
	case -1:
		return 1;
	case 0:
		return 0;
	default:
		if (wait(&i) == -1 && errno == ECHILD) return 0;
		else return 1;
	}
}
	], rc_cv_sysv_sigcld=yes, rc_cv_sysv_sigcld=no, rc_cv_sysv_sigcld=yes))
case "$rc_cv_sysv_sigcld" in
yes)	AC_DEFINE(HAVE_SYSV_SIGCLD) ;;
esac


dnl Does the kernel handle `#! /interpreter'?
AC_SYS_INTERPRETER
case "$ac_cv_sys_interpreter" in
yes)	AC_DEFINE(HASH_BANG) ;;
esac
AM_CONDITIONAL(N_H_B, test "$ac_cv_sys_interpreter" = no)


dnl What do we do for command arguments?  We want /dev/fd, Linux's
dnl /proc/self/fd, or failing that, FIFOs.
AC_CACHE_CHECK(for /dev/fd, rc_cv_sys_dev_fd,
	if test -d /dev/fd && test -r /dev/fd/0; then
		rc_cv_sys_dev_fd=yes
	elif test -d /proc/self/fd && test -r /proc/self/fd/0; then
		rc_cv_sys_dev_fd=odd
	else
		rc_cv_sys_dev_fd=no
	fi)
	
case "$rc_cv_sys_dev_fd" in
yes)	AC_DEFINE(HAVE_DEV_FD) ;;
odd)	AC_DEFINE(HAVE_PROC_SELF_FD) ;;
no)	AC_CACHE_CHECK(for named pipes, rc_cv_sys_fifo,
		AC_TRY_RUN([
#include <sys/types.h>
#include <sys/stat.h>

main() {
	exit(mknod("/tmp/rc$$.0", S_IFIFO | 0666, 0) != 0);
}
		], rc_cv_sys_fifo=yes, rc_cv_sys_fifo=no, rc_cv_sys_fifo=no))
	rm -f /tmp/rc$$.0
	case "$rc_cv_sys_fifo" in
	yes)	AC_DEFINE(HAVE_FIFO) ;;
	esac
	;;
esac

AC_ARG_ENABLE(builtin-echo, [  --disable-builtin-echo  Don't include \`echo' as a builtin],
	test "x$enableval" != "xno" && AC_DEFINE(RC_ECHO),
	AC_DEFINE(RC_ECHO))

AC_ARG_ENABLE(job, [  --disable-job           Don't do job-control-style backgrounding],
	test "x$enableval" != "xno" && AC_DEFINE(RC_JOB),
	AC_DEFINE(RC_JOB))

AC_ARG_ENABLE(protect-env, [  --disable-protect-env   Don't protect environment names],
	test "x$enableval" != "xno" && AC_DEFINE(PROTECT_ENV),
	AC_DEFINE(PROTECT_ENV))

AC_ARG_ENABLE(def-interp,
[  --enable-def-interp=/bin/foo
                          Use /bin/foo as default interpreter [/bin/sh]],
[
	case "x$enableval" in
	xno)
		;;
	xyes)
		AC_DEFINE(DEFAULTINTERP, "/bin/sh")
		;;
	*)
		AC_DEFINE_UNQUOTED(DEFAULTINTERP, "$enableval")
	esac
],
	AC_DEFINE(DEFAULTINTERP, "/bin/sh"))

AC_ARG_ENABLE(def-path,
[  --enable-def-path=\"/usr/local/bin/\",\"/usr/bin\"
                          Default path [All of these that exist
                          (/usr/local/bin /usr/bin /usr/ucb /bin .)]],
[
	case "$enableval" in
	no|yes)	;;
	*)	AC_DEFINE_UNQUOTED(DEFAULTPATH, $enableval) ;;
	esac
],
	enable_def_path=yes)

case "$enable_def_path" in
yes)	AC_CACHE_CHECK(extant directories for default path, rc_cv_def_path,[
		rc_cv_def_path=''
		for i in /usr/local/bin /usr/bin /usr/ucb /bin .; do
			if test -d $i; then
				case "$rc_cv_def_path" in
				'')	rc_cv_def_path=\"$i\" ;;
				*)	rc_cv_def_path=$rc_cv_def_path,\"$i\" ;;
				esac
			fi
		done
	])
	AC_DEFINE_UNQUOTED(DEFAULTPATH, $rc_cv_def_path)
	;;
esac

AC_ARG_ENABLE(history,
	[  --enable-history        Build history subprograms],[
	case "$enableval" in
        yes) rc_history=yes ;;
        *) rc_history=no ;;
        esac
	], rc_history=no)
AM_CONDITIONAL(HISTORY, test "$rc_history" = yes)

AC_ARG_WITH(addon, [  --with-addon            Extra builtins, from addon.c ],[
	case "$withval" in
	yes)	ADDON=addon.c ;;
	no)	ADDON='' ;;
	*)	ADDON=$withval ;;
	esac
	])
AC_SUBST(ADDON)

AC_ARG_WITH(editline, [  --with-editline         Simmule Turner's line editing],
	AC_CHECK_LIB(edit, readline,
		AC_DEFINE(READLINE) LIBS="$LIBS -ledit",
		AC_MSG_WARN(editline library not found)))

AC_ARG_WITH(readline, [  --with-readline         Bloated GNU line editing],
	AC_CHECK_LIB(readline, readline,
		AC_DEFINE(READLINE) LIBS="$LIBS -lreadline -ltermcap",
		AC_MSG_WARN(readline library not found),
		-ltermcap))

AC_OUTPUT(Makefile)