src/Build.sh

   1 #!/bin/sh
   2 srcversion='$MirOS: src/bin/mksh/Build.sh,v 1.702 2016/08/10 18:20:16 tg Exp $'
   3 #-
   4 # Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   5 #               2011, 2012, 2013, 2014, 2015, 2016
   6 #       mirabilos <m@mirbsd.org>
   7 #
   8 # Provided that these terms and disclaimer and all copyright notices
   9 # are retained or reproduced in an accompanying document, permission
  10 # is granted to deal in this work without restriction, including un-
  11 # limited rights to use, publicly perform, distribute, sell, modify,
  12 # merge, give away, or sublicence.
  13 #
  14 # This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
  15 # the utmost extent permitted by applicable law, neither express nor
  16 # implied; without malicious intent or gross negligence. In no event
  17 # may a licensor, author or contributor be held liable for indirect,
  18 # direct, other damage, loss, or other issues arising in any way out
  19 # of dealing in the work, even if advised of the possibility of such
  20 # damage or existence of a defect, except proven that it results out
  21 # of said person's immediate fault when using the work as intended.
  22 #-
  23 # People analysing the output must whitelist conftest.c for any kind
  24 # of compiler warning checks (mirtoconf is by design not quiet).
  25 #
  26 # Used environment documentation is at the end of this file.
  27
  28 LC_ALL=C
  29 export LC_ALL
  30
  31 case $ZSH_VERSION:$VERSION in
  32 :zsh*) ZSH_VERSION=2 ;;
  33 esac
  34
  35 if test -n "${ZSH_VERSION+x}" && (emulate sh) >/dev/null 2>&1; then
  36         emulate sh
  37         NULLCMD=:
  38 fi
  39
  40 if test -d /usr/xpg4/bin/. >/dev/null 2>&1; then
  41         # Solaris: some of the tools have weird behaviour, use portable ones
  42         PATH=/usr/xpg4/bin:$PATH
  43         export PATH
  44 fi
  45
  46 nl='
  47 '
  48 safeIFS='       '
  49 safeIFS=" $safeIFS$nl"
  50 IFS=$safeIFS
  51 allu=QWERTYUIOPASDFGHJKLZXCVBNM
  52 alll=qwertyuiopasdfghjklzxcvbnm
  53 alln=0123456789
  54 alls=______________________________________________________________
  55
  56 genopt_die() {
  57         if test -n "$1"; then
  58                 echo >&2 "E: $*"
  59                 echo >&2 "E: in '$srcfile': '$line'"
  60         else
  61                 echo >&2 "E: invalid input in '$srcfile': '$line'"
  62         fi
  63         rm -f "$bn.gen"
  64         exit 1
  65 }
  66
  67 genopt_soptc() {
  68         optc=`echo "$line" | sed 's/^[<>]\(.\).*$/\1/'`
  69         test x"$optc" = x'|' && return
  70         optclo=`echo "$optc" | tr $allu $alll`
  71         if test x"$optc" = x"$optclo"; then
  72                 islo=1
  73         else
  74                 islo=0
  75         fi
  76         sym=`echo "$line" | sed 's/^[<>]/|/'`
  77         o_str=$o_str$nl"<$optclo$islo$sym"
  78 }
  79
  80 genopt_scond() {
  81         case x$cond in
  82         x)
  83                 cond=
  84                 ;;
  85         x*' '*)
  86                 cond=`echo "$cond" | sed 's/^ //'`
  87                 cond="#if $cond"
  88                 ;;
  89         x'!'*)
  90                 cond=`echo "$cond" | sed 's/^!//'`
  91                 cond="#ifndef $cond"
  92                 ;;
  93         x*)
  94                 cond="#ifdef $cond"
  95                 ;;
  96         esac
  97 }
  98
  99 do_genopt() {
 100         srcfile=$1
 101         test -f "$srcfile" || genopt_die Source file \$srcfile not set.
 102         bn=`basename "$srcfile" | sed 's/.opt$//'`
 103         o_hdr='/* +++ GENERATED FILE +++ DO NOT EDIT +++ */'
 104         o_gen=
 105         o_str=
 106         o_sym=
 107         ddefs=
 108         state=0
 109         exec <"$srcfile"
 110         IFS=
 111         while IFS= read line; do
 112                 IFS=$safeIFS
 113                 case $state:$line in
 114                 2:'|'*)
 115                         # end of input
 116                         o_sym=`echo "$line" | sed 's/^.//'`
 117                         o_gen=$o_gen$nl"#undef F0"
 118                         o_gen=$o_gen$nl"#undef FN"
 119                         o_gen=$o_gen$ddefs
 120                         state=3
 121                         ;;
 122                 1:@@)
 123                         # begin of data block
 124                         o_gen=$o_gen$nl"#endif"
 125                         o_gen=$o_gen$nl"#ifndef F0"
 126                         o_gen=$o_gen$nl"#define F0 FN"
 127                         o_gen=$o_gen$nl"#endif"
 128                         state=2
 129                         ;;
 130                 *:@@*)
 131                         genopt_die ;;
 132                 0:/\*-|0:\ \**|0:)
 133                         o_hdr=$o_hdr$nl$line
 134                         ;;
 135                 0:@*|1:@*)
 136                         # begin of a definition block
 137                         sym=`echo "$line" | sed 's/^@//'`
 138                         if test $state = 0; then
 139                                 o_gen=$o_gen$nl"#if defined($sym)"
 140                         else
 141                                 o_gen=$o_gen$nl"#elif defined($sym)"
 142                         fi
 143                         ddefs="$ddefs$nl#undef $sym"
 144                         state=1
 145                         ;;
 146                 0:*|3:*)
 147                         genopt_die ;;
 148                 1:*)
 149                         # definition line
 150                         o_gen=$o_gen$nl$line
 151                         ;;
 152                 2:'<'*'|'*)
 153                         genopt_soptc
 154                         ;;
 155                 2:'>'*'|'*)
 156                         genopt_soptc
 157                         cond=`echo "$line" | sed 's/^[^|]*|//'`
 158                         genopt_scond
 159                         case $optc in
 160                         '|') optc=0 ;;
 161                         *) optc=\'$optc\' ;;
 162                         esac
 163                         IFS= read line || genopt_die Unexpected EOF
 164                         IFS=$safeIFS
 165                         test -n "$cond" && o_gen=$o_gen$nl"$cond"
 166                         o_gen=$o_gen$nl"$line, $optc)"
 167                         test -n "$cond" && o_gen=$o_gen$nl"#endif"
 168                         ;;
 169                 esac
 170         done
 171         case $state:$o_sym in
 172         3:) genopt_die Expected optc sym at EOF ;;
 173         3:*) ;;
 174         *) genopt_die Missing EOF marker ;;
 175         esac
 176         echo "$o_str" | sort | while IFS='|' read x opts cond; do
 177                 IFS=$safeIFS
 178                 test -n "$x" || continue
 179                 genopt_scond
 180                 test -n "$cond" && echo "$cond"
 181                 echo "\"$opts\""
 182                 test -n "$cond" && echo "#endif"
 183         done | {
 184                 echo "$o_hdr"
 185                 echo "#ifndef $o_sym$o_gen"
 186                 echo "#else"
 187                 cat
 188                 echo "#undef $o_sym"
 189                 echo "#endif"
 190         } >"$bn.gen"
 191         IFS=$safeIFS
 192         return 0
 193 }
 194
 195 if test x"$BUILDSH_RUN_GENOPT" = x"1"; then
 196         set x -G "$srcfile"
 197         shift
 198 fi
 199 if test x"$1" = x"-G"; then
 200         do_genopt "$2"
 201         exit $?
 202 fi
 203
 204 echo "For the build logs, demonstrate that /dev/null and /dev/tty exist:"
 205 ls -l /dev/null /dev/tty
 206
 207 v() {
 208         $e "$*"
 209         eval "$@"
 210 }
 211
 212 vv() {
 213         _c=$1
 214         shift
 215         $e "\$ $*" 2>&1
 216         eval "$@" >vv.out 2>&1
 217         sed "s\a^\a${_c} \a" <vv.out
 218 }
 219
 220 vq() {
 221         eval "$@"
 222 }
 223
 224 rmf() {
 225         for _f in "$@"; do
 226                 case $_f in
 227                 Build.sh|check.pl|check.t|dot.mkshrc|*.1|*.c|*.h|*.ico|*.opt) ;;
 228                 *) rm -f "$_f" ;;
 229                 esac
 230         done
 231 }
 232
 233 tcfn=no
 234 bi=
 235 ui=
 236 ao=
 237 fx=
 238 me=`basename "$0"`
 239 orig_CFLAGS=$CFLAGS
 240 phase=x
 241 oldish_ed=stdout-ed,no-stderr-ed
 242
 243 if test -t 1; then
 244         bi='\e[1m'
 245         ui='\e[4m'
 246         ao='\e[0m'
 247 fi
 248
 249 upper() {
 250         echo :"$@" | sed 's/^://' | tr $alll $allu
 251 }
 252
 253 # clean up after ac_testrun()
 254 ac_testdone() {
 255         eval HAVE_$fu=$fv
 256         fr=no
 257         test 0 = $fv || fr=yes
 258         $e "$bi==> $fd...$ao $ui$fr$ao$fx"
 259         fx=
 260 }
 261
 262 # ac_cache label: sets f, fu, fv?=0
 263 ac_cache() {
 264         f=$1
 265         fu=`upper $f`
 266         eval fv=\$HAVE_$fu
 267         case $fv in
 268         0|1)
 269                 fx=' (cached)'
 270                 return 0
 271                 ;;
 272         esac
 273         fv=0
 274         return 1
 275 }
 276
 277 # ac_testinit label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
 278 # returns 1 if value was cached/implied, 0 otherwise: call ac_testdone
 279 ac_testinit() {
 280         if ac_cache $1; then
 281                 test x"$2" = x"!" && shift
 282                 test x"$2" = x"" || shift
 283                 fd=${3-$f}
 284                 ac_testdone
 285                 return 1
 286         fi
 287         fc=0
 288         if test x"$2" = x""; then
 289                 ft=1
 290         else
 291                 if test x"$2" = x"!"; then
 292                         fc=1
 293                         shift
 294                 fi
 295                 eval ft=\$HAVE_`upper $2`
 296                 shift
 297         fi
 298         fd=${3-$f}
 299         if test $fc = "$ft"; then
 300                 fv=$2
 301                 fx=' (implied)'
 302                 ac_testdone
 303                 return 1
 304         fi
 305         $e ... $fd
 306         return 0
 307 }
 308
 309 # pipe .c | ac_test[n] [!] label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
 310 ac_testnnd() {
 311         if test x"$1" = x"!"; then
 312                 fr=1
 313                 shift
 314         else
 315                 fr=0
 316         fi
 317         ac_testinit "$@" || return 1
 318         cat >conftest.c
 319         vv ']' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN conftest.c $LIBS $ccpr"
 320         test $tcfn = no && test -f a.out && tcfn=a.out
 321         test $tcfn = no && test -f a.exe && tcfn=a.exe
 322         test $tcfn = no && test -f conftest.exe && tcfn=conftest.exe
 323         test $tcfn = no && test -f conftest && tcfn=conftest
 324         if test -f $tcfn; then
 325                 test 1 = $fr || fv=1
 326         else
 327                 test 0 = $fr || fv=1
 328         fi
 329         vscan=
 330         if test $phase = u; then
 331                 test $ct = gcc && vscan='unrecogni[sz]ed'
 332                 test $ct = hpcc && vscan='unsupported'
 333                 test $ct = pcc && vscan='unsupported'
 334                 test $ct = sunpro && vscan='-e ignored -e turned.off'
 335         fi
 336         test -n "$vscan" && grep $vscan vv.out >/dev/null 2>&1 && fv=$fr
 337         return 0
 338 }
 339 ac_testn() {
 340         ac_testnnd "$@" || return
 341         rmf conftest.c conftest.o ${tcfn}* vv.out
 342         ac_testdone
 343 }
 344
 345 # ac_ifcpp cppexpr [!] label [!] checkif[!]0 [setlabelifcheckis[!]0] useroutput
 346 ac_ifcpp() {
 347         expr=$1; shift
 348         ac_testn "$@" <<-EOF
 349                 #include <unistd.h>
 350                 extern int thiswillneverbedefinedIhope(void);
 351                 int main(void) { return (isatty(0) +
 352                 #$expr
 353                     0
 354                 #else
 355                 /* force a failure: expr is false */
 356                     thiswillneverbedefinedIhope()
 357                 #endif
 358                     ); }
 359 EOF
 360         test x"$1" = x"!" && shift
 361         f=$1
 362         fu=`upper $f`
 363         eval fv=\$HAVE_$fu
 364         test x"$fv" = x"1"
 365 }
 366
 367 add_cppflags() {
 368         CPPFLAGS="$CPPFLAGS $*"
 369 }
 370
 371 ac_cppflags() {
 372         test x"$1" = x"" || fu=$1
 373         fv=$2
 374         test x"$2" = x"" && eval fv=\$HAVE_$fu
 375         add_cppflags -DHAVE_$fu=$fv
 376 }
 377
 378 ac_test() {
 379         ac_testn "$@"
 380         ac_cppflags
 381 }
 382
 383 # ac_flags [-] add varname cflags [text] [ldflags]
 384 ac_flags() {
 385         if test x"$1" = x"-"; then
 386                 shift
 387                 hf=1
 388         else
 389                 hf=0
 390         fi
 391         fa=$1
 392         vn=$2
 393         f=$3
 394         ft=$4
 395         fl=$5
 396         test x"$ft" = x"" && ft="if $f can be used"
 397         save_CFLAGS=$CFLAGS
 398         CFLAGS="$CFLAGS $f"
 399         if test -n "$fl"; then
 400                 save_LDFLAGS=$LDFLAGS
 401                 LDFLAGS="$LDFLAGS $fl"
 402         fi
 403         if test 1 = $hf; then
 404                 ac_testn can_$vn '' "$ft"
 405         else
 406                 ac_testn can_$vn '' "$ft" <<-'EOF'
 407                         /* evil apo'stroph in comment test */
 408                         #include <unistd.h>
 409                         int main(void) { return (isatty(0)); }
 410                 EOF
 411         fi
 412         eval fv=\$HAVE_CAN_`upper $vn`
 413         if test -n "$fl"; then
 414                 test 11 = $fa$fv || LDFLAGS=$save_LDFLAGS
 415         fi
 416         test 11 = $fa$fv || CFLAGS=$save_CFLAGS
 417 }
 418
 419 # ac_header [!] header [prereq ...]
 420 ac_header() {
 421         if test x"$1" = x"!"; then
 422                 na=1
 423                 shift
 424         else
 425                 na=0
 426         fi
 427         hf=$1; shift
 428         hv=`echo "$hf" | tr -d '\012\015' | tr -c $alll$allu$alln $alls`
 429         echo "/* NeXTstep bug workaround */" >x
 430         for i
 431         do
 432                 case $i in
 433                 _time)
 434                         echo '#if HAVE_BOTH_TIME_H' >>x
 435                         echo '#include <sys/time.h>' >>x
 436                         echo '#include <time.h>' >>x
 437                         echo '#elif HAVE_SYS_TIME_H' >>x
 438                         echo '#include <sys/time.h>' >>x
 439                         echo '#elif HAVE_TIME_H' >>x
 440                         echo '#include <time.h>' >>x
 441                         echo '#endif' >>x
 442                         ;;
 443                 *)
 444                         echo "#include <$i>" >>x
 445                         ;;
 446                 esac
 447         done
 448         echo "#include <$hf>" >>x
 449         echo '#include <unistd.h>' >>x
 450         echo 'int main(void) { return (isatty(0)); }' >>x
 451         ac_testn "$hv" "" "<$hf>" <x
 452         rmf x
 453         test 1 = $na || ac_cppflags
 454 }
 455
 456 addsrcs() {
 457         if test x"$1" = x"!"; then
 458                 fr=0
 459                 shift
 460         else
 461                 fr=1
 462         fi
 463         eval i=\$$1
 464         test $fr = "$i" && case " $SRCS " in
 465         *\ $2\ *)       ;;
 466         *)              SRCS="$SRCS $2" ;;
 467         esac
 468 }
 469
 470
 471 curdir=`pwd` srcdir=`dirname "$0" 2>/dev/null`
 472 case x$srcdir in
 473 x)
 474         srcdir=.
 475         ;;
 476 *\ *|*" "*|*"$nl"*)
 477         echo >&2 Source directory should not contain space or tab or newline.
 478         echo >&2 Errors may occur.
 479         ;;
 480 *"'"*)
 481         echo Source directory must not contain single quotes.
 482         exit 1
 483         ;;
 484 esac
 485 dstversion=`sed -n '/define MKSH_VERSION/s/^.*"\([^"]*\)".*$/\1/p' "$srcdir/sh.h"`
 486 add_cppflags -DMKSH_BUILDSH
 487
 488 e=echo
 489 r=0
 490 eq=0
 491 pm=0
 492 cm=normal
 493 optflags=-std-compile-opts
 494 check_categories=
 495 last=
 496 tfn=
 497 legacy=0
 498
 499 for i
 500 do
 501         case $last:$i in
 502         c:combine|c:dragonegg|c:llvm|c:lto)
 503                 cm=$i
 504                 last=
 505                 ;;
 506         c:*)
 507                 echo "$me: Unknown option -c '$i'!" >&2
 508                 exit 1
 509                 ;;
 510         o:*)
 511                 optflags=$i
 512                 last=
 513                 ;;
 514         t:*)
 515                 tfn=$i
 516                 last=
 517                 ;;
 518         :-c)
 519                 last=c
 520                 ;;
 521         :-G)
 522                 echo "$me: Do not call me with '-G'!" >&2
 523                 exit 1
 524                 ;;
 525         :-g)
 526                 # checker, debug, valgrind build
 527                 add_cppflags -DDEBUG
 528                 CFLAGS="$CFLAGS -g3 -fno-builtin"
 529                 ;;
 530         :-j)
 531                 pm=1
 532                 ;;
 533         :-L)
 534                 legacy=1
 535                 ;;
 536         :+L)
 537                 legacy=0
 538                 ;;
 539         :-M)
 540                 cm=makefile
 541                 ;;
 542         :-O)
 543                 optflags=-std-compile-opts
 544                 ;;
 545         :-o)
 546                 last=o
 547                 ;;
 548         :-Q)
 549                 eq=1
 550                 ;;
 551         :-r)
 552                 r=1
 553                 ;;
 554         :-t)
 555                 last=t
 556                 ;;
 557         :-v)
 558                 echo "Build.sh $srcversion"
 559                 echo "for mksh $dstversion"
 560                 exit 0
 561                 ;;
 562         :*)
 563                 echo "$me: Unknown option '$i'!" >&2
 564                 exit 1
 565                 ;;
 566         *)
 567                 echo "$me: Unknown option -'$last' '$i'!" >&2
 568                 exit 1
 569                 ;;
 570         esac
 571 done
 572 if test -n "$last"; then
 573         echo "$me: Option -'$last' not followed by argument!" >&2
 574         exit 1
 575 fi
 576
 577 test -z "$tfn" && if test $legacy = 0; then
 578         tfn=mksh
 579 else
 580         tfn=lksh
 581 fi
 582 if test -d $tfn || test -d $tfn.exe; then
 583         echo "$me: Error: ./$tfn is a directory!" >&2
 584         exit 1
 585 fi
 586 rmf a.exe* a.out* conftest.c conftest.exe* *core core.* ${tfn}* *.bc *.dbg \
 587     *.ll *.o *.gen Rebuild.sh lft no signames.inc test.sh x vv.out
 588
 589 SRCS="lalloc.c eval.c exec.c expr.c funcs.c histrap.c jobs.c"
 590 SRCS="$SRCS lex.c main.c misc.c shf.c syn.c tree.c var.c"
 591
 592 if test $legacy = 0; then
 593         SRCS="$SRCS edit.c"
 594         check_categories="$check_categories shell:legacy-no int:32"
 595 else
 596         check_categories="$check_categories shell:legacy-yes"
 597         add_cppflags -DMKSH_LEGACY_MODE
 598         HAVE_PERSISTENT_HISTORY=0
 599 fi
 600
 601 if test x"$srcdir" = x"."; then
 602         CPPFLAGS="-I. $CPPFLAGS"
 603 else
 604         CPPFLAGS="-I. -I'$srcdir' $CPPFLAGS"
 605 fi
 606 test -n "$LDSTATIC" && if test -n "$LDFLAGS"; then
 607         LDFLAGS="$LDFLAGS $LDSTATIC"
 608 else
 609         LDFLAGS=$LDSTATIC
 610 fi
 611
 612 if test -z "$TARGET_OS"; then
 613         x=`uname -s 2>/dev/null || uname`
 614         test x"$x" = x"`uname -n 2>/dev/null`" || TARGET_OS=$x
 615 fi
 616 if test -z "$TARGET_OS"; then
 617         echo "$me: Set TARGET_OS, your uname is broken!" >&2
 618         exit 1
 619 fi
 620 oswarn=
 621 ccpc=-Wc,
 622 ccpl=-Wl,
 623 tsts=
 624 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'
 625
 626 # Evil hack
 627 if test x"$TARGET_OS" = x"Android"; then
 628         check_categories="$check_categories android"
 629         TARGET_OS=Linux
 630 fi
 631
 632 # Evil OS
 633 if test x"$TARGET_OS" = x"Minix"; then
 634         echo >&2 "
 635 WARNING: additional checks before running Build.sh required!
 636 You can avoid these by calling Build.sh correctly, see below.
 637 "
 638         cat >conftest.c <<'EOF'
 639 #include <sys/types.h>
 640 const char *
 641 #ifdef _NETBSD_SOURCE
 642 ct="Ninix3"
 643 #else
 644 ct="Minix3"
 645 #endif
 646 ;
 647 EOF
 648         ct=unknown
 649         vv ']' "${CC-cc} -E $CFLAGS $CPPFLAGS $NOWARN conftest.c | grep ct= | tr -d \\\\015 >x"
 650         sed 's/^/[ /' x
 651         eval `cat x`
 652         rmf x vv.out
 653         case $ct in
 654         Minix3|Ninix3)
 655                 echo >&2 "
 656 Warning: you set TARGET_OS to $TARGET_OS but that is ambiguous.
 657 Please set it to either Minix3 or Ninix3, whereas the latter is
 658 all versions of Minix with even partial NetBSD(R) userland. The
 659 value determined from your compiler for the current compilation
 660 (which may be wrong) is: $ct
 661 "
 662                 TARGET_OS=$ct
 663                 ;;
 664         *)
 665                 echo >&2 "
 666 Warning: you set TARGET_OS to $TARGET_OS but that is ambiguous.
 667 Please set it to either Minix3 or Ninix3, whereas the latter is
 668 all versions of Minix with even partial NetBSD(R) userland. The
 669 proper value couldn't be determined, continue at your own risk.
 670 "
 671                 ;;
 672         esac
 673 fi
 674
 675 # Configuration depending on OS revision, on OSes that need them
 676 case $TARGET_OS in
 677 NEXTSTEP)
 678         test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`hostinfo 2>&1 | \
 679             grep 'NeXT Mach [0-9][0-9.]*:' | \
 680             sed 's/^.*NeXT Mach \([0-9][0-9.]*\):.*$/\1/'`
 681         ;;
 682 QNX|SCO_SV)
 683         test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
 684         ;;
 685 esac
 686
 687 # Configuration depending on OS name
 688 case $TARGET_OS in
 689 386BSD)
 690         : "${HAVE_CAN_OTWO=0}"
 691         add_cppflags -DMKSH_NO_SIGSETJMP
 692         add_cppflags -DMKSH_TYPEDEF_SIG_ATOMIC_T=int
 693         ;;
 694 AIX)
 695         add_cppflags -D_ALL_SOURCE
 696         : "${HAVE_SETLOCALE_CTYPE=0}"
 697         ;;
 698 BeOS)
 699         case $KSH_VERSION in
 700         *MIRBSD\ KSH*)
 701                 oswarn="; it has minor issues"
 702                 ;;
 703         *)
 704                 oswarn="; you must recompile mksh with"
 705                 oswarn="$oswarn${nl}itself in a second stage"
 706                 ;;
 707         esac
 708         # BeOS has no real tty either
 709         add_cppflags -DMKSH_UNEMPLOYED
 710         add_cppflags -DMKSH_DISABLE_TTY_WARNING
 711         # BeOS doesn't have different UIDs and GIDs
 712         add_cppflags -DMKSH__NO_SETEUGID
 713         ;;
 714 BSD/OS)
 715         : "${HAVE_SETLOCALE_CTYPE=0}"
 716         ;;
 717 Coherent)
 718         oswarn="; it has major issues"
 719         add_cppflags -DMKSH__NO_SYMLINK
 720         check_categories="$check_categories nosymlink"
 721         add_cppflags -DMKSH__NO_SETEUGID
 722         add_cppflags -DMKSH_DISABLE_TTY_WARNING
 723         ;;
 724 CYGWIN*)
 725         : "${HAVE_SETLOCALE_CTYPE=0}"
 726         ;;
 727 Darwin)
 728         add_cppflags -D_DARWIN_C_SOURCE
 729         ;;
 730 DragonFly)
 731         ;;
 732 FreeBSD)
 733         ;;
 734 FreeMiNT)
 735         oswarn="; it has minor issues"
 736         add_cppflags -D_GNU_SOURCE
 737         : "${HAVE_SETLOCALE_CTYPE=0}"
 738         ;;
 739 GNU)
 740         case $CC in
 741         *tendracc*) ;;
 742         *) add_cppflags -D_GNU_SOURCE ;;
 743         esac
 744         add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
 745         # define MKSH__NO_PATH_MAX to use Hurd-only functions
 746         add_cppflags -DMKSH__NO_PATH_MAX
 747         ;;
 748 GNU/kFreeBSD)
 749         case $CC in
 750         *tendracc*) ;;
 751         *) add_cppflags -D_GNU_SOURCE ;;
 752         esac
 753         add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
 754         ;;
 755 Haiku)
 756         add_cppflags -DMKSH_ASSUME_UTF8; HAVE_ISSET_MKSH_ASSUME_UTF8=1
 757         ;;
 758 HP-UX)
 759         ;;
 760 Interix)
 761         ccpc='-X '
 762         ccpl='-Y '
 763         add_cppflags -D_ALL_SOURCE
 764         : "${LIBS=-lcrypt}"
 765         : "${HAVE_SETLOCALE_CTYPE=0}"
 766         ;;
 767 IRIX*)
 768         : "${HAVE_SETLOCALE_CTYPE=0}"
 769         ;;
 770 Linux)
 771         case $CC in
 772         *tendracc*) ;;
 773         *) add_cppflags -D_GNU_SOURCE ;;
 774         esac
 775         add_cppflags -DSETUID_CAN_FAIL_WITH_EAGAIN
 776         : "${HAVE_REVOKE=0}"
 777         ;;
 778 LynxOS)
 779         oswarn="; it has minor issues"
 780         ;;
 781 MidnightBSD)
 782         ;;
 783 Minix-vmd)
 784         add_cppflags -DMKSH__NO_SETEUGID
 785         add_cppflags -DMKSH_UNEMPLOYED
 786         add_cppflags -D_MINIX_SOURCE
 787         oldish_ed=no-stderr-ed          # no /bin/ed, maybe see below
 788         : "${HAVE_SETLOCALE_CTYPE=0}"
 789         ;;
 790 Minix3)
 791         add_cppflags -DMKSH_UNEMPLOYED
 792         add_cppflags -DMKSH_NO_LIMITS
 793         add_cppflags -D_POSIX_SOURCE -D_POSIX_1_SOURCE=2 -D_MINIX
 794         oldish_ed=no-stderr-ed          # /usr/bin/ed(!) is broken
 795         : "${HAVE_SETLOCALE_CTYPE=0}"
 796         ;;
 797 MirBSD)
 798         ;;
 799 MSYS_*)
 800         add_cppflags -DMKSH_ASSUME_UTF8=0; HAVE_ISSET_MKSH_ASSUME_UTF8=1
 801         # almost same as CYGWIN* (from RT|Chatzilla)
 802         : "${HAVE_SETLOCALE_CTYPE=0}"
 803         # broken on this OE (from ir0nh34d)
 804         : "${HAVE_STDINT_H=0}"
 805         ;;
 806 NetBSD)
 807         ;;
 808 NEXTSTEP)
 809         add_cppflags -D_NEXT_SOURCE
 810         add_cppflags -D_POSIX_SOURCE
 811         : "${AWK=gawk}"
 812         : "${CC=cc -posix}"
 813         add_cppflags -DMKSH_NO_SIGSETJMP
 814         # NeXTstep cannot get a controlling tty
 815         add_cppflags -DMKSH_UNEMPLOYED
 816         case $TARGET_OSREV in
 817         4.2*)
 818                 # OpenStep 4.2 is broken by default
 819                 oswarn="; it needs libposix.a"
 820                 ;;
 821         esac
 822         ;;
 823 Ninix3)
 824         # similar to Minix3
 825         add_cppflags -DMKSH_UNEMPLOYED
 826         add_cppflags -DMKSH_NO_LIMITS
 827         # but no idea what else could be needed
 828         oswarn="; it has unknown issues"
 829         ;;
 830 OpenBSD)
 831         : "${HAVE_SETLOCALE_CTYPE=0}"
 832         ;;
 833 OS/2)
 834         HAVE_TERMIOS_H=0
 835         HAVE_MKNOD=0    # setmode() incompatible
 836         oswarn="; it is currently being ported"
 837         check_categories="$check_categories nosymlink"
 838         : "${CC=gcc}"
 839         : "${SIZE=: size}"
 840         add_cppflags -DMKSH_UNEMPLOYED
 841         add_cppflags -DMKSH_NOPROSPECTOFWORK
 842         ;;
 843 OSF1)
 844         HAVE_SIG_T=0    # incompatible
 845         add_cppflags -D_OSF_SOURCE
 846         add_cppflags -D_POSIX_C_SOURCE=200112L
 847         add_cppflags -D_XOPEN_SOURCE=600
 848         add_cppflags -D_XOPEN_SOURCE_EXTENDED
 849         : "${HAVE_SETLOCALE_CTYPE=0}"
 850         ;;
 851 Plan9)
 852         add_cppflags -D_POSIX_SOURCE
 853         add_cppflags -D_LIMITS_EXTENSION
 854         add_cppflags -D_BSD_EXTENSION
 855         add_cppflags -D_SUSV2_SOURCE
 856         add_cppflags -DMKSH_ASSUME_UTF8; HAVE_ISSET_MKSH_ASSUME_UTF8=1
 857         add_cppflags -DMKSH_NO_CMDLINE_EDITING
 858         add_cppflags -DMKSH__NO_SETEUGID
 859         oswarn=' and will currently not work'
 860         add_cppflags -DMKSH_UNEMPLOYED
 861         # this is for detecting kencc
 862         add_cppflags -DMKSH_MAYBE_KENCC
 863         ;;
 864 PW32*)
 865         HAVE_SIG_T=0    # incompatible
 866         oswarn=' and will currently not work'
 867         : "${HAVE_SETLOCALE_CTYPE=0}"
 868         ;;
 869 QNX)
 870         add_cppflags -D__NO_EXT_QNX
 871         add_cppflags -D__EXT_UNIX_MISC
 872         case $TARGET_OSREV in
 873         [012345].*|6.[0123].*|6.4.[01])
 874                 oldish_ed=no-stderr-ed          # oldish /bin/ed is broken
 875                 ;;
 876         esac
 877         : "${HAVE_SETLOCALE_CTYPE=0}"
 878         ;;
 879 SCO_SV)
 880         case $TARGET_OSREV in
 881         3.2*)
 882                 # SCO OpenServer 5
 883                 add_cppflags -DMKSH_UNEMPLOYED
 884                 ;;
 885         5*)
 886                 # SCO OpenServer 6
 887                 ;;
 888         *)
 889                 oswarn='; this is an unknown version of'
 890                 oswarn="$oswarn$nl$TARGET_OS ${TARGET_OSREV}, please tell me what to do"
 891                 ;;
 892         esac
 893         : "${HAVE_SYS_SIGLIST=0}${HAVE__SYS_SIGLIST=0}"
 894         ;;
 895 skyos)
 896         oswarn="; it has minor issues"
 897         ;;
 898 SunOS)
 899         add_cppflags -D_BSD_SOURCE
 900         add_cppflags -D__EXTENSIONS__
 901         ;;
 902 syllable)
 903         add_cppflags -D_GNU_SOURCE
 904         add_cppflags -DMKSH_NO_SIGSUSPEND
 905         oswarn=' and will currently not work'
 906         ;;
 907 ULTRIX)
 908         : "${CC=cc -YPOSIX}"
 909         add_cppflags -DMKSH_TYPEDEF_SSIZE_T=int
 910         : "${HAVE_SETLOCALE_CTYPE=0}"
 911         ;;
 912 UnixWare|UNIX_SV)
 913         # SCO UnixWare
 914         : "${HAVE_SYS_SIGLIST=0}${HAVE__SYS_SIGLIST=0}"
 915         ;;
 916 UWIN*)
 917         ccpc='-Yc,'
 918         ccpl='-Yl,'
 919         tsts=" 3<>/dev/tty"
 920         oswarn="; it will compile, but the target"
 921         oswarn="$oswarn${nl}platform itself is very flakey/unreliable"
 922         : "${HAVE_SETLOCALE_CTYPE=0}"
 923         ;;
 924 _svr4)
 925         # generic target for SVR4 Unix with uname -s = uname -n
 926         # this duplicates the * target below
 927         oswarn='; it may or may not work'
 928         test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
 929         ;;
 930 *)
 931         oswarn='; it may or may not work'
 932         test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r`
 933         ;;
 934 esac
 935
 936 : "${HAVE_MKNOD=0}"
 937
 938 : "${AWK=awk}${CC=cc}${NROFF=nroff}${SIZE=size}"
 939 test 0 = $r && echo | $NROFF -v 2>&1 | grep GNU >/dev/null 2>&1 && \
 940     echo | $NROFF -c >/dev/null 2>&1 && NROFF="$NROFF -c"
 941
 942 # this aids me in tracing FTBFSen without access to the buildd
 943 $e "Hi from$ao $bi$srcversion$ao on:"
 944 case $TARGET_OS in
 945 AIX)
 946         vv '|' "oslevel >&2"
 947         vv '|' "uname -a >&2"
 948         ;;
 949 Darwin)
 950         vv '|' "hwprefs machine_type os_type os_class >&2"
 951         vv '|' "sw_vers >&2"
 952         vv '|' "system_profiler SPSoftwareDataType SPHardwareDataType >&2"
 953         vv '|' "/bin/sh --version >&2"
 954         vv '|' "xcodebuild -version >&2"
 955         vv '|' "uname -a >&2"
 956         vv '|' "sysctl kern.version hw.machine hw.model hw.memsize hw.availcpu hw.cpufrequency hw.byteorder hw.cpu64bit_capable >&2"
 957         ;;
 958 IRIX*)
 959         vv '|' "uname -a >&2"
 960         vv '|' "hinv -v >&2"
 961         ;;
 962 OSF1)
 963         vv '|' "uname -a >&2"
 964         vv '|' "/usr/sbin/sizer -v >&2"
 965         ;;
 966 SCO_SV|UnixWare|UNIX_SV)
 967         vv '|' "uname -a >&2"
 968         vv '|' "uname -X >&2"
 969         ;;
 970 *)
 971         vv '|' "uname -a >&2"
 972         ;;
 973 esac
 974 test -z "$oswarn" || echo >&2 "
 975 Warning: mksh has not yet been ported to or tested on your
 976 operating system '$TARGET_OS'$oswarn. If you can provide
 977 a shell account to the developer, this may improve; please
 978 drop us a success or failure notice or even send in diffs.
 979 "
 980 $e "$bi$me: Building the MirBSD Korn Shell$ao $ui$dstversion$ao on $TARGET_OS ${TARGET_OSREV}..."
 981
 982 #
 983 # Begin of mirtoconf checks
 984 #
 985 $e $bi$me: Scanning for functions... please ignore any errors.$ao
 986
 987 #
 988 # Compiler: which one?
 989 #
 990 # notes:
 991 # - ICC defines __GNUC__ too
 992 # - GCC defines __hpux too
 993 # - LLVM+clang defines __GNUC__ too
 994 # - nwcc defines __GNUC__ too
 995 CPP="$CC -E"
 996 $e ... which compiler seems to be used
 997 cat >conftest.c <<'EOF'
 998 const char *
 999 #if defined(__ICC) || defined(__INTEL_COMPILER)
1000 ct="icc"
1001 #elif defined(__xlC__) || defined(__IBMC__)
1002 ct="xlc"
1003 #elif defined(__SUNPRO_C)
1004 ct="sunpro"
1005 #elif defined(__ACK__)
1006 ct="ack"
1007 #elif defined(__BORLANDC__)
1008 ct="bcc"
1009 #elif defined(__WATCOMC__)
1010 ct="watcom"
1011 #elif defined(__MWERKS__)
1012 ct="metrowerks"
1013 #elif defined(__HP_cc)
1014 ct="hpcc"
1015 #elif defined(__DECC) || (defined(__osf__) && !defined(__GNUC__))
1016 ct="dec"
1017 #elif defined(__PGI)
1018 ct="pgi"
1019 #elif defined(__DMC__)
1020 ct="dmc"
1021 #elif defined(_MSC_VER)
1022 ct="msc"
1023 #elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
1024 ct="adsp"
1025 #elif defined(__IAR_SYSTEMS_ICC__)
1026 ct="iar"
1027 #elif defined(SDCC)
1028 ct="sdcc"
1029 #elif defined(__PCC__)
1030 ct="pcc"
1031 #elif defined(__TenDRA__)
1032 ct="tendra"
1033 #elif defined(__TINYC__)
1034 ct="tcc"
1035 #elif defined(__llvm__) && defined(__clang__)
1036 ct="clang"
1037 #elif defined(__NWCC__)
1038 ct="nwcc"
1039 #elif defined(__GNUC__)
1040 ct="gcc"
1041 #elif defined(_COMPILER_VERSION)
1042 ct="mipspro"
1043 #elif defined(__sgi)
1044 ct="mipspro"
1045 #elif defined(__hpux) || defined(__hpua)
1046 ct="hpcc"
1047 #elif defined(__ultrix)
1048 ct="ucode"
1049 #elif defined(__USLC__)
1050 ct="uslc"
1051 #elif defined(__LCC__)
1052 ct="lcc"
1053 #elif defined(MKSH_MAYBE_KENCC)
1054 /* and none of the above matches */
1055 ct="kencc"
1056 #else
1057 ct="unknown"
1058 #endif
1059 ;
1060 const char *
1061 #if defined(__KLIBC__) && !defined(__OS2__)
1062 et="klibc"
1063 #else
1064 et="unknown"
1065 #endif
1066 ;
1067 EOF
1068 ct=untested
1069 et=untested
1070 vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c | \
1071     sed -n '/^ *[ce]t *= */s/^ *\([ce]t\) *= */\1=/p' | tr -d \\\\015 >x"
1072 sed 's/^/[ /' x
1073 eval `cat x`
1074 rmf x vv.out
1075 cat >conftest.c <<'EOF'
1076 #include <unistd.h>
1077 int main(void) { return (isatty(0)); }
1078 EOF
1079 case $ct in
1080 ack)
1081         # work around "the famous ACK const bug"
1082         CPPFLAGS="-Dconst= $CPPFLAGS"
1083         ;;
1084 adsp)
1085         echo >&2 'Warning: Analog Devices C++ compiler for Blackfin, TigerSHARC
1086     and SHARC (21000) DSPs detected. This compiler has not yet
1087     been tested for compatibility with mksh. Continue at your
1088     own risk, please report success/failure to the developers.'
1089         ;;
1090 bcc)
1091         echo >&2 "Warning: Borland C++ Builder detected. This compiler might
1092     produce broken executables. Continue at your own risk,
1093     please report success/failure to the developers."
1094         ;;
1095 clang)
1096         # does not work with current "ccc" compiler driver
1097         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
1098         # one of these two works, for now
1099         vv '|' "${CLANG-clang} -version"
1100         vv '|' "${CLANG-clang} --version"
1101         # ensure compiler and linker are in sync unless overridden
1102         case $CCC_CC:$CCC_LD in
1103         :*)     ;;
1104         *:)     CCC_LD=$CCC_CC; export CCC_LD ;;
1105         esac
1106         : "${HAVE_STRING_POOLING=i1}"
1107         ;;
1108 dec)
1109         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
1110         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -Wl,-V conftest.c $LIBS"
1111         ;;
1112 dmc)
1113         echo >&2 "Warning: Digital Mars Compiler detected. When running under"
1114         echo >&2 "    UWIN, mksh tends to be unstable due to the limitations"
1115         echo >&2 "    of this platform. Continue at your own risk,"
1116         echo >&2 "    please report success/failure to the developers."
1117         ;;
1118 gcc)
1119         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
1120         vv '|' 'echo `$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS \
1121             -dumpmachine` gcc`$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN \
1122             $LIBS -dumpversion`'
1123         : "${HAVE_STRING_POOLING=i2}"
1124         ;;
1125 hpcc)
1126         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
1127         ;;
1128 iar)
1129         echo >&2 'Warning: IAR Systems (http://www.iar.com) compiler for embedded
1130     systems detected. This unsupported compiler has not yet
1131     been tested for compatibility with mksh. Continue at your
1132     own risk, please report success/failure to the developers.'
1133         ;;
1134 icc)
1135         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
1136         ;;
1137 kencc)
1138         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
1139         ;;
1140 lcc)
1141         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
1142         add_cppflags -D__inline__=__inline
1143         ;;
1144 metrowerks)
1145         echo >&2 'Warning: Metrowerks C compiler detected. This has not yet
1146     been tested for compatibility with mksh. Continue at your
1147     own risk, please report success/failure to the developers.'
1148         ;;
1149 mipspro)
1150         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
1151         ;;
1152 msc)
1153         ccpr=           # errorlevels are not reliable
1154         case $TARGET_OS in
1155         Interix)
1156                 if [[ -n $C89_COMPILER ]]; then
1157                         C89_COMPILER=`ntpath2posix -c "$C89_COMPILER"`
1158                 else
1159                         C89_COMPILER=CL.EXE
1160                 fi
1161                 if [[ -n $C89_LINKER ]]; then
1162                         C89_LINKER=`ntpath2posix -c "$C89_LINKER"`
1163                 else
1164                         C89_LINKER=LINK.EXE
1165                 fi
1166                 vv '|' "$C89_COMPILER /HELP >&2"
1167                 vv '|' "$C89_LINKER /LINK >&2"
1168                 ;;
1169         esac
1170         ;;
1171 nwcc)
1172         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version"
1173         ;;
1174 pcc)
1175         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -v"
1176         ;;
1177 pgi)
1178         echo >&2 'Warning: PGI detected. This unknown compiler has not yet
1179     been tested for compatibility with mksh. Continue at your
1180     own risk, please report success/failure to the developers.'
1181         ;;
1182 sdcc)
1183         echo >&2 'Warning: sdcc (http://sdcc.sourceforge.net), the small devices
1184     C compiler for embedded systems detected. This has not yet
1185     been tested for compatibility with mksh. Continue at your
1186     own risk, please report success/failure to the developers.'
1187         ;;
1188 sunpro)
1189         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
1190         ;;
1191 tcc)
1192         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -v"
1193         ;;
1194 tendra)
1195         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V 2>&1 | \
1196             grep -F -i -e version -e release"
1197         ;;
1198 ucode)
1199         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V"
1200         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -Wl,-V conftest.c $LIBS"
1201         ;;
1202 uslc)
1203         case $TARGET_OS:$TARGET_OSREV in
1204         SCO_SV:3.2*)
1205                 # SCO OpenServer 5
1206                 CFLAGS="$CFLAGS -g"
1207                 : "${HAVE_CAN_OTWO=0}${HAVE_CAN_OPTIMISE=0}"
1208                 ;;
1209         esac
1210         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
1211         ;;
1212 watcom)
1213         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
1214         ;;
1215 xlc)
1216         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -qversion"
1217         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -qversion=verbose"
1218         vv '|' "ld -V"
1219         ;;
1220 *)
1221         test x"$ct" = x"untested" && $e "!!! detecting preprocessor failed"
1222         ct=unknown
1223         vv "$CC --version"
1224         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS"
1225         vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS"
1226         ;;
1227 esac
1228 case $cm in
1229 dragonegg|llvm)
1230         vv '|' "llc -version"
1231         ;;
1232 esac
1233 etd=" on $et"
1234 case $et in
1235 klibc)
1236         add_cppflags -DMKSH_NO_LIMITS
1237         ;;
1238 unknown)
1239         # nothing special detected, don’t worry
1240         etd=
1241         ;;
1242 *)
1243         # huh?
1244         ;;
1245 esac
1246 $e "$bi==> which compiler seems to be used...$ao $ui$ct$etd$ao"
1247 rmf conftest.c conftest.o conftest a.out* a.exe* conftest.exe* vv.out
1248
1249 #
1250 # Compiler: works as-is, with -Wno-error and -Werror
1251 #
1252 save_NOWARN=$NOWARN
1253 NOWARN=
1254 DOWARN=
1255 ac_flags 0 compiler_works '' 'if the compiler works'
1256 test 1 = $HAVE_CAN_COMPILER_WORKS || exit 1
1257 HAVE_COMPILER_KNOWN=0
1258 test $ct = unknown || HAVE_COMPILER_KNOWN=1
1259 if ac_ifcpp 'if 0' compiler_fails '' \
1260     'if the compiler does not fail correctly'; then
1261         save_CFLAGS=$CFLAGS
1262         : "${HAVE_CAN_DELEXE=x}"
1263         case $ct in
1264         dec)
1265                 CFLAGS="$CFLAGS ${ccpl}-non_shared"
1266                 ac_testn can_delexe compiler_fails 0 'for the -non_shared linker option' <<-EOF
1267                         #include <unistd.h>
1268                         int main(void) { return (isatty(0)); }
1269                 EOF
1270                 ;;
1271         dmc)
1272                 CFLAGS="$CFLAGS ${ccpl}/DELEXECUTABLE"
1273                 ac_testn can_delexe compiler_fails 0 'for the /DELEXECUTABLE linker option' <<-EOF
1274                         #include <unistd.h>
1275                         int main(void) { return (isatty(0)); }
1276                 EOF
1277                 ;;
1278         *)
1279                 exit 1
1280                 ;;
1281         esac
1282         test 1 = $HAVE_CAN_DELEXE || CFLAGS=$save_CFLAGS
1283         ac_testn compiler_still_fails '' 'if the compiler still does not fail correctly' <<-EOF
1284         EOF
1285         test 1 = $HAVE_COMPILER_STILL_FAILS && exit 1
1286 fi
1287 if ac_ifcpp 'ifdef __TINYC__' couldbe_tcc '!' compiler_known 0 \
1288     'if this could be tcc'; then
1289         ct=tcc
1290         CPP='cpp -D__TINYC__'
1291         HAVE_COMPILER_KNOWN=1
1292 fi
1293
1294 case $ct in
1295 bcc)
1296         save_NOWARN="${ccpc}-w"
1297         DOWARN="${ccpc}-w!"
1298         ;;
1299 dec)
1300         # -msg_* flags not used yet, or is -w2 correct?
1301         ;;
1302 dmc)
1303         save_NOWARN="${ccpc}-w"
1304         DOWARN="${ccpc}-wx"
1305         ;;
1306 hpcc)
1307         save_NOWARN=
1308         DOWARN=+We
1309         ;;
1310 kencc)
1311         save_NOWARN=
1312         DOWARN=
1313         ;;
1314 mipspro)
1315         save_NOWARN=
1316         DOWARN="-diag_error 1-10000"
1317         ;;
1318 msc)
1319         save_NOWARN="${ccpc}/w"
1320         DOWARN="${ccpc}/WX"
1321         ;;
1322 sunpro)
1323         test x"$save_NOWARN" = x"" && save_NOWARN='-errwarn=%none'
1324         ac_flags 0 errwarnnone "$save_NOWARN"
1325         test 1 = $HAVE_CAN_ERRWARNNONE || save_NOWARN=
1326         ac_flags 0 errwarnall "-errwarn=%all"
1327         test 1 = $HAVE_CAN_ERRWARNALL && DOWARN="-errwarn=%all"
1328         ;;
1329 tendra)
1330         save_NOWARN=-w
1331         ;;
1332 ucode)
1333         save_NOWARN=
1334         DOWARN=-w2
1335         ;;
1336 watcom)
1337         save_NOWARN=
1338         DOWARN=-Wc,-we
1339         ;;
1340 xlc)
1341         save_NOWARN=-qflag=i:e
1342         DOWARN=-qflag=i:i
1343         ;;
1344 *)
1345         test x"$save_NOWARN" = x"" && save_NOWARN=-Wno-error
1346         ac_flags 0 wnoerror "$save_NOWARN"
1347         test 1 = $HAVE_CAN_WNOERROR || save_NOWARN=
1348         ac_flags 0 werror -Werror
1349         test 1 = $HAVE_CAN_WERROR && DOWARN=-Werror
1350         test $ct = icc && DOWARN="$DOWARN -wd1419"
1351         ;;
1352 esac
1353 NOWARN=$save_NOWARN
1354
1355 #
1356 # Compiler: extra flags (-O2 -f* -W* etc.)
1357 #
1358 i=`echo :"$orig_CFLAGS" | sed 's/^://' | tr -c -d $alll$allu$alln`
1359 # optimisation: only if orig_CFLAGS is empty
1360 test x"$i" = x"" && case $ct in
1361 hpcc)
1362         phase=u
1363         ac_flags 1 otwo +O2
1364         phase=x
1365         ;;
1366 kencc|tcc|tendra)
1367         # no special optimisation
1368         ;;
1369 sunpro)
1370         cat >x <<-'EOF'
1371                 #include <unistd.h>
1372                 int main(void) { return (isatty(0)); }
1373                 #define __IDSTRING_CONCAT(l,p)  __LINTED__ ## l ## _ ## p
1374                 #define __IDSTRING_EXPAND(l,p)  __IDSTRING_CONCAT(l,p)
1375                 #define pad                     void __IDSTRING_EXPAND(__LINE__,x)(void) { }
1376         EOF
1377         yes pad | head -n 256 >>x
1378         ac_flags - 1 otwo -xO2 <x
1379         rmf x
1380         ;;
1381 xlc)
1382         ac_flags 1 othree "-O3 -qstrict"
1383         test 1 = $HAVE_CAN_OTHREE || ac_flags 1 otwo -O2
1384         ;;
1385 *)
1386         ac_flags 1 otwo -O2
1387         test 1 = $HAVE_CAN_OTWO || ac_flags 1 optimise -O
1388         ;;
1389 esac
1390 # other flags: just add them if they are supported
1391 i=0
1392 case $ct in
1393 bcc)
1394         ac_flags 1 strpool "${ccpc}-d" 'if string pooling can be enabled'
1395         ;;
1396 clang)
1397         i=1
1398         ;;
1399 dec)
1400         ac_flags 0 verb -verbose
1401         ac_flags 1 rodata -readonly_strings
1402         ;;
1403 dmc)
1404         ac_flags 1 decl "${ccpc}-r" 'for strict prototype checks'
1405         ac_flags 1 schk "${ccpc}-s" 'for stack overflow checking'
1406         ;;
1407 gcc)
1408         # The following tests run with -Werror (gcc only) if possible
1409         NOWARN=$DOWARN; phase=u
1410         ac_flags 1 wnodeprecateddecls -Wno-deprecated-declarations
1411         # mksh is not written in CFrustFrust!
1412         ac_flags 1 no_eh_frame -fno-asynchronous-unwind-tables
1413         ac_flags 1 fnostrictaliasing -fno-strict-aliasing
1414         ac_flags 1 fstackprotectorstrong -fstack-protector-strong
1415         test 1 = $HAVE_CAN_FSTACKPROTECTORSTRONG || \
1416             ac_flags 1 fstackprotectorall -fstack-protector-all
1417         test $cm = dragonegg && case " $CC $CFLAGS $LDFLAGS " in
1418         *\ -fplugin=*dragonegg*) ;;
1419         *) ac_flags 1 fplugin_dragonegg -fplugin=dragonegg ;;
1420         esac
1421         case $cm in
1422         combine)
1423                 fv=0
1424                 checks='7 8'
1425                 ;;
1426         lto)
1427                 fv=0
1428                 checks='1 2 3 4 5 6 7 8'
1429                 ;;
1430         *)
1431                 fv=1
1432                 ;;
1433         esac
1434         test $fv = 1 || for what in $checks; do
1435                 test $fv = 1 && break
1436                 case $what in
1437                 1)      t_cflags='-flto=jobserver'
1438                         t_ldflags='-fuse-linker-plugin'
1439                         t_use=1 t_name=fltojs_lp ;;
1440                 2)      t_cflags='-flto=jobserver' t_ldflags=''
1441                         t_use=1 t_name=fltojs_nn ;;
1442                 3)      t_cflags='-flto=jobserver'
1443                         t_ldflags='-fno-use-linker-plugin -fwhole-program'
1444                         t_use=1 t_name=fltojs_np ;;
1445                 4)      t_cflags='-flto'
1446                         t_ldflags='-fuse-linker-plugin'
1447                         t_use=1 t_name=fltons_lp ;;
1448                 5)      t_cflags='-flto' t_ldflags=''
1449                         t_use=1 t_name=fltons_nn ;;
1450                 6)      t_cflags='-flto'
1451                         t_ldflags='-fno-use-linker-plugin -fwhole-program'
1452                         t_use=1 t_name=fltons_np ;;
1453                 7)      t_cflags='-fwhole-program --combine' t_ldflags=''
1454                         t_use=0 t_name=combine cm=combine ;;
1455                 8)      fv=1 cm=normal ;;
1456                 esac
1457                 test $fv = 1 && break
1458                 ac_flags $t_use $t_name "$t_cflags" \
1459                     "if gcc supports $t_cflags $t_ldflags" "$t_ldflags"
1460         done
1461         i=1
1462         ;;
1463 hpcc)
1464         phase=u
1465         # probably not needed
1466         #ac_flags 1 agcc -Agcc 'for support of GCC extensions'
1467         phase=x
1468         ;;
1469 icc)
1470         ac_flags 1 fnobuiltinsetmode -fno-builtin-setmode
1471         ac_flags 1 fnostrictaliasing -fno-strict-aliasing
1472         ac_flags 1 fstacksecuritycheck -fstack-security-check
1473         i=1
1474         ;;
1475 mipspro)
1476         ac_flags 1 fullwarn -fullwarn 'for remark output support'
1477         ;;
1478 msc)
1479         ac_flags 1 strpool "${ccpc}/GF" 'if string pooling can be enabled'
1480         echo 'int main(void) { char test[64] = ""; return (*test); }' >x
1481         ac_flags - 1 stackon "${ccpc}/GZ" 'if stack checks can be enabled' <x
1482         ac_flags - 1 stckall "${ccpc}/Ge" 'stack checks for all functions' <x
1483         ac_flags - 1 secuchk "${ccpc}/GS" 'for compiler security checks' <x
1484         rmf x
1485         ac_flags 1 wall "${ccpc}/Wall" 'to enable all warnings'
1486         ac_flags 1 wp64 "${ccpc}/Wp64" 'to enable 64-bit warnings'
1487         ;;
1488 nwcc)
1489         i=1
1490         #broken# ac_flags 1 ssp -stackprotect
1491         ;;
1492 sunpro)
1493         phase=u
1494         ac_flags 1 v -v
1495         ac_flags 1 ipo -xipo 'for cross-module optimisation'
1496         phase=x
1497         ;;
1498 tcc)
1499         : #broken# ac_flags 1 boundschk -b
1500         ;;
1501 tendra)
1502         ac_flags 0 ysystem -Ysystem
1503         test 1 = $HAVE_CAN_YSYSTEM && CPPFLAGS="-Ysystem $CPPFLAGS"
1504         ac_flags 1 extansi -Xa
1505         ;;
1506 xlc)
1507         ac_flags 1 rodata "-qro -qroconst -qroptr"
1508         ac_flags 1 rtcheck -qcheck=all
1509         #ac_flags 1 rtchkc -qextchk     # reported broken
1510         ac_flags 1 wformat "-qformat=all -qformat=nozln"
1511         #ac_flags 1 wp64 -qwarn64       # too verbose for now
1512         ;;
1513 esac
1514 # flags common to a subset of compilers (run with -Werror on gcc)
1515 if test 1 = $i; then
1516         ac_flags 1 wall -Wall
1517         ac_flags 1 fwrapv -fwrapv
1518 fi
1519
1520 # “on demand” means: GCC version >= 4
1521 fd='if to rely on compiler for string pooling'
1522 ac_cache string_pooling || case $HAVE_STRING_POOLING in
1523 2) fx=' (on demand, cached)' ;;
1524 i1) fv=1 ;;
1525 i2) fv=2; fx=' (on demand)' ;;
1526 esac
1527 ac_testdone
1528 test x"$HAVE_STRING_POOLING" = x"0" || ac_cppflags
1529
1530 phase=x
1531 # The following tests run with -Werror or similar (all compilers) if possible
1532 NOWARN=$DOWARN
1533 test $ct = pcc && phase=u
1534
1535 #
1536 # Compiler: check for stuff that only generates warnings
1537 #
1538 ac_test attribute_bounded '' 'for __attribute__((__bounded__))' <<-'EOF'
1539         #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
1540         extern int thiswillneverbedefinedIhope(void);
1541         /* force a failure: TenDRA and gcc 1.42 have false positive here */
1542         int main(void) { return (thiswillneverbedefinedIhope()); }
1543         #else
1544         #include <string.h>
1545         #undef __attribute__
1546         int xcopy(const void *, void *, size_t)
1547             __attribute__((__bounded__(__buffer__, 1, 3)))
1548             __attribute__((__bounded__(__buffer__, 2, 3)));
1549         int main(int ac, char *av[]) { return (xcopy(av[0], av[--ac], 1)); }
1550         int xcopy(const void *s, void *d, size_t n) {
1551                 /*
1552                  * if memmove does not exist, we are not on a system
1553                  * with GCC with __bounded__ attribute either so poo
1554                  */
1555                 memmove(d, s, n); return ((int)n);
1556         }
1557         #endif
1558 EOF
1559 ac_test attribute_format '' 'for __attribute__((__format__))' <<-'EOF'
1560         #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
1561         extern int thiswillneverbedefinedIhope(void);
1562         /* force a failure: TenDRA and gcc 1.42 have false positive here */
1563         int main(void) { return (thiswillneverbedefinedIhope()); }
1564         #else
1565         #define fprintf printfoo
1566         #include <stdio.h>
1567         #undef __attribute__
1568         #undef fprintf
1569         extern int fprintf(FILE *, const char *format, ...)
1570             __attribute__((__format__(__printf__, 2, 3)));
1571         int main(int ac, char **av) { return (fprintf(stderr, "%s%d", *av, ac)); }
1572         #endif
1573 EOF
1574 ac_test attribute_noreturn '' 'for __attribute__((__noreturn__))' <<-'EOF'
1575         #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
1576         extern int thiswillneverbedefinedIhope(void);
1577         /* force a failure: TenDRA and gcc 1.42 have false positive here */
1578         int main(void) { return (thiswillneverbedefinedIhope()); }
1579         #else
1580         #include <stdlib.h>
1581         #undef __attribute__
1582         void fnord(void) __attribute__((__noreturn__));
1583         int main(void) { fnord(); }
1584         void fnord(void) { exit(0); }
1585         #endif
1586 EOF
1587 ac_test attribute_pure '' 'for __attribute__((__pure__))' <<-'EOF'
1588         #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
1589         extern int thiswillneverbedefinedIhope(void);
1590         /* force a failure: TenDRA and gcc 1.42 have false positive here */
1591         int main(void) { return (thiswillneverbedefinedIhope()); }
1592         #else
1593         #include <unistd.h>
1594         #undef __attribute__
1595         int foo(const char *) __attribute__((__pure__));
1596         int main(int ac, char **av) { return (foo(av[ac - 1]) + isatty(0)); }
1597         int foo(const char *s) { return ((int)s[0]); }
1598         #endif
1599 EOF
1600 ac_test attribute_unused '' 'for __attribute__((__unused__))' <<-'EOF'
1601         #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
1602         extern int thiswillneverbedefinedIhope(void);
1603         /* force a failure: TenDRA and gcc 1.42 have false positive here */
1604         int main(void) { return (thiswillneverbedefinedIhope()); }
1605         #else
1606         #include <unistd.h>
1607         #undef __attribute__
1608         int main(int ac __attribute__((__unused__)), char **av
1609             __attribute__((__unused__))) { return (isatty(0)); }
1610         #endif
1611 EOF
1612 ac_test attribute_used '' 'for __attribute__((__used__))' <<-'EOF'
1613         #if defined(__TenDRA__) || (defined(__GNUC__) && (__GNUC__ < 2))
1614         extern int thiswillneverbedefinedIhope(void);
1615         /* force a failure: TenDRA and gcc 1.42 have false positive here */
1616         int main(void) { return (thiswillneverbedefinedIhope()); }
1617         #else
1618         #include <unistd.h>
1619         #undef __attribute__
1620         static const char fnord[] __attribute__((__used__)) = "42";
1621         int main(void) { return (isatty(0)); }
1622         #endif
1623 EOF
1624
1625 # End of tests run with -Werror
1626 NOWARN=$save_NOWARN
1627 phase=x
1628
1629 #
1630 # mksh: flavours (full/small mksh, omit certain stuff)
1631 #
1632 if ac_ifcpp 'ifdef MKSH_SMALL' isset_MKSH_SMALL '' \
1633     "if a reduced-feature mksh is requested"; then
1634         : "${HAVE_NICE=0}"
1635         : "${HAVE_PERSISTENT_HISTORY=0}"
1636         check_categories="$check_categories smksh"
1637 fi
1638 ac_ifcpp 'if defined(MKSH_BINSHPOSIX) || defined(MKSH_BINSHREDUCED)' \
1639     isset_MKSH_BINSH '' 'if invoking as sh should be handled specially' && \
1640     check_categories="$check_categories binsh"
1641 ac_ifcpp 'ifdef MKSH_UNEMPLOYED' isset_MKSH_UNEMPLOYED '' \
1642     "if mksh will be built without job control" && \
1643     check_categories="$check_categories arge"
1644 ac_ifcpp 'ifdef MKSH_NOPROSPECTOFWORK' isset_MKSH_NOPROSPECTOFWORK '' \
1645     "if mksh will be built without job signals" && \
1646     check_categories="$check_categories arge nojsig"
1647 ac_ifcpp 'ifdef MKSH_ASSUME_UTF8' isset_MKSH_ASSUME_UTF8 '' \
1648     'if the default UTF-8 mode is specified' && : "${HAVE_SETLOCALE_CTYPE=0}"
1649 #ac_ifcpp 'ifdef MKSH_DISABLE_DEPRECATED' isset_MKSH_DISABLE_DEPRECATED '' \
1650 #    "if deprecated features are to be omitted" && \
1651 #    check_categories="$check_categories nodeprecated"
1652 #ac_ifcpp 'ifdef MKSH_DISABLE_EXPERIMENTAL' isset_MKSH_DISABLE_EXPERIMENTAL '' \
1653 #    "if experimental features are to be omitted" && \
1654 #    check_categories="$check_categories noexperimental"
1655 ac_ifcpp 'ifdef MKSH_MIDNIGHTBSD01ASH_COMPAT' isset_MKSH_MIDNIGHTBSD01ASH_COMPAT '' \
1656     'if the MidnightBSD 0.1 ash compatibility mode is requested' && \
1657     check_categories="$check_categories mnbsdash"
1658
1659 #
1660 # Environment: headers
1661 #
1662 ac_header sys/time.h sys/types.h
1663 ac_header time.h sys/types.h
1664 test "11" = "$HAVE_SYS_TIME_H$HAVE_TIME_H" || HAVE_BOTH_TIME_H=0
1665 ac_test both_time_h '' 'whether <sys/time.h> and <time.h> can both be included' <<-'EOF'
1666         #include <sys/types.h>
1667         #include <sys/time.h>
1668         #include <time.h>
1669         #include <unistd.h>
1670         int main(void) { struct tm tm; return ((int)sizeof(tm) + isatty(0)); }
1671 EOF
1672 ac_header sys/bsdtypes.h
1673 ac_header sys/file.h sys/types.h
1674 ac_header sys/mkdev.h sys/types.h
1675 ac_header sys/mman.h sys/types.h
1676 ac_header sys/param.h
1677 ac_header sys/resource.h sys/types.h _time
1678 ac_header sys/select.h sys/types.h
1679 ac_header sys/sysmacros.h
1680 ac_header bstring.h
1681 ac_header grp.h sys/types.h
1682 ac_header io.h
1683 ac_header libgen.h
1684 ac_header libutil.h sys/types.h
1685 ac_header paths.h
1686 ac_header stdint.h stdarg.h
1687 # include strings.h only if compatible with string.h
1688 ac_header strings.h sys/types.h string.h
1689 ac_header termios.h
1690 ac_header ulimit.h sys/types.h
1691 ac_header values.h
1692
1693 #
1694 # Environment: definitions
1695 #
1696 echo '#include <sys/types.h>
1697 #include <unistd.h>
1698 /* check that off_t can represent 2^63-1 correctly, thx FSF */
1699 #define LARGE_OFF_T ((((off_t)1 << 31) << 31) - 1 + (((off_t)1 << 31) << 31))
1700 int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 &&
1701     LARGE_OFF_T % 2147483647 == 1) ? 1 : -1];
1702 int main(void) { return (isatty(0)); }' >lft.c
1703 ac_testn can_lfs '' "for large file support" <lft.c
1704 save_CPPFLAGS=$CPPFLAGS
1705 add_cppflags -D_FILE_OFFSET_BITS=64
1706 ac_testn can_lfs_sus '!' can_lfs 0 "... with -D_FILE_OFFSET_BITS=64" <lft.c
1707 if test 0 = $HAVE_CAN_LFS_SUS; then
1708         CPPFLAGS=$save_CPPFLAGS
1709         add_cppflags -D_LARGE_FILES=1
1710         ac_testn can_lfs_aix '!' can_lfs 0 "... with -D_LARGE_FILES=1" <lft.c
1711         test 1 = $HAVE_CAN_LFS_AIX || CPPFLAGS=$save_CPPFLAGS
1712 fi
1713 rm -f lft.c
1714 rmf lft*        # end of large file support test
1715
1716 #
1717 # Environment: types
1718 #
1719 ac_test can_inttypes '!' stdint_h 1 "for standard 32-bit integer types" <<-'EOF'
1720         #include <sys/types.h>
1721         #include <stddef.h>
1722         int main(int ac, char **av) { return ((uint32_t)(size_t)*av + (int32_t)ac); }
1723 EOF
1724 ac_test can_ucbints '!' can_inttypes 1 "for UCB 32-bit integer types" <<-'EOF'
1725         #include <sys/types.h>
1726         #include <stddef.h>
1727         int main(int ac, char **av) { return ((u_int32_t)(size_t)*av + (int32_t)ac); }
1728 EOF
1729 ac_test can_int8type '!' stdint_h 1 "for standard 8-bit integer type" <<-'EOF'
1730         #include <sys/types.h>
1731         #include <stddef.h>
1732         int main(int ac, char **av) { return ((uint8_t)(size_t)av[ac]); }
1733 EOF
1734 ac_test can_ucbint8 '!' can_int8type 1 "for UCB 8-bit integer type" <<-'EOF'
1735         #include <sys/types.h>
1736         #include <stddef.h>
1737         int main(int ac, char **av) { return ((u_int8_t)(size_t)av[ac]); }
1738 EOF
1739
1740 ac_test rlim_t <<-'EOF'
1741         #include <sys/types.h>
1742         #if HAVE_BOTH_TIME_H
1743         #include <sys/time.h>
1744         #include <time.h>
1745         #elif HAVE_SYS_TIME_H
1746         #include <sys/time.h>
1747         #elif HAVE_TIME_H
1748         #include <time.h>
1749         #endif
1750         #if HAVE_SYS_RESOURCE_H
1751         #include <sys/resource.h>
1752         #endif
1753         #include <unistd.h>
1754         int main(void) { return (((int)(rlim_t)0) + isatty(0)); }
1755 EOF
1756
1757 # only testn: added later below
1758 ac_testn sig_t <<-'EOF'
1759         #include <sys/types.h>
1760         #include <signal.h>
1761         #include <stddef.h>
1762         volatile sig_t foo = (sig_t)0;
1763         int main(void) { return (foo == (sig_t)0); }
1764 EOF
1765
1766 ac_testn sighandler_t '!' sig_t 0 <<-'EOF'
1767         #include <sys/types.h>
1768         #include <signal.h>
1769         #include <stddef.h>
1770         volatile sighandler_t foo = (sighandler_t)0;
1771         int main(void) { return (foo == (sighandler_t)0); }
1772 EOF
1773 if test 1 = $HAVE_SIGHANDLER_T; then
1774         add_cppflags -Dsig_t=sighandler_t
1775         HAVE_SIG_T=1
1776 fi
1777
1778 ac_testn __sighandler_t '!' sig_t 0 <<-'EOF'
1779         #include <sys/types.h>
1780         #include <signal.h>
1781         #include <stddef.h>
1782         volatile __sighandler_t foo = (__sighandler_t)0;
1783         int main(void) { return (foo == (__sighandler_t)0); }
1784 EOF
1785 if test 1 = $HAVE___SIGHANDLER_T; then
1786         add_cppflags -Dsig_t=__sighandler_t
1787         HAVE_SIG_T=1
1788 fi
1789
1790 test 1 = $HAVE_SIG_T || add_cppflags -Dsig_t=nosig_t
1791 ac_cppflags SIG_T
1792
1793 #
1794 # check whether whatever we use for the final link will succeed
1795 #
1796 if test $cm = makefile; then
1797         : nothing to check
1798 else
1799         HAVE_LINK_WORKS=x
1800         ac_testinit link_works '' 'checking if the final link command may succeed'
1801         fv=1
1802         cat >conftest.c <<-EOF
1803                 #define EXTERN
1804                 #define MKSH_INCLUDES_ONLY
1805                 #include "sh.h"
1806                 __RCSID("$srcversion");
1807                 int main(void) { printf("Hello, World!\\n"); return (isatty(0)); }
1808 EOF
1809         case $cm in
1810         llvm)
1811                 v "$CC $CFLAGS $CPPFLAGS $NOWARN -emit-llvm -c conftest.c" || fv=0
1812                 rmf $tfn.s
1813                 test $fv = 0 || v "llvm-link -o - conftest.o | opt $optflags | llc -o $tfn.s" || fv=0
1814                 test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn $tfn.s $LIBS $ccpr"
1815                 ;;
1816         dragonegg)
1817                 v "$CC $CFLAGS $CPPFLAGS $NOWARN -S -flto conftest.c" || fv=0
1818                 test $fv = 0 || v "mv conftest.s conftest.ll"
1819                 test $fv = 0 || v "llvm-as conftest.ll" || fv=0
1820                 rmf $tfn.s
1821                 test $fv = 0 || v "llvm-link -o - conftest.bc | opt $optflags | llc -o $tfn.s" || fv=0
1822                 test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn $tfn.s $LIBS $ccpr"
1823                 ;;
1824         combine)
1825                 v "$CC $CFLAGS $CPPFLAGS $LDFLAGS -fwhole-program --combine $NOWARN -o $tcfn conftest.c $LIBS $ccpr"
1826                 ;;
1827         lto|normal)
1828                 cm=normal
1829                 v "$CC $CFLAGS $CPPFLAGS $NOWARN -c conftest.c" || fv=0
1830                 test $fv = 0 || v "$CC $CFLAGS $LDFLAGS -o $tcfn conftest.o $LIBS $ccpr"
1831                 ;;
1832         esac
1833         test -f $tcfn || fv=0
1834         ac_testdone
1835         test $fv = 1 || exit 1
1836 fi
1837
1838 #
1839 # Environment: errors and signals
1840 #
1841 test x"NetBSD" = x"$TARGET_OS" && $e Ignore the compatibility warning.
1842
1843 ac_testn sys_errlist '' "the sys_errlist[] array and sys_nerr" <<-'EOF'
1844         extern const int sys_nerr;
1845         extern const char * const sys_errlist[];
1846         extern int isatty(int);
1847         int main(void) { return (*sys_errlist[sys_nerr - 1] + isatty(0)); }
1848 EOF
1849 ac_testn _sys_errlist '!' sys_errlist 0 "the _sys_errlist[] array and _sys_nerr" <<-'EOF'
1850         extern const int _sys_nerr;
1851         extern const char * const _sys_errlist[];
1852         extern int isatty(int);
1853         int main(void) { return (*_sys_errlist[_sys_nerr - 1] + isatty(0)); }
1854 EOF
1855 if test 1 = "$HAVE__SYS_ERRLIST"; then
1856         add_cppflags -Dsys_nerr=_sys_nerr
1857         add_cppflags -Dsys_errlist=_sys_errlist
1858         HAVE_SYS_ERRLIST=1
1859 fi
1860 ac_cppflags SYS_ERRLIST
1861
1862 for what in name list; do
1863         uwhat=`upper $what`
1864         ac_testn sys_sig$what '' "the sys_sig${what}[] array" <<-EOF
1865                 extern const char * const sys_sig${what}[];
1866                 extern int isatty(int);
1867                 int main(void) { return (sys_sig${what}[0][0] + isatty(0)); }
1868         EOF
1869         ac_testn _sys_sig$what '!' sys_sig$what 0 "the _sys_sig${what}[] array" <<-EOF
1870                 extern const char * const _sys_sig${what}[];
1871                 extern int isatty(int);
1872                 int main(void) { return (_sys_sig${what}[0][0] + isatty(0)); }
1873         EOF
1874         eval uwhat_v=\$HAVE__SYS_SIG$uwhat
1875         if test 1 = "$uwhat_v"; then
1876                 add_cppflags -Dsys_sig$what=_sys_sig$what
1877                 eval HAVE_SYS_SIG$uwhat=1
1878         fi
1879         ac_cppflags SYS_SIG$uwhat
1880 done
1881
1882 #
1883 # Environment: library functions
1884 #
1885 ac_test flock <<-'EOF'
1886         #include <sys/types.h>
1887         #include <fcntl.h>
1888         #undef flock
1889         #if HAVE_SYS_FILE_H
1890         #include <sys/file.h>
1891         #endif
1892         int main(void) { return (flock(0, LOCK_EX | LOCK_UN)); }
1893 EOF
1894
1895 ac_test lock_fcntl '!' flock 1 'whether we can lock files with fcntl' <<-'EOF'
1896         #include <fcntl.h>
1897         #undef flock
1898         int main(void) {
1899                 struct flock lks;
1900                 lks.l_type = F_WRLCK | F_UNLCK;
1901                 return (fcntl(0, F_SETLKW, &lks));
1902         }
1903 EOF
1904
1905 ac_test getrusage <<-'EOF'
1906         #define MKSH_INCLUDES_ONLY
1907         #include "sh.h"
1908         int main(void) {
1909                 struct rusage ru;
1910                 return (getrusage(RUSAGE_SELF, &ru) +
1911                     getrusage(RUSAGE_CHILDREN, &ru));
1912         }
1913 EOF
1914
1915 ac_test getsid <<-'EOF'
1916         #include <unistd.h>
1917         int main(void) { return ((int)getsid(0)); }
1918 EOF
1919
1920 ac_test gettimeofday <<-'EOF'
1921         #define MKSH_INCLUDES_ONLY
1922         #include "sh.h"
1923         int main(void) { struct timeval tv; return (gettimeofday(&tv, NULL)); }
1924 EOF
1925
1926 ac_test killpg <<-'EOF'
1927         #include <signal.h>
1928         int main(int ac, char *av[]) { return (av[0][killpg(123, ac)]); }
1929 EOF
1930
1931 ac_test memmove <<-'EOF'
1932         #include <sys/types.h>
1933         #include <stddef.h>
1934         #include <string.h>
1935         #if HAVE_STRINGS_H
1936         #include <strings.h>
1937         #endif
1938         int main(int ac, char *av[]) {
1939                 return (*(int *)(void *)memmove(av[0], av[1], (size_t)ac));
1940         }
1941 EOF
1942
1943 ac_test mknod '' 'if to use mknod(), makedev() and friends' <<-'EOF'
1944         #define MKSH_INCLUDES_ONLY
1945         #include "sh.h"
1946         int main(int ac, char *av[]) {
1947                 dev_t dv;
1948                 dv = makedev((unsigned int)ac, (unsigned int)av[0][0]);
1949                 return (mknod(av[0], (mode_t)0, dv) ? (int)major(dv) :
1950                     (int)minor(dv));
1951         }
1952 EOF
1953
1954 ac_test mmap lock_fcntl 0 'for mmap and munmap' <<-'EOF'
1955         #include <sys/types.h>
1956         #if HAVE_SYS_FILE_H
1957         #include <sys/file.h>
1958         #endif
1959         #if HAVE_SYS_MMAN_H
1960         #include <sys/mman.h>
1961         #endif
1962         #include <stddef.h>
1963         #include <stdlib.h>
1964         int main(void) { return ((void *)mmap(NULL, (size_t)0,
1965             PROT_READ, MAP_PRIVATE, 0, (off_t)0) == (void *)NULL ? 1 :
1966             munmap(NULL, 0)); }
1967 EOF
1968
1969 ac_test nice <<-'EOF'
1970         #include <unistd.h>
1971         int main(void) { return (nice(4)); }
1972 EOF
1973
1974 ac_test revoke <<-'EOF'
1975         #include <sys/types.h>
1976         #if HAVE_LIBUTIL_H
1977         #include <libutil.h>
1978         #endif
1979         #include <unistd.h>
1980         int main(int ac, char *av[]) { return (ac + revoke(av[0])); }
1981 EOF
1982
1983 ac_test setlocale_ctype '' 'setlocale(LC_CTYPE, "")' <<-'EOF'
1984         #include <locale.h>
1985         #include <stddef.h>
1986         int main(void) { return ((int)(size_t)(void *)setlocale(LC_CTYPE, "")); }
1987 EOF
1988
1989 ac_test langinfo_codeset setlocale_ctype 0 'nl_langinfo(CODESET)' <<-'EOF'
1990         #include <langinfo.h>
1991         #include <stddef.h>
1992         int main(void) { return ((int)(size_t)(void *)nl_langinfo(CODESET)); }
1993 EOF
1994
1995 ac_test select <<-'EOF'
1996         #include <sys/types.h>
1997         #if HAVE_BOTH_TIME_H
1998         #include <sys/time.h>
1999         #include <time.h>
2000         #elif HAVE_SYS_TIME_H
2001         #include <sys/time.h>
2002         #elif HAVE_TIME_H
2003         #include <time.h>
2004         #endif
2005         #if HAVE_SYS_BSDTYPES_H
2006         #include <sys/bsdtypes.h>
2007         #endif
2008         #if HAVE_SYS_SELECT_H
2009         #include <sys/select.h>
2010         #endif
2011         #if HAVE_BSTRING_H
2012         #include <bstring.h>
2013         #endif
2014         #include <stddef.h>
2015         #include <stdlib.h>
2016         #include <string.h>
2017         #if HAVE_STRINGS_H
2018         #include <strings.h>
2019         #endif
2020         #include <unistd.h>
2021         int main(void) {
2022                 struct timeval tv = { 1, 200000 };
2023                 fd_set fds; FD_ZERO(&fds); FD_SET(0, &fds);
2024                 return (select(FD_SETSIZE, &fds, NULL, NULL, &tv));
2025         }
2026 EOF
2027
2028 ac_test setresugid <<-'EOF'
2029         #include <sys/types.h>
2030         #include <unistd.h>
2031         int main(void) { return (setresuid(0,0,0) + setresgid(0,0,0)); }
2032 EOF
2033
2034 ac_test setgroups setresugid 0 <<-'EOF'
2035         #include <sys/types.h>
2036         #if HAVE_GRP_H
2037         #include <grp.h>
2038         #endif
2039         #include <unistd.h>
2040         int main(void) { gid_t gid = 0; return (setgroups(0, &gid)); }
2041 EOF
2042
2043 if test x"$et" = x"klibc"; then
2044
2045         ac_testn __rt_sigsuspend '' 'whether klibc uses RT signals' <<-'EOF'
2046                 #define MKSH_INCLUDES_ONLY
2047                 #include "sh.h"
2048                 extern int __rt_sigsuspend(const sigset_t *, size_t);
2049                 int main(void) { return (__rt_sigsuspend(NULL, 0)); }
2050 EOF
2051
2052         # no? damn! legacy crap ahead!
2053
2054         ac_testn __sigsuspend_s '!' __rt_sigsuspend 1 \
2055             'whether sigsuspend is usable (1/2)' <<-'EOF'
2056                 #define MKSH_INCLUDES_ONLY
2057                 #include "sh.h"
2058                 extern int __sigsuspend_s(sigset_t);
2059                 int main(void) { return (__sigsuspend_s(0)); }
2060 EOF
2061         ac_testn __sigsuspend_xxs '!' __sigsuspend_s 1 \
2062             'whether sigsuspend is usable (2/2)' <<-'EOF'
2063                 #define MKSH_INCLUDES_ONLY
2064                 #include "sh.h"
2065                 extern int __sigsuspend_xxs(int, int, sigset_t);
2066                 int main(void) { return (__sigsuspend_xxs(0, 0, 0)); }
2067 EOF
2068
2069         if test "000" = "$HAVE___RT_SIGSUSPEND$HAVE___SIGSUSPEND_S$HAVE___SIGSUSPEND_XXS"; then
2070                 # no usable sigsuspend(), use pause() *ugh*
2071                 add_cppflags -DMKSH_NO_SIGSUSPEND
2072         fi
2073 fi
2074
2075 ac_test strerror '!' sys_errlist 0 <<-'EOF'
2076         extern char *strerror(int);
2077         int main(int ac, char *av[]) { return (*strerror(*av[ac])); }
2078 EOF
2079
2080 ac_test strsignal '!' sys_siglist 0 <<-'EOF'
2081         #include <string.h>
2082         #include <signal.h>
2083         int main(void) { return (strsignal(1)[0]); }
2084 EOF
2085
2086 ac_test strlcpy <<-'EOF'
2087         #include <string.h>
2088         int main(int ac, char *av[]) { return (strlcpy(*av, av[1],
2089             (size_t)ac)); }
2090 EOF
2091
2092 #
2093 # check headers for declarations
2094 #
2095 ac_test flock_decl flock 1 'for declaration of flock()' <<-'EOF'
2096         #define MKSH_INCLUDES_ONLY
2097         #include "sh.h"
2098         #if HAVE_SYS_FILE_H
2099         #include <sys/file.h>
2100         #endif
2101         int main(void) { return ((flock)(0, 0)); }
2102 EOF
2103 ac_test revoke_decl revoke 1 'for declaration of revoke()' <<-'EOF'
2104         #define MKSH_INCLUDES_ONLY
2105         #include "sh.h"
2106         int main(void) { return ((revoke)("")); }
2107 EOF
2108 ac_test sys_errlist_decl sys_errlist 0 "for declaration of sys_errlist[] and sys_nerr" <<-'EOF'
2109         #define MKSH_INCLUDES_ONLY
2110         #include "sh.h"
2111         int main(void) { return (*sys_errlist[sys_nerr - 1] + isatty(0)); }
2112 EOF
2113 ac_test sys_siglist_decl sys_siglist 0 'for declaration of sys_siglist[]' <<-'EOF'
2114         #define MKSH_INCLUDES_ONLY
2115         #include "sh.h"
2116         int main(void) { return (sys_siglist[0][0] + isatty(0)); }
2117 EOF
2118
2119 #
2120 # other checks
2121 #
2122 fd='if to use persistent history'
2123 ac_cache PERSISTENT_HISTORY || case $HAVE_MMAP$HAVE_FLOCK$HAVE_LOCK_FCNTL in
2124 11*|101) fv=1 ;;
2125 esac
2126 test 1 = $fv || check_categories="$check_categories no-histfile"
2127 ac_testdone
2128 ac_cppflags
2129
2130 save_CFLAGS=$CFLAGS
2131 ac_testn compile_time_asserts_$$ '' 'whether compile-time assertions pass' <<-'EOF'
2132         #define MKSH_INCLUDES_ONLY
2133         #include "sh.h"
2134         #ifndef CHAR_BIT
2135         #define CHAR_BIT 8      /* defuse this test on really legacy systems */
2136         #endif
2137         struct ctasserts {
2138         #define cta(name, assertion) char name[(assertion) ? 1 : -1]
2139 /* this one should be defined by the standard */
2140 cta(char_is_1_char, (sizeof(char) == 1) && (sizeof(signed char) == 1) &&
2141     (sizeof(unsigned char) == 1));
2142 cta(char_is_8_bits, ((CHAR_BIT) == 8) && ((int)(unsigned char)0xFF == 0xFF) &&
2143     ((int)(unsigned char)0x100 == 0) && ((int)(unsigned char)(int)-1 == 0xFF));
2144 /* the next assertion is probably not really needed */
2145 cta(short_is_2_char, sizeof(short) == 2);
2146 cta(short_size_no_matter_of_signedness, sizeof(short) == sizeof(unsigned short));
2147 /* the next assertion is probably not really needed */
2148 cta(int_is_4_char, sizeof(int) == 4);
2149 cta(int_size_no_matter_of_signedness, sizeof(int) == sizeof(unsigned int));
2150
2151 cta(long_ge_int, sizeof(long) >= sizeof(int));
2152 cta(long_size_no_matter_of_signedness, sizeof(long) == sizeof(unsigned long));
2153
2154 #ifndef MKSH_LEGACY_MODE
2155 /* the next assertion is probably not really needed */
2156 cta(ari_is_4_char, sizeof(mksh_ari_t) == 4);
2157 /* but this is */
2158 cta(ari_has_31_bit, 0 < (mksh_ari_t)(((((mksh_ari_t)1 << 15) << 15) - 1) * 2 + 1));
2159 /* the next assertion is probably not really needed */
2160 cta(uari_is_4_char, sizeof(mksh_uari_t) == 4);
2161 /* but the next three are; we REQUIRE unsigned integer wraparound */
2162 cta(uari_has_31_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 2 + 1));
2163 cta(uari_has_32_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3));
2164 cta(uari_wrap_32_bit,
2165     (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3) >
2166     (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 4));
2167 #define NUM 22
2168 #else
2169 #define NUM 16
2170 #endif
2171 /* these are always required */
2172 cta(ari_is_signed, (mksh_ari_t)-1 < (mksh_ari_t)0);
2173 cta(uari_is_unsigned, (mksh_uari_t)-1 > (mksh_uari_t)0);
2174 /* we require these to have the precisely same size and assume 2s complement */
2175 cta(ari_size_no_matter_of_signedness, sizeof(mksh_ari_t) == sizeof(mksh_uari_t));
2176
2177 cta(sizet_size_no_matter_of_signedness, sizeof(ssize_t) == sizeof(size_t));
2178 cta(sizet_voidptr_same_size, sizeof(size_t) == sizeof(void *));
2179 cta(sizet_funcptr_same_size, sizeof(size_t) == sizeof(void (*)(void)));
2180 /* our formatting routines assume this */
2181 cta(ptr_fits_in_long, sizeof(size_t) <= sizeof(long));
2182 cta(ari_fits_in_long, sizeof(mksh_ari_t) <= sizeof(long));
2183 /* for struct alignment people */
2184                 char padding[64 - NUM];
2185         };
2186 char ctasserts_dblcheck[sizeof(struct ctasserts) == 64 ? 1 : -1];
2187         int main(void) { return (sizeof(ctasserts_dblcheck) + isatty(0)); }
2188 EOF
2189 CFLAGS=$save_CFLAGS
2190 eval test 1 = \$HAVE_COMPILE_TIME_ASSERTS_$$ || exit 1
2191
2192 #
2193 # extra checks for legacy mksh
2194 #
2195 if test $legacy = 1; then
2196         ac_test long_32bit '' 'whether long is 32 bit wide' <<-'EOF'
2197                 #define MKSH_INCLUDES_ONLY
2198                 #include "sh.h"
2199                 #ifndef CHAR_BIT
2200                 #define CHAR_BIT 0
2201                 #endif
2202                 struct ctasserts {
2203                 #define cta(name, assertion) char name[(assertion) ? 1 : -1]
2204                         cta(char_is_8_bits, (CHAR_BIT) == 8);
2205                         cta(long_is_32_bits, sizeof(long) == 4);
2206                 };
2207                 int main(void) { return (sizeof(struct ctasserts)); }
2208 EOF
2209
2210         ac_test long_64bit '!' long_32bit 0 'whether long is 64 bit wide' <<-'EOF'
2211                 #define MKSH_INCLUDES_ONLY
2212                 #include "sh.h"
2213                 #ifndef CHAR_BIT
2214                 #define CHAR_BIT 0
2215                 #endif
2216                 struct ctasserts {
2217                 #define cta(name, assertion) char name[(assertion) ? 1 : -1]
2218                         cta(char_is_8_bits, (CHAR_BIT) == 8);
2219                         cta(long_is_64_bits, sizeof(long) == 8);
2220                 };
2221                 int main(void) { return (sizeof(struct ctasserts)); }
2222 EOF
2223
2224         case $HAVE_LONG_32BIT$HAVE_LONG_64BIT in
2225         10) check_categories="$check_categories int:32" ;;
2226         01) check_categories="$check_categories int:64" ;;
2227         *) check_categories="$check_categories int:u" ;;
2228         esac
2229 fi
2230
2231 #
2232 # Compiler: Praeprocessor (only if needed)
2233 #
2234 test 0 = $HAVE_SYS_SIGNAME && if ac_testinit cpp_dd '' \
2235     'checking if the C Preprocessor supports -dD'; then
2236         echo '#define foo bar' >conftest.c
2237         vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN -dD conftest.c >x"
2238         grep '#define foo bar' x >/dev/null 2>&1 && fv=1
2239         rmf conftest.c x vv.out
2240         ac_testdone
2241 fi
2242
2243 #
2244 # End of mirtoconf checks
2245 #
2246 $e ... done.
2247
2248 # Some operating systems have ancient versions of ed(1) writing
2249 # the character count to standard output; cope for that
2250 echo wq >x
2251 ed x <x 2>/dev/null | grep 3 >/dev/null 2>&1 && \
2252     check_categories="$check_categories $oldish_ed"
2253 rmf x vv.out
2254
2255 if test 0 = $HAVE_SYS_SIGNAME; then
2256         if test 1 = $HAVE_CPP_DD; then
2257                 $e Generating list of signal names...
2258         else
2259                 $e No list of signal names available via cpp. Falling back...
2260         fi
2261         sigseenone=:
2262         sigseentwo=:
2263         echo '#include <signal.h>
2264 #if defined(NSIG_MAX)
2265 #define cfg_NSIG NSIG_MAX
2266 #elif defined(NSIG)
2267 #define cfg_NSIG NSIG
2268 #elif defined(_NSIG)
2269 #define cfg_NSIG _NSIG
2270 #elif defined(SIGMAX)
2271 #define cfg_NSIG (SIGMAX + 1)
2272 #elif defined(_SIGMAX)
2273 #define cfg_NSIG (_SIGMAX + 1)
2274 #else
2275 /*XXX better error out, see sh.h */
2276 #define cfg_NSIG 64
2277 #endif
2278 int
2279 mksh_cfg= cfg_NSIG
2280 ;' >conftest.c
2281         # GNU sed 2.03 segfaults when optimising this to sed -n
2282         NSIG=`vq "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c" | \
2283             grep -v '^#' | \
2284             sed '/mksh_cfg.*= *$/{
2285                 N
2286                 s/\n/ /
2287                 }' | \
2288             grep '^ *mksh_cfg *=' | \
2289             sed 's/^ *mksh_cfg *=[       ]*\([()0-9x+-][()0-9x+  -]*\).*$/\1/'`
2290         case $NSIG in
2291         *mksh_cfg*) $e "Error: NSIG='$NSIG'"; NSIG=0 ;;
2292         *[\ \(\)+-]*) NSIG=`"$AWK" "BEGIN { print $NSIG }" </dev/null` ;;
2293         esac
2294         printf=printf
2295         (printf hallo) >/dev/null 2>&1 || printf=echo
2296         test $printf = echo || test "`printf %d 42`" = 42 || printf=echo
2297         test $printf = echo || NSIG=`printf %d "$NSIG" 2>/dev/null`
2298         $printf "NSIG=$NSIG ... "
2299         sigs="ABRT FPE ILL INT SEGV TERM ALRM BUS CHLD CONT HUP KILL PIPE QUIT"
2300         sigs="$sigs STOP TSTP TTIN TTOU USR1 USR2 POLL PROF SYS TRAP URG VTALRM"
2301         sigs="$sigs XCPU XFSZ INFO WINCH EMT IO DIL LOST PWR SAK CLD IOT STKFLT"
2302         sigs="$sigs ABND DCE DUMP IOERR TRACE DANGER THCONT THSTOP RESV UNUSED"
2303         test 1 = $HAVE_CPP_DD && test $NSIG -gt 1 && sigs="$sigs "`vq \
2304             "$CPP $CFLAGS $CPPFLAGS $NOWARN -dD conftest.c" | \
2305             grep '[      ]SIG[A-Z0-9][A-Z0-9]*[  ]' | \
2306             sed 's/^.*[  ]SIG\([A-Z0-9][A-Z0-9]*\)[      ].*$/\1/' | sort`
2307         test $NSIG -gt 1 || sigs=
2308         for name in $sigs; do
2309                 case $sigseenone in
2310                 *:$name:*) continue ;;
2311                 esac
2312                 sigseenone=$sigseenone$name:
2313                 echo '#include <signal.h>' >conftest.c
2314                 echo int >>conftest.c
2315                 echo mksh_cfg= SIG$name >>conftest.c
2316                 echo ';' >>conftest.c
2317                 # GNU sed 2.03 croaks on optimising this, too
2318                 vq "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c" | \
2319                     grep -v '^#' | \
2320                     sed '/mksh_cfg.*= *$/{
2321                         N
2322                         s/\n/ /
2323                         }' | \
2324                     grep '^ *mksh_cfg *=' | \
2325                     sed 's/^ *mksh_cfg *=[       ]*\([0-9][0-9x]*\).*$/:\1 '$name/
2326         done | sed -n '/^:[^ ]/s/^://p' | while read nr name; do
2327                 test $printf = echo || nr=`printf %d "$nr" 2>/dev/null`
2328                 test $nr -gt 0 && test $nr -lt $NSIG || continue
2329                 case $sigseentwo in
2330                 *:$nr:*) ;;
2331                 *)      echo "          { \"$name\", $nr },"
2332                         sigseentwo=$sigseentwo$nr:
2333                         $printf "$name=$nr " >&2
2334                         ;;
2335                 esac
2336         done 2>&1 >signames.inc
2337         rmf conftest.c
2338         $e done.
2339 fi
2340
2341 addsrcs '!' HAVE_STRLCPY strlcpy.c
2342 addsrcs USE_PRINTF_BUILTIN printf.c
2343 test 1 = "$USE_PRINTF_BUILTIN" && add_cppflags -DMKSH_PRINTF_BUILTIN
2344 test 1 = "$HAVE_CAN_VERB" && CFLAGS="$CFLAGS -verbose"
2345 add_cppflags -DMKSH_BUILD_R=530
2346
2347 $e $bi$me: Finished configuration testing, now producing output.$ao
2348
2349 files=
2350 objs=
2351 sp=
2352 case $tcfn in
2353 a.exe|conftest.exe)
2354         mkshexe=$tfn.exe
2355         add_cppflags -DMKSH_EXE_EXT
2356         ;;
2357 *)
2358         mkshexe=$tfn
2359         ;;
2360 esac
2361 case $curdir in
2362 *\ *)   mkshshebang="#!./$mkshexe" ;;
2363 *)      mkshshebang="#!$curdir/$mkshexe" ;;
2364 esac
2365 cat >test.sh <<-EOF
2366         $mkshshebang
2367         LC_ALL=C PATH='$PATH'; export LC_ALL PATH
2368         test -n "\$KSH_VERSION" || exit 1
2369         set -A check_categories -- $check_categories
2370         pflag='$curdir/$mkshexe'
2371         sflag='$srcdir/check.t'
2372         usee=0 Pflag=0 Sflag=0 uset=0 vflag=1 xflag=0
2373         while getopts "C:e:fPp:QSs:t:v" ch; do case \$ch {
2374         (C)     check_categories[\${#check_categories[*]}]=\$OPTARG ;;
2375         (e)     usee=1; eflag=\$OPTARG ;;
2376         (f)     check_categories[\${#check_categories[*]}]=fastbox ;;
2377         (P)     Pflag=1 ;;
2378         (+P)    Pflag=0 ;;
2379         (p)     pflag=\$OPTARG ;;
2380         (Q)     vflag=0 ;;
2381         (+Q)    vflag=1 ;;
2382         (S)     Sflag=1 ;;
2383         (+S)    Sflag=0 ;;
2384         (s)     sflag=\$OPTARG ;;
2385         (t)     uset=1; tflag=\$OPTARG ;;
2386         (v)     vflag=1 ;;
2387         (+v)    vflag=0 ;;
2388         (*)     xflag=1 ;;
2389         }
2390         done
2391         shift \$((OPTIND - 1))
2392         set -A args -- '$srcdir/check.pl' -p "\$pflag"
2393         x=
2394         for y in "\${check_categories[@]}"; do
2395                 x=\$x,\$y
2396         done
2397         if [[ -n \$x ]]; then
2398                 args[\${#args[*]}]=-C
2399                 args[\${#args[*]}]=\${x#,}
2400         fi
2401         if (( usee )); then
2402                 args[\${#args[*]}]=-e
2403                 args[\${#args[*]}]=\$eflag
2404         fi
2405         (( Pflag )) && args[\${#args[*]}]=-P
2406         if (( uset )); then
2407                 args[\${#args[*]}]=-t
2408                 args[\${#args[*]}]=\$tflag
2409         fi
2410         (( vflag )) && args[\${#args[*]}]=-v
2411         (( xflag )) && args[\${#args[*]}]=-x    # force usage by synerr
2412         if [[ -n \$TMPDIR && -d \$TMPDIR/. ]]; then
2413                 args[\${#args[*]}]=-T
2414                 args[\${#args[*]}]=\$TMPDIR
2415         fi
2416         print Testing mksh for conformance:
2417         grep -F -e Mir''OS: -e MIRBSD "\$sflag"
2418         print "This shell is actually:\\n\\t\$KSH_VERSION"
2419         print 'test.sh built for mksh $dstversion'
2420         cstr='\$os = defined \$^O ? \$^O : "unknown";'
2421         cstr="\$cstr"'print \$os . ", Perl version " . \$];'
2422         for perli in \$PERL perl5 perl no; do
2423                 if [[ \$perli = no ]]; then
2424                         print Cannot find a working Perl interpreter, aborting.
2425                         exit 1
2426                 fi
2427                 print "Trying Perl interpreter '\$perli'..."
2428                 perlos=\$(\$perli -e "\$cstr")
2429                 rv=\$?
2430                 print "Errorlevel \$rv, running on '\$perlos'"
2431                 if (( rv )); then
2432                         print "=> not using"
2433                         continue
2434                 fi
2435                 if [[ -n \$perlos ]]; then
2436                         print "=> using it"
2437                         break
2438                 fi
2439         done
2440         (( Sflag )) || echo + \$perli "\${args[@]}" -s "\$sflag" "\$@"
2441         (( Sflag )) || exec \$perli "\${args[@]}" -s "\$sflag" "\$@"$tsts
2442         # use of the -S option for check.t split into multiple chunks
2443         rv=0
2444         for s in "\$sflag".*; do
2445                 echo + \$perli "\${args[@]}" -s "\$s" "\$@"
2446                 \$perli "\${args[@]}" -s "\$s" "\$@"$tsts
2447                 rc=\$?
2448                 (( rv = rv ? rv : rc ))
2449         done
2450         exit \$rv
2451 EOF
2452 chmod 755 test.sh
2453 case $cm in
2454 dragonegg)
2455         emitbc="-S -flto"
2456         ;;
2457 llvm)
2458         emitbc="-emit-llvm -c"
2459         ;;
2460 *)
2461         emitbc=-c
2462         ;;
2463 esac
2464 echo ": # work around NeXTstep bug" >Rebuild.sh
2465 cd "$srcdir"
2466 optfiles=`echo *.opt`
2467 cd "$curdir"
2468 for file in $optfiles; do
2469         echo "echo + Running genopt on '$file'..."
2470         echo "(srcfile='$srcdir/$file'; BUILDSH_RUN_GENOPT=1; . '$srcdir/Build.sh')"
2471 done >>Rebuild.sh
2472 echo set -x >>Rebuild.sh
2473 for file in $SRCS; do
2474         op=`echo x"$file" | sed 's/^x\(.*\)\.c$/\1./'`
2475         test -f $file || file=$srcdir/$file
2476         files="$files$sp$file"
2477         sp=' '
2478         echo "$CC $CFLAGS $CPPFLAGS $emitbc $file || exit 1" >>Rebuild.sh
2479         if test $cm = dragonegg; then
2480                 echo "mv ${op}s ${op}ll" >>Rebuild.sh
2481                 echo "llvm-as ${op}ll || exit 1" >>Rebuild.sh
2482                 objs="$objs$sp${op}bc"
2483         else
2484                 objs="$objs$sp${op}o"
2485         fi
2486 done
2487 case $cm in
2488 dragonegg|llvm)
2489         echo "rm -f $tfn.s" >>Rebuild.sh
2490         echo "llvm-link -o - $objs | opt $optflags | llc -o $tfn.s" >>Rebuild.sh
2491         lobjs=$tfn.s
2492         ;;
2493 *)
2494         lobjs=$objs
2495         ;;
2496 esac
2497 echo tcfn=$mkshexe >>Rebuild.sh
2498 echo "$CC $CFLAGS $LDFLAGS -o \$tcfn $lobjs $LIBS $ccpr" >>Rebuild.sh
2499 echo "test -f \$tcfn || exit 1; $SIZE \$tcfn" >>Rebuild.sh
2500 if test $cm = makefile; then
2501         extras='emacsfn.h exprtok.h rlimits.opt sh.h sh_flags.opt var_spec.h'
2502         test 0 = $HAVE_SYS_SIGNAME && extras="$extras signames.inc"
2503         gens= genq=
2504         for file in $optfiles; do
2505                 genf=`basename "$file" | sed 's/.opt$/.gen/'`
2506                 gens="$gens $genf"
2507                 genq="$genq$nl$genf: $srcdir/Build.sh $srcdir/$file
2508                         srcfile=$srcdir/$file; BUILDSH_RUN_GENOPT=1; . $srcdir/Build.sh"
2509         done
2510         cat >Makefrag.inc <<EOF
2511 # Makefile fragment for building mksh $dstversion
2512
2513 PROG=           $mkshexe
2514 MAN=            mksh.1
2515 SRCS=           $SRCS
2516 SRCS_FP=        $files
2517 OBJS_BP=        $objs
2518 INDSRCS=        $extras
2519 NONSRCS_INST=   dot.mkshrc \$(MAN)
2520 NONSRCS_NOINST= Build.sh Makefile Rebuild.sh check.pl check.t test.sh
2521 CC=             $CC
2522 CFLAGS=         $CFLAGS
2523 CPPFLAGS=       $CPPFLAGS
2524 LDFLAGS=        $LDFLAGS
2525 LIBS=           $LIBS
2526
2527 .depend \$(OBJS_BP):$gens$genq
2528
2529 # not BSD make only:
2530 #VPATH=         $srcdir
2531 #all: \$(PROG)
2532 #\$(PROG): \$(OBJS_BP)
2533 #       \$(CC) \$(CFLAGS) \$(LDFLAGS) -o \$@ \$(OBJS_BP) \$(LIBS)
2534 #\$(OBJS_BP): \$(SRCS_FP) \$(NONSRCS)
2535 #.c.o:
2536 #       \$(CC) \$(CFLAGS) \$(CPPFLAGS) -c \$<
2537
2538 # for all make variants:
2539 #REGRESS_FLAGS= -f
2540 #regress:
2541 #       ./test.sh \$(REGRESS_FLAGS)
2542 check_categories=$check_categories
2543
2544 # for BSD make only:
2545 #.PATH: $srcdir
2546 #.include <bsd.prog.mk>
2547 EOF
2548         $e
2549         $e Generated Makefrag.inc successfully.
2550         exit 0
2551 fi
2552 for file in $optfiles; do
2553         $e "+ Running genopt on '$file'..."
2554         do_genopt "$srcdir/$file" || exit 1
2555 done
2556 if test $cm = combine; then
2557         objs="-o $mkshexe"
2558         for file in $SRCS; do
2559                 test -f $file || file=$srcdir/$file
2560                 objs="$objs $file"
2561         done
2562         emitbc="-fwhole-program --combine"
2563         v "$CC $CFLAGS $CPPFLAGS $LDFLAGS $emitbc $objs $LIBS $ccpr"
2564 elif test 1 = $pm; then
2565         for file in $SRCS; do
2566                 test -f $file || file=$srcdir/$file
2567                 v "$CC $CFLAGS $CPPFLAGS $emitbc $file" &
2568         done
2569         wait
2570 else
2571         for file in $SRCS; do
2572                 test $cm = dragonegg && \
2573                     op=`echo x"$file" | sed 's/^x\(.*\)\.c$/\1./'`
2574                 test -f $file || file=$srcdir/$file
2575                 v "$CC $CFLAGS $CPPFLAGS $emitbc $file" || exit 1
2576                 if test $cm = dragonegg; then
2577                         v "mv ${op}s ${op}ll"
2578                         v "llvm-as ${op}ll" || exit 1
2579                 fi
2580         done
2581 fi
2582 case $cm in
2583 dragonegg|llvm)
2584         rmf $tfn.s
2585         v "llvm-link -o - $objs | opt $optflags | llc -o $tfn.s"
2586         ;;
2587 esac
2588 tcfn=$mkshexe
2589 test $cm = combine || v "$CC $CFLAGS $LDFLAGS -o $tcfn $lobjs $LIBS $ccpr"
2590 test -f $tcfn || exit 1
2591 test 1 = $r || v "$NROFF -mdoc <'$srcdir/mksh.1' >$tfn.cat1" || \
2592     rmf $tfn.cat1
2593 test 0 = $eq && v $SIZE $tcfn
2594 i=install
2595 test -f /usr/ucb/$i && i=/usr/ucb/$i
2596 test 1 = $eq && e=:
2597 $e
2598 $e Installing the shell:
2599 $e "# $i -c -s -o root -g bin -m 555 $tfn /bin/$tfn"
2600 if test $legacy = 0; then
2601         $e "# grep -x /bin/$tfn /etc/shells >/dev/null || echo /bin/$tfn >>/etc/shells"
2602         $e "# $i -c -o root -g bin -m 444 dot.mkshrc /usr/share/doc/mksh/examples/"
2603 fi
2604 $e
2605 $e Installing the manual:
2606 if test -f $tfn.cat1; then
2607         $e "# $i -c -o root -g bin -m 444 $tfn.cat1" \
2608             "/usr/share/man/cat1/$tfn.0"
2609         $e or
2610 fi
2611 $e "# $i -c -o root -g bin -m 444 $tfn.1 /usr/share/man/man1/$tfn.1"
2612 $e
2613 $e Run the regression test suite: ./test.sh
2614 $e Please also read the sample file dot.mkshrc and the fine manual.
2615 exit 0
2616
2617 : <<'EOD'
2618
2619 === Environment used ===
2620
2621 ==== build environment ====
2622 AWK                             default: awk
2623 CC                              default: cc
2624 CFLAGS                          if empty, defaults to -xO2 or +O2
2625                                 or -O3 -qstrict or -O2, per compiler
2626 CPPFLAGS                        default empty
2627 LDFLAGS                         default empty; added before sources
2628 LDSTATIC                        set this to '-static'; default unset
2629 LIBS                            default empty; added after sources
2630                                 [Interix] default: -lcrypt (XXX still needed?)
2631 NOWARN                          -Wno-error or similar
2632 NROFF                           default: nroff
2633 TARGET_OS                       default: $(uname -s || uname)
2634 TARGET_OSREV                    [QNX] default: $(uname -r)
2635
2636 ==== feature selectors ====
2637 USE_PRINTF_BUILTIN              1 to include (unsupported) printf(1) as builtin
2638 ===== general format =====
2639 HAVE_STRLEN                     ac_test
2640 HAVE_STRING_H                   ac_header
2641 HAVE_CAN_FSTACKPROTECTORALL     ac_flags
2642
2643 ==== cpp definitions ====
2644 DEBUG                           dont use in production, wants gcc, implies:
2645 DEBUG_LEAKS                     enable freeing resources before exiting
2646 MKSHRC_PATH                     "~/.mkshrc" (do not change)
2647 MKSH_A4PB                       force use of arc4random_pushb
2648 MKSH_ASSUME_UTF8                (0=disabled, 1=enabled; default: unset)
2649 MKSH_BINSHPOSIX                 if */sh or */-sh, enable set -o posix
2650 MKSH_BINSHREDUCED               if */sh or */-sh, enable set -o sh
2651 MKSH_CLS_STRING                 "\033[;H\033[J"
2652 MKSH_DEFAULT_EXECSHELL          "/bin/sh" (do not change)
2653 MKSH_DEFAULT_PROFILEDIR         "/etc" (do not change)
2654 MKSH_DEFAULT_TMPDIR             "/tmp" (do not change)
2655 MKSH_DISABLE_DEPRECATED         disable code paths scheduled for later removal
2656 MKSH_DISABLE_EXPERIMENTAL       disable code not yet comfy for (LTS) snapshots
2657 MKSH_DISABLE_TTY_WARNING        shut up warning about ctty if OS cant be fixed
2658 MKSH_DONT_EMIT_IDSTRING         omit RCS IDs from binary
2659 MKSH_MIDNIGHTBSD01ASH_COMPAT    set -o sh: additional compatibility quirk
2660 MKSH_NOPROSPECTOFWORK           disable jobs, co-processes, etc. (do not use)
2661 MKSH_NOPWNAM                    skip PAM calls, for -static on glibc or Solaris
2662 MKSH_NO_CMDLINE_EDITING         disable command line editing code entirely
2663 MKSH_NO_DEPRECATED_WARNING      omit warning when deprecated stuff is run
2664 MKSH_NO_LIMITS                  omit ulimit code
2665 MKSH_NO_SIGSETJMP               define if sigsetjmp is broken or not available
2666 MKSH_NO_SIGSUSPEND              use sigprocmask+pause instead of sigsuspend
2667 MKSH_SMALL                      omit some code, optimise hard for size (slower)
2668 MKSH_SMALL_BUT_FAST             disable some hard-for-size optim. (modern sys.)
2669 MKSH_S_NOVI=1                   disable Vi editing mode (default if MKSH_SMALL)
2670 MKSH_TYPEDEF_SIG_ATOMIC_T       define to e.g. 'int' if sig_atomic_t is missing
2671 MKSH_TYPEDEF_SSIZE_T            define to e.g. 'long' if your OS has no ssize_t
2672 MKSH_UNEMPLOYED                 disable job control (but not jobs/co-processes)
2673
2674 === generic installation instructions ===
2675
2676 Set CC and possibly CFLAGS, CPPFLAGS, LDFLAGS, LIBS. If cross-compiling,
2677 also set TARGET_OS. To disable tests, set e.g. HAVE_STRLCPY=0; to enable
2678 them, set to a value other than 0 or 1. Ensure /bin/ed is installed. For
2679 MKSH_SMALL but with Vi mode, add -DMKSH_S_NOVI=0 to CPPFLAGS as well.
2680
2681 Normally, the following command is what you want to run, then:
2682 $ (sh Build.sh -r -c lto && ./test.sh -f) 2>&1 | tee log
2683
2684 Copy dot.mkshrc to /etc/skel/.mkshrc; install mksh into $prefix/bin; or
2685 /bin; install the manpage, if omitting the -r flag a catmanpage is made
2686 using $NROFF. Consider using a forward script as /etc/skel/.mkshrc like
2687 http://anonscm.debian.org/cgit/collab-maint/mksh.git/plain/debian/.mkshrc
2688 and put dot.mkshrc as /etc/mkshrc so users need not keep up their HOME.
2689
2690 You may also want to install the lksh binary (also as /bin/sh) built by:
2691 $ CPPFLAGS="$CPPFLAGS -DMKSH_BINSHPOSIX" sh Build.sh -L -r -c lto
2692
2693 EOD