1#!/bin/sh 2srcversion='$MirOS: src/bin/mksh/Build.sh,v 1.622 2013/02/19 18:45:15 tg Exp $' 3#- 4# Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 5# 2011, 2012, 2013 6# Thorsten Glaser <tg@mirbsd.org> 7# 8# Provided that these terms and disclaimer and all copyright notices 9# are retained or reproduced in an accompanying document, permission 10# is granted to deal in this work without restriction, including un- 11# limited rights to use, publicly perform, distribute, sell, modify, 12# merge, give away, or sublicence. 13# 14# This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to 15# the utmost extent permitted by applicable law, neither express nor 16# implied; without malicious intent or gross negligence. In no event 17# may a licensor, author or contributor be held liable for indirect, 18# direct, other damage, loss, or other issues arising in any way out 19# of dealing in the work, even if advised of the possibility of such 20# damage or existence of a defect, except proven that it results out 21# of said person's immediate fault when using the work as intended. 22#- 23# People analysing the output must whitelist conftest.c for any kind 24# of compiler warning checks (mirtoconf is by design not quiet). 25# 26# Used environment documentation is at the end of this file. 27 28LC_ALL=C 29export LC_ALL 30 31case $ZSH_VERSION:$VERSION in 32:zsh*) ZSH_VERSION=2 ;; 33esac 34 35if test -n "${ZSH_VERSION+x}" && (emulate sh) >/dev/null 2>&1; then 36 emulate sh 37 NULLCMD=: 38fi 39 40if 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 44fi 45 46v() { 47 $e "$*" 48 eval "$@" 49} 50 51vv() { 52 _c=$1 53 shift 54 $e "\$ $*" 2>&1 55 eval "$@" >vv.out 2>&1 56 sed "s^${_c} " <vv.out 57} 58 59vq() { 60 eval "$@" 61} 62 63rmf() { 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 72allu=QWERTYUIOPASDFGHJKLZXCVBNM 73alll=qwertyuiopasdfghjklzxcvbnm 74alln=0123456789 75alls=______________________________________________________________ 76nl=' 77' 78tcfn=no 79bi= 80ui= 81ao= 82fx= 83me=`basename "$0"` 84orig_CFLAGS=$CFLAGS 85phase=x 86oldish_ed=stdout-ed,no-stderr-ed 87 88if test -t 1; then 89 bi='[1m' 90 ui='[4m' 91 ao='[0m' 92fi 93 94upper() { 95 echo :"$@" | sed 's/^://' | tr $alll $allu 96} 97 98# clean up after ac_testrun() 99ac_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 108ac_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 124ac_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 155ac_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} 183ac_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 190ac_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 ); } 201EOF 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 209add_cppflags() { 210 CPPFLAGS="$CPPFLAGS $*" 211} 212 213ac_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 220ac_test() { 221 ac_testn "$@" 222 ac_cppflags 223} 224 225# ac_flags [-] add varname cflags [text] [ldflags] 226ac_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 ...] 261ac_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 296addsrcs() { 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 324curdir=`pwd` srcdir=`dirname "$0" 2>/dev/null` check_categories= 325test -n "$srcdir" || srcdir=. # in case dirname does not exist 326dstversion=`sed -n '/define MKSH_VERSION/s/^.*"\([^"]*\)".*$/\1/p' $srcdir/sh.h` 327add_cppflags -DMKSH_BUILDSH 328 329e=echo 330r=0 331eq=0 332pm=0 333cm=normal 334optflags=-std-compile-opts 335last= 336tfn= 337legacy=0 338 339for i 340do 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 407done 408if test -n "$last"; then 409 echo "$me: Option -'$last' not followed by argument!" >&2 410 exit 1 411fi 412 413test -z "$tfn" && if test $legacy = 0; then 414 tfn=mksh 415else 416 tfn=lksh 417fi 418if test -d $tfn || test -d $tfn.exe; then 419 echo "$me: Error: ./$tfn is a directory!" >&2 420 exit 1 421fi 422rmf 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 425SRCS="lalloc.c eval.c exec.c expr.c funcs.c histrap.c jobs.c" 426SRCS="$SRCS lex.c main.c misc.c shf.c syn.c tree.c var.c" 427 428if test $legacy = 0; then 429 SRCS="$SRCS edit.c" 430 check_categories="$check_categories shell:legacy-no int:32" 431else 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 436fi 437 438if test x"$srcdir" = x"."; then 439 CPPFLAGS="-I. $CPPFLAGS" 440else 441 CPPFLAGS="-I. -I'$srcdir' $CPPFLAGS" 442fi 443test -n "$LDSTATIC" && if test -n "$LDFLAGS"; then 444 LDFLAGS="$LDFLAGS $LDSTATIC" 445else 446 LDFLAGS=$LDSTATIC 447fi 448 449if 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 452fi 453if test -z "$TARGET_OS"; then 454 echo "$me: Set TARGET_OS, your uname is broken!" >&2 455 exit 1 456fi 457oswarn= 458ccpc=-Wc, 459ccpl=-Wl, 460tsts= 461ccpr='|| 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 464if test x"$TARGET_OS" = x"Android"; then 465 check_categories="$check_categories android" 466 TARGET_OS=Linux 467fi 468 469# Evil OS 470if test x"$TARGET_OS" = x"Minix"; then 471 echo >&2 " 472WARNING: additional checks before running Build.sh required! 473You can avoid these by calling Build.sh correctly, see below. 474" 475 cat >conftest.c <<'EOF' 476#include <sys/types.h> 477const char * 478#ifdef _NETBSD_SOURCE 479ct="Ninix3" 480#else 481ct="Minix3" 482#endif 483; 484EOF 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 " 493Warning: you set TARGET_OS to $TARGET_OS but that is ambiguous. 494Please set it to either Minix3 or Ninix3, whereas the latter is 495all versions of Minix with even partial NetBSD(R) userland. The 496value 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 " 503Warning: you set TARGET_OS to $TARGET_OS but that is ambiguous. 504Please set it to either Minix3 or Ninix3, whereas the latter is 505all versions of Minix with even partial NetBSD(R) userland. The 506proper value couldn't be determined, continue at your own risk. 507" 508 ;; 509 esac 510fi 511 512# Configuration depending on OS revision, on OSes that need them 513case $TARGET_OS in 514NEXTSTEP) 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 ;; 519QNX|SCO_SV) 520 test x"$TARGET_OSREV" = x"" && TARGET_OSREV=`uname -r` 521 ;; 522esac 523 524# Configuration depending on OS name 525case $TARGET_OS in 526386BSD) 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 ;; 532AIX) 533 add_cppflags -D_ALL_SOURCE 534 : ${HAVE_SETLOCALE_CTYPE=0} 535 ;; 536BeOS) 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 ;; 552BSD/OS) 553 : ${HAVE_SETLOCALE_CTYPE=0} 554 ;; 555Coherent) 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 ;; 563CYGWIN*) 564 : ${HAVE_SETLOCALE_CTYPE=0} 565 ;; 566Darwin) 567 add_cppflags -D_DARWIN_C_SOURCE 568 ;; 569DragonFly) 570 ;; 571FreeBSD) 572 ;; 573FreeMiNT) 574 oswarn="; it has minor issues" 575 add_cppflags -D_GNU_SOURCE 576 add_cppflags -DMKSH_CONSERVATIVE_FDS 577 : ${HAVE_SETLOCALE_CTYPE=0} 578 ;; 579GNU) 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 ;; 587GNU/kFreeBSD) 588 case $CC in 589 *tendracc*) ;; 590 *) add_cppflags -D_GNU_SOURCE ;; 591 esac 592 ;; 593Haiku) 594 add_cppflags -DMKSH_ASSUME_UTF8; HAVE_ISSET_MKSH_ASSUME_UTF8=1 595 ;; 596HP-UX) 597 ;; 598Interix) 599 ccpc='-X ' 600 ccpl='-Y ' 601 add_cppflags -D_ALL_SOURCE 602 : ${LIBS='-lcrypt'} 603 : ${HAVE_SETLOCALE_CTYPE=0} 604 ;; 605IRIX*) 606 : ${HAVE_SETLOCALE_CTYPE=0} 607 ;; 608Linux) 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 ;; 616LynxOS) 617 oswarn="; it has minor issues" 618 ;; 619MidnightBSD) 620 ;; 621Minix-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 ;; 629Minix3) 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 ;; 637MirBSD) 638 ;; 639MSYS_*) 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 ;; 646NetBSD) 647 ;; 648NEXTSTEP) 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 ;; 663Ninix3) 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 ;; 671OpenBSD) 672 : ${HAVE_SETLOCALE_CTYPE=0} 673 ;; 674OSF1) 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 ;; 682Plan9) 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 ;; 692PW32*) 693 HAVE_SIG_T=0 # incompatible 694 oswarn=' and will currently not work' 695 : ${HAVE_SETLOCALE_CTYPE=0} 696 ;; 697QNX) 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 ;; 707SCO_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 ;; 724skyos) 725 oswarn="; it has minor issues" 726 ;; 727SunOS) 728 add_cppflags -D_BSD_SOURCE 729 add_cppflags -D__EXTENSIONS__ 730 ;; 731syllable) 732 add_cppflags -D_GNU_SOURCE 733 add_cppflags -DMKSH_NO_SIGSUSPEND 734 oswarn=' and will currently not work' 735 ;; 736ULTRIX) 737 : ${CC=cc -YPOSIX} 738 add_cppflags -DMKSH_TYPEDEF_SSIZE_T=int 739 add_cppflags -DMKSH_CONSERVATIVE_FDS 740 : ${HAVE_SETLOCALE_CTYPE=0} 741 ;; 742UnixWare|UNIX_SV) 743 # SCO UnixWare 744 add_cppflags -DMKSH_CONSERVATIVE_FDS 745 : ${HAVE_SYS_SIGLIST=0} ${HAVE__SYS_SIGLIST=0} 746 ;; 747UWIN*) 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 ;; 765esac 766 767: ${HAVE_MKNOD=0} 768 769: ${AWK=awk} ${CC=cc} ${NROFF=nroff} 770test 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:" 775case $TARGET_OS in 776AIX) 777 vv '|' "oslevel >&2" 778 vv '|' "uname -a >&2" 779 ;; 780Darwin) 781 vv '|' "hwprefs machine_type os_type os_class >&2" 782 vv '|' "uname -a >&2" 783 ;; 784IRIX*) 785 vv '|' "uname -a >&2" 786 vv '|' "hinv -v >&2" 787 ;; 788OSF1) 789 vv '|' "uname -a >&2" 790 vv '|' "/usr/sbin/sizer -v >&2" 791 ;; 792SCO_SV|UnixWare|UNIX_SV) 793 vv '|' "uname -a >&2" 794 vv '|' "uname -X >&2" 795 ;; 796*) 797 vv '|' "uname -a >&2" 798 ;; 799esac 800test -z "$oswarn" || echo >&2 " 801Warning: mksh has not yet been ported to or tested on your 802operating system '$TARGET_OS'$oswarn. If you can provide 803a shell account to the developer, this may improve; please 804drop 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 821CPP="$CC -E" 822$e ... which compiler seems to be used 823cat >conftest.c <<'EOF' 824const char * 825#if defined(__ICC) || defined(__INTEL_COMPILER) 826ct="icc" 827#elif defined(__xlC__) || defined(__IBMC__) 828ct="xlc" 829#elif defined(__SUNPRO_C) 830ct="sunpro" 831#elif defined(__ACK__) 832ct="ack" 833#elif defined(__BORLANDC__) 834ct="bcc" 835#elif defined(__WATCOMC__) 836ct="watcom" 837#elif defined(__MWERKS__) 838ct="metrowerks" 839#elif defined(__HP_cc) 840ct="hpcc" 841#elif defined(__DECC) || (defined(__osf__) && !defined(__GNUC__)) 842ct="dec" 843#elif defined(__PGI) 844ct="pgi" 845#elif defined(__DMC__) 846ct="dmc" 847#elif defined(_MSC_VER) 848ct="msc" 849#elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) 850ct="adsp" 851#elif defined(__IAR_SYSTEMS_ICC__) 852ct="iar" 853#elif defined(SDCC) 854ct="sdcc" 855#elif defined(__PCC__) 856ct="pcc" 857#elif defined(__TenDRA__) 858ct="tendra" 859#elif defined(__TINYC__) 860ct="tcc" 861#elif defined(__llvm__) && defined(__clang__) 862ct="clang" 863#elif defined(__NWCC__) 864ct="nwcc" 865#elif defined(__GNUC__) 866ct="gcc" 867#elif defined(_COMPILER_VERSION) 868ct="mipspro" 869#elif defined(__sgi) 870ct="mipspro" 871#elif defined(__hpux) || defined(__hpua) 872ct="hpcc" 873#elif defined(__ultrix) 874ct="ucode" 875#elif defined(__USLC__) 876ct="uslc" 877#elif defined(__LCC__) 878ct="lcc" 879#else 880ct="unknown" 881#endif 882; 883const char * 884#if defined(__KLIBC__) 885et="klibc" 886#else 887et="unknown" 888#endif 889; 890EOF 891ct=untested 892et=untested 893vv ']' "$CPP $CFLAGS $CPPFLAGS $NOWARN conftest.c | \ 894 sed -n '/^ *[ce]t *= */s/^ *\([ce]t\) *= */\1=/p' | tr -d \\\\015 >x" 895sed 's/^/[ /' x 896eval `cat x` 897rmf x vv.out 898echo 'int main(void) { return (0); }' >conftest.c 899case $ct in 900ack) 901 # work around "the famous ACK const bug" 902 CPPFLAGS="-Dconst= $CPPFLAGS" 903 ;; 904adsp) 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 ;; 910bcc) 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 ;; 915clang) 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 ;; 927dec) 928 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V" 929 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -Wl,-V conftest.c $LIBS" 930 ;; 931dmc) 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 ;; 937gcc) 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 ;; 943hpcc) 944 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS" 945 ;; 946iar) 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 ;; 952icc) 953 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V" 954 ;; 955lcc) 956 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS" 957 add_cppflags -D__inline__=__inline 958 ;; 959metrowerks) 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 ;; 964mipspro) 965 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version" 966 ;; 967msc) 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 ;; 986nwcc) 987 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -version" 988 ;; 989pcc) 990 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -v" 991 ;; 992pgi) 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 ;; 997sdcc) 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 ;; 1003sunpro) 1004 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -V conftest.c $LIBS" 1005 ;; 1006tcc) 1007 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -v" 1008 ;; 1009tendra) 1010 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V 2>&1 | \ 1011 fgrep -i -e version -e release" 1012 ;; 1013ucode) 1014 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN $LIBS -V" 1015 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -Wl,-V conftest.c $LIBS" 1016 ;; 1017uslc) 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 ;; 1027watcom) 1028 vv '|' "$CC $CFLAGS $CPPFLAGS $LDFLAGS $NOWARN -v conftest.c $LIBS" 1029 ;; 1030xlc) 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 ;; 1042esac 1043case $cm in 1044dragonegg|llvm) 1045 vv '|' "llc -version" 1046 ;; 1047esac 1048case $et in 1049klibc) 1050 add_cppflags -DMKSH_NO_LIMITS 1051 ;; 1052unknown) 1053 # nothing special detected, donât worry 1054 unset et 1055 ;; 1056*) 1057 # huh? 1058 ;; 1059esac 1060$e "$bi==> which compiler seems to be used...$ao $ui$ct${et+ on $et}$ao" 1061rmf conftest.c conftest.o conftest a.out* a.exe* vv.out 1062 1063# 1064# Compiler: works as-is, with -Wno-error and -Werror 1065# 1066save_NOWARN=$NOWARN 1067NOWARN= 1068DOWARN= 1069ac_flags 0 compiler_works '' 'if the compiler works' 1070test 1 = $HAVE_CAN_COMPILER_WORKS || exit 1 1071HAVE_COMPILER_KNOWN=0 1072test $ct = unknown || HAVE_COMPILER_KNOWN=1 1073if 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 1094fi 1095if 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 1100fi 1101 1102if 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" 1108elif test $ct = hpcc; then 1109 save_NOWARN= 1110 DOWARN=+We 1111elif test $ct = mipspro; then 1112 save_NOWARN= 1113 DOWARN="-diag_error 1-10000" 1114elif test $ct = msc; then 1115 save_NOWARN="${ccpc}/w" 1116 DOWARN="${ccpc}/WX" 1117elif test $ct = dmc; then 1118 save_NOWARN="${ccpc}-w" 1119 DOWARN="${ccpc}-wx" 1120elif test $ct = bcc; then 1121 save_NOWARN="${ccpc}-w" 1122 DOWARN="${ccpc}-w!" 1123elif test $ct = dec; then 1124 : -msg_* flags not used yet, or is -w2 correct? 1125elif test $ct = xlc; then 1126 save_NOWARN=-qflag=i:e 1127 DOWARN=-qflag=i:i 1128elif test $ct = tendra; then 1129 save_NOWARN=-w 1130elif test $ct = ucode; then 1131 save_NOWARN= 1132 DOWARN=-w2 1133elif test $ct = watcom; then 1134 save_NOWARN= 1135 DOWARN=-Wc,-we 1136else 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 1142fi 1143 1144test $ct = icc && DOWARN="$DOWARN -wd1419" 1145NOWARN=$save_NOWARN 1146 1147# 1148# Compiler: extra flags (-O2 -f* -W* etc.) 1149# 1150i=`echo :"$orig_CFLAGS" | sed 's/^://' | tr -c -d $alll$allu$alln` 1151# optimisation: only if orig_CFLAGS is empty 1152test 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 1162elif test $ct = hpcc; then 1163 phase=u 1164 ac_flags 1 otwo +O2 1165 phase=x 1166elif test $ct = xlc; then 1167 ac_flags 1 othree "-O3 -qstrict" 1168 test 1 = $HAVE_CAN_OTHREE || ac_flags 1 otwo -O2 1169elif test $ct = tcc || test $ct = tendra; then 1170 : no special optimisation 1171else 1172 ac_flags 1 otwo -O2 1173 test 1 = $HAVE_CAN_OTWO || ac_flags 1 optimise -O 1174fi 1175# other flags: just add them if they are supported 1176i=0 1177if 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 1226elif 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 1231elif 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 1236elif 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 1241elif test $ct = dec; then 1242 ac_flags 0 verb -verbose 1243 ac_flags 1 rodata -readonly_strings 1244elif 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' 1247elif test $ct = bcc; then 1248 ac_flags 1 strpool "${ccpc}-d" 'if string pooling can be enabled' 1249elif test $ct = mipspro; then 1250 ac_flags 1 fullwarn -fullwarn 'for remark output support' 1251elif 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' 1260elif 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 1266elif 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 1270elif test $ct = tcc; then 1271 : #broken# ac_flags 1 boundschk -b 1272elif test $ct = clang; then 1273 i=1 1274elif test $ct = nwcc; then 1275 i=1 1276 : #broken# ac_flags 1 ssp -stackprotect 1277fi 1278# flags common to a subset of compilers (run with -Werror on gcc) 1279if test 1 = $i; then 1280 ac_flags 1 wall -Wall 1281 ac_flags 1 fwrapv -fwrapv 1282fi 1283 1284phase=x 1285# The following tests run with -Werror or similar (all compilers) if possible 1286NOWARN=$DOWARN 1287test $ct = pcc && phase=u 1288 1289# 1290# Compiler: check for stuff that only generates warnings 1291# 1292ac_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 1311EOF 1312ac_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 1325EOF 1326ac_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 1337EOF 1338ac_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 1346EOF 1347ac_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 1355EOF 1356 1357# End of tests run with -Werror 1358NOWARN=$save_NOWARN 1359phase=x 1360 1361# 1362# mksh: flavours (full/small mksh, omit certain stuff) 1363# 1364if 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 1370fi 1371ac_ifcpp 'ifdef MKSH_BINSHREDUCED' isset_MKSH_BINSHREDUCED '' \ 1372 "if a reduced-feature sh is requested" && \ 1373 check_categories="$check_categories binsh" 1374ac_ifcpp 'ifdef MKSH_UNEMPLOYED' isset_MKSH_UNEMPLOYED '' \ 1375 "if mksh will be built without job control" && \ 1376 check_categories="$check_categories arge" 1377ac_ifcpp 'ifdef MKSH_NOPROSPECTOFWORK' isset_MKSH_NOPROSPECTOFWORK '' \ 1378 "if mksh will be built without job signals" && \ 1379 check_categories="$check_categories arge nojsig" 1380ac_ifcpp 'ifdef MKSH_ASSUME_UTF8' isset_MKSH_ASSUME_UTF8 '' \ 1381 'if the default UTF-8 mode is specified' && : ${HAVE_SETLOCALE_CTYPE=0} 1382ac_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" 1391ac_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# 1398ac_header sys/time.h sys/types.h 1399ac_header time.h sys/types.h 1400test "11" = "$HAVE_SYS_TIME_H$HAVE_TIME_H" || HAVE_BOTH_TIME_H=0 1401ac_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)); } 1406EOF 1407ac_header sys/bsdtypes.h 1408ac_header sys/file.h sys/types.h 1409ac_header sys/mkdev.h sys/types.h 1410ac_header sys/mman.h sys/types.h 1411ac_header sys/param.h 1412ac_header sys/resource.h sys/types.h _time 1413ac_header sys/select.h sys/types.h 1414ac_header sys/sysmacros.h 1415ac_header bstring.h 1416ac_header grp.h sys/types.h 1417ac_header libgen.h 1418ac_header libutil.h sys/types.h 1419ac_header paths.h 1420ac_header stdint.h stdarg.h 1421# include strings.h only if compatible with string.h 1422ac_header strings.h sys/types.h string.h 1423ac_header termios.h 1424ac_header ulimit.h sys/types.h 1425ac_header values.h 1426 1427# 1428# Environment: definitions 1429# 1430echo '#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)) 1433int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && 1434 LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; 1435int main(void) { return (0); }' >lft.c 1436ac_testn can_lfs '' "for large file support" <lft.c 1437save_CPPFLAGS=$CPPFLAGS 1438add_cppflags -D_FILE_OFFSET_BITS=64 1439ac_testn can_lfs_sus '!' can_lfs 0 "... with -D_FILE_OFFSET_BITS=64" <lft.c 1440if 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 1445fi 1446rmf lft* # end of large file support test 1447 1448# 1449# Environment: types 1450# 1451ac_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); } 1455EOF 1456ac_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); } 1460EOF 1461ac_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]); } 1465EOF 1466ac_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]); } 1470EOF 1471 1472ac_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); } 1487EOF 1488 1489# only testn: added later below 1490ac_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)); } 1495EOF 1496 1497ac_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)); } 1502EOF 1503if test 1 = $HAVE_SIGHANDLER_T; then 1504 add_cppflags -Dsig_t=sighandler_t 1505 HAVE_SIG_T=1 1506fi 1507 1508ac_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)); } 1513EOF 1514if test 1 = $HAVE___SIGHANDLER_T; then 1515 add_cppflags -Dsig_t=__sighandler_t 1516 HAVE_SIG_T=1 1517fi 1518 1519test 1 = $HAVE_SIG_T || add_cppflags -Dsig_t=nosig_t 1520ac_cppflags SIG_T 1521 1522# 1523# check whether whatever we use for the final link will succeed 1524# 1525if test $cm = makefile; then 1526 : nothing to check 1527else 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); } 1537EOF 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 1565fi 1566 1567# 1568# Environment: errors and signals 1569# 1570test x"NetBSD" = x"$TARGET_OS" && $e Ignore the compatibility warning. 1571 1572ac_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]); } 1576EOF 1577ac_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]); } 1581EOF 1582if 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 1586fi 1587ac_cppflags SYS_ERRLIST 1588 1589for 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 1605done 1606 1607# 1608# Environment: library functions 1609# 1610ac_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)); } 1618EOF 1619 1620ac_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 } 1628EOF 1629 1630ac_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 } 1638EOF 1639 1640ac_test gettimeofday <<-'EOF' 1641 #define MKSH_INCLUDES_ONLY 1642 #include "sh.h" 1643 int main(void) { struct timeval tv; return (gettimeofday(&tv, NULL)); } 1644EOF 1645 1646ac_test killpg <<-'EOF' 1647 #include <signal.h> 1648 int main(int ac, char *av[]) { return (av[0][killpg(123, ac)]); } 1649EOF 1650 1651ac_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 } 1661EOF 1662 1663ac_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 } 1672EOF 1673 1674ac_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)); } 1687EOF 1688 1689ac_test nice <<-'EOF' 1690 #include <unistd.h> 1691 int main(void) { return (nice(4)); } 1692EOF 1693 1694ac_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])); } 1701EOF 1702 1703ac_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, "")); } 1707EOF 1708 1709ac_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)); } 1713EOF 1714 1715ac_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 } 1746EOF 1747 1748ac_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)); } 1752EOF 1753 1754ac_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)); } 1761EOF 1762 1763if 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)); } 1770EOF 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)); } 1780EOF 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)); } 1787EOF 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 1793fi 1794 1795ac_test strerror '!' sys_errlist 0 <<-'EOF' 1796 extern char *strerror(int); 1797 int main(int ac, char *av[]) { return (*strerror(*av[ac])); } 1798EOF 1799 1800ac_test strsignal '!' sys_siglist 0 <<-'EOF' 1801 #include <string.h> 1802 #include <signal.h> 1803 int main(void) { return (strsignal(1)[0]); } 1804EOF 1805 1806ac_test strlcpy <<-'EOF' 1807 #include <string.h> 1808 int main(int ac, char *av[]) { return (strlcpy(*av, av[1], 1809 (size_t)ac)); } 1810EOF 1811 1812# 1813# check headers for declarations 1814# 1815ac_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)); } 1822EOF 1823ac_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)("")); } 1827EOF 1828ac_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]); } 1832EOF 1833ac_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]); } 1837EOF 1838 1839# 1840# other checks 1841# 1842fd='if to use persistent history' 1843ac_cache PERSISTENT_HISTORY || case $HAVE_MMAP$HAVE_FLOCK$HAVE_LOCK_FCNTL in 184411*|101) fv=1 ;; 1845esac 1846test 1 = $fv || check_categories="$check_categories no-histfile" 1847ac_testdone 1848ac_cppflags 1849 1850save_CFLAGS=$CFLAGS 1851test x1 = x$HAVE_CAN_WNOOVERFLOW && CFLAGS="$CFLAGS -Wno-overflow" 1852ac_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 */ 1861cta(char_is_1_char, (sizeof(char) == 1) && (sizeof(signed char) == 1) && 1862 (sizeof(unsigned char) == 1)); 1863cta(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 */ 1866cta(short_is_2_char, sizeof(short) == 2); 1867cta(short_size_no_matter_of_signedness, sizeof(short) == sizeof(unsigned short)); 1868/* the next assertion is probably not really needed */ 1869cta(int_is_4_char, sizeof(int) == 4); 1870cta(int_size_no_matter_of_signedness, sizeof(int) == sizeof(unsigned int)); 1871 1872cta(long_ge_int, sizeof(long) >= sizeof(int)); 1873cta(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 */ 1877cta(ari_is_4_char, sizeof(mksh_ari_t) == 4); 1878/* but the next two are; we REQUIRE signed integer wraparound */ 1879cta(ari_has_31_bit, 0 < (mksh_ari_t)(((((mksh_ari_t)1 << 15) << 15) - 1) * 2 + 1)); 1880#ifndef MKSH_GCC55009 1881cta(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 */ 1886cta(uari_is_4_char, sizeof(mksh_uari_t) == 4); 1887/* but the next three are; we REQUIRE unsigned integer wraparound */ 1888cta(uari_has_31_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 2 + 1)); 1889cta(uari_has_32_bit, 0 < (mksh_uari_t)(((((mksh_uari_t)1 << 15) << 15) - 1) * 4 + 3)); 1890cta(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 */ 1895cta(ari_is_signed, (mksh_ari_t)-1 < (mksh_ari_t)0); 1896cta(uari_is_unsigned, (mksh_uari_t)-1 > (mksh_uari_t)0); 1897 1898cta(sizet_size_no_matter_of_signedness, sizeof(ssize_t) == sizeof(size_t)); 1899cta(ptrdifft_sizet_same_size, sizeof(ptrdiff_t) == sizeof(size_t)); 1900cta(ptrdifft_voidptr_same_size, sizeof(ptrdiff_t) == sizeof(void *)); 1901cta(ptrdifft_funcptr_same_size, sizeof(ptrdiff_t) == sizeof(void (*)(void))); 1902/* our formatting routines assume this */ 1903cta(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 1914char ctasserts_dblcheck[sizeof(struct ctasserts) == NUM ? 1 : -1]; 1915 int main(void) { return (sizeof(ctasserts_dblcheck)); } 1916EOF 1917CFLAGS=$save_CFLAGS 1918eval test 1 = \$HAVE_COMPILE_TIME_ASSERTS_$$ || exit 1 1919 1920# 1921# extra checks for legacy mksh 1922# 1923if 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)); } 1936EOF 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)); } 1950EOF 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 1957fi 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 1966if 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 2004EOF 2005then 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 2019fi 2020ac_cppflags 2021 2022$e "${bi}end of run-time checks$ao" 2023 2024# 2025# Compiler: Praeprocessor (only if needed) 2026# 2027test 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 2034fi 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 2043echo wq >x 2044ed x <x 2>/dev/null | grep 3 >/dev/null 2>&1 && \ 2045 check_categories="$check_categories $oldish_ed" 2046rmf x vv.out 2047 2048if 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 2066int 2067mksh_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. 2116fi 2117 2118addsrcs -s '!' HAVE_STRLCPY strlcpy.c 2119addsrcs USE_PRINTF_BUILTIN printf.c 2120test 1 = "$USE_PRINTF_BUILTIN" && add_cppflags -DMKSH_PRINTF_BUILTIN 2121test 1 = "$HAVE_CAN_VERB" && CFLAGS="$CFLAGS -verbose" 2122test -n "$LDSTATIC" && add_cppflags -DMKSH_OPTSTATIC 2123add_cppflags -DMKSH_BUILD_R=431 2124 2125$e $bi$me: Finished configuration testing, now producing output.$ao 2126 2127files= 2128objs= 2129sp= 2130case $tcfn in 2131a.exe) mkshexe=$tfn.exe ;; 2132*) mkshexe=$tfn ;; 2133esac 2134case $curdir in 2135*\ *) mkshshebang="#!./$mkshexe" ;; 2136*) mkshshebang="#!$curdir/$mkshexe" ;; 2137esac 2138cat >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 2220EOF 2221chmod 755 test.sh 2222if test $cm = llvm; then 2223 emitbc="-emit-llvm -c" 2224elif test $cm = dragonegg; then 2225 emitbc="-S -flto" 2226else 2227 emitbc=-c 2228fi 2229echo ": # work around NeXTstep bug" >Rebuild.sh 2230echo set -x >>Rebuild.sh 2231for 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 2244done 2245case $cm in 2246dragonegg|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 ;; 2254esac 2255echo tcfn=$mkshexe >>Rebuild.sh 2256echo "$CC $CFLAGS $LDFLAGS -o \$tcfn $lobjs $LIBS $ccpr" >>Rebuild.sh 2257echo 'test -f $tcfn || exit 1; size $tcfn' >>Rebuild.sh 2258if 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 2264PROG= $mkshexe 2265MAN= mksh.1 2266SRCS= $SRCS 2267SRCS_FP= $files 2268OBJS_BP= $objs 2269INDSRCS= $extras 2270NONSRCS_INST= dot.mkshrc \$(MAN) 2271NONSRCS_NOINST= Build.sh Makefile Rebuild.sh check.pl check.t test.sh 2272CC= $CC 2273CFLAGS= $CFLAGS 2274CPPFLAGS= $CPPFLAGS 2275LDFLAGS= $LDFLAGS 2276LIBS= $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) 2291check_categories=$check_categories 2292 2293# for BSD make only: 2294#.PATH: $srcdir 2295#.include <bsd.prog.mk> 2296EOF 2297 $e 2298 $e Generated Makefrag.inc successfully. 2299 exit 0 2300fi 2301if 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" 2309elif 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 2315else 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 2326fi 2327case $cm in 2328dragonegg|llvm) 2329 rmf $tfn.s 2330 v "llvm-link -o - $objs | opt $optflags | llc -o $tfn.s" 2331 ;; 2332esac 2333tcfn=$mkshexe 2334test $cm = combine || v "$CC $CFLAGS $LDFLAGS -o $tcfn $lobjs $LIBS $ccpr" 2335test -f $tcfn || exit 1 2336test 1 = $r || v "$NROFF -mdoc <'$srcdir/mksh.1' >$tfn.cat1" || \ 2337 rmf $tfn.cat1 2338test 0 = $eq && v size $tcfn 2339i=install 2340test -f /usr/ucb/$i && i=/usr/ucb/$i 2341test 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: 2349if 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 2353fi 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. 2358exit 0 2359 2360: <<'EOD' 2361 2362=== Environment used === 2363 2364==== build environment ==== 2365AWK default: awk 2366CC default: cc 2367CFLAGS if empty, defaults to -xO2 or +O2 2368 or -O3 -qstrict or -O2, per compiler 2369CPPFLAGS default empty 2370LDFLAGS default empty; added before sources 2371LDSTATIC set this to '-static'; default unset 2372LIBS default empty; added after sources 2373 [Interix] default: -lcrypt (XXX still needed?) 2374NOWARN -Wno-error or similar 2375NROFF default: nroff 2376TARGET_OS default: $(uname -s || uname) 2377TARGET_OSREV [QNX] default: $(uname -r) 2378 2379==== feature selectors ==== 2380USE_PRINTF_BUILTIN 1 to include (unsupported) printf(1) as builtin 2381===== general format ===== 2382HAVE_STRLEN ac_test 2383HAVE_STRING_H ac_header 2384HAVE_CAN_FSTACKPROTECTORALL ac_flags 2385 2386==== cpp definitions ==== 2387DEBUG dont use in production, wants gcc, implies: 2388DEBUG_LEAKS enable freeing resources before exiting 2389MKSHRC_PATH "~/.mkshrc" (do not change) 2390MKSH_A4PB force use of arc4random_pushb 2391MKSH_ASSUME_UTF8 (0=disabled, 1=enabled; default: unset) 2392MKSH_BINSHREDUCED if */sh or */-sh, enable set -o sh 2393MKSH_CLRTOEOL_STRING "\033[K" 2394MKSH_CLS_STRING "\033[;H\033[J" 2395MKSH_CONSERVATIVE_FDS fd 0-9 for scripts, shell only up to 31 2396MKSH_DEFAULT_EXECSHELL "/bin/sh" (do not change) 2397MKSH_DEFAULT_PROFILEDIR "/etc" (do not change) 2398MKSH_DEFAULT_TMPDIR "/tmp" (do not change) 2399MKSH_DISABLE_DEPRECATED disable code paths scheduled for later removal 2400MKSH_DISABLE_EXPERIMENTAL disable code not yet comfy for (LTS) snapshots 2401MKSH_DISABLE_TTY_WARNING shut up warning about ctty if OS cant be fixed 2402MKSH_DONT_EMIT_IDSTRING omit RCS IDs from binary 2403MKSH_GCC55009 DANGER! see http://www.mirbsd.org/mksh.htm#p41 2404MKSH_MIDNIGHTBSD01ASH_COMPAT set -o sh: additional compatibility quirk 2405MKSH_NOPROSPECTOFWORK disable jobs, co-processes, etc. (do not use) 2406MKSH_NOPWNAM skip PAM calls, for -static on eglibc, Solaris 2407MKSH_NO_CMDLINE_EDITING disable command line editing code entirely 2408MKSH_NO_DEPRECATED_WARNING omit warning when deprecated stuff is run 2409MKSH_NO_EXTERNAL_CAT omit hack to skip cat builtin when flags passed 2410MKSH_NO_LIMITS omit ulimit code 2411MKSH_NO_SIGSETJMP define if sigsetjmp is broken or not available 2412MKSH_NO_SIGSUSPEND use sigprocmask+pause instead of sigsuspend 2413MKSH_SMALL omit some code, optimise hard for size (slower) 2414MKSH_SMALL_BUT_FAST disable some hard-for-size optim. (modern sys.) 2415MKSH_S_NOVI=1 disable Vi editing mode (default if MKSH_SMALL) 2416MKSH_TYPEDEF_SIG_ATOMIC_T define to e.g. 'int' if sig_atomic_t is missing 2417MKSH_TYPEDEF_SSIZE_T define to e.g. 'long' if your OS has no ssize_t 2418MKSH_UNEMPLOYED disable job control (but not jobs/co-processes) 2419 2420=== generic installation instructions === 2421 2422Set CC and possibly CFLAGS, CPPFLAGS, LDFLAGS, LIBS. If cross-compiling, 2423also set TARGET_OS. To disable tests, set e.g. HAVE_STRLCPY=0; to enable 2424them, set to a value other than 0 or 1. Ensure /bin/ed is installed. For 2425MKSH_SMALL but with Vi mode, add -DMKSH_S_NOVI=0 to CPPFLAGS as well. 2426 2427Normally, 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 2430Copy 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 2432using $NROFF. Consider using a forward script as /etc/skel/.mkshrc like 2433https://www.mirbsd.org/cvs.cgi/contrib/hosted/tg/deb/mksh/debian/.mkshrc?rev=HEAD 2434and put dot.mkshrc as /etc/mkshrc so users need not keep up their HOME. 2435 2436EOD 2437