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