src/Build.sh

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