1787 lines
46 KiB
Bash
1787 lines
46 KiB
Bash
#!/bin/sh
|
||
srcversion='$MirOS: src/bin/mksh/Build.sh,v 1.490 2011/11/25 23:29:30 tg Exp $'
|
||
#-
|
||
# Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
|
||
# Thorsten Glaser <tg@mirbsd.org>
|
||
#
|
||
# Provided that these terms and disclaimer and all copyright notices
|
||
# are retained or reproduced in an accompanying document, permission
|
||
# is granted to deal in this work without restriction, including un-
|
||
# limited rights to use, publicly perform, distribute, sell, modify,
|
||
# merge, give away, or sublicence.
|
||
#
|
||
# This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
|
||
# the utmost extent permitted by applicable law, neither express nor
|
||
# implied; without malicious intent or gross negligence. In no event
|
||
# may a licensor, author or contributor be held liable for indirect,
|
||
# direct, other damage, loss, or other issues arising in any way out
|
||
# of dealing in the work, even if advised of the possibility of such
|
||
# damage or existence of a defect, except proven that it results out
|
||
# of said person's immediate fault when using the work as intended.
|
||
#-
|
||
# 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
|
||
# MKSH_NO_DEPRECATED_WARNING MKSH_DONT_EMIT_IDSTRING
|
||
# MKSH_NOPROSPECTOFWORK MKSH_NO_EXTERNAL_CAT
|
||
|
||
LC_ALL=C
|
||
export LC_ALL
|
||
|
||
v() {
|
||
$e "$*"
|
||
eval "$@"
|
||
}
|
||
|
||
vv() {
|
||
_c=$1
|
||
shift
|
||
$e "\$ $*" 2>&1
|
||
eval "$@" >vv.out 2>&1
|
||
sed "s^${_c} " <vv.out
|
||
}
|
||
|
||
vq() {
|
||
eval "$@"
|
||
}
|
||
|
||
rmf() {
|
||
for _f in "$@"; do
|
||
case ${_f} in
|
||
mksh.1) ;;
|
||
*) 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=
|
||
ao=
|
||
fx=
|
||
me=`basename "$0"`
|
||
orig_CFLAGS=$CFLAGS
|
||
phase=x
|
||
oldish_ed=stdout-ed,no-stderr-ed
|
||
|
||
if test -t 1; then
|
||
bi='[1m'
|
||
ui='[4m'
|
||
ao='[0m'
|
||
fi
|
||
|
||
upper() {
|
||
echo :"$@" | sed 's/^://' | tr $alll $allu
|
||
}
|
||
|
||
# clean up after ac_testrun()
|
||
ac_testdone() {
|
||
eval HAVE_$fu=$fv
|
||
fr=no
|
||
test 0 = $fv || fr=yes
|
||
$e "$bi==> $fd...$ao $ui$fr$ao$fx"
|
||
fx=
|
||
}
|
||
|
||
# ac_cache label: sets f, fu, fv?=0
|
||
ac_cache() {
|
||
f=$1
|
||
fu=`upper $f`
|
||
eval fv=\$HAVE_$fu
|
||
case $fv in
|
||
0|1)
|
||
fx=' (cached)'
|
||
return 0
|
||
;;
|
||
esac
|
||
fv=0
|
||
return 1
|
||
}
|
||
|
||
# ac_testinit label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
|
||
# returns 1 if value was cached/implied, 0 otherwise: call ac_testdone
|
||
ac_testinit() {
|
||
if ac_cache $1; then
|
||
test x"$2" = x"!" && shift
|
||
test x"$2" = x"" || shift
|
||
fd=${3-$f}
|
||
ac_testdone
|
||
return 1
|
||
fi
|
||
fc=0
|
||
if test x"$2" = x""; then
|
||
ft=1
|
||
else
|
||
if test x"$2" = x"!"; then
|
||
fc=1
|
||
shift
|
||
fi
|
||
eval ft=\$HAVE_`upper $2`
|
||
shift
|
||
fi
|
||
fd=${3-$f}
|
||
if test $fc = "$ft"; then
|
||
fv=$2
|
||
fx=' (implied)'
|
||
ac_testdone
|
||
return 1
|
||
fi
|
||
$e ... $fd
|
||
return 0
|
||
}
|
||
|
||
# pipe .c | ac_test[n] [!] label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
|
||
ac_testn() {
|
||
if test x"$1" = x"!"; then
|
||
fr=1
|
||
shift
|
||
else
|
||
fr=0
|
||
fi
|
||
ac_testinit "$@" || return
|
||
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 && tcfn=conftest
|
||
if test -f $tcfn; then
|
||
test 1 = $fr || fv=1
|
||
else
|
||
test 0 = $fr || fv=1
|
||
fi
|
||
vscan=
|
||
if test $phase = u; then
|
||
test $ct = gcc && vscan='unrecogni[sz]ed'
|
||
test $ct = hpcc && vscan='unsupported'
|
||
test $ct = pcc && vscan='unsupported'
|
||
test $ct = sunpro && vscan='-e ignored -e turned.off'
|
||
fi
|
||
test -n "$vscan" && grep $vscan vv.out >/dev/null 2>&1 && fv=$fr
|
||
rmf conftest.c conftest.o ${tcfn}* vv.out
|
||
ac_testdone
|
||
}
|
||
|
||
# ac_ifcpp cppexpr [!] label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
|
||
ac_ifcpp() {
|
||
expr=$1; shift
|
||
ac_testn "$@" <<-EOF
|
||
int main(void) { return (
|
||
#$expr
|
||
0
|
||
#else
|
||
/* force a failure: expr is false */
|
||
thiswillneverbedefinedIhope()
|
||
#endif
|
||
); }
|
||
EOF
|
||
test x"$1" = x"!" && shift
|
||
f=$1
|
||
fu=`upper $f`
|
||
eval fv=\$HAVE_$fu
|
||
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
|
||
add_cppflags -DHAVE_$fu=$fv
|
||
}
|
||
|
||
ac_test() {
|
||
ac_testn "$@"
|
||
ac_cppflags
|
||
}
|
||
|
||
# ac_flags [-] add varname cflags [text] [ldflags]
|
||
ac_flags() {
|
||
if test x"$1" = x"-"; then
|
||
shift
|
||
hf=1
|
||
else
|
||
hf=0
|
||
fi
|
||
fa=$1
|
||
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); }
|
||
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
|
||
}
|
||
|
||
# ac_header [!] header [prereq ...]
|
||
ac_header() {
|
||
if test x"$1" = x"!"; then
|
||
na=1
|
||
shift
|
||
else
|
||
na=0
|
||
fi
|
||
hf=$1; shift
|
||
hv=`echo "$hf" | tr -d '\012\015' | tr -c $alll$allu$alln $alls`
|
||
for i
|
||
do
|
||
echo "#include <$i>" >>x
|
||
done
|
||
echo "#include <$hf>" >>x
|
||
echo 'int main(void) { return (0); }' >>x
|
||
ac_testn "$hv" "" "<$hf>" <x
|
||
rmf x
|
||
test 1 = $na || ac_cppflags
|
||
}
|
||
|
||
addsrcs() {
|
||
if test x"$1" = x"!"; then
|
||
fr=0
|
||
shift
|
||
else
|
||
fr=1
|
||
fi
|
||
eval i=\$$1
|
||
test $fr = "$i" && case " $SRCS " in
|
||
*\ $2\ *) ;;
|
||
*) SRCS="$SRCS $2" ;;
|
||
esac
|
||
}
|
||
|
||
|
||
if test -d mksh || test -d mksh.exe; then
|
||
echo "$me: Error: ./mksh is a directory!" >&2
|
||
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 "$srcdir" || srcdir=.
|
||
dstversion=`sed -n '/define MKSH_VERSION/s/^.*"\(.*\)".*$/\1/p' $srcdir/sh.h`
|
||
|
||
e=echo
|
||
r=0
|
||
eq=0
|
||
pm=0
|
||
cm=normal
|
||
optflags=-std-compile-opts
|
||
last=
|
||
|
||
for i
|
||
do
|
||
case $last:$i in
|
||
c:combine|c:dragonegg|c:llvm|c:lto)
|
||
cm=$i
|
||
last=
|
||
;;
|
||
c:*)
|
||
echo "$me: Unknown option -c '$i'!" >&2
|
||
exit 1
|
||
;;
|
||
o:*)
|
||
optflags=$i
|
||
last=
|
||
;;
|
||
:-c)
|
||
last=c
|
||
;;
|
||
:-g)
|
||
# checker, debug, valgrind build
|
||
add_cppflags -DDEBUG
|
||
CFLAGS="$CFLAGS -g3 -fno-builtin"
|
||
;;
|
||
:-j)
|
||
pm=1
|
||
;;
|
||
:-M)
|
||
cm=makefile
|
||
;;
|
||
:-O)
|
||
optflags=-std-compile-opts
|
||
;;
|
||
:-o)
|
||
last=o
|
||
;;
|
||
:-Q)
|
||
eq=1
|
||
;;
|
||
:-r)
|
||
r=1
|
||
;;
|
||
:-v)
|
||
echo "Build.sh $srcversion"
|
||
echo "for mksh $dstversion"
|
||
exit 0
|
||
;;
|
||
:*)
|
||
echo "$me: Unknown option '$i'!" >&2
|
||
exit 1
|
||
;;
|
||
*)
|
||
echo "$me: Unknown option -'$last' '$i'!" >&2
|
||
exit 1
|
||
;;
|
||
esac
|
||
done
|
||
if test -n "$last"; then
|
||
echo "$me: Option -'$last' not followed by argument!" >&2
|
||
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"
|
||
|
||
if test x"$srcdir" = x"."; then
|
||
CPPFLAGS="-I. $CPPFLAGS"
|
||
else
|
||
CPPFLAGS="-I. -I'$srcdir' $CPPFLAGS"
|
||
fi
|
||
|
||
test x"$TARGET_OS" = x"" && TARGET_OS=`uname -s 2>/dev/null || uname`
|
||
if test x"$TARGET_OS" = x""; 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'
|
||
|
||
# Evil hack
|
||
if test x"$TARGET_OS" = x"Android"; then
|
||
check_categories="$check_categories android"
|
||
TARGET_OS=Linux
|
||
fi
|
||
|
||
# Configuration depending on OS revision, on OSes that need them
|
||
case $TARGET_OS in
|
||
QNX)
|
||
test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
|
||
;;
|
||
esac
|
||
|
||
# Configuration depending on OS name
|
||
case $TARGET_OS in
|
||
AIX)
|
||
add_cppflags -D_ALL_SOURCE
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
BeOS)
|
||
oswarn=' and will currently not work'
|
||
;;
|
||
BSD/OS)
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
CYGWIN*)
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
Darwin)
|
||
;;
|
||
DragonFly)
|
||
;;
|
||
FreeBSD)
|
||
;;
|
||
FreeMiNT)
|
||
oswarn="; it has minor issues"
|
||
add_cppflags -D_GNU_SOURCE
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
GNU)
|
||
case $CC in
|
||
*tendracc*) ;;
|
||
*) add_cppflags -D_GNU_SOURCE ;;
|
||
esac
|
||
# define NO_PATH_MAX to use Hurd-only functions
|
||
add_cppflags -DNO_PATH_MAX
|
||
;;
|
||
GNU/kFreeBSD)
|
||
case $CC in
|
||
*tendracc*) ;;
|
||
*) add_cppflags -D_GNU_SOURCE ;;
|
||
esac
|
||
;;
|
||
Haiku)
|
||
add_cppflags -DMKSH_ASSUME_UTF8
|
||
;;
|
||
HP-UX)
|
||
;;
|
||
Interix)
|
||
ccpc='-X '
|
||
ccpl='-Y '
|
||
add_cppflags -D_ALL_SOURCE
|
||
: ${LIBS='-lcrypt'}
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
IRIX*)
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
Linux)
|
||
case $CC in
|
||
*tendracc*) ;;
|
||
*) add_cppflags -D_GNU_SOURCE ;;
|
||
esac
|
||
add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
|
||
: ${HAVE_REVOKE=0}
|
||
;;
|
||
MidnightBSD)
|
||
;;
|
||
Minix)
|
||
add_cppflags -DMKSH_UNEMPLOYED
|
||
add_cppflags -DMKSH_CONSERVATIVE_FDS
|
||
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}
|
||
;;
|
||
MirBSD)
|
||
;;
|
||
MSYS_*)
|
||
# almost same as CYGWIN* (from RT|Chatzilla)
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
# broken on this OE (from ir0nh34d)
|
||
: ${HAVE_STDINT_H=0}
|
||
;;
|
||
NetBSD)
|
||
;;
|
||
OpenBSD)
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
OSF1)
|
||
HAVE_SIG_T=0 # incompatible
|
||
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)
|
||
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
|
||
oswarn=' and will currently not work'
|
||
add_cppflags -DMKSH_UNEMPLOYED
|
||
;;
|
||
PW32*)
|
||
HAVE_SIG_T=0 # incompatible
|
||
oswarn=' and will currently not work'
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
QNX)
|
||
add_cppflags -D__NO_EXT_QNX
|
||
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}
|
||
;;
|
||
SunOS)
|
||
add_cppflags -D_BSD_SOURCE
|
||
add_cppflags -D__EXTENSIONS__
|
||
;;
|
||
syllable)
|
||
add_cppflags -D_GNU_SOURCE
|
||
oswarn=' and will currently not work'
|
||
;;
|
||
ULTRIX)
|
||
: ${CC=cc -YPOSIX}
|
||
add_cppflags -Dssize_t=int
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
UWIN*)
|
||
ccpc='-Yc,'
|
||
ccpl='-Yl,'
|
||
tsts=" 3<>/dev/tty"
|
||
oswarn="; it will compile, but the target"
|
||
oswarn="$oswarn${nl}platform itself is very flakey/unreliable"
|
||
: ${HAVE_SETLOCALE_CTYPE=0}
|
||
;;
|
||
*)
|
||
oswarn='; it may or may not work'
|
||
;;
|
||
esac
|
||
|
||
: ${HAVE_MKNOD=0}
|
||
|
||
: ${CC=cc} ${NROFF=nroff}
|
||
test 0 = $r && echo | $NROFF -v 2>&1 | grep GNU >/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 '|' "uname -a >&2"
|
||
;;
|
||
IRIX*)
|
||
vv '|' "uname -a >&2"
|
||
vv '|' "hinv -v >&2"
|
||
;;
|
||
OSF1)
|
||
vv '|' "uname -a >&2"
|
||
vv '|' "/usr/sbin/sizer -v >&2"
|
||
;;
|
||
*)
|
||
vv '|' "uname -a >&2"
|
||
;;
|
||
esac
|
||
test -z "$oswarn" || echo >&2 "
|
||
Warning: mksh has not yet been ported to or tested on your
|
||
operating system '$TARGET_OS'$oswarn. If you can provide
|
||
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"
|
||
|
||
#
|
||
# Begin of mirtoconf checks
|
||
#
|
||
$e $bi$me: Scanning for functions... please ignore any errors.$ao
|
||
|
||
#
|
||
# Compiler: which one?
|
||
#
|
||
# notes:
|
||
# - ICC defines __GNUC__ too
|
||
# - GCC defines __hpux too
|
||
# - LLVM+clang defines __GNUC__ too
|
||
# - nwcc defines __GNUC__ too
|
||
CPP="$CC -E"
|
||
$e ... which compiler seems to be used
|
||
cat >conftest.c <<'EOF'
|
||
#if defined(__ICC) || defined(__INTEL_COMPILER)
|
||
ct=icc
|
||
#elif defined(__xlC__) || defined(__IBMC__)
|
||
ct=xlc
|
||
#elif defined(__SUNPRO_C)
|
||
ct=sunpro
|
||
#elif defined(__ACK__)
|
||
ct=ack
|
||
#elif defined(__BORLANDC__)
|
||
ct=bcc
|
||
#elif defined(__WATCOMC__)
|
||
ct=watcom
|
||
#elif defined(__MWERKS__)
|
||
ct=metrowerks
|
||
#elif defined(__HP_cc)
|
||
ct=hpcc
|
||
#elif defined(__DECC) || (defined(__osf__) && !defined(__GNUC__))
|
||
ct=dec
|
||
#elif defined(__PGI)
|
||
ct=pgi
|
||
#elif defined(__DMC__)
|
||
ct=dmc
|
||
#elif defined(_MSC_VER)
|
||
ct=msc
|
||
#elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
|
||
ct=adsp
|
||
#elif defined(__IAR_SYSTEMS_ICC__)
|
||
ct=iar
|
||
#elif defined(SDCC)
|
||
ct=sdcc
|
||
#elif defined(__PCC__)
|
||
ct=pcc
|
||
#elif defined(__TenDRA__)
|
||
ct=tendra
|
||
#elif defined(__TINYC__)
|
||
ct=tcc
|
||
#elif defined(__llvm__) && defined(__clang__)
|
||
ct=clang
|
||
#elif defined(__NWCC__)
|
||
ct=nwcc
|
||
#elif defined(__GNUC__)
|
||
ct=gcc
|
||
#elif defined(_COMPILER_VERSION)
|
||
ct=mipspro
|
||
#elif defined(__sgi)
|
||
ct=mipspro
|
||
#elif defined(__hpux) || defined(__hpua)
|
||
ct=hpcc
|
||
#elif defined(__ultrix)
|
||
ct=ucode
|
||
#else
|
||
ct=unknown
|
||
#endif
|
||
EOF
|
||
ct=unknown
|
||
vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c | grep ct= | tr -d \\\\015 >x"
|
||
sed 's/^/[ /' x
|
||
eval `cat x`
|
||
rmf x vv.out
|
||
echo 'int main(void) { return (0); }' >conftest.c
|
||
case $ct in
|
||
ack)
|
||
# work around "the famous ACK const bug"
|
||
CPPFLAGS="-Dconst= $CPPFLAGS"
|
||
;;
|
||
adsp)
|
||
echo >&2 'Warning: Analog Devices C++ compiler for Blackfin, TigerSHARC
|
||
and SHARC (21000) DSPs detected. This compiler has not yet
|
||
been tested for compatibility with mksh. Continue at your
|
||
own risk, please report success/failure to the developers.'
|
||
;;
|
||
bcc)
|
||
echo >&2 "Warning: Borland C++ Builder detected. This compiler might
|
||
produce broken executables. Continue at your own risk,
|
||
please report success/failure to the developers."
|
||
;;
|
||
clang)
|
||
# does not work with current "ccc" compiler driver
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
|
||
# this works, for now
|
||
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
|
||
;;
|
||
dec)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -Wl,-V conftest.c $LIBS"
|
||
;;
|
||
dmc)
|
||
echo >&2 "Warning: Digital Mars Compiler detected. When running under"
|
||
echo >&2 " UWIN, mksh tends to be unstable due to the limitations"
|
||
echo >&2 " of this platform. Continue at your own risk,"
|
||
echo >&2 " please report success/failure to the developers."
|
||
;;
|
||
gcc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
|
||
vv '|' 'echo `$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS \
|
||
-dumpmachine` gcc`$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN \
|
||
$LIBS -dumpversion`'
|
||
;;
|
||
hpcc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
|
||
;;
|
||
iar)
|
||
echo >&2 'Warning: IAR Systems (http://www.iar.com) compiler for embedded
|
||
systems detected. This unsupported compiler has not yet
|
||
been tested for compatibility with mksh. Continue at your
|
||
own risk, please report success/failure to the developers.'
|
||
;;
|
||
icc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
|
||
;;
|
||
metrowerks)
|
||
echo >&2 'Warning: Metrowerks C compiler detected. This has not yet
|
||
been tested for compatibility with mksh. Continue at your
|
||
own risk, please report success/failure to the developers.'
|
||
;;
|
||
mipspro)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
|
||
;;
|
||
msc)
|
||
ccpr= # errorlevels are not reliable
|
||
case $TARGET_OS in
|
||
Interix)
|
||
if [[ -n $C89_COMPILER ]]; then
|
||
C89_COMPILER=`ntpath2posix -c "$C89_COMPILER"`
|
||
else
|
||
C89_COMPILER=CL.EXE
|
||
fi
|
||
if [[ -n $C89_LINKER ]]; then
|
||
C89_LINKER=`ntpath2posix -c "$C89_LINKER"`
|
||
else
|
||
C89_LINKER=LINK.EXE
|
||
fi
|
||
vv '|' "$C89_COMPILER /HELP >&2"
|
||
vv '|' "$C89_LINKER /LINK >&2"
|
||
;;
|
||
esac
|
||
;;
|
||
nwcc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
|
||
;;
|
||
pcc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -v"
|
||
;;
|
||
pgi)
|
||
echo >&2 'Warning: PGI detected. This unknown compiler has not yet
|
||
been tested for compatibility with mksh. Continue at your
|
||
own risk, please report success/failure to the developers.'
|
||
;;
|
||
sdcc)
|
||
echo >&2 'Warning: sdcc (http://sdcc.sourceforge.net), the small devices
|
||
C compiler for embedded systems detected. This has not yet
|
||
been tested for compatibility with mksh. Continue at your
|
||
own risk, please report success/failure to the developers.'
|
||
;;
|
||
sunpro)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
|
||
;;
|
||
tcc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -v"
|
||
;;
|
||
tendra)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V 2>&1 | \
|
||
fgrep -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"
|
||
;;
|
||
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.'
|
||
;;
|
||
xlc)
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -qversion"
|
||
vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -qversion=verbose"
|
||
vv '|' "ld -V"
|
||
;;
|
||
*)
|
||
ct=unknown
|
||
;;
|
||
esac
|
||
case $cm in
|
||
dragonegg|llvm)
|
||
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
|
||
|
||
#
|
||
# Compiler: works as-is, with -Wno-error and -Werror
|
||
#
|
||
save_NOWARN=$NOWARN
|
||
NOWARN=
|
||
DOWARN=
|
||
ac_flags 0 compiler_works '' 'if the compiler works'
|
||
test 1 = $HAVE_CAN_COMPILER_WORKS || exit 1
|
||
HAVE_COMPILER_KNOWN=0
|
||
test $ct = unknown || HAVE_COMPILER_KNOWN=1
|
||
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
|
||
CFLAGS="$CFLAGS ${ccpl}-non_shared"
|
||
ac_testn can_delexe compiler_fails 0 'for the -non_shared linker option' <<-EOF
|
||
int main(void) { return (0); }
|
||
EOF
|
||
else
|
||
exit 1
|
||
fi
|
||
test 1 = $HAVE_CAN_DELEXE || CFLAGS=$save_CFLAGS
|
||
ac_testn compiler_still_fails '' 'if the compiler still does not fail correctly' <<-EOF
|
||
EOF
|
||
test 1 = $HAVE_COMPILER_STILL_FAILS && exit 1
|
||
fi
|
||
if ac_ifcpp 'ifdef __TINYC__' couldbe_tcc '!' compiler_known 0 \
|
||
'if this could be tcc'; then
|
||
ct=tcc
|
||
CPP='cpp -D__TINYC__'
|
||
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
|
||
save_NOWARN=
|
||
DOWARN=+We
|
||
elif test $ct = mipspro; then
|
||
save_NOWARN=
|
||
DOWARN="-diag_error 1-10000"
|
||
elif test $ct = msc; then
|
||
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
|
||
save_NOWARN=-w
|
||
elif test $ct = ucode; then
|
||
save_NOWARN=
|
||
DOWARN=-w2
|
||
else
|
||
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"
|
||
NOWARN=$save_NOWARN
|
||
|
||
#
|
||
# Compiler: extra flags (-O2 -f* -W* etc.)
|
||
#
|
||
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)
|
||
#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
|
||
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
|
||
# other flags: just add them if they are supported
|
||
i=0
|
||
if test $ct = gcc; then
|
||
# The following tests run with -Werror (gcc only) if possible
|
||
NOWARN=$DOWARN; phase=u
|
||
ac_flags 1 fnostrictaliasing -fno-strict-aliasing
|
||
ac_flags 1 fstackprotectorall -fstack-protector-all
|
||
ac_flags 1 fwrapv -fwrapv
|
||
test $cm = dragonegg && case " $CC $CFLAGS $LDFLAGS " in
|
||
*\ -fplugin=*dragonegg*) ;;
|
||
*) ac_flags 1 fplugin_dragonegg -fplugin=dragonegg ;;
|
||
esac
|
||
if test $cm = lto; then
|
||
fv=0
|
||
checks='1 2 3 4 5 6 7 8'
|
||
elif test $cm = combine; then
|
||
fv=0
|
||
checks='7 8'
|
||
else
|
||
fv=1
|
||
fi
|
||
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
|
||
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'
|
||
ac_flags 1 fullwarn -fullwarn 'for remark output support'
|
||
elif test $ct = msc; then
|
||
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
|
||
ac_flags - 1 stckall "${ccpc}/Ge" 'stack checks for all functions' <x
|
||
ac_flags - 1 secuchk "${ccpc}/GS" 'for compiler security checks' <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
|
||
ac_flags 1 rodata "-qro -qroconst -qroptr"
|
||
ac_flags 1 rtcheck -qcheck=all
|
||
ac_flags 1 rtchkc -qextchk
|
||
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
|
||
# 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
|
||
fi
|
||
|
||
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(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
|
||
/* 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)));
|
||
int main(int ac, char *av[]) { return (xcopy(av[0], av[--ac], 1)); }
|
||
int xcopy(const void *s, void *d, size_t n) {
|
||
memmove(d, s, n); return ((int)n);
|
||
}
|
||
#endif
|
||
EOF
|
||
ac_test attribute_format '' 'for __attribute__((__format__))' <<-'EOF'
|
||
#if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
|
||
/* 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 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(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
|
||
/* 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])); }
|
||
#endif
|
||
EOF
|
||
ac_test attribute_noreturn '' 'for __attribute__((__noreturn__))' <<-'EOF'
|
||
#if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
|
||
/* force a failure: TenDRA and gcc 1.42 have false positive here */
|
||
int main(void) { return (thiswillneverbedefinedIhope()); }
|
||
#else
|
||
#include <stdlib.h>
|
||
#undef __attribute__
|
||
void fnord(void) __attribute__((__noreturn__));
|
||
int main(void) { fnord(); }
|
||
void fnord(void) { exit(0); }
|
||
#endif
|
||
EOF
|
||
ac_test attribute_unused '' 'for __attribute__((__unused__))' <<-'EOF'
|
||
#if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
|
||
/* 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); }
|
||
#endif
|
||
EOF
|
||
ac_test attribute_used '' 'for __attribute__((__used__))' <<-'EOF'
|
||
#if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
|
||
/* 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); }
|
||
#endif
|
||
EOF
|
||
|
||
# End of tests run with -Werror
|
||
NOWARN=$save_NOWARN
|
||
phase=x
|
||
|
||
#
|
||
# mksh: flavours (full/small mksh, omit certain stuff)
|
||
#
|
||
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_NICE=0}
|
||
: ${HAVE_PERSISTENT_HISTORY=0}
|
||
check_categories="$check_categories smksh"
|
||
HAVE_ISSET_MKSH_CONSERVATIVE_FDS=1 # from sh.h
|
||
fi
|
||
ac_ifcpp 'ifdef MKSH_BINSHREDUCED' isset_MKSH_BINSHREDUCED '' \
|
||
"if a reduced-feature sh is requested" && \
|
||
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"
|
||
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"
|
||
|
||
#
|
||
# Environment: headers
|
||
#
|
||
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/select.h sys/types.h
|
||
ac_header sys/sysmacros.h
|
||
ac_header bstring.h
|
||
ac_header grp.h sys/types.h
|
||
ac_header libgen.h
|
||
ac_header libutil.h sys/types.h
|
||
ac_header paths.h
|
||
ac_header stdint.h stdarg.h
|
||
# include strings.h only if compatible with string.h
|
||
ac_header strings.h sys/types.h string.h
|
||
ac_header ulimit.h sys/types.h
|
||
ac_header values.h
|
||
|
||
#
|
||
# 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("$MirOS: src/bin/mksh/Build.sh,v 1.490 2011/11/25 23:29:30 tg Exp $");
|
||
int main(void) { printf("Hello, World!\n"); return (0); }
|
||
EOF
|
||
case $cm in
|
||
llvm)
|
||
v "$CC $CFLAGS $CPPFLAGS $NOWARN -emit-llvm -c conftest.c" || fv=0
|
||
rmf mksh.s
|
||
test $fv = 0 || v "llvm-link -o - conftest.o | opt $optflags | llc -o mksh.s" || fv=0
|
||
test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn mksh.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 mksh.s
|
||
test $fv = 0 || v "llvm-link -o - conftest.bc | opt $optflags | llc -o mksh.s" || fv=0
|
||
test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn mksh.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: definitions
|
||
#
|
||
echo '#include <sys/types.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))
|
||
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 &&
|
||
LARGE_OFF_T % 2147483647 == 1) ? 1 : -1];
|
||
int main(void) { return (0); }' >lft.c
|
||
ac_testn can_lfs '' "for large file support" <lft.c
|
||
save_CPPFLAGS=$CPPFLAGS
|
||
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
|
||
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
|
||
rmf lft* # end of large file support test
|
||
|
||
#
|
||
# Environment: types
|
||
#
|
||
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); }
|
||
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); }
|
||
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]); }
|
||
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]); }
|
||
EOF
|
||
|
||
ac_test rlim_t <<-'EOF'
|
||
#include <sys/types.h>
|
||
#include <sys/time.h>
|
||
#include <sys/resource.h>
|
||
#include <unistd.h>
|
||
int main(void) { return ((int)(rlim_t)0); }
|
||
EOF
|
||
|
||
# only testn: added later below
|
||
ac_testn sig_t <<-'EOF'
|
||
#include <sys/types.h>
|
||
#include <signal.h>
|
||
#include <stddef.h>
|
||
int main(void) { return ((int)(ptrdiff_t)(sig_t)(ptrdiff_t)kill(0,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)(ptrdiff_t)kill(0,0)); }
|
||
EOF
|
||
if test 1 = $HAVE_SIGHANDLER_T; then
|
||
add_cppflags -Dsig_t=sighandler_t
|
||
HAVE_SIG_T=1
|
||
fi
|
||
|
||
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)(ptrdiff_t)kill(0,0)); }
|
||
EOF
|
||
if test 1 = $HAVE___SIGHANDLER_T; then
|
||
add_cppflags -Dsig_t=__sighandler_t
|
||
HAVE_SIG_T=1
|
||
fi
|
||
|
||
test 1 = $HAVE_SIG_T || add_cppflags -Dsig_t=nosig_t
|
||
ac_cppflags SIG_T
|
||
|
||
#
|
||
# Environment: signals
|
||
#
|
||
test x"NetBSD" = x"$TARGET_OS" && $e Ignore the compatibility warning.
|
||
|
||
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]); }
|
||
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]); }
|
||
EOF
|
||
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'
|
||
#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 <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)); }
|
||
EOF
|
||
|
||
ac_test getrusage <<-'EOF'
|
||
#define MKSH_INCLUDES_ONLY
|
||
#include "sh.h"
|
||
int main(void) {
|
||
struct rusage ru;
|
||
return (getrusage(RUSAGE_SELF, &ru) +
|
||
getrusage(RUSAGE_CHILDREN, &ru));
|
||
}
|
||
EOF
|
||
|
||
ac_test killpg <<-'EOF'
|
||
#include <signal.h>
|
||
int main(int ac, char *av[]) { return (av[0][killpg(123, ac)]); }
|
||
EOF
|
||
|
||
ac_test mknod '' 'if to use mknod(), makedev() and friends' <<-'EOF'
|
||
#define MKSH_INCLUDES_ONLY
|
||
#include "sh.h"
|
||
int main(int ac, char *av[]) {
|
||
dev_t dv;
|
||
dv = makedev((unsigned int)ac, (unsigned int)av[0][0]);
|
||
return (mknod(av[0], (mode_t)0, dv) ? (int)major(dv) :
|
||
(int)minor(dv));
|
||
}
|
||
EOF
|
||
|
||
ac_test mkstemp <<-'EOF'
|
||
#include <stdlib.h>
|
||
#include <unistd.h>
|
||
int main(void) { char tmpl[] = "X"; return (mkstemp(tmpl)); }
|
||
EOF
|
||
|
||
ac_test nice <<-'EOF'
|
||
#include <unistd.h>
|
||
int main(void) { return (nice(4)); }
|
||
EOF
|
||
|
||
ac_test revoke <<-'EOF'
|
||
#include <sys/types.h>
|
||
#if HAVE_LIBUTIL_H
|
||
#include <libutil.h>
|
||
#endif
|
||
#include <unistd.h>
|
||
int main(int ac, char *av[]) { return (ac + revoke(av[0])); }
|
||
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, "")); }
|
||
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)); }
|
||
EOF
|
||
|
||
ac_test select <<-'EOF'
|
||
#include <sys/types.h>
|
||
#include <sys/time.h>
|
||
#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)); }
|
||
EOF
|
||
|
||
ac_test setgroups setresugid 0 <<-'EOF'
|
||
#include <sys/types.h>
|
||
#if HAVE_GRP_H
|
||
#include <grp.h>
|
||
#endif
|
||
#include <unistd.h>
|
||
int main(void) { gid_t gid = 0; return (setgroups(0, &gid)); }
|
||
EOF
|
||
|
||
ac_test strcasestr <<-'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)(ptrdiff_t)(void *)strcasestr(*av, av[ac]));
|
||
}
|
||
EOF
|
||
|
||
ac_test strlcpy <<-'EOF'
|
||
#include <string.h>
|
||
int main(int ac, char *av[]) { return (strlcpy(*av, av[1],
|
||
(size_t)ac)); }
|
||
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'
|
||
#define MKSH_INCLUDES_ONLY
|
||
#include "sh.h"
|
||
long flock(void); /* this clashes if defined before */
|
||
int main(void) { return ((int)flock()); }
|
||
EOF
|
||
ac_test '!' revoke_decl revoke 1 'if revoke() does not need to be declared' <<-'EOF'
|
||
#define MKSH_INCLUDES_ONLY
|
||
#include "sh.h"
|
||
long revoke(void); /* this clashes if defined before */
|
||
int main(void) { return ((int)revoke()); }
|
||
EOF
|
||
ac_test sys_siglist_decl sys_siglist 1 'if sys_siglist[] does not need to be declared' <<-'EOF'
|
||
#define MKSH_INCLUDES_ONLY
|
||
#include "sh.h"
|
||
int main(void) { return (sys_siglist[0][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_testdone
|
||
ac_cppflags
|
||
|
||
#
|
||
# Compiler: Praeprocessor (only if needed)
|
||
#
|
||
test 0 = $HAVE_SYS_SIGNAME && if ac_testinit cpp_dd '' \
|
||
'checking if the C Preprocessor supports -dD'; then
|
||
echo '#define foo bar' >conftest.c
|
||
vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN -dD conftest.c >x"
|
||
grep '#define foo bar' x >/dev/null 2>&1 && fv=1
|
||
rmf conftest.c x vv.out
|
||
ac_testdone
|
||
fi
|
||
|
||
#
|
||
# End of mirtoconf checks
|
||
#
|
||
$e ... done.
|
||
|
||
# Some operating systems have ancient versions of ed(1) writing
|
||
# 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"
|
||
rmf x vv.out
|
||
|
||
if test 0 = $HAVE_SYS_SIGNAME; then
|
||
if test 1 = $HAVE_CPP_DD; then
|
||
$e Generating list of signal names...
|
||
else
|
||
$e No list of signal names available via cpp. Falling back...
|
||
fi
|
||
sigseen=:
|
||
echo '#include <signal.h>
|
||
#ifndef NSIG
|
||
#if defined(_NSIG)
|
||
#define NSIG _NSIG
|
||
#elif defined(SIGMAX)
|
||
#define NSIG (SIGMAX+1)
|
||
#endif
|
||
#endif
|
||
mksh_cfg: NSIG' >conftest.c
|
||
NSIG=`vq "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c" | \
|
||
grep mksh_cfg: | sed 's/^mksh_cfg:[ ]*\([0-9x ()+-]*\).*$/\1/'`
|
||
case $NSIG in
|
||
*[\ \(\)+-]*) NSIG=`awk "BEGIN { print $NSIG }"` ;;
|
||
esac
|
||
printf=printf
|
||
(printf hallo) >/dev/null 2>&1 || 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"
|
||
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`
|
||
test $NSIG -gt 1 || sigs=
|
||
for name in $sigs; do
|
||
echo '#include <signal.h>' >conftest.c
|
||
echo mksh_cfg: SIG$name >>conftest.c
|
||
vq "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c" | \
|
||
grep mksh_cfg: | \
|
||
sed 's/^mksh_cfg:[ ]*\([0-9x]*\).*$/\1:'$name/
|
||
done | grep -v '^:' | sed 's/:/ /g' | 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
|
||
*:$nr:*) ;;
|
||
*) echo " { \"$name\", $nr },"
|
||
sigseen=$sigseen$nr:
|
||
$printf "$name=$nr " >&2
|
||
;;
|
||
esac
|
||
done 2>&1 >signames.inc
|
||
rmf conftest.c
|
||
$e done.
|
||
fi
|
||
|
||
addsrcs '!' HAVE_STRLCPY strlcpy.c
|
||
addsrcs USE_PRINTF_BUILTIN printf.c
|
||
test 1 = "$USE_PRINTF_BUILTIN" && add_cppflags -DMKSH_PRINTF_BUILTIN
|
||
test 1 = "$HAVE_CAN_VERB" && CFLAGS="$CFLAGS -verbose"
|
||
|
||
$e $bi$me: Finished configuration testing, now producing output.$ao
|
||
|
||
files=
|
||
objs=
|
||
sp=
|
||
case $curdir in
|
||
*\ *) echo "#!./mksh" >test.sh ;;
|
||
*) echo "#!$curdir/mksh" >test.sh ;;
|
||
esac
|
||
cat >>test.sh <<-EOF
|
||
LC_ALL=C PATH='$PATH'; export LC_ALL PATH
|
||
test -n "\$KSH_VERSION" || exit 1
|
||
set -A check_categories -- $check_categories
|
||
pflag='$curdir/mksh'
|
||
sflag='$srcdir/check.t'
|
||
usee=0 Pflag=0 uset=0 vflag=0 xflag=0
|
||
while getopts "C:e:fPp:s: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=\$OPTARG ;;
|
||
(s) sflag=\$OPTARG ;;
|
||
(t) uset=1; tflag=\$OPTARG ;;
|
||
(v) vflag=1 ;;
|
||
(*) xflag=1 ;;
|
||
}
|
||
done
|
||
shift \$((OPTIND - 1))
|
||
set -A args -- '$srcdir/check.pl' -p "\$pflag" -s "\$sflag"
|
||
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
|
||
print Testing mksh for conformance:
|
||
fgrep MirOS: '$srcdir/check.t'
|
||
fgrep MIRBSD '$srcdir/check.t'
|
||
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>/dev/null || continue
|
||
print "Perl interpreter '\$perli' running on '\$perlos'"
|
||
[[ -n \$perlos ]] && break
|
||
done
|
||
exec \$perli "\${args[@]}" "\$@"$tsts
|
||
EOF
|
||
chmod 755 test.sh
|
||
if test $cm = llvm; then
|
||
emitbc="-emit-llvm -c"
|
||
elif test $cm = dragonegg; then
|
||
emitbc="-S -flto"
|
||
else
|
||
emitbc=-c
|
||
fi
|
||
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
|
||
files="$files$sp$file"
|
||
sp=' '
|
||
echo "$CC $CFLAGS $CPPFLAGS $emitbc $file || exit 1" >>Rebuild.sh
|
||
if test $cm = dragonegg; then
|
||
echo "mv ${op}s ${op}ll" >>Rebuild.sh
|
||
echo "llvm-as ${op}ll || exit 1" >>Rebuild.sh
|
||
objs="$objs$sp${op}bc"
|
||
else
|
||
objs="$objs$sp${op}o"
|
||
fi
|
||
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
|
||
;;
|
||
*)
|
||
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
|
||
if test $cm = makefile; then
|
||
extras='emacsfn.h sh.h sh_flags.h var_spec.h'
|
||
test 0 = $HAVE_SYS_SIGNAME && extras="$extras signames.inc"
|
||
cat >Makefrag.inc <<EOF
|
||
# Makefile fragment for building mksh $dstversion
|
||
|
||
PROG= $mkshexe
|
||
MAN= mksh.1
|
||
SRCS= $SRCS
|
||
SRCS_FP= $files
|
||
OBJS_BP= $objs
|
||
INDSRCS= $extras
|
||
NONSRCS_INST= dot.mkshrc \$(MAN)
|
||
NONSRCS_NOINST= Build.sh Makefile Rebuild.sh check.pl check.t test.sh
|
||
CC= $CC
|
||
CFLAGS= $CFLAGS
|
||
CPPFLAGS= $CPPFLAGS
|
||
LDFLAGS= $LDFLAGS
|
||
LIBS= $LIBS
|
||
|
||
# not BSD make only:
|
||
#VPATH= $srcdir
|
||
#all: \$(PROG)
|
||
#\$(PROG): \$(OBJS_BP)
|
||
# \$(CC) \$(CFLAGS) \$(LDFLAGS) -o \$@ \$(OBJS_BP) \$(LIBS)
|
||
#\$(OBJS_BP): \$(SRCS_FP) \$(NONSRCS)
|
||
#.c.o:
|
||
# \$(CC) \$(CFLAGS) \$(CPPFLAGS) -c \$<
|
||
|
||
# for all make variants:
|
||
#REGRESS_FLAGS= -v
|
||
#regress:
|
||
# ./test.sh \$(REGRESS_FLAGS)
|
||
|
||
# for BSD make only:
|
||
#.PATH: $srcdir
|
||
#.include <bsd.prog.mk>
|
||
EOF
|
||
$e
|
||
$e Generated Makefrag.inc successfully.
|
||
exit 0
|
||
fi
|
||
if test $cm = combine; then
|
||
objs="-o $mkshexe"
|
||
for file in $SRCS; do
|
||
test -f $file || file=$srcdir/$file
|
||
objs="$objs $file"
|
||
done
|
||
emitbc="-fwhole-program --combine"
|
||
v "$CC $CFLAGS $CPPFLAGS $LDFLAGS $emitbc $objs $LIBS $ccpr"
|
||
elif test 1 = $pm; then
|
||
for file in $SRCS; do
|
||
test -f $file || file=$srcdir/$file
|
||
v "$CC $CFLAGS $CPPFLAGS $emitbc $file" &
|
||
done
|
||
wait
|
||
else
|
||
for file in $SRCS; do
|
||
test $cm = dragonegg && \
|
||
op=`echo x"$file" | sed 's/^x\(.*\)\.c$/\1./'`
|
||
test -f $file || file=$srcdir/$file
|
||
v "$CC $CFLAGS $CPPFLAGS $emitbc $file" || exit 1
|
||
if test $cm = dragonegg; then
|
||
v "mv ${op}s ${op}ll"
|
||
v "llvm-as ${op}ll" || exit 1
|
||
fi
|
||
done
|
||
fi
|
||
case $cm in
|
||
dragonegg|llvm)
|
||
rmf mksh.s
|
||
v "llvm-link -o - $objs | opt $optflags | llc -o mksh.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
|
||
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
|
||
$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"
|
||
$e or
|
||
fi
|
||
$e "# $i -c -o root -g bin -m 444 mksh.1 /usr/share/man/man1/mksh.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
|