#!/bin/sh
-srcversion='$MirOS: src/bin/mksh/Build.sh,v 1.459 2010/08/24 15:46:06 tg Exp $'
+srcversion='$MirOS: src/bin/mksh/Build.sh,v 1.702 2016/08/10 18:20:16 tg Exp $'
#-
-# Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-# Thorsten Glaser <tg@mirbsd.org>
+# Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+# 2011, 2012, 2013, 2014, 2015, 2016
+# mirabilos <m@mirbsd.org>
#
# Provided that these terms and disclaimer and all copyright notices
# are retained or reproduced in an accompanying document, permission
# People analysing the output must whitelist conftest.c for any kind
# of compiler warning checks (mirtoconf is by design not quiet).
#
-# Environment used: CC CFLAGS CPPFLAGS LDFLAGS LIBS NOWARN NROFF
-# TARGET_OS TARGET_OSREV
-# Feature selectors: USE_PRINTF_BUILTIN
-# CPPFLAGS recognised: MKSH_ASSUME_UTF8 MKSH_BINSHREDUCED MKSH_CLS_STRING
-# MKSH_CONSERVATIVE_FDS MKSH_MIDNIGHTBSD01ASH_COMPAT
-# MKSH_NOPWNAM MKSH_NO_LIMITS MKSH_SMALL MKSH_S_NOVI
-# MKSH_UNEMPLOYED MKSH_DEFAULT_EXECSHELL MKSHRC_PATH
-# MKSH_DEFAULT_TMPDIR MKSH_CLRTOEOL_STRING MKSH_A4PB
+# Used environment documentation is at the end of this file.
LC_ALL=C
export LC_ALL
+case $ZSH_VERSION:$VERSION in
+:zsh*) ZSH_VERSION=2 ;;
+esac
+
+if test -n "${ZSH_VERSION+x}" && (emulate sh) >/dev/null 2>&1; then
+ emulate sh
+ NULLCMD=:
+fi
+
+if test -d /usr/xpg4/bin/. >/dev/null 2>&1; then
+ # Solaris: some of the tools have weird behaviour, use portable ones
+ PATH=/usr/xpg4/bin:$PATH
+ export PATH
+fi
+
+nl='
+'
+safeIFS=' '
+safeIFS=" $safeIFS$nl"
+IFS=$safeIFS
+allu=QWERTYUIOPASDFGHJKLZXCVBNM
+alll=qwertyuiopasdfghjklzxcvbnm
+alln=0123456789
+alls=______________________________________________________________
+
+genopt_die() {
+ if test -n "$1"; then
+ echo >&2 "E: $*"
+ echo >&2 "E: in '$srcfile': '$line'"
+ else
+ echo >&2 "E: invalid input in '$srcfile': '$line'"
+ fi
+ rm -f "$bn.gen"
+ exit 1
+}
+
+genopt_soptc() {
+ optc=`echo "$line" | sed 's/^[<>]\(.\).*$/\1/'`
+ test x"$optc" = x'|' && return
+ optclo=`echo "$optc" | tr $allu $alll`
+ if test x"$optc" = x"$optclo"; then
+ islo=1
+ else
+ islo=0
+ fi
+ sym=`echo "$line" | sed 's/^[<>]/|/'`
+ o_str=$o_str$nl"<$optclo$islo$sym"
+}
+
+genopt_scond() {
+ case x$cond in
+ x)
+ cond=
+ ;;
+ x*' '*)
+ cond=`echo "$cond" | sed 's/^ //'`
+ cond="#if $cond"
+ ;;
+ x'!'*)
+ cond=`echo "$cond" | sed 's/^!//'`
+ cond="#ifndef $cond"
+ ;;
+ x*)
+ cond="#ifdef $cond"
+ ;;
+ esac
+}
+
+do_genopt() {
+ srcfile=$1
+ test -f "$srcfile" || genopt_die Source file \$srcfile not set.
+ bn=`basename "$srcfile" | sed 's/.opt$//'`
+ o_hdr='/* +++ GENERATED FILE +++ DO NOT EDIT +++ */'
+ o_gen=
+ o_str=
+ o_sym=
+ ddefs=
+ state=0
+ exec <"$srcfile"
+ IFS=
+ while IFS= read line; do
+ IFS=$safeIFS
+ case $state:$line in
+ 2:'|'*)
+ # end of input
+ o_sym=`echo "$line" | sed 's/^.//'`
+ o_gen=$o_gen$nl"#undef F0"
+ o_gen=$o_gen$nl"#undef FN"
+ o_gen=$o_gen$ddefs
+ state=3
+ ;;
+ 1:@@)
+ # begin of data block
+ o_gen=$o_gen$nl"#endif"
+ o_gen=$o_gen$nl"#ifndef F0"
+ o_gen=$o_gen$nl"#define F0 FN"
+ o_gen=$o_gen$nl"#endif"
+ state=2
+ ;;
+ *:@@*)
+ genopt_die ;;
+ 0:/\*-|0:\ \**|0:)
+ o_hdr=$o_hdr$nl$line
+ ;;
+ 0:@*|1:@*)
+ # begin of a definition block
+ sym=`echo "$line" | sed 's/^@//'`
+ if test $state = 0; then
+ o_gen=$o_gen$nl"#if defined($sym)"
+ else
+ o_gen=$o_gen$nl"#elif defined($sym)"
+ fi
+ ddefs="$ddefs$nl#undef $sym"
+ state=1
+ ;;
+ 0:*|3:*)
+ genopt_die ;;
+ 1:*)
+ # definition line
+ o_gen=$o_gen$nl$line
+ ;;
+ 2:'<'*'|'*)
+ genopt_soptc
+ ;;
+ 2:'>'*'|'*)
+ genopt_soptc
+ cond=`echo "$line" | sed 's/^[^|]*|//'`
+ genopt_scond
+ case $optc in
+ '|') optc=0 ;;
+ *) optc=\'$optc\' ;;
+ esac
+ IFS= read line || genopt_die Unexpected EOF
+ IFS=$safeIFS
+ test -n "$cond" && o_gen=$o_gen$nl"$cond"
+ o_gen=$o_gen$nl"$line, $optc)"
+ test -n "$cond" && o_gen=$o_gen$nl"#endif"
+ ;;
+ esac
+ done
+ case $state:$o_sym in
+ 3:) genopt_die Expected optc sym at EOF ;;
+ 3:*) ;;
+ *) genopt_die Missing EOF marker ;;
+ esac
+ echo "$o_str" | sort | while IFS='|' read x opts cond; do
+ IFS=$safeIFS
+ test -n "$x" || continue
+ genopt_scond
+ test -n "$cond" && echo "$cond"
+ echo "\"$opts\""
+ test -n "$cond" && echo "#endif"
+ done | {
+ echo "$o_hdr"
+ echo "#ifndef $o_sym$o_gen"
+ echo "#else"
+ cat
+ echo "#undef $o_sym"
+ echo "#endif"
+ } >"$bn.gen"
+ IFS=$safeIFS
+ return 0
+}
+
+if test x"$BUILDSH_RUN_GENOPT" = x"1"; then
+ set x -G "$srcfile"
+ shift
+fi
+if test x"$1" = x"-G"; then
+ do_genopt "$2"
+ exit $?
+fi
+
+echo "For the build logs, demonstrate that /dev/null and /dev/tty exist:"
+ls -l /dev/null /dev/tty
+
v() {
$e "$*"
eval "$@"
rmf() {
for _f in "$@"; do
- case ${_f} in
- mksh.1) ;;
- *) rm -f "${_f}" ;;
+ case $_f in
+ Build.sh|check.pl|check.t|dot.mkshrc|*.1|*.c|*.h|*.ico|*.opt) ;;
+ *) rm -f "$_f" ;;
esac
done
}
-if test -d /usr/xpg4/bin/. >/dev/null 2>&1; then
- # Solaris: some of the tools have weird behaviour, use portable ones
- PATH=/usr/xpg4/bin:$PATH
- export PATH
-fi
-
-if test -n "${ZSH_VERSION+x}" && (emulate sh) >/dev/null 2>&1; then
- emulate sh
- NULLCMD=:
-fi
-
-allu=QWERTYUIOPASDFGHJKLZXCVBNM
-alll=qwertyuiopasdfghjklzxcvbnm
-alln=0123456789
-alls=______________________________________________________________
-nl='
-'
tcfn=no
bi=
ui=
}
# pipe .c | ac_test[n] [!] label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
-ac_testn() {
+ac_testnnd() {
if test x"$1" = x"!"; then
fr=1
shift
else
fr=0
fi
- ac_testinit "$@" || return
+ ac_testinit "$@" || return 1
cat >conftest.c
vv ']' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN conftest.c $LIBS $ccpr"
test $tcfn = no && test -f a.out && tcfn=a.out
test $tcfn = no && test -f a.exe && tcfn=a.exe
+ test $tcfn = no && test -f conftest.exe && tcfn=conftest.exe
test $tcfn = no && test -f conftest && tcfn=conftest
if test -f $tcfn; then
test 1 = $fr || fv=1
test $ct = sunpro && vscan='-e ignored -e turned.off'
fi
test -n "$vscan" && grep $vscan vv.out >/dev/null 2>&1 && fv=$fr
+ return 0
+}
+ac_testn() {
+ ac_testnnd "$@" || return
rmf conftest.c conftest.o ${tcfn}* vv.out
ac_testdone
}
ac_ifcpp() {
expr=$1; shift
ac_testn "$@" <<-EOF
- int main(void) { return (
+ #include <unistd.h>
+ extern int thiswillneverbedefinedIhope(void);
+ int main(void) { return (isatty(0) +
#$expr
0
#else
test x"$fv" = x"1"
}
+add_cppflags() {
+ CPPFLAGS="$CPPFLAGS $*"
+}
+
ac_cppflags() {
test x"$1" = x"" || fu=$1
fv=$2
test x"$2" = x"" && eval fv=\$HAVE_$fu
- CPPFLAGS="$CPPFLAGS -DHAVE_$fu=$fv"
+ add_cppflags -DHAVE_$fu=$fv
}
ac_test() {
ac_cppflags
}
-# ac_flags [-] add varname flags [text]
+# ac_flags [-] add varname cflags [text] [ldflags]
ac_flags() {
if test x"$1" = x"-"; then
shift
vn=$2
f=$3
ft=$4
+ fl=$5
test x"$ft" = x"" && ft="if $f can be used"
save_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS $f"
+ if test -n "$fl"; then
+ save_LDFLAGS=$LDFLAGS
+ LDFLAGS="$LDFLAGS $fl"
+ fi
if test 1 = $hf; then
ac_testn can_$vn '' "$ft"
else
ac_testn can_$vn '' "$ft" <<-'EOF'
/* evil apo'stroph in comment test */
- int main(void) { return (0); }
+ #include <unistd.h>
+ int main(void) { return (isatty(0)); }
EOF
fi
eval fv=\$HAVE_CAN_`upper $vn`
+ if test -n "$fl"; then
+ test 11 = $fa$fv || LDFLAGS=$save_LDFLAGS
+ fi
test 11 = $fa$fv || CFLAGS=$save_CFLAGS
}
fi
hf=$1; shift
hv=`echo "$hf" | tr -d '\012\015' | tr -c $alll$allu$alln $alls`
+ echo "/* NeXTstep bug workaround */" >x
for i
do
- echo "#include <$i>" >>x
+ case $i in
+ _time)
+ echo '#if HAVE_BOTH_TIME_H' >>x
+ echo '#include <sys/time.h>' >>x
+ echo '#include <time.h>' >>x
+ echo '#elif HAVE_SYS_TIME_H' >>x
+ echo '#include <sys/time.h>' >>x
+ echo '#elif HAVE_TIME_H' >>x
+ echo '#include <time.h>' >>x
+ echo '#endif' >>x
+ ;;
+ *)
+ echo "#include <$i>" >>x
+ ;;
+ esac
done
echo "#include <$hf>" >>x
- echo 'int main(void) { return (0); }' >>x
+ echo '#include <unistd.h>' >>x
+ echo 'int main(void) { return (isatty(0)); }' >>x
ac_testn "$hv" "" "<$hf>" <x
rmf x
test 1 = $na || ac_cppflags
}
-if test -d mksh || test -d mksh.exe; then
- echo "$me: Error: ./mksh is a directory!" >&2
+curdir=`pwd` srcdir=`dirname "$0" 2>/dev/null`
+case x$srcdir in
+x)
+ srcdir=.
+ ;;
+*\ *|*" "*|*"$nl"*)
+ echo >&2 Source directory should not contain space or tab or newline.
+ echo >&2 Errors may occur.
+ ;;
+*"'"*)
+ echo Source directory must not contain single quotes.
exit 1
-fi
-rmf a.exe* a.out* conftest.c *core lft mksh* no *.bc *.ll *.o \
- Rebuild.sh signames.inc test.sh x vv.out
-
-curdir=`pwd` srcdir=`dirname "$0"` check_categories=
-test -n "$dirname" || dirname=.
-dstversion=`sed -n '/define MKSH_VERSION/s/^.*"\(.*\)".*$/\1/p' $srcdir/sh.h`
+ ;;
+esac
+dstversion=`sed -n '/define MKSH_VERSION/s/^.*"\([^"]*\)".*$/\1/p' "$srcdir/sh.h"`
+add_cppflags -DMKSH_BUILDSH
e=echo
r=0
pm=0
cm=normal
optflags=-std-compile-opts
+check_categories=
last=
+tfn=
+legacy=0
for i
do
case $last:$i in
- c:combine|c:dragonegg|c:llvm)
+ c:combine|c:dragonegg|c:llvm|c:lto)
cm=$i
last=
;;
optflags=$i
last=
;;
+ t:*)
+ tfn=$i
+ last=
+ ;;
:-c)
last=c
;;
- :-combine)
- cm=combine
- echo "$me: Warning: '$i' is deprecated, use '-c combine' instead!" >&2
+ :-G)
+ echo "$me: Do not call me with '-G'!" >&2
+ exit 1
;;
:-g)
# checker, debug, valgrind build
- CPPFLAGS="$CPPFLAGS -DDEBUG"
+ add_cppflags -DDEBUG
CFLAGS="$CFLAGS -g3 -fno-builtin"
;;
:-j)
pm=1
;;
- :-llvm)
- cm=llvm
- optflags=-std-compile-opts
- echo "$me: Warning: '$i' is deprecated, use '-c llvm -O' instead!" >&2
+ :-L)
+ legacy=1
;;
- :-llvm=*)
- cm=llvm
- optflags=`echo "x$i" | sed 's/^x-llvm=//'`
- echo "$me: Warning: '$i' is deprecated, use '-c llvm -o $llvm' instead!" >&2
+ :+L)
+ legacy=0
;;
:-M)
cm=makefile
:-r)
r=1
;;
+ :-t)
+ last=t
+ ;;
:-v)
echo "Build.sh $srcversion"
echo "for mksh $dstversion"
exit 1
fi
-SRCS="lalloc.c edit.c eval.c exec.c expr.c funcs.c histrap.c"
-SRCS="$SRCS jobs.c lex.c main.c misc.c shf.c syn.c tree.c var.c"
+test -z "$tfn" && if test $legacy = 0; then
+ tfn=mksh
+else
+ tfn=lksh
+fi
+if test -d $tfn || test -d $tfn.exe; then
+ echo "$me: Error: ./$tfn is a directory!" >&2
+ exit 1
+fi
+rmf a.exe* a.out* conftest.c conftest.exe* *core core.* ${tfn}* *.bc *.dbg \
+ *.ll *.o *.gen Rebuild.sh lft no signames.inc test.sh x vv.out
+
+SRCS="lalloc.c eval.c exec.c expr.c funcs.c histrap.c jobs.c"
+SRCS="$SRCS lex.c main.c misc.c shf.c syn.c tree.c var.c"
+
+if test $legacy = 0; then
+ SRCS="$SRCS edit.c"
+ check_categories="$check_categories shell:legacy-no int:32"
+else
+ check_categories="$check_categories shell:legacy-yes"
+ add_cppflags -DMKSH_LEGACY_MODE
+ HAVE_PERSISTENT_HISTORY=0
+fi
if test x"$srcdir" = x"."; then
CPPFLAGS="-I. $CPPFLAGS"
else
CPPFLAGS="-I. -I'$srcdir' $CPPFLAGS"
fi
+test -n "$LDSTATIC" && if test -n "$LDFLAGS"; then
+ LDFLAGS="$LDFLAGS $LDSTATIC"
+else
+ LDFLAGS=$LDSTATIC
+fi
-test x"$TARGET_OS" = x"" && TARGET_OS=`uname -s 2>/dev/null || uname`
+if test -z "$TARGET_OS"; then
+ x=`uname -s 2>/dev/null || uname`
+ test x"$x" = x"`uname -n 2>/dev/null`" || TARGET_OS=$x
+fi
+if test -z "$TARGET_OS"; then
+ echo "$me: Set TARGET_OS, your uname is broken!" >&2
+ exit 1
+fi
oswarn=
ccpc=-Wc,
ccpl=-Wl,
tsts=
-ccpr='|| for _f in ${tcfn}*; do test x"${_f}" = x"mksh.1" || rm -f "${_f}"; done'
+ccpr='|| for _f in ${tcfn}*; do case $_f in Build.sh|check.pl|check.t|dot.mkshrc|*.1|*.c|*.h|*.ico|*.opt) ;; *) rm -f "$_f" ;; esac; done'
+
+# Evil hack
+if test x"$TARGET_OS" = x"Android"; then
+ check_categories="$check_categories android"
+ TARGET_OS=Linux
+fi
+
+# Evil OS
+if test x"$TARGET_OS" = x"Minix"; then
+ echo >&2 "
+WARNING: additional checks before running Build.sh required!
+You can avoid these by calling Build.sh correctly, see below.
+"
+ cat >conftest.c <<'EOF'
+#include <sys/types.h>
+const char *
+#ifdef _NETBSD_SOURCE
+ct="Ninix3"
+#else
+ct="Minix3"
+#endif
+;
+EOF
+ ct=unknown
+ vv ']' "${CC-cc} -E $CFLAGS $CPPFLAGS $NOWARN conftest.c | grep ct= | tr -d \\\\015 >x"
+ sed 's/^/[ /' x
+ eval `cat x`
+ rmf x vv.out
+ case $ct in
+ Minix3|Ninix3)
+ echo >&2 "
+Warning: you set TARGET_OS to $TARGET_OS but that is ambiguous.
+Please set it to either Minix3 or Ninix3, whereas the latter is
+all versions of Minix with even partial NetBSD(R) userland. The
+value determined from your compiler for the current compilation
+(which may be wrong) is: $ct
+"
+ TARGET_OS=$ct
+ ;;
+ *)
+ echo >&2 "
+Warning: you set TARGET_OS to $TARGET_OS but that is ambiguous.
+Please set it to either Minix3 or Ninix3, whereas the latter is
+all versions of Minix with even partial NetBSD(R) userland. The
+proper value couldn't be determined, continue at your own risk.
+"
+ ;;
+ esac
+fi
# Configuration depending on OS revision, on OSes that need them
case $TARGET_OS in
-QNX)
+NEXTSTEP)
+ test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`hostinfo 2>&1 | \
+ grep 'NeXT Mach [0-9][0-9.]*:' | \
+ sed 's/^.*NeXT Mach \([0-9][0-9.]*\):.*$/\1/'`
+ ;;
+QNX|SCO_SV)
test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
;;
esac
# Configuration depending on OS name
case $TARGET_OS in
+386BSD)
+ : "${HAVE_CAN_OTWO=0}"
+ add_cppflags -DMKSH_NO_SIGSETJMP
+ add_cppflags -DMKSH_TYPEDEF_SIG_ATOMIC_T=int
+ ;;
AIX)
- CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
- : ${HAVE_SETLOCALE_CTYPE=0}
+ add_cppflags -D_ALL_SOURCE
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
BeOS)
- oswarn=' and will currently not work'
+ case $KSH_VERSION in
+ *MIRBSD\ KSH*)
+ oswarn="; it has minor issues"
+ ;;
+ *)
+ oswarn="; you must recompile mksh with"
+ oswarn="$oswarn${nl}itself in a second stage"
+ ;;
+ esac
+ # BeOS has no real tty either
+ add_cppflags -DMKSH_UNEMPLOYED
+ add_cppflags -DMKSH_DISABLE_TTY_WARNING
+ # BeOS doesn't have different UIDs and GIDs
+ add_cppflags -DMKSH__NO_SETEUGID
;;
BSD/OS)
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
+Coherent)
+ oswarn="; it has major issues"
+ add_cppflags -DMKSH__NO_SYMLINK
+ check_categories="$check_categories nosymlink"
+ add_cppflags -DMKSH__NO_SETEUGID
+ add_cppflags -DMKSH_DISABLE_TTY_WARNING
;;
CYGWIN*)
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
Darwin)
+ add_cppflags -D_DARWIN_C_SOURCE
;;
DragonFly)
;;
FreeBSD)
;;
+FreeMiNT)
+ oswarn="; it has minor issues"
+ add_cppflags -D_GNU_SOURCE
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
GNU)
- # define NO_PATH_MAX to use Hurd-only functions
- CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE -DNO_PATH_MAX"
+ case $CC in
+ *tendracc*) ;;
+ *) add_cppflags -D_GNU_SOURCE ;;
+ esac
+ add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
+ # define MKSH__NO_PATH_MAX to use Hurd-only functions
+ add_cppflags -DMKSH__NO_PATH_MAX
;;
GNU/kFreeBSD)
- CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
+ case $CC in
+ *tendracc*) ;;
+ *) add_cppflags -D_GNU_SOURCE ;;
+ esac
+ add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
;;
Haiku)
- CPPFLAGS="$CPPFLAGS -DMKSH_ASSUME_UTF8"
+ add_cppflags -DMKSH_ASSUME_UTF8; HAVE_ISSET_MKSH_ASSUME_UTF8=1
;;
HP-UX)
;;
Interix)
ccpc='-X '
ccpl='-Y '
- CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE"
- : ${LIBS='-lcrypt'}
- : ${HAVE_SETLOCALE_CTYPE=0}
+ add_cppflags -D_ALL_SOURCE
+ : "${LIBS=-lcrypt}"
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
IRIX*)
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
Linux)
- CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
- : ${HAVE_REVOKE=0}
+ case $CC in
+ *tendracc*) ;;
+ *) add_cppflags -D_GNU_SOURCE ;;
+ esac
+ add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
+ : "${HAVE_REVOKE=0}"
+ ;;
+LynxOS)
+ oswarn="; it has minor issues"
;;
MidnightBSD)
;;
-Minix)
- CPPFLAGS="$CPPFLAGS -DMKSH_UNEMPLOYED -DMKSH_CONSERVATIVE_FDS"
- CPPFLAGS="$CPPFLAGS -D_POSIX_SOURCE -D_POSIX_1_SOURCE=2 -D_MINIX"
+Minix-vmd)
+ add_cppflags -DMKSH__NO_SETEUGID
+ add_cppflags -DMKSH_UNEMPLOYED
+ add_cppflags -D_MINIX_SOURCE
+ oldish_ed=no-stderr-ed # no /bin/ed, maybe see below
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
+Minix3)
+ add_cppflags -DMKSH_UNEMPLOYED
+ add_cppflags -DMKSH_NO_LIMITS
+ add_cppflags -D_POSIX_SOURCE -D_POSIX_1_SOURCE=2 -D_MINIX
oldish_ed=no-stderr-ed # /usr/bin/ed(!) is broken
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
MirBSD)
;;
+MSYS_*)
+ add_cppflags -DMKSH_ASSUME_UTF8=0; HAVE_ISSET_MKSH_ASSUME_UTF8=1
+ # almost same as CYGWIN* (from RT|Chatzilla)
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ # broken on this OE (from ir0nh34d)
+ : "${HAVE_STDINT_H=0}"
+ ;;
NetBSD)
;;
+NEXTSTEP)
+ add_cppflags -D_NEXT_SOURCE
+ add_cppflags -D_POSIX_SOURCE
+ : "${AWK=gawk}"
+ : "${CC=cc -posix}"
+ add_cppflags -DMKSH_NO_SIGSETJMP
+ # NeXTstep cannot get a controlling tty
+ add_cppflags -DMKSH_UNEMPLOYED
+ case $TARGET_OSREV in
+ 4.2*)
+ # OpenStep 4.2 is broken by default
+ oswarn="; it needs libposix.a"
+ ;;
+ esac
+ ;;
+Ninix3)
+ # similar to Minix3
+ add_cppflags -DMKSH_UNEMPLOYED
+ add_cppflags -DMKSH_NO_LIMITS
+ # but no idea what else could be needed
+ oswarn="; it has unknown issues"
+ ;;
OpenBSD)
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
+OS/2)
+ HAVE_TERMIOS_H=0
+ HAVE_MKNOD=0 # setmode() incompatible
+ oswarn="; it is currently being ported"
+ check_categories="$check_categories nosymlink"
+ : "${CC=gcc}"
+ : "${SIZE=: size}"
+ add_cppflags -DMKSH_UNEMPLOYED
+ add_cppflags -DMKSH_NOPROSPECTOFWORK
;;
OSF1)
HAVE_SIG_T=0 # incompatible
- CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE -D_POSIX_C_SOURCE=200112L"
- CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=600 -D_XOPEN_SOURCE_EXTENDED"
- : ${HAVE_SETLOCALE_CTYPE=0}
+ add_cppflags -D_OSF_SOURCE
+ add_cppflags -D_POSIX_C_SOURCE=200112L
+ add_cppflags -D_XOPEN_SOURCE=600
+ add_cppflags -D_XOPEN_SOURCE_EXTENDED
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
Plan9)
- CPPFLAGS="$CPPFLAGS -D_POSIX_SOURCE -D_LIMITS_EXTENSION"
- CPPFLAGS="$CPPFLAGS -D_BSD_EXTENSION -D_SUSV2_SOURCE"
+ add_cppflags -D_POSIX_SOURCE
+ add_cppflags -D_LIMITS_EXTENSION
+ add_cppflags -D_BSD_EXTENSION
+ add_cppflags -D_SUSV2_SOURCE
+ add_cppflags -DMKSH_ASSUME_UTF8; HAVE_ISSET_MKSH_ASSUME_UTF8=1
+ add_cppflags -DMKSH_NO_CMDLINE_EDITING
+ add_cppflags -DMKSH__NO_SETEUGID
oswarn=' and will currently not work'
- CPPFLAGS="$CPPFLAGS -DMKSH_ASSUME_UTF8 -DMKSH_UNEMPLOYED"
+ add_cppflags -DMKSH_UNEMPLOYED
+ # this is for detecting kencc
+ add_cppflags -DMKSH_MAYBE_KENCC
;;
PW32*)
HAVE_SIG_T=0 # incompatible
oswarn=' and will currently not work'
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
;;
QNX)
- CPPFLAGS="$CPPFLAGS -D__NO_EXT_QNX"
+ add_cppflags -D__NO_EXT_QNX
+ add_cppflags -D__EXT_UNIX_MISC
case $TARGET_OSREV in
[012345].*|6.[0123].*|6.4.[01])
oldish_ed=no-stderr-ed # oldish /bin/ed is broken
;;
esac
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
+SCO_SV)
+ case $TARGET_OSREV in
+ 3.2*)
+ # SCO OpenServer 5
+ add_cppflags -DMKSH_UNEMPLOYED
+ ;;
+ 5*)
+ # SCO OpenServer 6
+ ;;
+ *)
+ oswarn='; this is an unknown version of'
+ oswarn="$oswarn$nl$TARGET_OS ${TARGET_OSREV}, please tell me what to do"
+ ;;
+ esac
+ : "${HAVE_SYS_SIGLIST=0}${HAVE__SYS_SIGLIST=0}"
+ ;;
+skyos)
+ oswarn="; it has minor issues"
;;
SunOS)
- CPPFLAGS="$CPPFLAGS -D_BSD_SOURCE -D__EXTENSIONS__"
+ add_cppflags -D_BSD_SOURCE
+ add_cppflags -D__EXTENSIONS__
;;
syllable)
- CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
+ add_cppflags -D_GNU_SOURCE
+ add_cppflags -DMKSH_NO_SIGSUSPEND
oswarn=' and will currently not work'
;;
ULTRIX)
- : ${CC=cc -YPOSIX}
- CPPFLAGS="$CPPFLAGS -Dssize_t=int"
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${CC=cc -YPOSIX}"
+ add_cppflags -DMKSH_TYPEDEF_SSIZE_T=int
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
+UnixWare|UNIX_SV)
+ # SCO UnixWare
+ : "${HAVE_SYS_SIGLIST=0}${HAVE__SYS_SIGLIST=0}"
;;
UWIN*)
ccpc='-Yc,'
tsts=" 3<>/dev/tty"
oswarn="; it will compile, but the target"
oswarn="$oswarn${nl}platform itself is very flakey/unreliable"
- : ${HAVE_SETLOCALE_CTYPE=0}
+ : "${HAVE_SETLOCALE_CTYPE=0}"
+ ;;
+_svr4)
+ # generic target for SVR4 Unix with uname -s = uname -n
+ # this duplicates the * target below
+ oswarn='; it may or may not work'
+ test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
;;
*)
oswarn='; it may or may not work'
+ test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
;;
esac
-: ${CC=cc} ${NROFF=nroff}
+: "${HAVE_MKNOD=0}"
+
+: "${AWK=awk}${CC=cc}${NROFF=nroff}${SIZE=size}"
test 0 = $r && echo | $NROFF -v 2>&1 | grep GNU >/dev/null 2>&1 && \
- NROFF="$NROFF -c"
+ echo | $NROFF -c >/dev/null 2>&1 && NROFF="$NROFF -c"
# this aids me in tracing FTBFSen without access to the buildd
$e "Hi from$ao $bi$srcversion$ao on:"
case $TARGET_OS in
+AIX)
+ vv '|' "oslevel >&2"
+ vv '|' "uname -a >&2"
+ ;;
Darwin)
vv '|' "hwprefs machine_type os_type os_class >&2"
+ vv '|' "sw_vers >&2"
+ vv '|' "system_profiler SPSoftwareDataType SPHardwareDataType >&2"
+ vv '|' "/bin/sh --version >&2"
+ vv '|' "xcodebuild -version >&2"
vv '|' "uname -a >&2"
+ vv '|' "sysctl kern.version hw.machine hw.model hw.memsize hw.availcpu hw.cpufrequency hw.byteorder hw.cpu64bit_capable >&2"
;;
IRIX*)
vv '|' "uname -a >&2"
vv '|' "uname -a >&2"
vv '|' "/usr/sbin/sizer -v >&2"
;;
+SCO_SV|UnixWare|UNIX_SV)
+ vv '|' "uname -a >&2"
+ vv '|' "uname -X >&2"
+ ;;
*)
vv '|' "uname -a >&2"
;;
a shell account to the developer, this may improve; please
drop us a success or failure notice or even send in diffs.
"
-$e "$bi$me: Building the MirBSD Korn Shell$ao $ui$dstversion$ao"
+$e "$bi$me: Building the MirBSD Korn Shell$ao $ui$dstversion$ao on $TARGET_OS ${TARGET_OSREV}..."
#
# Begin of mirtoconf checks
CPP="$CC -E"
$e ... which compiler seems to be used
cat >conftest.c <<'EOF'
+const char *
#if defined(__ICC) || defined(__INTEL_COMPILER)
-ct=icc
+ct="icc"
#elif defined(__xlC__) || defined(__IBMC__)
-ct=xlc
+ct="xlc"
#elif defined(__SUNPRO_C)
-ct=sunpro
+ct="sunpro"
#elif defined(__ACK__)
-ct=ack
+ct="ack"
#elif defined(__BORLANDC__)
-ct=bcc
+ct="bcc"
#elif defined(__WATCOMC__)
-ct=watcom
+ct="watcom"
#elif defined(__MWERKS__)
-ct=metrowerks
+ct="metrowerks"
#elif defined(__HP_cc)
-ct=hpcc
+ct="hpcc"
#elif defined(__DECC) || (defined(__osf__) && !defined(__GNUC__))
-ct=dec
+ct="dec"
#elif defined(__PGI)
-ct=pgi
+ct="pgi"
#elif defined(__DMC__)
-ct=dmc
+ct="dmc"
#elif defined(_MSC_VER)
-ct=msc
+ct="msc"
#elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
-ct=adsp
+ct="adsp"
#elif defined(__IAR_SYSTEMS_ICC__)
-ct=iar
+ct="iar"
#elif defined(SDCC)
-ct=sdcc
+ct="sdcc"
#elif defined(__PCC__)
-ct=pcc
+ct="pcc"
#elif defined(__TenDRA__)
-ct=tendra
+ct="tendra"
#elif defined(__TINYC__)
-ct=tcc
+ct="tcc"
#elif defined(__llvm__) && defined(__clang__)
-ct=clang
+ct="clang"
#elif defined(__NWCC__)
-ct=nwcc
+ct="nwcc"
#elif defined(__GNUC__)
-ct=gcc
+ct="gcc"
#elif defined(_COMPILER_VERSION)
-ct=mipspro
+ct="mipspro"
#elif defined(__sgi)
-ct=mipspro
+ct="mipspro"
#elif defined(__hpux) || defined(__hpua)
-ct=hpcc
+ct="hpcc"
#elif defined(__ultrix)
-ct=ucode
+ct="ucode"
+#elif defined(__USLC__)
+ct="uslc"
+#elif defined(__LCC__)
+ct="lcc"
+#elif defined(MKSH_MAYBE_KENCC)
+/* and none of the above matches */
+ct="kencc"
+#else
+ct="unknown"
+#endif
+;
+const char *
+#if defined(__KLIBC__) && !defined(__OS2__)
+et="klibc"
#else
-ct=unknown
+et="unknown"
#endif
+;
EOF
-ct=unknown
-vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c | grep ct= | tr -d \\\\015 >x"
+ct=untested
+et=untested
+vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c | \
+ sed -n '/^ *[ce]t *= */s/^ *\([ce]t\) *= */\1=/p' | tr -d \\\\015 >x"
sed 's/^/[ /' x
eval `cat x`
rmf x vv.out
-echo 'int main(void) { return (0); }' >conftest.c
+cat >conftest.c <<'EOF'
+#include <unistd.h>
+int main(void) { return (isatty(0)); }
+EOF
case $ct in
ack)
# work around "the famous ACK const bug"
clang)
# does not work with current "ccc" compiler driver
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
- # this works, for now
+ # one of these two works, for now
vv '|' "${CLANG-clang} -version"
+ vv '|' "${CLANG-clang} --version"
# ensure compiler and linker are in sync unless overridden
case $CCC_CC:$CCC_LD in
:*) ;;
*:) CCC_LD=$CCC_CC; export CCC_LD ;;
esac
+ : "${HAVE_STRING_POOLING=i1}"
;;
dec)
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
vv '|' 'echo `$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS \
-dumpmachine` gcc`$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN \
$LIBS -dumpversion`'
+ : "${HAVE_STRING_POOLING=i2}"
;;
hpcc)
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
icc)
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
;;
+kencc)
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
+ ;;
+lcc)
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
+ add_cppflags -D__inline__=__inline
+ ;;
metrowerks)
echo >&2 'Warning: Metrowerks C compiler detected. This has not yet
been tested for compatibility with mksh. Continue at your
;;
tendra)
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V 2>&1 | \
- fgrep -i -e version -e release"
+ grep -F -i -e version -e release"
;;
ucode)
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -Wl,-V conftest.c $LIBS"
;;
+uslc)
+ case $TARGET_OS:$TARGET_OSREV in
+ SCO_SV:3.2*)
+ # SCO OpenServer 5
+ CFLAGS="$CFLAGS -g"
+ : "${HAVE_CAN_OTWO=0}${HAVE_CAN_OPTIMISE=0}"
+ ;;
+ esac
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
+ ;;
watcom)
- echo >&2 'Warning: Watcom C Compiler detected. This compiler has not yet
- been tested for compatibility with mksh. Continue at your
- own risk, please report success/failure to the developers.'
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
;;
xlc)
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -qversion"
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -qversion=verbose"
vv '|' "ld -V"
;;
*)
+ test x"$ct" = x"untested" && $e "!!! detecting preprocessor failed"
ct=unknown
+ vv "$CC --version"
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
+ vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
;;
esac
case $cm in
vv '|' "llc -version"
;;
esac
-$e "$bi==> which compiler seems to be used...$ao $ui$ct$ao"
-rmf conftest.c conftest.o conftest a.out* a.exe* vv.out
+etd=" on $et"
+case $et in
+klibc)
+ add_cppflags -DMKSH_NO_LIMITS
+ ;;
+unknown)
+ # nothing special detected, don’t worry
+ etd=
+ ;;
+*)
+ # huh?
+ ;;
+esac
+$e "$bi==> which compiler seems to be used...$ao $ui$ct$etd$ao"
+rmf conftest.c conftest.o conftest a.out* a.exe* conftest.exe* vv.out
#
# Compiler: works as-is, with -Wno-error and -Werror
if ac_ifcpp 'if 0' compiler_fails '' \
'if the compiler does not fail correctly'; then
save_CFLAGS=$CFLAGS
- : ${HAVE_CAN_DELEXE=x}
- if test $ct = dmc; then
- CFLAGS="$CFLAGS ${ccpl}/DELEXECUTABLE"
- ac_testn can_delexe compiler_fails 0 'for the /DELEXECUTABLE linker option' <<-EOF
- int main(void) { return (0); }
- EOF
- elif test $ct = dec; then
+ : "${HAVE_CAN_DELEXE=x}"
+ case $ct in
+ dec)
CFLAGS="$CFLAGS ${ccpl}-non_shared"
ac_testn can_delexe compiler_fails 0 'for the -non_shared linker option' <<-EOF
- int main(void) { return (0); }
+ #include <unistd.h>
+ int main(void) { return (isatty(0)); }
EOF
- else
+ ;;
+ dmc)
+ CFLAGS="$CFLAGS ${ccpl}/DELEXECUTABLE"
+ ac_testn can_delexe compiler_fails 0 'for the /DELEXECUTABLE linker option' <<-EOF
+ #include <unistd.h>
+ int main(void) { return (isatty(0)); }
+ EOF
+ ;;
+ *)
exit 1
- fi
+ ;;
+ esac
test 1 = $HAVE_CAN_DELEXE || CFLAGS=$save_CFLAGS
ac_testn compiler_still_fails '' 'if the compiler still does not fail correctly' <<-EOF
EOF
'if this could be tcc'; then
ct=tcc
CPP='cpp -D__TINYC__'
+ HAVE_COMPILER_KNOWN=1
fi
-if test $ct = sunpro; then
- test x"$save_NOWARN" = x"" && save_NOWARN='-errwarn=%none'
- ac_flags 0 errwarnnone "$save_NOWARN"
- test 1 = $HAVE_CAN_ERRWARNNONE || save_NOWARN=
- ac_flags 0 errwarnall "-errwarn=%all"
- test 1 = $HAVE_CAN_ERRWARNALL && DOWARN="-errwarn=%all"
-elif test $ct = hpcc; then
+case $ct in
+bcc)
+ save_NOWARN="${ccpc}-w"
+ DOWARN="${ccpc}-w!"
+ ;;
+dec)
+ # -msg_* flags not used yet, or is -w2 correct?
+ ;;
+dmc)
+ save_NOWARN="${ccpc}-w"
+ DOWARN="${ccpc}-wx"
+ ;;
+hpcc)
save_NOWARN=
DOWARN=+We
-elif test $ct = mipspro; then
+ ;;
+kencc)
+ save_NOWARN=
+ DOWARN=
+ ;;
+mipspro)
save_NOWARN=
DOWARN="-diag_error 1-10000"
-elif test $ct = msc; then
+ ;;
+msc)
save_NOWARN="${ccpc}/w"
DOWARN="${ccpc}/WX"
-elif test $ct = dmc; then
- save_NOWARN="${ccpc}-w"
- DOWARN="${ccpc}-wx"
-elif test $ct = bcc; then
- save_NOWARN="${ccpc}-w"
- DOWARN="${ccpc}-w!"
-elif test $ct = dec; then
- : -msg_* flags not used yet, or is -w2 correct?
-elif test $ct = xlc; then
- save_NOWARN=-qflag=i:e
- DOWARN=-qflag=i:i
-elif test $ct = tendra; then
+ ;;
+sunpro)
+ test x"$save_NOWARN" = x"" && save_NOWARN='-errwarn=%none'
+ ac_flags 0 errwarnnone "$save_NOWARN"
+ test 1 = $HAVE_CAN_ERRWARNNONE || save_NOWARN=
+ ac_flags 0 errwarnall "-errwarn=%all"
+ test 1 = $HAVE_CAN_ERRWARNALL && DOWARN="-errwarn=%all"
+ ;;
+tendra)
save_NOWARN=-w
-elif test $ct = ucode; then
+ ;;
+ucode)
save_NOWARN=
DOWARN=-w2
-else
+ ;;
+watcom)
+ save_NOWARN=
+ DOWARN=-Wc,-we
+ ;;
+xlc)
+ save_NOWARN=-qflag=i:e
+ DOWARN=-qflag=i:i
+ ;;
+*)
test x"$save_NOWARN" = x"" && save_NOWARN=-Wno-error
ac_flags 0 wnoerror "$save_NOWARN"
test 1 = $HAVE_CAN_WNOERROR || save_NOWARN=
ac_flags 0 werror -Werror
test 1 = $HAVE_CAN_WERROR && DOWARN=-Werror
-fi
-
-test $ct = icc && DOWARN="$DOWARN -wd1419"
+ test $ct = icc && DOWARN="$DOWARN -wd1419"
+ ;;
+esac
NOWARN=$save_NOWARN
#
#
i=`echo :"$orig_CFLAGS" | sed 's/^://' | tr -c -d $alll$allu$alln`
# optimisation: only if orig_CFLAGS is empty
-test x"$i" = x"" && if test $ct = sunpro; then
- cat >x <<-'EOF'
- int main(void) { return (0); }
- #define __IDSTRING_CONCAT(l,p) __LINTED__ ## l ## _ ## p
- #define __IDSTRING_EXPAND(l,p) __IDSTRING_CONCAT(l,p)
+test x"$i" = x"" && case $ct in
+hpcc)
+ phase=u
+ ac_flags 1 otwo +O2
+ phase=x
+ ;;
+kencc|tcc|tendra)
+ # no special optimisation
+ ;;
+sunpro)
+ cat >x <<-'EOF'
+ #include <unistd.h>
+ int main(void) { return (isatty(0)); }
+ #define __IDSTRING_CONCAT(l,p) __LINTED__ ## l ## _ ## p
+ #define __IDSTRING_EXPAND(l,p) __IDSTRING_CONCAT(l,p)
#define pad void __IDSTRING_EXPAND(__LINE__,x)(void) { }
EOF
yes pad | head -n 256 >>x
ac_flags - 1 otwo -xO2 <x
rmf x
-elif test $ct = hpcc; then
- phase=u
- ac_flags 1 otwo +O2
- phase=x
-elif test $ct = xlc; then
+ ;;
+xlc)
ac_flags 1 othree "-O3 -qstrict"
test 1 = $HAVE_CAN_OTHREE || ac_flags 1 otwo -O2
-elif test $ct = tcc || test $ct = tendra; then
- : no special optimisation
-else
+ ;;
+*)
ac_flags 1 otwo -O2
test 1 = $HAVE_CAN_OTWO || ac_flags 1 optimise -O
-fi
+ ;;
+esac
# other flags: just add them if they are supported
i=0
-if test $ct = gcc; then
+case $ct in
+bcc)
+ ac_flags 1 strpool "${ccpc}-d" 'if string pooling can be enabled'
+ ;;
+clang)
+ i=1
+ ;;
+dec)
+ ac_flags 0 verb -verbose
+ ac_flags 1 rodata -readonly_strings
+ ;;
+dmc)
+ ac_flags 1 decl "${ccpc}-r" 'for strict prototype checks'
+ ac_flags 1 schk "${ccpc}-s" 'for stack overflow checking'
+ ;;
+gcc)
# The following tests run with -Werror (gcc only) if possible
NOWARN=$DOWARN; phase=u
+ ac_flags 1 wnodeprecateddecls -Wno-deprecated-declarations
+ # mksh is not written in CFrustFrust!
+ ac_flags 1 no_eh_frame -fno-asynchronous-unwind-tables
ac_flags 1 fnostrictaliasing -fno-strict-aliasing
- ac_flags 1 fstackprotectorall -fstack-protector-all
- ac_flags 1 fwrapv -fwrapv
- test $cm = combine && ac_flags 0 combine \
- '-fwhole-program --combine' \
- 'if gcc supports -fwhole-program --combine'
+ ac_flags 1 fstackprotectorstrong -fstack-protector-strong
+ test 1 = $HAVE_CAN_FSTACKPROTECTORSTRONG || \
+ ac_flags 1 fstackprotectorall -fstack-protector-all
+ test $cm = dragonegg && case " $CC $CFLAGS $LDFLAGS " in
+ *\ -fplugin=*dragonegg*) ;;
+ *) ac_flags 1 fplugin_dragonegg -fplugin=dragonegg ;;
+ esac
+ case $cm in
+ combine)
+ fv=0
+ checks='7 8'
+ ;;
+ lto)
+ fv=0
+ checks='1 2 3 4 5 6 7 8'
+ ;;
+ *)
+ fv=1
+ ;;
+ esac
+ test $fv = 1 || for what in $checks; do
+ test $fv = 1 && break
+ case $what in
+ 1) t_cflags='-flto=jobserver'
+ t_ldflags='-fuse-linker-plugin'
+ t_use=1 t_name=fltojs_lp ;;
+ 2) t_cflags='-flto=jobserver' t_ldflags=''
+ t_use=1 t_name=fltojs_nn ;;
+ 3) t_cflags='-flto=jobserver'
+ t_ldflags='-fno-use-linker-plugin -fwhole-program'
+ t_use=1 t_name=fltojs_np ;;
+ 4) t_cflags='-flto'
+ t_ldflags='-fuse-linker-plugin'
+ t_use=1 t_name=fltons_lp ;;
+ 5) t_cflags='-flto' t_ldflags=''
+ t_use=1 t_name=fltons_nn ;;
+ 6) t_cflags='-flto'
+ t_ldflags='-fno-use-linker-plugin -fwhole-program'
+ t_use=1 t_name=fltons_np ;;
+ 7) t_cflags='-fwhole-program --combine' t_ldflags=''
+ t_use=0 t_name=combine cm=combine ;;
+ 8) fv=1 cm=normal ;;
+ esac
+ test $fv = 1 && break
+ ac_flags $t_use $t_name "$t_cflags" \
+ "if gcc supports $t_cflags $t_ldflags" "$t_ldflags"
+ done
i=1
-elif test $ct = icc; then
+ ;;
+hpcc)
+ phase=u
+ # probably not needed
+ #ac_flags 1 agcc -Agcc 'for support of GCC extensions'
+ phase=x
+ ;;
+icc)
ac_flags 1 fnobuiltinsetmode -fno-builtin-setmode
ac_flags 1 fnostrictaliasing -fno-strict-aliasing
ac_flags 1 fstacksecuritycheck -fstack-security-check
i=1
-elif test $ct = sunpro; then
- phase=u
- ac_flags 1 v -v
- ac_flags 1 xc99 -xc99 'for support of ISO C99'
- ac_flags 1 ipo -xipo 'for cross-module optimisation'
- phase=x
-elif test $ct = hpcc; then
- phase=u
- ac_flags 1 agcc -Agcc 'for support of GCC extensions'
- ac_flags 1 ac99 -AC99 'for support of ISO C99'
- phase=x
-elif test $ct = dec; then
- ac_flags 0 verb -verbose
- ac_flags 1 rodata -readonly_strings
-elif test $ct = dmc; then
- ac_flags 1 decl "${ccpc}-r" 'for strict prototype checks'
- ac_flags 1 schk "${ccpc}-s" 'for stack overflow checking'
-elif test $ct = bcc; then
- ac_flags 1 strpool "${ccpc}-d" 'if string pooling can be enabled'
-elif test $ct = mipspro; then
- ac_flags 1 xc99 -c99 'for support of ISO C99'
+ ;;
+mipspro)
ac_flags 1 fullwarn -fullwarn 'for remark output support'
-elif test $ct = msc; then
+ ;;
+msc)
ac_flags 1 strpool "${ccpc}/GF" 'if string pooling can be enabled'
echo 'int main(void) { char test[64] = ""; return (*test); }' >x
ac_flags - 1 stackon "${ccpc}/GZ" 'if stack checks can be enabled' <x
rmf x
ac_flags 1 wall "${ccpc}/Wall" 'to enable all warnings'
ac_flags 1 wp64 "${ccpc}/Wp64" 'to enable 64-bit warnings'
-elif test $ct = xlc; then
- ac_flags 1 x99 -qlanglvl=extc99
- test 1 = $HAVE_CAN_X99 || ac_flags 1 c99 -qlanglvl=stdc99
+ ;;
+nwcc)
+ i=1
+ #broken# ac_flags 1 ssp -stackprotect
+ ;;
+sunpro)
+ phase=u
+ ac_flags 1 v -v
+ ac_flags 1 ipo -xipo 'for cross-module optimisation'
+ phase=x
+ ;;
+tcc)
+ : #broken# ac_flags 1 boundschk -b
+ ;;
+tendra)
+ ac_flags 0 ysystem -Ysystem
+ test 1 = $HAVE_CAN_YSYSTEM && CPPFLAGS="-Ysystem $CPPFLAGS"
+ ac_flags 1 extansi -Xa
+ ;;
+xlc)
ac_flags 1 rodata "-qro -qroconst -qroptr"
ac_flags 1 rtcheck -qcheck=all
- ac_flags 1 rtchkc -qextchk
+ #ac_flags 1 rtchkc -qextchk # reported broken
ac_flags 1 wformat "-qformat=all -qformat=nozln"
#ac_flags 1 wp64 -qwarn64 # too verbose for now
-elif test $ct = tendra; then
- ac_flags 0 ysystem -Ysystem
- test 1 = $HAVE_CAN_YSYSTEM && CPPFLAGS="-Ysystem $CPPFLAGS"
- ac_flags 1 extansi -Xa
-elif test $ct = tcc; then
- ac_flags 1 boundschk -b
-elif test $ct = clang; then
- i=1
-elif test $ct = nwcc; then
- i=1
- #broken# ac_flags 1 ssp -stackprotect
-fi
+ ;;
+esac
# flags common to a subset of compilers (run with -Werror on gcc)
if test 1 = $i; then
- ac_flags 1 stdg99 -std=gnu99 'for support of ISO C99 + GCC extensions'
- test 1 = $HAVE_CAN_STDG99 || \
- ac_flags 1 stdc99 -std=c99 'for support of ISO C99'
ac_flags 1 wall -Wall
+ ac_flags 1 fwrapv -fwrapv
fi
-phase=x
+# “on demand” means: GCC version >= 4
+fd='if to rely on compiler for string pooling'
+ac_cache string_pooling || case $HAVE_STRING_POOLING in
+2) fx=' (on demand, cached)' ;;
+i1) fv=1 ;;
+i2) fv=2; fx=' (on demand)' ;;
+esac
+ac_testdone
+test x"$HAVE_STRING_POOLING" = x"0" || ac_cppflags
+
+phase=x
# The following tests run with -Werror or similar (all compilers) if possible
NOWARN=$DOWARN
test $ct = pcc && phase=u
#
# Compiler: check for stuff that only generates warnings
#
-ac_test attribute_bounded '' 'for __attribute__((bounded))' <<-'EOF'
- #if defined(__GNUC__) && (__GNUC__ < 2)
- /* force a failure: gcc 1.42 has a false positive here */
+ac_test attribute_bounded '' 'for __attribute__((__bounded__))' <<-'EOF'
+ #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
+ extern int thiswillneverbedefinedIhope(void);
+ /* force a failure: TenDRA and gcc 1.42 have false positive here */
int main(void) { return (thiswillneverbedefinedIhope()); }
#else
#include <string.h>
#undef __attribute__
int xcopy(const void *, void *, size_t)
- __attribute__((bounded (buffer, 1, 3)))
- __attribute__((bounded (buffer, 2, 3)));
+ __attribute__((__bounded__(__buffer__, 1, 3)))
+ __attribute__((__bounded__(__buffer__, 2, 3)));
int main(int ac, char *av[]) { return (xcopy(av[0], av[--ac], 1)); }
int xcopy(const void *s, void *d, size_t n) {
+ /*
+ * if memmove does not exist, we are not on a system
+ * with GCC with __bounded__ attribute either so poo
+ */
memmove(d, s, n); return ((int)n);
}
#endif
EOF
-ac_test attribute_format '' 'for __attribute__((format))' <<-'EOF'
- #if defined(__GNUC__) && (__GNUC__ < 2)
- /* force a failure: gcc 1.42 has a false positive here */
+ac_test attribute_format '' 'for __attribute__((__format__))' <<-'EOF'
+ #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
+ extern int thiswillneverbedefinedIhope(void);
+ /* force a failure: TenDRA and gcc 1.42 have false positive here */
int main(void) { return (thiswillneverbedefinedIhope()); }
#else
+ #define fprintf printfoo
#include <stdio.h>
#undef __attribute__
- #undef printf
- extern int printf(const char *format, ...)
- __attribute__((format (printf, 1, 2)));
- int main(int ac, char **av) { return (printf("%s%d", *av, ac)); }
+ #undef fprintf
+ extern int fprintf(FILE *, const char *format, ...)
+ __attribute__((__format__(__printf__, 2, 3)));
+ int main(int ac, char **av) { return (fprintf(stderr, "%s%d", *av, ac)); }
#endif
EOF
-ac_test attribute_nonnull '' 'for __attribute__((nonnull))' <<-'EOF'
- #if defined(__GNUC__) && (__GNUC__ < 2)
- /* force a failure: gcc 1.42 has a false positive here */
+ac_test attribute_noreturn '' 'for __attribute__((__noreturn__))' <<-'EOF'
+ #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
+ extern int thiswillneverbedefinedIhope(void);
+ /* force a failure: TenDRA and gcc 1.42 have false positive here */
int main(void) { return (thiswillneverbedefinedIhope()); }
#else
- int foo(char *s1, char *s2) __attribute__((nonnull));
- int bar(char *s1, char *s2) __attribute__((nonnull (1, 2)));
- int baz(char *s) __attribute__((nonnull (1)));
- int foo(char *s1, char *s2) { return (bar(s2, s1)); }
- int bar(char *s1, char *s2) { return (baz(s1) - baz(s2)); }
- int baz(char *s) { return (*s); }
- int main(int ac, char **av) { return (ac == foo(av[0], av[ac-1])); }
+ #include <stdlib.h>
+ #undef __attribute__
+ void fnord(void) __attribute__((__noreturn__));
+ int main(void) { fnord(); }
+ void fnord(void) { exit(0); }
#endif
EOF
-ac_test attribute_noreturn '' 'for __attribute__((noreturn))' <<-'EOF'
- #if defined(__GNUC__) && (__GNUC__ < 2)
- /* force a failure: gcc 1.42 has a false positive here */
+ac_test attribute_pure '' 'for __attribute__((__pure__))' <<-'EOF'
+ #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
+ extern int thiswillneverbedefinedIhope(void);
+ /* force a failure: TenDRA and gcc 1.42 have false positive here */
int main(void) { return (thiswillneverbedefinedIhope()); }
#else
- #include <stdlib.h>
+ #include <unistd.h>
#undef __attribute__
- void fnord(void) __attribute__((noreturn));
- int main(void) { fnord(); }
- void fnord(void) { exit(0); }
+ int foo(const char *) __attribute__((__pure__));
+ int main(int ac, char **av) { return (foo(av[ac - 1]) + isatty(0)); }
+ int foo(const char *s) { return ((int)s[0]); }
#endif
EOF
-ac_test attribute_unused '' 'for __attribute__((unused))' <<-'EOF'
- #if defined(__GNUC__) && (__GNUC__ < 2)
- /* force a failure: gcc 1.42 has a false positive here */
+ac_test attribute_unused '' 'for __attribute__((__unused__))' <<-'EOF'
+ #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
+ extern int thiswillneverbedefinedIhope(void);
+ /* force a failure: TenDRA and gcc 1.42 have false positive here */
int main(void) { return (thiswillneverbedefinedIhope()); }
#else
- int main(int ac __attribute__((unused)), char **av
- __attribute__((unused))) { return (0); }
+ #include <unistd.h>
+ #undef __attribute__
+ int main(int ac __attribute__((__unused__)), char **av
+ __attribute__((__unused__))) { return (isatty(0)); }
#endif
EOF
-ac_test attribute_used '' 'for __attribute__((used))' <<-'EOF'
- #if defined(__GNUC__) && (__GNUC__ < 2)
- /* force a failure: gcc 1.42 has a false positive here */
+ac_test attribute_used '' 'for __attribute__((__used__))' <<-'EOF'
+ #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
+ extern int thiswillneverbedefinedIhope(void);
+ /* force a failure: TenDRA and gcc 1.42 have false positive here */
int main(void) { return (thiswillneverbedefinedIhope()); }
#else
- static const char fnord[] __attribute__((used)) = "42";
- int main(void) { return (0); }
+ #include <unistd.h>
+ #undef __attribute__
+ static const char fnord[] __attribute__((__used__)) = "42";
+ int main(void) { return (isatty(0)); }
#endif
EOF
#
if ac_ifcpp 'ifdef MKSH_SMALL' isset_MKSH_SMALL '' \
"if a reduced-feature mksh is requested"; then
- #XXX this sucks; fix it for *all* compilers
- case $ct in
- clang|icc|nwcc)
- ac_flags 1 fnoinline -fno-inline
- ;;
- gcc)
- NOWARN=$DOWARN; phase=u
- ac_flags 1 fnoinline -fno-inline
- NOWARN=$save_NOWARN; phase=x
- ;;
- sunpro)
- ac_flags 1 fnoinline -xinline=
- ;;
- xlc)
- ac_flags 1 fnoinline -qnoinline
- ;;
- esac
-
- : ${HAVE_MKNOD=0}
- : ${HAVE_NICE=0}
- : ${HAVE_REVOKE=0}
- : ${HAVE_PERSISTENT_HISTORY=0}
- check_categories=$check_categories,smksh
- HAVE_ISSET_MKSH_CONSERVATIVE_FDS=1 # from sh.h
+ : "${HAVE_NICE=0}"
+ : "${HAVE_PERSISTENT_HISTORY=0}"
+ check_categories="$check_categories smksh"
fi
-ac_ifcpp 'ifdef MKSH_BINSHREDUCED' isset_MKSH_BINSHREDUCED '' \
- "if a reduced-feature sh is requested" && \
- check_categories=$check_categories,binsh
+ac_ifcpp 'if defined(MKSH_BINSHPOSIX) || defined(MKSH_BINSHREDUCED)' \
+ isset_MKSH_BINSH '' 'if invoking as sh should be handled specially' && \
+ check_categories="$check_categories binsh"
ac_ifcpp 'ifdef MKSH_UNEMPLOYED' isset_MKSH_UNEMPLOYED '' \
"if mksh will be built without job control" && \
- check_categories=$check_categories,arge
+ check_categories="$check_categories arge"
+ac_ifcpp 'ifdef MKSH_NOPROSPECTOFWORK' isset_MKSH_NOPROSPECTOFWORK '' \
+ "if mksh will be built without job signals" && \
+ check_categories="$check_categories arge nojsig"
ac_ifcpp 'ifdef MKSH_ASSUME_UTF8' isset_MKSH_ASSUME_UTF8 '' \
- 'if the default UTF-8 mode is specified' && : ${HAVE_SETLOCALE_CTYPE=0}
-ac_ifcpp 'ifdef MKSH_CONSERVATIVE_FDS' isset_MKSH_CONSERVATIVE_FDS '' \
- 'if traditional/conservative fd use is requested' && \
- check_categories=$check_categories,convfds
+ 'if the default UTF-8 mode is specified' && : "${HAVE_SETLOCALE_CTYPE=0}"
+#ac_ifcpp 'ifdef MKSH_DISABLE_DEPRECATED' isset_MKSH_DISABLE_DEPRECATED '' \
+# "if deprecated features are to be omitted" && \
+# check_categories="$check_categories nodeprecated"
+#ac_ifcpp 'ifdef MKSH_DISABLE_EXPERIMENTAL' isset_MKSH_DISABLE_EXPERIMENTAL '' \
+# "if experimental features are to be omitted" && \
+# check_categories="$check_categories noexperimental"
+ac_ifcpp 'ifdef MKSH_MIDNIGHTBSD01ASH_COMPAT' isset_MKSH_MIDNIGHTBSD01ASH_COMPAT '' \
+ 'if the MidnightBSD 0.1 ash compatibility mode is requested' && \
+ check_categories="$check_categories mnbsdash"
#
# Environment: headers
#
-ac_header sys/param.h
+ac_header sys/time.h sys/types.h
+ac_header time.h sys/types.h
+test "11" = "$HAVE_SYS_TIME_H$HAVE_TIME_H" || HAVE_BOTH_TIME_H=0
+ac_test both_time_h '' 'whether <sys/time.h> and <time.h> can both be included' <<-'EOF'
+ #include <sys/types.h>
+ #include <sys/time.h>
+ #include <time.h>
+ #include <unistd.h>
+ int main(void) { struct tm tm; return ((int)sizeof(tm) + isatty(0)); }
+EOF
+ac_header sys/bsdtypes.h
+ac_header sys/file.h sys/types.h
ac_header sys/mkdev.h sys/types.h
ac_header sys/mman.h sys/types.h
+ac_header sys/param.h
+ac_header sys/resource.h sys/types.h _time
+ac_header sys/select.h sys/types.h
ac_header sys/sysmacros.h
+ac_header bstring.h
ac_header grp.h sys/types.h
+ac_header io.h
ac_header libgen.h
ac_header libutil.h sys/types.h
ac_header paths.h
-ac_header stdbool.h
ac_header stdint.h stdarg.h
-ac_header strings.h sys/types.h
+# include strings.h only if compatible with string.h
+ac_header strings.h sys/types.h string.h
+ac_header termios.h
ac_header ulimit.h sys/types.h
ac_header values.h
# Environment: definitions
#
echo '#include <sys/types.h>
+#include <unistd.h>
/* check that off_t can represent 2^63-1 correctly, thx FSF */
-#define LARGE_OFF_T (((off_t)1 << 62) - 1 + ((off_t)1 << 62))
+#define LARGE_OFF_T ((((off_t)1 << 31) << 31) - 1 + (((off_t)1 << 31) << 31))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 &&
LARGE_OFF_T % 2147483647 == 1) ? 1 : -1];
-int main(void) { return (0); }' >lft.c
+int main(void) { return (isatty(0)); }' >lft.c
ac_testn can_lfs '' "for large file support" <lft.c
save_CPPFLAGS=$CPPFLAGS
-CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64"
+add_cppflags -D_FILE_OFFSET_BITS=64
ac_testn can_lfs_sus '!' can_lfs 0 "... with -D_FILE_OFFSET_BITS=64" <lft.c
if test 0 = $HAVE_CAN_LFS_SUS; then
- CPPFLAGS="$save_CPPFLAGS -D_LARGE_FILES=1"
+ CPPFLAGS=$save_CPPFLAGS
+ add_cppflags -D_LARGE_FILES=1
ac_testn can_lfs_aix '!' can_lfs 0 "... with -D_LARGE_FILES=1" <lft.c
test 1 = $HAVE_CAN_LFS_AIX || CPPFLAGS=$save_CPPFLAGS
fi
+rm -f lft.c
rmf lft* # end of large file support test
#
ac_test can_inttypes '!' stdint_h 1 "for standard 32-bit integer types" <<-'EOF'
#include <sys/types.h>
#include <stddef.h>
- int main(int ac, char **av) { return ((uint32_t)(ptrdiff_t)*av + (int32_t)ac); }
+ int main(int ac, char **av) { return ((uint32_t)(size_t)*av + (int32_t)ac); }
EOF
ac_test can_ucbints '!' can_inttypes 1 "for UCB 32-bit integer types" <<-'EOF'
#include <sys/types.h>
#include <stddef.h>
- int main(int ac, char **av) { return ((u_int32_t)(ptrdiff_t)*av + (int32_t)ac); }
+ int main(int ac, char **av) { return ((u_int32_t)(size_t)*av + (int32_t)ac); }
EOF
ac_test can_int8type '!' stdint_h 1 "for standard 8-bit integer type" <<-'EOF'
#include <sys/types.h>
#include <stddef.h>
- int main(int ac, char **av) { return ((uint8_t)(ptrdiff_t)av[ac]); }
+ int main(int ac, char **av) { return ((uint8_t)(size_t)av[ac]); }
EOF
ac_test can_ucbint8 '!' can_int8type 1 "for UCB 8-bit integer type" <<-'EOF'
#include <sys/types.h>
#include <stddef.h>
- int main(int ac, char **av) { return ((u_int8_t)(ptrdiff_t)av[ac]); }
+ int main(int ac, char **av) { return ((u_int8_t)(size_t)av[ac]); }
EOF
ac_test rlim_t <<-'EOF'
#include <sys/types.h>
+ #if HAVE_BOTH_TIME_H
#include <sys/time.h>
+ #include <time.h>
+ #elif HAVE_SYS_TIME_H
+ #include <sys/time.h>
+ #elif HAVE_TIME_H
+ #include <time.h>
+ #endif
+ #if HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
+ #endif
#include <unistd.h>
- int main(void) { return ((int)(rlim_t)0); }
+ int main(void) { return (((int)(rlim_t)0) + isatty(0)); }
EOF
# only testn: added later below
#include <sys/types.h>
#include <signal.h>
#include <stddef.h>
- int main(void) { return ((int)(ptrdiff_t)(sig_t)kill(0,0)); }
+ volatile sig_t foo = (sig_t)0;
+ int main(void) { return (foo == (sig_t)0); }
EOF
ac_testn sighandler_t '!' sig_t 0 <<-'EOF'
#include <sys/types.h>
#include <signal.h>
#include <stddef.h>
- int main(void) { return ((int)(ptrdiff_t)(sighandler_t)kill(0,0)); }
+ volatile sighandler_t foo = (sighandler_t)0;
+ int main(void) { return (foo == (sighandler_t)0); }
EOF
if test 1 = $HAVE_SIGHANDLER_T; then
- CPPFLAGS="$CPPFLAGS -Dsig_t=sighandler_t"
+ add_cppflags -Dsig_t=sighandler_t
HAVE_SIG_T=1
fi
#include <sys/types.h>
#include <signal.h>
#include <stddef.h>
- int main(void) { return ((int)(ptrdiff_t)(__sighandler_t)kill(0,0)); }
+ volatile __sighandler_t foo = (__sighandler_t)0;
+ int main(void) { return (foo == (__sighandler_t)0); }
EOF
if test 1 = $HAVE___SIGHANDLER_T; then
- CPPFLAGS="$CPPFLAGS -Dsig_t=__sighandler_t"
+ add_cppflags -Dsig_t=__sighandler_t
HAVE_SIG_T=1
fi
-test 1 = $HAVE_SIG_T || CPPFLAGS="$CPPFLAGS -Dsig_t=nosig_t"
+test 1 = $HAVE_SIG_T || add_cppflags -Dsig_t=nosig_t
ac_cppflags SIG_T
#
-# Environment: signals
+# check whether whatever we use for the final link will succeed
+#
+if test $cm = makefile; then
+ : nothing to check
+else
+ HAVE_LINK_WORKS=x
+ ac_testinit link_works '' 'checking if the final link command may succeed'
+ fv=1
+ cat >conftest.c <<-EOF
+ #define EXTERN
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ __RCSID("$srcversion");
+ int main(void) { printf("Hello, World!\\n"); return (isatty(0)); }
+EOF
+ case $cm in
+ llvm)
+ v "$CC $CFLAGS $CPPFLAGS $NOWARN -emit-llvm -c conftest.c" || fv=0
+ rmf $tfn.s
+ test $fv = 0 || v "llvm-link -o - conftest.o | opt $optflags | llc -o $tfn.s" || fv=0
+ test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn $tfn.s $LIBS $ccpr"
+ ;;
+ dragonegg)
+ v "$CC $CFLAGS $CPPFLAGS $NOWARN -S -flto conftest.c" || fv=0
+ test $fv = 0 || v "mv conftest.s conftest.ll"
+ test $fv = 0 || v "llvm-as conftest.ll" || fv=0
+ rmf $tfn.s
+ test $fv = 0 || v "llvm-link -o - conftest.bc | opt $optflags | llc -o $tfn.s" || fv=0
+ test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn $tfn.s $LIBS $ccpr"
+ ;;
+ combine)
+ v "$CC $CFLAGS $CPPFLAGS $LDFLAGS -fwhole-program --combine $NOWARN -o $tcfn conftest.c $LIBS $ccpr"
+ ;;
+ lto|normal)
+ cm=normal
+ v "$CC $CFLAGS $CPPFLAGS $NOWARN -c conftest.c" || fv=0
+ test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn conftest.o $LIBS $ccpr"
+ ;;
+ esac
+ test -f $tcfn || fv=0
+ ac_testdone
+ test $fv = 1 || exit 1
+fi
+
+#
+# Environment: errors and signals
#
test x"NetBSD" = x"$TARGET_OS" && $e Ignore the compatibility warning.
+ac_testn sys_errlist '' "the sys_errlist[] array and sys_nerr" <<-'EOF'
+ extern const int sys_nerr;
+ extern const char * const sys_errlist[];
+ extern int isatty(int);
+ int main(void) { return (*sys_errlist[sys_nerr - 1] + isatty(0)); }
+EOF
+ac_testn _sys_errlist '!' sys_errlist 0 "the _sys_errlist[] array and _sys_nerr" <<-'EOF'
+ extern const int _sys_nerr;
+ extern const char * const _sys_errlist[];
+ extern int isatty(int);
+ int main(void) { return (*_sys_errlist[_sys_nerr - 1] + isatty(0)); }
+EOF
+if test 1 = "$HAVE__SYS_ERRLIST"; then
+ add_cppflags -Dsys_nerr=_sys_nerr
+ add_cppflags -Dsys_errlist=_sys_errlist
+ HAVE_SYS_ERRLIST=1
+fi
+ac_cppflags SYS_ERRLIST
+
for what in name list; do
uwhat=`upper $what`
ac_testn sys_sig$what '' "the sys_sig${what}[] array" <<-EOF
- extern const char *const sys_sig${what}[];
- int main(void) { return (sys_sig${what}[0][0]); }
+ extern const char * const sys_sig${what}[];
+ extern int isatty(int);
+ int main(void) { return (sys_sig${what}[0][0] + isatty(0)); }
EOF
ac_testn _sys_sig$what '!' sys_sig$what 0 "the _sys_sig${what}[] array" <<-EOF
- extern const char *const _sys_sig${what}[];
- int main(void) { return (_sys_sig${what}[0][0]); }
+ extern const char * const _sys_sig${what}[];
+ extern int isatty(int);
+ int main(void) { return (_sys_sig${what}[0][0] + isatty(0)); }
EOF
- if eval "test 1 = \$HAVE__SYS_SIG$uwhat"; then
- CPPFLAGS="$CPPFLAGS -Dsys_sig$what=_sys_sig$what"
- eval "HAVE_SYS_SIG$uwhat=1"
+ eval uwhat_v=\$HAVE__SYS_SIG$uwhat
+ if test 1 = "$uwhat_v"; then
+ add_cppflags -Dsys_sig$what=_sys_sig$what
+ eval HAVE_SYS_SIG$uwhat=1
fi
ac_cppflags SYS_SIG$uwhat
done
-ac_test strsignal '!' sys_siglist 0 <<-'EOF'
- #include <string.h>
- #include <signal.h>
- int main(void) { return (strsignal(1)[0]); }
-EOF
-
#
# Environment: library functions
#
-ac_testn flock_ex '' 'flock and mmap' <<-'EOF'
+ac_test flock <<-'EOF'
#include <sys/types.h>
+ #include <fcntl.h>
+ #undef flock
+ #if HAVE_SYS_FILE_H
#include <sys/file.h>
- #include <sys/mman.h>
+ #endif
+ int main(void) { return (flock(0, LOCK_EX | LOCK_UN)); }
+EOF
+
+ac_test lock_fcntl '!' flock 1 'whether we can lock files with fcntl' <<-'EOF'
#include <fcntl.h>
- #include <stdlib.h>
- int main(void) { return ((void *)mmap(NULL, (size_t)flock(0, LOCK_EX),
- PROT_READ, MAP_PRIVATE, 0, (off_t)0) == (void *)NULL ? 1 :
- munmap(NULL, 0)); }
+ #undef flock
+ int main(void) {
+ struct flock lks;
+ lks.l_type = F_WRLCK | F_UNLCK;
+ return (fcntl(0, F_SETLKW, &lks));
+ }
EOF
ac_test getrusage <<-'EOF'
}
EOF
+ac_test getsid <<-'EOF'
+ #include <unistd.h>
+ int main(void) { return ((int)getsid(0)); }
+EOF
+
+ac_test gettimeofday <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ int main(void) { struct timeval tv; return (gettimeofday(&tv, NULL)); }
+EOF
+
ac_test killpg <<-'EOF'
#include <signal.h>
int main(int ac, char *av[]) { return (av[0][killpg(123, ac)]); }
EOF
+ac_test memmove <<-'EOF'
+ #include <sys/types.h>
+ #include <stddef.h>
+ #include <string.h>
+ #if HAVE_STRINGS_H
+ #include <strings.h>
+ #endif
+ int main(int ac, char *av[]) {
+ return (*(int *)(void *)memmove(av[0], av[1], (size_t)ac));
+ }
+EOF
+
ac_test mknod '' 'if to use mknod(), makedev() and friends' <<-'EOF'
#define MKSH_INCLUDES_ONLY
#include "sh.h"
}
EOF
-ac_test mkstemp <<-'EOF'
+ac_test mmap lock_fcntl 0 'for mmap and munmap' <<-'EOF'
+ #include <sys/types.h>
+ #if HAVE_SYS_FILE_H
+ #include <sys/file.h>
+ #endif
+ #if HAVE_SYS_MMAN_H
+ #include <sys/mman.h>
+ #endif
+ #include <stddef.h>
#include <stdlib.h>
- #include <unistd.h>
- int main(void) { char tmpl[] = "X"; return (mkstemp(tmpl)); }
+ int main(void) { return ((void *)mmap(NULL, (size_t)0,
+ PROT_READ, MAP_PRIVATE, 0, (off_t)0) == (void *)NULL ? 1 :
+ munmap(NULL, 0)); }
EOF
ac_test nice <<-'EOF'
ac_test setlocale_ctype '' 'setlocale(LC_CTYPE, "")' <<-'EOF'
#include <locale.h>
#include <stddef.h>
- int main(void) { return ((int)(ptrdiff_t)(void *)setlocale(LC_CTYPE, "")); }
+ int main(void) { return ((int)(size_t)(void *)setlocale(LC_CTYPE, "")); }
EOF
ac_test langinfo_codeset setlocale_ctype 0 'nl_langinfo(CODESET)' <<-'EOF'
#include <langinfo.h>
#include <stddef.h>
- int main(void) { return ((int)(ptrdiff_t)(void *)nl_langinfo(CODESET)); }
+ int main(void) { return ((int)(size_t)(void *)nl_langinfo(CODESET)); }
EOF
-ac_test setmode mknod 1 <<-'EOF'
- /* XXX imake style */
- /* XXX conditions correct? */
- #if defined(__MSVCRT__) || defined(__CYGWIN__)
- /* force a failure: Win32 setmode() is not what we want... */
- int main(void) { return (thiswillneverbedefinedIhope()); }
- #else
+ac_test select <<-'EOF'
#include <sys/types.h>
- #include <unistd.h>
- int main(int ac, char *av[]) { return (getmode(setmode(av[0]),
- (mode_t)ac)); }
+ #if HAVE_BOTH_TIME_H
+ #include <sys/time.h>
+ #include <time.h>
+ #elif HAVE_SYS_TIME_H
+ #include <sys/time.h>
+ #elif HAVE_TIME_H
+ #include <time.h>
+ #endif
+ #if HAVE_SYS_BSDTYPES_H
+ #include <sys/bsdtypes.h>
+ #endif
+ #if HAVE_SYS_SELECT_H
+ #include <sys/select.h>
+ #endif
+ #if HAVE_BSTRING_H
+ #include <bstring.h>
+ #endif
+ #include <stddef.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #if HAVE_STRINGS_H
+ #include <strings.h>
#endif
+ #include <unistd.h>
+ int main(void) {
+ struct timeval tv = { 1, 200000 };
+ fd_set fds; FD_ZERO(&fds); FD_SET(0, &fds);
+ return (select(FD_SETSIZE, &fds, NULL, NULL, &tv));
+ }
EOF
ac_test setresugid <<-'EOF'
#include <sys/types.h>
#include <unistd.h>
- int main(void) { setresuid(0,0,0); return (setresgid(0,0,0)); }
+ int main(void) { return (setresuid(0,0,0) + setresgid(0,0,0)); }
EOF
ac_test setgroups setresugid 0 <<-'EOF'
int main(void) { gid_t gid = 0; return (setgroups(0, &gid)); }
EOF
-ac_test strcasestr <<-'EOF'
- #include <sys/types.h>
- #include <stddef.h>
+if test x"$et" = x"klibc"; then
+
+ ac_testn __rt_sigsuspend '' 'whether klibc uses RT signals' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ extern int __rt_sigsuspend(const sigset_t *, size_t);
+ int main(void) { return (__rt_sigsuspend(NULL, 0)); }
+EOF
+
+ # no? damn! legacy crap ahead!
+
+ ac_testn __sigsuspend_s '!' __rt_sigsuspend 1 \
+ 'whether sigsuspend is usable (1/2)' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ extern int __sigsuspend_s(sigset_t);
+ int main(void) { return (__sigsuspend_s(0)); }
+EOF
+ ac_testn __sigsuspend_xxs '!' __sigsuspend_s 1 \
+ 'whether sigsuspend is usable (2/2)' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ extern int __sigsuspend_xxs(int, int, sigset_t);
+ int main(void) { return (__sigsuspend_xxs(0, 0, 0)); }
+EOF
+
+ if test "000" = "$HAVE___RT_SIGSUSPEND$HAVE___SIGSUSPEND_S$HAVE___SIGSUSPEND_XXS"; then
+ # no usable sigsuspend(), use pause() *ugh*
+ add_cppflags -DMKSH_NO_SIGSUSPEND
+ fi
+fi
+
+ac_test strerror '!' sys_errlist 0 <<-'EOF'
+ extern char *strerror(int);
+ int main(int ac, char *av[]) { return (*strerror(*av[ac])); }
+EOF
+
+ac_test strsignal '!' sys_siglist 0 <<-'EOF'
#include <string.h>
- #if HAVE_STRINGS_H
- #include <strings.h>
- #endif
- int main(int ac, char *av[]) {
- return ((int)(ptrdiff_t)(void *)strcasestr(*av, av[ac]));
- }
+ #include <signal.h>
+ int main(void) { return (strsignal(1)[0]); }
EOF
ac_test strlcpy <<-'EOF'
#
# check headers for declarations
#
-save_CC=$CC; save_LDFLAGS=$LDFLAGS; save_LIBS=$LIBS
-CC="$CC -c -o $tcfn"; LDFLAGS=; LIBS=
-ac_test '!' flock_decl flock_ex 1 'if flock() does not need to be declared' <<-'EOF'
+ac_test flock_decl flock 1 'for declaration of flock()' <<-'EOF'
#define MKSH_INCLUDES_ONLY
#include "sh.h"
- long flock(void); /* this clashes if defined before */
- int main(void) { return ((int)flock()); }
+ #if HAVE_SYS_FILE_H
+ #include <sys/file.h>
+ #endif
+ int main(void) { return ((flock)(0, 0)); }
EOF
-ac_test '!' revoke_decl revoke 1 'if revoke() does not need to be declared' <<-'EOF'
+ac_test revoke_decl revoke 1 'for declaration of revoke()' <<-'EOF'
#define MKSH_INCLUDES_ONLY
#include "sh.h"
- long revoke(void); /* this clashes if defined before */
- int main(void) { return ((int)revoke()); }
+ int main(void) { return ((revoke)("")); }
EOF
-ac_test sys_siglist_decl sys_siglist 1 'if sys_siglist[] does not need to be declared' <<-'EOF'
+ac_test sys_errlist_decl sys_errlist 0 "for declaration of sys_errlist[] and sys_nerr" <<-'EOF'
#define MKSH_INCLUDES_ONLY
#include "sh.h"
- int main(void) { return (sys_siglist[0][0]); }
+ int main(void) { return (*sys_errlist[sys_nerr - 1] + isatty(0)); }
+EOF
+ac_test sys_siglist_decl sys_siglist 0 'for declaration of sys_siglist[]' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ int main(void) { return (sys_siglist[0][0] + isatty(0)); }
EOF
-CC=$save_CC; LDFLAGS=$save_LDFLAGS; LIBS=$save_LIBS
#
# other checks
#
fd='if to use persistent history'
-ac_cache PERSISTENT_HISTORY || test 0 = $HAVE_FLOCK_EX || fv=1
-test 1 = $fv || check_categories=$check_categories,no-histfile
+ac_cache PERSISTENT_HISTORY || case $HAVE_MMAP$HAVE_FLOCK$HAVE_LOCK_FCNTL in
+11*|101) fv=1 ;;
+esac
+test 1 = $fv || check_categories="$check_categories no-histfile"
ac_testdone
ac_cppflags
+save_CFLAGS=$CFLAGS
+ac_testn compile_time_asserts_$$ '' 'whether compile-time assertions pass' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ #ifndef CHAR_BIT
+ #define CHAR_BIT 8 /* defuse this test on really legacy systems */
+ #endif
+ struct ctasserts {
+ #define cta(name, assertion) char name[(assertion) ? 1 : -1]
+/* this one should be defined by the standard */
+cta(char_is_1_char, (sizeof(char) == 1) && (sizeof(signed char) == 1) &&
+ (sizeof(unsigned char) == 1));
+cta(char_is_8_bits, ((CHAR_BIT) == 8) && ((int)(unsigned char)0xFF == 0xFF) &&
+ ((int)(unsigned char)0x100 == 0) && ((int)(unsigned char)(int)-1 == 0xFF));
+/* the next assertion is probably not really needed */
+cta(short_is_2_char, sizeof(short) == 2);
+cta(short_size_no_matter_of_signedness, sizeof(short) == sizeof(unsigned short));
+/* the next assertion is probably not really needed */
+cta(int_is_4_char, sizeof(int) == 4);
+cta(int_size_no_matter_of_signedness, sizeof(int) == sizeof(unsigned int));
+
+cta(long_ge_int, sizeof(long) >= sizeof(int));
+cta(long_size_no_matter_of_signedness, sizeof(long) == sizeof(unsigned long));
+
+#ifndef MKSH_LEGACY_MODE
+/* the next assertion is probably not really needed */
+cta(ari_is_4_char, sizeof(mksh_ari_t) == 4);
+/* but this is */
+cta(ari_has_31_bit, 0 < (mksh_ari_t)(((((mksh_ari_t)1 << 15) << 15) - 1) * 2 + 1));
+/* the next assertion is probably not really needed */
+cta(uari_is_4_char, sizeof(mksh_uari_t) == 4);
+/* but the next three are; we REQUIRE unsigned integer wraparound */
+cta(uari_has_31_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 2 + 1));
+cta(uari_has_32_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3));
+cta(uari_wrap_32_bit,
+ (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3) >
+ (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 4));
+#define NUM 22
+#else
+#define NUM 16
+#endif
+/* these are always required */
+cta(ari_is_signed, (mksh_ari_t)-1 < (mksh_ari_t)0);
+cta(uari_is_unsigned, (mksh_uari_t)-1 > (mksh_uari_t)0);
+/* we require these to have the precisely same size and assume 2s complement */
+cta(ari_size_no_matter_of_signedness, sizeof(mksh_ari_t) == sizeof(mksh_uari_t));
+
+cta(sizet_size_no_matter_of_signedness, sizeof(ssize_t) == sizeof(size_t));
+cta(sizet_voidptr_same_size, sizeof(size_t) == sizeof(void *));
+cta(sizet_funcptr_same_size, sizeof(size_t) == sizeof(void (*)(void)));
+/* our formatting routines assume this */
+cta(ptr_fits_in_long, sizeof(size_t) <= sizeof(long));
+cta(ari_fits_in_long, sizeof(mksh_ari_t) <= sizeof(long));
+/* for struct alignment people */
+ char padding[64 - NUM];
+ };
+char ctasserts_dblcheck[sizeof(struct ctasserts) == 64 ? 1 : -1];
+ int main(void) { return (sizeof(ctasserts_dblcheck) + isatty(0)); }
+EOF
+CFLAGS=$save_CFLAGS
+eval test 1 = \$HAVE_COMPILE_TIME_ASSERTS_$$ || exit 1
+
+#
+# extra checks for legacy mksh
+#
+if test $legacy = 1; then
+ ac_test long_32bit '' 'whether long is 32 bit wide' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ #ifndef CHAR_BIT
+ #define CHAR_BIT 0
+ #endif
+ struct ctasserts {
+ #define cta(name, assertion) char name[(assertion) ? 1 : -1]
+ cta(char_is_8_bits, (CHAR_BIT) == 8);
+ cta(long_is_32_bits, sizeof(long) == 4);
+ };
+ int main(void) { return (sizeof(struct ctasserts)); }
+EOF
+
+ ac_test long_64bit '!' long_32bit 0 'whether long is 64 bit wide' <<-'EOF'
+ #define MKSH_INCLUDES_ONLY
+ #include "sh.h"
+ #ifndef CHAR_BIT
+ #define CHAR_BIT 0
+ #endif
+ struct ctasserts {
+ #define cta(name, assertion) char name[(assertion) ? 1 : -1]
+ cta(char_is_8_bits, (CHAR_BIT) == 8);
+ cta(long_is_64_bits, sizeof(long) == 8);
+ };
+ int main(void) { return (sizeof(struct ctasserts)); }
+EOF
+
+ case $HAVE_LONG_32BIT$HAVE_LONG_64BIT in
+ 10) check_categories="$check_categories int:32" ;;
+ 01) check_categories="$check_categories int:64" ;;
+ *) check_categories="$check_categories int:u" ;;
+ esac
+fi
+
#
# Compiler: Praeprocessor (only if needed)
#
# the character count to standard output; cope for that
echo wq >x
ed x <x 2>/dev/null | grep 3 >/dev/null 2>&1 && \
- check_categories=$check_categories,$oldish_ed
+ check_categories="$check_categories $oldish_ed"
rmf x vv.out
if test 0 = $HAVE_SYS_SIGNAME; then
else
$e No list of signal names available via cpp. Falling back...
fi
- sigseen=:
+ sigseenone=:
+ sigseentwo=:
echo '#include <signal.h>
-#ifndef NSIG
-#if defined(_NSIG)
-#define NSIG _NSIG
+#if defined(NSIG_MAX)
+#define cfg_NSIG NSIG_MAX
+#elif defined(NSIG)
+#define cfg_NSIG NSIG
+#elif defined(_NSIG)
+#define cfg_NSIG _NSIG
#elif defined(SIGMAX)
-#define NSIG (SIGMAX+1)
-#endif
+#define cfg_NSIG (SIGMAX + 1)
+#elif defined(_SIGMAX)
+#define cfg_NSIG (_SIGMAX + 1)
+#else
+/*XXX better error out, see sh.h */
+#define cfg_NSIG 64
#endif
-mksh_cfg: NSIG' >conftest.c
+int
+mksh_cfg= cfg_NSIG
+;' >conftest.c
+ # GNU sed 2.03 segfaults when optimising this to sed -n
NSIG=`vq "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c" | \
- grep mksh_cfg: | sed 's/^mksh_cfg:[ ]*\([0-9x ()+-]*\).*$/\1/'`
+ grep -v '^#' | \
+ sed '/mksh_cfg.*= *$/{
+ N
+ s/\n/ /
+ }' | \
+ grep '^ *mksh_cfg *=' | \
+ sed 's/^ *mksh_cfg *=[ ]*\([()0-9x+-][()0-9x+ -]*\).*$/\1/'`
case $NSIG in
- *[\ \(\)+-]*) NSIG=`awk "BEGIN { print $NSIG }"` ;;
+ *mksh_cfg*) $e "Error: NSIG='$NSIG'"; NSIG=0 ;;
+ *[\ \(\)+-]*) NSIG=`"$AWK" "BEGIN { print $NSIG }" </dev/null` ;;
esac
printf=printf
(printf hallo) >/dev/null 2>&1 || printf=echo
+ test $printf = echo || test "`printf %d 42`" = 42 || printf=echo
test $printf = echo || NSIG=`printf %d "$NSIG" 2>/dev/null`
$printf "NSIG=$NSIG ... "
- sigs="ABRT ALRM BUS CHLD CLD CONT DIL EMT FPE HUP ILL INFO INT IO IOT"
- sigs="$sigs KILL LOST PIPE PROF PWR QUIT RESV SAK SEGV STOP SYS TERM"
- sigs="$sigs TRAP TSTP TTIN TTOU URG USR1 USR2 VTALRM WINCH XCPU XFSZ"
+ sigs="ABRT FPE ILL INT SEGV TERM ALRM BUS CHLD CONT HUP KILL PIPE QUIT"
+ sigs="$sigs STOP TSTP TTIN TTOU USR1 USR2 POLL PROF SYS TRAP URG VTALRM"
+ sigs="$sigs XCPU XFSZ INFO WINCH EMT IO DIL LOST PWR SAK CLD IOT STKFLT"
+ sigs="$sigs ABND DCE DUMP IOERR TRACE DANGER THCONT THSTOP RESV UNUSED"
test 1 = $HAVE_CPP_DD && test $NSIG -gt 1 && sigs="$sigs "`vq \
"$CPP $CFLAGS $CPPFLAGS $NOWARN -dD conftest.c" | \
- grep '[ ]SIG[A-Z0-9]*[ ]' | \
- sed 's/^\(.*[ ]SIG\)\([A-Z0-9]*\)\([ ].*\)$/\2/' | sort`
+ grep '[ ]SIG[A-Z0-9][A-Z0-9]*[ ]' | \
+ sed 's/^.*[ ]SIG\([A-Z0-9][A-Z0-9]*\)[ ].*$/\1/' | sort`
test $NSIG -gt 1 || sigs=
for name in $sigs; do
+ case $sigseenone in
+ *:$name:*) continue ;;
+ esac
+ sigseenone=$sigseenone$name:
echo '#include <signal.h>' >conftest.c
- echo mksh_cfg: SIG$name >>conftest.c
+ echo int >>conftest.c
+ echo mksh_cfg= SIG$name >>conftest.c
+ echo ';' >>conftest.c
+ # GNU sed 2.03 croaks on optimising this, too
vq "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c" | \
- grep mksh_cfg: | \
- sed 's/^mksh_cfg:[ ]*\([0-9x]*\).*$/\1:'$name/
- done | grep -v '^:' | while IFS=: read nr name; do
+ grep -v '^#' | \
+ sed '/mksh_cfg.*= *$/{
+ N
+ s/\n/ /
+ }' | \
+ grep '^ *mksh_cfg *=' | \
+ sed 's/^ *mksh_cfg *=[ ]*\([0-9][0-9x]*\).*$/:\1 '$name/
+ done | sed -n '/^:[^ ]/s/^://p' | while read nr name; do
test $printf = echo || nr=`printf %d "$nr" 2>/dev/null`
- test $nr -gt 0 && test $nr -le $NSIG || continue
- case $sigseen in
+ test $nr -gt 0 && test $nr -lt $NSIG || continue
+ case $sigseentwo in
*:$nr:*) ;;
*) echo " { \"$name\", $nr },"
- sigseen=$sigseen$nr:
+ sigseentwo=$sigseentwo$nr:
$printf "$name=$nr " >&2
;;
esac
$e done.
fi
-addsrcs '!' HAVE_SETMODE setmode.c
addsrcs '!' HAVE_STRLCPY strlcpy.c
addsrcs USE_PRINTF_BUILTIN printf.c
-test 1 = "$USE_PRINTF_BUILTIN" && CPPFLAGS="$CPPFLAGS -DMKSH_PRINTF_BUILTIN"
-test 0 = "$HAVE_SETMODE" && CPPFLAGS="$CPPFLAGS -DHAVE_CONFIG_H -DCONFIG_H_FILENAME=\\\"sh.h\\\""
+test 1 = "$USE_PRINTF_BUILTIN" && add_cppflags -DMKSH_PRINTF_BUILTIN
test 1 = "$HAVE_CAN_VERB" && CFLAGS="$CFLAGS -verbose"
+add_cppflags -DMKSH_BUILD_R=530
$e $bi$me: Finished configuration testing, now producing output.$ao
files=
objs=
sp=
+case $tcfn in
+a.exe|conftest.exe)
+ mkshexe=$tfn.exe
+ add_cppflags -DMKSH_EXE_EXT
+ ;;
+*)
+ mkshexe=$tfn
+ ;;
+esac
case $curdir in
-*\ *) echo "#!./mksh" >test.sh ;;
-*) echo "#!$curdir/mksh" >test.sh ;;
+*\ *) mkshshebang="#!./$mkshexe" ;;
+*) mkshshebang="#!$curdir/$mkshexe" ;;
esac
-cat >>test.sh <<-EOF
+cat >test.sh <<-EOF
+ $mkshshebang
LC_ALL=C PATH='$PATH'; export LC_ALL PATH
test -n "\$KSH_VERSION" || exit 1
- check_categories=$check_categories
+ set -A check_categories -- $check_categories
+ pflag='$curdir/$mkshexe'
+ sflag='$srcdir/check.t'
+ usee=0 Pflag=0 Sflag=0 uset=0 vflag=1 xflag=0
+ while getopts "C:e:fPp:QSs:t:v" ch; do case \$ch {
+ (C) check_categories[\${#check_categories[*]}]=\$OPTARG ;;
+ (e) usee=1; eflag=\$OPTARG ;;
+ (f) check_categories[\${#check_categories[*]}]=fastbox ;;
+ (P) Pflag=1 ;;
+ (+P) Pflag=0 ;;
+ (p) pflag=\$OPTARG ;;
+ (Q) vflag=0 ;;
+ (+Q) vflag=1 ;;
+ (S) Sflag=1 ;;
+ (+S) Sflag=0 ;;
+ (s) sflag=\$OPTARG ;;
+ (t) uset=1; tflag=\$OPTARG ;;
+ (v) vflag=1 ;;
+ (+v) vflag=0 ;;
+ (*) xflag=1 ;;
+ }
+ done
+ shift \$((OPTIND - 1))
+ set -A args -- '$srcdir/check.pl' -p "\$pflag"
+ x=
+ for y in "\${check_categories[@]}"; do
+ x=\$x,\$y
+ done
+ if [[ -n \$x ]]; then
+ args[\${#args[*]}]=-C
+ args[\${#args[*]}]=\${x#,}
+ fi
+ if (( usee )); then
+ args[\${#args[*]}]=-e
+ args[\${#args[*]}]=\$eflag
+ fi
+ (( Pflag )) && args[\${#args[*]}]=-P
+ if (( uset )); then
+ args[\${#args[*]}]=-t
+ args[\${#args[*]}]=\$tflag
+ fi
+ (( vflag )) && args[\${#args[*]}]=-v
+ (( xflag )) && args[\${#args[*]}]=-x # force usage by synerr
+ if [[ -n \$TMPDIR && -d \$TMPDIR/. ]]; then
+ args[\${#args[*]}]=-T
+ args[\${#args[*]}]=\$TMPDIR
+ fi
print Testing mksh for conformance:
- fgrep MirOS: '$srcdir/check.t'
- fgrep MIRBSD '$srcdir/check.t'
+ grep -F -e Mir''OS: -e MIRBSD "\$sflag"
print "This shell is actually:\\n\\t\$KSH_VERSION"
print 'test.sh built for mksh $dstversion'
cstr='\$os = defined \$^O ? \$^O : "unknown";'
cstr="\$cstr"'print \$os . ", Perl version " . \$];'
for perli in \$PERL perl5 perl no; do
- [[ \$perli = no ]] && exit 1
- perlos=\$(\$perli -e "\$cstr") 2>&- || continue
- print "Perl interpreter '\$perli' running on '\$perlos'"
- [[ -n \$perlos ]] && break
+ if [[ \$perli = no ]]; then
+ print Cannot find a working Perl interpreter, aborting.
+ exit 1
+ fi
+ print "Trying Perl interpreter '\$perli'..."
+ perlos=\$(\$perli -e "\$cstr")
+ rv=\$?
+ print "Errorlevel \$rv, running on '\$perlos'"
+ if (( rv )); then
+ print "=> not using"
+ continue
+ fi
+ if [[ -n \$perlos ]]; then
+ print "=> using it"
+ break
+ fi
+ done
+ (( Sflag )) || echo + \$perli "\${args[@]}" -s "\$sflag" "\$@"
+ (( Sflag )) || exec \$perli "\${args[@]}" -s "\$sflag" "\$@"$tsts
+ # use of the -S option for check.t split into multiple chunks
+ rv=0
+ for s in "\$sflag".*; do
+ echo + \$perli "\${args[@]}" -s "\$s" "\$@"
+ \$perli "\${args[@]}" -s "\$s" "\$@"$tsts
+ rc=\$?
+ (( rv = rv ? rv : rc ))
done
- exec \$perli '$srcdir/check.pl' -s '$srcdir/check.t' -p '$curdir/mksh' \${check_categories:+-C} \${check_categories#,} \$*$tsts
+ exit \$rv
EOF
chmod 755 test.sh
-test $HAVE_CAN_COMBINE$cm = 0combine && cm=normal
-if test $cm = llvm; then
- emitbc="-emit-llvm -c"
-elif test $cm = dragonegg; then
+case $cm in
+dragonegg)
emitbc="-S -flto"
-else
+ ;;
+llvm)
+ emitbc="-emit-llvm -c"
+ ;;
+*)
emitbc=-c
-fi
-echo set -x >Rebuild.sh
+ ;;
+esac
+echo ": # work around NeXTstep bug" >Rebuild.sh
+cd "$srcdir"
+optfiles=`echo *.opt`
+cd "$curdir"
+for file in $optfiles; do
+ echo "echo + Running genopt on '$file'..."
+ echo "(srcfile='$srcdir/$file'; BUILDSH_RUN_GENOPT=1; . '$srcdir/Build.sh')"
+done >>Rebuild.sh
+echo set -x >>Rebuild.sh
for file in $SRCS; do
op=`echo x"$file" | sed 's/^x\(.*\)\.c$/\1./'`
test -f $file || file=$srcdir/$file
done
case $cm in
dragonegg|llvm)
- echo "rm -f mksh.s" >>Rebuild.sh
- echo "llvm-link -o - $objs | opt $optflags | llc -o mksh.s" >>Rebuild.sh
- lobjs=mksh.s
+ echo "rm -f $tfn.s" >>Rebuild.sh
+ echo "llvm-link -o - $objs | opt $optflags | llc -o $tfn.s" >>Rebuild.sh
+ lobjs=$tfn.s
;;
*)
lobjs=$objs
;;
esac
-case $tcfn in
-a.exe) mkshexe=mksh.exe ;;
-*) mkshexe=mksh ;;
-esac
echo tcfn=$mkshexe >>Rebuild.sh
echo "$CC $CFLAGS $LDFLAGS -o \$tcfn $lobjs $LIBS $ccpr" >>Rebuild.sh
-echo 'test -f $tcfn || exit 1; size $tcfn' >>Rebuild.sh
+echo "test -f \$tcfn || exit 1; $SIZE \$tcfn" >>Rebuild.sh
if test $cm = makefile; then
- extras='emacsfn.h sh.h sh_flags.h var_spec.h'
+ extras='emacsfn.h exprtok.h rlimits.opt sh.h sh_flags.opt var_spec.h'
test 0 = $HAVE_SYS_SIGNAME && extras="$extras signames.inc"
+ gens= genq=
+ for file in $optfiles; do
+ genf=`basename "$file" | sed 's/.opt$/.gen/'`
+ gens="$gens $genf"
+ genq="$genq$nl$genf: $srcdir/Build.sh $srcdir/$file
+ srcfile=$srcdir/$file; BUILDSH_RUN_GENOPT=1; . $srcdir/Build.sh"
+ done
cat >Makefrag.inc <<EOF
# Makefile fragment for building mksh $dstversion
LDFLAGS= $LDFLAGS
LIBS= $LIBS
+.depend \$(OBJS_BP):$gens$genq
+
# not BSD make only:
#VPATH= $srcdir
#all: \$(PROG)
# \$(CC) \$(CFLAGS) \$(CPPFLAGS) -c \$<
# for all make variants:
-#REGRESS_FLAGS= -v
+#REGRESS_FLAGS= -f
#regress:
# ./test.sh \$(REGRESS_FLAGS)
+check_categories=$check_categories
# for BSD make only:
#.PATH: $srcdir
$e Generated Makefrag.inc successfully.
exit 0
fi
+for file in $optfiles; do
+ $e "+ Running genopt on '$file'..."
+ do_genopt "$srcdir/$file" || exit 1
+done
if test $cm = combine; then
objs="-o $mkshexe"
for file in $SRCS; do
fi
case $cm in
dragonegg|llvm)
- rmf mksh.s
- v "llvm-link -o - $objs | opt $optflags | llc -o mksh.s"
+ rmf $tfn.s
+ v "llvm-link -o - $objs | opt $optflags | llc -o $tfn.s"
;;
esac
tcfn=$mkshexe
test $cm = combine || v "$CC $CFLAGS $LDFLAGS -o $tcfn $lobjs $LIBS $ccpr"
test -f $tcfn || exit 1
-test 1 = $r || v "$NROFF -mdoc <'$srcdir/mksh.1' >mksh.cat1" || \
- rmf mksh.cat1
-test 0 = $eq && v size $tcfn
+test 1 = $r || v "$NROFF -mdoc <'$srcdir/mksh.1' >$tfn.cat1" || \
+ rmf $tfn.cat1
+test 0 = $eq && v $SIZE $tcfn
i=install
test -f /usr/ucb/$i && i=/usr/ucb/$i
test 1 = $eq && e=:
$e
$e Installing the shell:
-$e "# $i -c -s -o root -g bin -m 555 mksh /bin/mksh"
-$e "# grep -x /bin/mksh /etc/shells >/dev/null || echo /bin/mksh >>/etc/shells"
-$e "# $i -c -o root -g bin -m 444 dot.mkshrc /usr/share/doc/mksh/examples/"
+$e "# $i -c -s -o root -g bin -m 555 $tfn /bin/$tfn"
+if test $legacy = 0; then
+ $e "# grep -x /bin/$tfn /etc/shells >/dev/null || echo /bin/$tfn >>/etc/shells"
+ $e "# $i -c -o root -g bin -m 444 dot.mkshrc /usr/share/doc/mksh/examples/"
+fi
$e
$e Installing the manual:
-if test -f mksh.cat1; then
- $e "# $i -c -o root -g bin -m 444 mksh.cat1" \
- "/usr/share/man/cat1/mksh.0"
+if test -f $tfn.cat1; then
+ $e "# $i -c -o root -g bin -m 444 $tfn.cat1" \
+ "/usr/share/man/cat1/$tfn.0"
$e or
fi
-$e "# $i -c -o root -g bin -m 444 mksh.1 /usr/share/man/man1/mksh.1"
+$e "# $i -c -o root -g bin -m 444 $tfn.1 /usr/share/man/man1/$tfn.1"
$e
$e Run the regression test suite: ./test.sh
$e Please also read the sample file dot.mkshrc and the fine manual.
exit 0
+
+: <<'EOD'
+
+=== Environment used ===
+
+==== build environment ====
+AWK default: awk
+CC default: cc
+CFLAGS if empty, defaults to -xO2 or +O2
+ or -O3 -qstrict or -O2, per compiler
+CPPFLAGS default empty
+LDFLAGS default empty; added before sources
+LDSTATIC set this to '-static'; default unset
+LIBS default empty; added after sources
+ [Interix] default: -lcrypt (XXX still needed?)
+NOWARN -Wno-error or similar
+NROFF default: nroff
+TARGET_OS default: $(uname -s || uname)
+TARGET_OSREV [QNX] default: $(uname -r)
+
+==== feature selectors ====
+USE_PRINTF_BUILTIN 1 to include (unsupported) printf(1) as builtin
+===== general format =====
+HAVE_STRLEN ac_test
+HAVE_STRING_H ac_header
+HAVE_CAN_FSTACKPROTECTORALL ac_flags
+
+==== cpp definitions ====
+DEBUG dont use in production, wants gcc, implies:
+DEBUG_LEAKS enable freeing resources before exiting
+MKSHRC_PATH "~/.mkshrc" (do not change)
+MKSH_A4PB force use of arc4random_pushb
+MKSH_ASSUME_UTF8 (0=disabled, 1=enabled; default: unset)
+MKSH_BINSHPOSIX if */sh or */-sh, enable set -o posix
+MKSH_BINSHREDUCED if */sh or */-sh, enable set -o sh
+MKSH_CLS_STRING "\033[;H\033[J"
+MKSH_DEFAULT_EXECSHELL "/bin/sh" (do not change)
+MKSH_DEFAULT_PROFILEDIR "/etc" (do not change)
+MKSH_DEFAULT_TMPDIR "/tmp" (do not change)
+MKSH_DISABLE_DEPRECATED disable code paths scheduled for later removal
+MKSH_DISABLE_EXPERIMENTAL disable code not yet comfy for (LTS) snapshots
+MKSH_DISABLE_TTY_WARNING shut up warning about ctty if OS cant be fixed
+MKSH_DONT_EMIT_IDSTRING omit RCS IDs from binary
+MKSH_MIDNIGHTBSD01ASH_COMPAT set -o sh: additional compatibility quirk
+MKSH_NOPROSPECTOFWORK disable jobs, co-processes, etc. (do not use)
+MKSH_NOPWNAM skip PAM calls, for -static on glibc or Solaris
+MKSH_NO_CMDLINE_EDITING disable command line editing code entirely
+MKSH_NO_DEPRECATED_WARNING omit warning when deprecated stuff is run
+MKSH_NO_LIMITS omit ulimit code
+MKSH_NO_SIGSETJMP define if sigsetjmp is broken or not available
+MKSH_NO_SIGSUSPEND use sigprocmask+pause instead of sigsuspend
+MKSH_SMALL omit some code, optimise hard for size (slower)
+MKSH_SMALL_BUT_FAST disable some hard-for-size optim. (modern sys.)
+MKSH_S_NOVI=1 disable Vi editing mode (default if MKSH_SMALL)
+MKSH_TYPEDEF_SIG_ATOMIC_T define to e.g. 'int' if sig_atomic_t is missing
+MKSH_TYPEDEF_SSIZE_T define to e.g. 'long' if your OS has no ssize_t
+MKSH_UNEMPLOYED disable job control (but not jobs/co-processes)
+
+=== generic installation instructions ===
+
+Set CC and possibly CFLAGS, CPPFLAGS, LDFLAGS, LIBS. If cross-compiling,
+also set TARGET_OS. To disable tests, set e.g. HAVE_STRLCPY=0; to enable
+them, set to a value other than 0 or 1. Ensure /bin/ed is installed. For
+MKSH_SMALL but with Vi mode, add -DMKSH_S_NOVI=0 to CPPFLAGS as well.
+
+Normally, the following command is what you want to run, then:
+$ (sh Build.sh -r -c lto && ./test.sh -f) 2>&1 | tee log
+
+Copy dot.mkshrc to /etc/skel/.mkshrc; install mksh into $prefix/bin; or
+/bin; install the manpage, if omitting the -r flag a catmanpage is made
+using $NROFF. Consider using a forward script as /etc/skel/.mkshrc like
+http://anonscm.debian.org/cgit/collab-maint/mksh.git/plain/debian/.mkshrc
+and put dot.mkshrc as /etc/mkshrc so users need not keep up their HOME.
+
+You may also want to install the lksh binary (also as /bin/sh) built by:
+$ CPPFLAGS="$CPPFLAGS -DMKSH_BINSHPOSIX" sh Build.sh -L -r -c lto
+
+EOD