src/Build.sh

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