diff options
Diffstat (limited to 'src/cmd/INIT')
91 files changed, 42175 insertions, 0 deletions
diff --git a/src/cmd/INIT/C+probe b/src/cmd/INIT/C+probe new file mode 100644 index 0000000..f427742 --- /dev/null +++ b/src/cmd/INIT/C+probe @@ -0,0 +1,870 @@ +: +### this script contains archaic constructs that work with all sh variants ### +# Glenn Fowler +# AT&T Research +# +# @(#)C probe (AT&T Research) 2012-02-29 +# +# probe [ -d ] c-compiler-path [ attributes ] +# +# common C probe preamble for the tool specific probes +# +# NOTE: some cc -E's do syntax analysis! + +# +# probe_* are first eval'd and then attempted from left to right +# + +probe_binding="-dy -dn -Bdynamic -Bstatic '-Wl,-ashared -Wl,+s' -Wl,-aarchive -call_shared -non_shared -dynamic -static -bshared -bstatic '' -static" +probe_env="CC_OPTIONS CCOPTS LD_OPTIONS LDOPTS LIBPATH LPATH" +probe_include="stdio.h iostream.h complex.h ctype.h plot.h stdarg.h varargs.h ranlib.h hash.h sys/types.h stab.h cmath cstdio iostream string" +probe_longlong="long 'long long'" +probe_longlong_t="__int64_t _int64_t __int64 _int64 int64" +probe_l="l yyreject m sin mopt sin" +probe_lxx="C exit ++ exit g++ exit" +probe_ppprefix="a n" +probe_size="size" +probe_src="cxx C cc c" +probe_sa=".sa" +probe_sd=".dll .lib .dll .x" +probe_sdb=".pdb" +probe_so=".dylib .so .sl" +probe_symprefix="_" +probe_verbose="'-v -v' '-# -#' '-d -d' -dryrun '-V -V'" +probe_version="--version -V -version -v" + +# +# the following are set by the preamble for the tool specific probe +# + +cc=cc +debug= +dir=. +dll=.dll +dynamic= +exe=exe +executable="test -x" +hosted= +ifs=${IFS-' + '} +obj=o +ppenv= +ppopt= +predef= +prepred= +sa= +sd= +sdb= +so= +sov= +static= +stdlib= +stdpp= +suffix_command= +if test "" != "$TMPDIR" -a -d "$TMPDIR" +then tmpdir=$TMPDIR +else tmpdir=/tmp +fi +tmpdir=$tmpdir/probe$$ +undef="define defined elif else endif error if ifdef ifndef include line pragma undef __STDC__ __STDPP__ __ARGC__ __BASE__ __BASE_FILE__ __DATE__ __FILE__ __FUNCTION__ __INCLUDE_LEVEL__ __LINE__ __PATH__ __TIME__ __TIMESTAMP__ __VERSION__" +version_flags= +version_stamp= +version_string= + +# +# constrain the environment +# + +DISPLAY= +LC_ALL=C +export DISPLAY LC_ALL + +# +# now the common probes +# + +while : +do case $1 in + -d) debug=1 ;; + -*) set ''; break ;; + *) break ;; + esac + shift +done + +cc=$1 +case $cc in +[\\/]*|[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]:\\*) + ;; +*) echo "Usage: $0 [ -d ] c-compiler-path [ attributes ]" >&2 + exit 1 + ;; +esac +ATTRIBUTES= +eval $2 +_probe_PATH=$PATH +PATH=/usr/bin:/bin:$PATH + +case $0 in +*[\\/]*) dir=`echo $0 | sed -e 's,[\\/][\\/]*[^\\/]*\$,,'` ;; +esac + +$executable . 2>/dev/null || executable='test -r' + +case $SHELL in +[\\/]*|[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]:\\*) + sh=$SHELL + ;; +*) sh=/bin/sh + ;; +esac + +trap 'code=$?; cd ..; rm -rf $tmpdir; exit $code' 0 1 2 3 +mkdir $tmpdir +cd $tmpdir + +exec 3>&1 4>&2 </dev/null +case $debug in +"") exec >/dev/null 2>&1 + (ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0 + ;; +*) PS4='+$LINENO+ ' + set -x + ;; +esac + +if (xxx=xxx; unset xxx) +then UNSET=1 +else UNSET= +fi +eval set x $probe_env +while : +do shift + case $# in + 0) break ;; + esac + eval x='$'$1 + case $x in + '') continue ;; + esac + case $1 in + *PATH) _probe_export="$_probe_export $1='$x'" ;; + esac + case $UNSET in + '') eval $1= + export $1 + ;; + *) unset $1 + ;; + esac +done + +if test -f "$dir/probe.ini" +then . "$dir/probe.ini" + IFS=$ifs +fi + +mkdir suffix +cd suffix +for src in $probe_src +do echo "int main(){return 0;}" > ../test.$src + rm -f test* + if $cc -c ../test.$src + then set test.* + if test -f "$1" + then o="$*" + mv $* .. + for i in $o + do if $cc -o test.exe ../$i + then obj=`echo "$i" | sed -e 's,test.,,'` + $executable test.exe || executable="test -r" + set test* + rm * + if $cc -o test ../$i + then rm $* + set test.* + if $executable "$1" + then exe=`echo "$1" | sed -e 's,test.,,'` + suffix_command=.$exe + fi + fi + break 2 + fi + done + fi + fi +done +cd .. + +case $src in +c) ;; +*) echo '// ( +int +main() +{ + class { public: int i; } j; + j.i = 0; + int k = j.i + 1; + return k; +}' > dialect.$src + if $cc -c dialect.$src && $cc -o dialect.$exe dialect.$obj && $executable dialect.$exe + then mv dialect.$src dialect.c + rm -f dialect.$obj dialect.$exe + if $cc -c dialect.c && $cc -o dialect.$exe dialect.$obj && $executable dialect.$exe + then src=c + else set x $cc + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + *=*) continue ;; + esac + case `echo $1 | sed -e 's,.*/,,'` in + *CC*|*++*|*[xX][xX]*|*[pP][lL][uU][sS]*) ;; + *) src=c ;; + esac + break + done + fi + else src=c + fi + ;; +esac + +set x x '(' 1 'int x;' 0 +while : +do shift + shift + case $# in + [01]) break ;; + esac + rm -f test.$obj + echo "$1" > test.$src + $cc -c test.$src + r=$? + case $r in + 0) test -f test.$obj || r=1 ;; + *) r=1 ;; + esac + case $2:$r in + 0:0) ;; + 0:1) echo "$cc: not a C compiler: failed to compile \`\`$1''" >&4 + exit 1 + ;; + 1:0) echo "$cc: not a C compiler: successfully compiled \`\`$1''" >&4 + exit 1 + ;; + esac +done + +hosttype=`package CC="$cc" || $SHELL -c "package CC='$cc'"` +case $hosttype in +*[Uu][Ss][Aa][Gg][Ee]:*) + hosttype=`PATH=$_probe_PATH; export PATH; package CC="$cc" || $SHELL -c "package CC='$cc'"` + ;; +esac + +echo '#include <stdio.h> +int main(){printf("hello");return 0;}' > dynamic.$src +echo 'extern int sfclose() { return 0; }' > fun.$src +if $cc -c dynamic.$src && $cc -c fun.$src +then eval set x $probe_so + while : + do shift + case $# in + 0) break ;; + esac + for i in foo junk + do rm -f dynamic.$exe + if $cc -L. -o dynamic.$exe dynamic.$obj -l$i + then : "there's really a -l$i"? + else rm -f dynamic.$exe + cat fun.$obj > lib$i$1 + $cc -L. -o dynamic.$exe dynamic.$obj -l$i && $executable dynamic.$exe + x=$? + rm lib$i$1 + case $x in + 0) so=$1 + rm -f dynamic.$exe > lib$i$1.1 + $cc -L. -o dynamic.$exe dynamic.$obj -l$i && $executable dynamic.$exe + x=$? + rm lib$i$1.1 + case $x in + 0) sov=1 ;; + esac + break 2 + ;; + *) break + ;; + esac + fi + done + k= + for i in "" .1 .2 .3 .4 .5 .6 .7 .8 .9 + do rm -f dynamic.$exe > libc$1$i + $cc -L. -o dynamic.$exe dynamic.$obj && $executable dynamic.$exe + x=$? + (cd ..; rm $tmpdir/libc$1$i) + case $x in + 0) ;; + *) k=X$k + case $k in + XXX) break ;; + esac + ;; + esac + done + case $k in + XXX) so=$1 + sov=1 + break + ;; + ?*) so=$1 + break + ;; + esac + done + rm -f dynamic.$exe + if $cc -o dynamic.$exe dynamic.$obj 2>e && $executable dynamic.$exe + then e=`wc -l e` + maybe= + eval set x x $probe_binding + while : + do shift + shift + case $# in + 0) break ;; + esac + rm -f dynamic.$exe + $cc -o dynamic.$exe $1 dynamic.$obj 2>e && $executable dynamic.$exe || continue + case $1 in + ?*) case $maybe in + "") maybe=$1 ;; + *) maybe=-- ;; + esac + ;; + esac + case `wc -l e` in + $e) ;; + *) continue ;; + esac + d=`ls -s dynamic.$exe` + rm -f dynamic.$exe + $cc -o dynamic.$exe $2 dynamic.$obj 2>e && $executable dynamic.$exe || continue + case `wc -l e` in + $e) ;; + *) continue ;; + esac + case `ls -s dynamic.$exe` in + $d) ;; + *) dynamic=$1 + static=$2 + maybe= + break + ;; + esac + done + case $maybe in + ""|--) ;; + *) rm -f dynamic.$exe + if $cc -o dynamic.$exe $maybe dynamic.$obj 2>e && $executable dynamic.$exe + then e=`wc -l e` + if $cc -o dynamic.$exe $maybe-bogus-bogus-bogus dynamic.$obj 2>e && $executable dynamic.$exe + then case `wc -l e` in + $e) ;; + *) dynamic=$maybe ;; + esac + else dynamic=$maybe + fi + fi + ;; + esac + fi +fi + +eval set x $probe_version +shift +for o in "$@" +do if $cc $o > version.out 2>&1 + then version_string=`sed -e '/ is /d' -e 's/;/ /g' version.out | sed -e 1q` + case $version_string in + ''|*[Ee][Rr][Rr][Oo][Rr]*|*[Ff][Aa][Tt][Aa][Ll]*|*[Ww][Aa][Rr][Nn][Ii][Nn][Gg]*|*[Oo][Pp][Tt][Ii][Oo][Nn]*) + ;; + *) version_flags=$o + version_stamp=";VERSION;$o;$version_string;PATH;$cc" + break + ;; + esac + fi +done +case $version_stamp in +'') eval set x $probe_version + shift + echo 'int main() { return 0; }' > version.i + for o in "$@" + do if $cc -c $o version.i > version.out 2>&1 + then version_string=`sed -e '/ is /d' -e 's/;/ /g' version.out | sed -e 1q` + case $version_string in + ''|*[Ee][Rr][Rr][Oo][Rr]*|*[Ff][Aa][Tt][Aa][Ll]*|*[Ww][Aa][Rr][Nn][Ii][Nn][Gg]*|*[Oo][Pp][Tt][Ii][Oo][Nn]*) + ;; + *) version_flags=$o + break + ;; + esac + fi + done + ;; +esac + +echo 'int main(){return 0;}' > hosted.$src +$cc -o hosted.$exe hosted.$src && ./hosted.$exe && hosted=1 + +echo '#!'$sh' +echo "" $@' > cpp +chmod +x cpp +case `./cpp -Dprobe` in +*-Dprobe*) + ;; +*) cp /bin/echo cpp + chmod u+w cpp + ;; +esac +for prefix in $probe_ppprefix `echo $cc | sed -e '/cc\$/!d' -e 's,cc\$,,' -e 's,.*/,,'` +do cp cpp ${prefix}cpp +done + +echo "" > flags.$src +echo '#pragma pp:version' > libpp.$src + +if test `realcppC=./cpp $cc -Dprobe -E flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppenv='realcppC=${ppcmd}' +elif test `cppC=./cpp $cc -Dprobe -E flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppenv='cppC=${ppcmd}' +elif test `_CPPNAME=./cpp $cc -Dprobe -E flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppenv='_CPPNAME=${ppcmd}' +elif test `_CPP=./cpp $cc -Dprobe -E flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppenv='_CPP=${ppcmd}' +elif test `$cc -Dprobe -E -%p+. flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 && test `$cc -Dprobe -E -%p+. flags.$src | wc -l` -eq 1 +then ppopt='-%p+${ppdir}' +elif test `$cc -Dprobe -E -Yp,. flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppopt='-Yp,${ppdir}' +elif test `$cc -Dprobe -E -Qpath $tmpdir flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppopt='-Qpath ${ppdir}' +elif test `$cc -Dprobe -E -tp -B./ flags.$src 2>err.out | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 -a ! -s err.out +then ppopt='-tp -B${ppdir}/' +elif test `$cc -Dprobe -E -B./ flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppopt='-B${ppdir}/' +elif test `$cc -Dprobe -E -tp -h./ -B flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppopt='-tp -h${ppdir}/ -B' +elif test `$cc -Dprobe -E -t p,./cpp flags.$src | tee cpp.out | grep -c '[-]Dprobe'` -eq 1 +then ppopt='-t p,${ppcmd}' +else { + eval set x $probe_verbose + shift + for o in "$@" + do $cc -E $o flags.$src + done + } 2>&1 | sed -e "s/['\"]//g" > cpp.out +fi + +set x `sed -e 's,[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]:\\\\,/,g' -e 's,\\\\,/,g' cpp.out` +def= +definclude="-I+C -I-H" +stdinclude=$definclude +case $hosted in +"") usrinclude= ;; +esac +cmdinclude= +while : +do case $# in + 0|1) break ;; + esac + shift + case $1 in + -A) case $2 in + *\(*\)) shift + prepred="$prepred `echo $1 | sed 's/\(.*\)(\(.*\))/\1 \2/'`" + ;; + esac + ;; + -A\(*\)) + prepred="$prepred `echo $1 | sed 's/-A\(.*\)(\(.*\))/\1 \2/'`" + ;; + -[DI][-+][ABCDEFGHIJKLMNOPQRSTUVWXYZ]*) + stdpp=1 + case $1 in + -I?[CH]) case $def in + ?*) definclude="$definclude $1" ;; + *) stdinclude="$stdinclude $1" ;; + esac + ;; + -I-S*|-YI,*) usrinclude="`echo $1 | sed 's/....//'`" ;; + -Y?,*) ;; + -Y*) usrinclude="`echo $1 | sed 's/..//'`" ;; + esac + ;; + -D) shift + case $1 in + [ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_]*=*) + predef="$predef +`echo $1 | sed -e 's/=.*//'`" + ;; + [ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_]*) + predef="$predef +$1" + ;; + esac + ;; + -Dprobe);; + -D*) case $1 in + -D[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_]*=*) + predef="$predef +`echo $1 | sed -e 's/^-D//' -e 's/=.*//'`" + ;; + -D[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_]*) + predef="$predef +`echo $1 | sed -e 's/^-D//'`" + ;; + esac + ;; + -I) shift + case $1 in + /*) case $def in + ?*) definclude="$definclude $1" ;; + *) stdinclude="$stdinclude $1" ;; + esac + cmdinclude="$cmdinclude $1" + ;; + esac + ;; + -I/*) f=`echo X$1 | sed 's/X-I//'` + case $def in + ?*) definclude="$definclude $f" ;; + *) stdinclude="$stdinclude $f" ;; + esac + cmdinclude="$cmdinclude $f" + ;; + -U) shift + undef="$undef $1" + ;; + -U*) undef="$undef `echo $1 | sed 's/^-U//'`" + ;; + flags.$src)def= + ;; + esac +done +stdinclude="$stdinclude $definclude" +case " $stdinclude " in +*\ $usrinclude\ *) + case $usrinclude in + /usr/include) + usrinclude= + ;; + *) case " $stdinclude " in + *\ /usr/include\ *) + usrinclude= + ;; + *) usrinclude=/usr/include + ;; + esac + ;; + esac + ;; +esac + +tstinclude=`$cc -v -E flags.$src 2>&1 | sed -e '1,/[iI][nN][cC][lL][uU][dD][eE][ ]*<[.][.][.]>/d' -e '/^[eE][nN][dD] [oO][fF] [sS][eE][aA][rR][cC][hH]/,\$d'` +j=$tstinclude +case $j in +*/*) ;; +*) j=$cmdinclude ;; +esac +tstinclude= +good= +nogood= +c_hdr="stdio.h ctype.h" +C_hdr="libc.h" +for i in $j +do if test -d "$i" + then tstinclude="$tstinclude $i" + h= + for f in $c_hdr + do if test -f "$i/$f" + then case $i in + */CC) nogood=1 ;; + *) good=1 ;; + esac + else h="$h $f" + fi + done + c_hdr=$h + h= + for f in $C_hdr + do if test -f "$i/$f" + then case $i in + */CC) nogood=1 ;; + *) good=1 ;; + esac + else h="$h $f" + fi + done + C_hdr=$h + fi +done +case $nogood in +1) good=0 ;; +esac +case $good in +1) case $c_hdr in + ?*) bad=1 + usrinclude=/usr/include + set '' $tstinclude /usr/include + ;; + *) set '' $tstinclude + ;; + esac + shift + stdinclude=$* + echo "#include <sys/types.h>" > include.$src + $cc -E include.$src | sed -e '/# 1 "[\\/]/!d' -e 's,[^"]*",,' -e 's,[\\/][^\\/]*".*,,' -e 's,[\\/]sys,,' > include.out + for f in `cat include.out` + do if test -d "$f" + then g=`echo $f | sed -e 's,[\\/][\\/]*[^\\/]*$,,'` + case " $stdinclude " in + *\ $f\ *|*\ $g\ *) + ;; + *) stdinclude="$stdinclude $f" + case $f in + /usr/include) usrinclude=$f ;; + esac + bad=1 + ;; + esac + fi + done + ;; +*) case $ppopt$ppenv in + ?*) echo '#!'$sh' + echo $VIRTUAL_ROOT | sed "s/:.*//"' > cpp + chmod +x cpp + ppcmd=cpp + ppdir=. + eval x='`'$ppenv '$'cc -E $ppopt flags.$src'`' + case $x in + ?*) tstinclude=$x/usr/include + ;; + esac + cp /bin/echo cpp + chmod u+w cpp + ;; + esac + + eval set x $probe_include + while : + do shift + case $# in + 0) break ;; + esac + echo "#include <$1>" > include.$src + $cc -E include.$src + done > include.out + + ccinclude= + x=$stdinclude + stdinclude= + subinclude= + for f in $x $tstinclude `sed -e 's,\\\\,/,g' -e 's,///*,/,g' -e 's,"[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]:/,"/,g' -e '/^#[line ]*[0123456789][0123456789]*[ ][ ]*"[\\/]/!d' -e 's/^#[line ]*[0123456789][0123456789]*[ ][ ]*"\(.*\)[\\/].*".*/\1/' include.out | sort -u` + do case $f in + -*) ;; + */) f=`echo $f | sed -e 's,//*\$,,'` ;; + */.) f=`echo $f | sed -e 's,//*.\$,,'` ;; + esac + case $f in + -I*) ;; + */cc) ccinclude=1 + ;; + */sys) continue + ;; + */include/*/*) + ;; + */include/*) + subinclude="$subinclude $f" + continue + ;; + esac + if test -d "$f" + then case " $stdinclude " in + *\ $f\ *) ;; + *) stdinclude="$stdinclude $f" ;; + esac + fi + done + rm include.out + case $ccinclude in + ?*) eval set x $probe_include + while : + do shift + case $# in + 0) break ;; + esac + echo "#include <cc/$1>" > include.$src + if $cc -E include.$src > /dev/null + then break + fi + done + case $# in + 0) ;; + *) x=$stdinclude + stdinclude= + for f in $x + do case $f in + */cc) ;; + *) stdinclude="$stdinclude $f" ;; + esac + done + ;; + esac + ;; + esac + case $subinclude in + ?*) for i in $subinclude + do for j in $stdinclude + do case $i in + $j/*/*) ;; + $j/*) both= + eval set x $probe_include + while : + do shift + case $# in + 0) for k in $both + do echo "#include <$k>" > include.$src + $cc -E include.$src > include.out + I=`grep -c $i/$k < include.out` + J=`grep -c $j/$k < include.out` + case $I:$J in + 0:*) ;; + *:0) stdinclude="$i $stdinclude" + break + ;; + esac + done + continue 3 + ;; + esac + if test -f $i/$1 + then if test ! -f $j/$1 + then break 2 + fi + both="$both $1" + fi + done + ;; + $j) continue 2 + ;; + esac + done + stdinclude="$i $stdinclude" + done + ;; + esac + + { + + for i in $stdinclude + do + case $i in + $usrinclude) ;; + *) echo $i $i ;; + esac + done + + eval set x $probe_include + while : + do shift + case $# in + 0) break ;; + esac + echo "#include <$1>" > t.c + p= + for j in `$cc -E t.c | grep "$1" | sed -e 's,\\\\,/,g' -e 's,"[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]:/,"/,g' -e '/^#[line ]*1[ ][ ]*"[\\/]/!d' -e 's/^#[line ]*1[ ][ ]*"\(.*\)[\\/].*".*/\1/'` + do j=`echo $j | sed -e 's,///*,/,g' -e 's,/$,,'` + case $p in + ?*) echo $p $j ;; + esac + p=$j + done + done + + case $usrinclude in + ?*) echo $usrinclude $usrinclude ;; + esac + + } | tsort > tmp.tmp + tstinclude=`cat tmp.tmp` + bad= + for i in $stdinclude + do case " +$tstinclude +" in + *" +$i +"*) ;; + *) bad=1 + break + ;; + esac + done + ;; +esac + +case $bad in +"") x=$stdinclude + stdinclude= + z= + for i in $tstinclude + do case " $x " in + *" $i "*) + stdinclude="$stdinclude $i" + z=$i + ;; + esac + done + case $usrinclude in + '') usrinclude=$z ;; + esac + ;; +esac +case $hosted in +"") case $usrinclude in + /usr/include) usrinclude= ;; + esac + ;; +esac + +case $usrinclude in +?*) case " $stdinclude " in + *\ $usrinclude\ *) + x=$stdinclude + stdinclude= + for f in $x + do case $f in + $usrinclude) ;; + *) stdinclude="$stdinclude $f" ;; + esac + done + ;; + esac + ;; +esac + +# drop dups -- they creep in somehow + +x=$stdinclude +stdinclude= +for f in $x +do case " $stdinclude $usrinclude " in + *" $f "*) ;; + *) stdinclude="$stdinclude $f" ;; + esac +done diff --git a/src/cmd/INIT/CONVERT.mk b/src/cmd/INIT/CONVERT.mk new file mode 100644 index 0000000..63a60ef --- /dev/null +++ b/src/cmd/INIT/CONVERT.mk @@ -0,0 +1,260 @@ +/* + * {automake|configure} => {nmake|iffe} conversion support + * + * The first command line target overrides the default original source + * directory name $(MAKEFILE:D). The hard work is in the makefile using + * these assertions, since it must (manually) provide the nmake makefiles + * and config equivalent iffe scripts. The conversion makefile is typically + * named lib/package/PACKAGE.cvt in an ast package $PACKAGEROOT directory, + * and the conversion is run from the $PACKAGEROOT directory, e.g.: + * + * nmake -I lib/package -f PACKAGE-VERSION/PACKAGE.cvt + * + * The conversion requires the ast nmake, pax and tw commands. + * + * After the conversion you will be liberated from ./configure, *.in, + * *.am, automake, autom4te, libtool, make depend, and makefile + * recursion ordering. You can build from $PACKAGEROOT using the ast + * package(1) (which sets up the { HOSTTYPE PATH VPATH } environment): + * + * package make + * + * or cd into any arch/$HOSTTYPE/src subdirectory and rebuild that portion + * of the hierarchy with the ast nmake(1) (after setting PATH and VPATH): + * + * nmake + * + * The conversion assertions are: + * + * package :CONVERT: file ... + * + * files in the original source directory are copied + * and converted into the ./src and ./lib subdirectories + * the default original source directory is ./original + * + * package package name + * file original source file that must exist + * + * :OMIT: pattern + * + * files matching pattern are not copied into the converted + * directory + * + * pattern ksh pattern of files to omit + * + * :COPY: from to [ file ... ] + * + * files in the from directory are copied to the to directory + * the action may contain :MOVE: exceptions to the copy + * + * from original directory subdirectory + * . names the original directory + * .. names the + * to converted subdirectory + * libNAME => src/lib/libNAME + * NAME => src/cmd/NAME + * file files or files in subdirectories to be copied; + * explicit files are copied to the to directory; + * if no files are specified then the from hierarchy + * is recursively copied to the converted directory + * + * :MOVE: to file ... + * + * :COPY: assertion exceptions placed in the assertion's action + * + * to files or subdirectory files are copied to this directory + * file file or files in subdirectories to be copied + * + * :FILE: to file <<! + * contents + * ! + * + * the :FILE: action is copied to the named file in the to directory + * the :FILE: action is usually specified using the here syntax to + * avoid make comment, quote and variable expansion + * + * :EDIT: to file ... | - pattern <<! + * edit script + * ! + * + * the :EDIT: action is an ed(1) script applied to each file in the + * to directory after it has been copied from the original source + * directory; if to is - then the :EDIT: action is a sed(1) script + * that is applied to all files matching the file pattern during the + * copy from the original source directory; a file may be subject to + * both a sed(1) and ed(1) :EDIT:; the :EDIT: action is usually + * specified using the here syntax to avoid make comment, quote and + * variable expansion + */ + +.CONVERT.ID. = "@(#)$Id: CONVERT (AT&T Research) 2004-03-19 $" + +set nojobs noscan nowriteobject writestate=$$(MAKEFILE).ms + +package = $(PWD:B) +here = !-=-=-=-=-! +hierarchy = src src/cmd src/lib +omit = .*|*.?(l)[ao] +original = $(MAKEFILE:D) +showedit = $(-debug:?p??) + +CPFLAGS = -u +PAXFLAGS = -u -v +STDEDFLAGS = - +TW = tw +TWFLAGS = -CP + +all : .VIRTUAL file +file : .VIRTUAL edit +edit : .VIRTUAL copy +copy : .VIRTUAL init +init : .VIRTUAL + +.MAKEINIT : .cvt.init + +.cvt.init : .MAKE .VIRTUAL .FORCE + local D + if D = "$(~.ARGS:O=1)" + if "$(D:T>FD)" + original := $(D) + .ARGS : .CLEAR $(~.ARGS:O>1) + end + end + +.cvt.filter = +.cvt.package = + +.cvt.atom : .FUNCTION + local N V + V := $(%:O=1) + let .cvt.$(V) = .cvt.$(V) + 1 + return .cvt.$(V).$(.cvt.$(V)) + +.cvt.omit : .FUNCTION + return -s',^\(\(?K)?(*/)($(omit))?(/*))$,,$(showedit)' + +.cvt.to : .FUNCTION + if "$(%)" == "." + return src + end + if "$(%)" == "*/*" + return src/$(%) + end + if "$(%)" == "lib*" + return src/lib/$(%) + end + return src/cmd/$(%) + +":CONVERT:" : .MAKE .OPERATOR + local I + package := $(<) + I := $(hierarchy:C,$,/Makefile) + init : .cvt.verify $(I) + $(I) : .ACCEPT + test -d $(<:D) || $(MKDIR) -p $(<:D) + echo :MAKE: > $(<) + .cvt.verify : .MAKE .FORCE .REPEAT + local I + if I = "$(.cvt.package:T!=F)" + error 3 $(original): not a $(package) source directory: missing $(I) + end + .cvt.package := $(>:C,^,$$(original)/,) + +":COPY:" : .MAKE .OPERATOR + local F T I A + F := $(>:O=1) + T := $(.cvt.to $(>:O=2)) + A := $(.cvt.atom copy) + copy : $(A) + $(A) : .VIRTUAL + if F == "." + $(A) : $(T) + $(T) : + test -d $(<) || $(MKDIR) -p $(<) + for I $(>:O>2) + eval + $$(A) : $(I:D=$(T):B:S) + $(I:D=$(T):B:S) : $$(original)/$(I) + $$(CP) $$(CPFLAGS) $$(*) $$(<) + end + end + elif "$(F:T=FF)" || "$(F:N=*.(pax|t[bg]z))" + eval + $$(A) : $$(F) + test -d $(T) || $$(MKDIR) -p $(T) + cd $(T) + $$(PAX) $$(PAXFLAGS) -rf $$(*:P=A) -s ',^$(>:O=2)/*,,' $(.cvt.omit) $(.cvt.filter) + end + else + F := $$(original)/$(F) + if ! "$(@:V)" + eval + $$(A) : .FORCE + test -d $(T) || $$(MKDIR) -p $(T) + cd $(F:V) + $$(TW) $$(TWFLAGS) | $$(PAX) $$(PAXFLAGS) -rw $(.cvt.omit) $(.cvt.filter) $(T:P=A) + end + else + .cvt.move = + : $(@:V:@R) + eval + $$(A) : .FORCE + test -d $(T) || $$(MKDIR) -p $(T) + cd $(F:V) + $$(TW) $$(TWFLAGS) | $$(PAX) $$(PAXFLAGS) -rw $(.cvt.omit) $(.cvt.move) $(.cvt.filter) $(T:P=A) + end + end + end + +":EDIT:" : .MAKE .OPERATOR + local A D F + D := $(>:O=1) + if D == "-" + A := ^$(>:O=2)^$$(SED) -e $(@:Q:/'\n'/ -e /G) + .cvt.filter += --action=$(A:@Q) + else + D := $(.cvt.to $(D)) + F := $(>:O>1:C,^,$(D)/,) + edit : $(F) + eval + $$(F) : + $$(STDED) $$(STDEDFLAGS) $$(<) <<'$(here)' + $(@:V) + w + q + $(here) + end + end + +":FILE:" : .MAKE .OPERATOR + local ( D F ) $(>) + local A + A := $(.cvt.atom file) + $(A) := $(@:V) + D := $(.cvt.to $(D)) + file : $(D)/$(F) + eval + $$(D)/$$(F) : + test -d $$(<:D) || $$(MKDIR) -p $$(<:D) + cat > $$(<) <<'$(here)' + $$($(A):V) + $(here) + end + +":MOVE:" : .MAKE .OPERATOR + local T I + T := ../../../$(.cvt.to $(>:O=1)) + for I $(>:O>1) + if I == "*/" + .cvt.move += -s',^\(\(?K)$(I)),$(T)/,$(showedit)' + .cvt.move += -s',^\(\(?K)$(I:C%/$%%))$,,$(showedit)' + else + .cvt.move += -s',^\(\(?K)$(I))$,$(T)/$(I:B:S),$(showedit)' + end + end + +":OMIT:" : .MAKE .OPERATOR + local P + for P $(>) + omit := $(omit)|$(P) + end diff --git a/src/cmd/INIT/MAPLIB.mk b/src/cmd/INIT/MAPLIB.mk new file mode 100644 index 0000000..5761035 --- /dev/null +++ b/src/cmd/INIT/MAPLIB.mk @@ -0,0 +1,45 @@ +/* + * normalize local -l* library conventions + * + * L [ [ G11 ... G1n ] ... [ Gg1 ... Ggn ] ] :MAPLIB: T1.c ... Tn.c + * + * if Giji not specified then G11 == L + * the first Ti.c that compiles/links with group -lGi1 ... -lGin + * but does not compile/link with no libraries maps + * -lL to to require -lGi1 ... -lGin + * otherwise -lL is not required and maps to "no library required" + */ + +":MAPLIB:" : .MAKE .OPERATOR + local L P + L := $(<:B:O=1) + if ! ( P = "$(<:B:O>1)" ) + P := $(L) + end + $(LIBDIR)/lib/$(L) :INSTALL: $(L).req + eval + $(L).req : (CC) $$(>) + set - + r='-' + for i in $$(*) + do if $$(CC) -c $i > /dev/null + then g= + for p in $(P) - + do case $p in + -) if $$(CC) -o $$(<:B:S=.exe) $i $g > /dev/null 2>&1 + then $$(CC) -o $$(<:B:S=.exe) $i > /dev/null 2>&1 || { + r="$g" + break 2 + } + fi + g= + ;; + *) g="$g -l$p" + ;; + esac + done + fi + done 2>/dev/null + echo " $r" > $$(<) + rm -f $$(<:B:S=.exe) $$(*:B:S=$$(CC.SUFFIX.OBJECT)) + end diff --git a/src/cmd/INIT/MSGFUN.mk b/src/cmd/INIT/MSGFUN.mk new file mode 100644 index 0000000..0888d00 --- /dev/null +++ b/src/cmd/INIT/MSGFUN.mk @@ -0,0 +1,2 @@ +/* stub for pre-2000-05-01 nmake */ +":MSGFUN:" : .MAKE .OPERATOR diff --git a/src/cmd/INIT/MSGKEY.mk b/src/cmd/INIT/MSGKEY.mk new file mode 100644 index 0000000..db18559 --- /dev/null +++ b/src/cmd/INIT/MSGKEY.mk @@ -0,0 +1,2 @@ +/* stub for pre-2000-05-01 nmake */ +":MSGKEY:" : .MAKE .OPERATOR diff --git a/src/cmd/INIT/Makefile b/src/cmd/INIT/Makefile new file mode 100644 index 0000000..b1af6aa --- /dev/null +++ b/src/cmd/INIT/Makefile @@ -0,0 +1,293 @@ +/* + * initialization for all packages + */ + +:PACKAGE: license=ast + +LICENSE = since=1994,author=gsf + +PACKAGEROOT = $(INSTALLROOT:T=F:P=L*:O=n) + +hurl :: hurl.sh LICENSE=since=2003,author=gsf + +iffe :: iffe.sh LICENSE=since=1994,author=gsf+kpv + +mktest :: mktest.sh LICENSE=since=2005,author=gsf + +package :: package.sh + +regress :: regress.sh LICENSE=since=1995,author=gsf + +rt :: rt.sh LICENSE=since=2005,author=gsf + +$(PACKAGEROOT)/bin :INSTALLDIR: execrate ignore mamprobe package silent + +crossexec :: crossexec.sh + +ditto :: ditto.sh LICENSE=since=2001,author=gsf+ek + +execrate :: execrate.sh LICENSE=since=2002,author=gsf + +filter :: filter.sh + +ignore :: ignore.sh + +silent :: silent.sh + +$(PACKAGEROOT)/lib/package :INSTALLDIR: package.mk CONVERT.mk + +$(LIBDIR)/make :INSTALLDIR: package.mk PROBE.mk TEST.mk WWW.mk \ + MSGFUN.mk MSGKEY.mk MAPLIB.mk + +:TEST: iffe mamake + +cc ld ldd :PACKAGE_INIT: mamake.c proto.c ratz.c release.c + +:: RELEASE hosttype.tst p.c hello.c \ + ar.ibm.risc \ + cc.specialize cc.pentium4 \ + ldd.cygwin.i386 \ + cc.darwin.i386 cc.darwin.i386-64 cc.darwin ldd.darwin \ + cc.hp.ia64 cc.hp.pa cc.hp.pa64 ld.hp.pa ldd.hp.pa \ + cc.ibm.risc cc.ibm.risc.gcc ldd.ibm.risc \ + cc.linux.ia64-icc cc.linux.i386-icc cc.linux.i386-64-icc \ + cc.lynxos.i386 cc.lynxos.ppc ldd.lynxos \ + cc.mvs.390 cc.next.i386 cc.next.m68k ldd.mvs.390 \ + cc.osf.alpha \ + cc.sco.i386 \ + cc.sgi.mips2 cc.sgi.mips3 cc.sgi.mips3-o32 cc.sgi.mips4 \ + cc.sgi.mips4-n32 ldd.sgi \ + cc.unix.mc68k + +LICENSE : .DONTCARE + +if ! CC.HOSTTYPE + CC.HOSTTYPE := $(_hosttype_|HOSTTYPE) +end + +$(BINDIR)/mkdir :INSTALL: mkdir.sh + if test ! -x $(<) -a -x /bin/mkdir + then mkdir -p 2>/dev/null || : + if test -d ./-p + then rmdir ./-p + cp $(*) $(<) + chmod +x $(<) + fi + fi + +/* + * ksh93 function search on PATH + * ksh93 builtin command library -lcmd + * ksh93 ld library path search on PATH + */ + +$(BINDIR)/.paths :INSTALL: (CC.DIALECT) + if test ! -f $(<) -o -w $(<) + then nl=" +" + o=`cat $(<) 2>/dev/null` || : + v= + n= + case $nl$o in + *${nl}FPATH=*|*#FPATH=*|*[Nn][Oo]FPATH=*) + ;; + *) case $n in + '') ;; + *) n="$n$nl" v="$v|" ;; + esac + n="${n}FPATH=../fun" + v="${v}FPATH" + ;; + esac + case $nl$o in + *${nl}BUILTIN_LIB=*|*#BUILTIN_LIB=*|*[Nn][Oo]BUILTIN_LIB=*) + ;; + *) case $n in + '') ;; + *) n="$n$nl" v="$v|" ;; + esac + case '$(CC.DIALECT:N=*EXPORT=[AD]LL*)' in + ?*) p= c= ;; + *) p='XX' ;; + esac + n="${n}${p}BUILTIN_LIB=cmd" + v="${v}BUILTIN_LIB" + ;; + esac + set x x : $(-mam:??$(.GETCONF LIBPATH:/:/ /G:/,/ : /G:Q)?) + p= + while : + do while : + do case $# in + 0) break ;; + esac + x=$1 + shift + case $x in + :) break ;; + esac + done + case $# in + 0|1) break + ;; + 2) p=$2 + ;; + *) case "$(CC.HOSTTYPE)" in + $3) p=$2; break ;; + esac + ;; + esac + done + case $p in + '') if test -x /lib/dld.sl + then p=SHLIB_PATH + elif test -x /usr/lib/dyld + then p=DYLD_LIBRARY_PATH + else case "$(CC.HOSTTYPE)" in + ibm.*|mvs.*) + p=LIBPATH + ;; + sgi.mips3) + p=LD_LIBRARYN32_PATH + ;; + sgi.mips4) + p=LD_LIBRARYN64_PATH + ;; + *) p=LD_LIBRARY_PATH + ;; + esac + fi + ;; + esac + case $nl$o in + *${nl}${p}=*|*#${p}=*|*[Nn][Oo]${p}=*) + ;; + *) case $n in + '') ;; + *) n="$n$nl" v="$v|" ;; + esac + n="${n}${p}=../lib" + v="${v}${p}" + ;; + esac + case $n in + ?*) case $o in + ?*) o=`egrep -v "($v)=" $(<)`$nl ;; + esac + echo "# use { # no NO } prefix instead of XX to permanently disable #$nl$o$n" > $(<) + ;; + esac + fi + +/* + * probe initialization + */ + +for T C+probe C+make+probe.lcl C+pp+probe.lcl + if T == "*.lcl" + $(T) : .DONTCARE + end + $(LIBDIR)/probe/$(T:C,+,/,G) :INSTALL: $(T) +end + +$(LIBDIR)/probe/C/mam/probe :INSTALL: mprobe + +mprobe :: mprobe.sh + +$(LIBDIR)/probe/C/make :INSTALLDIR: probe probe.ini + +probe.sh : C+probe make.probe + cat $(*) > $(<) + +probe :: probe.sh + +probe.ini : (CC.HOSTTYPE) probe.win32 + t=$(CC.HOSTTYPE) + ifs=$IFS + IFS=. + set x $t + IFS=$ifs + t=$2 + set x $(*) + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + *probe.$t) + break + esac + done + case $1 in + ?*) cmp -s $1 $(<) || cp $1 $(<) ;; + *) : > $(<) + esac + +/* + * proto initialization + */ + +$(INCLUDEDIR) :INSTALLDIR: prototyped.h + +prototyped.h : $(BINDIR)/proto + proto -f /dev/null > h.$(tmp).h + if $(CMP) -s h.$(tmp).h $(<) + then $(RM) -f h.$(tmp).h + else $(MV) h.$(tmp).h $(<) + fi + +/* + * check if -ldl is required + * this allows makefiles to use -ldl on all systems + * + * NOTE: this works around the sgi botch: + * (1) irix 5.* made -ldl optional but warned + * (2) irix 6.* has no -ldl + * (3) dynamic progs built on irix 5.* and using -ldl fail + * at runtime on irix 6.* because -ldl is not there + */ + +dl :MAPLIB: dl.c + +/* + * requiring these is a botch + */ + +iconv :MAPLIB: iconv.c + +w :MAPLIB: w.c w2.c + +/* + * miscellaneous -l* checks + */ + +intl :MAPLIB: intl.c + +m :MAPLIB: m.c m2.c m3.c m4.c m5.c m6.c + +nsl :MAPLIB: nsl.c + +/* + * what was sco smoking + * almost all of gethost* are in -lnsl except gethostbyname which + * is in -lsocket which isn't needed to resolve socket() but seems + * to do the -lnsl job + */ + +socket :MAPLIB: socket.c nsl.c + +/* + * more substance abuse + * gdbm's ndbm "compatibility" doesn't supply <ndbm.h>, instead supplies + * <gdbm/ndbm.h> which provides K&R prototypes *and* it requires -lgdbm + * some <ndbm.h> implementations use -lndbm, others -ldbm, still others -lc + * this is why unix is starting to look like windows + * this map allows makefiles to use -ldbm on all systems + * + * and this just in: sometimes its <gdbm-ndbm.h> and possibly -lgdbm_compat + * + * at least the -l* buck stops here + */ + +dbm db - gdbm_compat - gdbm - ndbm - dbm :MAPLIB: db.c gdbm.c gdbm1.c gdbm2.c diff --git a/src/cmd/INIT/Mamfile b/src/cmd/INIT/Mamfile new file mode 100644 index 0000000..e5826d2 --- /dev/null +++ b/src/cmd/INIT/Mamfile @@ -0,0 +1,1332 @@ +info mam static 00000 1994-07-17 make (AT&T Research) 5.7 2012-02-29 +setv INSTALLROOT ../../.. +setv PACKAGEROOT ../../../../.. +setv AR ${mam_cc_AR} ${mam_cc_AR_ARFLAGS} +setv ARFLAGS rc +setv AS as +setv ASFLAGS +setv CC cc +setv mam_cc_FLAGS +setv CCFLAGS ${-debug-symbols?1?${mam_cc_DEBUG} -D_BLD_DEBUG?${mam_cc_OPTIMIZE}?} +setv CCLDFLAGS ${-strip-symbols?1?${mam_cc_LD_STRIP}??} +setv COTEMP $$ +setv CPIO cpio +setv CPIOFLAGS +setv CPP "${CC} -E" +setv F77 f77 +setv HOSTCC ${CC} +setv IGNORE +setv LD ld +setv LDFLAGS +setv LEX lex +setv LEXFLAGS +setv LPR lpr +setv LPRFLAGS +setv M4FLAGS +setv NMAKE nmake +setv NMAKEFLAGS +setv PR pr +setv PRFLAGS +setv SHELL /bin/sh +setv SILENT +setv TAR tar +setv YACC yacc +setv YACCFLAGS -d +make ${PACKAGEROOT}/lib/package/ast.lic +done ${PACKAGEROOT}/lib/package/ast.lic +make install +make hurl +make hurl.sh +done hurl.sh +meta hurl %.sh>% hurl.sh hurl +prev hurl.sh +setv LICENSE -DLICENSE="since=2003,author=gsf" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : hurl contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n hurl.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp hurl.sh hurl +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < hurl.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - hurl.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2003-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > hurl +exec - ;; +exec - esac +exec - ;; +exec - *) cat - hurl.sh > hurl <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2003-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w hurl -a -x hurl || chmod u+w,+x hurl +done hurl generated +make iffe +make iffe.sh +done iffe.sh +meta iffe %.sh>% iffe.sh iffe +prev iffe.sh +setv LICENSE -DLICENSE="since=1994,author=gsf+kpv" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : iffe contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n iffe.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 241 in +exec - 0) cp iffe.sh iffe +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < iffe.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - iffe.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-author?Phong Vo <kpv@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > iffe +exec - ;; +exec - esac +exec - ;; +exec - *) cat - iffe.sh > iffe <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-author?Phong Vo <kpv@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w iffe -a -x iffe || chmod u+w,+x iffe +done iffe generated +make mktest +make mktest.sh +done mktest.sh +meta mktest %.sh>% mktest.sh mktest +prev mktest.sh +setv LICENSE -DLICENSE="since=2005,author=gsf" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : mktest contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n mktest.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp mktest.sh mktest +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < mktest.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - mktest.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2005-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > mktest +exec - ;; +exec - esac +exec - ;; +exec - *) cat - mktest.sh > mktest <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2005-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w mktest -a -x mktest || chmod u+w,+x mktest +done mktest generated +make package +make package.sh +done package.sh +meta package %.sh>% package.sh package +prev package.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : package contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n package.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp package.sh package +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < package.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - package.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > package +exec - ;; +exec - esac +exec - ;; +exec - *) cat - package.sh > package <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w package -a -x package || chmod u+w,+x package +done package generated +make regress +make regress.sh +done regress.sh +meta regress %.sh>% regress.sh regress +prev regress.sh +setv LICENSE -DLICENSE="since=1995,author=gsf" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : regress contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n regress.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp regress.sh regress +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < regress.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - regress.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1995-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > regress +exec - ;; +exec - esac +exec - ;; +exec - *) cat - regress.sh > regress <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1995-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w regress -a -x regress || chmod u+w,+x regress +done regress generated +make rt +make rt.sh +done rt.sh +meta rt %.sh>% rt.sh rt +prev rt.sh +setv LICENSE -DLICENSE="since=2005,author=gsf" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : rt contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n rt.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp rt.sh rt +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < rt.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - rt.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2005-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > rt +exec - ;; +exec - esac +exec - ;; +exec - *) cat - rt.sh > rt <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2005-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w rt -a -x rt || chmod u+w,+x rt +done rt generated +make crossexec +make crossexec.sh +done crossexec.sh +meta crossexec %.sh>% crossexec.sh crossexec +prev crossexec.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : crossexec contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n crossexec.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp crossexec.sh crossexec +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < crossexec.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - crossexec.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > crossexec +exec - ;; +exec - esac +exec - ;; +exec - *) cat - crossexec.sh > crossexec <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w crossexec -a -x crossexec || chmod u+w,+x crossexec +done crossexec generated +make ditto +make ditto.sh +done ditto.sh +meta ditto %.sh>% ditto.sh ditto +prev ditto.sh +setv LICENSE -DLICENSE="since=2001,author=gsf+ek" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : ditto contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n ditto.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 248 in +exec - 0) cp ditto.sh ditto +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < ditto.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - ditto.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-author?Lefty Koutsofios <ek@research.att.com>][-copyright?Copyright (c) 2001-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > ditto +exec - ;; +exec - esac +exec - ;; +exec - *) cat - ditto.sh > ditto <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-author?Lefty Koutsofios <ek@research.att.com>][-copyright?Copyright (c) 2001-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w ditto -a -x ditto || chmod u+w,+x ditto +done ditto generated +make execrate +make execrate.sh +done execrate.sh +meta execrate %.sh>% execrate.sh execrate +prev execrate.sh +setv LICENSE -DLICENSE="since=2002,author=gsf" +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : execrate contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n execrate.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp execrate.sh execrate +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < execrate.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - execrate.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2002-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > execrate +exec - ;; +exec - esac +exec - ;; +exec - *) cat - execrate.sh > execrate <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 2002-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w execrate -a -x execrate || chmod u+w,+x execrate +done execrate generated +make filter +make filter.sh +done filter.sh +meta filter %.sh>% filter.sh filter +prev filter.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : filter contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n filter.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 200 in +exec - 0) cp filter.sh filter +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < filter.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - filter.sh <<'!' +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - } > filter +exec - ;; +exec - esac +exec - ;; +exec - *) cat - filter.sh > filter <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - USAGE_LICENSE="[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]" +exec - ! +exec - ;; +exec - esac +exec - silent test -w filter -a -x filter || chmod u+w,+x filter +done filter generated +make ignore +make ignore.sh +done ignore.sh +meta ignore %.sh>% ignore.sh ignore +prev ignore.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : ignore contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n ignore.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 0 in +exec - 0) cp ignore.sh ignore +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < ignore.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - ignore.sh <<'!' +exec - +exec - ! +exec - } > ignore +exec - ;; +exec - esac +exec - ;; +exec - *) cat - ignore.sh > ignore <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - +exec - ! +exec - ;; +exec - esac +exec - silent test -w ignore -a -x ignore || chmod u+w,+x ignore +done ignore generated +make silent +make silent.sh +done silent.sh +meta silent %.sh>% silent.sh silent +prev silent.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : silent contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n silent.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 0 in +exec - 0) cp silent.sh silent +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < silent.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - silent.sh <<'!' +exec - +exec - ! +exec - } > silent +exec - ;; +exec - esac +exec - ;; +exec - *) cat - silent.sh > silent <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - +exec - ! +exec - ;; +exec - esac +exec - silent test -w silent -a -x silent || chmod u+w,+x silent +done silent generated +make mamake +make mamake.o +make mamake.c +make shlib-compat.h implicit +done shlib-compat.h dontcare virtual +make ast.h implicit +done ast.h dontcare virtual +done mamake.c +meta mamake.o %.c>%.o mamake.c mamake +prev mamake.c +exec - ${CC} ${mam_cc_FLAGS} ${CCFLAGS} -DUSAGE_LICENSE=\""[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]"\" -c mamake.c +done mamake.o generated +exec - ${CC} ${CCLDFLAGS} ${mam_cc_FLAGS} ${CCFLAGS} ${LDFLAGS} -o mamake mamake.o +done mamake generated +make proto +make proto.o +make proto.c +done proto.c +meta proto.o %.c>%.o proto.c proto +prev proto.c +exec - ${CC} ${mam_cc_FLAGS} ${CCFLAGS} -c proto.c +done proto.o generated +exec - ${CC} ${CCLDFLAGS} ${mam_cc_FLAGS} ${CCFLAGS} ${LDFLAGS} -o proto proto.o +done proto generated +make ratz +make ratz.o +make ratz.c +make unix.h implicit +done unix.h dontcare virtual +make alloc.h implicit +done alloc.h dontcare virtual +make unixio.h implicit +done unixio.h dontcare virtual +make ast_std.h implicit +done ast_std.h dontcare virtual +make windows.h implicit +done windows.h dontcare virtual +make io.h implicit +done io.h dontcare virtual +make direct.h implicit +done direct.h dontcare virtual +prev ast.h implicit +done ratz.c +meta ratz.o %.c>%.o ratz.c ratz +prev ratz.c +exec - ${CC} ${mam_cc_FLAGS} ${CCFLAGS} -c ratz.c +done ratz.o generated +exec - ${CC} ${CCLDFLAGS} ${mam_cc_FLAGS} ${CCFLAGS} ${LDFLAGS} -o ratz ratz.o +done ratz generated +make release +make release.o +make release.c +prev ast.h implicit +done release.c +meta release.o %.c>%.o release.c release +prev release.c +exec - ${CC} ${mam_cc_FLAGS} ${CCFLAGS} -DUSAGE_LICENSE=\""[-author?Glenn Fowler <gsf@research.att.com>][-copyright?Copyright (c) 1994-2012 AT&T Intellectual Property][-license?http://www.eclipse.org/org/documents/epl-v10.html][--catalog?INIT]"\" -c release.c +done release.o generated +exec - ${CC} ${CCLDFLAGS} ${mam_cc_FLAGS} ${CCFLAGS} ${LDFLAGS} -o release release.o +done release generated +make mprobe +make mprobe.sh +done mprobe.sh +meta mprobe %.sh>% mprobe.sh mprobe +prev mprobe.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : mprobe contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n mprobe.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 0 in +exec - 0) cp mprobe.sh mprobe +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < mprobe.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - mprobe.sh <<'!' +exec - +exec - ! +exec - } > mprobe +exec - ;; +exec - esac +exec - ;; +exec - *) cat - mprobe.sh > mprobe <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - +exec - ! +exec - ;; +exec - esac +exec - silent test -w mprobe -a -x mprobe || chmod u+w,+x mprobe +done mprobe generated +make probe +make probe.sh +make C+probe +done C+probe +make make.probe +done make.probe +exec - cat C+probe make.probe > probe.sh +done probe.sh generated +meta probe %.sh>% probe.sh probe +prev probe.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : probe contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n probe.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 0 in +exec - 0) cp probe.sh probe +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < probe.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - probe.sh <<'!' +exec - +exec - ! +exec - } > probe +exec - ;; +exec - esac +exec - ;; +exec - *) cat - probe.sh > probe <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - +exec - ! +exec - ;; +exec - esac +exec - silent test -w probe -a -x probe || chmod u+w,+x probe +done probe generated +make ${INSTALLROOT}/bin +exec - if silent test ! -d ${INSTALLROOT}/bin +exec - then mkdir -p ${INSTALLROOT}/bin +exec - fi +done ${INSTALLROOT}/bin generated +make ${INSTALLROOT}/bin/hurl +prev ${INSTALLROOT}/bin +prev hurl +exec - test '' = 'hurl' || ${STDCMP} 2>/dev/null -s hurl ${INSTALLROOT}/bin/hurl || { ${STDMV} ${INSTALLROOT}/bin/hurl ${INSTALLROOT}/bin/hurl.old 2>/dev/null || true; ${STDCP} hurl ${INSTALLROOT}/bin/hurl ;} +done ${INSTALLROOT}/bin/hurl generated +make ${INSTALLROOT}/bin/iffe +prev iffe +exec - test '' = 'iffe' || ${STDCMP} 2>/dev/null -s iffe ${INSTALLROOT}/bin/iffe || { ${STDMV} ${INSTALLROOT}/bin/iffe ${INSTALLROOT}/bin/iffe.old 2>/dev/null || true; ${STDCP} iffe ${INSTALLROOT}/bin/iffe ;} +done ${INSTALLROOT}/bin/iffe generated +make ${INSTALLROOT}/bin/mktest +prev mktest +exec - test '' = 'mktest' || ${STDCMP} 2>/dev/null -s mktest ${INSTALLROOT}/bin/mktest || { ${STDMV} ${INSTALLROOT}/bin/mktest ${INSTALLROOT}/bin/mktest.old 2>/dev/null || true; ${STDCP} mktest ${INSTALLROOT}/bin/mktest ;} +done ${INSTALLROOT}/bin/mktest generated +make ${INSTALLROOT}/bin/package +prev package +exec - test '' = 'package' || ${STDCMP} 2>/dev/null -s package ${INSTALLROOT}/bin/package || { ${STDMV} ${INSTALLROOT}/bin/package ${INSTALLROOT}/bin/package.old 2>/dev/null || true; ${STDCP} package ${INSTALLROOT}/bin/package ;} +done ${INSTALLROOT}/bin/package generated +make ${INSTALLROOT}/bin/regress +prev regress +exec - test '' = 'regress' || ${STDCMP} 2>/dev/null -s regress ${INSTALLROOT}/bin/regress || { ${STDMV} ${INSTALLROOT}/bin/regress ${INSTALLROOT}/bin/regress.old 2>/dev/null || true; ${STDCP} regress ${INSTALLROOT}/bin/regress ;} +done ${INSTALLROOT}/bin/regress generated +make ${INSTALLROOT}/bin/rt +prev rt +exec - test '' = 'rt' || ${STDCMP} 2>/dev/null -s rt ${INSTALLROOT}/bin/rt || { ${STDMV} ${INSTALLROOT}/bin/rt ${INSTALLROOT}/bin/rt.old 2>/dev/null || true; ${STDCP} rt ${INSTALLROOT}/bin/rt ;} +done ${INSTALLROOT}/bin/rt generated +make ${PACKAGEROOT}/bin +exec - if silent test ! -d ${PACKAGEROOT}/bin +exec - then mkdir -p ${PACKAGEROOT}/bin +exec - fi +done ${PACKAGEROOT}/bin generated +make ${PACKAGEROOT}/bin/execrate +prev ${PACKAGEROOT}/bin +prev execrate +exec - test '' = 'execrate' || ${STDCMP} 2>/dev/null -s execrate ${PACKAGEROOT}/bin/execrate || { ${STDMV} ${PACKAGEROOT}/bin/execrate ${PACKAGEROOT}/bin/execrate.old 2>/dev/null || true; ${STDCP} execrate ${PACKAGEROOT}/bin/execrate ;} +done ${PACKAGEROOT}/bin/execrate generated +make ${PACKAGEROOT}/bin/ignore +prev ignore +exec - test '' = 'ignore' || ${STDCMP} 2>/dev/null -s ignore ${PACKAGEROOT}/bin/ignore || { ${STDMV} ${PACKAGEROOT}/bin/ignore ${PACKAGEROOT}/bin/ignore.old 2>/dev/null || true; ${STDCP} ignore ${PACKAGEROOT}/bin/ignore ;} +done ${PACKAGEROOT}/bin/ignore generated +make ${PACKAGEROOT}/bin/mamprobe +make mamprobe +meta mamprobe %.sh>% mamprobe.sh mamprobe +make mamprobe.sh +done mamprobe.sh +exec - case static,port:$OPTIND:$RANDOM in +exec - ?*:*:*|*::*|*:*:$RANDOM) +exec - ;; +exec - *) if ENV= LC_ALL=C x= $SHELL -nc '[[ a || b ]] && : ${list[level]} !(pattern)' 2>/dev/null +exec - then if grep -q '### .*archaic.* ###' +exec - then : mamprobe contains archaic constructs : +exec - else ENV= LC_ALL=C $SHELL -n mamprobe.sh +exec - fi +exec - fi +exec - ;; +exec - esac +exec - case '${mam_cc_SHELLMAGIC}' in +exec - "") case 0 in +exec - 0) cp mamprobe.sh mamprobe +exec - ;; +exec - *) { +exec - i=`(read x; echo $x) < mamprobe.sh` +exec - case $i in +exec - '#!'*|*'||'*|':'*|'":"'*|"':'"*) echo "$i" ;; +exec - esac +exec - cat - mamprobe.sh <<'!' +exec - +exec - ! +exec - } > mamprobe +exec - ;; +exec - esac +exec - ;; +exec - *) cat - mamprobe.sh > mamprobe <<'!' +exec - ${mam_cc_SHELLMAGIC} +exec - +exec - ! +exec - ;; +exec - esac +exec - silent test -w mamprobe -a -x mamprobe || chmod u+w,+x mamprobe +done mamprobe generated +exec - test '' = 'mamprobe' || ${STDCMP} 2>/dev/null -s mamprobe ${PACKAGEROOT}/bin/mamprobe || { ${STDMV} ${PACKAGEROOT}/bin/mamprobe ${PACKAGEROOT}/bin/mamprobe.old 2>/dev/null || true; ${STDCP} mamprobe ${PACKAGEROOT}/bin/mamprobe ;} +done ${PACKAGEROOT}/bin/mamprobe generated +make ${PACKAGEROOT}/bin/package +prev package +exec - test '' = 'package' || ${STDCMP} 2>/dev/null -s package ${PACKAGEROOT}/bin/package || { ${STDMV} ${PACKAGEROOT}/bin/package ${PACKAGEROOT}/bin/package.old 2>/dev/null || true; ${STDCP} package ${PACKAGEROOT}/bin/package ;} +done ${PACKAGEROOT}/bin/package generated +make ${PACKAGEROOT}/bin/silent +prev silent +exec - test '' = 'silent' || ${STDCMP} 2>/dev/null -s silent ${PACKAGEROOT}/bin/silent || { ${STDMV} ${PACKAGEROOT}/bin/silent ${PACKAGEROOT}/bin/silent.old 2>/dev/null || true; ${STDCP} silent ${PACKAGEROOT}/bin/silent ;} +done ${PACKAGEROOT}/bin/silent generated +make ${INSTALLROOT}/bin/crossexec +prev crossexec +exec - test '' = 'crossexec' || ${STDCMP} 2>/dev/null -s crossexec ${INSTALLROOT}/bin/crossexec || { ${STDMV} ${INSTALLROOT}/bin/crossexec ${INSTALLROOT}/bin/crossexec.old 2>/dev/null || true; ${STDCP} crossexec ${INSTALLROOT}/bin/crossexec ;} +done ${INSTALLROOT}/bin/crossexec generated +make ${INSTALLROOT}/bin/ditto +prev ditto +exec - test '' = 'ditto' || ${STDCMP} 2>/dev/null -s ditto ${INSTALLROOT}/bin/ditto || { ${STDMV} ${INSTALLROOT}/bin/ditto ${INSTALLROOT}/bin/ditto.old 2>/dev/null || true; ${STDCP} ditto ${INSTALLROOT}/bin/ditto ;} +done ${INSTALLROOT}/bin/ditto generated +make ${INSTALLROOT}/bin/filter +prev filter +exec - test '' = 'filter' || ${STDCMP} 2>/dev/null -s filter ${INSTALLROOT}/bin/filter || { ${STDMV} ${INSTALLROOT}/bin/filter ${INSTALLROOT}/bin/filter.old 2>/dev/null || true; ${STDCP} filter ${INSTALLROOT}/bin/filter ;} +done ${INSTALLROOT}/bin/filter generated +make ${PACKAGEROOT}/lib/package +exec - if silent test ! -d ${PACKAGEROOT}/lib/package +exec - then mkdir -p ${PACKAGEROOT}/lib/package +exec - fi +done ${PACKAGEROOT}/lib/package generated +make ${PACKAGEROOT}/lib/package/package.mk +prev ${PACKAGEROOT}/lib/package +make package.mk +done package.mk +exec - test '' = 'package.mk' || ${STDCMP} 2>/dev/null -s package.mk ${PACKAGEROOT}/lib/package/package.mk || { ${STDMV} ${PACKAGEROOT}/lib/package/package.mk ${PACKAGEROOT}/lib/package/package.mk.old 2>/dev/null || true; ${STDCP} package.mk ${PACKAGEROOT}/lib/package/package.mk ;} +done ${PACKAGEROOT}/lib/package/package.mk generated +make ${PACKAGEROOT}/lib/package/CONVERT.mk +make CONVERT.mk +done CONVERT.mk +exec - test '' = 'CONVERT.mk' || ${STDCMP} 2>/dev/null -s CONVERT.mk ${PACKAGEROOT}/lib/package/CONVERT.mk || { ${STDMV} ${PACKAGEROOT}/lib/package/CONVERT.mk ${PACKAGEROOT}/lib/package/CONVERT.mk.old 2>/dev/null || true; ${STDCP} CONVERT.mk ${PACKAGEROOT}/lib/package/CONVERT.mk ;} +done ${PACKAGEROOT}/lib/package/CONVERT.mk generated +make ${INSTALLROOT}/lib/make +exec - if silent test ! -d ${INSTALLROOT}/lib/make +exec - then mkdir -p ${INSTALLROOT}/lib/make +exec - fi +done ${INSTALLROOT}/lib/make generated +make ${INSTALLROOT}/lib/make/package.mk +prev ${INSTALLROOT}/lib/make +prev package.mk +exec - test '' = 'package.mk' || ${STDCMP} 2>/dev/null -s package.mk ${INSTALLROOT}/lib/make/package.mk || { ${STDMV} ${INSTALLROOT}/lib/make/package.mk ${INSTALLROOT}/lib/make/package.mk.old 2>/dev/null || true; ${STDCP} package.mk ${INSTALLROOT}/lib/make/package.mk ;} +done ${INSTALLROOT}/lib/make/package.mk generated +make ${INSTALLROOT}/lib/make/PROBE.mk +make PROBE.mk +done PROBE.mk +exec - test '' = 'PROBE.mk' || ${STDCMP} 2>/dev/null -s PROBE.mk ${INSTALLROOT}/lib/make/PROBE.mk || { ${STDMV} ${INSTALLROOT}/lib/make/PROBE.mk ${INSTALLROOT}/lib/make/PROBE.mk.old 2>/dev/null || true; ${STDCP} PROBE.mk ${INSTALLROOT}/lib/make/PROBE.mk ;} +done ${INSTALLROOT}/lib/make/PROBE.mk generated +make ${INSTALLROOT}/lib/make/TEST.mk +make TEST.mk +done TEST.mk +exec - test '' = 'TEST.mk' || ${STDCMP} 2>/dev/null -s TEST.mk ${INSTALLROOT}/lib/make/TEST.mk || { ${STDMV} ${INSTALLROOT}/lib/make/TEST.mk ${INSTALLROOT}/lib/make/TEST.mk.old 2>/dev/null || true; ${STDCP} TEST.mk ${INSTALLROOT}/lib/make/TEST.mk ;} +done ${INSTALLROOT}/lib/make/TEST.mk generated +make ${INSTALLROOT}/lib/make/WWW.mk +make WWW.mk +done WWW.mk +exec - test '' = 'WWW.mk' || ${STDCMP} 2>/dev/null -s WWW.mk ${INSTALLROOT}/lib/make/WWW.mk || { ${STDMV} ${INSTALLROOT}/lib/make/WWW.mk ${INSTALLROOT}/lib/make/WWW.mk.old 2>/dev/null || true; ${STDCP} WWW.mk ${INSTALLROOT}/lib/make/WWW.mk ;} +done ${INSTALLROOT}/lib/make/WWW.mk generated +make ${INSTALLROOT}/lib/make/MSGFUN.mk +make MSGFUN.mk +done MSGFUN.mk +exec - test '' = 'MSGFUN.mk' || ${STDCMP} 2>/dev/null -s MSGFUN.mk ${INSTALLROOT}/lib/make/MSGFUN.mk || { ${STDMV} ${INSTALLROOT}/lib/make/MSGFUN.mk ${INSTALLROOT}/lib/make/MSGFUN.mk.old 2>/dev/null || true; ${STDCP} MSGFUN.mk ${INSTALLROOT}/lib/make/MSGFUN.mk ;} +done ${INSTALLROOT}/lib/make/MSGFUN.mk generated +make ${INSTALLROOT}/lib/make/MSGKEY.mk +make MSGKEY.mk +done MSGKEY.mk +exec - test '' = 'MSGKEY.mk' || ${STDCMP} 2>/dev/null -s MSGKEY.mk ${INSTALLROOT}/lib/make/MSGKEY.mk || { ${STDMV} ${INSTALLROOT}/lib/make/MSGKEY.mk ${INSTALLROOT}/lib/make/MSGKEY.mk.old 2>/dev/null || true; ${STDCP} MSGKEY.mk ${INSTALLROOT}/lib/make/MSGKEY.mk ;} +done ${INSTALLROOT}/lib/make/MSGKEY.mk generated +make ${INSTALLROOT}/lib/make/MAPLIB.mk +make MAPLIB.mk +done MAPLIB.mk +exec - test '' = 'MAPLIB.mk' || ${STDCMP} 2>/dev/null -s MAPLIB.mk ${INSTALLROOT}/lib/make/MAPLIB.mk || { ${STDMV} ${INSTALLROOT}/lib/make/MAPLIB.mk ${INSTALLROOT}/lib/make/MAPLIB.mk.old 2>/dev/null || true; ${STDCP} MAPLIB.mk ${INSTALLROOT}/lib/make/MAPLIB.mk ;} +done ${INSTALLROOT}/lib/make/MAPLIB.mk generated +make ${INSTALLROOT}/bin/mamake +prev mamake +exec - test '' = 'mamake' || ${STDCMP} 2>/dev/null -s mamake ${INSTALLROOT}/bin/mamake || { ${STDMV} ${INSTALLROOT}/bin/mamake ${INSTALLROOT}/bin/mamake.old 2>/dev/null || true; ${STDCP} mamake ${INSTALLROOT}/bin/mamake ;} +done ${INSTALLROOT}/bin/mamake generated +make ${INSTALLROOT}/bin/proto +prev proto +exec - test '' = 'proto' || ${STDCMP} 2>/dev/null -s proto ${INSTALLROOT}/bin/proto || { ${STDMV} ${INSTALLROOT}/bin/proto ${INSTALLROOT}/bin/proto.old 2>/dev/null || true; ${STDCP} proto ${INSTALLROOT}/bin/proto ;} +done ${INSTALLROOT}/bin/proto generated +make ${INSTALLROOT}/bin/ratz +prev ratz +exec - test '' = 'ratz' || ${STDCMP} 2>/dev/null -s ratz ${INSTALLROOT}/bin/ratz || { ${STDMV} ${INSTALLROOT}/bin/ratz ${INSTALLROOT}/bin/ratz.old 2>/dev/null || true; ${STDCP} ratz ${INSTALLROOT}/bin/ratz ;} +done ${INSTALLROOT}/bin/ratz generated +make ${INSTALLROOT}/bin/release +prev release +exec - test '' = 'release' || ${STDCMP} 2>/dev/null -s release ${INSTALLROOT}/bin/release || { ${STDMV} ${INSTALLROOT}/bin/release ${INSTALLROOT}/bin/release.old 2>/dev/null || true; ${STDCP} release ${INSTALLROOT}/bin/release ;} +done ${INSTALLROOT}/bin/release generated +make ${INSTALLROOT}/bin/mkdir +make mkdir.sh +done mkdir.sh +exec - if test ! -x ${INSTALLROOT}/bin/mkdir -a -x /bin/mkdir +exec - then mkdir -p 2>/dev/null || : +exec - if test -d ./-p +exec - then rmdir ./-p +exec - cp mkdir.sh ${INSTALLROOT}/bin/mkdir +exec - chmod +x ${INSTALLROOT}/bin/mkdir +exec - fi +exec - fi +done ${INSTALLROOT}/bin/mkdir generated +make ${INSTALLROOT}/bin/.paths +exec - if test ! -f ${INSTALLROOT}/bin/.paths -o -w ${INSTALLROOT}/bin/.paths +exec - then nl=" +exec - " +exec - o=`cat ${INSTALLROOT}/bin/.paths 2>/dev/null` || : +exec - v= +exec - n= +exec - case $nl$o in +exec - *${nl}FPATH=*|*#FPATH=*|*[Nn][Oo]FPATH=*) +exec - ;; +exec - *) case $n in +exec - '') ;; +exec - *) n="$n$nl" v="$v|" ;; +exec - esac +exec - n="${n}FPATH=../fun" +exec - v="${v}FPATH" +exec - ;; +exec - esac +exec - case $nl$o in +exec - *${nl}BUILTIN_LIB=*|*#BUILTIN_LIB=*|*[Nn][Oo]BUILTIN_LIB=*) +exec - ;; +exec - *) case $n in +exec - '') ;; +exec - *) n="$n$nl" v="$v|" ;; +exec - esac +exec - case '' in +exec - ?*) p= c= ;; +exec - *) p='XX' ;; +exec - esac +exec - n="${n}${p}BUILTIN_LIB=cmd" +exec - v="${v}BUILTIN_LIB" +exec - ;; +exec - esac +exec - set x x : +exec - p= +exec - while : +exec - do while : +exec - do case $# in +exec - 0) break ;; +exec - esac +exec - x=$1 +exec - shift +exec - case $x in +exec - :) break ;; +exec - esac +exec - done +exec - case $# in +exec - 0|1) break +exec - ;; +exec - 2) p=$2 +exec - ;; +exec - *) case "${mam_cc_HOSTTYPE}" in +exec - $3) p=$2; break ;; +exec - esac +exec - ;; +exec - esac +exec - done +exec - case $p in +exec - '') if test -x /lib/dld.sl +exec - then p=SHLIB_PATH +exec - elif test -x /usr/lib/dyld +exec - then p=DYLD_LIBRARY_PATH +exec - else case "${mam_cc_HOSTTYPE}" in +exec - ibm.*|mvs.*) +exec - p=LIBPATH +exec - ;; +exec - sgi.mips3) +exec - p=LD_LIBRARYN32_PATH +exec - ;; +exec - sgi.mips4) +exec - p=LD_LIBRARYN64_PATH +exec - ;; +exec - *) p=LD_LIBRARY_PATH +exec - ;; +exec - esac +exec - fi +exec - ;; +exec - esac +exec - case $nl$o in +exec - *${nl}${p}=*|*#${p}=*|*[Nn][Oo]${p}=*) +exec - ;; +exec - *) case $n in +exec - '') ;; +exec - *) n="$n$nl" v="$v|" ;; +exec - esac +exec - n="${n}${p}=../lib" +exec - v="${v}${p}" +exec - ;; +exec - esac +exec - case $n in +exec - ?*) case $o in +exec - ?*) o=`egrep -v "($v)=" ${INSTALLROOT}/bin/.paths`$nl ;; +exec - esac +exec - echo "# use { # no NO } prefix instead of XX to permanently disable #$nl$o$n" > ${INSTALLROOT}/bin/.paths +exec - ;; +exec - esac +exec - fi +done ${INSTALLROOT}/bin/.paths generated +make ${INSTALLROOT}/lib/probe/C +exec - if silent test ! -d ${INSTALLROOT}/lib/probe/C +exec - then mkdir -p ${INSTALLROOT}/lib/probe/C +exec - fi +done ${INSTALLROOT}/lib/probe/C generated +make ${INSTALLROOT}/lib/probe/C/probe +prev ${INSTALLROOT}/lib/probe/C +prev C+probe +exec - test '' = 'C+probe' || ${STDCMP} 2>/dev/null -s C+probe ${INSTALLROOT}/lib/probe/C/probe || { ${STDMV} ${INSTALLROOT}/lib/probe/C/probe ${INSTALLROOT}/lib/probe/C/probe.old 2>/dev/null || true; ${STDCP} C+probe ${INSTALLROOT}/lib/probe/C/probe ;} +done ${INSTALLROOT}/lib/probe/C/probe generated +make ${INSTALLROOT}/lib/probe/C/make +exec - if silent test ! -d ${INSTALLROOT}/lib/probe/C/make +exec - then mkdir -p ${INSTALLROOT}/lib/probe/C/make +exec - fi +done ${INSTALLROOT}/lib/probe/C/make generated +prev ${INSTALLROOT}/lib/probe/C/make +make ${INSTALLROOT}/lib/probe/C/pp +exec - if silent test ! -d ${INSTALLROOT}/lib/probe/C/pp +exec - then mkdir -p ${INSTALLROOT}/lib/probe/C/pp +exec - fi +done ${INSTALLROOT}/lib/probe/C/pp generated +prev ${INSTALLROOT}/lib/probe/C/pp +make ${INSTALLROOT}/lib/probe/C/mam +exec - if silent test ! -d ${INSTALLROOT}/lib/probe/C/mam +exec - then mkdir -p ${INSTALLROOT}/lib/probe/C/mam +exec - fi +done ${INSTALLROOT}/lib/probe/C/mam generated +make ${INSTALLROOT}/lib/probe/C/mam/probe +prev ${INSTALLROOT}/lib/probe/C/mam +prev mprobe +exec - test '' = 'mprobe' || ${STDCMP} 2>/dev/null -s mprobe ${INSTALLROOT}/lib/probe/C/mam/probe || { ${STDMV} ${INSTALLROOT}/lib/probe/C/mam/probe ${INSTALLROOT}/lib/probe/C/mam/probe.old 2>/dev/null || true; ${STDCP} mprobe ${INSTALLROOT}/lib/probe/C/mam/probe ;} +done ${INSTALLROOT}/lib/probe/C/mam/probe generated +make ${INSTALLROOT}/lib/probe/C/mam/mprobe +prev mprobe +exec - test '' = 'mprobe' || ${STDCMP} 2>/dev/null -s mprobe ${INSTALLROOT}/lib/probe/C/mam/mprobe || { ${STDMV} ${INSTALLROOT}/lib/probe/C/mam/mprobe ${INSTALLROOT}/lib/probe/C/mam/mprobe.old 2>/dev/null || true; ${STDCP} mprobe ${INSTALLROOT}/lib/probe/C/mam/mprobe ;} +done ${INSTALLROOT}/lib/probe/C/mam/mprobe generated +make ${INSTALLROOT}/lib/probe/C/make/probe +prev probe +exec - test '' = 'probe' || ${STDCMP} 2>/dev/null -s probe ${INSTALLROOT}/lib/probe/C/make/probe || { ${STDMV} ${INSTALLROOT}/lib/probe/C/make/probe ${INSTALLROOT}/lib/probe/C/make/probe.old 2>/dev/null || true; ${STDCP} probe ${INSTALLROOT}/lib/probe/C/make/probe ;} +done ${INSTALLROOT}/lib/probe/C/make/probe generated +make ${INSTALLROOT}/lib/probe/C/make/probe.ini +make probe.ini +make probe.win32 +done probe.win32 +exec - t=${mam_cc_HOSTTYPE} +exec - ifs=$IFS +exec - IFS=. +exec - set x $t +exec - IFS=$ifs +exec - t=$2 +exec - set x probe.win32 +exec - while : +exec - do shift +exec - case $# in +exec - 0) break ;; +exec - esac +exec - case $1 in +exec - *probe.$t) +exec - break +exec - esac +exec - done +exec - case $1 in +exec - ?*) cmp -s $1 probe.ini || cp $1 probe.ini ;; +exec - *) : > probe.ini +exec - esac +done probe.ini generated +exec - test '' = 'probe.ini' || ${STDCMP} 2>/dev/null -s probe.ini ${INSTALLROOT}/lib/probe/C/make/probe.ini || { ${STDMV} ${INSTALLROOT}/lib/probe/C/make/probe.ini ${INSTALLROOT}/lib/probe/C/make/probe.ini.old 2>/dev/null || true; ${STDCP} probe.ini ${INSTALLROOT}/lib/probe/C/make/probe.ini ;} +done ${INSTALLROOT}/lib/probe/C/make/probe.ini generated +make ${INSTALLROOT}/include +exec - if silent test ! -d ${INSTALLROOT}/include +exec - then mkdir -p ${INSTALLROOT}/include +exec - fi +done ${INSTALLROOT}/include generated +make ${INSTALLROOT}/include/prototyped.h +prev ${INSTALLROOT}/include +make prototyped.h +prev ${INSTALLROOT}/bin/proto +exec - proto -f /dev/null > h.${COTEMP}.h +exec - if cmp 2>/dev/null -s h.${COTEMP}.h prototyped.h +exec - then rm -f h.${COTEMP}.h +exec - else mv h.${COTEMP}.h prototyped.h +exec - fi +done prototyped.h generated +exec - test '' = 'prototyped.h' || ${STDCMP} 2>/dev/null -s prototyped.h ${INSTALLROOT}/include/prototyped.h || { ${STDMV} ${INSTALLROOT}/include/prototyped.h ${INSTALLROOT}/include/prototyped.h.old 2>/dev/null || true; ${STDCP} prototyped.h ${INSTALLROOT}/include/prototyped.h ;} +done ${INSTALLROOT}/include/prototyped.h generated +make ${INSTALLROOT}/lib/lib +exec - if silent test ! -d ${INSTALLROOT}/lib/lib +exec - then mkdir -p ${INSTALLROOT}/lib/lib +exec - fi +done ${INSTALLROOT}/lib/lib generated +make ${INSTALLROOT}/lib/lib/dl +prev ${INSTALLROOT}/lib/lib +make dl.req +make dl.c +done dl.c +exec - set - +exec - r='-' +exec - for i in dl.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in dl - +exec - do case $p in +exec - -) if ${CC} -o dl.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o dl.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > dl.req +exec - rm -f dl.exe dl +done dl.req generated +exec - test '' = 'dl.req' || ${STDCMP} 2>/dev/null -s dl.req ${INSTALLROOT}/lib/lib/dl || { ${STDMV} ${INSTALLROOT}/lib/lib/dl ${INSTALLROOT}/lib/lib/dl.old 2>/dev/null || true; ${STDCP} dl.req ${INSTALLROOT}/lib/lib/dl ;} +done ${INSTALLROOT}/lib/lib/dl generated +make ${INSTALLROOT}/lib/lib/iconv +make iconv.req +make iconv.c +done iconv.c +exec - set - +exec - r='-' +exec - for i in iconv.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in iconv - +exec - do case $p in +exec - -) if ${CC} -o iconv.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o iconv.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > iconv.req +exec - rm -f iconv.exe iconv +done iconv.req generated +exec - test '' = 'iconv.req' || ${STDCMP} 2>/dev/null -s iconv.req ${INSTALLROOT}/lib/lib/iconv || { ${STDMV} ${INSTALLROOT}/lib/lib/iconv ${INSTALLROOT}/lib/lib/iconv.old 2>/dev/null || true; ${STDCP} iconv.req ${INSTALLROOT}/lib/lib/iconv ;} +done ${INSTALLROOT}/lib/lib/iconv generated +make ${INSTALLROOT}/lib/lib/w +make w.req +make w.c +done w.c +make w2.c +done w2.c +exec - set - +exec - r='-' +exec - for i in w.c w2.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in w - +exec - do case $p in +exec - -) if ${CC} -o w.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o w.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > w.req +exec - rm -f w.exe w w2 +done w.req generated +exec - test '' = 'w.req' || ${STDCMP} 2>/dev/null -s w.req ${INSTALLROOT}/lib/lib/w || { ${STDMV} ${INSTALLROOT}/lib/lib/w ${INSTALLROOT}/lib/lib/w.old 2>/dev/null || true; ${STDCP} w.req ${INSTALLROOT}/lib/lib/w ;} +done ${INSTALLROOT}/lib/lib/w generated +make ${INSTALLROOT}/lib/lib/intl +make intl.req +make intl.c +done intl.c +exec - set - +exec - r='-' +exec - for i in intl.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in intl - +exec - do case $p in +exec - -) if ${CC} -o intl.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o intl.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > intl.req +exec - rm -f intl.exe intl +done intl.req generated +exec - test '' = 'intl.req' || ${STDCMP} 2>/dev/null -s intl.req ${INSTALLROOT}/lib/lib/intl || { ${STDMV} ${INSTALLROOT}/lib/lib/intl ${INSTALLROOT}/lib/lib/intl.old 2>/dev/null || true; ${STDCP} intl.req ${INSTALLROOT}/lib/lib/intl ;} +done ${INSTALLROOT}/lib/lib/intl generated +make ${INSTALLROOT}/lib/lib/m +make m.req +make m.c +done m.c +make m2.c +done m2.c +make m3.c +done m3.c +make m4.c +done m4.c +make m5.c +done m5.c +make m6.c +done m6.c +exec - set - +exec - r='-' +exec - for i in m.c m2.c m3.c m4.c m5.c m6.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in m - +exec - do case $p in +exec - -) if ${CC} -o m.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o m.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > m.req +exec - rm -f m.exe m m2 m3 m4 m5 m6 +done m.req generated +exec - test '' = 'm.req' || ${STDCMP} 2>/dev/null -s m.req ${INSTALLROOT}/lib/lib/m || { ${STDMV} ${INSTALLROOT}/lib/lib/m ${INSTALLROOT}/lib/lib/m.old 2>/dev/null || true; ${STDCP} m.req ${INSTALLROOT}/lib/lib/m ;} +done ${INSTALLROOT}/lib/lib/m generated +make ${INSTALLROOT}/lib/lib/nsl +make nsl.req +make nsl.c +done nsl.c +exec - set - +exec - r='-' +exec - for i in nsl.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in nsl - +exec - do case $p in +exec - -) if ${CC} -o nsl.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o nsl.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > nsl.req +exec - rm -f nsl.exe nsl +done nsl.req generated +exec - test '' = 'nsl.req' || ${STDCMP} 2>/dev/null -s nsl.req ${INSTALLROOT}/lib/lib/nsl || { ${STDMV} ${INSTALLROOT}/lib/lib/nsl ${INSTALLROOT}/lib/lib/nsl.old 2>/dev/null || true; ${STDCP} nsl.req ${INSTALLROOT}/lib/lib/nsl ;} +done ${INSTALLROOT}/lib/lib/nsl generated +make ${INSTALLROOT}/lib/lib/socket +make socket.req +make socket.c +done socket.c +prev nsl.c +exec - set - +exec - r='-' +exec - for i in socket.c nsl.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in socket - +exec - do case $p in +exec - -) if ${CC} -o socket.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o socket.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > socket.req +exec - rm -f socket.exe socket nsl +done socket.req generated +exec - test '' = 'socket.req' || ${STDCMP} 2>/dev/null -s socket.req ${INSTALLROOT}/lib/lib/socket || { ${STDMV} ${INSTALLROOT}/lib/lib/socket ${INSTALLROOT}/lib/lib/socket.old 2>/dev/null || true; ${STDCP} socket.req ${INSTALLROOT}/lib/lib/socket ;} +done ${INSTALLROOT}/lib/lib/socket generated +make ${INSTALLROOT}/lib/lib/dbm +make dbm.req +make db.c +done db.c +make gdbm.c +done gdbm.c +make gdbm1.c +make gdbm-ndbm.h implicit +done gdbm-ndbm.h dontcare virtual +done gdbm1.c +make gdbm2.c +make ndbm.h implicit +done ndbm.h dontcare virtual +done gdbm2.c +exec - set - +exec - r='-' +exec - for i in db.c gdbm.c gdbm1.c gdbm2.c +exec - do if ${CC} -c $i > /dev/null +exec - then g= +exec - for p in db - gdbm_compat - gdbm - ndbm - dbm - +exec - do case $p in +exec - -) if ${CC} -o dbm.exe $i $g > /dev/null 2>&1 +exec - then ${CC} -o dbm.exe $i > /dev/null 2>&1 || { +exec - r="$g" +exec - break 2 +exec - } +exec - fi +exec - g= +exec - ;; +exec - *) g="$g -l$p" +exec - ;; +exec - esac +exec - done +exec - fi +exec - done 2>/dev/null +exec - echo " $r" > dbm.req +exec - rm -f dbm.exe db gdbm gdbm1 gdbm2 +done dbm.req generated +exec - test '' = 'dbm.req' || ${STDCMP} 2>/dev/null -s dbm.req ${INSTALLROOT}/lib/lib/dbm || { ${STDMV} ${INSTALLROOT}/lib/lib/dbm ${INSTALLROOT}/lib/lib/dbm.old 2>/dev/null || true; ${STDCP} dbm.req ${INSTALLROOT}/lib/lib/dbm ;} +done ${INSTALLROOT}/lib/lib/dbm generated +done install virtual +make test +make test.iffe +prev iffe +make iffe.tst +done iffe.tst +exec - regress iffe.tst iffe +done test.iffe virtual +make test.mamake +prev mamake +make mamake.tst +meta mamake.tst %.rt>%.tst mamake.rt mamake +make mamake.rt +done mamake.rt +exec - if [[ "1" || "mamake.rt" -nt "mamake.tst" ]] +exec - then mktest --style=regress mamake.rt > mamake.tst +exec - fi +done mamake.tst generated +exec - regress mamake.tst mamake +done test.mamake virtual +done test dontcare virtual diff --git a/src/cmd/INIT/PROBE.mk b/src/cmd/INIT/PROBE.mk new file mode 100644 index 0000000..9a8553f --- /dev/null +++ b/src/cmd/INIT/PROBE.mk @@ -0,0 +1,13 @@ +/* + * @(#)probe (AT&T Bell Laboratories) 11/11/91 + * + * <lang> <tool> :PROBE: *.probe *.sh * + * + * common probe script installation + * generates probe.sh and probe in . + */ + +":PROBE:" : .MAKE .OPERATOR + probe.sh : $(LIBDIR)/probe/$(<:O=1)/probe $(>:N=*.(probe|sh)) + cat $(*) > $(<) + $(LIBDIR)/probe/$(<:O=1)/$(<:O=2) :INSTALLDIR: probe $(>:N!=*.(probe|sh)) diff --git a/src/cmd/INIT/RELEASE b/src/cmd/INIT/RELEASE new file mode 100644 index 0000000..ebed09f --- /dev/null +++ b/src/cmd/INIT/RELEASE @@ -0,0 +1,918 @@ +12-02-29 cc.darwin.i386*: handle default cc vs kernel bittedness +12-02-29 C+probe: add __TIMESTAMP__ to the nopredefined list +12-02-29 package.sh: don't assume grep -q or /usr/local/lib in LD_LIBRARY_PATH +12-02-29 package.sh: fix ksh vs -lcmd compatibility checks +12-02-23 iffe.sh: checkcc() before checkread() for sensible diagnostics +12-02-14 package.mk: { --clobber --compare --link=lib*.a* } for --mam=static +12-02-14 package.mk: export LICENSEFILEDEFAULT instead of LICENSEFILE +12-02-14 package.sh: handle @(cc|ld).${HOSTTYPE}* intercepts +12-02-07 package.sh: add { clean clobber } actions +12-02-02 regress.sh: fix ulimit -c defaults for --nokeep +12-01-18 regress.sh: add INPUT|OUTPUT|ERROR -e 'filter' to filter before comparison +12-01-21 package.sh: fix `admin make' bug that created unused $INSTALLROOT/lib +12-01-21 Makefile: :PACKAGE: license=ast -- oops +12-01-20 cc.darwin,cc.mvs.390: tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err +12-01-12 package.sh: add admin make share closure to handle alternate HOSTTYPEs +11-12-13 iffe.sh: add /*<NOSTDIO>*/ test code comment to disable default #include <stdio.h> +11-11-11 C+probe: test for .so before .sl +11-10-26 package.sh: don't forget about *.pkg for admin update +11-10-18 cc.*-icc: update and add more +11-10-11 package.sh: handle package make|view when no source installed +11-09-11 package.sh: count admin '*** termination code' errors +11-08-31 mamake.c: add -e, ignore use recursive prereq timestamps +11-08-29 iffe.sh: add ``set stdio try1.h - try2.h ...'' +11-08-29 iffe.sh: trap EXIT => trap 0 for ancient sh +11-08-11 iffe.sh: handle ancient sort that doesn't have -k +11-06-01 make.probe: add more /lib64 logic +11-05-01 package.sh: fix admin ditto to sync LICENSES too +11-03-25 package.sh: initialize { $SED $TR } before first use! +11-03-21 package.sh: fix vpath probes +11-03-17 iffe.sh: fix cleanup to rm $tmp* instead of $tmp*.* +11-02-24 package.sh: change curl usage to "curl -L ..." +11-02-11 package.sh,C+probe,make.probe,mamprobe.sh: add ###.*archiac.*### +11-02-02 Makefile: add :MAPLIB: check for ancient -lw +11-02-02 make.probe: handle -print-multi-directory => 64 => /usr/lib64 /lib64 +11-02-02 package.sh: HOSTTYPE=*,*cc*[,-*,...] sets CC [ and CCFLAGS ] +11-02-02 make.probe: handle gcc $ORIGIN link but exec failure -- gee thanks +11-01-25 cc.hp.ia64: bundled cc is a pile of shaving cream +11-01-07 iffe.sh: check debug==3 for is_hdr() failure +10-11-22 ditto.sh: fix timing problem between |& and exec &p +10-11-10 package.sh: fix cc cross compile check to use checkcc absolute path +10-10-10 package.sh: list main env vars at start of make action +10-10-10 ratz.c: tweak widnows delays +10-09-10 ratz.c: add _SEAR_ARGS for _SEAR_EXEC +10-09-01 package.sh: fix ratz from source logic +10-08-25 package.mk: consolidate license file search in .package.licenses. +10-08-22 ratz.c: run sear bootstrap command detached +10-08-20 C+probe: version_stamp only if version_flags works +10-08-17 package.sh: unset makerules *DIR variables in env +10-08-15 package.sh: "make" action now lists some env values +10-08-11 mktest.sh: add "DO command ..." +10-07-27 rt.sh: handle "rt X=Y ..." +10-06-29 ratz.c: non-option sear args passed to sear_exec() +10-06-25 iffe.sh: "api" op chanegd to not do "map-libc" type mappings +10-06-25 package.sh: "force admin ditto" => no ditto --update option +10-06-22 C+probe: handle cc that require .[ci] input for version info +10-06-21 ditto.sh: change default remote access to ssh (about time) +10-06-12 regress.sh: DISGNOSTICS [ 1 | 0 | pattern ] and fix EXIT for all +10-06-09 package.sh: add AT&T to usable nmake check +10-06-06 iffe.sh,iffe.tst: add { api ver } ops +10-04-22 package.sh: update "html binary|source" NAME/PASSWORD info +10-04-15 iffe.sh: don't forget candidate headers for hdr|sys! +10-04-11 WWW.mk: disable man page metarule -- now done by admin-man(1) +10-02-14 package.sh: $CC verification needs $INSTALLROOT/bin in PATH +10-02-11 package.sh: fix package admin make report error count +10-02-02 package.sh: fix write binary bug that did scp on local fs +10-02-02 package.mk: up to date binary targets must still be in PACKAGE.*.lst +10-01-01 package.sh: fix premature $INSTALLROOT/bin during cross compile check +10-01-01 make.probe: handle ['"] in CC.VERSION.STRING +09-12-04 iffe.sh: add "opt name" to check for name in $PACKAGE_OPTIONS +09-11-30 mktest.sh: change RESET to STATE.RESET to make it global +09-11-14 make.probe: use gcc { -print-multi-directory -print-search-dirs } +09-11-11 package.sh: re-order and combine cc checks +09-10-27 C+probe,make.probe,probe.win32: add CC.SUFFIX.DEBUG +09-10-21 iffe.sh,Makefile: test -e is not in ksh88! +09-10-06 iffe.sh: handle cc -E #error with 0 exit status (sgi) +09-10-06 package.sh: stub in ar intercept checks -- not used yet +09-10-06 ar.ibm.risc: add ar intercept because some aix require -Xfoo first!! +09-09-24 regress.sh: fix UMASK logic to create test support files before umask +09-08-28 release.c: change docs to mention stdin if no file operands +09-08-24 package.sh: fix isascii() bug that failed on od(1) trailing space +09-08-20 make.probe: add CC.SHARED.NAME +09-08-20 regress.sh: add { JOB CONTINUE EXITED KILL FIFO } +09-08-11 package.sh: filter lines containing : for package results +09-07-31 make.probe: add CC.AR.ARFLAGS (for aix ar -xany) +09-07-31 package.sh,cc.*: fix -dumpmachine to handle 32/64/* bit options +09-06-24 package.sh: fix admin.db output formatting +09-05-05 package.sh: export dll hackery environment vars +09-05-05 package.sh: handle non-identifier hostnames +09-05-05 mamake.c: pass undefined ${...} identifiers to the shell +09-05-05 mamake.rt: add macro expansion regression tests +09-05-01 iffe.sh: fix output initialization *again* +09-04-28 package.sh: handle admin.db contact field $9 +09-04-15 iffe.sh: add implicit "ini" op to initialize io for subsequent ops +09-03-31 regress.sh: EXPORT before test => global ENVIRON[] +09-03-26 package.sh: test fail pattern is 'fail[es]' +09-03-26 UNIT - ... appends (options) to command line +09-03-19 TEST.mk: x.tst => x only if x is command target +09-03-15 regress.sh: add ${MAIN} for base name of main unit +09-03-10 TEST.mk: add .SOURCE:tests if tests is a dir +09-03-03 regress.sh: allow command line unit to override UNIT +09-03-03 mktest.sh: handle IO == $'\n' +09-02-02 package.sh: delay $INSTALLROOT/bin/.paths generation until mamprobe runs +09-01-30 cc.mvs.390: c89 balks at [ ()] in -Dname="..."! +09-01-27 package.sh: add isascii() to use ratz instead of tar +09-01-20 hurl.sh: add --size=bytes option +09-01-08 TEST.mk: add test.* prereqs, multiple arg lists with :T=*: binding +09-01-03 regress.sh: fix UNIT to allow command line override +09-01-03 mktest.sh: handle TWD +08-12-24 package.sh: fix cross-compile HOSTTYPE logic +08-12-15 package.sh,hurl.sh: handle http codes { 301 302 303 } +08-10-16 make.probe '-fno-stack-protector -fno-stack-protector-all' to cop out!! +08-09-30 rt.sh: fix ksh93 regression test signal count +08-09-26 regress.sh: ignore SIGPIPE for SET pipe-input +08-09-24 package.sh: package only test foo => make --recurse=only recurse tests foo +08-09-20 make.probe: handle another /usr/bin/file shared lib description +08-09-20 regress.sh: add --pipefail for SET pipe-input ... +08-09-17 Makefile: add gdbm1.c for <gdbm-ndbm.h> +08-09-10 make.probe: add CC.NOPROTECT +08-08-08 mktest.sh: add --width=width +08-08-05 dbm.req: favor sleepycat ndbm compatibility +08-08-04 C+probe: fix stdlib initialization logic +08-06-24 package.sh: fix $INSTALLROOT/bin/cc intercept time stamp file typo +08-06-20 TEST.mk: make the localyunit before *.rt => *.tst -- doh +08-06-20 mktest.sh: prepend $PWD onto PATH for local units -- doh^2 +08-06-11 regress.sh: fix bug that skipped the last test +08-05-20 regress.sh: add --local to put *.tmp dir in local fs +08-05-05 regress.sh: add IF command ... ELIF command ... ELSE ... FI +08-05-01 package.sh: package test => ulimit -c 0 +08-04-28 regress.sh: fix EXPORT quoting +08-04-28 regress.sh: fix UNIT set check args too +08-04-24 rt.sh: exit code > 256 => signal termination +08-04-10 C+probe: change probe_so order to check .so last (macos ld workaround) +08-04-01 package.sh: handle multiple admin HOSTTYPEs per HOST +08-03-28 C+probe: add C++ #include <iostream> (no extension) dir probes +08-03-17 regress.sh: fix trap on EXIT, add terminated note to final tally +08-02-28 make.probe: fix probe_warn to include ld! +08-02-02 make.probe: add CC.RUNPATH to match default -L order +08-01-31 package.sh: check lib64 for LD_LIBRARY_PATH +08-01-31 iffe.sh: tweak ancient /bin/sh workarounds +08-01-28 make.probe: darwin ld export dynamic is -force_flat_namespace +08-01-28 C+probe: handle sgi cc error message but exit 0 botch(es) +08-01-23 package.sh: fix checksum doc typo +08-01-09 C+probe: add __FUNCTION__ to the undef (don't check) list +07-12-14 iffe.sh: add set nooptimize +07-12-03 package.sh: add LC_ALL=C +07-11-27 package.sh: fix overaggressive *.md5 cleanup +07-11-20 iffe.sh: treat exit status >= 250 as normal error with no signal +07-11-05 package.sh: fix write op error count pattern +07-11-05 package.mk: fix $(~req) .ver binding +07-08-11 probe.win32: add cl.exe setuid workaround, CC.VERSION[.STRING] +07-08-01 package.sh: handle 'package read lcl|tgz' +07-05-08 regress.sh: execute basename instead of absolute path for short $0 +07-04-27 cc.sgi.mips[34]: for #error to exit non-zero -- a no brainer +07-04-20 mktest.sh: defer to systems without 'grep -q' -- sigh +07-04-11 mamprobe.sh: handle $(CC.*) => ${mam_cc_*}, $(...) => ${...} +07-04-11 make.probe: fix CC.PICBIG probe, default { CC.PIC CC.DLL } to BIG +07-04-04 iffe.sh: prepend ${tst}${ext} to each .c probe +07-03-28 package.sh: fix binary tgz architecture type duplication +07-03-28 package.mk: add binary write PACKAGE.$HOSTTYPE.lst +07-03-28 iffe.sh: add -F header to mac test +07-03-23 make.probe: handle file(1) that returns 'archive' for .so +07-03-22 mamprobe.sh: fix STDED probe for implementations that ignore EOF +07-03-11 package.sh: add nocopyright and tst => nocopyright +07-03-11 package.mk: add copyright=0 +07-03-08 C+probe: restore IFS after probe.ini +07-02-26 mamake.c: expand first of ${mam_lib*} for ${AR} +07-01-05 package.sh: fix "admin write binary" logic +07-01-01 iffe.sh: add "cmd" --verbose trace +07-01-01 iffe.sh: sort => LC_ALL=C sort +07-01-01 C+probe: LC_ALL=C +06-12-22 make.probe: lean on gcc -v for stdlib, but preserve /usr/local! +06-11-23 package.sh: *.md5 are not tarballs -- doh +06-11-23 iffe.sh: add -F, --features=feature-test-header +06-11-11 make.probe: favor lib64 over lib for hosttype==*64 +06-10-31 make.probe: add "-ignore-source-dir -iquote" test +06-10-31 iffe.sh: add status{...} code block +06-10-11 regress.sh: fix DO to handle {...} (time for regress.tst?) +06-10-11 package.sh: handle already gunzip'd *.tgz +06-10-06 iffe.sh: add reference for header content tests +06-09-27 regress.sh: fix UMASK to do DO too (duh) +06-09-22 iffe.sh: drop -O for npt tests (for msvc intrinsics) +06-09-14 cc.darwin: drop -O until gcc 4.* gets its act together +06-09-11 package.sh: { cc ld ldd } intercepts check ${HOSTTYPE%.*} too +06-09-08 regress.sh: add PIPE INPUT|OUTPUT for pipe io +06-09-05 C+probe: add { probe_version version_stamp version_string } +06-09-05 make.probe: add version stamp comment, CC.VERSION[.STRING] +06-08-27 regress.sh,mktest.sh: add UMASK +06-08-25 regress.sh: add -b,--ignore-space,IGNORESPACE +06-08-25 mktest.sh: add IGNORESPACE +06-08-24 mktest.sh: handle \000 in data +06-08-24 regress.sh: handle -f* for INPUT|OUTPUT|ERROR +06-08-16 package.sh: fix 'install flat' logic +06-08-11 rt.sh: handle style=shell %K date format +06-07-17 ratz.c: fix __MVS__ FAR definition +06-07-17 iffe.sh: "header x.h" -- deprecate "include x.h" for .SCAN.iffe +06-07-17 package.sh: differentiate urls vs. assignments +06-06-27 rt.sh: add --failed, --heading +06-06-27 C+probe,TEST.mk,make.probe,mktest.sh,regress.sh: 'ulimit -c 0' +06-06-26 cc.darwin.ppc: handle -lcc_dynamic disappearance +06-06-25 mktest.sh: implement PROG +06-06-11 Makefile: add -ldbm :MAPLIB:, provide public MAPLIB.mk +06-05-06 package.sh: add PACKAGE_admin_tail_timeout +06-05-22 ratz.c: upgrade to zlib-1.2.3 +06-05-09 package.sh: fix admin.db docs +06-03-11 package.sh: fix `package use - command ...' +06-03-05 make.probe: work around pedantic bash 3.1 mismatched " in `.` +06-02-14 package.sh: "results failed test" == "results test failed" + cc.sgi.*: add _AST_cc_OPTIONS parameterization, -OPT:Olimit=0 + cc.linux.ia64-icc: add for intel cc +06-02-02 package.sh: freebsd stuck with os version for all arch +06-02-01 package.mk: fix locale logic (tw -d requires dir arg) +06-01-31 package.sh: require $CC only for make|test +06-01-30 package.sh,hurl.sh: use the backwards-compatible --http-passwd + package.sh: add more pdksh => /bin/sh checks +06-01-26 package.sh: wget --http-pass => --http-password + package.sh: fix wget error logic + hurl.sh: wget --http-pass => --http-password +06-01-11 package.mk: pass package.license.class to make --mam too + package.mk: variants=pattern => --variants=pattern + package.sh: darwin rel<=7 => darwin7.ppc + package.sh: freebsd rel<=4 => freebsd4 + package.sh: freebsd rel<=5 => freebsd5 +05-12-07 iffe.sh: don't emit <stdio.h> if <sfio.h>|<ast.h> (XXX) +05-12-05 make.probe: disable readonly.exe core dump via ulimit -c 0 +05-09-22 mktest.sh: add EXEC [ ++NOOUTPUT ++NOERROR ++NOEXIT ] +05-09-21 mktest.sh: fix --style=shell compare to ignore \r +05-09-12 TEST.mk: all --force to force %.rt regeneration +05-09-05 TEST.mk: regenerate from %.rt only if newer, :SAVE: %.tst +05-08-25 mktest.sh: add + TEST.mk: add %.rt=>%.tst for mktest +05-08-18 package.sh: 'package host cpu' now checks $NPROC first +05-07-17 iffe.sh: add { define extern include print } ops + iffe.sh: accept output{...}end output on success only -- doh +05-07-01 package.sh: add TARPROBE for tar B flag probe +05-06-24 package.sh: fix binary read chmod via *.sum +05-06-06 package.sh: fix KEEP_HOSTTYPE logic to handle synthesized types +05-06-01 make.probe: verify that cc_pic works for hosted cc + cc.lynxos.ppc: make -mshared the default + package.sh: note $INSTALLROOT/bin/@(cc|ld|ldd) installation +05-05-25 make.probe: add CC.INCLUDE.LOCAL instead of -I- in CC.DIALECT +05-05-24 iffe.sh: really fix grouping logic -- with tests this time + package.sh: pipe/socket configuration mismatches => use /bin/sh +05-04-28 TEST.mk: add $(TESTS) +05-04-19 package.sh: package results test uses rt if possible + iffe.sh: fix 'op var - ... - ...' grouping logic +05-04-15 rt.sh: handle autom4ate style +05-04-11 regress.sh: fix unit name when command line unit also specified + rt.sh: handle all ast package test output formats + package.sh: fix make docs for options passed to underlying make +05-04-08 package.sh: cp -p makerules.mo to $OK to preserve mtime + regress.sh: add "TITLE name" to change TEST output title +05-04-01 rt.sh: add pretty make test + regress.sh wrapper +05-03-29 package.sh: test -e path => test -f path -o -d path +05-03-24 make.probe: fix CC.PICBIG probe to prefer -fPIC over -fpic -- doh +05-03-19 mamake.c: command line name=var also defines name.FORCE=var +05-03-11 regress.sh: unset LC_ALL when LC_* EXPORT'd + package.sh: old make.out saved in circular make.out.[1-9] + mamake.c: sync with nmake :W=O: +05-03-01 package.sh: fix flat hierarchy initialization + package.sh: admin action now properly resets sibling remote logs + package.mk: relax unknown/unwritten package messages to warnings + package.sh: handle space in command line name=value + make.probe: add mvs -Wc,dll,exportall,longname,rent to CC.DLL probe +05-02-24 package.sh: hosttype *.powerpc => *.ppc + cc.lynxos.ppc,ldd.lynxos.ppc: add +05-02-22 mamake.c: fix { -G --debug-symbols -S --strip-symbols } MAMAKEFLAGS bug +05-02-20 probe.win32: handle /platformsdk mount +05-02-19 package.sh,package.mk: add write tst for tgz in tst subdir +05-02-18 package.sh: accept cc -dumpmachine with 0 or 1 - +05-02-14 package.sh: handle mutiple architectures per host in admin.db + Makefile,package.sh: honor $INSTALLROOT/bin/.paths overrides + package.sh: normalize trailing [-_]bits in host type + iffe.sh: some ksh-compatible shells don't do *(pattern) +05-02-11 iffe.sh: back out 05-01-11 child process stdin hijack + cc.lynxos.i386: -dynamic instead of -static default +05-02-10 package.sh: cyg usr/doc => usr/share/doc +05-02-08 package.sh: drop -m with pax -- delta bug fixed 2005-02-08 + iffe.sh: work around old bash 0<... redirection bug +05-02-06 package.mk: source.tgz: update generated files only when they change +05-02-02 *.sh,*probe: IFS may be unset and { ash bsh } don't on startup -- wow +05-01-11 package.sh: update setup docs to include authorize+password + package.mk: fix .source.cyg final directory edit + package.mk: notice=1 for conspicuous empty NOTICE file + WWW.mk: fix *-index.html installation + filter.sh: retain input file suffix in tmp copy + mamexec.c: fix non-contiguous "exec" bug that skipped lines + iffe.sh: fix candidate lib test to try grouping subsequent libs + iffe.sh: fix child process stdin hijack that skipped input lines + iffe.sh: --shell=osh to force read -r compatibility command + iffe.sh: chop iffe input leading space before # for KnR compatibility +05-01-05 package.sh: add ${TAR} ${TARFLAGS} and tar B flag for pipes + mamake.c: fix makefile scan to ignore lib*.[hH] + iffe.sh: immunize function/symbol tests from aggressive -O +04-12-28 WWW.mk: add :WWWPAGE: faq.*.mm index generator +04-12-21 ratz.c: make sure tmp dir is writable -- doh +04-12-08 iffe.sh: fix dat test for aggressive -O +04-12-01 iffe.sh: add `include file' to pull in #define's for `exp' +04-11-11 package.sh: default MAKESKIP is "*[-.]*" +04-10-22 ratz.c: change docs to note zlib license + mamake.c: handle --debug-symbols and --strip-symbols + package.sh: make (debug|strip)=1 => --(debug|strip)-symbols + package.mk: add :LICENSE: => package.license.class + mamake.c: fix recursive order logic +04-10-18 package.mk: add :LICENSE:, :OMIT: to omit package subdirs +04-10-11 package.sh: add 'authorize name' and 'password password' +04-10-01 iffe.sh: double check $static link with ! $static + Makefile: add BUILTIN_LIB to $INSTALLROOT/bin/.paths + make.probe: add CC.DIALECT EXPORT={ALL,REF,EXT,DLL} + package.sh: add BUILTIN_LIB to $INSTALLROOT/bin/.paths +04-09-21 package.mk: $(init)$(name) is now an implicit prereq +04-09-09 package.sh: copy makerules.mo to $INSTALLROOT/bin/ok +04-09-01 package.mk,package.sh: rename *.txt => *.README + package.mk: add the runtime package type (no *.[ah]) + iffe.sh: fix key test reports +04-08-26 Makefile: { add m2.c m3.c } -lm tests for { frexp[l] ldexp[l] } +04-08-11 package.mk: handle HOSTTYPE for solaris > 9 + package.sh: add `checkaout proto' for { make view } + package.sh: check for { md5sum md5 } + iffe.sh: add {if|elif|else|endif} test ... + iffe.sh: add 'exp - expression' and '( expression )' + iffe.sh: add 'name = test ...' user defined macros + iffe.sh: add '! test ...' negation + TEST.mk: add implied { .c .sh } generated prereq + cc.darwin.ppc: handle 10.3 -dylib mess +04-08-01 package.mk: let include handle nested requirements -- duh +04-07-31 package.sh: attempt a second ping before admin assumes host down +04-07-26 package.sh: fix hp.ia64 HOSTTYPE +04-07-23 probe.win32: generalize #include dir order search +04-07-17 regress.sh: add INPUT -x for chmod +x +04-07-01 regress.sh: TMP => TWD +04-06-29 regress.sh: put COMMAND in $TWD too +04-06-21 regress.sh: mkdir -p INPUT and OUTPUT intermediate dirs + TEST.mk: add :TEST: -- to disable .c .sh search +04-06-18 TEST.mk: add .SCAN.tst +04-06-17 regress.sh: TEST returns true if active, false otherwise + regress.sh: add CD to change test pwd from $TWD +04-06-16 regress.sh: add TWD for ./unit.tmp override + regress.sh: DO now flushes previous test + regress.sh: INPUT and OUTPUT handle -f for printf instead of print +04-06-11 package.sh: make sure $INSTALLROOT/bin is in front of $PATH + package.sh: skip nmake if older than 2000-10-31 +04-05-20 package.sh: fix arg vs. package parse with - or '' to disambuguate +04-05-11 package.sh: package verbose update lists closure for package setup + package.sh: add src/lib/libardir to nmake proto bootstrap + regress.sh: probe for rm -u vs. chmod -R u+rwx +04-05-01 package.sh: $CC must be C, not C++; allow release command on $PATH +04-04-15 make.probe: check probe_libdir false positives + package.sh: add lib/package/*.lic src package subdirs + package.mk: add mamfile=0 to inhibit Mamfile generation + iffe.sh: config name_DECLARED => HAVE_name_DECL + iffe.sh: fix mac to handle default value +04-04-11 iffe.sh: normalize sed [\\\\/] quoting +04-04-04 package.mk: only checksum generated tarballs + mamprobe.sh: add STDCHMOD +04-04-01 C+probe: set export LANG=C for uniform error messages + make.probe: another CC.STDLIB tweak + package.sh: fix regress core dump pattern, expand [a-z] match ranges +04-03-31 Makefile: add intl :MAPLIB: test + make.probe: fix CC.STDLIB search; drop CC.* path duplicates +04-03-28 iffe.sh: drop unused exec $stdin<&0 dup +04-03-25 Makefile: add iconv :MAPLIB: + package.sh: use ${PING:-ping -c 1 -w 4}, allowing admin.db override +04-03-24 package.mk: add *.md5 checksum for each *.(c|exe|tgz) + package.sh: update base change on md5 sum instead of size + iffe.sh: adjust case label \ and keyword quoting for ancient /bin/sh +04-03-22 probe.win32: ncc => nld +04-03-19 CONVERT.mk: change the instructions and old source dir default + package.mk: fix recurse=list check + package.mk: add *.md5 checksum for each *.(c|exe|tgz) + package.sh: fix update base/delta/sync existence check +04-03-18 iffe.sh: -d2 does not remove core dumps on exit +04-03-17 package.sh: fix make recurse arg/action order +04-02-29 package.sh: add regress action to compare current and previous tests + package.sh: fix sgi.mips[23] HOSTTYPE test for old irix cc + package.sh: add `export variable ...' + package.sh: admin action now handles host name with non-id chars + package.sh: non-numeric M T W in admin.db disables that action + package.sh: fix admin write binary local vs. shared clash + cc.hp.pa: add _AST_CC_hp_pa_DEFAULT=+DAportable + cc.hp.pa64: sync with cc.hp.pa + cc.ibm.risc: -bnolibpath => -blibpath:/usr/lib:/lib + probe.win32: sync with make.probe + make.probe: fix last chance dynamic test + make.probe: add hp.pa CC.EXPORT.DYNAMIC -Wl,-E + make.probe: add ibm.risc CC.EXPORT.DYNAMIC -bexpall + make.probe: move probe_dll_def to the end of probe_dll + package.mk: capture subcomponent mamfile recursion +04-02-24 make.probe: strip "..." from cc/ld traces + iffe.sh: add ``set [no]define'' to disable macro #define/#undef +04-02-23 make.probe: rework CC.LD search +04-02-14 make.probe: add CC.EXPORT.DYNAMIC for main dynamic sym export + make.probe: resurrect CC.PIC with separate semantics from CC.DLL + make.probe: add CC.SHARED.LD for CC.SHARED linker + C+probe: clear DISPLAY to stifle interactive windows +04-02-11 iffe.sh: handle ``siz void*'', add cross{ ... }end + make.probe: add { CC.AR CC.SIZE }, fix cross command search + cc.darwin.ppc: change $cc => $CC for old ksh + libast conf bug +04-02-09 make.probe: drop -nostartfiles from CC.SHARED for C++ +04-02-04 package.sh: fix cross compilation bug that mixed binary formats +04-02-02 package.sh: package admin now ditto's bin/package too +04-01-30 cc.sgi.mips3: drop warning 3421 +04-01-11 regress.sh: output label#count for tests in loops +04-01-05 regress.sh: fix bug that ignored the first SAME +04-01-04 crossexec.sh: fix typo that did not recognize rcp +03-12-19 mamake.c: add `foolib:foo:libfoo' to recurse() +03-10-11 regress.sh: add EXPORT, export COLUMNS=80 for message consistency +03-09-23 ratz.c: fix tar header number parse bug that skipped to next number + regress.sh: rm cleanup now handles files matching -* +03-09-11 iffe.sh: add unnamed { ... } blocks + regress.sh: add COPY from to, like MOVE but comprison still done + regress.sh: rm -rfu to handle test dirs w/o u+rwx +03-08-14 Makfile: add hello.c to the manifest +03-08-11 package.sh: fix `html binary' generation +03-06-21 package.sh: fix INITROOT initialization bug + package.sh: make sure admin logs exists before tail'ing +03-06-11 probe.win32: fix $(BINDIR) typo that expanded in sh instead of make + cc.mvs.390: return code 4 yields exit code 3 but its *really* ok + package.sh: fix onpath function global var conflict + make.probe: add CC.DIALECT { GNU -dD } + package.mk: add Mamfile to lcl manifest +03-06-10 package.sh: fix setup action typo that only checked the INIT package + package.sh: *.s390x => *.s390-64 +03-06-09 package.mk: add cyg :POSTINSTALL: +03-06-08 make.probe: fix CC.STDLIB logic + hurl.sh: add User-Agent identification + package.sh: tweak source and binary installation instructions + cc.hp.pa,ld.hp.pa: +-Wl,+cdp,${INSTALLROOT}/lib/: drops abs lib paths + ldd.hp.pa: add +03-06-06 package.sh: fix $INSTALLROOT/bin/ldd check + make.probe: add CC.STDLIB verification +03-06-04 make.probe: add +forceread +noforceread +03-05-11 hurl.sh: handle http://host:port/path +03-05-06 package.sh: fix setup action PACKAGEROOT and INIT logic +03-05-05 package.mk: fix cygwin tarball names +03-04-30 package.sh: move (cc|ld|ldd).$HOSTTYPE updates from Makefile +03-04-27 make.probe: fix mvs CC.PREFIX.SHARED "lib" => "" + make.probe: add CC.DLL.DIR = $(BINDIR) or $(LIBDIR) + make.probe: add { CC.LD.LAZY CC.LD.NOLAZY CC.LD.RECORD CC.LD.NORECORD } + probe.win32: sync with latest CC.* +03-04-25 mamprobe.sh: add args to `. $makeprobe' for ancient sh +03-04-23 package.mk: fix dup "covered by" licenses +03-04-22 probe.win32: CC.DIALECT += "LIBPP -I-" for all cc's + package.sh: fix admin write binary tarball snarf +03-04-21 package.mk: package covered *.@(pkg|lic) too +03-04-15 package.mk: don't generate incremental archives for lcl + package.mk: add incremental=[source:1 binary:0] archive control + package.sh: generate $INSTALLROOT/bin/cc wrapper for CC != cc + package.sh: admin must ditto lib/package/*.@(pkg|lic) too + mamake.c: ignore time of ignore prereqs + mamake.c: -D2 lists propagated times +03-04-11 package.mk: tidy up cyg tarballs + package.sh: fix old shell clash between get() and $get +03-04-05 package.mk: restore *.inx generation somehow lost during cyg additions + package.sh: add pthread_num_processors_np() last resort for cpu count + package.sh: use `make believe' to accept mamake generated files + package.sh: handle `make [make-flags] [target ...]' + mamake.c: ignore -e +03-03-21 package.mk: fix cyg old make typo + package.sh: switch to `package setup' instructions +03-03-19 package.sh: add registry checks for `host cpu' + package.sh: `results failed' now lists core dump messages +03-03-17 package.sh: on cygwin verify 'ntsec binmode' in $CYGWIN or die + Makefile: install gcc wrapper if no cc + package.mk: add :DETAILS: { :README: :EXPORT: :INSTALL: :TEST: } ops +03-03-12 package.mk: add :DETAILS: for style-specific details +03-03-11 package.sh: add beta setup/update support + TEST.mk: add (TESTCC) prereq for .sh tests +03-03-07 hurl.sh: add +03-03-06 iffe.sh: fix lib win32 test cygwin vs native incompatibility + iffe.sh: change internal stdio.h guard to handle C++ inline vs. macro +03-03-03 package.sh: check for curl or wget for update + package.sh: add setup action == update read make + package.sh: fix packageroot() typo that showed up in non ~user shells + mamake.c: treat name+=value args like name=value + mamake.c: add ${var?*|value?match?no-match?} + mamake.c: fix archive vs. dynamic bind logic +03-02-28 package.sh: add the "cyg" (cygwin) package type + package.mk: add "cyg" stubs, :CATEGORY: for category name(s) +03-02-25 mamake.c: add -D4 system(3) debug trace +03-02-24 package.mk: change --mismatch to --corrupt=accept +03-02-14 ratz.c: add _WIN32 setmode([01],O_BINARY) and fopen "rb"/"wb" +03-02-12 Makefile: handle getconf LIBPATH with host pattern +03-01-31 package.mk: fix .lic search +03-01-30 package.sh: handle { INIT ksh nmake } already installed elsewhere + package.sh: admin handles command outside of $PACKAGEROOT/bin + Makefile: install $(INSTALLROOT)/lib/make/package.mk +03-01-28 package.sh: admin remote commands on one line to please syslog +03-01-23 probe.win32: borland and mingw32 tweaks +03-01-22 package.sh: fix $CC test to ignore set -x trace -- duh +03-01-16 ditto.sh: tw --chop on by default +03-01-14 package.sh: use /bin/cp to copy previous binaries to bin/ok/ + package.sh: admin now initiates remote exec and copy from local host +03-01-12 package.sh: handle admin "xxx:" default root +03-01-03 probe.win32: add /usr/include/borland path truncation workaround +02-12-10 iffe.sh: add <&$nullin >&$nullout to checkread() $cc +02-12-06 probe.win32: fix inlcude => include typo, add lcc lib + probe.win32: CC.MAKE.OPTIONS = nativepp=0 +02-12-04 mamake.c: fix ${foo-bar} to expand foo if defined +02-11-28 probe.win32: add C++ and -I- CC.DIALECT checks +02-11-26 package.sh: package release now checks for second level files +02-11-22 package.sh: update action now uses HTTP/1.0 +02-11-21 probe.win32: update the vc include dir test +02-11-20 make.probe: fix CC.LD.ORIGIN typo that expanded make var +02-11-13 packahe.mk: fix list.install => list.installed typo +02-11-12 make.probe: add CC.LD.ORIGIN for a.out origin dir relative dll search + make.probe: add CC.LD.STRIP for link time a.out strip + package.sh: fix package_use vs. PACKAGE_USE check +02-10-24 WWW.mk: fix bug that required a :WWWBIN: assertion to post +02-10-23 mamake.c: fix unuinitialized time in make() + ratz.c: fix meter buffer overflow +02-10-20 package.sh: fix lib/probe/C/make/probe update test +02-10-18 probe.win32: update for mingw + make.probe: add bash workaround to SHELLMAGIC test + package.sh: work around yet another cygwin hassle +02-10-17 iffe.sh: short circuit id check for *[-+/\\]* +02-10-08 regress.sh: unset FIGNORE to avoid rm . errors + package.sh: unset FIGNORE to avoid rm . errors + package.sh: $CC must at least compile and executable hello world +02-10-04 package.sh: $INSTALLROOT/lib/package/tgz=>$PACKAGEROOT/lib/package/tgz + package.mk: $(ED) => $(STDED), $(EDFLAGS) => $(STDEDFLAGS) + iffe.sh: add identifier checks for tests that (implicitly) require them + iffe.sh: disambiguate a few --config macros +02-10-02 iffe.sh: fix shell=bsh `hdr a/b' +02-09-30 package.sh: handle chmod of -* files + package.sh: verify that $SHELL is Bourne compatible + package.sh: tighten PACKAGE_USE logic PATH,LIBPATH,etc. validation + iffe.sh: fix bug that didn't define mac variable on success +02-09-22 package.sh: handle admin_action=ditto + iffe.sh: --config sizeof(foo) macro is SIZEOF_foo + iffe.sh: fix long.long test so it doesn't defeat uwin "typ long.long" + mamprobe.sh: convert $("foo") nmake string constants +02-09-21 mamprobe.sh: "-" info-path writes probe info to stdout +02-09-11 make.probe: move from nmake src to be part of mamprobe.sh + mamprobe: generate from mamprobe.beg C.probe make.probe mamprobe.end + mamake.c: pass cc absolute path to mamprobe + package.sh: generate mamprobe -- yuk (at least its confined to INIT) + iffe.sh: lcl,nxt: drop default sys/ check + ditto.sh: tw --logical by default; add --physical +02-09-10 package.sh: SHELLMAGIC creeps into package too -- duh and fooey +02-09-09 ditto.sh: test that remote .profile exists before sourcing +02-09-06 package.sh: don't ditto nfs junk + ditto.sh: --show now lists directory ops instead of enumerating all +02-09-05 ditto.sh: add --remote={rsh|ssh} + package.sh: add admin [[{rsh|ssh|-}]:]directory +02-09-02 iffe.sh: change 'print -r --' to 'print -r -' for ksh86 compatibility +02-09-01 cc.unix.mc68k: add for ancient 3b1 +02-08-22 package.sh: fix component() to test for components -- duh + Makefile: add LICENSE:.DONTCARE to workaround mam +02-08-11 iffe.sh: provide defaults for LD_* additions +02-08-07 ratz.c: change -m to use * instead of non-portable inverse video +02-07-17 mamprobe.sh: close tmp file in trap before rm for cygwin + package.sh: fix "type" to handle i1586 (P4) + package.sh: add the view action +02-06-28 package.sh: handle multiple packages for release action +02-06-27 package.sh: catch sol*.sparc=>sol*.sun4 when CC=gcc +02-06-14 package.sh: fix admin_action to not include qualifiers + package.sh: fix help/html doc typo +02-06-11 package.sh: fix ditto update doc to `PACKAGEROOT field matching *:*' +02-06-07 WWW.mk: change substitute $("\n") to \n +02-06-06 package.sh: clarify output streams for help/html +02-05-22 mamake.c: fix executable file check to use (S_IXUSR|S_IXGRP|S_IXOTH) +02-04-04 package.sh: fix update to differentiate *.sun4 and sun4 +02-03-27 package.sh: yacc/bison warning only if both missing +02-03-24 mamake.c: all shell actions wrapped with -c to avoid #! problems +02-03-23 package.sh: recover $PACKAGEROOT/bin/package if not in INIT package + package.sh: precheck $CC, not `cc' + package.sh: fix install to use pax -ps to preserve set-uid/gid + package.sh: fix install to use list.installed for existing files only +02-03-17 package.sh: fix PAX initialization that was sometimes omitted for read + package.sh: fix update delta sync fetch +02-02-14 iffe.sh: fix macro{ }end docs to include " + iffe.sh: add dfn to extract #define from headers + iffe.sh: handle nxt #include ok but no line sync + iffe.sh: drop local header clash logic + iffe.sh: add -X, --exclude=dir to exclude -I dirs + iffe.sh: lcl,nxt now generate <...> headers instead of "..." + package.sh: admin.db root dir matching -* disables host + package.mk: fix package.src.pat typo -- too many ) + package.mk: add { :COVERS: :DESCRIPTION: :REQUIRES: } + package.sh: handle { :COVERS: :DESCRIPTION: :REQUIRES: } + Makefile: move proto.c generation to the proto component dir +02-02-02 execrate.sh: add for .exe challenged win32 systems/commands + mamprobe.sh: add STD* commands/flags + mamake.c: update mamprobe info when older than mamprobe executable + package.sh: move ed/ex workaround to mamprobe.sh + package.sh: fix `host type' bug that incorrectly assumed sun4 for sol + package.sh: add execrate(1) hooks for challenged systems + package.sh: add check for { cc ar nm yacc/bison } before make + ratz.c: fix "rb" vs. "r" macro tests + iffe.sh: add nxt, similar to lcl but defines _nxt_foo for #include + iffe.sh,package.sh: remove vaibale from sccs,cvs ident strings -- duh +02-01-24 C+probe: check CC.DYNAMIC to handle cc that accept but ignore -B* + iffe.sh: handle 'mem struct.a.b' +02-01-22 iffe.sh: cache (internal) `foo vs. struct foo' test results + package.sh: uts.370 => uts.390 +02-01-18 package.sh: fix uts hosttype +02-01-17 package.sh: add 'results failed ...' to list failures only + package.sh: change ARCH internal var to all_types to avoid env conflict + iffe.sh: fix hdr/lib precheck that missed some -- ouch + iffe.sh: fix noexecute test that forgot to check compile first! +02-01-15 ratz.c: fix path[] type typo +02-01-01 package.mk: tighten license search +02-01-08 package.sh: `pwd` => ${PWD:-`pwd`} + package.mk: expand license file pattern match +02-01-04 iffe.sh: fix `exp name "value"' bug that duped "value" + iffe.sh: fix initial <sys/types.h> check to honor --config +01-12-25 iffe.sh: fix bug where -o file restored old file +01-12-23 package.mk: uniq the closure lists +01-12-07 ratz.c: fix --meter to retain paths containing " -- " +01-11-30 ratz.c: use sear_system() to execute; should work on all windows +01-11-28 ratz.c: fix sear_rm_r() to check SetCurrentDirectory() status +01-11-26 ditto.sh: drop n+=v for ksh compatibility +01-11-21 ditto.sh: add rsync script replacement [hey, it works!] + package.sh: add [ditto]:directory notation to admin.db +01-10-31 package.sh: handle *.sum paths with embedded space + package.sh: change executable() to onpath() + package.sh: executable([!] foo) replaces test [!] -x foo (.exe hack) + package.sh: add os2 fix to `host type' + mamake.c: add .exe hack + iffe.sh: fix intrinsic function lib test + mamprobe.sh: update pic probe to match make.probe for linux.ia64 +01-10-30 package.sh: make action skeleton view now checks subdirs +01-10-20 package.sh: don't recurse into leaf dirs matching $MAKESKIP + package.mk: tarball package.notice replaces `license accepted' prompt + package.sh: eliminate `license accepted' prompt + package.sh: add update to download latest from a url + package.sh: use builtin arithmetic when we know its ksh + iffe.sh: unkown -> unknown +01-10-18 package.sh: convert to YYYY-MM-DD delta releases instead of NNNN + package.mk: convert to YYYY-MM-DD delta releases instead of NNNN + ratz.c: fix -m for paths containing \f\n\r\v +01-10-16 ratz.c: _SEA_* => SEAR_* + ratz.c: preserve stdin for sear_exec() + ratz.c: add recursive sear_rm_r() to sear_exec() tmp dir cleanup +01-10-10 mamprobe.sh: add mam_cc_SHELLMAGIC + package.sh: add nfs wakeup call to admin to avoid stale file handles +01-10-04 cc.darwin.ppc: -flat_namespace is not longer the default (huh) +01-10-01 package make: prepend $INSTALLROOT/bin/ok to PATH + package read: save cpy of bin/package when reading the INIT package + mamprobe.sh: allow cc path with optional arguments +01-09-24 Makefile,package.sh: add $INSTALLROOT/bin/.paths initialization +01-09-19 package.mk: add recurse to list.package.* + package.sh: bootstrap build nmake with _BLD_STATIC for _WIN32 +01-09-11 ratz.c: add _SEA_SKIP & _SEA_COMMAND for self extracting archives +01-09-07 package.mk: fix output capture to not generate files names with spaces +01-09-07 package.mk: fix delta release number search +01-08-11 package.mk: handle single gz executable packages (e.g., for ksh) + package.sh: fix package install to require nmake only if no *.sum + iffe.sh: drop ancient menu and prompt actions; check ./hdr.h clash +01-07-17 package: fix use cross compile test to generate files in /tmp +01-06-27 ratz: handle hard and soft links if possible +01-06-07 Makefile: fix :MAPLIB: for sco +01-05-31 crossexec.sh: add + iffe.sh: add -x crosstype to run crossexec + iffe.sh: exp test now handles pass{}end fail{}end yes{}end no{}end + package.sh: add package host canon external-host-type-name + package.sh: fix `use USER' lookup for shells that support ~USER + cc.*: add -dumpmachine to dump target HOSTTYPE +01-05-18 iffe.sh: drop $HOME/tmp/t.sh debug trace -- oops +01-05-01 mamake.c: scan() now handles :PACKAGE: foo:command +01-04-26 *.sh: expand [a-z][A-Z][0-9] for non-contiguous character codes + iffe.sh: fix run *.sh for shells that don't $* across . command + cc.mvs.390: recode for /bin/sh +01-04-25 package.mk: include non cc-g variants by default + package.sh: *[._]* => *?[_.]* for mvs.390 /bin/sh +01-04-24 TEST.mk: no tests for VARIANT=="DLL" +01-04-22 package.mk,package.sh: tarball text members are ascii encoded +01-04-18 package.mk: allow package name to be the same as one of its components + cc.mvs.390: handle .C .cpp .cxx + cc.mvs.390: compensate for -o that does not overwrite +01-04-01 regress: fix SAME that just skipped it -- we should regress regress! + iffe: fix bug that didn't emit _hdr_foo for internal hdr tests + iffe: fix lcl bug for cc -E that doesn't emit line syncs + ratz: add ascii=>ebcdic conversion for text archive members + mamake: fix buffer overlap bug that clobbered the probe file path +01-03-17 iffe: handle : separator as first arg +01-03-15 mamake.c,ratz.c,release.c: add <stdlib.h> and <string.h> +01-02-26 iffe.sh: fix bug that omitted runtime #define for `mac' op +01-02-22 cc.ibm.risc: handle SF_CLOSE clash in <sfio.h> +01-02-14 cc.sgi.mips3,cc.sgi.mips4: handle -mips2 -mips3 -mips4 for cross cc + C+probe: quote "$cc" when its an argument! + mamake: execute actions with $SHELL, ignored signals back to default + package.sh: nmake check error output to /dev/null + package.sh: fix INIT a.out updates for knr cc + package.sh: package list now handles large tgz dirs + package.sh: *-ok executables moved to ok/* for *.dll systems + iffe.sh: change "exec >&-" to "exec >/dev/null" else linux mkdir fails! + mamake: handle `bind -lx [dontcare]' +01-02-12 ratz.c: fix _PACKAGE_ast includes + package.sh: $HOSTTYPE env overrides if $PACKAGEROOT/arch/$HOSTTYPE/ + package.sh: $CC ^HOSTTYPE=[A-Za-z_0-9.]*$ overrides HOSTTYPE + iffe.sh: fix dat code that used previous $tmp.exe + iffe.sh: fix dat code for _DLL imports +01-02-09 iffe.sh: add copy() for shells with the dissappearing here doc bug +01-02-08 Makefile: guard against null $(CC.HOSTTYPE) +01-02-06 Makefile: separate out cc,ld,ldd workarounds (so they will be packaged) +01-02-02 package.sh: fix package use for $INSTALLROOT != */$HOSTTYPE + package.sh: create intermediate recursion makefiles when needed + package.sh: add $SECONDS to the DEBUG trace prompt +01-01-01 ratz.c: #ifdef for uwin ncc + iffe.sh,package.sh: check PACKAGE_PATH for local installations + package.sh: add psrinfo for osf.alpha host cpu + package.sh: change pax --meter probe; some hang on /dev/tty + package.sh: fix `install flat ARCH' + mamake: eliminate loops from scan order + C+probe: add probe_verbose -V for aix cc=xlc + cc.ibm.risc,ldd.ibm.risc: add + package.mk: list refs to top-level licenses only + package.mk: add local link table to change log html +00-12-25 package.sh: `no package archives' is a hard error, duh + package.sh: reorder host type logic for lame shells + mamake.c: getcwd => getwd for NeXT -- how about posix==default guys + iffe.sh: really gross workaround for NeXT -lposix stdout null's + iffe.sh: handle cc -E that insists on compiling +00-12-15 iffe.sh: ancient sh function call blows $*; call only when $# == 0 + *.sh: `getopts 2>/dev/null` => `(getopts)2>/dev/null` for ancient sh + package.sh: fix LD_LIBRARY*_PATH initialization + cc.next.m68k: add for _POSIX_SOURCE and linker multiply defined syms +00-12-12 ratz: add --meter + package.sh: a few VPATH fixes + Makefile: don't override *.mips* cc if -version not accepted +00-12-11 package.mk: *.inx now contains name=value +00-12-07 package.sh: handle PC netscape . => _ pathname mangle + WWW.mk: .tar.gz => .tgz +00-11-27 package.sh: add checklicense() to do license checks at read time + package.mk: change component list from preformat to table +00-10-31 package.mk: *.pkg must assert closure + package.mk: add cc- variants to list.package.binary + package.sh: omit dups from package list + package.sh: invalid arg gives one line Usage + package.sh: relax checkaout checks for non-owners + package.sh: package use sets NPROC if not already set or [01] + proto.c: add $(INSTALLROOT)/include/ast hack +00-10-26 WWW.mk: add .SOURCE rhs to :WWWPAGE: +00-10-25 package: fix install + package.mk: add list.install +00-10-22 regress: fix VIEW to skip empty dirs +00-10-19 package.mk: $(PACKAGEROOT)/bin/nmake => $(PACKAGEROOT)/bin/manmake + iffe: validate #define identifiers +00-10-18 C+probe: mac os10 additions + package: add DYLD_LIBRARY_PATH initialization + add ldd.$(CC.HOSTTYPE) +00-10-01 iffe: handle -I* -L* options +00-09-21 mamake: add libxxx and xxx to makefile ordered prereqs +00-09-19 C+probe: add probe_longlong +00-09-11 package: drop manmake and $PACKAGEROOT/bin/nmake +00-09-08 iffe: verfiy that $cc is a C compiler +00-06-14 mamprobe: fix win32.* probe + mamake: fix bug that used lower view path for generation + package: don't clobber $PACKAGEROOT/bin/nmake +00-06-01 C+probe: fix stdinclude *again* + package: fix write delta source to use default pax format + package: add disambiguating bias for sgi.mips3 over sgi.mips4 + package.mk: fix for directory content packages lib ast-locale +00-05-01 iffe: fix invalid _LIB_ macro identifier +00-04-11 C+probe: uniq stdinclude and stdlib, fix usrinclude +00-04-01 regress: fix explicit OUTPUT bug that didn't compare with expected +00-03-17 package: all archives are .tgz for binary download + package: $(PACKAGEROOT)/LICENSES/* in source and binary archives + package: implement install and verify actions + iffe: add exp, pth file dir ..., fix lib - -lfoo, fix lib - - -la -lb + iffe: -L* must affect LD_LIBRARY* hacks for .exe tests -- yuk + package.mk: add *.pkg :INDEX: +00-03-07 package: add admin action +00-03-06 makefile: install optional make probe override script C+make+probe.lcl +00-02-14 --- release 1.0 --- + ratz: treat "foo/" as a dir, not a regular file + package: clarify source and binary installation instructions + package: fix so binary packages can install without cc + package: "ratz" now a non-archive package (the only one) for bootstrap + package: handle VPATH=a:b arg + package.mk: "ratz" package adjustments + Makefile: use :PACKAGE_INIT: to support binary INIT packages + WWW.mk: add :WWWALL: + C.probe: fix .so check that let .dll slip through + iffe: fix config sh var assignment for HAVE_member_IN_struct + iffe: fix config sh var assignment for symbol_DECLARED + package: delay PATH export until dll hack exports complete + package: don't forget binary package $(INSTALLROOT)/lib(32|64) + package: add delta change log for source packages +00-02-10 mamprobe: add mam_cc_DLLBIG + package: fix spelling typos + package: add html help output + package.mk: beef up source and binary help => html +00-02-08 package: mkdir man/man[138] in the new arch to cover MAM bug +00-01-28 package,release: add -rcount to release + package: fix linux "host cpu" and "host rating" + package: copy *.lic to $PACKAGEBIN for "make" and "write binary" + package: fix 'release change log' case match +00-01-24 package: add copyright action + mamprobe: add -D_BLD_DLL to mam_cc_DLL +00-01-11 package: tsort for package write + package: early verification that $CC works + package: add non-interactive command arg for use action + proto: fix -C intermediate mkdir() + mamprobe: unixware.i386 ksh workaround + C.probe: move hosttype to C.probe (with unixware.i386 workaround) + WWW.mk: fix mm2html option quoting + WWW.mk: add .SCAN.mm + WWW.mk: don't force static=1; grab dll's instead + *.sh: fix getopts test to handle botched implementations like osf.alpha + iffe.sh: fix read -r test +99-12-25 iffe: tweak verbose messages + iffe: hand code non-optget getopts parse + iffe: fix bash quoting bug again + iffe: do test -w . after option parse + package: fix PACKAGEROOT search +99-11-19 --- release 0.2 --- +99-11-19 first working package & friends +99-10-31 change from lib0ast to INIT; add MAM and package bootstrap + hostinfo: gobbled by package +99-10-01 iffe: add --config, yes{...}end no{...}end, fix read -r workaround +99-09-27 iffe: add --all --verbose, --* set options +99-09-22 regress: -v disables long line truncation +99-09-11 WWW.mk: WWWDIR and MM2HTMLINFO are now lists searched in $(HOME) +99-08-11 hostinfo: fix type sgi.mips4 +99-06-24 WWW.mk: add +99-06-08 hostinfo.sh: ${TMPDIR:-/tmp} +99-06-07 TEST.mk: add +99-06-01 iffe: add `siz type' for _siz_type == sizeof(type) +99-05-11 hostinfo,iffe,regress,use: long options +99-05-01 C.probe: fix over aggressive stdinclude, e.g., /usr/include/machine +99-04-01 hostinfo: sgi.mips? -o32 and -n32 checks + iffe: check that . is writable +99-03-17 hostinfo: fix for cc not found + dl.c,hello.c,m.c: headers in conditionals to force .DONTCARE + C.probe: extra check for include dirs pulled in by <sys/types.h> +99-03-03 regress: add `UNIT - ...' for extra args + Makefile: add (_hosttype_) prereq for cc +99-01-23 hostinfo: tweak rating, use /proc/cpuinfo if there +99-01-11 C.probe: shlib before lib, /usr before / +98-12-25 iffe: work around win32.alpha intrinsic clash with -O +98-11-11 regress: fix UNIT PATH lookup +98-11-01 regress: add PROG +98-10-01 hostinfo: add unixware.* + use: export PACKAGE_* +98-08-11 C.probe: add /usr/include check (for sco CC) + hostinfo: handle uwin uname update +98-05-01 regress: fix bug sometimes didn't list last test +98-04-01 hostinfo: add cc path arg + hostinfo: now works with /bin/sh + Makefile: strengthed -lm probe +98-01-23 Makefile: check for -ldl -lm + C.probe: handle gcc -v -E phony include dirs + iffe: fix lcl by dropping sort -u -- we need the real first + iffe: `mem x' to test if x is a non-opaque struct +98-01-11 $(INSTALLROOT)/lib32 for sgi.mips3 + $(INSTALLROOT)/lib64 for sgi.mips4 + add cc.hp.pa +98-01-01 cc.sgi.mips*: turn off ld library multiply defined +97-10-11 regress: add VIEW function for locating data +97-10-01 Makefile: -ldl test moved to libdll Makefile +97-08-11 regress: add MOVE + regress: add SAME + regress: use getopts + regress: `EXEC' repeats previous test +97-07-17 use: tweak PATH and LIBPATH bootstrap order + iffe: fix lcl bug that botched pathnames with embedded spaces +97-06-12 iffe: add npt `needs prototype' test +97-05-09 hostinfo: mvs.* => mvs.390 + Makefile: cc.$(_hosttype_) workaround installed here + iffe: fix nolink{ ... }end + iffe: add [no]static{ ... }end for static link test + C.probe: _probe_PATH => _probe_export which must be eval'd +97-04-01 use: _RLD_ROOT set too +97-03-17 mm2html: changed inner loop + mm2html: handle .if|.ie|.el, .so + mm2html: handle different man styles + mm2html: differentiate mm/man in some non-obvious cases + hostinfo: r5000 is not mips4 +97-02-14 hostinfo: validate type with cc +96-12-25 C.probe: uwin tweaks + iffe: use `...` instead of $(...) for alpha /bin/sh + iffe: fix `typ' divide by 0 + iffe: `lcl' now drops X: prefix + iffe: +l* -> -l* + iffe: eval around ${...#%...} for bsd /bin/sh + use: add sgi.mips LD_LIBRARY<abi>_PATH variants + use: add -e to list exports + iffe: lcl leaves leading [a-zA-Z]: for dos + iffe: fix no{link|output|execute} logic + C.probe: don't automatically add /usr/include for non-hosted compilers + C.probe: don't automatically place /usr/include last + C.probe: check gcc style -v -E for stdinclude usrinclude +96-11-28 iffe: check BASH_VERSION for IFS botch + iffe: typ long.xxx only if sizeof(long xxx) != sizeof(xxx) + hostinfo: fix sgi.mips[234] tests + hostinfo: fix ncr.i386 tests +96-10-31 iffe: work around old bsh here doc bug by running separate sh +96-10-11 iffe: *.iffe and *.iff for iffe src files + hostinfo: tighten sgi.mips cpu type check +96-10-01 C.probe: add probe_libdir to catch alpha /usr/shlib +96-09-17 iffe: fix typ bug that failed for single id types! +96-08-31 hostinfo: handle recent sgi hinv cpu changes +96-07-17 make sure sizeof(long xxx)>sizeof(xxx) for typ long.xxx +96-05-09 C.probe: drop multiple / in stdinclude +96-02-29 use: package root must have bin and lib subdir + mm2html: add + C.probe: probe_members += -whole-archive for gcc + iffe: add + fix the blasted `...'...\\...'...` +96-01-31 use: add pkg dir + hostinfo: add tandem +96-01-01 hostinfo: windows_nt|windows[0-9][0-9] -> win32 +95-11-24 hostinfo: linux-aout.* for non-elf linux +95-11-11 use: add aix LIBPATH +95-10-11 hostinfo: no args prints type +95-08-11 use: add +95-05-09 save original PATH in _probe_PATH + beef up library dir probe +95-04-01 use c source suffix if it still preserves the dialect + add hostinfo + add lib/hostinfo/typemap user type map + add sol.sun4 cpu count + fix C.probe to properly handle C/C++ combined compiler drivers + add NeXT to hostinfo + bummer: mach has /usr/bin/hostinfo +95-03-19 fix dialect executable test +95-03-19 --- release 0.0 --- diff --git a/src/cmd/INIT/TEST.mk b/src/cmd/INIT/TEST.mk new file mode 100644 index 0000000..adc4390 --- /dev/null +++ b/src/cmd/INIT/TEST.mk @@ -0,0 +1,197 @@ +/* + * regression test support + * + * @(#)TEST.mk (AT&T Research) 2010-05-19 + * + * test management is still in the design phase + */ + +/* + * three forms for :TEST: + * + * :TEST: xxx yyy ... + * + * $(REGRESS) $(REGRESSFLAGS) xxx.tst + * $(REGRESS) $(REGRESSFLAGS) yyy.tst + * + * :TEST: xxx.tst yyy ... + * + * $(REGRESS) $(REGRESSFLAGS) xxx.tst yyy ... + * + * :TEST: xxx.c [ :: test-prereq ... :: ] [ args [ : args ... ] ] + * + * :TEST: xxx.sh [ :: test-prereq ... :: ] [ args [ : args ... ] ] + * + * xxx :TEST: prereq ... + * [ action ] + * + * $(*) if no action + */ + +":TEST:" : .MAKE .OPERATOR + local B G P S T + test : .INSERT .TESTINIT + if "$("tests":T=FD)" + .SOURCE : tests + end + P := $(>:O=1) + if "$(P:N=*.tst)" && ! "$(@:V)" + B := $(P:B) + if ! ( T = "$(<:V)" ) + T := $(B) + end + test : - test.$(T) + eval + test.$$(T) : $$(B).tst + $$(REGRESS) $$(REGRESSFLAGS) $$(*) $(>:V:O>1) + :SAVE: $$(B).tst + end + elif "$(P:N=*@(.sh|$(.SUFFIX.c:/ /|/G)|$(.SUFFIX.C:/ /|/G)))" + B := $(P:B) + if ! ( T = "$(<:V)" ) + T := $(B) + end + :INSTALLDIR: $(B) + $(B) :: $(P) $(*:-l*|*$(CC.SUFFIX.ARCHIVE)) + if "$(P:N=*.sh)" + TESTCC == $(CC) + $(B) : (TESTCC) + end + test : - test.$(T) + if "$(@:V)" + eval + test.$$(T) : $$(B) $(>:V:O>1) + set +x; (ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0; set -x + $(@:V) + end + elif "$(>:V:O>1)" + local I A V X S R=0 + for A $(>:V:O>1) + if A == "::" + let R = !R + elif A == ":" + let I = I + 1 + test.$(T).$(I) := $(V:V) + V = + X := $(X:V)$(S)$$(*) $$(test.$(T).$(I):T=*) + S = $("\n") + elif A != "-l*|*$(CC.SUFFIX.ARCHIVE)" + if R + test.$(A) : .VIRTUAL .FORCE + test.$(T) : test.$(A) + else + V += $(A:V) + end + end + end + if V + let I = I + 1 + test.$(T).$(I) := $(V:V) + X := $(X:V)$(S)$$(*) $$(test.$(T).$(I):T=*) + end + eval + test.$$(T) : $$(B) + set +x; (ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0; set -x + $(X:V) + end + else + eval + test.$$(T) : $$(B) + set +x; (ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0; set -x + $$(*) + end + end + elif ! "$(<:V)" + G = 1 + for B $(>) + if B == "-|--" + let G = !G + else + if ! G + T = + elif ! ( T = "$(B:A=.COMMAND)" ) && ! "$(B:A=.TARGET)" + for S .c .sh + if "$(B:B:S=$(S):T=F)" + :INSTALLDIR: $(B) + $(B) :: $(B:B:S=$(S)) + T := $(B) + break + end + end + end + test : - test.$(B) + test.$(B) : $(T) - $(B).tst + $(REGRESS) $(REGRESSFLAGS) $(*:N=*.tst) $(*:N!=*.tst) + :SAVE: $(B).tst + end + end + else + if "$(>:V)" || "$(@:V)" + P := $(>) + T := $(P:O=1) + B := $(T:B) + if "$(T)" != "$(B)" && "$(T:G=$(B))" + :INSTALLDIR: $(B) + $(B) :: $(T) $(P:O>1:N=-*) + T := $(B) + P := $(B) $(P:O>1:N!=-*) + end + if "$(<:V)" + T := $(<:V) + end + test : - test.$(T) + if "$(@:V)" + eval + test.$$(T) : $$(P) $(>:V:O>1) + set +x; (ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0; set -x + $(@:V) + end + else + test.$(T) : $(P) + set +x; (ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0; set -x + $(*) + end + else + test : - test.$(<) + test.$(<) : $(<).tst $(<:A=.COMMAND) + $(REGRESS) $(REGRESSFLAGS) $(*) + end + end + +.TESTINIT : .MAKE .VIRTUAL .FORCE .REPEAT + if VARIANT == "DLL" + error 1 :DLL: tests skipped + exit 0 + end + set keepgoing + REGRESSFLAGS &= $(TESTS:@/ /|/G:/.*/--test=&/:@Q) + +.SCAN.tst : .SCAN + $(@.SCAN.sh) + I| INCLUDE@ % | + +.ATTRIBUTE.%.tst : .SCAN.tst + +MKTEST = mktest +MKTESTFLAGS = --style=regress + +/* + * test scripts are only regenerated from *.rt when --force + * is specified or the .rt file is newer than the script + * otherwise the script is accepted if it exists + * + * this avoids the case where a fresh build with no state + * would regenerate the test script and capture current + * behavior instead of expected behavior + */ + +%.tst : %.rt + if [[ "$(-force)" || "$(>)" -nt "$(^|<)" ]] + then $(MKTEST) $(MKTESTFLAGS) $(>) > $(<) + fi + +test%.sh test%.out : %.rt + if [[ "$(-force)" || "$(>)" -nt "$(^|<:O=1)" ]] + then $(MKTEST) --style=shell $(>) > $(<:N=*.sh) + $(SHELL) $(<:N=*.sh) --accept > $(<:N=*.out) + fi diff --git a/src/cmd/INIT/WWW.mk b/src/cmd/INIT/WWW.mk new file mode 100644 index 0000000..4542dae --- /dev/null +++ b/src/cmd/INIT/WWW.mk @@ -0,0 +1,450 @@ +/* + * post stuff to WWWDIR for web access + * index generated from *.mm + */ + +WWWDIR = wwwfiles public_html +WWWSAVE = +WWWSTYLE = +WWWTYPES = + +.WWW.semaphore : .SEMAPHORE + +.EXPORT : WWWSTYLE WWWTYPES + +/* + * item :WWW: [style=frame] [save=pattern] file ... + * + * `item'.mm generates index.html + * other files copied to $(WWWDIR)/`item' + * sets up www.bin + */ + +":WWW:" : .MAKE .OPERATOR + local A B D I J L X E P R M + .WWW.LOCAL .WWW.REMOTE : .DO.NOTHING + WWWDIR := $(HOME:X=$(WWWDIR):T=F:O=1) + B := $(*:N=*.mm::O=1:B) + D := $(WWWDIR)/$(B) + M := $(WWWDIR)/man/man1 + R := $(>:N!=*=*) + for I $(>:N=*=*) + A := WWW$(I:/=.*//:F=%(upper)s) + $(A) := $(I:/.*=//) + end + (html_info) : $$(MM2HTMLINFO) $$(MM2HTMLINIT) + if WWWSTYLE == "frame" + %.html %-index.html : %.mm (html_info) + $(MM2HTML) $(MM2HTMLFLAGS) $(%:N=faq.*:?> $(<:O=1)?-f $(%) -x?) -o WWWTYPES=$(WWWTYPES:@Q:@Q) $(WWWSOURCE.$(%)) $(>) + else + %.html : %.mm (html_info) + $(MM2HTML) $(MM2HTMLFLAGS) -o WWWTYPES=$(WWWTYPES:@Q:@Q) $(>) $(WWWSOURCE.$(%)) > $(<) + end + %.html : %.1 (html_info) + $(MM2HTML) $(MM2HTMLFLAGS) $(>) $(WWWSOURCE.$(%)) > $(<) + %-man.html : $(BINDIR)/% (html_info) + ignore $(>) --html 2> $(<) + .DO.WWW.MAN : .USE + if { test '' = '$(*)' || { strings $(*) | egrep -q '\[\+NAME\?|libcmd\.|cmd[0-9][0-9]\.' ;} ;} && [[ "$( $(<:B) '--???html' -- 2>&1 )" == version=[1-9]* ]] + then ( $(<:B) '--??html' -- 2>$(<) ) || true + fi + if 0 + $(M)/%.html : .DONTCARE $(INSTALLROOT)/bin/% + $(@.DO.WWW.MAN) + end + if "$(<)" + D := $(<) + elif ! "$(R)" + return + end + .WWW .WWW.BIN : $(D) $(M) - + $(D) $(M) : + $(SILENT) test -d $(<) || mkdir $(<) + if ( J = "$(R:N=*.mm)" ) + for I $(J:G=%.html) + if I == "*-index.html" + O := $(D)/index.html + else + O := $(I:D=$(D):B:S) + end + .WWW : $(O) + $(O) :COPY: $(I) + end + end + .WWW.req : .FUNCTION + return $(*$(%:T=SR):N=-l*:T=F:P=B:N!=-l*|/*) + A = 0 + for I $(R:N!=*.mm) + if I == "-" + let A = ! A + elif I == "-l*" + L := $(I:/-l//) + if J = "$(.DLL.NAME. $(L) $($(L).VERSION):T=F)" + X += $(J) + end + elif A || "$(I:A=.COMMAND|.ARCHIVE)" || "$(I:D:D:N=$(INSTALLROOT))" || "$(I:N=*-www)" + X += $(I) + if "$(I:A=.COMMAND)" + X += $$(.WWW.req $(I)) + J := $(I:/-www$//) + eval + .WWW : $(J:D=$(M):B:S=.html) + $(J:D=$(M):B:S=.html) : $(I) $(I:B:S=.1:T=F:?$(I:B:S=.1)??) + if strings $$(*:O=1) | egrep -q '\[\+NAME\?|libcmd\.|cmd[0-9][0-9]\.' + then $$(IGNORE) $$(*:O=1) '--??html' -- 2>&1 + elif test '' != '$$(*:N=*.1)' + then $$(MM2HTML) $$(*:N=*.1) + fi > $$(<) + end + end + else + if I == "*.html" + $(I) : .TERMINAL + end + .WWW : $(D)/$(I) + $(D)/$(I) :COPY: $(I) + end + end + if "$(X:V)" + .WWW.EDIT. : .FUNCTION + local E I J + for I $(.INSTALL.LIST.:C,^$(INSTALLROOT)/,,:N!=lib/lib/*) + for J $(%) + if "$(I:B:S)" == "$(J:B:S)" + E += -s ',^$(J)$,$(I),' + end + end + end + return $(E) + .WWW.LIST. : .FUNCTION + local E I J + for I $(.INSTALL.LIST.:C,^$(INSTALLROOT)/,,:N!=lib/lib/*) + for J $(%) + if "$(I:B:S)" == "$(J:B:S)" + E += $(I) + end + end + end + return $(E) + .WWW .WWW.BIN : $(D)/$(B)-$(CC.HOSTTYPE).tgz + $(D)/$(B)-$(CC.HOSTTYPE).tgz : $(X:V) + cat > X.$(tmp).X <<! + This archive contains $(CC.HOSTTYPE) binaries for + $(.WWW.LIST. $(*)) + Add the bin directory to PATH and the lib directory + to LD_LIBRARY_PATH or its equivalent for your system. + Use the --?help and --man options for online help, + documentation and contact info. + ! + $(PAX) -wvf $(<) -x tar:gzip -s "/X.$(tmp).X/README/" $(.WWW.EDIT. $(*)) -s ',\(.*\)-www$,bin/\1,' -s ',.*/lib/,lib/,' X.$(tmp).X $(*:N!=-l*) + $(RM) -f X.$(tmp).X + end + +/* + * item ... :WWWBIN: index.mm file ... host:arch ... + * + * home page control + * `host' of type `arch' for www.bin files + */ + +":WWWBIN:" : .MAKE .OPERATOR + local HOST ITEM ARCH BINS DIRS G + .WWW.NOMAN. += $(<) + for HOST $(>) + TYPE := $(HOST:/.*://) + HOST := $(HOST:/:.*//) + WWWTYPES += $(TYPE) + ARCH := $(PWD:D:C,/$(CC.HOSTTYPE)/,/$(TYPE)/) + BINS := + DIRS := + for ITEM $(<) + if TYPE == "$(CC.HOSTTYPE)" + G := $("index.mm":G=%.html:D=$(WWWDIR)/$(ITEM):B:S) + .WWW.LOCAL : $(G) + eval + $(G) : .JOINT $(ARCH)/$(ITEM)/$(ITEM).mm (html_info) .WWW.semaphore .FORCE + cd $$(*:D) + $$(MAKE) $$(-) $$(=) www + end + else + BINS += $(WWWDIR)/$(ITEM)/$(ITEM)-$(TYPE).tgz + DIRS += $(ARCH)/$(ITEM) + end + end + .WWW.REMOTE : $(BINS) + ARCH := $(ARCH:C,/src/.*,,) + eval + $(BINS) :JOINT: .FORCE .WWW.semaphore + rsh $(HOST) " + eval \"\`bin/package debug use\`\" + PATH=\$PATH:$(PATH):/usr/ccs/bin + umask 022 + for dir in $(DIRS) + do cd \$dir + $(MAKE) $(-) $(=) --errorid=\$dir www.bin + done + " + end + end + +/* + * :WWWPOST: [ host [ dir [ tmp ] ] ] + * + * post local $(WWWDIR) to host:dir putting archives in host:tmp/www-*.pax + * defaults: host=www dir=$(WWWDIR) tmp=tmp + */ + +":WWWPOST:" : .MAKE .OPERATOR + local ( host dir tmp ignore ... ) $(>) www $(WWWDIR:B:S) tmp ignore + :ALL: delta.pax + .WWW.ALL : .WWW.REMOTE - .WWW.LOCAL + eval + .POST : .VIRTUAL base.pax delta.pax + case "$$(>)" in + '') ;; + *) $$(>:C,.*,rcp & $(host):$(tmp)/$(dir)-&;,) + rsh $(host) ' + umask 022 + PATH=$HOME/bin:$PATH + cd $(dir) + pax -rvf $HOME/$(tmp)/$(dir)-delta.pax -z $HOME/$(tmp)/$(dir)-base.pax + ' + ;; + esac + end + base.pax : + cd $(WWWDIR) + pax -wvf $(<:P=A) . + .base.list. : .FUNCTION + local X + X := $(sh pax -f $(%:N=*.pax):C,\n, ,G:C,^,$$(WWWDIR)/,) + $(X) : .DONTCARE + return $(X) + delta.pax : .WWW.ALL base.pax $$(.base.list. $$(*)) + cd $(WWWDIR) + pax -wvf $(<:P=A) -z $(*:N=*.pax:P=A) . + +.WWW.FAQ : .USE + { + set -o noglob + print .xx title=\"$(<:B:/\..*//) FAQ index\" + print .MT 4 + print .TL + print + print .H 1 \"$(<:B:/\..*//) FAQ index\" + print .BL + for i in $(*) + do exec < $i || exit 1 + e=0 l=0 x=y + while read -r op a1 a2 + do case $op in + .H) case $e in + 0) e=1 ;; + 1) print .LE ;; + esac + print .sp + print .LI + a2=${a2//\"/} + a2=${a2%\ [Ff][Aa][Qq]} + f=${i%.*}.html + f=${f#*/} + print .xx link=\"$f' '$a2\" + print .sp + print .NL + ;; + .AL|.BL|.NL) + case $x in + y) x=x ;; + *) x=xx$x ;; + esac + ;; + .LE) x=${x%xx} + ;; + .LI) case $x in + x) x= + print .LI + ;; + esac + ;; + .sp) case $x in + '') x=x ;; + esac + ;; + *) case $x in + '') print -r -- $op $a1 $a2 ;; + esac + ;; + esac + done + case $e in + 1) print .LE ;; + esac + done + print .LE + } > $(<) + +/* + * [ dir ] :WWWPAGE: [ source ... ] file.mm file + * + * *.mm generates *.html + * faq.*.mm generates faq.mm + * other files copied to $(WWWDIR)[/dir] + * files after - (toggle) are just asserted on :: + */ + +":WWWPAGE:" : .MAKE .OPERATOR + local B D I J O P Q S X G A + A = 0 + D := $(<:O=1) + P := $(>:N!=*=*) + S := $(>:N=*=*) + if X = "$(P:B:S:N=faq.*.mm)" + Q := $(D:+$(D).)faq.mm + $(Q) : .WWW.FAQ $(X) + P += $(Q) + end + if D + B := $(D:B) + if D != "/*" + D := $(WWWDIR)/$(D) + $(D) :INSTALLDIR: + .WWW.LOCAL : $(D) + end + for I $(<:B) + .WWW.LOCAL : $(WWWDIR)/man/man1/$(I).html + $(WWWDIR)/man/man1/$(I).html : .DONTCARE + end + for I $(P) + if I == "-" + let A = !A + continue + end + if A || I == "$(WWWSAVE)" + :: $(I) + continue + end + if "$(I:T=FD)" + .SOURCE : $(I) + if "$(<)" + WWWSOURCE.$(<:O=1) += $(I:T=F:P=L=*) + end + continue + end + if I == "*.html" + $(I) : .TERMINAL + O := $(I) + X := $(I) + elif ( G = "$(I:G=%.html)" ) + $(G) : .IMPLICIT $(S) $(I) + if $(G:O) > 1 + for J $(G) + if J == "*-index.html" + if J == "faq.*.*" + continue + end + O := index.html + else + O := $(J) + end + .WWW.LOCAL : $(D)/$(O) + $(D)/$(O) :INSTALL: $(J) + end + continue + end + if X + X := $(I) + else + X := index + end + I := $(I:B:S=.html) + O := $(X:B:S=.html) + else + O := $(I) + end + $(D)/$(O) :INSTALL: $(I) + .WWW.LOCAL : $(D)/$(O) + end + else + for I $(P) + if I == "-" + let A = !A + continue + end + if A || I == "$(WWWSAVE)" + :: $(I) + continue + end + if "$(I:T=FD)" + .SOURCE : $(I) + continue + end + if I == "*.html" + $(I) : .TERMINAL + O := $(I) + elif ( O = "$(I:G=%.html)" ) + $(O) : $(S) .IMPLICIT $(I) + end + for J $(O) + if J == "*-index.html" + X := index.html + else + X := $(J) + end + X := $(WWWDIR)/$(X) + .WWW.LOCAL : $(X) + $(X) :COPY: $(J) + end + end + end + +/* + * rhs done by default + */ + +":WWWALL:" : .MAKE .OPERATOR + .WWW.ALL : $(>) + +":WWWMAN:" : .MAKE .OPERATOR + .INIT : .WWW.MAN + .WWW.MAN. := $(>) + .WWW.MAN : .MAKE .FORCE + local H I + for I $(.WWW.MAN.) + .WWW.LOCAL : $(WWWDIR)/man/man1/$(I:B).html + $(WWWDIR)/man/man1/$(I:B).html : .DO.WWW.MAN $(I) + end + for I $(sh builtin:B) + .WWW.LOCAL : $(WWWDIR)/man/man1/$(I).html + $(WWWDIR)/man/man1/$(I).html : .DO.WWW.MAN - + end + for I $("$(BINDIR)/*([!-.])":P=G:B) + if I != "*_*" + H := $(WWWDIR)/man/man1/$(I).html + if ! "$(*$(H))" && I != "$(.WWW.NOMAN.:/ /|/G)" + .WWW.LOCAL : $(H) + end + elif "$(PATH:/:/ /G:X=$(I:/.*_//):T=F:O=1)" + H := $(WWWDIR)/man/man1/$(I:/.*_//).html + .WWW.LOCAL : $(H) + $(H) : .DO.WWW.MAN $(BINDIR)/$(I) + end + end + +.WWW.SED. : .FUNCTION + local E T + E = s/^\(\.xx.link=.*\)%HOSTTYPE%\(.*\)%HOSTTYPE%\(.*\)/ + for T $(%) + E := $(E:V)\$$("\n").LI\$$("\n")\1$(T)\2$(T)\3 + end + return $(E:V)/ + +/* + * mm scan support + */ + +.SCAN.mm : .SCAN + O|S| + I|.sn %|A.DONTCARE|M$$(%)| + I|.so %|A.DONTCARE|M$$(%)| + +.ATTRIBUTE.%.mm : .SCAN.mm diff --git a/src/cmd/INIT/ar.ibm.risc b/src/cmd/INIT/ar.ibm.risc new file mode 100755 index 0000000..0247643 --- /dev/null +++ b/src/cmd/INIT/ar.ibm.risc @@ -0,0 +1,9 @@ +: stupid stupid stupid to require a non-standard option for ar to work : 2009-10-06 : + +op=$1 +shift +case $op in +-*) ;; +*) op=-$op ;; +esac +/usr/bin/ar -Xany "$op" "$@" diff --git a/src/cmd/INIT/cc.darwin b/src/cmd/INIT/cc.darwin new file mode 100755 index 0000000..081bd43 --- /dev/null +++ b/src/cmd/INIT/cc.darwin @@ -0,0 +1,73 @@ +: unix wrapper for mac osx cc : 2012-01-20 : + +HOSTTYPE=darwin.generic + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +CC=/usr/bin/cc +op=init +for arg +do case $op in + init) op=ld + set '' + ;; + esac + case $arg in + -c) op=cc + ;; + -E) op=cpp + continue + ;; + -G) op=dll + continue + ;; + -lc) continue + ;; + -lm) continue + ;; + -O) continue + ;; + esac + set "$@" "$arg" +done +case $# in +0) ;; +*) shift ;; +esac +case $* in +-v) $CC "$@"; exit ;; +esac +case $op in +init) echo "cc: arguments expected" >&2 + exit 1 + ;; +cpp) $CC -E "$@" + ;; +cc) $CC -DCLK_TCK=100 "$@" + ;; +dll) # what a compatibility mess -- surely they can get the apis to play nice + tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err + trap "rm -f $tmp" EXIT + case `MACOSX_DEPLOYMENT_TARGET=10.3 ld -undefined dynamic_lookup 2>&1` in + *undefined*dynamic_lookup*) + ld -m -flat_namespace -undefined suppress -dylib -dynamic \ + -ldylib1.o "$@" -lcc_dynamic -framework System >$tmp 2>&1 + status=$? + ;; + *) MACOSX_DEPLOYMENT_TARGET=10.3 $CC -Wl,-flat_namespace -dynamiclib -undefined dynamic_lookup "$@" >$tmp 2>&1 + status=$? + ;; + esac + egrep -v ' (warning .*multiple definitions|definition) of ' $tmp >&2 + exit $status + ;; +ld) tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err + trap "rm -f $tmp" EXIT + $CC -Wl,-m -DCLK_TCK=100 "$@" >$tmp 2>&1 + status=$? + egrep -v ' (warning .*multiple definitions of|definition of|as lazy binding|not from earlier dynamic) ' $tmp >&2 + exit $status + ;; +esac diff --git a/src/cmd/INIT/cc.darwin.i386 b/src/cmd/INIT/cc.darwin.i386 new file mode 100755 index 0000000..9afde8d --- /dev/null +++ b/src/cmd/INIT/cc.darwin.i386 @@ -0,0 +1,73 @@ +: unix wrapper for mac osx cc : 2012-02-29 : + +HOSTTYPE=darwin.i386 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +CC='/usr/bin/cc -m32' +op=init +for arg +do case $op in + init) op=ld + set '' + ;; + esac + case $arg in + -c) op=cc + ;; + -E) op=cpp + continue + ;; + -G) op=dll + continue + ;; + -lc) continue + ;; + -lm) continue + ;; + -O) continue + ;; + esac + set "$@" "$arg" +done +case $# in +0) ;; +*) shift ;; +esac +case $* in +-v) $CC "$@"; exit ;; +esac +case $op in +init) echo "cc: arguments expected" >&2 + exit 1 + ;; +cpp) $CC -E "$@" + ;; +cc) $CC -DCLK_TCK=100 "$@" + ;; +dll) # what a compatibility mess -- surely they can get the apis to play nice + tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err + trap "rm -f $tmp" EXIT + case `MACOSX_DEPLOYMENT_TARGET=10.3 ld -undefined dynamic_lookup 2>&1` in + *undefined*dynamic_lookup*) + ld -m -flat_namespace -undefined suppress -dylib -dynamic \ + -ldylib1.o "$@" -lcc_dynamic -framework System >$tmp 2>&1 + status=$? + ;; + *) MACOSX_DEPLOYMENT_TARGET=10.3 $CC -Wl,-flat_namespace -dynamiclib -undefined dynamic_lookup "$@" >$tmp 2>&1 + status=$? + ;; + esac + egrep -v ' (warning .*multiple definitions|definition) of ' $tmp >&2 + exit $status + ;; +ld) tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err + trap "rm -f $tmp" EXIT + $CC -Wl,-m -DCLK_TCK=100 "$@" >$tmp 2>&1 + status=$? + egrep -v ' (warning .*multiple definitions of|definition of|as lazy binding|not from earlier dynamic) ' $tmp >&2 + exit $status + ;; +esac diff --git a/src/cmd/INIT/cc.darwin.i386-64 b/src/cmd/INIT/cc.darwin.i386-64 new file mode 100755 index 0000000..9010d96 --- /dev/null +++ b/src/cmd/INIT/cc.darwin.i386-64 @@ -0,0 +1,73 @@ +: unix wrapper for mac osx cc : 2012-02-29 : + +HOSTTYPE=darwin.i386-64 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +CC=/usr/bin/cc +op=init +for arg +do case $op in + init) op=ld + set '' + ;; + esac + case $arg in + -c) op=cc + ;; + -E) op=cpp + continue + ;; + -G) op=dll + continue + ;; + -lc) continue + ;; + -lm) continue + ;; + -O) continue + ;; + esac + set "$@" "$arg" +done +case $# in +0) ;; +*) shift ;; +esac +case $* in +-v) $CC "$@"; exit ;; +esac +case $op in +init) echo "cc: arguments expected" >&2 + exit 1 + ;; +cpp) $CC -E "$@" + ;; +cc) $CC -DCLK_TCK=100 "$@" + ;; +dll) # what a compatibility mess -- surely they can get the apis to play nice + tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err + trap "rm -f $tmp" EXIT + case `MACOSX_DEPLOYMENT_TARGET=10.3 ld -undefined dynamic_lookup 2>&1` in + *undefined*dynamic_lookup*) + ld -m -flat_namespace -undefined suppress -dylib -dynamic \ + -ldylib1.o "$@" -lcc_dynamic -framework System >$tmp 2>&1 + status=$? + ;; + *) MACOSX_DEPLOYMENT_TARGET=10.3 $CC -Wl,-flat_namespace -dynamiclib -undefined dynamic_lookup "$@" >$tmp 2>&1 + status=$? + ;; + esac + egrep -v ' (warning .*multiple definitions|definition) of ' $tmp >&2 + exit $status + ;; +ld) tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err + trap "rm -f $tmp" EXIT + $CC -Wl,-m -DCLK_TCK=100 "$@" >$tmp 2>&1 + status=$? + egrep -v ' (warning .*multiple definitions of|definition of|as lazy binding|not from earlier dynamic) ' $tmp >&2 + exit $status + ;; +esac diff --git a/src/cmd/INIT/cc.hp.ia64 b/src/cmd/INIT/cc.hp.ia64 new file mode 100755 index 0000000..204bd0e --- /dev/null +++ b/src/cmd/INIT/cc.hp.ia64 @@ -0,0 +1,13 @@ +: hp.ia64 cc wrapper for reasonable ansi C defaults : 2011-01-25 : + +[ /usr/bin/cc -ef /usr/ccs/bin/cc ] || exit 1 + +: bundled cc -- really, in the face of gcc you ship a sub-par /usr/bin/cc? : + +HOSTTYPE=hp.ia64 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +/usr/bin/cc -D_HPUX_SOURCE -D_INCLUDE__STDC_A1_SOURCE -D_INCLUDE_XOPEN_SOURCE_500 "$@" diff --git a/src/cmd/INIT/cc.hp.pa b/src/cmd/INIT/cc.hp.pa new file mode 100755 index 0000000..cd5f576 --- /dev/null +++ b/src/cmd/INIT/cc.hp.pa @@ -0,0 +1,13 @@ +: hp.pa cc wrapper for reasonable ansi C defaults : 2004-02-29 : + +HOSTTYPE=hp.pa + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +_AST_CC_hp_pa_DEFAULT=${_AST_CC_hp_pa_DEFAULT-"+DAportable"} + +/opt/ansic/bin/cc -Ae +e -Wl,+s $_AST_CC_hp_pa_DEFAULT \ + ${INSTALLROOT:+-Wl,+cdp,${INSTALLROOT}/lib/:} \ + -Wl,+vnocompatwarnings "$@" diff --git a/src/cmd/INIT/cc.hp.pa64 b/src/cmd/INIT/cc.hp.pa64 new file mode 100755 index 0000000..49f2395 --- /dev/null +++ b/src/cmd/INIT/cc.hp.pa64 @@ -0,0 +1,11 @@ +: hp.pa64 cc wrapper for reasonable ansi C defaults : 2001-02-11 : + +HOSTTYPE=hp.pa64 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +/opt/ansic/bin/cc +D2.0W -Ae +e -Wl,+s \ + ${INSTALLROOT:+-Wl,+cdp,${INSTALLROOT}/lib/:} \ + -Wl,+vnocompatwarnings "$@" diff --git a/src/cmd/INIT/cc.ibm.risc b/src/cmd/INIT/cc.ibm.risc new file mode 100755 index 0000000..17a8f70 --- /dev/null +++ b/src/cmd/INIT/cc.ibm.risc @@ -0,0 +1,63 @@ +: cc wrapper for aix risc xlc : 2009-09-28 : + +hosttype=ibm.risc + +case $HOSTTYPE in +$hosttype-64) + case " $* " in + *" -q64 "*) ;; + *) set -- -q64 "$@" ;; + esac + ;; +*) case " $* " in + *" -q64 "*) HOSTTYPE=$hosttype-64 ;; + *) HOSTTYPE=$hosttype ;; + esac + ;; +esac + +case " $* " in +*" -dumpmachine "*) + echo $HOSTTYPE + exit + ;; +esac + +bin=/usr/vac/bin +cc=$bin/xlc + +ccflags="-brtl -qhalt=e -qsuppress=1506-224:1506-507" +case " $@ " in +*" -G "*) + ccflags="$ccflags -berok" + ;; +esac +if test -x $bin/c99 +then # the xlc optimizer vintage that supports c99 is flawed and causes the ast build to fail # + case " $* " in + *" -O "*) + set '' "$@" '' + shift + while : + do a=$1 + shift + case $a in + '') break ;; + -O) ;; + *) set '' "$@" $a ;; + esac + shift + done + ;; + esac + $cc $ccflags "$@" + code=$? +else export PATH=/bin:$PATH LIBPATH=/usr/lib:/lib + ccflags="$ccflags -blibpath:$LIBPATH" +fi +$cc $ccflags "$@" +code=$? +case $code in +127|255) code=1 ;; +esac +exit $code diff --git a/src/cmd/INIT/cc.ibm.risc.gcc b/src/cmd/INIT/cc.ibm.risc.gcc new file mode 100755 index 0000000..5d4d16b --- /dev/null +++ b/src/cmd/INIT/cc.ibm.risc.gcc @@ -0,0 +1,36 @@ +: cc wrapper for aix risc gcc : 2012-02-14 : + +hosttype=ibm.risc + +case $HOSTTYPE in +$hosttype-64) + case " $* " in + *" -maix64 "*) ;; + *) set -- -maix64 "$@" ;; + esac + ;; +*) case " $* " in + *" -maix64 "*) HOSTTYPE=$hosttype-64 ;; + *) HOSTTYPE=$hosttype ;; + esac + ;; +esac + +case " $* " in +*" -dumpmachine "*) + echo $HOSTTYPE + exit + ;; +esac + +cc=gcc +ccflags= + +case " $@ " in +*" -shared "*) + ccflags="$ccflags -shared -Wl,-G -Wl,-berok" + ;; +*) ccflags="-Wl,-brtl" + ;; +esac +$cc $ccflags "$@" diff --git a/src/cmd/INIT/cc.linux.i386-64-icc b/src/cmd/INIT/cc.linux.i386-64-icc new file mode 100755 index 0000000..4d945bf --- /dev/null +++ b/src/cmd/INIT/cc.linux.i386-64-icc @@ -0,0 +1,22 @@ +: linux.i386-64 icc wrapper : 2011-10-18 : + +HOSTTYPE=linux.i386-64-icc + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +icc=$(which icc 2>/dev/null) +case $icc in +"") if test -f /etc/profile.d/icc.sh + then . /etc/profile.d/icc.sh + fi + icc=$(which icc 2>/dev/null) + case $icc in + "") echo icc: not found >&2 + exit 127 + ;; + esac + ;; +esac +$icc "$@" diff --git a/src/cmd/INIT/cc.linux.i386-icc b/src/cmd/INIT/cc.linux.i386-icc new file mode 100755 index 0000000..09dc25c --- /dev/null +++ b/src/cmd/INIT/cc.linux.i386-icc @@ -0,0 +1,22 @@ +: linux.ia64 icc wrapper : 2011-10-18 : + +HOSTTYPE=linux.ia64-icc + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +icc=$(which icc 2>/dev/null) +case $icc in +"") if test -f /etc/profile.d/icc.sh + then . /etc/profile.d/icc.sh + fi + icc=$(which icc 2>/dev/null) + case $icc in + "") echo icc: not found >&2 + exit 127 + ;; + esac + ;; +esac +$icc "$@" diff --git a/src/cmd/INIT/cc.linux.ia64-icc b/src/cmd/INIT/cc.linux.ia64-icc new file mode 100755 index 0000000..09dc25c --- /dev/null +++ b/src/cmd/INIT/cc.linux.ia64-icc @@ -0,0 +1,22 @@ +: linux.ia64 icc wrapper : 2011-10-18 : + +HOSTTYPE=linux.ia64-icc + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +icc=$(which icc 2>/dev/null) +case $icc in +"") if test -f /etc/profile.d/icc.sh + then . /etc/profile.d/icc.sh + fi + icc=$(which icc 2>/dev/null) + case $icc in + "") echo icc: not found >&2 + exit 127 + ;; + esac + ;; +esac +$icc "$@" diff --git a/src/cmd/INIT/cc.lynxos.i386 b/src/cmd/INIT/cc.lynxos.i386 new file mode 100755 index 0000000..acd0d02 --- /dev/null +++ b/src/cmd/INIT/cc.lynxos.i386 @@ -0,0 +1,81 @@ +: lynxos.i386 cc wrapper with -dynamic default : 2005-02-14 : + +HOSTTYPE=lynxos.i386 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=gcc + +link=1 +static=0 +set . "$@" /../ +while : +do shift + case $1 in + /../) break ;; + esac + case $1 in + *.[cChHiI]|*.[cChHiI][pPxX][pPxX]) + set . -D__NO_INCLUDE_WARN__ -I/sys/include/kernel -I/sys/include/family/x86 "$@" + shift + break + ;; + -o) case $2 in + /../) ;; + *) x=$1 + shift + set . "$@" "$x" + shift + ;; + esac + ;; + -static)static=1 + ;; + -l*) case $static in + 0) static=n + set . -L/lib/shlib "$@" + shift + ;; + esac + ;; + -[cE]) link=0 + ;; + esac + x=$1 + shift + set . "$@" "$x" +done +while : +do case $1 in + /../) shift + break + ;; + -l*) case $static in + 0) static=n + set . -L/lib/shlib "$@" + shift + ;; + esac + ;; + -[cE]) link=0 + ;; + esac + x=$1 + shift + set . "$@" "$x" + shift +done +case $link:$static in +1:0) static=n ;; +esac +case $static in +n) specs=/tmp/cc$$.specs + trap 'status=$?; rm -f $specs; exit $status' 0 1 2 + echo '*link: %{shared:-shared} %{static:-static} %{mshared|shared: %{static: %eerror: -shared and -static may not be combined. }}' > $specs + $cc -specs=$specs "$@" + ;; +*) $cc "$@" + ;; +esac diff --git a/src/cmd/INIT/cc.lynxos.ppc b/src/cmd/INIT/cc.lynxos.ppc new file mode 100755 index 0000000..32738f2 --- /dev/null +++ b/src/cmd/INIT/cc.lynxos.ppc @@ -0,0 +1,85 @@ +: lynxos.ppc cc wrapper with -mshared default : 2005-06-01 : + +HOSTTYPE=lynxos.ppc + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=gcc + +link=1 +static=0 +set . "$@" /../ +while : +do shift + case $1 in + /../) break ;; + esac + case $1 in + *.[cChHiI]|*.[cChHiI][pPxX][pPxX]) + set . -D__NO_INCLUDE_WARN__ -I/sys/include/kernel -I/sys/include/family/ppc "$@" + shift + break + ;; + -o) case $2 in + /../) ;; + *) x=$1 + shift + set . "$@" "$x" + shift + ;; + esac + ;; + -static)static=1 + ;; + -mshared) + static=n + continue + ;; + -l*) case $static in + 0) static=n + set . -L/lib/shlib "$@" + shift + ;; + esac + ;; + -[cE]) link=0 + ;; + esac + x=$1 + shift + set . "$@" "$x" +done +while : +do case $1 in + /../) shift + break + ;; + -l*) case $static in + 0) static=n + set . -L/lib/shlib "$@" + shift + ;; + esac + ;; + -[cE]) link=0 + ;; + esac + x=$1 + shift + set . "$@" "$x" + shift +done +case $link:$static in +1:0) static=n ;; +esac +case $static in +n) specs=/tmp/cc$$.specs + trap 'status=$?; rm -f $specs; exit $status' 0 1 2 + echo '*link: %{shared:-shared} %{static:-static} %{mshared|shared: %{static: %eerror: -shared and -static may not be combined. }}' > $specs + $cc -specs=$specs -mshared "$@" + ;; +*) $cc "$@" + ;; +esac diff --git a/src/cmd/INIT/cc.mvs.390 b/src/cmd/INIT/cc.mvs.390 new file mode 100755 index 0000000..50bc7d5 --- /dev/null +++ b/src/cmd/INIT/cc.mvs.390 @@ -0,0 +1,279 @@ +: mvs.390 cc wrapper for unix message and exit code semantics : 2012-01-20 : + +HOSTTYPE=mvs.390 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +ar=ar +cc=/bin/c89 +CC=/bin/c++ +ccflags="-D_ALL_SOURCE -Wc,dll" +objmax=60 +tmpfiles= +unbotch= + +# -n as *first* arg shows but does not do +# -Wc,exportall => -Wl,dll +# -Bdynamic => .c,.o dynamic +# -Bstatic => .c,.o static +# *.C => cc=$CC +# *.cpp => cc=$CC +# *.cxx => cc=$CC +# no optimization until the optimizer is fixed: +# -O dropped (no optimization) +# -0 dropped (no optimization) +# -1 -O (default level 1 optimization) +# -2 -2 (maximal level 2 optimization) + +let argc=0 cmp=0 dll=0 libc=0 dynamic=1 dynamic_objc=0 static_objc=0 relc=0 botched=0 +case $1 in +-n) exec=print + shift + ;; +*) exec= + ;; +esac +export _CC_ACCEPTABLE_RC=1 +export _C89_ACCEPTABLE_RC=$_CC_ACCEPTABLE_RC +export _CXX_ACCEPTABLE_RC=$_CC_ACCEPTABLE_RC +case " $* " in +*.C" "*)let dll=2 + cc=$CC + export _CXXSUFFIX=C + ;; +*.cpp" "*)let dll=2 + cc=$CC + export _CXXSUFFIX=cpp + ;; +*.cxx" "*)let dll=2 + cc=$CC + export _CXXSUFFIX=cxx + ;; +esac +exe= +xxx= +while : +do case $# in + 0) break ;; + esac + arg=$1 + case $arg in + -1) arg=-O + ;; + -Bdynamic) + let dynamic=1 + ;; + -Bstatic) + let dynamic=0 + ;; + -c) let cmp=1 + ;; + -D_ALL_SOURCE|-D_ALL_SOURCE=*) + arg= + ;; + -D*[\ \(\)]*) + arg=${arg#-D} + botch_macro[botched]=${arg%%=*} + botch_value[botched]=${arg#*=} + let botched=botched+1 + arg= + ;; + -o) argv[argc]=$arg + let argc=argc+1 + shift + arg=$1 + exe=$arg + rm -f "$exe" + ;; + -[O0]) arg= + ;; + -Wc,dll)arg= + ;; + -Wc,exportall) + let dll=1 + ;; + -Wl,dll)arg= + let dll=1 + ;; + *.c) if [[ $botched != 0 ]] + then src=$arg + arg=${arg##*/} + unbotch="$unbotch ${arg%.c}.o" + arg=__$arg + tmpfiles="$tmpfiles $arg" + { + while [[ $botched != 0 ]] + do let botched=botched-1 + print -r -- "#define ${botch_macro[botched]} ${botch_value[botched]}" + done + cat $src + } > $arg + fi + ;; + *.o) if test 0 != $dynamic + then let dynamic_objc=dynamic_objc+1 + else let static_objc=static_objc+1 + fi + ;; + *.x) a=${arg%.x}.a + if test -f $a + then argv[argc]=$a + let argc=argc+1 + xxx=-Wl,dll + case $a in + ast.a|*/ast.a) + cc="$CC -u_ast_init" + ;; + esac + fi + ;; + esac + case $arg in + ?*) argv[argc]=$arg + let argc=argc+1 + ;; + esac + shift +done + +tmp=/tmp/cc.${USER:-$LOGNAME}.$$.err +tmpfiles="$tmp $tmpfiles" + +# if any dll .o's are in .a then a .x gets generated +# but the native cc doesn't jcl for the .x +# -Wl,dll does that, so we nuke the .x and keep the exe + +test 0 != $dll && xxx= +case $xxx in +?*) case $exe in + ?*) a=${exe##*/} + a=${a%.*} + case $exe in + */*) tmpfiles="$tmpfiles ${exe%/*}/${a}.x" ;; + *) tmpfiles="$tmpfiles ${a}.x" ;; + esac + ;; + esac + ;; +esac +if test 0 != $dll +then if test 0 != $cmp + then xxx="-D_SHARE_EXT_VARS $xxx" + else xxx="-Wl,dll $xxx" + fi +fi +set -- $xxx "${argv[@]}" + +# can't handle more than objmax .o's +# -r into intermediates doesn't work, but the cat trick does +# also, the runtime dll file must be executable but cc -Wl,dll forgets + +if test 0 != $dll -a \( $dynamic_objc -ge $objmax -o 0 != $static_objc \) +then unset argv + argc=0 libc=0 dynamic=1 dynamic_objc=0 static_objc=0 endc=0 + while : + do case $# in + 0) break ;; + esac + case $1 in + -Bdynamic) + let dynamic=1 + ;; + -Bstatic) + let dynamic=0 + ;; + *.o) if test 0 != $dynamic + then dynamic_objv[dynamic_objc]=$1 + let dynamic_objc=dynamic_objc+1 + else static_objv[static_objc]=$1 + let static_objc=static_objc+1 + fi + ;; + -l*) libv[libc]=$1 + let libc=libc+1 + ;; + -o) argv[argc]=$1 + let argc=argc+1 + shift + argv[argc]=$1 + let argc=argc+1 + exe=$1 + ;; + *) argv[argc]=$1 + let argc=argc+1 + ;; + esac + shift + done + if test 0 != $static_objc + then case $exe in + ?*) $exec $ar cr ${exe%.*}.a "${static_objv[@]}" ;; + esac + fi + if test 0 != $dynamic_objc + then cat=0.0.o + tmpfiles="$tmpfiles $cat" + cat "${dynamic_objv[@]}" > $cat || exit + else cat= + fi + set -- "${argv[@]}" $cat "${libv[@]}" +fi + +# grep through the warning/error messages to get the true exit code +# some annoying messages are dropped while we're at it + +trap 'rm -f $tmpfiles' 0 1 2 15 +$exec $cc $ccflags "$@" 2> $tmp +code=$? +for i in $unbotch +do test -f __$i && mv __$i $i +done +typeset -l lc +while : +do if read line + then lc=$line + case $lc in + *'#include file'*'not found'*) + code=1 + ;; + *'#pragma ignored'*) + continue + ;; + *'definition side file is not defined'*) + continue + ;; + *'step ended with return code 4'*) + code=0 + continue + ;; + *'step ended with return code'*) + code=1 + continue + ;; + *'try again'*) + code=1 + continue + ;; + *'unknown preprocessing directive'*) + code=1 + case $lc in + 'warning '*) + set -- $line + shift + line=$* + ;; + esac + ;; + *'unresolved writable static references are detected'*) + test 0 != $dll && continue + ;; + esac + else case $code:$exe in + 0:?*) $exec chmod +x $exe ;; + esac + exit $code + fi + echo "$line" >&2 +done < $tmp diff --git a/src/cmd/INIT/cc.next.i386 b/src/cmd/INIT/cc.next.i386 new file mode 100755 index 0000000..16df709 --- /dev/null +++ b/src/cmd/INIT/cc.next.i386 @@ -0,0 +1,158 @@ +: next.i386 cc wrapper for unix message and exit code semantics : 1995-05-09 : + +HOSTTYPE=next.i386 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +# 1995-05-09 -lposix termios.o waitpid.o setpgid.o *do* work +# 1994-11-04 -posix has old redirection hole bug +# -D_POSIX_SOURCE requires <sys/dirent.h> manual fixes +# libexpr/exeval.c bombs -O, no -O ok + +command=cc +cc="/bin/cc -D_POSIX_SOURCE" +nooptimize="exeval" + +# first check $INSTALLROOT/botch + +case $INSTALLROOT in +"") echo "$command: INSTALLROOT: must be defined and exported" >&2; exit 1 ;; +esac +if test ! -d $INSTALLROOT/botch -a -dryrun != "$1" +then if mkdir $INSTALLROOT/botch + then : ok to initialize + else echo "$command: $INSTALLROOT/botch must be initialized by the owner of $INSTALLROOT" 2>&1 + exit 1 + fi + ( + cd $INSTALLROOT/botch + dir=. + for i in lib . include sys + do case $i in + .) dir=. + ;; + *) case $i in + /*) dir=$i ;; + *) dir=$dir/$i ;; + esac + test -d $dir || mkdir $dir + ;; + esac + done + if test ! -f include/sys/dirent.h + then echo "#include <dirent.h>" > tmp.c + header=`$cc -E tmp.c | sed -e '/^#[ ]*1[ ].*\/sys\/dirent\.h"/!d' -e 's/.*"\(.*\)".*/\1/'` + sed -e 's/[ ]off_t[ ][ ]*d_off[ ]*;//' $header > include/sys/dirent.h + fi + if test ! -f lib/libbotch.a + then lipo /usr/lib/libposix.a -thin i386 -output tmp.a + ar x tmp.a termios.o waitpid.o setpgid.o + ar cr lib/libbotch.a *.o + ranlib lib/libbotch.a + fi + rm -f *.[aco] + ) +fi + +# now slip in our args + +case $nooptimize in +"") nooptimize=. + ;; +*) optimize= + for arg in $nooptimize + do case $optimize in + ?*) optimize="$optimize|" ;; + esac + optimize="$optimize$arg.[ci]|*/$arg.[ci]" + done + nooptimize=$optimize + ;; +esac +set . "$@" . +noexec= +library= +local= +optimize= +verbose= +while : +do shift + arg=$1 + shift + case $arg in + .) break + ;; + -[cES]) library=1 + ;; + -O) optimize=1 + ;; + -v) verbose=1 + ;; + -dryrun)noexec=1 + verbose=1 + ;; + -I-) case $local in + "") local=1 + set . "$@" -I$INSTALLROOT/botch/include -I- -I$INSTALLROOT/botch/include + ;; + *) set . "$@" -I- -I$INSTALLROOT/botch/include + ;; + esac + continue + ;; + -I*|*.[cChHiI]|*.[cChHiI][pPxX][pPxX]) + case $optimize in + 1) eval " + case \$arg in + $nooptimize) + optimize=0 + ;; + esac + " + ;; + esac + case $local in + "") local=1 + set . "$@" -I$INSTALLROOT/botch/include "$arg" + continue + ;; + esac + ;; + -last|*/libast.a) + case $library in + "") library=1 + set . "$@" $INSTALLROOT/botch/lib/libbotch.a "$arg" $INSTALLROOT/botch/lib/libbotch.a + continue + ;; + esac + ;; + esac + set . "$@" "$arg" +done +case $library in +"") set . "$@" $INSTALLROOT/botch/lib/libbotch.a + shift + ;; +esac +case $optimize in +0) set . "$@" . + while : + do shift + arg=$1 + shift + case $arg in + .) break ;; + -O) set . "$@" ;; + *) set . "$@" "$arg" ;; + esac + done + ;; +esac +case $verbose in +?*) echo $cc "$@" ;; +esac +case $noexec in +"") $cc "$@" ;; +esac diff --git a/src/cmd/INIT/cc.next.m68k b/src/cmd/INIT/cc.next.m68k new file mode 100755 index 0000000..1c2f8b5 --- /dev/null +++ b/src/cmd/INIT/cc.next.m68k @@ -0,0 +1,9 @@ +: next.m68k cc wrapper that enables posix : 2000-12-15 : + +HOSTTYPE=next.m68k + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +/bin/cc -posix -Xlinker -m "$@" diff --git a/src/cmd/INIT/cc.osf.alpha b/src/cmd/INIT/cc.osf.alpha new file mode 100755 index 0000000..fe19bb4 --- /dev/null +++ b/src/cmd/INIT/cc.osf.alpha @@ -0,0 +1,9 @@ +: osf.alpha cc wrapper with reasonable namespace defaults : 1998-02-04 : + +HOSTTYPE=osf.alpha + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +/usr/bin/cc -std -Dnoshare=_noshare_ -Dreadonly=_readonly_ "$@" diff --git a/src/cmd/INIT/cc.pentium4 b/src/cmd/INIT/cc.pentium4 new file mode 100755 index 0000000..8794cda --- /dev/null +++ b/src/cmd/INIT/cc.pentium4 @@ -0,0 +1,26 @@ +: linux.pentium4 gcc wrapper : 2005-10-24 : + +HOSTTYPE=linux.pentium4 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +case " $* " in +*" -O "*) + set -A argv -- "$@" + set -A nargv + integer i j + for ((i = j = 0; i < ${#argv[@]}; i++)) + do if [[ ${argv[i]} == -O ]] + then nargv[j++]=-O3 + nargv[j++]=-march=pentium4 + else nargv[j++]=${argv[i]} + fi + done + gcc "${nargv[@]}" + exit + ;; +esac + +gcc "$@" diff --git a/src/cmd/INIT/cc.sco.i386 b/src/cmd/INIT/cc.sco.i386 new file mode 100755 index 0000000..d0cba57 --- /dev/null +++ b/src/cmd/INIT/cc.sco.i386 @@ -0,0 +1,9 @@ +: sco.i386 cc wrapper with reasonable binary and namespace : 1998-02-04 : + +HOSTTYPE=sco.i386 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +/bin/cc -b elf -D_SVID3 "$@" diff --git a/src/cmd/INIT/cc.sgi.mips2 b/src/cmd/INIT/cc.sgi.mips2 new file mode 100755 index 0000000..a0e5d33 --- /dev/null +++ b/src/cmd/INIT/cc.sgi.mips2 @@ -0,0 +1,68 @@ +: sgi.mips2 cc wrapper that generates mips2 binaries : 2006-02-14 : + +HOSTTYPE=sgi.mips2 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=/usr/bin/cc +debug= +dynamic=-G0 +flags=-OPT:Olimit=0 +ignore=1685,733,1048,1155,1171,1184,1209,1343,3169,3170,3433 +ldignore=15,84,85,13 +optimize= + +case $_AST_cc_OPTIONS in +?*) eval $_AST_cc_OPTIONS ;; +esac +case $ignore in +?*) ignore="-woff $ignore" ;; +esac +case $ldignore in +?*) ifs=$IFS + IFS=, + v=$ldignore + ldignore= + for i in $v + do ldignore="$ldignore -Wl,-woff,$i" + done + IFS=$ifs + ;; +esac +case $debug in +?*) integer n=0 + for i + do case $i in + -g*) case $debug in + -) continue ;; + esac + i=$debug + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac +case $optimize in +?*) integer n=0 + for i + do case $i in + -O*) case $optimize in + -) continue ;; + esac + i=$optimize + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac + +if test -d /usr/lib32 +then LD_LIBRARYN32_PATH=/lib32 $cc -32 -mips2 $flags $dynamic $ldignore $ignore "$@" +else $cc -mips2 $flags $ignore "$@" +fi diff --git a/src/cmd/INIT/cc.sgi.mips3 b/src/cmd/INIT/cc.sgi.mips3 new file mode 100755 index 0000000..426317a --- /dev/null +++ b/src/cmd/INIT/cc.sgi.mips3 @@ -0,0 +1,110 @@ +: sgi.mips3 cc wrapper that generates mips3 binaries : 2007-04-27 : + +HOSTTYPE=sgi.mips3 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +# ld: +# 15 +# 84 +# 85 +# 134 +# cc: +# 1685 (first!!) Invalid error number: X. +# 1035 cpp #error -- 0 exit status by default - botch botch botch +# 1048 +# 1155 +# 1171 The indicated expression has no effect. +# 1184 "=" is used where where "==" may have been intended. +# 1209 The controlling expression is constant. +# 1343 +# 3169 X not marked as intrinsic because it is not yet declared +# 3170 X not marked as intrinsic because it is not yet declared +# 3421 expecting function name #pragma intrinsic (X) +# 3433 X not marked as intrinsic because it is not yet declared +# 3434 X not marked as intrinsic because it is not yet declared + +cc=/usr/bin/cc +debug= +dynamic=-G0 +flags=-OPT:Olimit=0 +fatal=1035 +ignore=1685,733,1048,1155,1171,1184,1209,1343,3169,3170,3421,3433,3434 +ldignore=15,84,85,13 +optimize= + +case $_AST_cc_OPTIONS in +?*) eval $_AST_cc_OPTIONS ;; +esac +case $fatal in +?*) fatal="-diag_error $fatal" ;; +esac +case $ignore in +?*) ignore="-woff $ignore" ;; +esac +case $ldignore in +?*) ifs=$IFS + IFS=, + v=$ldignore + ldignore= + for i in $v + do ldignore="$ldignore -Wl,-woff,$i" + done + IFS=$ifs + ;; +esac +case $debug in +?*) integer n=0 + for i + do case $i in + -g*) case $debug in + -) continue ;; + esac + i=$debug + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac +case $optimize in +?*) integer n=0 + for i + do case $i in + -O*) case $optimize in + -) continue ;; + esac + i=$optimize + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac + +case $1 in +-mips2) if test -d /usr/lib32 + then LD_LIBRARYN32_PATH=/lib32 $cc -32 -mips2 $flags $dynamic $ldignore $ignore "$@" + else $cc -mips2 $flags $ignore "$@" + fi + ;; +-mips4) case " $* " in + *" -ldl "*) + integer n=0 + for i + do case $i in + -ldl) ;; + *) a[n++]=$i ;; + esac + done + set -- ${a[@]} + esac + $cc -64 -mips4 $flags $dynamic $fatal $ldignore $ignore "$@" + ;; +*) $cc -n32 -mips3 $flags $dynamic $fatal $ldignore $ignore "$@" + ;; +esac diff --git a/src/cmd/INIT/cc.sgi.mips3-o32 b/src/cmd/INIT/cc.sgi.mips3-o32 new file mode 100755 index 0000000..a9c6c9c --- /dev/null +++ b/src/cmd/INIT/cc.sgi.mips3-o32 @@ -0,0 +1,65 @@ +: sgi.mips3-o32 cc wrapper that generates mips3 o32 binaries : 2006-02-14 : + +HOSTTYPE=sgi.mips3-o32 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=/usr/bin/cc +debug= +dynamic=-G0 +flags= +ignore=1685,733,1048,1155,1171,1184,1209,1343,3169,3170,3433 +ldignore=15,84,85,13 +optimize= + +case $_AST_cc_OPTIONS in +?*) eval $_AST_cc_OPTIONS ;; +esac +case $ignore in +?*) ignore="-woff $ignore" ;; +esac +case $ldignore in +?*) ifs=$IFS + IFS=, + v=$ldignore + ldignore= + for i in $v + do ldignore="$ldignore -Wl,-woff,$i" + done + IFS=$ifs + ;; +esac +case $debug in +?*) integer n=0 + for i + do case $i in + -g*) case $debug in + -) continue ;; + esac + i=$debug + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac +case $optimize in +?*) integer n=0 + for i + do case $i in + -O*) case $optimize in + -) continue ;; + esac + i=$optimize + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac + +$cc -o32 -mips3 $flags $dynamic $ldignore $ignore "$@" diff --git a/src/cmd/INIT/cc.sgi.mips4 b/src/cmd/INIT/cc.sgi.mips4 new file mode 100755 index 0000000..1300cd2 --- /dev/null +++ b/src/cmd/INIT/cc.sgi.mips4 @@ -0,0 +1,90 @@ +: sgi.mips4 cc wrapper that generates mips4 binaries : 2007-04-27 : + +HOSTTYPE=sgi.mips4 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=/usr/bin/cc +debug= +dynamic=-G0 +flags=-OPT:Olimit=0 +fatal=1035 +ignore=1685,733,1048,1155,1171,1184,1209,1343,3169,3170,3433 +ldignore=15,84,85,13 +optimize= + +case $_AST_cc_OPTIONS in +?*) eval $_AST_cc_OPTIONS ;; +esac +case $fatal in +?*) fatal="-diag_error $fatal" ;; +esac +case $ignore in +?*) ignore="-woff $ignore" ;; +esac +case $ldignore in +?*) ifs=$IFS + IFS=, + v=$ldignore + ldignore= + for i in $v + do ldignore="$ldignore -Wl,-woff,$i" + done + IFS=$ifs + ;; +esac +case $debug in +?*) integer n=0 + for i + do case $i in + -g*) case $debug in + -) continue ;; + esac + i=$debug + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac +case $optimize in +?*) integer n=0 + for i + do case $i in + -O*) case $optimize in + -) continue ;; + esac + i=$optimize + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac + +case $1 in +-mips2) if test -d /usr/lib32 + then LD_LIBRARYN32_PATH=/lib32 $cc -32 -mips2 $flags $dynamic $ldignore $ignore "$@" + else $cc -mips2 $flags $ignore "$@" + fi + ;; +-mips3) $cc -n32 -mips3 $flags $dynamic $fatal $ldignore $ignore "$@" + ;; +*) case " $* " in + *" -ldl "*) + integer n=0 + for i + do case $i in + -ldl) ;; + *) a[n++]=$i ;; + esac + done + set -- ${a[@]} + esac + $cc -64 -mips4 $flags $dynamic $fatal $ldignore $ignore "$@" + ;; +esac diff --git a/src/cmd/INIT/cc.sgi.mips4-n32 b/src/cmd/INIT/cc.sgi.mips4-n32 new file mode 100755 index 0000000..0e1b562 --- /dev/null +++ b/src/cmd/INIT/cc.sgi.mips4-n32 @@ -0,0 +1,65 @@ +: sgi.mips4-n32 cc wrapper that generates mips4 n32 binaries : 2006-02-14 : + +HOSTTYPE=sgi.mips4-n32 + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=/usr/bin/cc +debug= +dynamic=-G0 +flags= +ignore=1685,733,1048,1155,1171,1184,1209,1343,3169,3170,3433 +ldignore=15,84,85,13 +optimize= + +case $_AST_cc_OPTIONS in +?*) eval $_AST_cc_OPTIONS ;; +esac +case $ignore in +?*) ignore="-woff $ignore" ;; +esac +case $ldignore in +?*) ifs=$IFS + IFS=, + v=$ldignore + ldignore= + for i in $v + do ldignore="$ldignore -Wl,-woff,$i" + done + IFS=$ifs + ;; +esac +case $debug in +?*) integer n=0 + for i + do case $i in + -g*) case $debug in + -) continue ;; + esac + i=$debug + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac +case $optimize in +?*) integer n=0 + for i + do case $i in + -O*) case $optimize in + -) continue ;; + esac + i=$optimize + ;; + esac + a[n++]=$i + done + set -- ${a[@]} + ;; +esac + +$cc -n32 -mips4 $flags $dynamic $ldignore $ignore "$@" diff --git a/src/cmd/INIT/cc.specialize b/src/cmd/INIT/cc.specialize new file mode 100755 index 0000000..87077b5 --- /dev/null +++ b/src/cmd/INIT/cc.specialize @@ -0,0 +1,35 @@ +: -O* specialization cc wrapper : 2011-11-11 : + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +cc=cc + +CCREPLACE='' # these (possibly empty) options replace -O* +CCALWAYS='' # these (possibly empty) options always set + +case $CCREPLACE in +'') ;; +*) case " $* " in + *" -O"*) + set '' "$@" '' + shift + while : + do a=$1 + shift + case $a in + '') break + ;; + -O*) set '' "$@" $CCREPLACE + ;; + *) set '' "$@" "$a" + ;; + esac + shift + done + ;; + esac + ;; +esac +$cc $CCALWAYS "$@" diff --git a/src/cmd/INIT/cc.unix.mc68k b/src/cmd/INIT/cc.unix.mc68k new file mode 100755 index 0000000..ebdfa0d --- /dev/null +++ b/src/cmd/INIT/cc.unix.mc68k @@ -0,0 +1,76 @@ +: 3B1/PC7300 unix.mc68k cc wrapper for ANSI C : 2002-09-01 : + +HOSTTYPE=unix.mc68k + +case " $* " in +*" -dumpmachine "*) echo $HOSTTYPE; exit ;; +esac + +# /bin/cc predates ANSI C; use gcc +# some headers depend on SYSTEM5 or mc68k being defined +# headers for Ethernet software are under /usr/ethernet/include +# both /usr/lib/libnet.a and /usr/lib/libcurses.a define select() +# -lcurses uses a version of select for napms(), but that +# implementation always returns an error if given file +# descriptors to watch +# the one in -lnet must be used if fds (instead of or in addition to +# a timeout) are of interest therefore, -lnet should be +# specified before -lcurses +# rename(old, new) in /usr/lib/libnet.a fails if new exists +# (permitted by ANSI/ISO C-1990 7.9.4.2) +# gcc -fpic doesn't work as there's no _GLOBAL_OFFSET_TABLE symbol + +cc="gcc" + +exec= +show=: +inc=0 +lib=0 +set '' -DSYSTEM5 -Dmc68k "$@" '' +shift +while : +do a=$1 + shift + case $a in + '') break + ;; + -lcurses|libcurses.a|*/libcurses.a) + lib=1 + set '' "$@" -lnet + shift + ;; + -lnet|libnet.a|*/libnet.a) + lib=1 + ;; + -o) a=$1 + shift + set '' "$@" -o + shift + ;; + -fpic) continue + ;; + -n) exec=: + continue + ;; + -v) show=echo + continue + ;; + -*) ;; + *) case $inc in + 0) inc=1 + set '' "$@" -I/usr/ethernet/include + shift + ;; + esac + ;; + esac + set '' "$@" "$a" + shift +done +case $lib in +0) set '' "$@" -lnet + shift + ;; +esac +$show $cc "$@" +$exec $cc "$@" diff --git a/src/cmd/INIT/crossexec.sh b/src/cmd/INIT/crossexec.sh new file mode 100644 index 0000000..9d73ee2 --- /dev/null +++ b/src/cmd/INIT/crossexec.sh @@ -0,0 +1,139 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: cross compiler a.out execution + +command=crossexec + +tmp=/tmp/cross$$ + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) ARGV0="-a $command" + USAGE=$' +[-? +@(#)$Id: crossexec (AT&T Labs Research) 2004-01-04 $ +] +'$USAGE_LICENSE$' +[+NAME?crossexec - cross compiler a.out execution] +[+DESCRIPTION?\bcrossexec\b runs a cross-compiled \acommand\a in an environment + that supports a cross-compilation architecture different from the + current host. The cross environment is determined by \acrosstype\a, + usually a host type name produced by \bpackage\b(1). \acrosstype\a + is used to find an entry in \b$HOME/.crossexec\b that specifies + the cross compiler host and access details.] +[+?The exit status of \bcrossexec\b is the exit status of \acommand\a.] +[+CROSS ENVIRONMENT FILE?\b$HOME/.crossexec\b contains one line for each + supported \acrosstype\a. Each line contains 5 tab separated fields. + Field default values are specified as \b-\b. The fields are:]{ + [+crosstype?The host type produced by \bpackage\b(1).] + [+host?The host name.] + [+user?The user name on \ahost\a. The default is the current user.] + [+dir?The directory to copy \acommand\a and execute it. The default + is the \auser\a \b$HOME\b on \ahost\a.] + [+shell?The command used to get shell access to \ahost\a. Currently + only \brsh\b and \bssh\b are supported.] + [+copy?The command used to copy \acommand\a to \ahost\a. Currently + only \brcp\b and \bscp\b are supported.] +} +[n:show?Show the underlying commands but do not execute.] + +crosstype command [ option ... ] [ file ... ] + +[+SEE ALSO?\brcp\b(1), \brsh\b(1), \bscp\b(1), \bssh\b(1)] +' + ;; +*) ARGV0="" + USAGE="crosstype command [ option ... ] [ file ... ]" + ;; +esac + +usage() +{ + OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 +} + +exec= + +# get the options and operands + +while getopts $ARGV0 "$USAGE" OPT +do case $OPT in + n) exec=echo ;; + *) usage ;; + esac +done +shift $OPTIND-1 +case $# in +[01]) usage ;; +esac + +type=$1 +shift +cmd=$1 +shift + +# get the host info + +info=$HOME/.$command +if test ! -r $info +then echo "$command: $info: not found" >&2 + exit 1 +fi +ifs=${IFS-' + '} +while : +do IFS=' ' + read hosttype hostname usr dir sh cp + code=$? + IFS=$ifs + case $code in + 0) ;; + *) echo "$command: $type: unknown cross compiler host type" >&2 + exit 1 + ;; + esac + case $hosttype in + $type) break ;; + esac +done < $info + +# fill in the defaults + +case $usr in +-) cpu= shu= ;; +*) cpu=${usr}@ shu="-l $usr" ;; +esac +case $dir in +-) dir= ;; +esac +case $sh in +''|-) sh=ssh ;; +esac +case $cp in +''|-) cp=scp ;; +scp) cp="$cp -q" ;; +esac + +trap "rm -f $tmp" 0 1 2 3 15 +$exec $cp $cmd $cpu$hostname:$dir </dev/null || exit 1 +cmd=./${cmd##*/} +$exec $sh $shu $hostname "cd $dir; LD_LIBRARY_PATH=: $cmd $@ </dev/null 2>/dev/null; code=\$?; rm -f $cmd; echo $command: exit \$code >&2" </dev/null 2>$tmp +exit `sed -e '/^'$command': exit [0-9][0-9]*$/!d' -e 's/.* //' $tmp` diff --git a/src/cmd/INIT/db.c b/src/cmd/INIT/db.c new file mode 100644 index 0000000..5a3a7c1 --- /dev/null +++ b/src/cmd/INIT/db.c @@ -0,0 +1,37 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for sleepycat dbm compatibility + */ + +#define DB_DBM_HSEARCH 1 + +#if DB_DBM_HSEARCH +#include <db.h> +#endif + +int +main() +{ + DBM* dbm = 0; + + dbm_close(dbm); + return 0; +} diff --git a/src/cmd/INIT/ditto.sh b/src/cmd/INIT/ditto.sh new file mode 100644 index 0000000..1141a0d --- /dev/null +++ b/src/cmd/INIT/ditto.sh @@ -0,0 +1,460 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: replicate directory hierarchies + +COMMAND=ditto +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) ARGV0="-a $COMMAND" + USAGE=$' +[-? +@(#)$Id: ditto (AT&T Labs Research) 2010-11-22 $ +] +'$USAGE_LICENSE$' +[+NAME?ditto - replicate directory hierarchies] +[+DESCRIPTION?\bditto\b replicates the \asource\a directory hierarchy + to the \adestination\a directory hierarchy. Both \asource\a and + \adestination\a may be of the form + [\auser\a@]][\ahost\a:]][\adirectory\a]]. At least one of + \ahost\a: or \adirectory\a must be specified. The current user is used + if \auser@\a is omitted, the local host is used if \ahost\a: is + omitted, and the user home directory is used if \adirectory\a is + omitted.] +[+?Remote hosts and files are accessed via \bssh\b(1) or \brsh\b(1). \bksh\b(1), + \bpax\b(1), and \btw\b(1) must be installed on the local and remote hosts.] +[+?For each source file \bditto\b does one of these actions:]{ + [+chmod|chown?change the mode and/or ownership of the destination + file to match the source] + [+copy?copy the source file to the destination] + [+delete?delete the destination file] + [+skip?the destination file is not changed] +} +[+?The source and destination hierarchies are generated by \btw\b(1) with + the \b--logical\b option. An \b--expr\b option may + be specified to prune the search. The \btw\b searches are relative to + the \asource\a and \adestination\a directories.] +[c:checksum?Copy if the \btw\b(1) 32x4 checksum mismatches.] +[d:delete?Delete \adestination\a files that are not in the \asource\a.] +[e:expr?\btw\b(1) select expression.]:[tw-expression] +[m!:mode?Preserve file mode.] +[n:show?Show the operations but do not exectute.] +[o:owner?Preserve file user and group ownership.] +[p:physical?Generate source and destination hierarchies by \btw\b(1) with + the \b--physical\b option.] +[r:remote?The remote access protocol; either \bssh\b or + \brsh\b.]:[protocol:=ssh] +[u:update?Copy only if the \asource\a file is newer than the + \adestination\a file.] +[v:verbose?Trace the operations as they are executed.] +[D:debug?Enable the debug trace.] + +source destination + +[+SEE ALSO?\brdist\b(1), \brsync\b(1), \brsh\b(1), \bssh\b(1), \btw\b(1)] +' + ;; +*) ARGV0="" + USAGE="de:[tw-expression]mnouvD source destination" + ;; +esac + +usage() +{ + OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 +} + +parse() # id user@host:dir +{ + typeset id dir user host + id=$1 + dir=$2 + (( debug || ! exec )) && print -r $id $dir + if [[ $dir == *@* ]] + then + user=${dir%%@*} + dir=${dir#${user}@} + else + user= + fi + if [[ $dir == *:* ]] + then + host=${dir%%:*} + dir=${dir#${host}:} + else + host= + fi + if [[ $user ]] + then + user="-l $user" + if [[ ! $host ]] + then + host=$(hostname) + fi + fi + eval ${id}_user='$user' + eval ${id}_host='$host' + eval ${id}_dir='$dir' +} + +# initialize + +typeset -A chown chmod +typeset tw cp rm link +integer ntw=0 ncp=0 nrm=0 nlink=0 n + +typeset src_user src_host src_path src_type src_uid src_gid src_perm src_sum +typeset dst_user dst_host dst_path dst_type dst_uid dst_gid dst_perm dst_sum +integer src_size src_mtime src_eof +integer dst_size dst_mtime dst_eof + +integer debug=0 delete=0 exec=1 mode=1 owner=0 update=0 verbose=0 logical + +typeset remote=ssh trace +typeset checksum='"-"' pax="pax" +typeset paxreadflags="" paxwriteflags="--write --format=tgz --nosummary" + +tw[ntw++]=tw +(( logical=ntw )) +tw[ntw++]=--logical +tw[ntw++]=--chop +tw[ntw++]=--ignore-errors +tw[ntw++]=--expr=sort:name + +# grab the options + +while getopts $ARGV0 "$USAGE" OPT +do case $OPT in + c) checksum=checksum ;; + d) delete=1 ;; + e) tw[ntw++]=--expr=\"$OPTARG\" ;; + m) mode=0 ;; + n) exec=0 verbose=1 ;; + o) owner=1 ;; + p) tw[logical]=--physical ;; + r) remote=$OPTARG ;; + u) update=1 ;; + v) verbose=1 ;; + D) debug=1 ;; + *) usage ;; + esac +done +shift $OPTIND-1 +if (( $# != 2 )) +then usage +fi +tw[ntw++]=--expr=\''action:printf("%d\t%d\t%s\t%s\t%s\t%-.1s\t%o\t%s\t%s\n", size, mtime, '$checksum', uid, gid, mode, perm, path, symlink);'\' +if (( exec )) +then + paxreadflags="$paxreadflags --read" +fi +if (( verbose )) +then + paxreadflags="$paxreadflags --verbose" +fi + +# start the source and destination path list generators + +parse src "$1" +parse dst "$2" + +# the |& command may exit before the exec &p +# the print sync + read delays the |& until the exec &p finishes + +if [[ $src_host ]] +then ($remote $src_user $src_host "{ test ! -f .profile || . ./.profile ;} && cd $src_dir && read && ${tw[*]}") 2>&1 |& +else (cd $src_dir && read && eval "${tw[@]}") 2>&1 |& +fi +exec 5<&p 7>&p +print -u7 sync +exec 7>&- + +if [[ $dst_host ]] +then ($remote $dst_user $dst_host "{ test ! -f .profile || . ./.profile ;} && cd $dst_dir && read && ${tw[*]}") 2>&1 |& +else (cd $dst_dir && read && eval "${tw[@]}") 2>&1 |& +fi +exec 6<&p 7>&p +print -u7 sync +exec 7>&- + +# scan through the sorted path lists + +if (( exec )) +then + src_skip=* + dst_skip=* +else + src_skip= + dst_skip= +fi +src_path='' src_eof=0 +dst_path='' dst_eof=0 +ifs=${IFS-$' \t\n'} +IFS=$'\t' +while : +do + # get the next source path + + if [[ ! $src_path ]] && (( ! src_eof )) + then + if read -r -u5 text src_mtime src_sum src_uid src_gid src_type src_perm src_path src_link + then + if [[ $text != +([[:digit:]]) ]] + then + print -u2 $COMMAND: source: "'$text'" + src_path= + continue + fi + src_size=$text + elif (( dst_eof )) + then + break + elif (( src_size==0 )) + then + exit 1 + else + src_path= + src_eof=1 + fi + fi + + # get the next destination path + + if [[ ! $dst_path ]] && (( ! dst_eof )) + then + if read -r -u6 text dst_mtime dst_sum dst_uid dst_gid dst_type dst_perm dst_path dst_link + then + if [[ $text != +([[:digit:]]) ]] + then + print -u2 $COMMAND: destination: $text + dst_path= + continue + fi + dst_size=$text + elif (( src_eof )) + then + break + elif (( dst_size==0 )) + then + exit 1 + else + dst_path= + dst_eof=1 + fi + fi + + # determine the { cp rm chmod chown } ops + + if (( debug )) + then + [[ $src_path ]] && print -r -u2 -f $': src %8s %10s %s %s %s %s %3s %s\n' $src_size $src_mtime $src_sum $src_uid $src_gid $src_type $src_perm "$src_path" + [[ $dst_path ]] && print -r -u2 -f $': dst %8s %10s %s %s %s %s %3s %s\n' $dst_size $dst_mtime $dst_sum $dst_uid $dst_gid $dst_type $dst_perm "$dst_path" + fi + if [[ $src_path == $dst_path ]] + then + if [[ $src_type != $dst_type ]] + then + rm[nrm++]=$dst_path + if [[ $dst_path != $dst_skip ]] + then + if [[ $dst_type == d ]] + then + dst_skip="$dst_path/*" + print -r rm -r "'$dst_path'" + else + dst_skip= + print -r rm "'$dst_path'" + fi + fi + fi + if [[ $src_type == l ]] + then if [[ $src_link != $dst_link ]] + then + cp[ncp++]=$src_path + if [[ $src_path != $src_skip ]] + then + src_skip= + print -r cp "'$src_path'" + fi + fi + elif [[ $src_type != d ]] && { (( update && src_mtime > dst_mtime )) || (( ! update )) && { (( src_size != dst_size )) || [[ $src_sum != $dst_sum ]] ;} ;} + then + if [[ $src_path != . ]] + then + cp[ncp++]=$src_path + if [[ $src_path != $src_skip ]] + then + src_skip= + print -r cp "'$src_path'" + fi + fi + else + if (( owner )) && [[ $src_uid != $dst_uid || $src_gid != $dst_gid ]] + then + chown[$src_uid.$src_gid]="${chown[$src_uid.$src_gid]} '$src_path'" + if [[ $src_path != $src_skip ]] + then + src_skip= + print -r chown $src_uid.$src_gid "'$src_path'" + fi + if (( (src_perm & 07000) || mode && src_perm != dst_perm )) + then + chmod[$src_perm]="${chmod[$src_perm]} '$src_path'" + if [[ $src_path != $src_skip ]] + then + src_skip= + print -r chmod $src_perm "'$src_path'" + fi + fi + elif (( mode && src_perm != dst_perm )) + then + chmod[$src_perm]="${chmod[$src_perm]} '$src_path'" + if [[ $src_path != $src_skip ]] + then + src_skip= + print -r chmod $src_perm "'$src_path'" + fi + fi + fi + src_path= + dst_path= + elif [[ ! $dst_path || $src_path && $src_path < $dst_path ]] + then + if [[ $src_path != . ]] + then + cp[ncp++]=$src_path + if [[ $src_path != $src_skip ]] + then + if [[ $src_type == d ]] + then + src_skip="$src_path/*" + print -r cp -r "'$src_path'" + else + src_skip= + print -r cp "'$src_path'" + fi + fi + fi + src_path= + elif [[ $dst_path ]] + then + if (( delete )) + then + rm[nrm++]=$dst_path + if [[ $dst_path != $dst_skip ]] + then + if [[ $dst_type == d ]] + then + dst_skip="$dst_path/*" + print -r rm -r "'$dst_path'" + else + dst_skip= + print -r rm "'$dst_path'" + fi + fi + fi + dst_path= + fi +done +IFS=$ifs + +(( exec )) || exit 0 + +# generate, transfer and execute the { rm chown chmod } script + +if (( ${#rm[@]} || ${#chmod[@]} || ${#chown[@]} )) +then + { + if (( verbose )) + then + print -r -- set -x + fi + print -nr -- cd "'$dst_dir'" + n=0 + for i in ${rm[@]} + do + if (( --n <= 0 )) + then + n=32 + print + print -nr -- rm -rf + fi + print -nr -- " '$i'" + done + for i in ${!chown[@]} + do + n=0 + for j in ${chown[$i]} + do + if (( --n <= 0 )) + then + n=32 + print + print -nr -- chown $i + fi + print -nr -- " $j" + done + done + for i in ${!chmod[@]} + do + n=0 + for j in ${chmod[$i]} + do + if (( --n <= 0 )) + then + n=32 + print + print -nr -- chmod $i + fi + print -nr -- " $j" + done + done + print + } | { + if (( ! exec )) + then + cat + elif [[ $dst_host ]] + then + $remote $dst_user $dst_host sh + else + $SHELL + fi + } +fi + +# generate, transfer and read back the { cp } tarball + +if (( ${#cp[@]} )) +then + { + cd $src_dir && + print -r -f $'%s\n' "${cp[@]}" | + $pax $paxwriteflags + } | { + if [[ $dst_host ]] + then + $remote $dst_user $dst_host "{ test ! -f .profile || . ./.profile ;} && { test -d \"$dst_dir\" || mkdir -p \"$dst_dir\" ;} && cd \"$dst_dir\" && gunzip | $pax $paxreadflags" + else + ( { test -d "$dst_dir" || mkdir -p "$dst_dir" ;} && cd "$dst_dir" && gunzip | $pax $paxreadflags ) + fi + } + wait +fi diff --git a/src/cmd/INIT/dl.c b/src/cmd/INIT/dl.c new file mode 100644 index 0000000..c710ad6 --- /dev/null +++ b/src/cmd/INIT/dl.c @@ -0,0 +1,33 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for -ldl + */ + +#ifndef dlopen +#include <dlfcn.h> +#endif + +int +main() +{ + dlopen("libdl.so",0); + return 0; +} diff --git a/src/cmd/INIT/execrate.sh b/src/cmd/INIT/execrate.sh new file mode 100644 index 0000000..71ba78d --- /dev/null +++ b/src/cmd/INIT/execrate.sh @@ -0,0 +1,179 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: wrapper for .exe challenged win32 systems/commands + +command=execrate + +bins='/bin /usr/bin /usr/sbin' + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) ARGV0="-a $command" + USAGE=$' +[-? +@(#)$Id: execrate (AT&T Labs Research) 2002-02-02 $ +] +'$USAGE_LICENSE$' +[+NAME?execrate - wrapper for .exe challenged commands] +[+DESCRIPTION?\bexecrate\b runs \acommand\a after checking the \afile\a + operands for standard semantics with respect to \bwin32\b \b.exe\b + suffix conventions. This command is only needed on \bwin32\b + systems that inconsistently handle \b.exe\b across library and + command interfaces. \acommand\a may be one of \bcat\b(1), \bchmod\b(1), + \bcmp\b(1), \bcp\b(1), \bln\b(1), \bmv\b(1), or \brm\b(1). + Only the 2 argument forms of \bcp\b, \bln\b and \bmv\b are handled. + Unsupported commands and commands requiring no change are + silently executed.] +[+?With no arguments \bexecrate\b exits with status 0 if the current system + is \b.exe\b challenged, 1 if the current system is normal.] +[n:show?Show the underlying commands but do not execute.] + +command [ option ... ] file ... + +[+SEE ALSO?\bwebster\b(1)] +' + usage() + { + OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 + } + exec=1 + while getopts $ARGV0 "$USAGE" OPT + do case $OPT in + n) exec=0 ;; + *) usage ;; + esac + done + shift `expr $OPTIND - 1` + ;; +*) usage() + { + echo "Usage: execrate [ -n ] [ command [ option ... ] file ... ]" >&2 + exit 2 + } + exec=1 + while : + do case $1 in + -n) exec=0 ;; + -*) usage ;; + *) break ;; + esac + shift + done + ;; +esac +case $# in +0) if test ! -x /bin/cat.exe + then exit 1 # normal + fi + if /bin/cat /bin/cat >/dev/null 2>&1 + then exit 1 # normal + fi + exit 0 # challenged + ;; +1) usage + ;; +esac +case $1 in +*cat|*rm) + NUM=0 + ;; +*chgrp|*chmod) + NUM=1 + ;; +*cmp|*cp|*ln|*mv) + NUM=2 + ;; +*) case $exec in + 0) echo "$@" ;; + *) "$@" ;; + esac + exit + ;; +esac +CMD=$1 +shift +case $CMD in +*/*) ;; +*) for d in $bins + do if test -x $d/$1 -o -x $d/$1.exe + then CMD=$d/$1 + break + fi + done + ;; +esac +while : +do case $1 in + -*) CMD="$CMD $1" ;; + *) break ;; + esac + shift +done +case $exec in +0) CMD="echo $CMD" ;; +esac +case $NUM:$# in +*:0) ;; +1:*) CMD="$CMD $1" + NUM=0 + shift + ;; +esac +case $NUM:$# in +0:*) status=0 + for f + do if test "$f" -ef "$f".exe + then f=$f.exe + fi + $CMD "$f" + case $? in + 0) ;; + *) status=$? ;; + esac + done + exit $status + ;; +2:2) f=$1 + case $f in + *.exe) ;; + *) if test "$f" -ef "$f".exe + then f=$f.exe + fi + ;; + esac + case $f in + *.exe) if test -d "$2" + then t=$2/$f + else t=$2 + fi + case $t in + */*) b=`basename "$t"` ;; + *) b=$t ;; + esac + case $b in + *.*) $CMD "$f" "$t"; exit ;; + *) $CMD "$f" "$t".exe; exit ;; + esac + ;; + esac + ;; +esac +$CMD "$@" diff --git a/src/cmd/INIT/filter.sh b/src/cmd/INIT/filter.sh new file mode 100644 index 0000000..2637a58 --- /dev/null +++ b/src/cmd/INIT/filter.sh @@ -0,0 +1,98 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: convert command that operates on file args to pipeline filter + +command=filter + +tmp=/tmp/$command$$ +suf= + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) ARGV0="-a $command" + USAGE=$' +[-? +@(#)$Id: filter (AT&T Labs Research) 2001-05-31 $ +] +'$USAGE_LICENSE$' +[+NAME?filter - run a command in stdin/stdout mode] +[+DESCRIPTION?\bfilter\b runs \acommand\a in a mode that takes input from + the \afile\a operands, or from the standard input if no \afile\a + operands are specified, and writes the results to the standard output. + It can be used to run commands like \bsplit\b(1), that normally modify + \afile\a operands in-place, in pipelines. The \afile\a operands are + not modified; \acommand\a is run on copies in \b/tmp\b.] + +command [ option ... ] [ file ... ] + +[+SEE ALSO?\bstrip\b(1)] +' + ;; +*) ARGV0="" + USAGE="command [ option ... ] [ file ... ]" + ;; +esac + +usage() +{ + OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 +} + +while getopts $ARGV0 "$USAGE" OPT +do case $OPT in + *) usage ;; + esac +done +shift `expr $OPTIND - 1` +case $# in +0) usage ;; +esac + +cmd=$1 +while : +do shift + case $# in + 0) break ;; + esac + case $1 in + -*) cmd="$cmd $1" ;; + *) break ;; + esac +done +trap 'rm -f $tmp$suf' 0 1 2 3 15 +case $# in +0) cat > $tmp + $cmd $tmp + ;; +*) for file + do suf=${file##*/} + case $suf in + *.*) suf=.${suf#*.} ;; + *) suf= ;; + esac + cp $file $tmp$suf || exit 1 + chmod u+rwx $tmp$suf || exit 1 + $cmd $tmp$suf || exit 1 + cat $tmp$suf + rm -f $tmp$suf + done + ;; +esac diff --git a/src/cmd/INIT/gdbm.c b/src/cmd/INIT/gdbm.c new file mode 100644 index 0000000..cc0a9f6 --- /dev/null +++ b/src/cmd/INIT/gdbm.c @@ -0,0 +1,37 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for -lgdbm + */ + +#define _hdr_gdbm_ndbm 1 + +#if _hdr_gdbm_ndbm +#include <gdbm/ndbm.h> +#endif + +int +main() +{ + DBM* dbm = 0; + + dbm_close(dbm); + return 0; +} diff --git a/src/cmd/INIT/gdbm1.c b/src/cmd/INIT/gdbm1.c new file mode 100644 index 0000000..6ad2071 --- /dev/null +++ b/src/cmd/INIT/gdbm1.c @@ -0,0 +1,37 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for -lgdbm + */ + +#define _hdr_gdbm_ndbm 1 + +#if _hdr_gdbm_ndbm +#include <gdbm-ndbm.h> +#endif + +int +main() +{ + DBM* dbm = 0; + + dbm_close(dbm); + return 0; +} diff --git a/src/cmd/INIT/gdbm2.c b/src/cmd/INIT/gdbm2.c new file mode 100644 index 0000000..1b9a48f --- /dev/null +++ b/src/cmd/INIT/gdbm2.c @@ -0,0 +1,37 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for -lgdbm + */ + +#define _hdr_ndbm 1 + +#if _hdr_ndbm +#include <ndbm.h> +#endif + +int +main() +{ + DBM* dbm = 0; + + dbm_close(dbm); + return 0; +} diff --git a/src/cmd/INIT/hello.c b/src/cmd/INIT/hello.c new file mode 100755 index 0000000..2a8e2d1 --- /dev/null +++ b/src/cmd/INIT/hello.c @@ -0,0 +1,23 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#ifndef printf +#include <stdio.h> +#endif +int main() { int new = 0; printf("hello world\n"); return new;} diff --git a/src/cmd/INIT/hosttype.tst b/src/cmd/INIT/hosttype.tst new file mode 100644 index 0000000..7a64588 --- /dev/null +++ b/src/cmd/INIT/hosttype.tst @@ -0,0 +1,6 @@ +hp.pa hostname 9000/730 hp9000s700 HP-UX hostname A.09.01 A +linux-aout.i386 hostname i586 i386 linux hostname 1.1.59 #1 +sgi.mips2 hostname.domain IP22 mips IRIX hostname 5.2 02282016 +osf.alpha hostname.domain alpha alpha OSF1 hostname.domain V3.2 62 +sun4 hostname.domain sun4 sparc SunOS hostname.domain 4.1.1 1 sun4c +sol.sun4 hostname.domain sun4 sparc SunOS hostname.domain 5.4 Generic_101945-13 diff --git a/src/cmd/INIT/hurl.sh b/src/cmd/INIT/hurl.sh new file mode 100644 index 0000000..60e8a6b --- /dev/null +++ b/src/cmd/INIT/hurl.sh @@ -0,0 +1,207 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: copy http url data + +command=hurl +agent="$command/2009-01-20 (AT&T Research)" +authorize= +verbose=0 + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) ARGV0="-a $command" + USAGE=$' +[-? +@(#)$Id: hurl (AT&T Research) 2009-01-20 $ +] +'$USAGE_LICENSE$' +[+NAME?hurl - copy http url data] +[+DESCRIPTION?\bhurl\b copies the data for the \bhttp\b \aurl\a operand + to the standard output. The \aurl\a must be of the form + \b[http://]]\b\ahost\a[\b:\b\aport\a]]\b/\b\apath\a. The default + \aport\a is \b80\b.] +[+?\bhurl\b is a shell script that attempts to access the \aurl\a by + these methods:]{ + [+/dev/tcp/\ahost\a\b/80\b?Supported by \bksh\b(1) and recent + \bbash\b(1).] + [+wget -nv -O - \aurl\a?] + [+lynx -source \aurl\a?] + [+curl -s -L -o - \aurl\a?] +} +[a:authorize?The url authorization user name and password, separated + by \b:\b (one colon character.)]:[user::password] +[s:size?Terminate the data transmission after \abytes\a have been + transferred.]:[bytes] +[v:verbose?Verbose trace.] + +url + +[+SEE ALSO?\bcurl\b(1), \blynx\b(1), \bwget\b(1)] +' + ;; +*) ARGV0="" + USAGE="a:v" + ;; +esac + +usage() +{ + OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 +} + +integer limit=0 total=0 block=8*1024 + +while getopts $ARGV0 "$USAGE" OPT +do case $OPT in + a) authorize=$OPTARG ;; + s) limit=$OPTARG ;; + v) verbose=1 ;; + esac +done +shift `expr $OPTIND - 1` + +url=$1 +AUTHORIZE= + +exec 9<&0 + +while : +do test 0 != $verbose && echo "$command: url=$url" >&2 + case $url in + *://*/*)prot=${url%%:*} + url=${url#*://} + ;; + *) prot=http + ;; + esac + host=$url + path=/${host#*/} + host=${host%%/*} + case $host in + *:+([0-9])) + port=${host##*:} + host=${host%:*} + ;; + *) port=80 + ;; + esac + test 0 != $verbose && echo "$command: prot=$prot host=$host port=$port path=$path" >&2 + case $prot in + http) if (eval "exec >" || exit 0) 2>/dev/null && + eval "exec 8<> /dev/tcp/\$host/$port" 2>/dev/null + then test 0 != $verbose && echo "$command: using /dev/tcp/$host/$port" >&2 + if ! echo "GET $path HTTP/1.0
+Host: $host
+User-Agent: $agent
${AUTHORIZE} +
" >&8 + then echo "$command: $host: write error" + exit 1 + fi + { + if ! read prot code text + then echo "$command: $host: read error" >&2 + exit 1 + fi + code=${code%:*} + type=Basic + realm=access + test 0 != $verbose && echo "$command: prot=$prot code=$code $text" >&2 + while : + do if ! read head data + then echo "$command: $host: read error" >&2 + exit 1 + fi + test 0 != $verbose && echo "$command: head=$head $data" >&2 + case $head in + Location:) + case $code in + 30[123])url=$data + continue 2 + ;; + esac + ;; + WWW-Authenticate:) + set -- $data + type=$1 + shift + eval "$@" + realm=${realm%$'\r'} + ;; + ''|?) break + ;; + esac + done + case $code in + 200) if (( limit )) + then (( limit = (limit + block - 1) / block)) + dd bs=$block count=$limit silent=1 + else cat + fi + exit + ;; + 401) { + if [[ $AUTHORIZE || $type != Basic ]] + then print authorization failed + exit 1 + fi + if [[ ! $authorize ]] + then if [[ ! -t 0 ]] + then print authorization failed + exit 1 + fi + print -n "Enter user name for $realm: " + read -u9 user + print -n "Password: " + trap 'stty echo <&9' 0 1 2 3 15 + stty -echo + read password + stty echo + print + trap - 0 1 2 3 15 + authorize=$user:$password + fi + AUTHORIZE=$'\nAuthorization: '$type' '$(print -n -r -- "$authorize" | uuencode -h -x base64)$'\r' + } <&9 >&2 + continue 2 + ;; + *) echo "$0: $url: $code: $text" >&2 + exit 1 + ;; + esac + } <&8 + elif wget ${authorize:+--http-user="${authorize%:*}"} ${password:+--http-passwd="${password##*:}"} -nv -O - $url 2>/dev/null + then test 0 != $verbose && echo "$command: using wget" >&2 + exit + elif lynx ${authorize:+-auth "$authorize"} -source $url 2>/dev/null + then test 0 != $verbose && echo "$command: using wget" >&2 + exit + elif curl ${authorize:+-u "$authorize"} -s -L -o - $url 2>/dev/null + then test 0 != $verbose && echo "$command: using curl" >&2 + exit + else echo "$command: $url: { /dev/tcp/$host/$port wget curl } failed" >&2 + exit 1 + fi + ;; + *) echo "$command: $prot: protocol not supported" >&2 + exit 1 + ;; + esac +done diff --git a/src/cmd/INIT/iconv.c b/src/cmd/INIT/iconv.c new file mode 100644 index 0000000..64f2797 --- /dev/null +++ b/src/cmd/INIT/iconv.c @@ -0,0 +1,29 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#ifndef iconv +#include <iconv.h> +#endif + +int +main() +{ + iconv(0, 0, 0, 0, 0); + return 0; +} diff --git a/src/cmd/INIT/iffe.sh b/src/cmd/INIT/iffe.sh new file mode 100644 index 0000000..cfd216c --- /dev/null +++ b/src/cmd/INIT/iffe.sh @@ -0,0 +1,4639 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2012 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +# Glenn Fowler & Phong Vo +# AT&T Research +# +# test if feature exists +# this script is written to make it through all sh variants +# +# NOTE: .exe a.out suffix and [\\/] in path patterns for dos/nt + +case $-:$BASH_VERSION in +*x*:[0123456789]*) : bash set -x is broken :; set +ex ;; +esac + +command=iffe +version=2012-02-23 # update in USAGE too # + +compile() # $cc ... +{ + "$@" 2>$tmp.err + _compile_status=$? + if test -s $tmp.err + then cat $tmp.err >&2 + case $_compile_status in + [1-9]|[1-9][0-9]|1[01][0-9]|12[0-7]) + if egrep -i -c 'terminated with signal|core dump|segmentation fault' $tmp.err >&$nullout + then _compile_status=139 + fi + ;; + esac + fi + case $_compile_status in + ?|??|1[01]?|12[0-8]|25?) + ;; + *) echo "$command: $@" >&$stderr + cat $tmp.err >&$stderr + echo "$command: $1: core dump or fatal interruption -- results inconclusive" >&$stderr + exit $_compile_status + ;; + esac + return $_compile_status +} + +is_hdr() # [ - ] [ file.c ] hdr +{ + case $1 in + -) _is_hdr_flag=-; shift ;; + *) _is_hdr_flag= ;; + esac + case $1 in + *.c) _is_hdr_file=$1; shift ;; + *) _is_hdr_file=$tmp.c ;; + esac + is hdr $1 + compile $cc -c $_is_hdr_file <&$nullin >&$nullout 2>$tmp.e + _is_hdr_status=$? + case $_is_hdr_status in + 0) if test -s $tmp.e + then case `grep '#.*error' $tmp.e` in + ?*) _is_hdr_status=1 ;; + esac + fi + ;; + esac + case $_is_hdr_status in + 0) success $_is_hdr_flag + ;; + *) case $debug in + 3) cat $tmp.e >&$stderr ;; + esac + failure $_is_hdr_flag + ;; + esac + return $_is_hdr_status +} + +pkg() # package +{ + case $1 in + '') pth=`getconf PATH 2>/dev/null` + case $pth in + '') pth="/bin /usr/bin" ;; + *:*) pth=`echo "$pth" | sed 's/:/ /g'` ;; + esac + return + ;; + '<') shift + ;; + *) return + ;; + esac + case $1 in + X|X11*) i="openwin" + case $1 in + X) set X11 ;; + esac + case $1 in + X11) case $# in + 1) set $1 6 5 4 ;; + esac + ;; + esac + ;; + *) i= + ;; + esac + pth="{ usr . - . contrib local $i - . share - . lib - $1" + i=$1 + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + '>') shift; break ;; + esac + pth="$pth ${i}R$1 ${i}.$1" + done + pth="$pth . } $*" +} + +is() # op name +{ + case $verbose in + 1) case $complete in + 1) failure ;; + esac + oo=$1 + shift + case $1 in + ?*) yy=is + ii=$1 + complete=1 + case $oo in + cmd) mm="a command" ;; + dat) mm="a library data symbol" ;; + dfn) mm="a macro with extractable value" ;; + exp) mm="true" ;; + hdr) mm="a header" ;; + id) mm="an identifier" ;; + lcl) mm="a native header" ;; + key) mm="a reserved keyword" ;; + lib) mm="a library function" ;; + LIB) case $2 in + "") mm="a library" ;; + *) ii=$*; mm="a library group" ;; + esac + ;; + mac) mm="a macro" ;; + mem) mm="a member of $2" ;; + mth) mm="a math library symbol" ;; + nos) mm="a non-opaque struct" ;; + npt) mm="a symbol that needs a prototype" ;; + num) mm="a numeric constant or enum" ;; + nxt) mm="an include path for the native header" ;; + opt) mm="set in \$PACKAGE_OPTIONS" ;; + pth) mm="a file" ;; + run) yy="capture output of" mm= ;; + siz) mm="a type with known size" ;; + sym) mm="a typed variable" ;; + sys) mm="a system header" ;; + typ) mm="a type or typedef" ;; + val) yy="determine" mm="value" ;; + *) yy= mm= ;; + esac + case $ii in + [abcdefghijklmnopqrstuvwxyz]*[abcdefghijklmnopqrstuvwxyz]'{') ii="$ii ... }end" ;; + esac + $show "$command: test:" $yy $ii $mm "...$SHOW" >&$stderr + complete=1 + ;; + esac + ;; + esac +} + +success() +{ + case $1 in + -) shift + ;; + *) case $result in + UNKNOWN) result=SUCCESS ;; + esac + case $1 in + +) return ;; + esac + ;; + esac + case $complete:$verbose in + 1:1) case $suspended in + 1) suspended=0 + $show "$command: test:" $yy $ii $mm "...$SHOW" >&$stderr + ;; + esac + complete=0 + case $# in + 0) mm="yes" ;; + *) mm="'$*'" ;; + esac + case $debug in + 0) echo " $mm" >&$stderr ;; + *) echo "$command: ... $mm" >&$stderr ;; + esac + ;; + esac +} + +failure() +{ + case $1 in + -) shift ;; + *) result=FAILURE + case $1 in + +) return ;; + esac + ;; + esac + case $complete:$verbose in + 1:1) case $suspended in + 1) suspended=0 + $show "$command: test:" $yy $ii $mm "...$SHOW" >&$stderr + ;; + esac + complete=0 + case $group in + '') case $# in + 0) mm="no" ;; + *) mm=$* ;; + esac + ;; + *) mm= + ;; + esac + case $debug in + 0) echo " $mm" >&$stderr ;; + *) echo "$command: ... $mm" >&$stderr ;; + esac + ;; + esac +} + +# report +# +# - ignore global status +# -0 normal sense +# -1 inverted sense if ! def +# status test status 0:success *:failure +# success success comment +# failure failure comment +# default default setting comment +# +# globals +# +# $not invert test sense +# $M test variable +# $m test macro +# $v default macro + +report() # [-] [-0] [-1] status value success failure default +{ + case $1 in + -) _report_ignore=$1 + shift + ;; + *) _report_ignore= + ;; + esac + _report_not=$not + case $1 in + -0) shift + ;; + -1) shift + case $def in + ''|-) case $_report_not in + 1) _report_not= ;; + *) _report_not=1 ;; + esac + ;; + esac + ;; + esac + _report_status=$1 + case $_report_ignore:$_report_status in + -:*) ;; + *:0) success $_report_ignore + ;; + *) failure $_report_ignore + case $group in + ?*) return ;; + esac + ;; + esac + _report_value=$2 + case $_report_not in + 1) case $_report_status in + 0) _report_status=1 ;; + *) _report_status=0 ;; + esac + _report_success=$4 + _report_failure=$3 + ;; + *) _report_success=$3 + _report_failure=$4 + ;; + esac + _report_default=$5 + case $_report_status in + 0) case $M in + *-*) ;; + *) usr="$usr$nl#define $m $_report_value" + case $_report_success in + ''|-) ;; + *) case $define in + 1) echo "#define $m $_report_value /* $_report_success */" ;; + n) echo "$m=$_report_value" + esac + ;; + esac + eval $m=\'$_report_value\' + ;; + esac + ;; + *) case $M in + *-*) ;; + *) case $_report_failure in + ''|-) ;; + *) case $define$all$config$undef in + 1?1?|1??1)echo "#undef $m /* $_report_failure */" ;; + 11??) echo "#define $m 0 /* $_report_failure */" ;; + n1?1) echo "$m=" ;; + n1??) echo "$m=0" ;; + esac + ;; + esac + case $_report_default in + ''|-) ;; + *) case $define$set in + 1?*) echo "#define $v $set /* $_report_default */" ;; + n?*) echo "$v=$set" ;; + esac + ;; + esac + eval $m=0 + ;; + esac + ;; + esac +} + +noisy() +{ + case $complete:$verbose in + 1:1) suspended=1 + echo >&$stderr + ;; + esac +} + +here_broken=0 + +literal() # line that echo might process +{ + if cat <<! +$* +! + then : old here doc botch not present + else case $here_broken in + 0) here_broken=1 + echo "$command: your shell botches here documents; this was fixed back in the 80's" >&$stderr + ;; + esac + sh -c "cat <<! +$* +! +" + fi +} + +copy() # "output-file" "data-that-must-not-be-processed-by-echo" +{ + case $1 in + -) case $shell in + ksh) print -r - "$2" + ;; + *) if cat <<! +$2 +! + then : ancient here doc botch not present + else case $here_broken in + 0) here_broken=1 + echo "$command: your shell botches here documents; this was fixed back in the 80's" >&$stderr + ;; + esac + sh -c "cat <<! +$2 +! +" + fi + ;; + esac + ;; + *) case $shell in + ksh) print -r - "$2" > "$1" + ;; + *) if cat > "$1" <<! +$2 +! + then : ancient here doc botch not present + else case $here_broken in + 0) here_broken=1 + echo "$command: your shell botches here documents; this was fixed back in the 80's" >&$stderr + ;; + esac + sh -c "cat > \"$1\" <<! +$2 +! +" + fi + ;; + esac + ;; + esac +} + +# verify that cc is a C compiler + +checkcc() +{ + # check for local package root directories + + case $PACKAGE_PATH in + ?*) for i in `echo $PACKAGE_PATH | sed 's,:, ,g'` + do if test -d $i/include + then cc="$cc -I$i/include" + occ="$occ -I$i/include" + fi + if test -d $i/lib + then cc="$cc -L$i/lib" + occ="$occ -L$i/lib" + for y in $libpaths + do eval $y=\"\$$y:\$i/lib\$${y}_default\" + eval export $y + done + fi + done + ;; + esac + echo "int i = 1;" > $tmp.c + if compile $cc -c $tmp.c <&$nullin >&$nullout + then echo "(;" > $tmp.c + if compile $cc -c $tmp.c <&$nullin >&$nullout + then cctest="should not compile '(;'" + fi + else cctest="should compile 'int i = 1;'" + fi + case $cctest in + "") cctest=0 + ;; + *) echo "$command: $cc: not a C compiler: $cctest" >&$stderr + exit 1 + ;; + esac +} + +checkread() +{ + case $cctest in + "") checkcc ;; + esac + case $posix_read in + -no) ;; + *) posix_read=`(read -r _checkread_line; echo $_checkread_line) 2>/dev/null <<! +a z +! +` + ;; + esac + case $posix_read in + "a z") posix_read=1 + ;; + *) copy ${tmp}r.c " + extern int read(); + extern int write(); + int main() + { + char c; + char r; + int k; + char s[32]; + k = 0; + while (read(0, &c, 1) == 1) + { + if (k >= 0) + { + if (c == ' ' || c == '\\t') + { + if (k < sizeof(s)) + s[k++] = c; + continue; + } + if (k > 1 && c != '#' && c != '\\n' && c != '\\r') + write(1, s + 1, k - 1); + k = -1; + } + if (c == '\\r') + { + r = c; + if (read(0, &c, 1) == 1 && c != '\\n') + write(1, &r, 1); + } + write(1, &c, 1); + if (c == '\\n') + return 0; + } + return 1; + }" + if compile $cc -o ${tmp}r.exe ${tmp}r.c >&$nullout + then posix_read=${tmp}r.exe + else echo "$command: cannot compile read -r workaround" >&$stderr + exit 1 + fi + ;; + esac +} + +execute() +{ + if test "" != "$cross" + then crossexec $cross "$@" + _execute_=$? + elif test -d /NextDeveloper + then "$@" <&$nullin >&$nullout + _execute_=$? + "$@" <&$nullin | cat + else "$@" + _execute_=$? + fi + return $_execute_ +} + +exclude() +{ + case $excludes in + '') return 0 ;; + esac + for _exclude_var + do eval _exclude_old=\$$_exclude_var + case $_exclude_old in + *" -I"*);; + *) continue ;; + esac + _exclude_new= + _exclude_sep= + for _exclude_arg in $_exclude_old + do _exclude_skip= + for _exclude_dir in $excludes + do case $_exclude_arg in + -I$_exclude_dir|-I*/$_exclude_dir) + _exclude_skip=1 + break; + ;; + esac + done + case $_exclude_skip in + '') _exclude_new="$_exclude_new$_exclude_sep$_exclude_arg" + _exclude_sep=" " + ;; + esac + done + eval $_exclude_var=\$_exclude_new + case $debug in + 0) ;; + *) echo $command: exclude $_exclude_var: "$_exclude_old => $_exclude_new" >&$stderr + ;; + esac + done +} + +all=0 +apis= +binding="-dy -dn -Bdynamic -Bstatic -Wl,-ashared -Wl,-aarchive -call_shared -non_shared '' -static" +complete=0 +config=0 +defhdr= +define=1 +explicit=0 +iff= +usr= +cross= +debug=0 +deflib= +dir=FEATURE +excludes= +executable="test -x" +exists="test -e" +gothdr= +gotlib= +idno= +idyes= +ifs=${IFS-' + '} +in= +includes= +intrinsic= +libpaths="LD_LIBRARY_PATH LD_LIBRARYN32_PATH LD_LIBRARY64_PATH LIBPATH SHLIB_PATH" + LD_LIBRARY_PATH_default=:/lib:/usr/lib + LD_LIBRARYN32_PATH_default=:/lib32:/usr/lib32 + LD_LIBRARY64_PATH_default=:/lib64:/usr/lib64 + LIBPATH_default=:/lib:/usr/lib + SHLIB_PATH_default=:/shlib:/usr/shlib:/lib:/usr/lib +nl=" +" +optimize=1 +occ=cc +one= +out= +posix_read=-check +case `(set -f && set x * && echo $# && set +f) 2>/dev/null` in +2) posix_noglob="set -f" posix_glob="set +f" ;; +*) case `(set -F && set x * && echo $# && set +F) 2>/dev/null` in + 2) posix_noglob="set -F" posix_glob="set +F" ;; + *) posix_noglob=":" posix_glob=":" ;; + esac + ;; +esac +protoflags= +puthdr= +putlib= +pragma= +case $RANDOM in +$RANDOM)shell=bsh + ($executable .) 2>/dev/null || executable='test -r' + ($exists .) 2>/dev/null || exists='test -r' + ;; +*) case $BASH_VERSION in + ?*) shell=bash ;; + *) shell=ksh ;; + esac + ;; +esac +reallystatic= +reallystatictest= +regress= +static=. +statictest= +case $COTEMP in +"") case $HOSTNAME in + ""|?|??|???|????|????) + tmp=${HOSTNAME} + ;; + *) case $shell in + bsh) eval `echo $HOSTNAME | sed 's/\\(....\\).*/tmp=\\1/'` ;; + *) eval 'tmp=${HOSTNAME%${HOSTNAME#????}}' ;; + esac + ;; + esac + tmp=${tmp}$$ + ;; +*) tmp=x${COTEMP} + ;; +esac +COTEMP=${tmp} +export COTEMP +case $tmp in +./*) ;; +??????????*) + case $shell in + bsh) eval `echo $tmp | sed 's/\\(.........\\).*/tmp=\\1/'` ;; + *) eval 'tmp=${tmp%${tmp#?????????}}' ;; + esac + ;; +?????????) + ;; +????????) + tmp=F$tmp + ;; +esac +case $tmp in +./*) ;; +*) tmp=./$tmp ;; +esac +undef=0 +verbose=0 +vers= + +# options -- `-' for output to stdout otherwise usage + +case $1 in +-) out=-; shift ;; +esac +set= + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) USAGE=$' +[-? +@(#)$Id: iffe (AT&T Research) 2012-02-23 $ +] +'$USAGE_LICENSE$' +[+NAME?iffe - C compilation environment feature probe] +[+DESCRIPTION?\biffe\b is a command interpreter that probes the C + compilation environment for features. A feature is any file, option + or symbol that controls or is controlled by the C compiler. \biffe\b + tests features by generating and compiling C programs and observing + the behavior of the C compiler and generated programs.] +[+?\biffe\b statements are line oriented. Statements may appear in the + operand list with the \b:\b operand or \bnewline\b as the line + delimiter. The standard input is read if there are no command + line statements or if \afile\a\b.iffe\b is omitted.] +[+?Though similar in concept to \bautoconf\b(1) and \bconfig\b(1), there + are fundamental differences. The latter tend to generate global + headers accessed by all components in a package, whereas \biffe\b is + aimed at localized, self contained feature testing.] +[+?Output is generated in \bFEATURE/\b\atest\a by default, where \atest\a is + the base name of \afile\a\b.iffe\b or the \biffe\b \brun\b + file operand. Output is first generated in a temporary file; the + output file is updated if it does not exist or if the temporary file + is different. If the first operand is \b-\b then the output is written + to the standard output and no update checks are done.] +[+?Files with suffixes \b.iffe\b and \b.iff\b are assumed to contain + \biffe\b statements.] +[a:all?Define failed test macros \b0\b. By default only successful test macros + are defined \b1\b.] +[c:cc?Sets the C compiler name and flags to be used in the feature + tests.]:[C-compiler-name [C-compiler-flags ...]]] +[C:config?Generate \bconfig\b(1) style \aHAVE_\a* macro names. This implies + \b--undef\b. Since \bconfig\b(1) has inconsistent naming conventions, + the \bexp\b op may be needed to translate from the (consistent) + \biffe\b names. Unless otherwise noted a \bconfig\b macro name + is the \biffe\b macro name prefixed with \bHAVE\b and converted to + upper case. \b--config\b is set by default if the command arguments + contain a \brun\b op on an input file with the base name \bconfig\b.] +[d:debug?Sets the debug level. Level 0 inhibits most + error messages, level 1 shows compiler messages, and + level 2 traces internal \biffe\b \bsh\b(1) actions and does + not remove core dumps on exit.]#[level] +[D:define?Successful test macro definitions are emitted. This is the default.] +[E:explicit?Disable implicit test output.] +[F:features?Sets the feature test header to \ahdr\a. This header typically + defines *_SOURCE feature test macros.]:[hdr:=NONE] +[i:input?Sets the input file name to \afile\a, which + must contain \biffe\b statements.]:[file] +[I:include?Adds \b-I\b\adir\a to the C compiler flags.]:[dir] +[L:library?Adds \b-L\b\adir\a to the C compiler flags.]:[dir] +[n:name-value?Output \aname\a=\avalue\a assignments only.] +[N!:optimize?\b--nooptimize\b disables compiler optimization options.] +[o:output?Sets the output file name to \afile\a.]:[file] +[O:stdio?Sets the standard io header to \ahdr\a.]:[hdr:=stdio.h] +[e:package?Sets the \bproto\b(1) package name to \aname\a.]:[name] +[p:prototyped?Emits \b#pragma prototyped\b at the top of the + output file. See \bproto\b(1).] +[P:pragma?Emits \b#pragma\b \atext\a at the top of the output file.]:[text] +[r:regress?Massage output for regression testing.] +[s:shell?Sets the internal shell name to \aname\a. Used for debugging + Bourne shell compatibility (otherwise \biffe\b uses \aksh\a constructs + if available). The supported names are \bksh\b, \bbsh\b, \bbash\b, and + \bosh\b. \bosh\b forces the \bread -r\b compatibility read command to + be compiled and used instead of \bread -r\b. The default is determined + by probing the shell at startup.]:[name] +[S:static?Sets the C compiler flags that force static linking. If not set + then \biffe\b probes the compiler to determine the flags. \biffe\b + must use static linking (no dlls) because on some systems missing + library symbols are only detected when referenced at runtime from + dynamically linked executables.]:[flags] +[u:undef?\b#undef\b failed test macros. By default only successful test macros + are defined \b1\b.] +[v:verbose?Produce a message line on the standard error for each test as + it is performed.] +[x:cross?Some tests compile an executable (\ba.out\b) and then run it. + If the C compiler is a cross compiler and the executable format is + incompatible with the execution environment then the generated + executables must be run in a different environment, possibly on + another host. \acrosstype\a is the HOSTTYPE for generated executables + (the \bpackage\b(1) command generates a consistent HOSTTYPE namespace). + Generated executables are run via \bcrossexec\b(1) with \acrosstype\a + as the first argument. \bcrossexec\b supports remote execution for + cross-compiled executables. See \bcrossexec\b(1) for + details.]:[crosstype] +[X:exclude?Removes \b-I\b\adir\a and \b-I\b*/\adir\a C compiler flags.]:[dir] + +[ - ] [ file.iffe | statement [ : statement ... ] ] + +[+SYNTAX?\biffe\b input consists of a sequence of statement lines. Statements + that span more than one line contain \abegin\a\b{\b as the last + operand (where \abegin\a is command specific) and zero + or more data lines terminated by a line containing + \b}end\b as the first operand. The statement syntax is: + [\aname\a \b=\b]] [\b!\b]] \atest\a[,\atest\a...]] [\b-\b]] + [\aarg\a[,\aarg\a...]]]] [\aprereq\a ...]] + [\abegin\a{ ... |\bend\b ...]] [= [\adefault\a]]]]. + \atest\as and \aarg\as may be combined, separated by commas, to perform + a set of tests on a set of arguments. \aname\a \b=\b before \atest\a + overrides the default test variable and macro name, and \b-\b after + \atest\a performs the test but does not define the test variable and + macro values. \b!\b before \atest\a inverts the test sense for \bif\b, + \belif\b, and \byes{\b and \bno{\b blocks.] +[+?\aprereq\as are used when applying the features tests and may be + combinations of:]{ + [+compiler options?\b-D\b*, \b-L\b*, etc.] + [+library references?\b-l\b*, *\b.a\b, etc. \b_LIB_\b\aname\a + is defined to be 1 if \b-l\b\aname\a is a library.] + [+header references?*\b.h\b. \a_dir_name\a is defined to be 1 + if \adir/name\a\b.h\b is a header, or if \adir\a is + omitted, \b_hdr_\b\aname\a is defined to be 1 if + \aname\a\b.h\b is a header.] + [+-?Prereq grouping mark; prereqs before the first \b-\b are + passed to all feature tests. Subsequent groups + are attempted in left-to-right order until the first + successful group is found.] + } +[+?\abegin\a\b{\b ... \b}end\b delimit multiline code blocks that override + or augment the default code provided by \biffe\b. User supplied code + blocks should be compatible with the K&R, ANSI, and C++ C language + dialects for maximal portability. In addition to all macro definitions + generated by previous tests, all generated code contains the + following at the top to hide dialect differences:]{ + [+ ?#if defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus)] + [+ ?#define _STD_ 1] + [+ ?#define _ARG_(x) x] + [+ ?#define _VOID_ void] + [+ ?#else] + [+ ?#define _STD_ 0] + [+ ?#define _ARG_(x) ()] + [+ ?#define _VOID_ char] + [+ ?#endif] + [+ ?#if defined(__cplusplus)] + [+ ?#define _BEGIN_EXTERNS_ extern "C" {] + [+ ?#define _END_EXTERNS_ }] + [+ ?#else] + [+ ?#define _BEGIN_EXTERNS_] + [+ ?#define _END_EXTERNS_] + [+ ?#endif] + [+ ?#define _NIL_(x) ((x)0)] + [+ ?#include <stdio.h>] + } +[+?= \adefault\a may be specified for the \bkey\b, \blib\b, \bmac\b, \bmth\b + and \btyp\b tests. If the test fails for \aarg\a then + \b#define\b \aarg\a \adefault\a is emitted. \bkey\b accepts multiple + \b= \b\adefault\a values; the first valid one is used.] +[+?Each test statement generates a portion of a C language header that contains + macro defintions, comments, and other text corresponding to the feature + tests. \b#ifndef _def_\b\aname\a\b_\b\adirectory\a ... + \b#endif\b guards the generated header from multiple \b#include\bs, + where \aname\a is determined by either the \brun\b statement input file + name if any, or the first \atest\a in the first statement, and \adirectory\a + is the basename component of either the \brun\b statement file, if any, + or the current working directory. The output file name is determined + in this order:]{ + [+-?If the first command line operand is \b-\b then the output + is written to the standard output.] + [+--output=\afile\a?Output is \afile\a.] + [+set out \afile\a?Output is \afile\a.] + [+[run]] [\adirectory\a/]]\abase\a[\a.suffix\a]]?Output is + \bFEATURE/\b\abase\a.] + } +[+?Generated \biffe\b headers are often referenced in C source as: + \b#include "FEATURE/\b\afile\a". The \bnmake\b(1) base rules contain + metarules for generating \bFEATURE/\b\afile\a from + \bfeatures/\b\afile\a[\asuffix\a]], where \asuffix\a may be omitted, + \b.c\b, or \b.sh\b (see the \brun\b test below). Because + \b#include\b prerequisites are automatically detected, \bnmake\b(1) + ensures that all prerequisite \biffe\b headers are generated before + compilation. Note that the directories are deliberately named + \bFEATURE\b and \bfeatures\b to keep case-ignorant file systems + happy.] +[+?The feature tests are:]{ + [+# \acomment\a?Comment line - ignored.] + [+api \aname\a \aYYYYMMDD\a \asymbol ...\a?Emit api compatibility tests + for \aname\a and \b#define\b \asymbol\a \asymbol\a_\aYYYYMMDD\a + when \aNAME\a_API is >= \aYYYYMMDD\a (\aNAME\a is \aname\a + converted to upper case). If \aNAME\a_API is not defined + then \asymbol\a maps to the newest \aYYYYMMDD\a for \aname\a.] + [+define \aname\a [ (\aarg,...\a) ]] [ \avalue\a ]]?Emit a macro + \b#define\b for \aname\a if it is not already defined. The + definition is passed to subsequent tests.] + [+extern \aname\a \atype\a [ (\aarg,...\a) | [\adimension\a]] ]]?Emit + an \bextern\b prototype for \aname\a if one is not already + defined. The prototype is passed to subsequent tests.] + [+header \aheader\a?Emit \b#include <\b\aheader\a\b>\b if \aheader\a + exists. The \b#include\b is passed to subsequent tests.] + [+print \atext\a?Copy \atext\a to the output file. \atext\a is passed + to subsequent tests.] + [+reference \aheader\a?If \aheader\a exists then add \b#include\b + \aheader\a to subsequent tests.] + [+ver \aname\a \aYYYYMMDD\a?\b#define\b \aNAME\a_VERSION \aYYYYMMDD\a + (\aNAME\a is \aname\a converted to upper case).] + [+cmd \aname\a?Defines \b_cmd_\b\aname\a if \aname\a is an executable + in one of the standard system directories (\b/bin, /etc, + /usr/bin, /usr/etc, /usr/ucb\b). + \b_\b\adirectory\a\b_\b\aname\a is defined for \adirectory\a + in which \aname\a is found (with \b/\b translated to \b_\b).] + [+dat \aname\a?Defines \b_dat_\b\aname\a if \aname\a is a data symbol + in the default libraries.] + [+def \aname\a?Equivalent to \bcmd,dat,hdr,key,lib,mth,sys,typ\b + \aname\a.] + [+dfn \aname\a?If \aname\a is a macro in the candidate headers then + a \b#define\b \aname\a \avalue\a statment is output for the + \avalue\a defined in the headers. The definition is \b#ifndef\b + guarded.] + [+exp \aname\a \aexpression\a?If \aexpression\a is a \"...\" string + then \aname\a is defined to be the string, else if the + \bexpr\b(1) evaluation of \aexpression\a is not 0 then \aname\a + is defined to be 1, otherwise \aname\a is defined to be 0. + Identifiers in \aexpression\a may be previously defined names + from other \biffe\b tests; undefined names evaluate to 0. + If \aname\a was defined in a previous successful test then + the current and subsequent \bexp\b test on \aname\a are + skipped. If \aname\a is \b-\b then the \aexpression\a is + simply evaluated.] + [+hdr \aname\a?Defines \b_hdr_\b\aname\a if the header + \b<\b\aname\a\b.h>\b exists. The \b--config\b macro name is + \bHAVE_\b\aNAME\a\b_H\b.] + [+if \astatement\a ... | \belif\b \astatement\a ... | \belse\b | \bendif\b? + Nested if-else test control.] + [+iff \aname\a?The generated header \b#ifndef-#endif\b macro guard is + \b_\b\aname\a\b_H\b.] + [+inc \afile\a [ re ]]?Read #define macro names from \afile\a + and arrange for those names to evaluate to 1 in \bexp\b + expressions. If \are\a is specified then macros not matching + \are\a are ignored.] + [+key \aname\a?Defines \b_key_\b\aname\a if \aname\a is a reserved + word (keyword).] + [+lcl \aname\a?Generates a \b#include\b statement for the native version + of the header \b<\b\aname\a\b.h>\b if it exists. Defines + \b_lcl_\b\aname\a on success. The \b--config\b macro name is + \bHAVE_\b\aNAME\a\b_H\b. The default \are\a is \b^HAVE_\b + for \b--config\b and \b^_\b otherwise.] + [+lib \aname\a?Defines \b_lib_\b\aname\a if \aname\a is an external + symbol in the default libraries.] + [+mac \aname\a?Defines \b_mac_\b\aname\a if \aname\a is a macro.] + [+mem \astruct.member\a?Defines \b_mem_\b\amember\a\b_\b\astruct\a + if \amember\a is a member of the structure \astruct\a.] + [+mth \aname\a?Defines \b_mth_\b\aname\a if \aname\a is an external + symbol in the math library.] + [+nop \aname\a?If this is the first test then \aname\a may be used + to name the output file and/or the output header guard macro. + Otherwise this test is ignored.] + [+npt \aname\a?Defines \b_npt_\b\aname\a if the \aname\a symbol + requires a prototype. The \b--config\b macro name is + \bHAVE_\aNAME\a\b_DECL\b with the opposite sense.] + [+num \aname\a?Defines \b_num_\b\aname\a if \aname\a is a numeric + constant \aenum\a or \amacro\a.] + [+nxt \aname\a?Defines a string macro \b_nxt_\b\aname\a suitable for + a \b#include\b statement to include the next (on the include + path) or native version of the header \b<\b\aname\a\b.h>\b + if it exists. Also defines the \"...\" form + \b_nxt_\b\aname\a\b_str\b. The \b--config\b macro name is + \bHAVE_\b\aNAME\a\b_NEXT\b.] + [+one \aheader\a ...?Generates a \b#include\b statement for the first + header found in the \aheader\a list.] + [+opt \aname\a?Defines \b_opt_\b\aname\a if \aname\a is a space-separated + token in the global environment variable \bPACKAGE_OPTIONS\b.] + [+pth \afile\a [ \adir\a ... | { \ag1\a - ... - \agn\a } | < \apkg\a [\aver\a ...]] > ]]?Defines + \b_pth_\b\afile\a, with embedded \b/\b chars translated to + \b_\b, to the path of the first instance of \afile\a in the + \adir\a directories. \b{\b ... \b}\b forms a directory list + from the cross-product of \b-\b separated directory groups + \ag1\a ... \agn\a. < ... > forms a directory list for the + package \apkg\a with optional versions. If no operands are + specified then the default PATH directories are used. The + \b--config\b macro name is \aNAME\a\b_PATH\b.] + [+run \afile\a?Runs the tests in \afile\a based on the \afile\a + suffix:]{ + [+.c?\afile\a is compiled and executed and the output is copied + to the \biffe\b output file. Macros and headers supplied + to \bbegin{\b ... \b}end\b are also supplied to + \afile\a.] + [+.sh?\afile\a is executed as a shell script and the output is + copied to the \biffe\b output file.] + [+.iffe \bor no suffix?\afile\a contains \biffe\b + statements.] + } + [+set \aoption value\a?Sets option values. The options are described + above.] + [+siz \aname\a?Defines \b_siz_\b\aname\a to be \bsizeof\b(\aname\a) if + \aname\a is a type in any of \b<sys/types.h>, <times.h>, + <stddef.h>, <stdlib.h>\b. Any \b.\b characters in \aname\a are + translated to space before testing and are translated to \b_\b + in the output macro name.] + [+sym \aname\a?Defines \b_ary_\b\aname\a if \aname\a is an array, + \b_fun_\b\aname\a if \aname\a is a function pointer, + \b_ptr_\b\aname\a if \aname\a is a pointer, or + \b_reg_\b\aname\a if \aname\a is a scalar. In most cases + \aname\a is part of a macro expansion.] + [+sys \aname\a?Defines \b_sys_\b\aname\a if the header + \b<sys/\b\aname\a\b.h>\b exists. The \b--config\b macro name is + \bHAVE_SYS_\b\aNAME\a\b_H\b.] + [+tst \aname\a?A user defined test on name. A source block must be + supplied. Defines \b_\b\aname\a on success. \btst - ...\b is + treated as \btst - - ...\b.] + [+typ \aname\a?Defines \b_typ_\b\aname\a if \aname\a is a type in any + of \b<sys/types.h>, <times.h>, <stddef.h>, <stdlib.h>\b. Any + \b.\b characters in \aname\a are translated to space before + testing and are translated to \b_\b in the output macro name.] + [+val \aname\a?The output of \becho\b \aname\a is written to the + output file.] + [+var \aname\a?A user defined test on name. A source block must be + supplied. Sets the \bexp\b variable \b_\b\aname\a on success + but does not define a macro.] + [+(\aexpression\a)?Equivalent to \bexp -\b \aexpression\a.] +} +[+?Code block names may be prefixed by \bno\b to invert the test sense. The + block names are:]{ + [+cat?The block is copied to the output file.] + [+compile?The block is compiled (\bcc -c\b).] + [+cross?The block is executed as a shell script using \bcrossexec\b(1) + if \b--cross\b is on, or on the local host otherwise, and the + output is copied to the output file. Test macros are not + exported to the script.] + [+execute?The block is compiled, linked, and executed. \b0\b exit + status means success.] + [+fail?If the test fails then the block text is evaluated by + \bsh\b(1).] + [+link?The block is compiled and linked (\bcc -o\b).] + [+macro?The block is preprocessed (\bcc -E\b) and lines containing + text bracketed by \b<<"\b ... \b">>\b (\aless-than less-than + double-quote ... double-quote greater-than greater-than\a) + are copied to the output file with the brackets omitted.] + [+no?If the test fails then the block text is copied to the + output file. Deprecated: use { \bif\b \belif\b \belse\b + \bendif\b } with unnamed \b{\b ... \b}\b blocks.] + [+note?If the test succeeds then the block is copied to the output + as a \b/*\b ... \b*/\b comment.] + [+output?The block is compiled, linked, and executed, and the output + is copied to the output file.] + [+pass?If the test succeeds then the block text is evaluated by + \bsh\b(1).] + [+preprocess?The block is preprocessed (\bcc -E\b).] + [+run?The block is executed as a shell script and the output is + copied to the output file. Succesful test macros are also + defined as shell variables with value \b1\b and are available + within the block. Likewise, failed test macros are defined + as shell variables with value \b0\b.] + [+status?The block is compiled, linked, and executed, and the exit + status is the test outcome, 0 for \afailure\a, the value + otherwise.] + [+yes?If the test succeeds then the block text is copied to the output + file. \byes{\b ... \b}end\b is equivalent to the unnamed block + \b{\b ... \b}\b. Deprecated: use { \bif\b \belif\b \belse\b + \bendif\b } with unnamed \b{\b ... \b}\b blocks.] +} +[+SEE ALSO?\bautoconf\b(1), \bconfig\b(1), \bgetconf\b(1), \bcrossexec\b(1), + \bnmake\b(1), \bpackage\b(1), \bproto\b(1), \bsh\b(1)] +' + while getopts -a "$command" "$USAGE" OPT + do case $OPT in + a) set="$set set all :" ;; + c) set="$set set cc $OPTARG :" ;; + C) set="$set set config :" ;; + d) set="$set set debug $OPTARG :" ;; + D) set="$set set define :" ;; + E) set="$set set explicit :" ;; + F) set="$set set features $OPTARG :" ;; + i) set="$set set input $OPTARG :" ;; + I) set="$set set include $OPTARG :" ;; + L) set="$set set library $OPTARG :" ;; + n) set="$set set namval $OPTARG :" ;; + N) set="$set set nooptimize $OPTARG :" ;; + o) set="$set set output $OPTARG :" ;; + e) set="$set set package $OPTARG :" ;; + p) set="$set set prototyped :" ;; + P) set="$set set pragma $OPTARG :" ;; + r) set="$set set regress :" ;; + s) set="$set set shell $OPTARG :" ;; + S) set="$set set static $OPTARG :" ;; + O) set="$set set stdio $OPTARG :" ;; + u) set="$set set undef :" ;; + v) set="$set set verbose :" ;; + x) set="$set set cross $OPTARG :" ;; + X) set="$set set exclude $OPTARG :" ;; + esac + done + shift `expr $OPTIND - 1` + ;; +*) while : + do case $# in + 0) break ;; + esac + case $1 in + -) break + ;; + --) shift + break + ;; + --a|--al|--all) + REM=a + ;; + --cc=*) REM=c`echo X$1 | sed 's,[^=]*=,,'` + ;; + --co|--con|--conf|--confi|--config) + REM=C + ;; + --cr=*|--cro=*|--cros=*|--cross=*) + REM=x`echo X$1 | sed -e 's,[^=]*=,,'` + ;; + --d=*|--de=*|--deb=*|--debu=*|--debug=*) + REM=d`echo X$1 | sed 's,[^=]*=,,'` + ;; + --def|--defi|--defin|--define) + REM=D + ;; + --e=*|--ex=*|--exc=*|--excl=*|--exclu=*|--exclud=*|--exclude=*) + REM=X`echo X$1 | sed 's,[^=]*=,,'` + ;; + --e|--ex|--exp|--expl|--expli|--explic|--explici|--explicit) + REM=E + ;; + --f=*|--fe=*|--fea=*|--feat=*|--featu=*|--featur=*|--feature=*|--features=*) + REM=F`echo X$1 | sed 's,[^=]*=,,'` + ;; + --inp=*|--inpu=*|--input=*) + REM=i`echo X$1 | sed 's,[^=]*=,,'` + ;; + --inc=*|--incl=*|--inclu=*|--includ=*|--include=*) + REM=I`echo X$1 | sed 's,[^=]*=,,'` + ;; + --l=*|--li=*|--lib=*|--libr=*|--libra=*|--librar=*|--library=*) + REM=L`echo X$1 | sed 's,[^=]*=,,'` + ;; + --n|--na|--nam|--name|--name-v|--name-va|--name-val|--name-valu|--name-value) + REM=n + ;; + --o=*|--ou=*|--out=*|--outp=*|--outpu=*|--output=*) + REM=o`echo X$1 | sed 's,[^=]*=,,'` + ;; + --pa=*|--pac=*|--pack=*|--packa=*|--packag=*|--package=*) + REM=e`echo X$1 | sed 's,[^=]*=,,'` + ;; + --pro|--prot|--proto|--protot|--prototy|--prototyp|--prototype|--prototyped) + REM=p + ;; + --pra=*|--prag=*|--pragma=*) + REM=P`echo X$1 | sed 's,[^=]*=,,'` + ;; + --r|--re|--reg|--regre|--regres|--regress) + REM=r + ;; + --sh=*|--she=*|--shel=*|--shell=*) + REM=s`echo X$1 | sed 's,[^=]*=,,'` + ;; + --sta=*|--stat=*|--stati=*|--static=*) + REM=S`echo X$1 | sed 's,[^=]*=,,'` + ;; + --std=*|--stdi=*|--stdio=*) + REM=O`echo X$1 | sed 's,[^=]*=,,'` + ;; + --u|--un|--und|--unde|--undef) + REM=u + ;; + --v|--ve|--ver|--verb|--verbo|--verbos|--verbose) + REM=v + ;; + --*) echo $command: $1: unknown option >&2 + exit 2 + ;; + -*) REM=`echo X$1 | sed 's,X-,,'` + ;; + *) break + ;; + esac + shift + while : + do case $REM in + '') break ;; + esac + eval `echo $REM | sed "s,\(.\)\(.*\),OPT='\1' REM='\2',"` + case $OPT in + [cdFiILoOePsSxX]) + case $REM in + '') case $# in + 0) echo $command: -$OPT: option argument expected >&2 + exit 1 + ;; + esac + OPTARG=$1 + shift + ;; + *) OPTARG=$REM + REM='' + ;; + esac + esac + case $OPT in + a) set="$set set all :" ;; + c) set="$set set cc $OPTARG :" ;; + C) set="$set set config :" ;; + d) set="$set set debug $OPTARG :" ;; + D) set="$set set define :" ;; + E) set="$set set explicit :" ;; + F) set="$set set features $OPTARG :" ;; + i) set="$set set input $OPTARG :" ;; + I) set="$set set include $OPTARG :" ;; + L) set="$set set library $OPTARG :" ;; + n) set="$set set namval $OPTARG :" ;; + N) set="$set set nooptimize $OPTARG :" ;; + o) set="$set set output $OPTARG :" ;; + e) set="$set set package $OPTARG :" ;; + p) set="$set set prototyped :" ;; + P) set="$set set pragma $OPTARG :" ;; + r) set="$set set regress :" ;; + s) set="$set set shell $OPTARG :" ;; + S) set="$set set static $OPTARG :" ;; + O) set="$set set stdio $OPTARG :" ;; + u) set="$set set undef :" ;; + v) set="$set set verbose :" ;; + x) set="$set set cross $OPTARG :" ;; + X) set="$set set exclude $OPTARG :" ;; + *) echo "Usage: $command [-aCDEnpruv] [-c C-compiler-name [C-compiler-flags ...]] [-d level] + [-F features-header] [-i file] [-o file] [-O stdio-header] [-e name] [-P text] + [-s shell-path] [-S[flags]] [-x cross-exec-prefix] [-I dir] [-L dir] [-X dir] [ - ] + [ file.iffe | statement [ : statement ... ] ]" >&2 + exit 2 + ;; + esac + done + done + ;; +esac +case $1 in +-) out=-; shift ;; +esac +case $# in +0) in=- ;; +esac +set -- $set "$@" +case " $* " in +*' set config '*|*' run config.'*|*' run '*' config.'*|*' run '*'/config.'*) + config=1 + ;; +esac + +# standard error to /dev/null unless debugging +# standard output to the current output file +# +# stdout original standard output +# stderr original standard error +# nullin /dev/null input +# nullout /dev/null output + +stdout=5 stderr=6 nullin=7 nullout=8 +eval "exec $nullin</dev/null $nullout>/dev/null $stdout>&1 $stderr>&2" +case " $* " in +*" set debug "[3456789]*) + ;; +*) eval "exec 2>&$nullout" + ;; +esac + +# prompt complications + +case `print -n aha </dev/null 2>/dev/null` in +aha) show='print -n' SHOW='' ;; +*) case `echo -n aha 2>/dev/null` in + -n*) show=echo SHOW='\c' ;; + *) show='echo -n' SHOW='' ;; + esac + ;; +esac + +# tmp files cleaned up on exit +# status: 0:success 1:failure 2:interrupt + +status=1 +case $debug in +2) core= + ;; +*) if (ulimit -c 0) >/dev/null 2>&1 + then ulimit -c 0 + core= + else core="core core.??*" + fi + ;; +esac +trap "rm -f $core $tmp*" 0 +if (:>$tmp.c) 2>/dev/null +then rm -f $tmp.c +else echo "$command: cannot create tmp files in current dir" >&2 + exit 1 +fi +status=2 + +# standard header for c source + +std='#if defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus) +#define _STD_ 1 +#define _ARG_(x) x +#define _VOID_ void +#else +#define _STD_ 0 +#define _ARG_(x) () +#define _VOID_ char +#endif +#if defined(__cplusplus) +#define _BEGIN_EXTERNS_ extern "C" { +#define _END_EXTERNS_ } +#else +#define _BEGIN_EXTERNS_ +#define _END_EXTERNS_ +#endif +#define _NIL_(x) ((x)0)' +tst= +ext="#include <stdio.h>" +noext='*[<"][Ss][Tt][Dd][Ii][Oo].[Hh][">]*|*<ast.h>*|*<sfio.h>*|*/[*]<NOSTDIO>[*]/*' + +# loop on op [ arg [ ... ] ] [ : op [ arg [ ... ] ] ] + +argx=0 +cur=. +can= +cansep= +cctest= +file= +hdrtest= +ifelse=NONE +ifstack= +ini= +init=1 +line=0 +nan= +prototyped= +while : +do case $in in + "") case $argx:$* in + 1:$argv);; + 1:*) argx=0 + set x $argv + shift + ;; + esac + ;; + *) case $ini in + '') if read lin + then case $shell in + ksh) let line=line+1 ;; + *) line=`expr $line + 1` ;; + esac + $posix_noglob + set x $lin + $posix_glob + case $# in + 1) continue ;; + esac + else set x + fi + ;; + *) $posix_noglob + set x $ini + $posix_glob + ini= + ;; + esac + shift + case $init in + 1) case $1 in + iff) init=0 + ;; + print|ref|set) + ;; + *) init=0 + ini=$* + set ini + ;; + esac + esac + ;; + esac + case $# in + 0) case $ifstack in + ?*) echo "$command: $file$line: missing endif" >&$stderr + exit 1 + ;; + esac + set set out + + ;; + esac + + # if nesting + + while : + do case $1 in + "if") ifstack="$ifelse:$ifstack" + case $ifelse in + KEEP|NONE) + ifelse=TEST + ;; + TEST) ;; + *) ifelse=DONE + ;; + esac + shift + case $explicit in + 1) set '' - "$@"; shift ;; + esac + ;; + "elif") case $ifelse in + SKIP) ifelse=TEST + ;; + TEST) ;; + *) ifelse=DONE + ;; + NONE) echo "$command: $file$line: $1: no matching if" >&$stderr + exit 1 + ;; + esac + shift + case $explicit in + 1) set '' - "$@"; shift ;; + esac + ;; + "else") case $ifelse in + KEEP) ifelse=DONE + ;; + SKIP|TEST) + ifelse=KEEP + ;; + NONE) echo "$command: $file$line: $1: no matching if" >&$stderr + exit 1 + ;; + esac + shift + ;; + "endif")case $ifelse in + NONE) echo "$command: $file$line: $1: no matching if" >&$stderr + exit 1 + ;; + esac + case $shell in + ksh) ifelse=${ifstack%%:*} + ifstack=${ifstack#*:} + ;; + *) eval `echo $ifstack | sed 's,\([^:]*\):\(.*\),ifelse=\1 ifstack=\2,'` + ;; + esac + shift + ;; + *) break + ;; + esac + done + + # check if "run xxx" is equivalent to "set in xxx" + + case $1 in + "("*) set exp - "$@" ;; + *.iffe|*.iff) set run "$@" ;; + esac + case $1 in + :) shift + continue + ;; + run) case $shell in + bsh) case $2 in + */*) x=`echo $2 | sed 's,.*[\\\\/],,'` ;; + *) x=$2 ;; + esac + ;; + *) eval 'x=${2##*[\\/]}' + ;; + esac + case $x in + *.iffe|*.iff) + set set in $2 ;; + *.*) ;; + *) set set in $2 ;; + esac + ;; + esac + + # { inc set } drop out early + + case $1 in + ""|"#"*)continue + ;; + inc) case $ifelse in + DONE|SKIP) set ''; shift; continue ;; + esac + shift + case $# in + 0) echo "$command: $file$line: path expected" >&$stderr + exit 1 + ;; + esac + p=$1 + shift + if test ! -f $p + then echo "$command: $file$line: $p: file not found" >&$stderr + exit 1 + fi + case $# in + 0) case $config in + 1) e="^HAVE_" ;; + *) e="^_" ;; + esac + ;; + 1) e=$1 + ;; + *) shift + echo "$command: $file$line: warning: $*: operands ignored" >&$stderr + ;; + esac + eval `sed -e '/^#define[ ]/!d' -e 's/#define[ ]//' -e 's/[ (].*//' ${e:+"-e/$e/!d"} -e 's/.*/&=1/' $p | LC_ALL=C sort -u` + continue + ;; + set) case $ifelse in + DONE|SKIP) set ''; shift; continue ;; + esac + shift + case $1 in + ""|"#"*)op= + ;; + *) arg= + op=$1 + case $op in + --*) case $shell in + bsh) op=`echo X$op | sed 's/X--//'` ;; + *) op=${op#--} ;; + esac + ;; + -*) case $op in + -??*) case $shell in + bsh) arg=`echo X$op | sed 's/X-.//'` + op=`echo X$op | sed 's/X\\(-.\\).*/\\1/'` + ;; + *) arg=${op#-?} + op=${op%$arg} + ;; + esac + ;; + esac + case $op in + a) op=all ;; + c) op=cc ;; + C) op=config ;; + d) op=debug ;; + D) op=define ;; + E) op=explicit ;; + F) op=features ;; + i) op=input ;; + I) op=include ;; + L) op=library ;; + n) op=namval ;; + N) op=nooptimize ;; + o) op=output ;; + e) op=package ;; + p) op=prototyped ;; + P) op=pragma ;; + r) op=regress ;; + s) op=shell ;; + S) op=static ;; + O) op=stdio ;; + u) op=undef ;; + v) op=verbose ;; + x) op=cross ;; + X) op=exclude ;; + esac + ;; + esac + shift + while : + do case $# in + 0) break ;; + esac + case $1 in + *" "*) shift + continue + ;; + ""|"#"*)break + ;; + :) shift + break + ;; + esac + case $arg in + "") arg=$1 ;; + *) arg="$arg $1" ;; + esac + shift + done + ;; + esac + case $op in + all) all=1 + continue + ;; + cc) occ= + for x in $arg + do case $occ in + "") case $x in + *=*) case $shell in + bsh) eval $x + export `echo $x | sed 's/=.*//'` + ;; + *) export $x + ;; + esac + ;; + -O*) case $optimize in + 1) occ=$x ;; + esac + ;; + *) occ=$x + ;; + esac + ;; + *) occ="$occ $x" + ;; + esac + done + exclude occ + continue + ;; + config) config=1 + continue + ;; + cross) case $arg in + ""|-) cross= ;; + *) cross="$arg" libpaths= ;; + esac + continue + ;; + debug) debug=$arg + case $arg in + 0) exec 2>&$nullout + set - + show=echo + SHOW= + ;; + ""|1) exec 2>&$stderr + set - + show=echo + SHOW= + ;; + 2|3) exec 2>&$stderr + case $shell in + ksh) eval 'PS4="${PS4%+*([ ])}+\$LINENO+ "' + esac + show=echo + SHOW= + set -x + ;; + *) echo "$command: $arg: debug levels are 0, 1, 2, 3" >&$stderr + ;; + esac + continue + ;; + define) define=1 + continue + ;; + exclude)case $arg in + ""|-) excludes= ;; + *) excludes="$excludes $arg" ;; + esac + exclude includes occ + continue + ;; + explicit) + explicit=1 + continue + ;; + features)case $arg in + '') tst= ;; + *) tst="#include \"$arg\"" ;; + esac + continue + ;; + "in"|input) + case $arg in + "") in=- + ;; + *) in=$arg + if test ! -r $in + then echo "$command: $in: not found" >&$stderr + exit 1 + fi + exec < $in + file=$in: + case $out in + "") case $in in + *[.\\/]*) + case $shell in + bsh) eval `echo $in | sed -e 's,.*[\\\\/],,' -e 's/\\.[^.]*//' -e 's/^/out=/'` + ;; + *) eval 'out=${in##*[\\/]}' + eval 'out=${out%.*}' + ;; + esac + ;; + *) out=$in + ;; + esac + ;; + esac + ;; + esac + continue + ;; + include)case $arg in + ""|-) includes= ;; + *) includes="$includes -I$arg" ;; + esac + exclude includes + continue + ;; + library)for y in $libpaths + do eval $y=\"\$$y:\$arg\$${y}_default\" + eval export $y + done + continue + ;; + namval) define=n + continue + ;; + nodebug)exec 2>&$nullout + set - + continue + ;; + nodefine) + define=0 + continue + ;; + nooptimize) + optimize=0 + case $occ in + *" -O"*)occ=`echo $occ | sed 's/ -O[^ ]*//g'` + cc=$occ + ;; + esac + ;; + optimize) + optimize=1 + ;; + out|output) + out=$arg + defhdr= + usr= + deflib= + one= + puthdr= + putlib= + case $op in + output) continue ;; + esac + def= + test= + ;; + package)protoflags="$protoflags -e $arg" + continue + ;; + prototyped|noprototyped) + pragma="$pragma $op" + case $op in + prototyped) prototyped=1 ;; + *) prototyped= ;; + esac + continue + ;; + pragma) pragma="$pragma $arg" + continue + ;; + regress)regress=1 + version=1995-03-19 + continue + ;; + shell) case $arg in + osh) posix_read=-no + shell=bsh + ;; + esac + shell=$arg + continue + ;; + static) static=$arg + continue + ;; + stdio) case $arg in + '') ext= + ;; + *) ext= + sep= + for i in $arg + do case $i in + -) case $ext in + '') continue ;; + *) break ;; + esac + ;; + esac + echo "#include \"$i\"" > t.c + if $cc -E t.c > /dev/null 2>&1 + then ext="$ext$sep#include \"$arg\"" + sep=$nl + fi + done + ;; + esac + continue + ;; + undef) undef=1 + continue + ;; + verbose)verbose=1 + continue + ;; + *) echo "$command: $op: unknown option" >&$stderr + exit 1 + ;; + esac + ;; + api|define|extern|header|include|print|reference|ver) + op=$1 + shift + arg= + ;; + *) case $2 in + '=') def=$1 + shift + shift + ;; + *) case $1 in + '-'|'?')def=- + shift + ;; + *) def= + ;; + esac + ;; + esac + case $1 in + '!') not=1 + shift + ;; + *) not= + ;; + esac + case $1 in + *'{') op=- + ;; + '('*|'"'*'"'|'<'*'>') + op=exp + case $def in + '') def=- ;; + esac + ;; + *) op=$1 + shift + ;; + esac + arg= + cc="$occ $includes" + group= + groups= + fail= + hdr= + lib= + mac= + no= + note= + opt= + pass= + pth= + run= + set= + src= + test= + yes= + case $# in + 0) ;; + *) case $1 in + "#"*) set x + shift + ;; + *) case $op in + ref) ;; + *) case $1 in + '-') case $op:$2 in + tst:*) arg=$1 + case $2 in + -) shift ;; + esac + ;; + *:-*) arg=$1 + shift + ;; + *) def=- + shift + case $1 in + '('*|*'{'|'"'*'"'|'<'*'>') + arg=- + ;; + *) arg=$1 + case $# in + 0) ;; + *) shift ;; + esac + ;; + esac + ;; + esac + ;; + -*|+*|'('*|*'{'|'"'*'"'|'<'*'>') + arg=- + ;; + *) arg=$1 + shift + ;; + esac + ;; + esac + ;; + esac + case $1 in + '('*|'"'*'"'|'<'*'>') + while : + do case $# in + 0) break ;; + esac + case $1 in + *[.{}]*)break ;; + esac + case $test in + '') test=$1 ;; + *) test="$test $1" ;; + esac + shift + done + case $arg in + '') arg=- ;; + esac + case $op in + exp) case $def in + ''|'-') ;; + *) arg=$def ;; + esac + ;; + esac + ;; + esac + sline=$line + while : + do case $# in + 0) break ;; + esac + case $1 in + "") ;; + "#"*) set x + ;; + "=") shift + set=$* + case $set in + "") set=" " ;; + esac + while : + do case $# in + 0) break ;; + esac + shift + done + break + ;; + [abcdefghijklmnopqrstuvwxyz]*'{'|'{') + v=$1 + shift + x= + case $v in + "note{") + sep=" " ;; + *) sep=$nl ;; + esac + case $v in + '{') e='}' ;; + *) e='}end' ;; + esac + n=1 + SEP= + while : + do case $# in + 0) case $posix_read in + -*) checkread ;; + esac + case $in in + "") echo "$command: $file$line: missing }end" >&$stderr + exit 1 + ;; + esac + while : + do case $posix_read in + 1) case $shell in + ksh) IFS= read -r lin + eof=$? + while : + do lin="${lin#[' ']}" + case $lin in + [' ']*'#'*);; + *) break ;; + esac + done + ;; + *) IFS= + read -r lin + eof=$? + IFS=$ifs + case $lin in + [' ']*) lin=`sed -e 's,^[ ],,' -e 's,^[ ]*#,#,' <<! +$lin +! +` + ;; + esac + ;; + esac + ;; + *) lin=`$posix_read` + eof=$? + ;; + esac + case $eof in + 0) case $shell in + ksh) let line=line+1 ;; + *) line=`expr $line + 1` ;; + esac + $posix_noglob + set x $lin + $posix_glob + case $2 in + $v) case $shell in + ksh) let n=n+1 ;; + *) n=`expr $n + 1` ;; + esac + ;; + $e|$e';') + case $n in + 1) shift + break 2 + ;; + esac + case $shell in + ksh) let n=n-1 ;; + *) n=`expr $n - 1` ;; + esac + ;; + esac + x="$x$SEP$lin" + SEP=$sep + ;; + *) echo "$command: $file$line: missing $e" >&$stderr + exit 1 + ;; + esac + done + ;; + esac + case $1 in + $v) case $shell in + ksh) let n=n+1 ;; + *) n=`expr $n + 1` ;; + esac + ;; + $e|$e';') + case $n in + 1) break ;; + esac + case $shell in + ksh) let n=n-1 ;; + *) n=`expr $n - 1` ;; + esac + ;; + esac + x="$x$SEP$1" + SEP=$sep + shift + done + case $v in + 'note{');; + *) x="$x$nl" # \r\n bash needs this barf # ;; + esac + case $v in + 'fail{') fail=$x ;; + 'nofail{') pass=$x v='pass{' ;; + 'nopass{') fail=$x v='fail{' ;; + 'no{') no=$x ;; + 'note{') note=$x ;; + 'pass{') pass=$x ;; + 'test{') test=$x ;; + 'yes{'|'{') yes=$x ;; + *) src=$x run=$v ;; + esac + ;; + :) shift + break + ;; + *[\"\'\(\)\{\}\ \ ]*) + case $op in + pth) pth="$pth $1" + ;; + *) case $test in + '') test=$1 ;; + *) test="$test $1" ;; + esac + ;; + esac + ;; + -) group=$group$1 + case $group in + -) com_hdr=$hdr + com_lib=$lib + com_mac=$mac + com_opt=$opt + com_pth=$pth + com_test=$test + ;; + *) groups="$groups $1" + ;; + esac + ;; + -l*) case $group in + --*) groups="$groups $1" ;; + *) lib="$lib $1" ;; + esac + ;; + +l*) case $shell in + bsh) x=`echo X$1 | sed 's/X+/-/'` ;; + *) eval 'x=-${1#+}' ;; + esac + case $group in + --*) groups="$groups $x" ;; + *) lib="$lib $x" ;; + esac + ;; + -*|+*) case $op in + ref) cc="$cc $1" + occ="$occ $1" + case $1 in + -L*) case $shell in + ksh) x=${1#-L} ;; + *) x=`echo x$1 | sed 's,^x-L,,'` ;; + esac + for y in $libpaths + do eval $y=\"\$$y:\$x\$${y}_default\" + eval export $y + done + ;; + esac + ;; + *) case $group in + --*) groups="$groups $1" + ;; + *) case $op in + run) opt="$opt $1" + ;; + *) case $1 in + -D*) mac="$mac $1" ;; + *) cc="$cc $1" ;; + esac + ;; + esac + ;; + esac + ;; + esac + ;; + *.[aAxX]|*.[dD][lL][lL]|*.[lL][iI][bB]) + case $group in + --*) groups="$groups $1" ;; + *) lib="$lib $1" ;; + esac + ;; + *[.\\/]*) + case $group in + --*) groups="$groups $1" + ;; + *) case $op in + pth) pth="$pth $1" ;; + *) hdr="$hdr $1" ;; + esac + ;; + esac + ;; + *) case $group in + --*) groups="$groups $1" + ;; + *) case $op in + pth) pth="$pth $1" + ;; + *) case $test in + '') test=$1 ;; + *) test="$test $1" ;; + esac + ;; + esac + ;; + esac + ;; + esac + shift + done + case $group in + -) group= ;; + esac + ;; + esac + ;; + esac + case $ifelse in + DONE|SKIP) continue ;; + esac + + # make sure $cc compiles C + + case $cc in + "") cc="$occ $includes" ;; + esac + case $cctest in + "") checkcc ;; + esac + + # some ops allow no args + + case $arg in + '') case $op in + api) arg=- + case $1:$2 in + [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]*:[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]) + a=$1 + shift + case " $apis " in + *" $a "*) + ;; + *) apis="$apis $a" + eval api_sym_${a}= api_ver_${a}= + ;; + esac + rel= + while : + do case $# in + 0) break ;; + esac + case $1 in + [0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]) + rel="$rel $1" + ;; + *) break + ;; + esac + shift + done + while : + do case $# in + 0) break ;; + esac + case $1 in + :) break ;; + esac + eval syms='$'api_sym_${a} + case $syms in + '') sep='' ;; + *) sep=$nl ;; + esac + for r in $rel + do syms=$syms$sep${1}:${r} + sep=$nl + done + eval api_sym_${a}='$'syms + shift + done + ;; + *) echo "$command: $op: expected: name YYYYMMDD symbol ..." >&$stderr + ;; + esac + while : + do case $# in + 0) break ;; + esac + case $1 in + :) break ;; + esac + shift + done + ;; + iff|ini)arg=- + ;; + comment)copy - "/* $* */" + continue + ;; + define) x=$1 + shift + case $1 in + '('*')') + arg=$1 + shift + ;; + esac + case $in in + "") v= + while : + do case $# in + 0) break ;; + esac + t=$1 + shift + case $t in + ":") break ;; + esac + v="$v $t" + done + ;; + *) v=$* + ;; + esac + is mac $x + copy $tmp.c "$std +$usr +#ifndef $x +( +#endif +int x; +" + if compile $cc -c $tmp.c <&$nullin >&$nullout + then success - + else failure - + copy - "#define $x$arg $v" + usr="$usr${nl}#define $x$arg $v" + fi + continue + ;; + extern) x=$1 + shift + t=$1 + shift + is npt $x + copy $tmp.c " +$std +#include <sys/types.h> +$usr +_BEGIN_EXTERNS_ +struct _iffe_struct { int _iffe_member; }; +extern struct _iffe_struct* $x _ARG_((struct _iffe_struct*)); +_END_EXTERNS_ +" + # some compilers with -O only warn for invalid intrinsic prototypes + case " $cc " in + *" -O "*) xx=`echo $cc | sed 's/ -O / /g'` ;; + *) xx=$cc ;; + esac + if compile $xx -c $tmp.c <&$nullin >&$nullout + then success - + while : + do case $1 in + ''|'('*|'['*) + break + ;; + esac + t="$t $1" + shift + done + case $in in + "") v= + while : + do case $# in + 0) break ;; + esac + t=$1 + shift + case $t in + ":") break ;; + esac + v="$v $t" + done + ;; + *) v=$* + ;; + esac + copy - "extern $t $x$v;" + # NOTE: technically if prototyped is on all tests should + # be run through proto(1), but we'd like iffe to + # work sans proto -- so we drop the extern's in + # the test headers + case $prototyped in + '') usr="$usr${nl}extern $t $x$v;" ;; + esac + else failure - + case $in in + "") while : + do case $# in + 0) break ;; + esac + case $1 in + ":") break ;; + esac + done + ;; + esac + fi + continue + ;; + header|include|reference) + while : + do case $# in + 0) break ;; + esac + x=$1 + shift + case $x in + ":") break ;; + esac + case " $gothdr " in + *" - $x "*) + ;; + *" + $x "*) + case $usr in + *"# include <"$x">"*) + ;; + *) case $op in + reference) + ;; + *) copy - "#include <$x>" + ;; + esac + usr="$usr${nl}#include <$x>" + ;; + esac + ;; + *) copy $tmp.c "$std +$usr +#include <$x> +int x; +" + if is_hdr - $x + then gothdr="$gothdr + $x" + case $op in + reference) + ;; + *) copy - "#include <$x>" + ;; + esac + usr="$usr${nl}#include <$x>" + else gothdr="$gothdr - $x" + fi + ;; + esac + done + continue + ;; + print) case $in in + "") v= + while : + do case $# in + 0) break ;; + esac + t=$1 + shift + case $t in + ":") break ;; + esac + v="$v $t" + done + ;; + *) v=$* + ;; + esac + copy - "$*" + usr="$usr${nl}$v" + continue + ;; + ver) arg=- + case $1:$2 in + [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]*:[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]) + vers="$vers$nl$1" + eval ver_$1=$2 + ;; + *) echo "$command: $op: expected: name YYYYMMDD" >&$stderr + ;; + esac + while : + do case $# in + 0) break ;; + esac + case $1 in + :) break ;; + esac + shift + done + ;; + esac + ;; + esac + + # save $* for ancient shells + + argx=1 + argv=$* + + # loop on all candidate groups + + while : + do + # check the candidate macros + + cc="$cc $mac" + + # check for global default headers (some cc -E insist on compiling) + + case $hdrtest in + '') hdrtest=1 + allinc= + for x in types + do case $config in + 0) c=_sys_${x} + ;; + 1) case $shell in + ksh) typeset -u u=$x ;; + *) u=`echo $x | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + c=HAVE_SYS_${u}_H + ;; + esac + x=sys/$x.h + echo "${allinc}#include <$x>" > $tmp.c + if is_hdr $x + then gothdr="$gothdr + $x" + case $explicit in + 0) can="$can$cansep#define $c 1 /* #include <$x> ok */" + nan="$nan$cansep$c=1" + cansep=$nl + ;; + esac + eval $c=1 + allinc="${allinc}#include <$x>$nl" + else gothdr="$gothdr - $x" + case $explicit$all$config$undef in + 0?1?|0??1) + can="$can$cansep#undef $c /* #include <$x> not ok */" + nan="$nan$cansep$c=" + cansep=$nl + ;; + 01??) can="$can$cansep#define $c 0 /* #include <$x> not ok */" + nan="$nan$cansep$c=0" + cansep=$nl + ;; + esac + fi + done + ;; + esac + + # add implicit headers/libraries before the checks + + case $op in + npt) hdr="sys/types.h stdlib.h unistd.h $hdr" + ;; + siz|typ)hdr="sys/types.h time.h sys/time.h sys/times.h stddef.h stdlib.h $hdr" + ;; + esac + + # check the candidate headers + + case $hdr in + ?*) z=$hdr + hdr= + dis=0 + for x in $z + do case $x in + *.h) case " $gothdr " in + *" - $x "*) + continue + ;; + *" + $x "*) + ;; + *) case $shell in + bsh) eval `echo $x | sed -e 's,^\\([^\\\\/]*\\).*[\\\\/]\\([^\\\\/]*\\)\$,\\1_\\2,' -e 's/\\..*//' -e 's/^/c=/'` + ;; + *) eval 'c=${x##*[\\/]}' + eval 'c=${c%%.*}' + case $x in + */*) eval 'c=${x%%[\\/]*}_${c}' ;; + esac + ;; + esac + case $explicit in + 0) dis=0 + ;; + *) case $x in + */*) dis=$c ;; + *) dis=hdr ;; + esac + case ${dis}_ in + ${op}_*)dis=0 ;; + *) dis=1 ;; + esac + ;; + esac + case $config in + 0) case $x in + */*) c=_${c} ;; + *) c=_hdr_${c} ;; + esac + ;; + 1) case $shell in + ksh) typeset -u u=$c ;; + *) u=`echo $c | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + c=HAVE_${u}_H + ;; + esac + echo "${allinc}#include <$x>" > $tmp.c + if is_hdr $x + then gothdr="$gothdr + $x" + case $dis in + 0) can="$can$cansep#define $c 1 /* #include <$x> ok */" + nan="$nan$cansep$c=1" + cansep=$nl + ;; + esac + eval $c=1 + else gothdr="$gothdr - $x" + case $dis$all$config$undef in + 0?1?|0??1) + can="$can$cansep#undef $c /* #include <$x> not ok */" + nan="$nan$cansep$c=" + cansep=$nl + ;; + 01??) can="$can$cansep#define $c 0 /* #include <$x> not ok */" + nan="$nan$cansep$c=0" + cansep=$nl + ;; + esac + continue + fi + ;; + esac + ;; + *) test -r $x || continue + ;; + esac + hdr="$hdr $x" + done + ;; + esac + + # check the candidate libraries + + case $lib in + ?*) z=$lib + lib= + p= + hit=0 + echo "int main(){return(0);}" > $tmp.c + for x in $z + do p=$x + case " $gotlib " in + *"- $p "*) + failure + + p= + ;; + *"+ $p "*) + success + + lib="$lib $p" + ;; + *) rm -f $tmp.exe + is LIB $p + if compile $cc -o $tmp.exe $tmp.c $p <&$nullin >&$nullout + then success + gotlib="$gotlib + $p" + lib="$lib $p" + e=0 + else a= + e=1 + for l in $z + do case $l in + -) a= + continue + ;; + $p) a=$p + continue + ;; + *) case $gotlib in + *" $l "*) continue ;; + esac + ;; + esac + case $a in + $p) a="$a $l" + if compile $cc -o $tmp.exe $tmp.c $a <&$nullin >&$nullout + then success + gotlib="$gotlib + $p" + lib="$lib $p" + e=0 + break + fi + ;; + esac + done + case $e in + 1) failure + gotlib="$gotlib - $p" + ;; + esac + fi + y= + for x in $p + do case $shell in + bsh) c=`echo X$x | sed 's,X-l,,'` ;; + *) eval 'c=${x#-l}' ;; + esac + case $c in + *[!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]*) + c=`echo '' $c | sed -e 's,.*[\\\\/],,' -e 's,\.[^.]*$,,' -e 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_],_,g' -e '/^lib./s,^lib,,'` + ;; + esac + case $config in + 0) case $e$p in + 0*' '*) case " $gotlib " in + *[-+]" $x "*) + ;; + *) can="$can$cansep#define _LIB_$c 1 /* $x is a library */" + nan="$nan${cansep}_LIB_$c=1" + cansep=$nl + eval _LIB_$c=1 + ;; + esac + ;; + esac + ;; + 1) case $shell in + ksh) typeset -u u=$c ;; + *) u=`echo $c | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + c=$u + case $e in + 0*' '*) case " $gotlib " in + *[-+]" $x "*) + ;; + *) can="$can$cansep#define HAVE_${c}_LIB 1 /* $x is a library */" + nan="$nan${cansep}HAVE_${c}_LIB=1" + cansep=$nl + eval HAVE_${c}_LIB=1 + ;; + esac + ;; + esac + ;; + esac + y=${y}_$c + done + case $config in + 0) c=_LIB${y} ;; + 1) c=HAVE${y}_LIB ;; + esac + case $p in + *' '*) q="a library group" ;; + *) q="a library" ;; + esac + case $e in + 0) can="$can$cansep#define $c 1 /* $p is $q */" + nan="$nan$cansep$c=1" + cansep=$nl + eval $c=1 + case $hit in + 1) break ;; + esac + ;; + 1) case $all$config$undef in + ?1?|??1)can="$can$cansep#undef $c /* $p is not $q */" + nan="$nan$cansep$c=" + cansep=$nl + ;; + 1??) can="$can$cansep#define $c 0 /* $p is not $q */" + nan="$nan$cansep$c=0" + cansep=$nl + ;; + esac + eval $c=0 + ;; + esac + p= + ;; + esac + done + ;; + esac + + # last op precheck + + case $op in + ref) deflib="$deflib $lib" + defhdr="$defhdr $hdr" + break + ;; + esac + IFS=" ," + case $shell in + bash) op=`echo $op` + arg=`echo $arg` + ;; + *) eval op=\"$op\" + eval arg=\"$arg\" + ;; + esac + IFS=$ifs + + # check for op aliases + + x= + for o in $op + do case $o in + def|default) x="$x cmd dat hdr key lib mth sys typ" ;; + *) x="$x $o" ;; + esac + done + + # loop on the ops o and args a + + result=UNKNOWN + for o in $x + do for a in $arg + do c= + case $a in + *[.\\/]*) + case $o in + hdr|lcl|nxt|pth|sys) + x=$a + case $x in + *.lcl|*.nxt) + case $o in + sys) x=sys/$x ;; + esac + case $shell in + bsh) eval `echo $x | sed 's,\\(.*\\)\.\\([^.]*\\),x=\\1 o=\\2,'` + ;; + *) o=${x##*.} + x=${x%.${o}} + ;; + esac + v=$x + ;; + esac + case $x in + *[\\/]*)case $shell in + bsh) eval `echo $x | sed 's,\\(.*\\)[\\\\//]\\(.*\\),p=\\1 v=\\2,'` + ;; + *) eval 'p=${x%/*}' + eval 'v=${x##*/}' + ;; + esac + ;; + *.*) case $shell in + bsh) eval `echo $x | sed 's,\\(.*\\)\\.\\(.*\\),p=\\1 v=\\2,'` + ;; + *) eval 'p=${x%.*}' + eval 'v=${x##*.}' + ;; + esac + ;; + *) p= + ;; + esac + case $o in + lcl|nxt) c=$v.$o ;; + *) c=$v ;; + esac + ;; + *) case $shell in + bsh) eval `echo $a | sed -e 's,.*[\\\\/],,' -e 's/\\(.*\\)\\.\\(.*\\)/p=\\1 v=\\2/'` + ;; + *) eval 'p=${a%.*}' + eval 'p=${p##*[\\/]}' + eval 'v=${a##*.}' + eval 'v=${v##*[\\/]}' + ;; + esac + ;; + esac + case $p in + '') f=${v} ;; + *) f=${p}/${v} ;; + esac + case $o in + run) v=$p + p= + m=_${v} + ;; + mem) case $p in + *.*) case $shell in + bsh) eval `echo $p | sed 's/\\([^.]*\\)\\.\\(.*\\)/p=\\1 m=\\2/'` + ;; + *) eval 'm=${p#*.}' + eval 'p=${p%%.*}' + ;; + esac + v=${m}.${v} + esac + case $config in + 0) m=_${v}_${p} ;; + 1) m=_${v}_in_${p} ;; + esac + ;; + *) case $p in + '') m=_${v} ;; + *) m=_${p}_${v} ;; + esac + ;; + esac + ;; + *) p= + v=$a + f=$a + m=_${v} + ;; + esac + case $c in + '') c=$v ;; + esac + M=$m + case $o in + out) case $a in + -) a=- + ;; + ?*) test="$a $test" + a= + ;; + esac + ;; + *) case " $idyes " in + *" $m "*) + i=1 + ;; + *) case " $idno " in + *" $m "*) + i=0 + ;; + *) case $m in + *'*') m=`echo "$m" | sed 's,\*,_ptr,g'` ;; + esac + case $m in + *[-+/\\]*) + i=0 + ;; + *[!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]*) + is id $m + copy $tmp.c "int $m = 0;" + if compile $cc -c $tmp.c + then success - + idyes="$idyes $m" + i=1 + else failure - + idno="$idno $m" + i=0 + fi + ;; + *) i=1 + ;; + esac + ;; + esac + case $i in + 0) case $o in + dat|dfn|key|lib|mac|mth|nos|npt|siz|sym|typ|val) + continue + ;; + esac + ;; + esac + ;; + esac + ;; + esac + case $m in + *[!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]*) + m=`echo "X$m" | sed -e 's,^.,,' -e 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_],_,g'` + ;; + esac + + # check output redirection + + case $out in + $cur) ;; + *) case $cur in + $a|$c) ;; + *) case $cur in + .) ;; + *) case $vers in + ?*) echo + for api in $vers + do API=`echo $api | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` + eval ver='${'ver_${api}'}' + echo "#define ${API}_VERSION ${ver}" + done + esac + case $apis in + ?*) for api in $apis + do map= + sep= + eval syms='"${'api_sym_${api}'}"' + # old solaris requires -k<space><junk> # + set x x `echo "$syms" | sort -t: -u -k 1,1 -k 2,2nr 2>/dev/null | sed 's/:/ /'` + case $# in + 2) # ancient sort doesn't have -k # + set x x `echo "$syms" | sort -t: -u +0 -1 +1 -2nr 2>/dev/null | sed 's/:/ /'` + ;; + esac + sym= + while : + do shift 2 + case $# in + [01]) break ;; + esac + prv=$sym + sym=$1 + rel=$2 + case $prv in + $sym) echo "#elif _API_${api} >= $rel" + ;; + *) case $prv in + '') echo + echo "#if !defined(_API_${api}) && defined(_API_DEFAULT)" + echo "#define _API_${api} _API_DEFAULT" + echo "#endif" + ;; + *) echo "#endif" + ;; + esac + echo + echo "#if ( _BLD_${api} || !_API_${api} || _API_${api} >= $rel )" + ;; + esac + echo "#undef ${sym}" + echo "#define ${sym} ${sym}_${rel}" + map=$map$sep${sym}_${rel} + sep=' ' + done + echo "#endif" + echo + echo "#define _API_${api}_MAP \"$map\"" + done + echo + ;; + esac + case $iff in + ?*) echo "#endif" ;; + esac + case $cur in + -) ;; + *) exec >/dev/null + case $cur in + *[\\/]*|*.h) x=$cur ;; + *) x=$dir/$cur ;; + esac + case $define in + n) sed '/^#/d' $tmp.h > $tmp.c + sed '/^#/d' $x > $tmp.t + ;; + *) (proto -r $protoflags $tmp.h) >/dev/null 2>&1 + sed 's,/\*[^/]*\*/, ,g' $tmp.h > $tmp.c + sed 's,/\*[^/]*\*/, ,g' $x > $tmp.t + ;; + esac + if cmp -s $tmp.c $tmp.t + then rm -f $tmp.h + case $verbose in + 1) echo "$command: $x: unchanged" >&$stderr ;; + esac + else case $x in + ${dir}[\\/]$cur) test -d $dir || mkdir $dir || exit 1 ;; + esac + mv $tmp.h $x + fi + ;; + esac + ;; + esac + case $out in + +) case $status in + 1) ;; + *) status=0 ;; + esac + exit $status + ;; + -) eval "exec >&$stdout" + ;; + *) exec >$tmp.h + ;; + esac + case $out in + "") case $a in + *[\\/]*|???????????????*) cur=$c ;; + *) cur=$a ;; + esac + ;; + *) cur=$out + ;; + esac + case $in in + ""|-|+) case $o in + run) x=" from $a" ;; + *) x= ;; + esac + ;; + *) x=" from $in" + ;; + esac + + # output header comments + + case $define in + n) ;; + ?) echo "/* : : generated$x by $command version $version : : */" + for x in $pragma + do echo "#pragma $x" + done + case $out in + ""|-|+) x=$m + ;; + *.*) case $shell in + bsh) eval `echo $in | sed -e 's,\\.,_,g' -e 's/^/x=/'` + ;; + *) i=$out + x=_ + while : + do case $i in + *.*) eval 'x=$x${i%%.*}_' + eval 'i=${i#*.}' + ;; + *) x=$x$i + break + ;; + esac + done + ;; + esac + ;; + *) x=_$out + ;; + esac + case $o in + iff) case $M in + ""|*-*) ;; + *) iff=${m}_H ;; + esac + ;; + *) case $regress in + '') case $x in + *-*) ;; + *) x=`pwd | sed -e 's,.*[\\\\/],,' -e 's,\\..*,,' -e 's,^lib,,' -e 's,^,'${x}_',' -e 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_],_,g'` + # ksh n+ bug workaround + case $x in + *[!_]*) ;; + *) x=_$$ ;; + esac + iff=_def${x} + ;; + esac + ;; + *) case $x in + *-*) ;; + *) iff=_REGRESS + ;; + esac + ;; + esac + ;; + esac + case $iff in + ?*) echo "#ifndef $iff" + echo "#define $iff 1" + ;; + esac + ;; + esac + ;; + esac + ;; + esac + case $can in + ?*) case $define in + 1) echo "$can" ;; + n) echo "$nan" ;; + esac + can= + nan= + cansep= + ;; + esac + + # set up the candidate include list + + pre= + inc= + for x in $defhdr - $hdr + do case $x in + -) case $pre in + ?*) continue ;; + esac + case $v in + *.*) for x in `echo $v | sed 's,\\., ,g'` + do pre="$pre +#undef $x" + done + ;; + *) case $o in + siz|typ)case $v in + char|short|int|long) + ;; + *) pre="#undef $v" + ;; + esac + ;; + *) pre="#undef $v" + ;; + esac + ;; + esac + ;; + *.h) case $shell in + bsh) eval `echo $x | sed -e 's,^\\([^\\\\/]*\\).*[\\\\/]\\([^\\\\/]*\\)\$,\\1_\\2,' -e 's/\\..*//' -e 's/^/c=/'` + ;; + *) eval 'c=${x##*[\\/]}' + eval 'c=${c%%.*}' + case $x in + */*) eval 'c=${x%%[\\/]*}_${c}' ;; + esac + ;; + esac + case $config in + 0) case $x in + */*) c=_${c} ;; + *) c=_hdr_${c} ;; + esac + ;; + 1) case $shell in + ksh) typeset -u u=$c ;; + *) u=`echo $c | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + c=HAVE_${u}_H + ;; + esac + case " $puthdr " in + *" $c "*) + ;; + *) puthdr="$puthdr $c" + usr="$usr$nl#define $c 1" + ;; + esac + inc="$inc +#include <$x>" + ;; + esac + done + + # set up the candidate lib list + + for x in $lib $deflib + do case $shell in + ksh) eval 'c=${x#-l}' ;; + *) c=`echo X$x | sed 's,X-l,,'` ;; + esac + case $c in + *[!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]*) + c=`echo '' $c | sed -e 's,.*[\\\\/],,' -e 's,\.[^.]*$,,' -e 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_],_,g' -e '/^lib./s,^lib,,'` + ;; + esac + case $config in + 0) c=_LIB_${c} + ;; + 1) case $shell in + ksh) typeset -u u=$c ;; + *) u=`echo $c | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + c=HAVE_${u}_LIB + ;; + esac + case " $putlib " in + *" $c "*) + ;; + *) putlib="$putlib $c" + usr="$usr$nl#define $c 1" + ;; + esac + done + + # src overrides builtin test + + case $config:$def in + 0:) case $o in + tst|var);; + *) m=_${o}${m} ;; + esac + ;; + 1:) case $o in + tst|var)m=${v} ;; + esac + case $shell in + ksh) typeset -u u=$m ;; + *) u=`echo $m | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + case $o in + tst|var)case $m in + $u) ;; + *) case $m in + hdr_*|lib_*|sys_*) + case $shell in + ksh) u=${u#????} ;; + *) u=`echo $u | sed 's/....//'` ;; + esac + ;; + esac + m=HAVE_${u} + ;; + esac + ;; + dat) m=HAVE${u}_DATA ;; + hdr|lcl)m=HAVE${u}_H ;; + key) m=HAVE${u}_RESERVED ;; + mth) m=HAVE${u}_MATH ;; + npt) m=HAVE${u}_DECL ;; + pth) m=${u}_PATH + case $shell in + ksh) m=${m#_} ;; + *) m=`echo $m | sed 's,^_,,'` ;; + esac + ;; + nxt) m=HAVE${u}_NEXT ;; + siz) m=SIZEOF${u} ;; + sys) m=HAVE_SYS${u}_H ;; + *) m=HAVE${u} ;; + esac + ;; + *) m=$def + M=$m + ;; + esac + case $src in + ?*) case $src in + $noext) EXT= ;; + *) EXT="$tst +$ext" + ;; + esac + copy $tmp.c "$std +$EXT +$usr +$inc +$src +" + V=1 + e=0 + is tst "${note:-$run}" + case $run in + cat*|nocat*) + copy - "$src" + ;; + cross*|nocross*) + copy $tmp.sh "$src" + chmod +x $tmp.sh + execute $tmp.sh <&$nullin || e=1 + ;; + run*|norun*) + (eval "$src") <&$nullin || e=1 + ;; + mac*|nomac*) + if compile $cc -E $tmp.c <&$nullin >$tmp.i + then sed -e '/<<[ ]*".*"[ ]*>>/!d' -e 's/<<[ ]*"//g' -e 's/"[ ]*>>//g' $tmp.i + else e=1 + fi + ;; + p*|nop*)compile $cc -DTEST=$p -DID=$v -E $tmp.c <&$nullin >&$nullout || e=1 + ;; + c*|noc*)compile $cc -DTEST=$p -DID=$v -c $tmp.c <&$nullin >&$nullout || e=1 + ;; + *) case $run in + status*)ccflags= + ;; + s*|nos*)case $reallystatictest in + '') #UNDENT... + + reallystatictest=. + echo "$tst +$ext +int main(){printf("hello");return(0);}" > ${tmp}s.c + rm -f ${tmp}s.exe + if compile $cc -c ${tmp}s.c <&$nullin >&$nullout && + compile $cc -o ${tmp}s.exe ${tmp}s.o <&$nullin >&$nullout 2>${tmp}s.e && + $executable ${tmp}s.exe + then e=`wc -l ${tmp}s.e` + eval set x x $binding + while : + do shift + shift + case $# in + 0) break ;; + esac + rm -f ${tmp}s.exe + compile $cc -o ${tmp}s.exe $1 ${tmp}s.o <&$nullin >&$nullout 2>${tmp}s.e && $executable ${tmp}s.exe || continue + case `wc -l ${tmp}s.e` in + $e) ;; + *) continue ;; + esac + d=`ls -s ${tmp}s.exe` + rm -f ${tmp}s.exe + compile $cc -o ${tmp}s.exe $2 ${tmp}s.o <&$nullin >&$nullout 2>${tmp}s.e && $executable ${tmp}s.exe || continue + case `wc -l ${tmp}s.e` in + $e) ;; + *) continue ;; + esac + case `ls -s ${tmp}s.exe` in + $d) ;; + *) reallystatic=$2 + set x + shift + break + ;; + esac + done + fi + rm -f ${tmp}s.* + #...INDENT + ;; + esac + ccflags=$reallystatic + ;; + *) ccflags= + ;; + esac + set x $mac + e=1 + while : + do o= + shift + while : + do case $# in + 0) break ;; + esac + case $1 in + -) break ;; + esac + o="$o $1" + shift + done + rm -f $tmp.exe + if compile $cc $ccflags $o -DTEST=$p -DID=$v -o $tmp.exe $tmp.c $lib $deflib <&$nullin >&$nullout && $executable $tmp.exe + then case $run in + + status*)execute $tmp.exe <&$nullin >&$nullout + V=$? + case $V in + 0) e=1 ;; + *) e=0 ;; + esac + break + ;; + no[ls]*);; + [ls]*) e=0 && break ;; + noo*) execute $tmp.exe <&$nullin >$tmp.out || break ;; + o*) execute $tmp.exe <&$nullin >$tmp.out && e=0 && break ;; + no*) execute $tmp.exe <&$nullin >&$nullout || break ;; + *) execute $tmp.exe <&$nullin >&$nullout && e=0 && break ;; + + esac + else case $run in + no[els]*)e=1 && break ;; + esac + fi + case $# in + 0) case $run in + no*) e=0 ;; + esac + break + ;; + esac + done + ;; + esac + o=1 + case $run in + no*) case $e in + 0) e=1 ;; + *) e=0 ;; + esac + ;; + esac + case $run in + o*|noo*)case $e in + 0) cat $tmp.out ;; + esac + rm -f $tmp.out + ;; + esac + report $e $V "${note:-$run\ passed}" "${note:-$run} failed" + continue + ;; + esac + + # initialize common builtin state + + case $o in + dat|lib|mth|run) + case $statictest in + "") statictest=FoobaR + copy $tmp.c " +$tst +$ext +$std +$usr +_BEGIN_EXTERNS_ +extern int $statictest; +_END_EXTERNS_ +int main(){char* i = (char*)&$statictest; return ((unsigned int)i)^0xaaaa;} +" + rm -f $tmp.exe + if compile $cc -o $tmp.exe $tmp.c <&$nullin >&$nullout && $executable $tmp.exe + then case $static in + .) static= + copy $tmp.c " +$tst +$ext +int main(){printf("hello");return(0);} +" + rm -f $tmp.exe + if compile $cc -c $tmp.c <&$nullin >&$nullout && + compile $cc -o $tmp.exe $tmp.o <&$nullin >&$nullout && + $executable $tmp.exe + then e=`wc -l $tmp.e` + eval set x x $binding + while : + do shift + shift + case $# in + 0) break ;; + esac + rm -f $tmp.exe + compile $cc -o $tmp.exe $1 $tmp.o <&$nullin >&$nullout && $executable $tmp.exe || continue + case `wc -l $tmp.e` in + $e) ;; + *) continue ;; + esac + d=`ls -s $tmp.exe` + rm -f $tmp.exe + compile $cc -o $tmp.exe $2 $tmp.o <&$nullin >&$nullout && $executable $tmp.exe || continue + case `wc -l $tmp.e` in + $e) ;; + *) continue ;; + esac + case `ls -s $tmp.exe` in + $d) ;; + *) static=$2 + set x + shift + break + ;; + esac + done + fi + ;; + esac + else static= + fi + ;; + esac + ;; + esac + + # builtin tests + + case $o in + api) ;; + cmd) case $p in + ?*) continue ;; + esac + is $o $a + k=1 + for j in "" usr + do case $j in + "") d= s= ;; + *) d=/$j s=_$j ;; + esac + for i in bin etc ucb + do if test -f $d/$i/$a + then case $k in + 1) k=0 + case $M in + *-*) ;; + *) usr="$usr$nl#define $m 1" + case $define in + 1) echo "#define $m 1 /* $a in ?(/usr)/(bin|etc|ucb) */" ;; + n) echo "$m=1" ;; + esac + ;; + esac + ;; + esac + c=${s}_${i}_${v} + usr="$usr$nl#define $c 1" + case $define in + 1) echo "#define $c 1 /* $d/$i/$a found */" ;; + n) echo "$c=1" ;; + esac + fi + done + done + case $k in + 0) success ;; + 1) failure ;; + esac + ;; + dat) case $p in + ?*) continue ;; + esac + { + copy - " +$tst +$ext +$std +$usr +$pre +" + case $inc in + ?*) echo "$inc" + ;; + *) echo "_BEGIN_EXTERNS_ +extern int $v; +_END_EXTERNS_" + ;; + esac + echo " +#ifdef _DLL +#define _REF_ +#else +#define _REF_ & +#endif +int main(){char* i = (char*) _REF_ $v; return ((unsigned int)i)^0xaaaa;}" + } > $tmp.c + is $o $v + rm -f $tmp.exe + compile $cc -c $tmp.c <&$nullin >&$nullout && + compile $cc $static -o $tmp.exe $tmp.o $lib $deflib <&$nullin >&$nullout && + $executable $tmp.exe + report $? 1 "$v in default lib(s)" "$v not in default lib(s)" + ;; + dfn) case $p in + ?*) continue ;; + esac + is dfn $v + echo "$pre +$tst +$ext +$inc +#ifdef $v +<<\"#ifndef $v\">> +<<\"#define $v\">> $v <<\"/* native $v */\">> +<<\"#endif\">> +#endif" > $tmp.c + if compile $cc -E $tmp.c <&$nullin >$tmp.i + then sed -e '/<<[ ]*".*"[ ]*>>/!d' -e 's/<<[ ]*"//g' -e 's/"[ ]*>>//g' $tmp.i > $tmp.t + if test -s $tmp.t + then success + cat $tmp.t + else failure + fi + else failure + fi + ;; + exp) case $test in + '') echo "$command: $file$sline: test expression expected for $o" >&$stderr + exit 1 + ;; + esac + case $a in + -|'') ;; + *) eval x='$'$a + case $x in + 1) result=FAILURE + continue + ;; + esac + ;; + esac + case $test in + [01]|'"'*'"'|'<'*'>') + case $a in + -|'') ;; + *) case $define$note in + 1) echo "#define $a $test" ;; + 1*) echo "#define $a $test /* $note */" ;; + n) echo "$a=$test" ;; + esac + eval $a='$test' + ;; + esac + ;; + *) case $note in + '') note=$test ;; + esac + case $test in + '') c=1 + ;; + *) is exp "$note" + x= + for i in `echo '' $test | sed 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_], & ,g'` + do case $i in + [\ \ ]) + ;; + [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]*) + eval i='${'$i'}' + case $i in + '') i=0 + ;; + '"'*'"');; + *[!-+0123456789]*) + case $i in + *'"'*) i=1 ;; + *) i='"'$i'"' ;; + esac + ;; + esac + x="$x $i" + ;; + '!') x="$x 0 =" + ;; + '&'|'|')case $x in + *"$i") ;; + *) x="$x \\$i" ;; + esac + ;; + *) x="$x \\$i" + ;; + esac + done + c=`eval expr $x 2>&$stderr` + ;; + esac + case $c in + 0) c=1 ;; + *) c=0 ;; + esac + M=$a + m=$a + report $c 1 "$note is true" "$note is false" + ;; + esac + ;; + hdr|lcl|nxt|sys) + case $o in + lcl|nxt)case $M in + *-*) continue ;; + esac + eval x='$'_$m + case $x in + ?*) continue ;; + esac + eval _$m=1 + is $o $f + echo "$pre +$tst +$ext +$inc +#include <$f.h>" > $tmp.c + case $f in + sys/*) e= ;; + *) e='-e /[\\\\\/]sys[\\\\\/]'$f'\\.h"/d' ;; + esac + if compile $cc -E $tmp.c <&$nullin >$tmp.i + then i=`sed -e '/^#[line ]*[0123456789][0123456789]*[ ][ ]*"[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:]*[\\\\\/].*[\\\\\/]'$f'\\.h"/!d' $e -e s'/.*"\\(.*\\)".*/\\1/' -e 's,\\\\,/,g' -e 's,///*,/,g' $tmp.i | sed 1q` + case $i in + [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]:[\\/]*) + ;; + */*/*) k=`echo "$i" | sed 's,.*/\([^/]*/[^/]*\)$,../\1,'` + echo "$pre +$tst +$ext +$inc +#include <$k>" > $tmp.c + if compile $cc -E $tmp.c <&$nullin >$tmp.i + then j=`sed -e '/^#[line ]*[0123456789][0123456789]*[ ][ ]*"[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ:]*[\\\\\/].*[\\\\\/]'$f'\\.h"/!d' $e -e s'/.*"\\(.*\\)".*/\\1/' -e 's,\\\\,/,g' -e 's,///*,/,g' $tmp.i | sed 1q` + wi=`wc < "$i"` + wj=`wc < "$j"` + case $wi in + $wj) i=$k ;; + esac + fi + ;; + *) echo "$pre +$tst +$ext +$inc +#include <../include/$f.h>" > $tmp.c + if compile $cc -E $tmp.c <&$nullin >&$nullout + then i=../include/$f.h + fi + ;; + esac + else i= + fi + case $i in + [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]:[\\/]*|[\\/]*) + success + case $o in + lcl) echo "#if defined(__STDPP__directive)" + echo "__STDPP__directive pragma pp:hosted" + echo "#endif" + echo "#include <$i> /* the native <$f.h> */" + echo "#undef $m" + usr="$usr$nl#define $m 1" + echo "#define $m 1" + ;; + nxt) echo "#define $m <$i> /* include path for the native <$f.h> */" + echo "#define ${m}_str \"$i\" /* include string for the native <$f.h> */" + usr="$usr$nl#define $m <$i>$nl#define ${m}_str \"$i\"" + eval $m=\\\<$i\\\> + ;; + esac + break + ;; + ../*/*) success + case $o in + lcl) echo "#include <$i> /* the native <$f.h> */" + echo "#undef $m" + usr="$usr$nl#define $m 1" + echo "#define $m 1" + eval $m=1 + ;; + nxt) echo "#define $m <$i> /* include path for the native <$f.h> */" + echo "#define ${m}_str \"$i\" /* include string for the native <$f.h> */" + usr="$usr$nl#define $m <$i>$nl#define ${m}_str \"$i\"" + eval $m=\\\<$i\\\> + ;; + esac + break + ;; + *) failure + case $o in + lcl) case $all$config$undef in + ?1?|??1)echo "#undef $m /* no native <$f.h> */" ;; + 1??) echo "#define $m 0 /* no native <$f.h> */" ;; + esac + eval $m=0 + ;; + nxt) case $all$config$undef in + ?1?|??1)echo "#undef $m /* no include path for the native <$f.h> */" ;; + esac + ;; + esac + ;; + esac + ;; + *) case $o in + hdr) x=$f.h ;; + sys) x=sys/$f.h ;; + esac + case " $gothdr " in + *" - $x "*) + failure + + ;; + *" + $x "*) + success + + ;; + *) echo " +$tst +$ext +$allinc +$inc +#include <$x>" > $tmp.c + if is_hdr $x + then gothdr="$gothdr + $x" + case $M in + *-*) ;; + *) case " $puthdr " in + *" $m "*) + ;; + *) puthdr="$puthdr $m" + usr="$usr$nl#define $m 1" + ;; + esac + case $define in + 1) echo "#define $m 1 /* #include <$x> ok */" ;; + n) echo "$m=1" ;; + esac + eval $m=1 + ;; + esac + else gothdr="$gothdr - $x" + case $M in + *-*) ;; + *) case $define$all$config$undef in + 1?1?|1??1)echo "#undef $m /* #include <$x> not ok */" ;; + 11??) echo "#define $m 0 /* #include <$x> not ok */" ;; + n1?1) echo "$m=" ;; + n1??) echo "$m=0" ;; + esac + eval $m=0 + ;; + esac + fi + ;; + esac + continue + ;; + esac + ;; + iff) ;; + ini) ;; + key) case $p in + ?*) continue ;; + esac + w=$v + while : + do is $o $w + echo "$pre +$tst +$ext +int f(){int $w = 1;return($w);}" > $tmp.c + if compile $cc -c $tmp.c <&$nullin >&$nullout + then failure + case $set in + *" ="|*" = "*) + set x $set + shift + w= + while : + do case $# in + 0) break ;; + esac + case $1 in + =) break ;; + esac + case $w in + '') w=$1 ;; + *) w="$w $1" ;; + esac + shift + done + case $1 in + =) shift + case $# in + 0) set=" " ;; + *) set=$* ;; + esac + ;; + *) set= + ;; + esac + case $shell in + ksh) typeset -u u=$w ;; + *) u=`echo $w | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ` ;; + esac + u=_$u + M=$w + case $M in + *[!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]*) + M=`echo "X$m" | sed -e 's,^.,,' -e 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_],_,g'` + ;; + esac + case $config in + 1) m=HAVE${u}_RESERVED ;; + *) m=_key_${w} ;; + esac + continue + ;; + esac + report - 1 - - "$w is not a reserved keyword" "default for reserved keyword $v" + else report 0 1 "$w is a reserved keyword" - + case $M in + *-*) ;; + *) case $define$w in + 1$v) ;; + 1*) echo "#define $v $w /* alternate for reserved keyword $v */" ;; + n*) echo "$v=$w" ;; + esac + ;; + esac + fi + break + done + ;; + lib|mth)case $p in + ?*) continue ;; + esac + case $v in + -) continue ;; + esac + is $o $v + copy $tmp.c " +$tst +$ext +$std +$usr +$pre +$inc +typedef int (*_IFFE_fun)(); +#ifdef _IFFE_extern +_BEGIN_EXTERNS_ +extern int $v(); +_END_EXTERNS_ +#endif +static _IFFE_fun i=(_IFFE_fun)$v;int main(){return ((unsigned int)i)^0xaaaa;} +" + d=-D_IFFE_extern + if compile $cc -c $tmp.c <&$nullin >&$nullout + then d= + elif compile $cc $d -c $tmp.c <&$nullin >&$nullout + then : + else d=error + fi + if test error != "$d" + then rm -f $tmp.exe + if compile $cc $d $static -o $tmp.exe $tmp.o $lib $deflib <&$nullin >&$nullout && + $executable $tmp.exe + then case $o in + lib) c=0 ;; + *) c=1 ;; + esac + report $c 1 "$v() in default lib(s)" "$v() not in default lib(s)" "default for function $v()" + else case $o in + mth) rm -f $tmp.exe + compile $cc $d $static -o $tmp.exe $tmp.o -lm <&$nullin >&$nullout && + $executable $tmp.exe + report $? 1 "$v() in math lib" "$v() not in math lib" "default for function $v()" + ;; + *) report 1 1 - "$v() not in default lib(s)" "default for function $v()" + ;; + esac + fi + else case $intrinsic in + '') copy $tmp.c " +$tst +$ext +$std +$usr +$pre +$inc +_BEGIN_EXTERNS_ +extern int foo(); +_END_EXTERNS_ +static int ((*i)())=foo;int main(){return(i==0);} +" + compile $cc -c $tmp.c <&$nullin >&$nullout + intrinsic=$? + ;; + esac + case $o in + mth) report $intrinsic 1 "$v() in math lib" "$v() not in math lib" "default for function $v()" ;; + *) report $intrinsic 1 "$v() in default lib(s)" "$v() not in default lib(s)" "default for function $v()" ;; + esac + fi + ;; + mac) case $p in + ?*) continue ;; + esac + is mac $v + echo " +$tst +$ext +$pre +$inc +#ifdef $v +'$m:$v' +#endif" > $tmp.c + compile $cc -E $tmp.c <&$nullin | grep -c "'$m:$v'" >&$nullout + report $? 1 "$v is a macro" "$v is not a macro" "default for macro $v" + ;; + mem) case $p in + ?*) eval i='$'_iffe_typedef_$p + case $i in + 0|1) ;; + *) echo "$pre +$tst +$ext +$inc +static $p i; +int n = sizeof(i);" > $tmp.c + is typ $p + if compile $cc -c $tmp.c <&$nullin >&$nullout + then success - + eval _iffe_typedef_$p=1 + i=1 + else failure - + eval _iffe_typedef_$p=0 + i=0 + fi + ;; + esac + case $i in + 0) i="$v is not a member of $p" p="struct $p" ;; + *) i=- ;; + esac + is mem $v "$p" + echo "$pre +$tst +$ext +$inc +static $p i; +int n = sizeof(i.$v);" > $tmp.c + compile $cc -c $tmp.c <&$nullin >&$nullout + report $? 1 "$v is a member of $p" "$i" + ;; + *) p=$v + eval i='$'_iffe_typedef_$p + case $i in + 0|1) ;; + *) echo "$pre +$tst +$ext +$inc +static $p i; +int n = sizeof(i);" > $tmp.c + is typ $p + if compile $cc -c $tmp.c <&$nullin >&$nullout + then success - + eval _iffe_typedef_$p=1 + i=1 + else failure - + eval _iffe_typedef_$p=0 + i=0 + fi + ;; + esac + case $i in + 0) i="$p is not a non-opaque struct" p="struct $p" ;; + *) i=- ;; + esac + is nos "$p" + echo "$pre +$tst +$ext +$inc +static $p i; +int n = sizeof(i);" > $tmp.c + if compile $cc -c $tmp.c <&$nullin >&$nullout + then echo "$pre +$tst +$ext +$inc +static $p i; +unsigned long f() { return (unsigned long)i; }" > $tmp.c + if compile $cc -c $tmp.c <&$nullin >&$nullout + then c=1 + else c=0 + fi + else c=1 + fi + report $c 1 "$p is a non-opaque struct" "$i" + esac + ;; + nop) ;; + npt) is npt $v + copy $tmp.c " +$tst +$ext +$std +$usr +$pre +$inc +_BEGIN_EXTERNS_ +struct _iffe_struct { int _iffe_member; }; +extern struct _iffe_struct* $v _ARG_((struct _iffe_struct*)); +_END_EXTERNS_ +" + # some compilers with -O only warn for invalid intrinsic prototypes + case " $cc " in + *" -O "*) xx=`echo $cc | sed 's/ -O / /g'` ;; + *) xx=$cc ;; + esac + compile $xx -c $tmp.c <&$nullin >&$nullout + report -$config $? 1 "$v() needs a prototype" "$v() does not need a prototype" + ;; + num) is num $v + copy $tmp.c " +$tst +$ext +$std +$usr +$pre +$inc +_BEGIN_EXTERNS_ +int _iffe_int = $v / 2; +_END_EXTERNS_ +" + compile $cc -c $tmp.c <&$nullin >&$nullout + report $? 1 "$v is a numeric constant" "$v is not a numeric constant" + ;; + one) for i in $a $hdr + do x="#include <$i>" + case " $gothdr " in + *" - $i "*) + continue + ;; + *" + $i "*) + ;; + *) echo "$x" > $tmp.c + if is_hdr $x + then gothdr="$gothdr + $x" + else gothdr="$gothdr - $x" + continue + fi + ;; + esac + case $one in + "") one=$x + ;; + *"$x"*) break + ;; + *) echo "$one" > $tmp.c + if compile $cc -E $tmp.c <&$nullin >$tmp.i + then c=$i + case $c in + *[\\/]*) c=`echo $c | sed 's,[\\\\/],[\\\\/],g'` ;; + esac + case `sed -e '/^#[line ]*1[ ][ ]*"[\\\\\/].*[\\\\\/]'$c'"/!d' $tmp.i` in + ?*) break ;; + esac + fi + one="$one$nl$x" + ;; + esac + echo "$x" + break + done + ;; + opt) M=$m + is opt $a + case " $PACKAGE_OPTIONS " in + *" $a "*) c=0 ;; + *) c=1 ;; + esac + report $c 1 "$a is set in \$PACKAGE_OPTIONS" "$a is not set in \$PACKAGE_OPTIONS" + ;; + out|output) + ;; + pth) is pth $a + pkg $pth + tab=" " + e= + f= + for i in $pth + do case $i in + '{') e="${nl}}" + l= + x=i + v="\$${x}" + t=${nl}${tab} + b="fnd()${nl}{${t}for ${x} in" + ;; + '}') b="${b}${t}do${tab}if $exists ${v}/\${1}${t}${tab}${tab}then${tab}f=${v}/\${1}${t}${tab}${tab}${tab}return${t}${tab}${tab}fi" + e="${t}done${e}" + eval "${b}${e}" + fnd $a + case $f in + ?*) break ;; + esac + ;; + -) b="${b}${t}do${tab}test \"${v}\" = '' -o -d \"${v}\" &&${t}${tab}${tab}" + x=${x}i + v="${v}\$${x}" + b="${b}for ${x} in" + e="${t}done${e}" + t="${t}${tab}${tab}" + ;; + *) case $e in + '') if $exists ${i}/${a} + then f=${i}/${a} + break + fi + ;; + *) case $i in + /|.) b="${b} ''" ;; + *) b="${b} /${i}" ;; + esac + ;; + esac + ;; + esac + done + case $f in + '') case $set in + ' ') f=$a ;; + ?*) f=$set ;; + esac + ;; + esac + case $f in + '') c=1 + ;; + *) c=0 + f="\"$f\"" + ;; + esac + report $c "$f" "${note:-$a path}" "$a path not found" + ;; + run) is run $a + if test ! -r $a + then failure not found + case $verbose in + 0) echo "$command: $file$line: $a: not found" >&$stderr ;; + esac + exit 1 + fi + noisy + case $a in + *.c) rm -f $tmp.exe + { + echo "$tst +$ext +$std +$usr +$inc" + cat $a + } > $tmp.c + compile $cc -o $tmp.exe $tmp.c $lib $deflib <&$nullin >&$stderr 2>&$stderr && + $executable $tmp.exe && + execute $tmp.exe $opt <&$nullin + ;; + *.sh) { + copy - ": +set \"cc='$cc' executable='$executable' id='$m' static='$static' tmp='$tmp'\" $opt $hdr $test" + cat $a + } > $tmp.sh + chmod +x $tmp.sh + ( . $tmp.sh ) <&$nullin + ;; + *) false + ;; + esac + case $? in + 0) success + ;; + *) failure cannot run + case $verbose in + 0) echo "$command: $file$line: $a: cannot run" >&$stderr ;; + esac + exit 1 + ;; + esac + ;; + siz) case $p in + "") x= ;; + *) x="$p " ;; + esac + is siz "$x$v" + { + case $p:$v in + long:*|*:*[_0123456789]int[_0123456789]*) + echo "$pre +$tst +$ext +$inc +static $x$v i; +$x$v f() { +$x$v v; i = 1; v = i;" + echo "i = v * i; i = i / v; v = v + i; i = i - v;" + case $v in + float|double) ;; + *) echo "v <<= 4; i = v >> 2; i = 10; i = v % i; i |= v; v ^= i; i = 123; v &= i;" ;; + esac + echo "return v; }" + ;; + *) echo "$pre +$inc +struct xxx { $x$v mem; }; +static struct xxx v; +struct xxx* f() { return &v; }" + ;; + esac + case $x in + ""|"struct "|"union ") + echo "int g() { return 0; }" + ;; + *) echo "int g() { return sizeof($x$v)<=sizeof($v); }" ;; + esac + copy - " +int main() { + f(); + g(); + printf(\"%u\\n\", sizeof($x$v)); + return 0; +}" + } > $tmp.c + rm -f $tmp.exe $tmp.dat + if compile $cc -o $tmp.exe $tmp.c $lib $deflib <&$nullin >&$nullout && + $executable $tmp.exe && + execute $tmp.exe > $tmp.dat + then z=`cat $tmp.dat` + c=0 + else z=0 + c=1 + fi + report $c "$z" "sizeof($x$v)" "$x$v not a type with known size" + ;; + sym) case $test in + "") x=$v ;; + *) x=$test ;; + esac + echo "$pre +$tst +$ext +$inc +'=' $x '='" > $tmp.c + compile $cc -E $tmp.c <&$nullin \ + | sed \ + -e "/'='/!d" \ + -e "s/'='//g" \ + -e 's/[ ]//g' \ + -e 's/((([^()]*)))->/->/g' \ + -e 's/(([^()]*))->/->/g' \ + -e 's/([^()]*)->/->/g' \ + -e 's/\([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789]*\)\[/\ +ary \1[/g' \ + -e 's/\([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789]*\)(/\ +fun \1[/g' \ + -e 's/\*->\([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]\)/->\ +ptr \1/g' \ + -e 's/->\([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]\)/->\ +reg \1/g' \ + -e "/^$v\$/d" \ + -e 's/^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789]*$/\ +nam &/g' \ + | sed \ + -e '/^... /!d' \ + | LC_ALL=C sort \ + -u \ + | sed \ + -e 's/\(...\) \([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789]*\).*/#ifndef _\1_'$v'\ +#define _\1_'$v' \2\ +#define _\1_'$v'_str "\2"\ +#endif/' + ;; + typ) case $p in + "") x= ;; + *) x="$p " ;; + esac + is typ "$x$v" + { + case $p:$v in + long:*|*:*[_0123456789]int[_0123456789]*) + echo "$pre +$tst +$ext +$inc +static $x$v i; +$x$v f() { +$x$v v; i = 1; v = i;" + echo "i = v * i; i = i / v; v = v + i; i = i - v;" + case $v in + float|double) ;; + *) echo "v <<= 4; i = v >> 2; i = 10; i = v % i; i |= v; v ^= i; i = 123; v &= i;" ;; + esac + echo "return v; }" + ;; + *) echo "$pre +$tst +$ext +$inc +struct xxx { $x$v mem; }; +static struct xxx v; +struct xxx* f() { return &v; }" + ;; + esac + case $x in + ""|"struct "|"union ") + echo "int main() { f(); return 0; }" ;; + *) echo "int main() { f(); return sizeof($x$v)<=sizeof($v); }" ;; + esac + } > $tmp.c + rm -f $tmp.exe + compile $cc -o $tmp.exe $tmp.c $lib $deflib <&$nullin >&$nullout && + $executable $tmp.exe && + execute $tmp.exe + report $? 1 "$x$v is a type" "$x$v is not a type" "default for type $x$v" + ;; + val) case $arg in + '"'*'"')echo $arg=\'$val\' ;; + *) echo $arg=\"$val\" ;; + esac + ;; + ver) ;; + 0) result=FAILURE + ;; + 1) result=SUCCESS + ;; + :) ;; + -) ;; + *) echo "$command: $file$line: $o: unknown feature test" >&$stderr + status=1 + ;; + esac + done + done + case $not in + 1) case $result in + FAILURE) result=SUCCESS ;; + *) result=FAILURE ;; + esac + ;; + esac + case $result in + FAILURE) user_pf=$fail user_yn=$no ;; + *) user_pf=$pass user_yn=$yes ;; + esac + case $user_pf in + ?*) eval "$user_pf" <&$nullin ;; + esac + case $user_yn in + ?*) case $def in + -) ;; + *) case $note in + ?*) case $user_yn in + *$nl*) user_yn="/* $note */$nl$user_yn" ;; + *) user_yn="$user_yn /* $note */" ;; + esac + ;; + esac + ;; + esac + copy - "$user_yn" + ;; + esac + case $ifelse:$result in + TEST:SUCCESS) ifelse=KEEP ;; + TEST:*) ifelse=SKIP ;; + esac + case $group:$result in + :*|*:SUCCESS) break ;; + esac + set '' $groups '' "$@" + shift + case $1 in + '') shift; break ;; + esac + shift + + # set up and try the next group + + hdr=$com_hdr + lib=$com_lib + mac=$com_mac + opt=$com_opt + pth=$com_pth + test=$com_test + cc="$occ $includes" + group= + groups= + while : + do case $1 in + '') shift; break ;; + esac + case $1 in + *[\"\'\(\)\{\}\ \ ]*) + case $op in + pth) pth="$pth $1" + ;; + *) case $test in + '') test=$1 ;; + *) test="$test $1" ;; + esac + ;; + esac + ;; + -) group=$group$1 + groups="$groups $1" + ;; + -l*) case $group in + -*) groups="$groups $1" ;; + *) lib="$lib $1" ;; + esac + ;; + +l*) case $shell in + bsh) x=`echo X$1 | sed 's/X+/-/'` ;; + *) eval 'x=-${1#+}' ;; + esac + case $group in + -*) groups="$groups $x" ;; + *) lib="$lib $x" ;; + esac + ;; + -*|+*) case $group in + -*) groups="$groups $1" + ;; + *) case $op in + run) opt="$opt $1" + ;; + *) case $1 in + -D*) mac="$mac $1" ;; + *) cc="$cc $1" ;; + esac + ;; + esac + ;; + esac + ;; + *.[aAxX]|*.[dD][lL][lL]|*.[lL][iI][bB]) + case $group in + -*) groups="$groups $1" ;; + *) lib="$lib $1" ;; + esac + ;; + *[.\\/]*) + case $group in + -*) groups="$groups $1" + ;; + *) case $op in + pth) pth="$pth $1" ;; + *) hdr="$hdr $1" ;; + esac + ;; + esac + ;; + *) case $group in + -*) groups="$groups $1" + ;; + *) case $op in + pth) pth="$pth $1" + ;; + *) case $test in + '') test=$1 ;; + *) test="$test $1" ;; + esac + ;; + esac + ;; + esac + ;; + esac + shift + done + done +done diff --git a/src/cmd/INIT/iffe.tst b/src/cmd/INIT/iffe.tst new file mode 100644 index 0000000..115ef62 --- /dev/null +++ b/src/cmd/INIT/iffe.tst @@ -0,0 +1,1943 @@ +# regression tests for the iffe command + +TEST 01 'command line basics' + + EXEC -r -v - hdr stdio + OUTPUT - $'/* : : generated by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes' + + EXEC -r -v -s bsh - hdr stdio + + EXEC -r -v - hdr stdio,limits + OUTPUT - $'/* : : generated by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define _hdr_limits 1 /* #include <limits.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is limits.h a header ... yes' + + EXEC -r -v -s bsh - hdr stdio,limits + + EXEC -r -v - hdr,lib no_foo_bar,no_bar_foo stdio.h + OUTPUT - $'/* : : generated by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is no_foo_bar.h a header ... no +iffe: test: is no_bar_foo.h a header ... no +iffe: test: is no_foo_bar a library function ... no +iffe: test: is no_bar_foo a library function ... no' + + EXEC -r -v -s bsh - hdr,lib no_foo_bar,no_bar_foo stdio.h + + EXEC -r -v - hdr no_foo_bar,no_bar_foo stdio.h : lib no_foo_bar,no_bar_foo stdio.h + + EXEC -r -v -s bsh - hdr no_foo_bar,no_bar_foo stdio.h : lib no_foo_bar,no_bar_foo stdio.h + +TEST 02 'file input basics' + + EXEC -r -v - t1.iffe + INPUT t1.iffe $'hdr stdio' + OUTPUT - $'/* : : generated from t1.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes' + + EXEC -r -v -s bsh - t1.iffe + + EXEC -r -v - t2.iffe + INPUT t2.iffe $'hdr stdio,limits' + OUTPUT - $'/* : : generated from t2.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define _hdr_limits 1 /* #include <limits.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is limits.h a header ... yes' + + EXEC -r -v -s bsh - t2.iffe + + EXEC -r -v - t3.iffe + INPUT t3.iffe $'hdr,lib no_foo_bar,no_bar_foo stdio.h' + OUTPUT - $'/* : : generated from t3.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is no_foo_bar.h a header ... no +iffe: test: is no_bar_foo.h a header ... no +iffe: test: is no_foo_bar a library function ... no +iffe: test: is no_bar_foo a library function ... no' + + EXEC -r -v -s bsh - t3.iffe + + EXEC -r -v - t3.iffe + INPUT t3.iffe $'hdr no_foo_bar,no_bar_foo stdio.h +lib no_foo_bar,no_bar_foo stdio.h' + + EXEC -r -v -s bsh - t3.iffe + +TEST 03 'nested if' + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if hdr stdio + if lib open { + HIT 1 + } + elif lib close { + HIT 2 + } + else { + HIT 3 + } + endif +elif hdr limits { + HIT 4 +} +else { + HIT 5 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define _lib_open 1 /* open() in default lib(s) */ + HIT 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is open a library function ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if hdr _XXX_stdio + if lib open { + HIT 1 + } + elif lib close { + HIT 2 + } + else { + HIT 3 + } + endif +elif hdr limits { + HIT 4 +} +else { + HIT 5 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_limits 1 /* #include <limits.h> ok */ +HIT 4 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is _XXX_stdio.h a header ... no +iffe: test: is limits.h a header ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if hdr _XXX_stdio + if lib open { + HIT 1 + } + elif lib close { + HIT 2 + } + else { + HIT 3 + } + endif +elif hdr _XXX_limits { + HIT 4 +} +else { + HIT 5 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +HIT 5 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is _XXX_stdio.h a header ... no +iffe: test: is _XXX_limits.h a header ... no' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if hdr stdio + if lib _XXX_open { + HIT 1 + } + elif lib close { + HIT 2 + } + else { + HIT 3 + } + endif +elif hdr limits { + HIT 4 +} +else { + HIT 5 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define _lib_close 1 /* close() in default lib(s) */ + HIT 2 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is _XXX_open a library function ... no +iffe: test: is close a library function ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if hdr stdio + if lib _XXX_open { + HIT 1 + } + elif lib _XXX_close { + HIT 2 + } + else { + HIT 3 + } + endif +elif hdr limits { + HIT 4 +} +else { + HIT 5 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ + HIT 3 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is _XXX_open a library function ... no +iffe: test: is _XXX_close a library function ... no' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if mem stat.st_atime sys/types.h sys/stat.h { + #define ATIME 1 +} +elif mem stat.st_ctime sys/types.h sys/stat.h { + #define CTIME 1 +} +elif mem stat.st_mtime sys/types.h sys/stat.h { + #define MTIME 1 +} +else pass{ no_stat_time=1 }end { + #define NOTIME 1 +} +endif +if ( !no_stat_time ) { + #define YESTIME 1 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _sys_stat 1 /* #include <sys/stat.h> ok */ +#define _mem_st_atime_stat 1 /* st_atime is a member of struct stat */ +#define ATIME 1 + +#define YESTIME 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is sys/stat.h a header ... yes +iffe: test: is stat a type or typedef ... no +iffe: test: is st_atime a member of struct stat ... yes +iffe: test: is ( !no_stat_time ) true ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if mem foo_stat.st_atime sys/types.h sys/stat.h { + #define ATIME 1 +} +elif mem stat.st_ctime sys/types.h sys/stat.h { + #define CTIME 1 +} +elif mem stat.st_mtime sys/types.h sys/stat.h { + #define MTIME 1 +} +else pass{ no_stat_time=1 }end { + #define NOTIME 1 +} +endif +if ( !no_stat_time ) { + #define YESTIME 1 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _sys_stat 1 /* #include <sys/stat.h> ok */ +#define _mem_st_ctime_stat 1 /* st_ctime is a member of struct stat */ +#define CTIME 1 + +#define YESTIME 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is sys/stat.h a header ... yes +iffe: test: is foo_stat a type or typedef ... no +iffe: test: is st_atime a member of struct foo_stat ... no +iffe: test: is stat a type or typedef ... no +iffe: test: is st_ctime a member of struct stat ... yes +iffe: test: is ( !no_stat_time ) true ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if mem foo_stat.st_atime sys/types.h sys/stat.h { + #define ATIME 1 +} +elif mem foo_stat.st_ctime sys/types.h sys/stat.h { + #define CTIME 1 +} +elif mem stat.st_mtime sys/types.h sys/stat.h { + #define MTIME 1 +} +else pass{ no_stat_time=1 }end { + #define NOTIME 1 +} +endif +if ( !no_stat_time ) { + #define YESTIME 1 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _sys_stat 1 /* #include <sys/stat.h> ok */ +#define _mem_st_mtime_stat 1 /* st_mtime is a member of struct stat */ +#define MTIME 1 + +#define YESTIME 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is sys/stat.h a header ... yes +iffe: test: is foo_stat a type or typedef ... no +iffe: test: is st_atime a member of struct foo_stat ... no +iffe: test: is st_ctime a member of struct foo_stat ... no +iffe: test: is stat a type or typedef ... no +iffe: test: is st_mtime a member of struct stat ... yes +iffe: test: is ( !no_stat_time ) true ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff ifelse +if mem foo_stat.st_atime sys/types.h sys/stat.h { + #define ATIME 1 +} +elif mem foo_stat.st_ctime sys/types.h sys/stat.h { + #define CTIME 1 +} +elif mem foo_stat.st_mtime sys/types.h sys/stat.h { + #define MTIME 1 +} +else pass{ no_stat_time=1 }end { + #define NOTIME 1 +} +endif +if ( !no_stat_time ) { + #define YESTIME 1 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _ifelse_H +#define _ifelse_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _sys_stat 1 /* #include <sys/stat.h> ok */ +#define NOTIME 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is sys/stat.h a header ... yes +iffe: test: is foo_stat a type or typedef ... no +iffe: test: is st_atime a member of struct foo_stat ... no +iffe: test: is st_ctime a member of struct foo_stat ... no +iffe: test: is st_mtime a member of struct foo_stat ... no +iffe: test: is ( !no_stat_time ) true ... no' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'set explicit +iff previous +hdr stdio +if hdr stdio { + OK +} +else { + OK +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _previous_H +#define _previous_H 1 +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +OK + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes' + + EXEC -r -v -s bsh - t.iffe + +TEST 04 'test variable/macro override' + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +HAVE_STDIO = hdr stdio' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define HAVE_STDIO 1 /* #include <stdio.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if hdr - stdio { + #define HIT 1 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define HIT 1 + +#endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if - hdr stdio { + #define HIT 1 +} +endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if ? hdr stdio { + #define HIT 1 +} +endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if hdr - stdio { + #define HIT 1 +} +endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if HAVE_STDIO = hdr stdio { + #define HIT 1 +} +endif +if ( HAVE_STDIO ) { + #define TOO ALSO +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define HAVE_STDIO 1 /* #include <stdio.h> ok */ +#define HIT 1 + +#define TOO ALSO + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is ( HAVE_STDIO ) true ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if HAVE_STDIO = hdr stdio { + #define HIT 1 +} +endif +exp ALSO HAVE_STDIO' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define HAVE_STDIO 1 /* #include <stdio.h> ok */ +#define HIT 1 + +#define ALSO 1 /* HAVE_STDIO is true */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is HAVE_STDIO true ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if HAVE_STDIO = hdr stdio { + #define HIT 1 +} +endif +ALSO = ( HAVE_STDIO )' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define HAVE_STDIO 1 /* #include <stdio.h> ok */ +#define HIT 1 + +#define ALSO 1 /* ( HAVE_STDIO ) is true */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is ( HAVE_STDIO ) true ... yes' + + EXEC -r -v -s bsh - t.iffe + +TEST 05 'test code option sequence' + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +tst seq - -DA=1 - -DB=1 note{ long int type }end compile{ + #if A == 1 && B == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end' + OUTPUT - '/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _seq 1 /* long int type */ +#endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +tst seq -DG=1 - -DN=1 - -DN=2 note{ long int type }end compile{ + #if G == 1 && N == 1 + #define t long + #else + #define t error + #endif + t n = 0; +}end' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +tst seq - -DA=1 - -DB=1 note{ long int type }end compile{ + #if A == 0 && B == 1 + #define t long + #else + #define t error + #endif + t n = 0; +}end' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +tst seq -DG=1 - -DN=1 - -DN=2 note{ long int type }end compile{ + #if G == 1 && N == 2 + #define t long + #else + #define t error + #endif + t n = 0; +}end' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +tst seq - -DA=1 - -DB=1 note{ long int type }end compile{ + #if A == 0 && B == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end' + OUTPUT - '/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... no' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +tst seq -DG=1 - -DN=1 - -DN=2 note{ long int type }end compile{ + #if G == 1 && N == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DA=1 - -DB=1 note{ long int type }end compile{ + #if A == 1 && B == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + OUTPUT - '/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +/* long int type */ +#define seq 1 + +#endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst -DG=1 - -DN=1 - -DN=2 note{ long int type }end compile{ + #if G == 1 && N == 1 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DA=1 - -DB=1 note{ long int type }end compile{ + #if A == 0 && B == 1 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst -DG=1 - -DN=1 - -DN=2 note{ long int type }end compile{ + #if G == 1 && N == 2 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DA=1 - -DB=1 note{ long int type }end compile{ + #if A == 0 && B == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + OUTPUT - '/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... no' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst -DG=1 - -DN=1 - -DN=2 note{ long int type }end compile{ + #if G == 1 && N == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DN=1 - -DN=2 - -DN=3 note{ long int type }end compile{ + #if N == 1 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + OUTPUT - '/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +/* long int type */ +#define seq 1 + +#endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DN=1 - -DN=2 - -DN=3 note{ long int type }end compile{ + #if N == 2 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DN=1 - -DN=2 - -DN=3 note{ long int type }end compile{ + #if N == 3 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... +iffe: test: long int type ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v - t.iffe + INPUT t.iffe $'iff macro +if tst - -DN=1 - -DN=2 - -DN=3 note{ long int type }end compile{ + #if N == 0 + #define t long + #else + #define t error + #endif + t n = 0; +}end { + #define seq 1 +} +endif' + OUTPUT - '/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _macro_H +#define _macro_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#endif' + ERROR - 'iffe: test: is sys/types.h a header ... yes +iffe: test: long int type ... +iffe: test: long int type ... +iffe: test: long int type ... no' + + EXEC -r -v -s bsh - t.iffe + +TEST 06 'block side effects' + + EXEC -r - t.iffe + INPUT t.iffe $'iff - +tst output{ + int + main() + { + printf("HIT\\n"); + return 0; + } +}end' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#define _sys_types 1 /* #include <sys/types.h> ok */ +HIT' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'iff +tst - output{ + int + main() + { + printf("HIT\\n"); + return 0; + } +}end' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'iff +tst - output{ + int + main() + { + printf("HIT\\n"); + return 1; + } +}end' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#define _sys_types 1 /* #include <sys/types.h> ok */' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'iff +tst - nooutput{ + int + main() + { + printf("HIT\\n"); + return 1; + } +}end' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#define _sys_types 1 /* #include <sys/types.h> ok */ +HIT' + + EXEC -r -s bsh - t.iffe + +TEST 07 'diagnostics' + + EXEC -r - t.iffe + INPUT t.iffe $'tst foo' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#endif' + ERROR - $'iffe: t.iffe:1: tst: unknown feature test' + EXIT 1 + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'if (1)' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */' + ERROR - $'iffe: t.iffe:1: missing endif' + EXIT 1 + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'if' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */' + ERROR - $'iffe: t.iffe:1: missing endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'endif' + ERROR - $'iffe: t.iffe:1: endif: no matching if' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'if { +}end' + ERROR - $'iffe: t.iffe:2: missing }' + + EXEC -r -s bsh - t.iffe + +TEST 08 'negation consternation' + + EXEC -r - t.iffe + INPUT t.iffe $'npt fopen,fooon stdio.h' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdlib 1 /* #include <stdlib.h> ok */ +#define _hdr_unistd 1 /* #include <unistd.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define _npt_fooon 1 /* fooon() needs a prototype */ +#endif' + + EXEC -r -u - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdlib 1 /* #include <stdlib.h> ok */ +#define _hdr_unistd 1 /* #include <unistd.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#undef _npt_fopen /* fopen() does not need a prototype */ +#define _npt_fooon 1 /* fooon() needs a prototype */ +#endif' + + EXEC -r -a - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdlib 1 /* #include <stdlib.h> ok */ +#define _hdr_unistd 1 /* #include <unistd.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define _npt_fopen 0 /* fopen() does not need a prototype */ +#define _npt_fooon 1 /* fooon() needs a prototype */ +#endif' + + EXEC -r -C - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define HAVE_SYS_TYPES_H 1 /* #include <sys/types.h> ok */ +#define HAVE_STDLIB_H 1 /* #include <stdlib.h> ok */ +#define HAVE_UNISTD_H 1 /* #include <unistd.h> ok */ +#define HAVE_STDIO_H 1 /* #include <stdio.h> ok */ +#define HAVE_FOPEN_DECL 1 /* fopen() does not need a prototype */ +#undef HAVE_FOOON_DECL /* fooon() needs a prototype */ +#endif' + + EXEC -r - t.iffe + INPUT t.iffe $'NEED_FOPEN = npt fopen stdio.h +HAVE_FOPEN = ! npt fopen stdio.h +NEED_FOOON = npt fooon stdio.h +HAVE_FOOON = ! npt fooon stdio.h' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdlib 1 /* #include <stdlib.h> ok */ +#define _hdr_unistd 1 /* #include <unistd.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#define HAVE_FOPEN 1 /* fopen() does not need a prototype */ +#define NEED_FOOON 1 /* fooon() needs a prototype */ +#endif' + + EXEC -r -u - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_stdlib 1 /* #include <stdlib.h> ok */ +#define _hdr_unistd 1 /* #include <unistd.h> ok */ +#define _hdr_stdio 1 /* #include <stdio.h> ok */ +#undef NEED_FOPEN /* fopen() does not need a prototype */ +#define HAVE_FOPEN 1 /* fopen() does not need a prototype */ +#define NEED_FOOON 1 /* fooon() needs a prototype */ +#undef HAVE_FOOON /* fooon() needs a prototype */ +#endif' + + EXEC -r -C - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define HAVE_SYS_TYPES_H 1 /* #include <sys/types.h> ok */ +#define HAVE_STDLIB_H 1 /* #include <stdlib.h> ok */ +#define HAVE_UNISTD_H 1 /* #include <unistd.h> ok */ +#define HAVE_STDIO_H 1 /* #include <stdio.h> ok */ +#undef NEED_FOPEN /* fopen() does not need a prototype */ +#define HAVE_FOPEN 1 /* fopen() does not need a prototype */ +#define NEED_FOOON 1 /* fooon() needs a prototype */ +#undef HAVE_FOOON /* fooon() needs a prototype */ +#endif' + +TEST 09 'exp vs. if' + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_false { + ONE +} +exp _tst_hit !_tst_hit&_tst_true pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&_tst_true { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#define _tst_hit 1 /* !_tst_false is true */ +/* !_tst_false */ +ONE + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_true { + ONE +} +exp _tst_hit !_tst_hit&_tst_true pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&_tst_true { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#define _tst_hit 1 /* !_tst_hit&_tst_true is true */ +TWO 0 1 +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_true { + ONE +} +exp _tst_hit !_tst_hit&_tst_false pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&_tst_true { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#define _tst_hit 1 /* !_tst_hit&_tst_true is true */ +/* !_tst_hit&_tst_true */ +THREE + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_true { + ONE +} +exp _tst_hit !_tst_hit&_tst_false pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&_tst_false { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_false { + ONE +} +exp _tst_hit !_tst_hit&&_tst_true pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&&_tst_true { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#define _tst_hit 1 /* !_tst_false is true */ +/* !_tst_false */ +ONE + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_true { + ONE +} +exp _tst_hit !_tst_hit&&_tst_true pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&&_tst_true { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#define _tst_hit 1 /* !_tst_hit&&_tst_true is true */ +TWO 0 1 +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_true { + ONE +} +exp _tst_hit !_tst_hit&&_tst_false pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&&_tst_true { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#define _tst_hit 1 /* !_tst_hit&&_tst_true is true */ +/* !_tst_hit&&_tst_true */ +THREE + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +exp _tst_hit !_tst_true { + ONE +} +exp _tst_hit !_tst_hit&&_tst_false pass{ +cat <<! + TWO $_tst_false $_tst_true +! +}end +exp _tst_hit !_tst_hit&&_tst_false { + THREE +}' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +if ( ! _tst_false ) { + ONE +} +elif ( _tst_true ) pass{ +cat <<! + TWO +! +}end +else { + THREE +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +ONE + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +if ( ! _tst_true ) { + ONE +} +elif ( _tst_true ) pass{ +cat <<! + TWO +! +}end +else { + THREE +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +TWO +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +if ( ! _tst_true ) { + ONE +} +elif ( _tst_false ) pass{ +cat <<! + TWO +! +}end +else { + THREE +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +THREE + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +if ( ! _tst_true ) yes{ + typedef struct + { + int dd_fd; /* file descriptor */ + } DIR; +}end +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +if ( ! _tst_true ) { + typedef struct + { + int dd_fd; /* file descriptor */ + } DIR; +} +else { + OK +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _tst_true 1 /* ( 1 ) is true */ +OK + +#endif' + + EXEC -r -s bsh - t.iffe + + EXEC -r - t.iffe + INPUT t.iffe $'_tst_false = ( 0 ) +_tst_true = ( 1 ) +if ( ! _tst_true ) { + typedef struct + { + int dd_fd; /* file descriptor */ + }; +} +else { + OK +} +endif' + + EXEC -r -s bsh - t.iffe + +TEST 10 'exp details' + + EXEC -r -v - t.iffe + INPUT t.iffe $'_str = "string" +_hdr = <header> +_aaa = ( 0 ) +_zzz = ( 1 ) +( _str ) +( ! _str ) +( _hdr ) +( ! _hdr ) +( _aaa ) +( ! _aaa ) +( _zzz ) +( ! _zzz )' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _str "string" +#define _hdr <header> +#define _zzz 1 /* ( 1 ) is true */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is ( 0 ) true ... no +iffe: test: is ( 1 ) true ... yes +iffe: test: is ( _str ) true ... yes +iffe: test: is ( ! _str ) true ... no +iffe: test: is ( _hdr ) true ... yes +iffe: test: is ( ! _hdr ) true ... no +iffe: test: is ( _aaa ) true ... no +iffe: test: is ( ! _aaa ) true ... yes +iffe: test: is ( _zzz ) true ... yes +iffe: test: is ( ! _zzz ) true ... no' + + EXEC -r -v -s bsh - t.iffe + +TEST 11 'set [no]define' + + EXEC -r -v - t.iffe + INPUT t.iffe $'set nodefine +mem stat.st_mtime sys/types.h sys/stat.h +set define +mem stat.st_mode sys/types.h sys/stat.h +if ( _mem_st_mtime_stat ) { + 1 +} +endif +if ( _mem_st_mode_stat ) { + 2 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _mem_st_mode_stat 1 /* st_mode is a member of struct stat */ +1 + +2 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is sys/stat.h a header ... yes +iffe: test: is stat a type or typedef ... no +iffe: test: is st_mtime a member of struct stat ... yes +iffe: test: is st_mode a member of struct stat ... yes +iffe: test: is ( _mem_st_mtime_stat ) true ... yes +iffe: test: is ( _mem_st_mode_stat ) true ... yes' + + EXEC -r -v -s bsh - t.iffe + +TEST 12 'non-opaque mem' + + EXEC -r -v - mem OPAQUE -I. t.h + INPUT t.h $'typedef struct opaque OPAQUE;' + OUTPUT - $'/* : : generated by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_t 1 /* #include <t.h> ok */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is t.h a header ... yes +iffe: test: is OPAQUE a type or typedef ... no +iffe: test: is struct OPAQUE a non-opaque struct ... no' + + EXEC -r -v - mem NONOPAQUE -I. t.h + INPUT t.h $'struct nonopaque { int pad; }; +typedef struct nonopaque NONOPAQUE;' + OUTPUT - $'/* : : generated by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _hdr_t 1 /* #include <t.h> ok */ +#define _mem_NONOPAQUE 1 /* NONOPAQUE is a non-opaque struct */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is t.h a header ... yes +iffe: test: is NONOPAQUE a type or typedef ... yes +iffe: test: is NONOPAQUE a non-opaque struct ... yes' + +TEST 13 'key states' + + EXEC -r -v - t.iffe + INPUT t.iffe $'key int +key const = +key foo +key bar = +key aha = huh = int +key chr = char = int' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _key_int 1 /* int is a reserved keyword */ +#define _key_const 1 /* const is a reserved keyword */ +#define bar /* default for reserved keyword bar */ +#define aha int /* default for reserved keyword aha */ +#define _key_char 1 /* char is a reserved keyword */ +#define chr char /* alternate for reserved keyword chr */ +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is int a reserved keyword ... yes +iffe: test: is const a reserved keyword ... yes +iffe: test: is foo a reserved keyword ... no +iffe: test: is bar a reserved keyword ... no +iffe: test: is aha a reserved keyword ... no +iffe: test: is huh a reserved keyword ... no +iffe: test: is chr a reserved keyword ... no +iffe: test: is char a reserved keyword ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -u -r -v - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _key_int 1 /* int is a reserved keyword */ +#define _key_const 1 /* const is a reserved keyword */ +#undef _key_foo /* foo is not a reserved keyword */ +#undef _key_bar /* bar is not a reserved keyword */ +#define bar /* default for reserved keyword bar */ +#undef _key_huh /* huh is not a reserved keyword */ +#define aha int /* default for reserved keyword aha */ +#define _key_char 1 /* char is a reserved keyword */ +#define chr char /* alternate for reserved keyword chr */ +#endif' + + EXEC -u -r -v -s bsh - t.iffe + + EXEC -a -r -v - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define _key_int 1 /* int is a reserved keyword */ +#define _key_const 1 /* const is a reserved keyword */ +#define _key_foo 0 /* foo is not a reserved keyword */ +#define _key_bar 0 /* bar is not a reserved keyword */ +#define bar /* default for reserved keyword bar */ +#define _key_huh 0 /* huh is not a reserved keyword */ +#define aha int /* default for reserved keyword aha */ +#define _key_char 1 /* char is a reserved keyword */ +#define chr char /* alternate for reserved keyword chr */ +#endif' + + EXEC -a -r -v -s bsh - t.iffe + + EXEC -C -r -v - t.iffe + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define HAVE_SYS_TYPES_H 1 /* #include <sys/types.h> ok */ +#define HAVE_INT_RESERVED 1 /* int is a reserved keyword */ +#define HAVE_CONST_RESERVED 1 /* const is a reserved keyword */ +#undef HAVE_FOO_RESERVED /* foo is not a reserved keyword */ +#undef HAVE_BAR_RESERVED /* bar is not a reserved keyword */ +#define bar /* default for reserved keyword bar */ +#undef HAVE_HUH_RESERVED /* huh is not a reserved keyword */ +#define aha int /* default for reserved keyword aha */ +#define HAVE_CHAR_RESERVED 1 /* char is a reserved keyword */ +#define chr char /* alternate for reserved keyword chr */ +#endif' + + EXEC -C -r -v -s bsh - t.iffe + +TEST 14 'inc file' + + EXEC -r -v - t.iffe + INPUT t.iffe $'inc t_lib.h +if ( bar_foo ) { + #define all 1 +} +elif ( _foo_bar ) { + #define some 1 +} +endif' + INPUT t_lib.h '#define bar_foo ALL +#define _foo_bar SOME' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define some 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is ( bar_foo ) true ... no +iffe: test: is ( _foo_bar ) true ... yes' + + EXEC -r -v - t.iffe + INPUT t.iffe $'inc t_lib.h . +if ( bar_foo ) { + #define all 1 +} +elif ( _foo_bar ) { + #define ok 1 +} +endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define all 1 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is ( bar_foo ) true ... yes' + + EXEC -r -v - t.iffe + INPUT t.iffe $'inc t_lib.h . ? +if ( bar_foo ) { + #define all 1 +} +elif ( _foo_bar ) { + #define ok 1 +} +endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: t.iffe:1: warning: ?: operands ignored +iffe: test: is ( bar_foo ) true ... yes' + + EXEC -r -v - t.iffe + INPUT t.iffe $'inc foo_lib.h' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: t.iffe:1: foo_lib.h: file not found' + EXIT 1 + + EXEC -r -v - t.iffe + INPUT t.iffe $'inc' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: t.iffe:1: path expected' + +TEST 15 'KnR compatibility' + + EXEC -r -v - t.iffe + INPUT t.iffe $' +if ( 1 ) { + #define all 1 +} +endif +if ( 2 ) { + #define some 1 +} +endif +cat{ +#define a 1 + #define b 2 + #define c 3 + #define d 4 +}end' +#define _foo_bar SOME' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define some 1 + +#endif' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#define all 1 + +#define some 1 + +#define a 1 +#define b 2 +#define c 3 +#define d 4 + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is ( 1 ) true ... yes +iffe: test: is ( 2 ) true ... yes +iffe: test: cat{ ... }end ... yes' + + EXEC -r -v -s bsh - t.iffe + + EXEC -r -v -s osh - t.iffe + +TEST 16 '{ define extern include print }' + + EXEC -r -v - t.iffe + INPUT t.iffe $' +print /* test header */ +header stdio.h +define EOF -1 +define FoobaR (a,b) ((a)+(b)) +define FoomaC -1 +extern fopen FILE* (char*, char*) +extern BarfoO struct barfoo* (int) +extern Tab_lE struct barfoo* [10]' + OUTPUT - $'/* test header */ +/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _REGRESS +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#include <stdio.h> +#define FoobaR(a,b) ((a)+(b)) +#define FoomaC -1 +extern struct barfoo* BarfoO(int); +extern struct barfoo* Tab_lE[10]; +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes +iffe: test: is EOF a macro ... yes +iffe: test: is FoobaR a macro ... no +iffe: test: is FoomaC a macro ... no +iffe: test: is fopen a symbol that needs a prototype ... no +iffe: test: is BarfoO a symbol that needs a prototype ... yes +iffe: test: is Tab_lE a symbol that needs a prototype ... yes' + +TEST 17 'features/* => FEATURE/*' + + EXEC -r -v run features/stdio + INPUT features/stdio $'set prototyped +header stdio.h' + OUTPUT FEATURE/stdio $' +/* : : generated by proto : : */ +/* : : generated from features/stdio by iffe version 1995-03-19 : : */ + +#ifndef _REGRESS +#if !defined(__PROTO__) +# if defined(__STDC__) || defined(__cplusplus) || defined(_proto) || defined(c_plusplus) +# if defined(__cplusplus) +# define __LINKAGE__ "C" +# else +# define __LINKAGE__ +# endif +# define __STDARG__ +# define __PROTO__(x) x +# define __OTORP__(x) +# define __PARAM__(n,o) n +# if !defined(__STDC__) && !defined(__cplusplus) +# if !defined(c_plusplus) +# define const +# endif +# define signed +# define void int +# define volatile +# define __V_ char +# else +# define __V_ void +# endif +# else +# define __PROTO__(x) () +# define __OTORP__(x) x +# define __PARAM__(n,o) o +# define __LINKAGE__ +# define __V_ char +# define const +# define signed +# define void int +# define volatile +# endif +# define __MANGLE__ __LINKAGE__ +# if defined(__cplusplus) || defined(c_plusplus) +# define __VARARG__ ... +# else +# define __VARARG__ +# endif +# if defined(__STDARG__) +# define __VA_START__(p,a) va_start(p,a) +# else +# define __VA_START__(p,a) va_start(p) +# endif +# if !defined(__INLINE__) +# if defined(__cplusplus) +# define __INLINE__ extern __MANGLE__ inline +# else +# if defined(_WIN32) && !defined(__GNUC__) +# define __INLINE__ __inline +# endif +# endif +# endif +#endif +#if !defined(__LINKAGE__) +#define __LINKAGE__ /* 2004-08-11 transition */ +#endif + +#define _REGRESS 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ +#include <stdio.h> +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes +iffe: test: is stdio.h a header ... yes' + +TEST 18 'api + ver' + EXEC -r -v - t.iffe + INPUT t.iffe $'iff api +ver foo 20100606 +ver bar 19840919 + +api foo 19991231 dis dat tother +api foo 20100601 dat +api foo 20100606 dis +api bar 19991231 moe larry shemp +api bar 20020202 curly +api bar 20030303 shemp +api bar 20040404 joe_b +api bar 20050505 joe_d +' + OUTPUT - $'/* : : generated from t.iffe by iffe version 1995-03-19 : : */ +#ifndef _api_H +#define _api_H 1 +#define _sys_types 1 /* #include <sys/types.h> ok */ + +#define FOO_VERSION 20100606 +#define BAR_VERSION 19840919 + +#if !defined(_API_foo) && defined(_API_DEFAULT) +#define _API_foo _API_DEFAULT +#endif + +#if ( _BLD_foo || !_API_foo || _API_foo >= 20100601 ) +#undef dat +#define dat dat_20100601 +#elif _API_foo >= 19991231 +#undef dat +#define dat dat_19991231 +#endif + +#if ( _BLD_foo || !_API_foo || _API_foo >= 20100606 ) +#undef dis +#define dis dis_20100606 +#elif _API_foo >= 19991231 +#undef dis +#define dis dis_19991231 +#endif + +#if ( _BLD_foo || !_API_foo || _API_foo >= 19991231 ) +#undef tother +#define tother tother_19991231 +#endif + +#define _API_foo_MAP "dat_20100601 dat_19991231 dis_20100606 dis_19991231 tother_19991231" + +#if !defined(_API_bar) && defined(_API_DEFAULT) +#define _API_bar _API_DEFAULT +#endif + +#if ( _BLD_bar || !_API_bar || _API_bar >= 20020202 ) +#undef curly +#define curly curly_20020202 +#endif + +#if ( _BLD_bar || !_API_bar || _API_bar >= 20040404 ) +#undef joe_b +#define joe_b joe_b_20040404 +#endif + +#if ( _BLD_bar || !_API_bar || _API_bar >= 20050505 ) +#undef joe_d +#define joe_d joe_d_20050505 +#endif + +#if ( _BLD_bar || !_API_bar || _API_bar >= 19991231 ) +#undef larry +#define larry larry_19991231 +#endif + +#if ( _BLD_bar || !_API_bar || _API_bar >= 19991231 ) +#undef moe +#define moe moe_19991231 +#endif + +#if ( _BLD_bar || !_API_bar || _API_bar >= 20030303 ) +#undef shemp +#define shemp shemp_20030303 +#elif _API_bar >= 19991231 +#undef shemp +#define shemp shemp_19991231 +#endif + +#define _API_bar_MAP "curly_20020202 joe_b_20040404 joe_d_20050505 larry_19991231 moe_19991231 shemp_20030303 shemp_19991231" + +#endif' + ERROR - $'iffe: test: is sys/types.h a header ... yes' diff --git a/src/cmd/INIT/ignore.sh b/src/cmd/INIT/ignore.sh new file mode 100644 index 0000000..2999645 --- /dev/null +++ b/src/cmd/INIT/ignore.sh @@ -0,0 +1,43 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +# non-ksh script for the nmake ignore prefix +# @(#)ignore (AT&T Research) 1992-08-11 + +case $-:$BASH_VERSION in +*x*:[0123456789]*) : bash set -x is broken :; set +ex ;; +esac + +while : +do case $# in + 0) exit 0 ;; + esac + case $1 in + *=*) case $RANDOM in + $RANDOM)`echo $1 | sed "s/\\([^=]*\\)=\\(.*\\)/eval \\1='\\2'; export \\1/"` ;; + *) export "$1" ;; + esac + shift + ;; + *) break + ;; + esac +done +"$@" +exit 0 diff --git a/src/cmd/INIT/intl.c b/src/cmd/INIT/intl.c new file mode 100644 index 0000000..1623dd6 --- /dev/null +++ b/src/cmd/INIT/intl.c @@ -0,0 +1,29 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#ifndef gettext +#include <libintl.h> +#endif + +int +main() +{ + gettext(0); + return 0; +} diff --git a/src/cmd/INIT/ld.hp.pa b/src/cmd/INIT/ld.hp.pa new file mode 100755 index 0000000..99d39f0 --- /dev/null +++ b/src/cmd/INIT/ld.hp.pa @@ -0,0 +1,5 @@ +: hp.pa ld wrapper for reasonable warning defaults + +# @(#)ld.hp.pa (AT&T Labs Research) 1998-01-23 + +/bin/ld +s +vnocompatwarnings "$@" diff --git a/src/cmd/INIT/ldd.cygwin.i386 b/src/cmd/INIT/ldd.cygwin.i386 new file mode 100755 index 0000000..5976b1f --- /dev/null +++ b/src/cmd/INIT/ldd.cygwin.i386 @@ -0,0 +1,22 @@ +#!/bin/env sh +: cygwin.i386 ldd -- how many ways does this confirm the windows bias? +for f +do case $f in + *.exe) ;; + *) f=$f.exe ;; + esac + p=$(type $f) + case $p in + *" not found"*) + ;; + *) p=${p##* } + case $p in + ?*) f=$p ;; + esac + ;; + esac + cygcheck $(cygpath -aw $f) | + for w in $(sed -e 's/^[[:space:]]*//' -e '/^$/d' -e '/^Use /d') + do cygpath -u "$w" + done +done diff --git a/src/cmd/INIT/ldd.darwin b/src/cmd/INIT/ldd.darwin new file mode 100755 index 0000000..ec75f7b --- /dev/null +++ b/src/cmd/INIT/ldd.darwin @@ -0,0 +1,2 @@ +: mac os10 ldd +otool -L "$@" diff --git a/src/cmd/INIT/ldd.hp.pa b/src/cmd/INIT/ldd.hp.pa new file mode 100755 index 0000000..34874b4 --- /dev/null +++ b/src/cmd/INIT/ldd.hp.pa @@ -0,0 +1,21 @@ +: hp.pa ldd +while : +do case $# in + 0) break ;; + esac + case $1 in + -*|+*) ;; + *) break ;; + esac + shift +done +trap ':' 15 +for cmd +do case $# in + 1) ;; + *) echo $cmd: ;; + esac + _HP_DLDOPTS=-ldd "$cmd" < /dev/null 2> /dev/null | sort -u + # chatr "$cmd" | + # sed -e '/^[ ]*dynamic[ ][ ]*/!d' -e 's// /' +done diff --git a/src/cmd/INIT/ldd.ibm.risc b/src/cmd/INIT/ldd.ibm.risc new file mode 100755 index 0000000..984ef6d --- /dev/null +++ b/src/cmd/INIT/ldd.ibm.risc @@ -0,0 +1,16 @@ +: ibm.risc ldd +case $# in +1) header=0 ;; +*) header=1 ;; +esac +for file +do case $header in + 1) echo "$file:" + header=2 + ;; + 2) echo + echo "$file:" + ;; + esac + dump -H "$file" | sed '1,/\*\*\*Import/d' +done diff --git a/src/cmd/INIT/ldd.lynxos b/src/cmd/INIT/ldd.lynxos new file mode 100755 index 0000000..43904a8 --- /dev/null +++ b/src/cmd/INIT/ldd.lynxos @@ -0,0 +1 @@ +elflook -L "$@" | sed -e '/^NEEDED:/!d' -e 's/.*: *//' diff --git a/src/cmd/INIT/ldd.mvs.390 b/src/cmd/INIT/ldd.mvs.390 new file mode 100755 index 0000000..341c4cc --- /dev/null +++ b/src/cmd/INIT/ldd.mvs.390 @@ -0,0 +1,18 @@ +: mvs.390 ldd +case $# in +1) header=0 ;; +*) header=1 ;; +esac +for file +do case $header in + 1) echo "$file:" + header=2 + ;; + 2) echo + echo "$file:" + ;; + esac + strings $file | + sed -e '/\<[[:lower:]][[:alnum:]]*\.dll\>/!d' -e 's/^/ /' | + sort -u +done diff --git a/src/cmd/INIT/ldd.sgi b/src/cmd/INIT/ldd.sgi new file mode 100755 index 0000000..d3c5347 --- /dev/null +++ b/src/cmd/INIT/ldd.sgi @@ -0,0 +1,2 @@ +: sgi.mips ldd +odump -Dl "$@" diff --git a/src/cmd/INIT/m.c b/src/cmd/INIT/m.c new file mode 100644 index 0000000..b56b99b --- /dev/null +++ b/src/cmd/INIT/m.c @@ -0,0 +1,34 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * -lm test #1 + */ + +#ifndef sin +#include <math.h> +#endif + +int +main() +{ + sin(0.0); + fmod(100.234, 11.0); + return 0; +} diff --git a/src/cmd/INIT/m2.c b/src/cmd/INIT/m2.c new file mode 100644 index 0000000..cad12b1 --- /dev/null +++ b/src/cmd/INIT/m2.c @@ -0,0 +1,36 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * -lm test #2 + */ + +#include <math.h> + +int +main() +{ + double value = 0; + int exp = 0; + int r = 0; + + r |= ldexp(value, exp) != 0; + r |= frexp(value, &exp) != 0; + return r; +} diff --git a/src/cmd/INIT/m3.c b/src/cmd/INIT/m3.c new file mode 100644 index 0000000..5d89991 --- /dev/null +++ b/src/cmd/INIT/m3.c @@ -0,0 +1,36 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * -lm test #3 + */ + +#include <math.h> + +int +main() +{ + long double value = 0; + int exp = 0; + int r = 0; + + r |= ldexpl(value, exp) != 0; + r |= frexpl(value, &exp) != 0; + return r; +} diff --git a/src/cmd/INIT/m4.c b/src/cmd/INIT/m4.c new file mode 100644 index 0000000..79b87f0 --- /dev/null +++ b/src/cmd/INIT/m4.c @@ -0,0 +1,32 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * -lm test #4 + */ + +#include <math.h> + +int +main() +{ + double value = 0; + + return isnan(value); +} diff --git a/src/cmd/INIT/m5.c b/src/cmd/INIT/m5.c new file mode 100644 index 0000000..f853921 --- /dev/null +++ b/src/cmd/INIT/m5.c @@ -0,0 +1,32 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * -lm test #5 + */ + +#include <math.h> + +int +main() +{ + long double value = 0; + + return isnanl(value); +} diff --git a/src/cmd/INIT/m6.c b/src/cmd/INIT/m6.c new file mode 100644 index 0000000..4387ea0 --- /dev/null +++ b/src/cmd/INIT/m6.c @@ -0,0 +1,34 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * -lm test #6 + */ + +#define _ISOC99_SOURCE 1 + +#include <math.h> + +int +main() +{ + double value = -0.0; + + return !signbit(value); +} diff --git a/src/cmd/INIT/make.probe b/src/cmd/INIT/make.probe new file mode 100644 index 0000000..8a3c383 --- /dev/null +++ b/src/cmd/INIT/make.probe @@ -0,0 +1,2242 @@ +: +### this script contains archaic constructs that work with all sh variants ### +# Glenn Fowler +# AT&T Research +# +# @(#)make.probe (AT&T Research) 2011-06-01 +# +# C probe for make +# +# NOTE: C.probe must be included or .'d here +# + +cc_dll_def=-D_BLD_DLL + +probe_ar_arflags="-Xany" +probe_arflags="-xar" +probe_ccs="strip size nm ld ar" # longest to shortest +probe_debug="-g" +probe_dll="'-G 0' -Wc,dll,exportall,longname,rent -Wc,exportall -dynamic $cc_dll_def" +probe_export_dynamic="-rdynamic -export-dynamic -Wl,-export-dynamic -Wl,-E -bexpall -force_flat_namespace" +probe_gcc_optimize="-O2" +probe_gcc_version="*[Gg][Cc][Cc]*" +probe_include_local="'-ignore-source-dir -iquote' -iquote -I-" +probe_ldlazy='-zlazyload -znolazyload -Wl,-zlazyload -Wl,-znolazyload' +probe_ldlib="LD_LIBRARY_PATH LIBPATH LPATH" +probe_ldmap="'-Wl,-M' '-Qoption ld -M' '-Wl,-m' '-m'" +probe_ldorigin="-Wl,-z,origin" +probe_ldrecord='-zrecord -zignore -Wl,-zrecord -Wl,-zignore' +probe_ldrunpath="-Wl,-R, -R -Wl,-rpath, -L" +probe_ldstrip="'-s -mr' -Wl,-s" +probe_lib="a lib" +probe_lib_append="/usr/lib/pa1.1" +probe_lib_all_undef="-all -notall -all -none -Bwhole-archive -Bno-whole-archive -whole-archive -no-whole-archive -Wl,-whole-archive -Wl,-no-whole-archive -all_load '' -Wl,-zallextract -Wl,-zdefaultextract +forceload +noforceload" +probe_lib_multiple="-Wl,-zmuldefs" +probe_libdir="shlib lib" +probe_nmflags="'' -p -B" +probe_optimize="-O" +probe_pic="-Kpic -KPIC -fpic -fPIC -pic -PIC +z +Z" +probe_no_protect="'-fno-stack-protector -fno-stack-protector-all' -GS-" +probe_readonly="-R -Krodata -xMerge -Wa,-r" +probe_shared="'' -G -b -c -shared -Wl,dll" +probe_shared_name="-Wl,-soname= -h" +probe_shared_nostart="-nostartfiles" +probe_shared_registry='"-update_registry $probe_shared_registry_file"' +probe_shared_registry_file='registry.ld' +probe_shared_registry_path="\$(LIBDIR)/$probe_shared_registry_file" +probe_strict="'-ansi -pedantic' '-ansi -strict' -strict -ansi" +probe_stripflags="'-f -s' -f -s" +probe_unresolved="'-expect_unresolved \"*\"'" +probe_warn="-Wall -fullwarn -w3 '-A -A' +w1" + +echo '#pragma pp:version' > libpp.$src +echo '#define dDflag on' > dDflag.$src +echo 'int main(){return 0;}' > doti.$src +echo 'int code(){return 0;} int main(){return code();}' > export.$src +echo '#include <stdio.h>' > imstd.$src +echo '#include "_i_.h"' > imusr.$src +echo 'int x;' > _i_.h +mkdir im +echo '(' > im/stdio.h +echo '#include "implc_x.h" +int main(){f(1);return 0;}' > implc.$src +echo 'template <class T> void f(T){}' > implc_x.$src +echo 'template <class T> void f(T);' > implc_x.h +echo 'extern int NotalL(){return(0);}' > notall.$src +echo '#include <stdio.h> +extern int i; +int i = 1; +extern int f(){return(!i);} +int main(){FILE* fp=stdin;return(f());}' > pic.$src +echo 'class x {int n;} m;' > plusplus.$src +echo 'int prefix(){return 0;}' > prefix.$src +echo 'template<class T> int gt(T a, T b); +template<class T> int gt(T a, T b) { return a > b; } +int main () { return gt(2,1); }' > ptr.$src +echo 'int main(){return 0;}' > require.$src +echo '#if mips && !sgi || __CYGWIN__ +( /* some systems choke on this probe */ +#else +#if test_const +#define CONST const +#else +#define CONST +#endif +CONST char x[]={1,2,3,4,5,6,7,8,9,0}; +int main(){*(char*)x=0; return x[0];} +#endif' > readonly.$src +# NOTE: sfclose() defined on uwin, not defined on all other systems +echo 'extern int sfclose(); extern int ShareD(){return(sfclose());}' > shared.$src +echo '#define g(a,b) a ## b +volatile int a; +const int g(x,y)=1; +extern int c(int);' > stdc.$src +echo 'extern int f(); int main() { return f(); }' > sovmain.$src +echo 'int f() { return 0; }' > sovlib.$src +echo '#include <stdio.h> +int i; +int main(){int j;j = i * 10;return j;}' > strip.$src +echo 'template <class T> void f(T){} +int main(){f(1);return 0;}' > toucho.$src +echo '#if defined(__STDC__) || defined(__cplusplus) +extern type call(int); +#endif +int main() {call(0);return(0);}' > tstlib.$src +echo 'int main(){return 0;}' > warn.$src +echo 'int f(){return 0;}' > warn1.$src +echo 'int f(){}' > warn2.$src +echo 'int f(){int i; return 0;}' > warn3.$src +echo 'int f(){int i; return i;}' > warn4.$src +echo 'int f(){return g();}' > warn5.$src +warn_enum="1 2 3 4 5" + +chmod -w *.$src + +ar_arflags= +arflags= +cc_dll= +cc_pic= +cc_PIC= +dDflag= +debug= +dialect= +dll_dir='$(LIBDIR)' +dll_libraries= +dll_variants= +doti= +exectype= +export_dynamic= +gnu= +implicitc= +include_local= +lddynamic= +ldlazy= +ldnolazy= +ldnorecord= +ldorigin= +ldrecord= +ldrunpath= +ldscript= +ldstatic= +ldstrip= +Lflag= +lib_dll= +lib_all= +lib_undef= +libpath= +libpp= +makeoptions= +nmedit= +nmflags= +no_protect= +optimize= +plusplus= +prefix_archive=lib +prefix_dynamic= +prefix_shared=lib +ptrcopy= +ptrimplicit= +ptrmkdir= +readonly= +repository= +require= +runpath= +shared= +shared_name= +shared_registry= +shellmagic= +soversion= +stdc= +strict= +stripflags= +symprefix= +toucho= +warn= + +set $probe_lib +lib=$1 + +d= +for f in $stdinclude $usrinclude +do case $f in + -I*) ;; + *) d="$d $f" ;; + esac +done +stdinclude=$d + +set x $cc +cc_dir=`echo $2 | sed -e 's,/*[^/]*$,,'` +for c in $probe_ccs +do if $executable $cc_dir/$c + then x=$cc_dir/$c + else x=$c + fi + eval $c='$x' +done +ld_dir= +rm -f doti.$obj +if $cc -c doti.$src +then eval set x $probe_verbose + shift + for o + do $cc $o doti.$obj + $cc $o doti.$obj -lF0oB@r + done 2>&1 | sed -e 's/^[+ ]*//' -e 's/[ ].*//' -e '/^\//!d' -e 's/:$//' -e '/ld[a-zA-Z0-9.]*$/!d' -e 's,///*,/,g' > t + for i in `cat t` + do rm -f t.$obj + if test -x $i && $i -r -o t.$obj doti.$obj && test -f t.$obj + then case $ld in + ld) ld=$i ;; + esac + ld_dir=`echo $i | sed 's,/[^/]*$,,'` + break + fi + done +fi +IFS=: +set x $PATH +IFS=$ifs +path=$* +m= +for c in $probe_ccs +do eval o='$'$c + case $o in + $c) ;; + *) continue ;; + esac + C='${c}' + for x in $cc_dir $ld_dir + do cd $x + for p in "${C}" "${C}[!a-zA-Z]*" "*[!a-zA-Z]${C}" "*[!a-zA-Z]${C}[!a-zA-Z]*" + do eval set x $p + case $# in + 2) if $executable $2 + then case $2 in + *$c*$c*);; + *) m=$p + break 3 + ;; + esac + fi + ;; + esac + done + done +done +cd $tmpdir +for c in $probe_ccs +do eval o='$'$c + case $o in + $c) ;; + *) continue ;; + esac + for x in $cc_dir $ld_dir + do if $executable $x/$c + then eval $c='$x/$c' + continue 2 + fi + case $m in + ?*) eval set x $x/$m + case $# in + 2) if $executable $2 + then eval $c='$2' + continue 2 + fi + ;; + esac + ;; + esac + done + for x in $path + do if $executable $x/$c + then eval $c='$x/$c' + break + fi + done +done +dld=$cc + +rm -f dynamic.$exe +if $cc -o dynamic.$exe dynamic.$obj && $executable dynamic.$exe +then mkdir mylib + echo > mylib/libc.$lib + eval set x $probe_ldlib + while : + do shift + case $# in + 0) break ;; + esac + rm -f dynamic.$exe + if eval $1=./mylib '$'cc -o dynamic.$exe dynamic.$obj + then : + else libpath=$1 + break + fi + done +fi +test `$cc -E libpp.$src | grep -c '^#pragma pp:version "libpp '` -eq 1 && libpp=1 +$cc -E doti.$src > doti.i && $cc -c doti.i && test -s doti.$obj && doti=1 +if $cc -c imusr.$src +then eval set x $probe_include_local + while : + do shift + case $# in + 0) break ;; + esac + if $cc -c $1 imusr.$src + then : "$1 should skip \"_i_.h\" in ." + elif $cc -c imstd.$src + then if $cc -c -Iim imstd.$src + then : '-Idir should find <stdio.h> in dir' + elif $cc -c $1 -Iim imstd.$src + then : "$1 -Idir should find <stdio.h> in dir" + elif $cc -c -Iim $1 imstd.$src + then include_local=$1 + break + else : "-Idir $1 should skip <stdio.h> in dir" + fi + else : should find stdio.h + fi + done +else : 'should find "_i_.h" in .' +fi + +if $cc -c pic.$src 2>e +then e=`wc -l e` + s=`$size pic.$obj; wc pic.$obj` + eval set x $probe_pic + shift + while : + do case $# in + 0|1) break ;; + esac + pic=$1 + shift + PIC=$1 + shift + rm -f pic.$obj + $cc $pic -c pic.$src 2>e && test -f pic.$obj || continue + $cc $pic -o pic.$exe pic.$obj && test -f pic.$exe || { + rm -f pic.$exe + $cc -o pic.$exe pic.$obj && test -f pic.$exe && continue + } + case `wc -l e` in + $e) ;; + *) continue ;; + esac + case $pic in + ???*) m=`echo " $pic" | sed -e 's/^ [-+]//g' -e 's/./-& /g' -e 's/[-+] //g'` + rm -f pic.$obj pic1.$exe + if $cc $m -c pic.$src 2>e && test -f pic.$obj && + $cc -o pic1.$exe pic.$obj && test -f pic1.$exe + then case `wc -l e` in + $e) cc_pic=$m + break + ;; + esac + fi + cc_pic=$pic + break + ;; + *) case `$size pic.$obj; wc pic.$obj` in + $s) ;; + *) cc_pic=$pic + break + ;; + esac + ;; + esac + done + # this works around gcc 2.95 sun4 -fpic a.out core dump after exit + case $hosted:$cc_pic in + 1:?*) if ./pic.$exe + then # this catches lynxos.ppc gcc that dumps -fpic and not -mshared + echo 'static int* f() { static int v; return &v; } +int main() { f(); return 0; }' > picok.$src + $cc $cc_pic -o picok.$exe picok.$src && ./picok.$exe || cc_pic= + else cc_pic= + fi + ;; + esac + case $cc_pic in + ?*) rm -f pic.$obj + if $cc $PIC -c pic.$src 2>e && test -f pic.$obj + then cc_PIC=$PIC + else cc_PIC=$cc_pic + fi + ;; + *) eval set x $probe_dll + while : + do shift + case $# in + 0) break ;; + esac + rm -f pic.$obj pic.$exe + $cc $1 -c pic.$src 2>e && test -f pic.$obj || continue + $cc $1 -o pic.$exe pic.$obj && test -f pic.$exe || { + rm -f pic.$exe + $cc -o pic.$exe pic.$obj && test -f pic.$exe && continue + } + case $1 in + -Wc,*exportall*) + # get specific since sgi gets this far too + rm -f pic.$exe pic.x + $cc -Wl,dll -o pic.$exe pic.$obj || continue + test -f pic.$exe || continue + test -f pic.x || continue + cc_dll="-D_SHARE_EXT_VARS $1" + so=.x + sd=.dll + dld=$cc + shared=-Wl,dll + prefix_shared= + probe_sd= + probe_shared= + #unused# lddynamic=-Bdynamic + #unused# ldstatic=-Bstatic + lib_dll=SYMBOL + break + ;; + esac + case `wc -l e` in + $e) cc_dll=$1 + break + ;; + esac + done + ;; + esac +fi + +$cc -c plusplus.$src && plusplus=1 +$cc -E -dD dDflag.$src > t +case `grep '#define[ ][ ]*dDflag[ ][ ]*on' t` in +?*) dDflag=1 ;; +esac +case `grep '#define.*_GNUC_' t` in +?*) gnu=1 ;; +esac +case $plusplus in +"") $cc -c stdc.$src && stdc=1 ;; +*) mkdir ptr + cd ptr + $cc -c ../ptr.$src & + NFS_locks_are_botched=$! + cd .. + if $cc -c require.$src && $cc require.$obj + then set x `$cc require.$obj 2>&1` + d= + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + -l*) d="$d $1" ;; + esac + done + for f in ++ + do if $cc require.$obj -l$f + then set x `$cc require.$obj -l$f 2>&1` + r= + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + -l*) case " $d $r " in + *" "$1" "*) ;; + *) r="$r $1" ;; + esac + esac + done + case $r in + ?*) require="$require $f" + echo '' $r > req.$f + ;; + esac + fi + done + fi + cd ptr + for i in * + do if test -d $i + then repository=$i + break + fi + done + cd .. + kill -9 $NFS_locks_are_botched + rm -rf ptr + case $repository in + *?) mkdir ptr + cd ptr + i=PTR + case $repository in + $i) i=$i$i ;; + esac + $cc -ptr$i -c ../ptr.$src & + NFS_locks_are_botched=$! + cd .. + sleep 5 + if test -d ptr/$i/$repository + then ptrimplicit=1 + fi + kill -9 $NFS_locks_are_botched + rm -rf ptr + ;; + esac + $cc -o implc implc.$src && $executable implc && implicitc=1 + if $cc -c toucho.$src && test -f toucho.$obj + then o=`ls -l toucho.$obj` + if $cc -o toucho toucho.$obj && $executable toucho + then n=`ls -l touch.$obj` + case $n in + "$o") ;; + *) toucho=1 ;; + esac + fi + fi + ;; +esac + +if $cc -c pic.$src +then eval set x $probe_nmflags + while : + do shift + case $# in + 0) break ;; + esac + case `$nm $1 pic.$obj | grep -c '[0123456789][ ][ ]*T[ ][ ]*[_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]'` in + 0) ;; + *) nmflags=$1 + break + ;; + esac + done + case $# in + 0) case `$nm -gh pic.$obj | grep -c '|\.*[TtDdBbC][EeAaSsOo][XxTtSsMm]'` in + 0) ;; + *) nmflags=-gh + nmedit="-e '/\.*[TtDdBbC][EeAaSsOo][XxTtSsMm]/!d' -e 's/[| ].*//'" + ;; + esac + ;; + *) nmedit="-e '/[ ]T[ ][ ]*[_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]/!d' -e 's/.*[ ]T[ ][ ]*//'" + ;; + esac +fi + +if $cc -c doti.$src +then eval set x $probe_stripflags + while : + do shift + case $# in + 0) break ;; + esac + if $strip $1 doti.$obj + then stripflags=$1 + break + fi + done +fi + +rm -f export.$obj export.exe +if $cc -c export.$src +then lm= + if $cc -o export.exe export.$obj -lm 2>e && lm=-lm || + $cc -o export.exe export.$obj 2>e + then z=`wc -c < export.exe; $size export.exe 2>/dev/null` + eval set x $probe_export_dynamic + while : + do shift + case $# in + 0) break ;; + esac + rm -f export.exe + if $cc -o export.exe $1 export.$obj $lm 2>f && $executable export.exe + then y=`wc -c < export.exe; $size export.exe 2>/dev/null` + case $y in + $z) ;; + *) if cmp -s e f + then export_dynamic=$1 + break + fi + ;; + esac + fi + done + fi +fi +rm -f export.$obj export.exe + +rm -f strip.exe +if $cc -o strip.exe strip.$src +then z=`wc -c < strip.exe` + eval set x $probe_ldstrip + while : + do shift + case $# in + 0) break ;; + esac + rm -f strip.exe + if $cc -o strip.exe $1 strip.$src + then case `wc -c < strip.exe` in + $z) ;; + *) ldstrip=$1 + break + ;; + esac + fi + done +fi + +rm -f strip.exe strip.$obj +if $cc -c strip.$src && $cc -o strip.exe strip.$obj 2>e +then eval set x x $probe_ldlazy + while : + do shift + shift + case $# in + 0) break ;; + esac + rm -f strip.$exe + $cc -o strip.$exe $1 strip.$obj $2 2>f && test -f strip.$exe || continue + cmp -s e f || continue + ldlazy=$1 + ldnolazy=$2 + break + done + eval set x x $probe_ldrecord + while : + do shift + shift + case $# in + 0) break ;; + esac + rm -f strip.$exe + $cc -o strip.$exe $1 strip.$obj $2 2>f && test -f strip.$exe || continue + cmp -s e f || continue + ldrecord=$1 + ldnorecord=$2 + break + done +fi + +case $cc_dll:$cc_pic:$so:$dynamic:$static in +::::|$cc_dll_def::::) + : last chance dynamic checks + while : + do + echo '__declspec(dllexport) int fun() { return 0; }' > exp.$src + if $cc -c $cc_dll_def exp.$src + then rm -f xxx.dll xxx.lib + if $cc -shared -Wl,--enable-auto-image-base -Wl,--out-implib=xxx.lib -o xxx.dll exp.$obj && + test -f xxx.lib -a -f xxx.dll + then + : cygwin + cc_dll=$cc_dll_def + dll_dir='$(BINDIR)' + sd=.dll + so=.dll.a + ldscript=".def .exp .ign .res" + lib_dll=option + lib_all=-Wl,-whole-archive + lib_undef=-Wl,-no-whole-archive + dld=$cc + shared='-shared -Wl,--enable-auto-image-base -Wl,--out-implib=$(<:N=*'$so')' + prefix_dynamic=cyg + prefix_shared=lib + break + fi + fi + break + done + ;; +*) if $cc -c $cc_dll $cc_pic shared.$src && $cc -c $cc_dll $cc_pic notall.$src + then for xx in "$cc" "$ld" + do eval set x $probe_shared + while : + do shift + case $# in + 0) break ;; + esac + rm -f xxx$dll + # UNDENT ... + + if $xx $1 -o xxx$dll shared.$obj 2>e && test -r xxx$dll + then if test -s e && egrep -i 'unknown|invalid|option' e > /dev/null + then continue + fi + case `PATH=/bin:/usr/bin:$PATH file xxx$dll` in + *lib*|*obj*|*shared*) + ;; + "") $executable xxx$dll || continue + ;; + *ELF*|*elf*) + $executable xxx$dll || continue + case `strings xxx$dll | sed -e 's,.*[ |],,' | sort -u | egrep -i '^([._](dynamic|dynstr|dynsym))$'` in + [012]) continue ;; + esac + ;; + *archive*not*stripped*|*data*dynamic*not*stripped*) + $executable xxx$dll || continue + ;; + *) continue + ;; + esac + dld=$xx + shared=$1 + # does -nostartfiles make sense for C? + case $plusplus in + '') z=`wc -c < xxx$dll` + eval set x $probe_shared_nostart + while : + do shift + case $# in + 0) break ;; + esac + rm -f xxx$dll + if $dld $shared $1 -o xxx$dll shared.$obj 2>e && test -r xxx$dll + then case `wc -c < xxx$dll` in + $z) ;; + *) if test -s e + then case `cat e` in + *[Ee][Rr][Rr][Oo][Rr]*|*[Ww][Aa][Rr][Nn][Ii][Nn][Gg]*|*[Oo][Pp][Tt][Ii][Oo][Nn]*) + continue + ;; + esac + fi + case $shared in + '') shared=$1 ;; + *) shared="$shared $1" ;; + esac + break + ;; + esac + fi + done + ;; + esac + case $cc_dll in + "") cc_dll=$cc_dll_def ;; + esac + eval set x x $probe_sd + while : + do shift + shift + case $# in + [01]) break ;; + esac + rm -f xxx xxx$1 xxx$2 + if $dld $shared -o xxx shared.$obj 2>e + then if test -f xxx$1 -a \( -f xxx$2 -o "$cc_dll" = "$cc_dll_def" \) + then sd=$1 + so=$2 + lddynamic=-Bdynamic + ldstatic=-Bstatic + break 2 + elif test -f xxx -a -f xxx$2 + then sd=$1 + so=$2 + break 2 + else case $so in + '') so=$1 ;; + esac + break + fi + fi + done + rm -f libxxx.$lib + $ar cr libxxx.$lib shared.$obj + ranlib libxxx.$lib + eval set x x $probe_lib_all_undef + rm -f xxx$dll + if $dld $shared -o xxx$dll libxxx.$lib && test -r xxx$dll + then if $nm $nmflags xxx$dll | grep ShareD + then lib_dll=OPTION + set x x + fi + fi + while : + do shift + shift + case $# in + 0|1) break ;; + esac + rm -f xxx$dll + if $dld $shared -o xxx$dll $1 libxxx.$lib $2 && test -r xxx$dll + then if $nm $nmflags xxx$dll | grep ShareD + then lib_dll=option + lib_all=$1 + lib_undef=$2 + break + fi + fi + case $2 in + ?*) if $dld $shared -o xxx$dll $1 libxxx.$lib && test -r xxx$dll + then if $nm $nmflags xxx$dll | grep ShareD + then lib_dll=option + lib_all=$1 + break + fi + fi + ;; + esac + done + case $lib_dll in + OPTION) lib_dll=option + ;; + option) case $lib_undef in + "") rm -f libyyy.$lib + $ar cr libyyy.$lib notall.$obj + ranlib libyyy.$lib + $cc -c prefix.$src + eval set x x $probe_lib_all_undef + while : + do shift + shift + case $# in + 0|1) break ;; + esac + rm -f xxx$dll + if $dld $shared -o xxx$dll prefix.$obj $lib_all libxxx.$lib $2 libyyy.$lib && test -r xxx$dll + then rm -f t + $nm $nmflags xxx$dll > t + case `grep -c ShareD t`:`grep -c NotalL t` in + 0:*) ;; + *:0) lib_undef=$2 + break + ;; + esac + fi + done + ;; + esac + case $lib_undef in + "") eval set x $probe_lib_multiple + rm -f libyyy.$lib + cp libxxx.$lib libyyy.$lib + rm -f xxx$dll + if $dld $shared -o xxx$dll prefix.$obj $lib_all libxxx.$lib libyyy.$lib && test -r xxx$dll + then : + else while : + do shift + case $# in + 0) break ;; + esac + rm -f xxx$dll + if $dld $shared -o xxx$dll prefix.$obj $lib_all $1 libxxx.$lib libyyy.$lib && test -r xxx$dll + then rm -f t + $nm $nmflags xxx$dll > t + case `grep -c ShareD t` in + 0) ;; + *) lib_all="$lib_all $1" + break + ;; + esac + fi + done + fi + lib_dll=symbol + ;; + esac + ;; + *) lib_dll=symbol + ;; + esac + case `cat e` in + ?*) eval set x $probe_unresolved + while : + do shift + case $# in + 0) break ;; + esac + rm -f xxx$dll + if eval '$dld $shared' $1 '-o xxx$dll shared.$obj 2>e && test -r xxx$dll' + then case `cat e` in + "") shared="$shared $1"; break ;; + esac + fi + done + ;; + esac + r= + eval set x $probe_shared_registry + while : + do shift + r=x$r + case $# in + 0) break ;; + esac + rm -f xxx$dll + if eval \$dld \$shared -o xxx\$dll $1 shared.\$obj && + test -r xxx$dll -a -r $probe_shared_registry_file + then probe_shared_registry_file='$(CC.SHARED.REGISTRY.PATH)' + eval set x $probe_shared_registry + i= + while : + do shift + i=x$i + case $i in + $r) break ;; + esac + done + shared_registry=$1 + fi + done + break 2 + fi + + # ... INDENT + done + done + fi + case $so in + ?*) rm -f xxx* + if $dld $shared -g -o xxx shared.$obj 2>e + then set x $probe_sdb + while : + do shift + case $1 in + 0) break ;; + esac + if test -f xxx$1 + then sdb=$1 + break + fi + done + fi + if $cc -c require.$src + then p=' +/usr/proberun/lib:/local/runprobe/lib +' + eval set x $probe_ldrunpath + while : + do shift + case $# in + 0) break ;; + esac + rm -f require.exe + if $cc -o require.exe $1"$p" require.$obj && + grep -c /proberun/ require.exe >/dev/null && + grep -c /runprobe/ require.exe > /dev/null + then ldrunpath=$1 + eval set x $probe_ldorigin + while : + do shift + case $# in + 0) break ;; + esac + rm -f origin.exe + if $cc -o origin.exe $1 $ldrunpath'$ORIGIN' require.$obj + then if ./origin.exe > /dev/null 2>&1 + then ldorigin="$1 $ldrunpath"'\$ORIGIN/$(BINDIR:P=R=$(DLLDIR))' + fi + break + fi + done + break + fi + done + fi + rm -f libxxx$so + if $cc -c sovmain.$src && + $cc -c $cc_dll $cc_pic sovlib.c && + $dld $shared -o libxxx$so sovlib.$obj && + $cc -o sovmain.$exe -L. sovmain.$obj -lxxx + then rm -f sovmain.$exe + mv libxxx$so libxxx$so.5.6 + if $cc -o sovmain.$exe -L. sovmain.$obj -lxxx + then soversion=1 + fi + fi + rm -f doti.$obj + std64=/lib64 + lcl64=/usr/local/lib64 + if test -d $std64 -a -d $lcl64 && $cc -c doti.$src + then for i in `cd $lcl64; ls *$so 2>/dev/null | sed 's/lib\([^.]*\).*/\1/'` + do if $cc -o runpath.$exe doti.$obj -l$i >/dev/null 2>&1 + then LD_LIBRARY_PATH= ./runpath.$exe >/dev/null 2>&1 && continue + if LD_LIBRARY_PATH=$lcl64 ./runpath.$exe >/dev/null 2>&1 + then runpath=$lcl64 + break + elif LD_LIBRARY_PATH=$std64 ./runpath.$exe >/dev/null 2>&1 + then runpath=$std64 + break + elif LD_LIBRARY_PATH=$lcl64:$std64 ./runpath.$exe >/dev/null 2>&1 + then runpath=$lcl64:$std64 + break + fi + fi + done + fi + ;; + esac + ;; +esac + +rm -f shared.$obj +if $cc -c shared.$src +then eval set x $probe_ar_arflags + while : + do shift + case $# in + 0) break ;; + esac + rm -f libxxx.$lib + if $ar $1 r libxxx.$lib shared.$obj && $ar $1 t libxxx.$lib 2>&1 | grep shared.$obj >/dev/null + then ar_arflags=$1 + break + fi + done + eval set x $probe_arflags + while : + do shift + case $# in + 0) break ;; + esac + rm -f libxxx.$lib + if $cc $1 -o libxxx.$lib shared.$obj && $ar t libxxx.$lib 2>&1 | grep shared.$obj >/dev/null + then arflags=$1 + break + fi + done +fi + +case $shared in +-G) case $cc_dll in + "") cc_dll=$cc_dll_def ;; + esac + ;; +*) case $lib_dll in + symbol) echo 'extern int f(); + int main() { f(); return 0; }' > main.$src + echo '#include <stdio.h> + int f() { printf("hello world"); return 0; }' > member.$src + if $cc -c main.$src && $cc -c member.$src + then echo f > lib.exp + rm -f lib.$obj main.exe + if $ld -o lib.$obj -L: -bexport:lib.exp -berok -bmodtype:SRE -T512 -H512 -lm -lc member.$obj && $cc -o main.exe main.$obj lib.$obj + then dld=$ld + shared='-T512 -H512 -L$(LIBDIR): -berok -bmodtype:SRE' + lib_dll=export + dll_libraries='-lm -lc' + ldscript=.exp + case $cc_dll in + "") cc_dll=$cc_dll_def ;; + esac + case $so in + "") so=.$obj ;; + esac + fi + fi + ;; + esac + ;; +esac +case $shared in +?*) if $cc -c $cc_dll $cc_pic shared.$src + then eval set x $probe_shared_name + while : + do shift + case $# in + 0) break ;; + esac + rm -f xxx$dll + if $dld $shared ${1}libfoo.1.2 -o xxx$dll shared.$obj 2>e && test -r xxx$dll + then shared_name=$1 + break + fi + done + fi + ;; +esac +case " $cc_dll " in +*" $cc_dll_def "*) + ;; +" ") ;; +*) cc_dll="$cc_dll_def $cc_dll" + ;; +esac + +case $hosttype in +win32.*|cygwin.*|os2.*) + Lflag=1 + ;; +*) if $cc -c doti.$src + then if $cc -L. doti.$obj -lc >/dev/null + then case $cc_dll in + '') ;; + *) Lflag=1 ;; + esac + fi + fi + ;; +esac + +case $lib_dll in +option) case $hosttype in + linux.*) dll_libraries=-lc ;; + esac + ;; +SYMBOL) lib_dll=symbol + ;; +symbol) echo "#include <stdio.h> +extern int fun() +{ + puts(\"fun\"); + return 0; +}" > dllib.$src + echo "extern int fun(); +int +main() +{ + return fun(); +}" > dlmain.$src + pwd=`pwd` + while : + do + if $cc -c $cc_dll $cc_pic dlmain.$src && + $cc -c $cc_dll $cc_pic dllib.$src + then rm -f libxxx$so + if $dld $shared -o libxxx$so dllib.$obj && + chmod 555 libxxx$so + then rm -f dlmain.$exe + if $cc -o dlmain.$exe dlmain.$obj $pwd/libxxx$so && + (./dlmain.$exe) >/dev/null 2>&1 + then break + fi + fi + rm -f libxxx$so dlmain.$exe + if $dld $shared -o libxxx$so dllib.$obj -lm -lc && + chmod 555 libxxx$so && + $cc -o dlmain.$exe dlmain.$obj $pwd/libxxx$so && + (./dlmain.$exe) >/dev/null 2>&1 + then dll_libraries='-lm -lc' + fi + fi + break + done + # the dll_libraries probe is still lame + case $dll_libraries in + '') case $hosttype in + sco.*|sol*.*|sun*) ;; + *) dll_libraries='-lm -lc' ;; + esac + ;; + esac + ;; +esac + +stdlib= +a=`$cc -print-multi-directory 2>/dev/null` +case $a in +.) ;; +*) for d in `$cc -print-search-dirs 2>/dev/null | sed -e '/^libraries:/!d' -e 's/.*=//' | tr : '\n' | grep /lib/` + do if [ -d ${d}${a} ] + then stdlib="$stdlib ${d}${a}" + else case $d in + */lib/) d=`echo '' $d | sed -e 's,/$,,'` + if [ -d ${d}${a} ] + then stdlib="$stdlib ${d}${a}" + fi + ;; + esac + fi + done + ;; +esac +case $stdlib in +'') stdlib=`$cc -v doti.$src 2>&1 | + sed 's/ */\n/g' | + sed -e '/^-L/!d' -e 's/^-L//' | + while read dir + do if test -d "$dir" + then (cd "$dir"; pwd) + fi + done` + ;; +*) eval set x $probe_verbose + shift + for o in "$@" + do stdlib="$stdlib "`$cc $o doti.$src 2>&1 | + sed 's/ */\n/g' | + sed -e '/^-L/!d' -e '/\/lib64$/!d' -e 's/^-L//'` + done + ;; +esac +case $stdlib in +?*) keepstdlib=1 + o=$stdlib + stdlib= + for dir in $o + do case " $stdlib " in + *" $o "*) continue ;; + esac + case $dir in + /usr/lib64) + i=/usr/local/lib64 + a=/lib64 + ;; + /lib64) i=/usr/local/lib64 + a=/usr/lib64 + ;; + /usr/lib) + i=/usr/local/lib + a=/lib + ;; + lib) i=/usr/local/lib + a=/usr/lib + ;; + *) i= + a= + ;; + esac + if test "" != "$i" -a -d "$i" + then case " $o " in + *" $i "*) + ;; + *) stdlib="$stdlib $i" + ;; + esac + fi + stdlib="$stdlib $dir" + if test "" != "$a" -a -d "$a" + then case " $o " in + *" $a "*) + ;; + *) stdlib="$stdlib $a" + ;; + esac + fi + done + case $hosted in + 1) case " $stdlib " in + *" /usr/lib "*) + ;; + *) case " $stdlib " in + *" /usr/local/lib "*) + ;; + *) stdlib="$stdlib /usr/local/lib" + ;; + esac + stdlib="$stdlib /usr/lib" + ;; + esac + case " $stdlib " in + *" /lib "*) + ;; + *) stdlib="$stdlib /lib" + ;; + esac + esac + ;; +*) keepstdlib=0 + case $dir in + */arch/$hosttype/lib/*) + notlib=`echo $dir | sed "s,/arch/$hosttype/lib/.*,/arch/$hosttype/lib,"` + ;; + *) notlib=//// + ;; + esac + tstlib= + implib= + if $cc -c hosted.$src + then for f in `( + eval set x $probe_verbose + while : + do shift + case $# in + 0) break ;; + esac + $cc $1 hosted.$obj + done + ) 2>&1 | sed -e 's/[ :]/\\ + /g' -e 's/-L//g' -e 's/^P,//' -e "s/[\"']//g" -e 's,^[\\\\/]*[\\\\/],/,' | sed -e '/^\$/d' -e '/^[-+]/d' -e '/^[^\\\\\\/]/d' -e '/[\\\\\\/]tmp[\\\\\\/]/d' -e 's/:\$//' -e 's,//*$,,'` + do case " $tstlib $implib " in + *" $f "*) continue ;; + esac + case $f in + $notlib) continue ;; + esac + if test -d $f + then tstlib="$tstlib $f" + elif test -f $f + then d=`echo $f | sed -e 's,[\\\\/]*[^\\\\/]*\$,,'` + case " $tstlib $implib " in + *" $d "*) continue ;; + esac + case $d in + *[\\/]usr[\\/]lib) + x=$d + d="`echo $d | sed -e 's,[\\\\/][\\\\/]*usr[\\\\/]lib\$,/lib,'`" + case " $tstlib $implib " in + *" $d "*) ;; + *) implib="$implib $d" ;; + esac + implib="$implib $x" + ;; + *[\\/]lib) + implib="$implib $d" + d="`echo $d | sed -e 's,[\\\\/][\\\\/]*lib\$,/usr/lib,'`" + case " $tstlib $implib " in + *" $d "*) ;; + *) implib="$implib $d" ;; + esac + ;; + *) implib="$implib $d" + ;; + esac + fi + done + fi + tstlib="$tstlib $implib" + if $cc -Dtype=void -Dcall=exit -c tstlib.$src && mv tstlib.$obj tst.$obj + then case $plusplus in + '') probe_lxx= ;; + esac + l= + for sym in $probe_l $probe_lxx + do case $l in + "") l=$sym; continue ;; + esac + rm -f tstlib.$exe + if $cc -o tstlib.$exe tst.$obj -l$l + then eval set x $probe_ldmap + while : + do shift + case $# in + 0) break ;; + esac + d=`$cc -Dtype=int -Dcall=$sym $static $1 tstlib.$src -l$l 2>&1 | sed -e '/[\\\\\\/].*[\\\\\\/]lib[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+]*\.[^\\\\\\/]*\$/!d' -e 's,^[^\\\\\/]*,,' -e 's,[\\\\\\/]lib[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+]*\.[^\\\\\\/]*\$,,' -e '/^[\\\\\\/]/!d' | sort -u` + case $d in + ?*) tstlib="$tstlib $d" ;; + esac + done + fi + l= + done + fi + libstd= + libset= + stdlibroot="/ /usr/" + for d in $tstlib + do case $d in + [\\/]lib|[\\/]usr[\\/]lib) + ;; + *) case " $stdlib " in + *\ $d\ *) + ;; + *) if ls $d ${PREROOT+$PREROOT/../$d} > tmp.tmp && test -s tmp.tmp + then for i in $probe_lib $obj + do if grep -i "\\.$i\$" tmp.tmp >/dev/null + then case " $probe_lib_append " in + *\ $d\ *) + libstd="$libstd $d" + ;; + *) stdlib="$stdlib $d" + case $d in + /usr/lib|/usr/lib/*) + ;; + /usr/lib?*) + e=`echo $d | sed -e 's,/usr,,'` + g=`echo $d/libc.* $e/libc.*` + case "$e $g " in + *".* "*);; + *) stdlib="$stdlib $e" + stdlibroot= + ;; + esac + ;; + esac + ;; + esac + case $libset in + "") case $i in + $obj) ;; + *) libset=1 + lib=$i + ;; + esac + ;; + esac + break + fi + done + fi + ;; + esac + ;; + esac + done + for d in `$ld --verbose 2>&1 | sed -e '/SEARCH_DIR/!d' -e 's/[ ][ ][ ]*/ /g' -e 's/SEARCH_DIR(\([^ ]*\));/\1/g' -e 's, //[^ ]*,,' -e 's,",,g'` + do if test -d $d + then case " $stdlib $libstd " in + *\ ${d}\ *) + ;; + *) libstd="$libstd $d" + ;; + esac + fi + done + case $hosted in + "") tstlib= ;; + *) tstlib="$stdlibroot /usr/ccs/ /usr/local/" ;; + esac + case $stdlibroot in + ?*) d= + for f in $stdinclude + do f=`echo $f | sed -e 's,[^\\\\/]*\$,,'` + d="$d $f" + done + tstlib="$d $tstlib" + ;; + esac + $cc -c doti.$src > all.tmp + for f in $probe_libdir + do for d in $stdlib $libstd $tstlib + do if test -d ${d}${f} + then ls ${d}${f} ${PREROOT:+$PREROOT/../${d}${f}} | + while read i + do for j in ${d}${f}/${i} ${PREROOT:+$PREROOT/../${d}${f}/${i}} + do if test -f $j -a -r $j -a -s $j + then echo $i + break + fi + done + done > tmp.tmp + if test -s tmp.tmp + then if egrep -i "^${prefix_archive}[abcdefghijklmnopqrstuvwxyz0123456789_][abcdefghijklmnopqrstuvwxyz0123456789_]*\\.$lib\$" tmp.tmp >lib.tmp || + egrep -i "\\.$obj\$" tmp.tmp >/dev/null || + egrep -i "^${prefix_shared}[abcdefghijklmnopqrstuvwxyz0123456789_][abcdefghijklmnopqrstuvwxyz0123456789_]*\\$so(.[0-9]+)*\$" tmp.tmp >>lib.tmp + then if test -s lib.tmp + then sed -e "s,.*/,," -e 's,^'${prefix_archive}'\(.*\)\.'$lib'$,\1,g' -e 's,^'${prefix_shared}'\(.*\)\'$so'[.0-9]*,\1,g' lib.tmp | sort -u > tmp.tmp + xs=`sort all.tmp all.tmp tmp.tmp | uniq -u` + case $xs in + '') continue ;; + esac + ok=0 + for x in $xs + do case $x in + *_p) continue ;; # linux gcc known to hang for -lc_p + esac + if $cc -o doti.$exe doti.$obj -l$x 2>e + then ok=1 + else if test -s e && egrep -i ":.*[ ](find|found|locate|search|-l$x)[ ]" e > /dev/null + then if egrep -i ":.*[ ](access|permission)[ ]" e + then : maybe + else ok=0 + break + fi + fi + case $Lflag in + 1) if $cc -L${d}${f} -o doti.$exe doti.$obj -l$x + then ok=0 + break + fi + ;; + esac + fi + done + case $ok in + 0) continue ;; + esac + sort -u all.tmp tmp.tmp > lib.tmp + mv lib.tmp all.tmp + fi + case " $stdlib $libstd " in + *" ${d}${f} "*) + ;; + *) if test -d ${d}${f}/fsoft + then stdlib="$stdlib ${d}${f}/"'$(FLOAT_OPTION)' + fi + stdlib="$stdlib ${d}${f}" + ;; + esac + fi + fi + fi + done + done + stdlib="$stdlib $libstd" + case $stdlib in + */shlib*) + dy= + st= + for i in $stdlib $libstd + do case $i in + */shlib) dy="$dy $i" ;; + *) st="$st $i" ;; + esac + done + for i in /var + do if test -d $i/shlib + then dy="$dy $i/shlib" + fi + done + stdlib="$dy $st" + ;; + esac + ;; +esac + +if $cc -c prefix.$src +then eval set x $probe_symprefix + while : + do shift + case $# in + 0) break ;; + esac + if $nm $nmflags prefix.$obj | grep -c ${1}prefix >/dev/null + then symprefix=$1 + break + fi + done +fi + +if $cc -c warn.$src 2>e && test -f warn.$obj +then e=`wc -c < e` + + eval set x $probe_debug + while : + do shift + case $# in + 0) break ;; + esac + rm -f warn.$obj + $cc $1 -c warn.$src 2>e && test -f warn.$obj || continue + case `wc -c < e` in + $e) debug=$1; break ;; + esac + done + + eval set x $probe_no_protect + while : + do shift + case $# in + 0) break ;; + esac + rm -f warn.$obj + $cc $1 -c warn.$src 2>e && test -f warn.$obj || continue + case `wc -c < e` in + $e) no_protect=$1; break ;; + esac + done + + case $version_string in + $probe_gcc_version) probe_optimize="$probe_gcc_optimize $probe_optimize" ;; + esac + eval set x $probe_optimize + while : + do shift + case $# in + 0) break ;; + esac + rm -f warn.$obj + $cc $1 -c warn.$src 2>e && test -f warn.$obj || continue + case `wc -c < e` in + $e) optimize=$1; break ;; + esac + done + + eval set x $probe_strict + while : + do shift + case $# in + 0) break ;; + esac + rm -f warn.$obj + $cc $1 -c warn.$src 2>e && test -f warn.$obj || continue + n=`wc -c < e` + if test $n -ge $e + then strict=$1 + break + fi + done + + $cc -c warn1.$src 2>e + o=`wc -c < e` + eval set x $probe_warn + while : + do shift + case $# in + 0) break ;; + esac + rm -f warn.$obj warn.$exe + $cc -o warn.$exe $1 warn.$src 2>e && test -f warn.$exe || continue + n=`wc -c < e` + for i in $warn_enum + do rm -f warn$i.$obj + $cc -c $1 warn$i.$src 2>e && test -f warn$i.$obj || continue + n=`wc -c < e` + if test $n -gt $o + then warn=$1 + break 2 + fi + done + done + +fi + +while : +do case $hosted in + 1) rm -f readonly.$exe + eval set x '""' $probe_readonly + while : + do shift + case $# in + 0) break ;; + esac + for co in '' -Dtest_const + do rm -f readonly.$exe + if $cc -o readonly.$exe $co $1 readonly.$src && $executable readonly.$exe + then if ./readonly.$exe >/dev/null 2>&1 + then : + else readonly=$1 + break 3 + fi + fi + done + done + rm -f readonly.$exe readonly.s + if $cc -S readonly.$src && test -f readonly.s + then if sed -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)data/\1text/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)zero[ ][ ]*/\1set .,.+/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*1/\1byte 0/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*2/\1byte 0,0/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*3/\1byte 0,0,0/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*4/\1byte 0,0,0,0/' \ + readonly.s > ro.s && $cc -o readonly.$exe ro.s && $executable readonly.$exe + then if ./readonly.$exe >/dev/null 2>&1 + then : + else readonly='-S.data' + break + fi + fi + rm -f readonly.$exe + if sed -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)idat/\1code/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)zero[ ][ ]*/\1set .,.+/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*1/\1byte 0/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*2/\1byte 0,0/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*3/\1byte 0,0,0/' \ + -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)space[ ][ ]*4/\1byte 0,0,0,0/' \ + readonly.s > ro.s && $cc -o readonly.$exe ro.s && $executable readonly.$exe + then if ./readonly.$exe >/dev/null 2>&1 + then : + else readonly='-S.idat' + break + fi + fi + if sed -e 's/^\([ ]*[.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$:]*[ ]*\.*\)data/\1rdata/' \ + readonly.s > ro.s && $cc -o readonly.$exe ro.s && $executable readonly.$exe + then if ./readonly.$exe >/dev/null 2>&1 + then : + else readonly='-S.rdata' + break + fi + fi + fi + ;; + esac + break +done + +case $stdc in +?*) dialect="$dialect ANSI" ;; +esac +case $plusplus in +?*) dialect="$dialect C++" ;; +esac +case $hosted in +"") dialect="$dialect CROSS" ;; +esac +case $doti in +?*) dialect="$dialect DOTI" ;; +esac +case $gnu in +?*) dialect="$dialect GNU" ;; +esac +case $so:$dynamic:$static in +::) ;; +*) dialect="$dialect DYNAMIC" + case $soversion in + ?*) dialect="$dialect VERSION" ;; + esac + ;; +esac +case $implicitc in +?*) dialect="$dialect IMPLICITC" ;; +esac +case $ptrcopy in +?*) dialect="$dialect PTRCOPY" ;; +esac +case $ptrimplicit in +?*) dialect="$dialect PTRIMPLICIT" ;; +esac +case $ptrmkdir in +?*) dialect="$dialect PTRMKDIR" ;; +esac +case $libpp in +?*) dialect="$dialect LIBPP" ;; +esac +case $toucho in +?*) dialect="$dialect TOUCHO" ;; +esac +case $dDflag in +?*) dialect="$dialect -dD" ;; +esac +# 2005-05-25 use $(CC.INCLUDE.LOCAL) instead +case $include_local in +?*) dialect="$dialect -I-" ;; +esac +case $Lflag in +?*) dialect="$dialect -L" ;; +esac + +ppcmd='$(CPP)' +ppdir='$(CPP:D)' +eval ppopt='"'$ppopt'"' +eval ppenv='"'$ppenv'"' + +set x "" .$exe +shift +exe= +for i +do rm -f require$i +done +if $cc -o require require.$src +then for i + do if $executable require$i + then exe=$i + break + fi + done +fi +case $sa:$sd:$so in +::?*) eval set x $probe_sa + while : + do shift + case $# in + 0) break ;; + esac + for i in $stdlib + do eval j="'" $i/lib*$1 "'" + case $j in + " $i/lib*$1 ") + eval j="'" $i/lib*$1.[0123456789]* "'" + case $j in + " $i/lib*$1.[0123456789]* ") + continue + ;; + esac + ;; + esac + sa=$1 + lddynamic=-Bdynamic + ldstatic=-Bstatic + break 2 + done + done + ;; +esac +case $ldscript in +"") case $so in + .lib) ldscript=".def .exp" ;; + *) ldscript=".ld" ;; + esac + ;; +esac +case $hosttype in +'') hosttype=unknown ;; +sgi.mips3) dll_variants='sgi.mips2:o32:-mips2 sgi.mips4:64:-mips4' ;; +sgi.mips4) dll_variants='sgi.mips2:o32:-mips2 sgi.mips3:n32:-mips3' ;; +esac + +case $hosted in +"") ccnative=`echo $cc | sed -e 's,.*/,,'` + ccs=$ccnative + for c in cc gcc + do case " $ccs " in + *" $c "*) ;; + *) ccs="$ccs $c" ;; + esac + done + for p in $path + do for c in $ccs + do if $executable $p/$c + then rm -f native.$exe + if $p/$c -o native.$exe doti.$src && ./native.$exe + then ccnative=$p/$c + exectype=`package CC="$ccnative" || $SHELL -c "package CC='$ccnative'"` + case $exectype in + *[Uu][Ss][Aa][Gg][Ee]:*) + exectype=`PATH=$_probe_PATH; export PATH; package CC="$ccnative" || $SHELL -c "package CC='$ccnative'"` + ;; + esac + break 2 + fi + fi + done + done + ;; +*) ccnative=$cc + exectype=$hosttype + ;; +esac + +# runtime shared lib exported symbol resolution + +case $cc_dll:$shared in +:|:*|*:);; +*) cat > cmd.c <<'!' +#include <stdio.h> +#include <dlfcn.h> +typedef int (*Lib_f)(int**, int**, int**); +int gbl_def = 1; +int gbl_ref = 1; +int gbl_ext; +int main(int argc, char** argv) +{ + void* dll; + Lib_f lib; + int* def; + int* ref; + int* ext; + + if (!(dll = dlopen(*++argv, RTLD_LAZY))) + fprintf(stderr, "library not found\n"); + else if (!((lib = (Lib_f)dlsym(dll, "lib"))) && !(lib = (Lib_f)dlsym(dll, "_lib"))) + fprintf(stderr, "symbol not found\n"); + else if ((*lib)(&def, &ref, &ext)) + fprintf(stderr, "function failed\n"); + else if (def == &gbl_def && ref == &gbl_ref && ext == &gbl_ext) + printf("ALL\n"); + else if (ref == &gbl_ref && ext == &gbl_ext) + printf("REF\n"); + else if (ext == &gbl_ext) + printf("EXT\n"); + return 0; +} +! + cat > lib.c <<'!' +int gbl_def = 1; +int gbl_ref; +int gbl_ext; +int lib(int** def, int** ref, int** ext) +{ + *def = &gbl_def; + *ref = &gbl_ref; + *ext = &gbl_ext; + return 0; +} +! + if $cc -c $cc_dll $cc_pic cmd.c && + $cc -c $cc_dll $cc_pic lib.c && { + $cc $cc_dll $export_dynamic -o cmd.exe cmd.o || + $cc $cc_dll $export_dynamic -o cmd.exe cmd.o -ldl + } && + $dld $shared -o libgbl.dll lib.o + then x=`./cmd.exe ./libgbl.dll` + case $x in + ?*) dialect="$dialect EXPORT=$x" ;; + esac + else case $sd:$hosttype in + .dll:*win*) dialect="$dialect EXPORT=DLL" ;; + esac + fi + ;; +esac + +# shellmagic defined if installed shell scripts need magic + +echo ': got magic : +echo ok' > ok +chmod +x ok +case `(eval ./ok | /bin/sh) 2>/dev/null` in +ok) ;; +*) echo '#!/bin/env sh +: got magic : +echo ok' > ok + chmod +x ok + case `(eval ./ok | /bin/sh) 2>/dev/null` in + ok) shellmagic='$("#")!/bin/env sh' + ;; + *) for i in /emx/bin/bash.exe /emx/bin/sh.exe + do if test -x $i + then shellmagic='$("#")!'$i + break + fi + done + ;; + esac + ;; +esac + +# +# path cleanup +# + +for i in ar ccnative dld ld nm size stdinclude stdlib strip +do eval o='$'$i + v=$o + case $v in + *//*) v=`echo $v | sed 's,///*,/,g'` ;; + esac + if (test . -ef "`pwd`") + then k= + for x in $v + do case $x in + */../*|*/..) + case $x in + /*) a=/ ;; + *) a= ;; + esac + IFS=/ + set '' $x + IFS=$ifs + r= + for d + do r="$d $r" + done + p= + g= + for d in $r + do case $d in + ..) g="$g $d" ;; + *) case $g in + '') case $p in + '') p=$d ;; + *) p=$d/$p ;; + esac + ;; + *) set $g + shift + g=$* + ;; + esac + ;; + esac + done + case $a in + '') for d in $g + do p=$d/$p + done + ;; + *) p=$a$p + ;; + esac + case $p in + /) continue ;; + esac + test $x -ef $p && x=$p + ;; + esac + k="$k $x" + done + set '' $k + shift + v=$1 + case $# in + 0) ;; + *) shift + while : + do case $# in + 0) break ;; + esac + k= + for d + do for j in $v + do test $d -ef $j && continue 2 + done + k="$k $d" + done + set '' $k + case $# in + 1) break ;; + esac + shift + v="$v $1" + shift + done + ;; + esac + fi + case $v in + $o) ;; + *) eval $i='$'v ;; + esac +done + +case $keepstdlib in +1) ;; +*) # + # favor lib64 over lib + # + case $hosttype in + *64|*[!0-9]64[!a-zA-Z0-9]*) + o=$stdlib + stdlib= + for i in $o + do case " $stdlib " in + *" $i "*) + continue + ;; + esac + case $i in + *64) stdlib="$stdlib $i" + continue + ;; + esac + case " $o " in + *" ${i}64 "*) + case " $stdlib " in + *" ${i}64 "*) + ;; + *) stdlib="$stdlib ${i}64" + ;; + esac + ;; + esac + stdlib="$stdlib $i" + done + ;; + esac + ;; +esac + +# +# set up for local override +# + +CC_VERSION_STAMP=$version_stamp +CC_VERSION_STRING=$version_string +CC_CC=$cc +CC_NATIVE=$ccnative +CC_EXECTYPE=$exectype +CC_HOSTTYPE=$hosttype +CC_ALTPP_FLAGS=$ppopt +CC_ALTPP_ENV=$ppenv +CC_AR=$ar +CC_AR_ARFLAGS=$ar_arflags +CC_ARFLAGS=$arflags +CC_DEBUG=$debug +CC_DIALECT=$dialect +CC_PICBIG=$cc_PIC +CC_PICSMALL=$cc_pic +CC_PIC=$CC_PICBIG +CC_DLL_ONLY=$cc_dll +case $CC_DLL_ONLY in +'') CC_DLLBIG= + CC_DLLSMALL= + CC_DLL= + ;; +*) CC_DLLBIG="$CC_DLL_ONLY $CC_PICBIG" + CC_DLLSMALL="$CC_DLL_ONLY $CC_PICSMALL" + CC_DLL="$CC_DLL_ONLY $CC_PICBIG" + ;; +esac +CC_DLL_DIR=$dll_dir +CC_DLL_LIBRARIES=$dll_libraries +CC_DLL_VARIANTS=$dll_variants +CC_DYNAMIC=$dynamic +CC_EXPORT_DYNAMIC=$export_dynamic +CC_INCLUDE_LOCAL=$include_local +CC_LD=$ld +CC_LD_DYNAMIC=$lddynamic +CC_LD_LAZY=$ldlazy +CC_LD_NOLAZY=$ldnolazy +CC_LD_ORIGIN=$ldorigin +CC_LD_RECORD=$ldrecord +CC_LD_NORECORD=$ldnorecord +CC_LD_RUNPATH=$ldrunpath +CC_LD_STATIC=$ldstatic +CC_LD_STRIP=$ldstrip +CC_LIB_DLL=$lib_dll +CC_LIB_ALL=$lib_all +CC_LIB_UNDEF=$lib_undef +CC_MAKE_OPTIONS=$makeoptions +CC_NM=$nm +CC_NMEDIT=$nmedit +CC_NMFLAGS=$nmflags +CC_NOPROTECT=$no_protect +CC_OPTIMIZE=$optimize +CC_READONLY=$readonly +CC_REPOSITORY=$repository +CC_REQUIRE=$require +CC_RUNPATH=$runpath +CC_SHARED=$shared +CC_SHARED_LD=$dld +CC_SHARED_NAME=$shared_name +CC_SHARED_REGISTRY=$shared_registry +CC_SHARED_REGISTRY_PATH=$probe_shared_registry_path +CC_SHELLMAGIC=$shellmagic +CC_SIZE=$size +CC_STATIC=$static +CC_STDINCLUDE=$stdinclude +CC_STDLIB=$stdlib +CC_STRICT=$strict +CC_STRIP=$strip +CC_STRIP_FLAGS=$stripflags +CC_PREFIX_ARCHIVE=$prefix_archive +CC_PREFIX_DYNAMIC=$prefix_dynamic +CC_PREFIX_SHARED=$prefix_shared +CC_PREFIX_SYMBOL=$symprefix +CC_SUFFIX_ARCHIVE=.$lib +CC_SUFFIX_COMMAND=$suffix_command +CC_SUFFIX_DEBUG=$sdb +CC_SUFFIX_DYNAMIC=$sd +CC_SUFFIX_LD=$ldscript +CC_SUFFIX_OBJECT=.$obj +CC_SUFFIX_SHARED=$so +CC_SUFFIX_SOURCE=.$src +CC_SUFFIX_STATIC=$sa +CC_VERSION=$version_flags +CC_WARN=$warn +CC_ATTRIBUTES=$ATTRIBUTES + +exec >&3 + +# +# check for local override +# all CC_* but { CC_CC CC_VERSION_STAMP CC_VERSION_STRING } may be modified +# additional CC.* may be printed on stdout +# + +if test -f "$dir/probe.lcl" +then . "$dir/probe.lcl" +fi + +# +# the payoff +# + +case $version_stamp in +?*) echo "# $version_stamp" ;; +esac +echo CC.CC = $cc +echo CC.NATIVE = $CC_NATIVE +echo CC.EXECTYPE = $CC_EXECTYPE +echo CC.HOSTTYPE = $CC_HOSTTYPE +echo CC.ALTPP.FLAGS = $CC_ALTPP_FLAGS +echo CC.ALTPP.ENV = $CC_ALTPP_ENV +echo CC.AR = $CC_AR +echo CC.AR.ARFLAGS = $CC_AR_ARFLAGS +echo CC.ARFLAGS = $CC_ARFLAGS +echo CC.DEBUG = $CC_DEBUG +echo CC.DIALECT = $CC_DIALECT +echo CC.DLLBIG = $CC_DLLBIG +echo CC.DLLSMALL = $CC_DLLSMALL +echo CC.DLL = $CC_DLL +echo CC.DLL.DEF = $cc_dll_def +echo CC.DLL.DIR = $CC_DLL_DIR +echo CC.DLL.LIBRARIES = $CC_DLL_LIBRARIES +echo CC.DLL.VARIANTS = $CC_DLL_VARIANTS +echo CC.DYNAMIC = $CC_DYNAMIC +echo CC.EXPORT.DYNAMIC = $CC_EXPORT_DYNAMIC +echo CC.INCLUDE.LOCAL = $CC_INCLUDE_LOCAL +# +# 2004-02-14 release workaround +# +case $CC_SHARED_LD in +$CC_CC) echo if LDSHARED + echo CC.LD = $CC_LD + echo else + echo CC.LD = $CC_CC + echo end + ;; +*) echo CC.LD = $CC_LD + ;; +esac +echo CC.LD.DYNAMIC = $CC_LD_DYNAMIC +echo CC.LD.LAZY = $CC_LD_LAZY +echo CC.LD.NOLAZY = $CC_LD_NOLAZY +echo CC.LD.ORIGIN = $CC_LD_ORIGIN +echo CC.LD.RECORD = $CC_LD_RECORD +echo CC.LD.NORECORD = $CC_LD_NORECORD +echo CC.LD.RUNPATH = $CC_LD_RUNPATH +echo CC.LD.STATIC = $CC_LD_STATIC +echo CC.LD.STRIP = $CC_LD_STRIP +echo CC.LIB.DLL = $CC_LIB_DLL +echo CC.LIB.ALL = $CC_LIB_ALL +echo CC.LIB.UNDEF = $CC_LIB_UNDEF +echo CC.MAKE.OPTIONS = $CC_MAKE_OPTIONS +echo CC.NM = $CC_NM +case $CC_NMEDIT in +?*) CC_NMEDIT=" $CC_NMEDIT" ;; +esac +echo CC.NMEDIT ="$CC_NMEDIT" +echo CC.NMFLAGS = $CC_NMFLAGS +echo CC.NOPROTECT = $CC_NOPROTECT +echo CC.OPTIMIZE = $CC_OPTIMIZE +echo CC.PICBIG = $CC_PICBIG +echo CC.PICSMALL = $CC_PICSMALL +echo CC.PIC = $CC_PIC +echo CC.READONLY = $CC_READONLY +echo CC.REPOSITORY = $CC_REPOSITORY +for f in $CC_REQUIRE +do echo CC.REQUIRE.$f =`cat req.$f` +done +echo CC.RUNPATH = $CC_RUNPATH +echo CC.SHARED = $CC_SHARED +echo CC.SHARED.LD = $CC_SHARED_LD +echo CC.SHARED.NAME = $CC_SHARED_NAME +echo CC.SHARED.REGISTRY = $CC_SHARED_REGISTRY +echo CC.SHARED.REGISTRY.PATH = $CC_SHARED_REGISTRY_PATH +echo CC.SHELLMAGIC = $CC_SHELLMAGIC +echo CC.SIZE = $CC_SIZE +echo CC.STATIC = $CC_STATIC +echo CC.STDINCLUDE = $CC_STDINCLUDE +echo CC.STDLIB = $CC_STDLIB +echo CC.STRICT = $CC_STRICT +echo CC.STRIP = $CC_STRIP +echo CC.STRIP.FLAGS = $CC_STRIP_FLAGS +echo CC.PREFIX.ARCHIVE = $CC_PREFIX_ARCHIVE +echo CC.PREFIX.DYNAMIC = $CC_PREFIX_DYNAMIC +echo CC.PREFIX.SHARED = $CC_PREFIX_SHARED +echo CC.PREFIX.SYMBOL = $CC_PREFIX_SYMBOL +echo CC.SUFFIX.ARCHIVE = $CC_SUFFIX_ARCHIVE +echo CC.SUFFIX.COMMAND = $CC_SUFFIX_COMMAND +echo CC.SUFFIX.DEBUG = $CC_SUFFIX_DEBUG +echo CC.SUFFIX.DYNAMIC = $CC_SUFFIX_DYNAMIC +echo CC.SUFFIX.LD = $CC_SUFFIX_LD +echo CC.SUFFIX.OBJECT = $CC_SUFFIX_OBJECT +echo CC.SUFFIX.SHARED = $CC_SUFFIX_SHARED +echo CC.SUFFIX.SOURCE = $CC_SUFFIX_SOURCE +echo CC.SUFFIX.STATIC = $CC_SUFFIX_STATIC +echo CC.VERSION = $CC_VERSION +case $CC_VERSION_STRING in +*\"*) i=`echo " $CC_VERSION_STRING" | sed -e 's,",\\\\",g' -e 's,^ ,,' -e 's,.*,"&",'` ;; +*\'*) i=\"$CC_VERSION_STRING\" ;; +*) i=$CC_VERSION_STRING ;; +esac +cat <<! +CC.VERSION.STRING = $i +! +echo CC.WARN = $CC_WARN + +for i in $CC_ATTRIBUTES +do eval echo CC.$i = \$$i +done diff --git a/src/cmd/INIT/mamake.c b/src/cmd/INIT/mamake.c new file mode 100644 index 0000000..1f85240 --- /dev/null +++ b/src/cmd/INIT/mamake.c @@ -0,0 +1,2375 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#pragma prototyped + +/* + * mamake -- MAM make + * + * coded for portability + */ + +static char id[] = "\n@(#)$Id: mamake (AT&T Research) 2011-08-31 $\0\n"; + +#if _PACKAGE_ast + +#include <ast.h> +#include <error.h> + +static const char usage[] = +"[-?\n@(#)$Id: mamake (AT&T Research) 2011-08-31 $\n]" +USAGE_LICENSE +"[+NAME?mamake - make abstract machine make]" +"[+DESCRIPTION?\bmamake\b reads \amake abstract machine\a target and" +" prerequisite file descriptions from a mamfile (see \b-f\b) and executes" +" actions to update targets that are older than their prerequisites." +" Mamfiles are generated by the \b--mam\b option of \bnmake\b(1) and" +" \bgmake\b(1) and are portable to environments that only have" +" \bsh\b(1) and \bcc\b(1).]" +"[+?In practice \bmamake\b is used to bootstrap build \bnmake\b(1) and" +" \bksh\b(1) in new environments. Mamfiles are used rather than" +" old-\bmake\b makefiles because some features are not reliably supported" +" across all \bmake\b variants:]{" +" [+action execution?Multi-line actions are executed as a" +" unit by \b$SHELL\b. There are some shell constructs" +" that cannot be expressed in an old-\bmake\b makefile.]" +" [+viewpathing?\bVPATH\b is properly interpreted. This allows" +" source to be separate from generated files.]" +" [+recursion?Ordered subdirectory recursion over unrelated" +" makefiles.]" +" }" +"[+?\bmamprobe\b(1) is called to probe and generate system specific variable" +" definitions. The probe information is regenerated when it is older" +" than the \bmamprobe\b command.]" +"[+?For compatibility with \bnmake\b(1) the \b-K\b option and the" +" \brecurse\b and \bcc-*\b command line targets are ignored.]" +"[e:?Explain reason for triggering action. Ignored if -F is on.]" +"[f:?Read \afile\a instead of the default.]:[file:=Mamfile]" +"[i:?Ignore action errors.]" +"[k:?Continue after error with sibling prerequisites.]" +"[n:?Print actions but do not execute. Recursion actions (see \b-r\b) are still" +" executed. Use \b-N\b to disable recursion actions too.]" +"[r:?Recursively make leaf directories matching \apattern\a. Only leaf" +" directories containing a makefile named \bNmakefile\b, \bnmakefile\b," +" \bMakefile\b or \bmakefile\b are considered. The first makefile" +" found in each leaf directory is scanned for leaf directory" +" prerequisites; the recusion order is determined by a topological sort" +" of these prerequisites.]:[pattern]" +"[C:?Do all work in \adirectory\a. All messages will mention" +" \adirectory\a.]:[directory]" +"[D:?Set the debug trace level to \alevel\a. Higher levels produce more" +" output.]#[level]" +"[F:?Force all targets to be out of date.]" +"[K:?Ignored.]" +"[N:?Like \b-n\b but recursion actions (see \b-r\b) are also disabled.]" +"[V:?Print the program version and exit.]" +"[G:debug-symbols?Compile and link with debugging symbol options enabled.]" +"[S:strip-symbols?Strip link-time static symbols from executables.]" + +"\n" +"\n[ target ... ] [ name=value ... ]\n" +"\n" + +"[+SEE ALSO?\bgmake\b(1), \bmake\b(1), \bmamprobe\b(1)," +" \bnmake\b(1), \bsh\b(1)]" +; + +#else + +#define elementsof(x) (sizeof(x)/sizeof(x[0])) +#define newof(p,t,n,x) ((p)?(t*)realloc((char*)(p),sizeof(t)*(n)+(x)):(t*)calloc(1,sizeof(t)*(n)+(x))) + +#define NiL ((char*)0) + +#endif + +#include <stdio.h> +#include <unistd.h> +#include <ctype.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <time.h> + +#if !_PACKAGE_ast && defined(__STDC__) +#include <stdlib.h> +#include <string.h> +#endif + +#define delimiter(c) ((c)==' '||(c)=='\t'||(c)=='\n'||(c)==';'||(c)=='('||(c)==')'||(c)=='`'||(c)=='|'||(c)=='&'||(c)=='=') + +#define add(b,c) (((b)->nxt >= (b)->end) ? append(b, "") : NiL, *(b)->nxt++ = (c)) +#define get(b) ((b)->nxt-(b)->buf) +#define set(b,o) ((b)->nxt=(b)->buf+(o)) +#define use(b) (*(b)->nxt=0,(b)->nxt=(b)->buf) + +#define CHUNK 1024 +#define KEY(a,b,c,d) ((((unsigned long)(a))<<15)|(((unsigned long)(b))<<10)|(((unsigned long)(c))<<5)|(((unsigned long)(d)))) +#define NOW ((unsigned long)time((time_t*)0)) +#define ROTATE(p,l,r,t) ((t)=(p)->l,(p)->l=(t)->r,(t)->r=(p),(p)=(t)) + +#define RULE_active 0x0001 /* active target */ +#define RULE_dontcare 0x0002 /* ok if not found */ +#define RULE_error 0x0004 /* not found or not generated */ +#define RULE_exists 0x0008 /* target file exists */ +#define RULE_generated 0x0010 /* generated target */ +#define RULE_ignore 0x0020 /* ignore time */ +#define RULE_implicit 0x0040 /* implicit prerequisite */ +#define RULE_made 0x0080 /* already made */ +#define RULE_virtual 0x0100 /* not a file */ + +#define STREAM_KEEP 0x0001 /* don't fclose() on pop() */ +#define STREAM_MUST 0x0002 /* push() file must exist */ +#define STREAM_PIPE 0x0004 /* pclose() on pop() */ + +#ifndef S_IXUSR +#define S_IXUSR 0100 /* owner execute permission */ +#endif +#ifndef S_IXGRP +#define S_IXGRP 0010 /* group execute permission */ +#endif +#ifndef S_IXOTH +#define S_IXOTH 0001 /* other execute permission */ +#endif + +struct Rule_s; + +typedef struct stat Stat_t; +typedef FILE Stdio_t; + +typedef struct Buf_s /* buffer stream */ +{ + struct Buf_s* old; /* next dropped buffer */ + char* end; /* 1 past end of buffer */ + char* nxt; /* next char to add */ + char* buf; /* buffer space */ +} Buf_t; + +typedef struct Dict_item_s /* dictionary item */ +{ + struct Dict_item_s* left; /* left child */ + struct Dict_item_s* right; /* right child */ + void* value; /* user defined value */ + char name[1];/* 0 terminated name */ +} Dict_item_t; + +typedef struct Dict_s /* dictionary handle */ +{ + Dict_item_t* root; /* root item */ +} Dict_t; + +typedef struct List_s /* Rule_t list */ +{ + struct List_s* next; /* next in list */ + struct Rule_s* rule; /* list item */ +} List_t; + +typedef struct Rule_s /* rule item */ +{ + char* name; /* unbound name */ + char* path; /* bound path */ + List_t* prereqs; /* prerequisites */ + struct Rule_s* leaf; /* recursion leaf alias */ + int flags; /* RULE_* flags */ + int making; /* currently make()ing */ + unsigned long time; /* modification time */ +} Rule_t; + +typedef struct Stream_s /* input file stream stack */ +{ + Stdio_t* fp; /* read stream */ + char* file; /* stream path */ + unsigned long line; /* stream line */ + int flags; /* stream flags */ +} Stream_t; + +typedef struct View_s /* viewpath level */ +{ + struct View_s* next; /* next level in viewpath */ + int node; /* viewpath node path length */ + char dir[1]; /* viewpath level dir prefix */ +} View_t; + +static struct /* program state */ +{ + Buf_t* buf; /* work buffer */ + Buf_t* old; /* dropped buffers */ + Buf_t* opt; /* option buffer */ + + Dict_t* leaf; /* recursion leaf dictionary */ + Dict_t* libs; /* library dictionary */ + Dict_t* rules; /* rule dictionary */ + Dict_t* vars; /* variable dictionary */ + + View_t* view; /* viewpath levels */ + + char* directory; /* work in this directory */ + char* id; /* command name */ + char* file; /* first input file */ + char* pwd; /* current directory */ + char* recurse; /* recursion pattern */ + char* shell; /* ${SHELL} */ + + int active; /* targets currently active */ + int debug; /* negative of debug level */ + int errors; /* some error(s) occurred */ + int exec; /* execute actions */ + int explain; /* explain actions */ + int force; /* all targets out of date */ + int ignore; /* ignore command errors */ + int indent; /* debug indent */ + int keepgoing; /* do siblings on error */ + int never; /* never execute */ + int peek; /* next line already in input */ + int probed; /* probe already done */ + int verified; /* don't bother with verify() */ + + Stream_t streams[4]; /* input file stream stack */ + Stream_t* sp; /* input stream stack pointer */ + + char input[8*CHUNK]; /* input buffer */ +} state; + +static unsigned long make(Rule_t*); + +static char mamfile[] = "Mamfile"; +static char sh[] = "/bin/sh"; + +extern char** environ; + +#if !_PACKAGE_ast + +#if defined(NeXT) || defined(__NeXT) +#define getcwd(a,b) getwd(a) +#endif + +/* + * emit usage message and exit + */ + +static void +usage() +{ + fprintf(stderr, "Usage: %s [-iknFKNV] [-f mamfile] [-r pattern] [-C directory] [-D level] [target ...] [name=value ...]\n", state.id); + exit(2); +} + +#endif + +/* + * output error message identification + */ + +static void +identify(Stdio_t* sp) +{ + if (state.directory) + fprintf(sp, "%s [%s]: ", state.id, state.directory); + else + fprintf(sp, "%s: ", state.id); +} + +/* + * emit error message + * level: + * <0 debug + * 0 info + * 1 warning + * 2 error + * >2 exit(level-2) + */ + +static void +report(int level, char* text, char* item, unsigned long stamp) +{ + int i; + + if (level >= state.debug) + { + if (level) + identify(stderr); + if (level < 0) + { + fprintf(stderr, "debug%d: ", level); + for (i = 1; i < state.indent; i++) + fprintf(stderr, " "); + } + else + { + if (state.sp && state.sp->line) + { + if (state.sp->file) + fprintf(stderr, "%s: ", state.sp->file); + fprintf(stderr, "%ld: ", state.sp->line); + } + if (level == 1) + fprintf(stderr, "warning: "); + else if (level > 1) + state.errors = 1; + } + if (item) + fprintf(stderr, "%s: ", item); + fprintf(stderr, "%s", text); + if (stamp && state.debug <= -2) + fprintf(stderr, " %10lu", stamp); + fprintf(stderr, "\n"); + if (level > 2) + exit(level - 2); + } +} + +/* + * don't know how to make or exit code making + */ + +static void +dont(Rule_t* r, int code, int keepgoing) +{ + identify(stderr); + if (!code) + fprintf(stderr, "don't know how to make %s\n", r->name); + else + { + fprintf(stderr, "*** exit code %d making %s%s\n", code, r->name, state.ignore ? " ignored" : ""); + unlink(r->name); + if (state.ignore) + return; + } + if (!keepgoing) + exit(1); + state.errors++; + r->flags |= RULE_error; +} + +/* + * local strrchr() + */ + +static char* +last(register char* s, register int c) +{ + register char* r = 0; + + for (r = 0; *s; s++) + if (*s == c) + r = s; + return r; +} + +/* + * open a buffer stream + */ + +static Buf_t* +buffer(void) +{ + register Buf_t* buf; + + if (buf = state.old) + state.old = state.old->old; + else if (!(buf = newof(0, Buf_t, 1, 0)) || !(buf->buf = newof(0, char, CHUNK, 0))) + report(3, "out of space [buffer]", NiL, (unsigned long)0); + buf->end = buf->buf + CHUNK; + buf->nxt = buf->buf; + return buf; +} + +/* + * close a buffer stream + */ + +static void +drop(Buf_t* buf) +{ + buf->old = state.old; + state.old = buf; +} + +/* + * append str length n to buffer and return the buffer base + */ + +static char* +appendn(Buf_t* buf, char* str, int n) +{ + int m; + int i; + + if ((n + 1) >= (buf->end - buf->nxt)) + { + i = buf->nxt - buf->buf; + m = (((buf->end - buf->buf) + n + CHUNK + 1) / CHUNK) * CHUNK; + if (!(buf->buf = newof(buf->buf, char, m, 0))) + report(3, "out of space [buffer resize]", NiL, (unsigned long)0); + buf->end = buf->buf + m; + buf->nxt = buf->buf + i; + } + memcpy(buf->nxt, str, n + 1); + buf->nxt += n; + return buf->buf; +} + +/* + * append str to buffer and return the buffer base + * if str==0 then next pointer reset to base + */ + +static char* +append(Buf_t* buf, char* str) +{ + if (str) + return appendn(buf, str, strlen(str)); + buf->nxt = buf->buf; + return buf->buf; +} + +/* + * allocate space for s and return the copy + */ + +static char* +duplicate(char* s) +{ + char* t; + int n; + + n = strlen(s); + if (!(t = newof(0, char, n, 1))) + report(3, "out of space [duplicate]", s, (unsigned long)0); + strcpy(t, s); + return t; +} + +/* + * open a new dictionary + */ + +static Dict_t* +dictionary(void) +{ + Dict_t* dict; + + if (!(dict = newof(0, Dict_t, 1, 0))) + report(3, "out of space [dictionary]", NiL, (unsigned long)0); + return dict; +} + +/* + * return the value for item name in dictionary dict + * if value!=0 then name entry value is created if necessary and set + * uses top-down splaying (ala Tarjan and Sleator) + */ + +static void* +search(register Dict_t* dict, char* name, void* value) +{ + register int cmp; + register Dict_item_t* root; + register Dict_item_t* t; + register Dict_item_t* left; + register Dict_item_t* right; + register Dict_item_t* lroot; + register Dict_item_t* rroot; + + root = dict->root; + left = right = lroot = rroot = 0; + while (root) + { + if (!(cmp = strcmp(name, root->name))) + break; + else if (cmp < 0) + { + if (root->left && (cmp = strcmp(name, root->left->name)) <= 0) + { + ROTATE(root, left, right, t); + if (!cmp) + break; + } + if (right) + right->left = root; + else + rroot = root; + right = root; + root = root->left; + right->left = 0; + } + else + { + if (root->right && (cmp = strcmp(name, root->right->name)) >= 0) + { + ROTATE(root, right, left, t); + if (!cmp) + break; + } + if (left) + left->right = root; + else + lroot = root; + left = root; + root = root->right; + left->right = 0; + } + } + if (root) + { + if (right) + right->left = root->right; + else + rroot = root->right; + if (left) + left->right = root->left; + else + lroot = root->left; + } + else if (value) + { + if (!(root = newof(0, Dict_item_t, 1, strlen(name)))) + report(3, "out of space [dictionary]", name, (unsigned long)0); + strcpy(root->name, name); + } + if (root) + { + if (value) + root->value = value; + root->left = lroot; + root->right = rroot; + dict->root = root; + return value ? (void*)root->name : root->value; + } + if (left) + { + left->right = rroot; + dict->root = lroot; + } + else if (right) + { + right->left = lroot; + dict->root = rroot; + } + return 0; +} + +/* + * low level for walk() + */ + +static int +apply(Dict_t* dict, Dict_item_t* item, int (*func)(Dict_item_t*, void*), void* handle) +{ + register Dict_item_t* right; + + do + { + right = item->right; + if (item->left && apply(dict, item->left, func, handle)) + return -1; + if ((*func)(item, handle)) + return -1; + } while (item = right); + return 0; +} + +/* + * apply func to each dictionary item + */ + +static int +walk(Dict_t* dict, int (*func)(Dict_item_t*, void*), void* handle) +{ + return dict->root ? apply(dict, dict->root, func, handle) : 0; +} + +/* + * return a rule pointer for name + */ + +static Rule_t* +rule(char* name) +{ + Rule_t* r; + + if (!(r = (Rule_t*)search(state.rules, name, NiL))) + { + if (!(r = newof(0, Rule_t, 1, 0))) + report(3, "out of space [rule]", name, (unsigned long)0); + r->name = (char*)search(state.rules, name, (void*)r); + } + return r; +} + +/* + * prepend p onto rule r prereqs + */ + +static void +cons(Rule_t* r, Rule_t* p) +{ + register List_t* x; + + for (x = r->prereqs; x && x->rule != p; x = x->next); + if (!x) + { + if (!(x = newof(0, List_t, 1, 0))) + report(3, "out of space [list]", r->name, (unsigned long)0); + x->rule = p; + x->next = r->prereqs; + r->prereqs = x; + } +} + +/* + * initialize the viewpath + */ + +static void +view(void) +{ + register char* s; + register char* t; + register char* p; + register View_t* vp; + + View_t* zp; + int c; + int n; + + Stat_t st; + Stat_t ts; + + char buf[CHUNK]; + + if (stat(".", &st)) + report(3, "cannot stat", ".", (unsigned long)0); + if ((s = (char*)search(state.vars, "PWD", NiL)) && !stat(s, &ts) && + ts.st_dev == st.st_dev && ts.st_ino == st.st_ino) + state.pwd = s; + if (!state.pwd) + { + if (!getcwd(buf, sizeof(buf) - 1)) + report(3, "cannot determine PWD", NiL, (unsigned long)0); + state.pwd = duplicate(buf); + search(state.vars, "PWD", state.pwd); + } + if ((s = (char*)search(state.vars, "VPATH", NiL)) && *s) + { + zp = 0; + for (;;) + { + for (t = s; *t && *t != ':'; t++); + if (c = *t) + *t = 0; + if (!state.view) + { + /* + * determine the viewpath offset + */ + + if (stat(s, &st)) + report(3, "cannot stat top view", s, (unsigned long)0); + if (stat(state.pwd, &ts)) + report(3, "cannot stat", state.pwd, (unsigned long)0); + if (ts.st_dev == st.st_dev && ts.st_ino == st.st_ino) + p = "."; + else + { + p = state.pwd + strlen(state.pwd); + while (p > state.pwd) + if (*--p == '/') + { + if (p == state.pwd) + report(3, ". not under VPATH", s, (unsigned long)0); + *p = 0; + if (stat(state.pwd, &ts)) + report(3, "cannot stat", state.pwd, (unsigned long)0); + *p = '/'; + if (ts.st_dev == st.st_dev && ts.st_ino == st.st_ino) + { + p++; + break; + } + } + if (p <= state.pwd) + report(3, "cannot determine viewpath offset", s, (unsigned long)0); + } + } + n = strlen(s); + if (!(vp = newof(0, View_t, 1, strlen(p) + n + 1))) + report(3, "out of space [view]", s, (unsigned long)0); + vp->node = n + 1; + strcpy(vp->dir, s); + *(vp->dir + n) = '/'; + strcpy(vp->dir + n + 1, p); + report(-4, vp->dir, "view", (unsigned long)0); + if (!state.view) + state.view = zp = vp; + else + zp = zp->next = vp; + if (!c) + break; + *t++ = c; + s = t; + } + } +} + +/* + * return next '?' or '}' in nested '}' + */ + +static char* +cond(register char* s) +{ + register int n; + + if (*s == '?') + s++; + n = 0; + for (;;) + { + switch (*s++) + { + case 0: + break; + case '{': + n++; + continue; + case '}': + if (!n--) + break; + continue; + case '?': + if (!n) + break; + continue; + default: + continue; + } + break; + } + return s - 1; +} + +/* + * expand var refs from s into buf + */ + +static void +substitute(Buf_t* buf, register char* s) +{ + register char* t; + register char* v; + register char* q; + register char* b; + register int c; + register int n; + int a = 0; + int i; + + while (c = *s++) + { + if (c == '$' && *s == '{') + { + b = s - 1; + i = 1; + for (n = *(t = ++s) == '-' ? 0 : '-'; (c = *s) && c != '?' && c != '+' && c != n && c != ':' && c != '=' && c != '[' && c != '}'; s++) + if (!isalnum(c) && c != '_') + i = 0; + *s = 0; + if (c == '[') + { + append(buf, b); + *s = c; + continue; + } + v = (char*)search(state.vars, t, NiL); + if ((c == ':' || c == '=') && (!v || c == ':' && !*v)) + { + append(buf, b); + *s = c; + continue; + } + if (t[0] == 'A' && t[1] == 'R' && t[2] == 0) + a = 1; + *s = c; + if (c && c != '}') + { + n = 1; + for (t = ++s; *s; s++) + if (*s == '{') + n++; + else if (*s == '}' && !--n) + break; + } + switch (c) + { + case '?': + q = cond(t - 1); + if (v) + { + if (((q - t) != 1 || *t != '*') && strncmp(v, t, q - t)) + v = 0; + } + else if (q == t) + v = s; + t = cond(q); + if (v) + { + if (t > q) + { + c = *t; + *t = 0; + substitute(buf, q + 1); + *t = c; + } + } + else + { + q = cond(t); + if (q > t) + { + c = *q; + *q = 0; + substitute(buf, t + 1); + *q = c; + } + } + break; + case '+': + case '-': + if ((v == 0 || *v == 0) == (c == '-')) + { + c = *s; + *s = 0; + substitute(buf, t); + *s = c; + break; + } + if (c != '-') + break; + /*FALLTHROUGH*/ + case 0: + case '=': + case '}': + if (v) + { + if (a && t[0] == 'm' && t[1] == 'a' && t[2] == 'm' && t[3] == '_' && t[4] == 'l' && t[5] == 'i' && t[6] == 'b') + { + for (t = v; *t == ' '; t++); + for (; *t && *t != ' '; t++); + if (*t) + *t = 0; + else + t = 0; + substitute(buf, v); + if (t) + *t = ' '; + } + else + substitute(buf, v); + } + else if (i) + { + c = *s; + *s = 0; + append(buf, b); + *s = c; + continue; + } + break; + } + if (*s) + s++; + } + else + add(buf, c); + } +} + +/* + * expand var refs from s into buf and return buf base + */ + +static char* +expand(Buf_t* buf, char* s) +{ + substitute(buf, s); + return use(buf); +} + +/* + * stat() with .exe check + */ + +static char* +status(Buf_t* buf, int off, char* path, struct stat* st) +{ + int r; + char* s; + Buf_t* tmp; + + if (!stat(path, st)) + return path; + if (!(tmp = buf)) + { + tmp = buffer(); + off = 0; + } + if (off) + set(tmp, off); + else + append(tmp, path); + append(tmp, ".exe"); + s = use(tmp); + r = stat(s, st); + if (!buf) + { + drop(tmp); + s = path; + } + if (r) + { + if (off) + s[off] = 0; + s = 0; + } + return s; +} + +/* + * return path to file + */ + +static char* +find(Buf_t* buf, char* file, struct stat* st) +{ + char* s; + View_t* vp; + int node; + int c; + int o; + + if (s = status(buf, 0, file, st)) + { + report(-3, s, "find", (unsigned long)0); + return s; + } + if (vp = state.view) + { + node = 0; + if (*file == '/') + { + do + { + if (!strncmp(file, vp->dir, vp->node)) + { + file += vp->node; + node = 2; + break; + } + } while (vp = vp->next); + } + else + vp = vp->next; + if (vp) + do + { + if (node) + { + c = vp->dir[vp->node]; + vp->dir[vp->node] = 0; + append(buf, vp->dir); + vp->dir[vp->node] = c; + } + else + { + append(buf, vp->dir); + append(buf, "/"); + } + append(buf, file); + o = get(buf); + s = use(buf); + if (s = status(buf, o, s, st)) + { + report(-3, s, "find", (unsigned long)0); + return s; + } + } while (vp = vp->next); + } + return 0; +} + +/* + * bind r to a file and return the modify time + */ + +static unsigned long +bind(Rule_t* r) +{ + char* s; + Buf_t* buf; + struct stat st; + + buf = buffer(); + if (s = find(buf, r->name, &st)) + { + if (s != r->name) + r->path = duplicate(s); + r->time = st.st_mtime; + r->flags |= RULE_exists; + } + drop(buf); + return r->time; +} + +/* + * pop the current input file + */ + +static int +pop(void) +{ + int r; + + if (!state.sp) + report(3, "input stack underflow", NiL, (unsigned long)0); + if (!state.sp->fp || (state.sp->flags & STREAM_KEEP)) + r = 0; + else if (state.sp->flags & STREAM_PIPE) + r = pclose(state.sp->fp); + else + r = fclose(state.sp->fp); + if (state.sp == state.streams) + state.sp = 0; + else + state.sp--; + return r; +} + +/* + * push file onto the input stack + */ + +static int +push(char* file, Stdio_t* fp, int flags) +{ + char* path; + Buf_t* buf; + struct stat st; + + if (!state.sp) + state.sp = state.streams; + else if (++state.sp >= &state.streams[elementsof(state.streams)]) + report(3, "input stream stack overflow", NiL, (unsigned long)0); + if (state.sp->fp = fp) + state.sp->file = "pipeline"; + else if (flags & STREAM_PIPE) + report(3, "pipe error", file, (unsigned long)0); + else if (!file || !strcmp(file, "-") || !strcmp(file, "/dev/stdin")) + { + flags |= STREAM_KEEP; + state.sp->file = "/dev/stdin"; + state.sp->fp = stdin; + } + else + { + buf = buffer(); + if (path = find(buf, file, &st)) + { + if (!(state.sp->fp = fopen(path, "r"))) + report(3, "cannot read", path, (unsigned long)0); + state.sp->file = duplicate(path); + drop(buf); + } + else + { + drop(buf); + pop(); + if (flags & STREAM_MUST) + report(3, "not found", file, (unsigned long)0); + return 0; + } + } + state.sp->flags = flags; + state.sp->line = 0; + return 1; +} + +/* + * return the next input line + */ + +static char* +input(void) +{ + char* e; + + if (!state.sp) + report(3, "no input file stream", NiL, (unsigned long)0); + if (state.peek) + state.peek = 0; + else if (!fgets(state.input, sizeof(state.input), state.sp->fp)) + return 0; + else if (*state.input && *(e = state.input + strlen(state.input) - 1) == '\n') + *e = 0; + state.sp->line++; + return state.input; +} + +/* + * pass shell action s to ${SHELL:-/bin/sh} + * the -c wrapper ensures that scripts are run in the selected shell + * even on systems that otherwise demand #! magic (can you say cygwin) + */ + +static int +execute(register char* s) +{ + register int c; + Buf_t* buf; + + if (!state.shell && (!(state.shell = (char*)search(state.vars, "SHELL", NiL)) || !strcmp(state.shell, sh))) + state.shell = sh; + buf = buffer(); + append(buf, state.shell); + append(buf, " -c '"); + while (c = *s++) + { + if (c == '\'') + { + add(buf, c); + for (s--; *s == c; s++) + { + add(buf, '\\'); + add(buf, c); + } + } + add(buf, c); + } + add(buf, '\''); + s = use(buf); + report(-5, s, "exec", (unsigned long)0); + if ((c = system(s)) > 255) + c >>= 8; + drop(buf); + return c; +} + +/* + * run action s to update r + */ + +static unsigned long +run(Rule_t* r, register char* s) +{ + register Rule_t* q; + register char* t; + register int c; + register View_t* v; + int i; + int j; + int x; + Stat_t st; + Buf_t* buf; + + if (r->flags & RULE_error) + return r->time; + buf = buffer(); + if (!strncmp(s, "mamake -r ", 10)) + { + state.verified = 1; + x = !state.never; + } + else + x = state.exec; + if (x) + append(buf, "trap - 1 2 3 15\nPATH=.:$PATH\nset -x\n"); + if (state.view) + { + do + { + for (; delimiter(*s); s++) + add(buf, *s); + for (t = s; *s && !delimiter(*s); s++); + c = *s; + *s = 0; + if (c == '=') + { + append(buf, t); + continue; + } + if ((q = (Rule_t*)search(state.rules, t, NiL)) && q->path && !(q->flags & RULE_generated)) + append(buf, q->path); + else + { + append(buf, t); + if (*t == '-' && *(t + 1) == 'I' && (*(t + 2) || c)) + { + if (*(t + 2)) + i = 2; + else + { + for (i = 3; *(t + i) == ' ' || *(t + i) == '\t'; i++); + *s = c; + for (s = t + i; *s && *s != ' ' && *s != '\t' && *s != '\n'; s++); + c = *s; + *s = 0; + append(buf, t + 2); + } + if (*(t + i) && *(t + i) != '/') + { + v = state.view; + while (v = v->next) + { + add(buf, ' '); + for (j = 0; j < i; j++) + add(buf, *(t + j)); + append(buf, v->dir); + if (*(t + i) != '.' || *(t + i + 1)) + { + add(buf, '/'); + append(buf, t + i); + } + } + } + } + } + } while (*s = c); + s = use(buf); + } + else if (x) + { + append(buf, s); + s = use(buf); + } + if (x) + { + if (c = execute(s)) + dont(r, c, state.keepgoing); + if (status((Buf_t*)0, 0, r->name, &st)) + { + r->time = st.st_mtime; + r->flags |= RULE_exists; + } + else + r->time = NOW; + } + else + { + fprintf(stdout, "%s\n", s); + if (state.debug) + fflush(stdout); + r->time = NOW; + r->flags |= RULE_exists; + } + drop(buf); + return r->time; +} + +/* + * return the full path for s using buf workspace + */ + +static char* +path(Buf_t* buf, char* s, int must) +{ + register char* p; + register char* d; + register char* x; + char* e; + register int c; + int t; + int o; + Stat_t st; + + for (e = s; *e && *e != ' ' && *e != '\t'; e++); + t = *e; + if ((x = status(buf, 0, s, &st)) && (st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))) + return x; + if (!(p = (char*)search(state.vars, "PATH", NiL))) + report(3, "variable not defined", "PATH", (unsigned long)0); + do + { + for (d = p; *p && *p != ':'; p++); + c = *p; + *p = 0; + if (*d && (*d != '.' || *(d + 1))) + { + append(buf, d); + add(buf, '/'); + } + *p = c; + if (t) + *e = 0; + append(buf, s); + if (t) + *e = t; + o = get(buf); + x = use(buf); + if ((x = status(buf, o, x, &st)) && (st.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))) + return x; + } while (*p++); + if (must) + report(3, "command not found", s, (unsigned long)0); + return 0; +} + +/* + * generate (if necessary) and read the MAM probe information + * done on the first `setv CC ...' + */ + +static void +probe(void) +{ + register char* cc; + register char* s; + unsigned long h; + unsigned long q; + Buf_t* buf; + Buf_t* pro; + Buf_t* tmp; + struct stat st; + + static char let[] = "ABCDEFGHIJKLMNOP"; + static char cmd[] = "mamprobe"; + + if (!(cc = (char*)search(state.vars, "CC", NiL))) + cc = "cc"; + buf = buffer(); + s = path(buf, cmd, 1); + q = stat(s, &st) ? (unsigned long)0 : (unsigned long)st.st_mtime; + pro = buffer(); + s = cc = path(pro, cc, 1); + for (h = 0; *s; s++) + h = h * 0x63c63cd9L + *s + 0x9c39c33dL; + if (!(s = (char*)search(state.vars, "INSTALLROOT", NiL))) + report(3, "variable must be defined", "INSTALLROOT", (unsigned long)0); + append(buf, s); + append(buf, "/lib/probe/C/mam/"); + for (h &= 0xffffffffL; h; h >>= 4) + add(buf, let[h & 0xf]); + s = use(buf); + h = stat(s, &st) ? (unsigned long)0 : (unsigned long)st.st_mtime; + if (h < q || !push(s, (Stdio_t*)0, 0)) + { + tmp = buffer(); + append(tmp, cmd); + add(tmp, ' '); + append(tmp, s); + add(tmp, ' '); + append(tmp, cc); + if (execute(use(tmp))) + report(3, "cannot generate probe info", s, (unsigned long)0); + drop(tmp); + if (!push(s, (Stdio_t*)0, 0)) + report(3, "cannot read probe info", s, (unsigned long)0); + } + drop(pro); + drop(buf); + make(rule("")); + pop(); +} + +/* + * add attributes in s to r + */ + +static void +attributes(register Rule_t* r, register char* s) +{ + register char* t; + register int n; + + for (;;) + { + for (; *s == ' '; s++); + for (t = s; *s && *s != ' '; s++); + if (!(n = s - t)) + break; + switch (*t) + { + case 'd': + if (n == 8 && !strncmp(t, "dontcare", n)) + r->flags |= RULE_dontcare; + break; + case 'g': + if (n == 9 && !strncmp(t, "generated", n)) + r->flags |= RULE_generated; + break; + case 'i': + if (n == 6 && !strncmp(t, "ignore", n)) + r->flags |= RULE_ignore; + else if (n == 8 && !strncmp(t, "implicit", n)) + r->flags |= RULE_implicit; + break; + case 'v': + if (n == 7 && !strncmp(t, "virtual", n)) + r->flags |= RULE_virtual; + break; + } + } +} + +/* + * define ${mam_libX} for library reference lib + */ + +static char* +require(char* lib, int dontcare) +{ + register int c; + char* s; + char* r; + FILE* f; + Buf_t* buf; + Buf_t* tmp; + struct stat st; + + static int dynamic = -1; + + if (dynamic < 0) + dynamic = (s = search(state.vars, "mam_cc_L", NiL)) ? atoi(s) : 0; + if (!(r = search(state.vars, lib, NiL))) + { + buf = buffer(); + tmp = buffer(); + s = 0; + for (;;) + { + if (s) + append(buf, s); + if (r = search(state.vars, "mam_cc_PREFIX_ARCHIVE", NiL)) + append(buf, r); + append(buf, lib + 2); + if (r = search(state.vars, "mam_cc_SUFFIX_ARCHIVE", NiL)) + append(buf, r); + r = expand(tmp, use(buf)); + if (!stat(r, &st)) + break; + if (s) + { + r = lib; + break; + } + s = "${INSTALLROOT}/lib/"; + if (dynamic) + { + append(buf, s); + if (r = search(state.vars, "mam_cc_PREFIX_SHARED", NiL)) + append(buf, r); + append(buf, lib + 2); + if (r = search(state.vars, "mam_cc_SUFFIX_SHARED", NiL)) + append(buf, r); + r = expand(tmp, use(buf)); + if (!stat(r, &st)) + { + r = lib; + break; + } + } + } + if (r != lib) + r = duplicate(r); + search(state.vars, lib, r); + append(tmp, lib + 2); + append(tmp, ".req"); + if (!(f = fopen(use(tmp), "r"))) + { + append(tmp, "${INSTALLROOT}/lib/lib/"); + append(tmp, lib + 2); + f = fopen(expand(buf, use(tmp)), "r"); + } + if (f) + { + for (;;) + { + while ((c = fgetc(f)) == ' ' || c == '\t' || c == '\n'); + if (c == EOF) + break; + do + { + add(tmp, c); + } while ((c = fgetc(f)) != EOF && c != ' ' && c != '\t' && c != '\n'); + s = use(tmp); + if (s[0] && (s[0] != '-' || s[1])) + { + add(buf, ' '); + append(buf, require(s, 0)); + } + } + fclose(f); + r = use(buf); + } + else if (dontcare) + { + append(tmp, "set -\n"); + append(tmp, "cd /tmp\n"); + append(tmp, "echo 'int main(){return 0;}' > x.${!-$$}.c\n"); + append(tmp, "${CC} ${CCFLAGS} -o x.${!-$$}.x x.${!-$$}.c "); + append(tmp, r); + append(tmp, " >/dev/null 2>&1\n"); + append(tmp, "c=$?\n"); + append(tmp, "rm -f x.${!-$$}.[cox]\n"); + append(tmp, "exit $c\n"); + if (execute(expand(buf, use(tmp)))) + r = ""; + } + r = duplicate(r); + search(state.vars, lib, r); + append(tmp, "mam_lib"); + append(tmp, lib + 2); + search(state.vars, use(tmp), r); + drop(tmp); + drop(buf); + } + return r; +} + +/* + * input() until `done r' + */ + +static unsigned long +make(Rule_t* r) +{ + register char* s; + register char* t; + register char* u; + register char* v; + register Rule_t* q; + unsigned long z; + unsigned long x; + Buf_t* buf; + Buf_t* cmd; + + r->making++; + if (r->flags & RULE_active) + state.active++; + if (*r->name) + { + z = bind(r); + state.indent++; + report(-1, r->name, "make", r->time); + } + else + z = 0; + buf = buffer(); + cmd = 0; + while (s = input()) + { + for (; *s == ' '; s++); + for (; isdigit(*s); s++); + for (; *s == ' '; s++); + for (u = s; *s && *s != ' '; s++); + if (*s) + { + for (*s++ = 0; *s == ' '; s++); + for (t = s; *s && *s != ' '; s++); + if (*s) + for (*s++ = 0; *s == ' '; s++); + v = s; + } + else + t = v = s; + switch (KEY(u[0], u[1], u[2], u[3])) + { + case KEY('b','i','n','d'): + if ((t[0] == '-' || t[0] == '+') && t[1] == 'l' && (s = require(t, !strcmp(v, "dontcare"))) && strncmp(r->name, "FEATURE/", 8) && strcmp(r->name, "configure.h")) + for (;;) + { + for (t = s; *s && *s != ' '; s++); + if (*s) + *s = 0; + else + s = 0; + if (*t) + { + q = rule(expand(buf, t)); + attributes(q, v); + x = bind(q); + if (z < x) + z = x; + if (q->flags & RULE_error) + r->flags |= RULE_error; + } + if (!s) + break; + for (*s++ = ' '; *s == ' '; s++); + } + continue; + case KEY('d','o','n','e'): + q = rule(expand(buf, t)); + if (q != r) + report(2, "improper done statement", t, (unsigned long)0); + attributes(r, v); + if (cmd && state.active && (state.force || r->time < z || !r->time && !z)) + { + if (state.explain && !state.force) + { + if (!r->time) + fprintf(stderr, "%s [not found]\n", r->name); + else + fprintf(stderr, "%s [%lu] older than prerequisites [%lu]\n", r->name, r->time, z); + } + substitute(buf, use(cmd)); + x = run(r, use(buf)); + if (z < x) + z = x; + } + r->flags |= RULE_made; + if (!(r->flags & (RULE_dontcare|RULE_error|RULE_exists|RULE_generated|RULE_implicit|RULE_virtual))) + dont(r, 0, state.keepgoing); + break; + case KEY('e','x','e','c'): + r->flags |= RULE_generated; + if (r->path) + { + free(r->path); + r->path = 0; + r->time = 0; + } + if (state.active) + { + if (cmd) + add(cmd, '\n'); + else + cmd = buffer(); + append(cmd, v); + } + continue; + case KEY('m','a','k','e'): + q = rule(expand(buf, t)); + if (!q->making) + { + attributes(q, v); + x = make(q); + if (!(q->flags & RULE_ignore) && z < x) + z = x; + if (q->flags & RULE_error) + r->flags |= RULE_error; + } + continue; + case KEY('p','r','e','v'): + q = rule(expand(buf, t)); + if (!q->making) + { + if (!(q->flags & RULE_ignore) && z < q->time) + z = q->time; + if (q->flags & RULE_error) + r->flags |= RULE_error; + state.indent++; + report(-2, q->name, "prev", q->time); + state.indent--; + } + continue; + case KEY('s','e','t','v'): + if (!search(state.vars, t, NiL)) + { + if (*v == '"') + { + s = v + strlen(v) - 1; + if (*s == '"') + { + *s = 0; + v++; + } + } + search(state.vars, t, duplicate(expand(buf, v))); + } + if (!state.probed && t[0] == 'C' && t[1] == 'C' && !t[2]) + { + state.probed = 1; + probe(); + } + continue; + default: + continue; + } + break; + } + drop(buf); + if (cmd) + drop(cmd); + if (*r->name) + { + report(-1, r->name, "done", z); + state.indent--; + } + if (r->flags & RULE_active) + state.active--; + r->making--; + return r->time = z; +} + +/* + * verify that active targets were made + */ + +static int +verify(Dict_item_t* item, void* handle) +{ + Rule_t* r = (Rule_t*)item->value; + + if ((r->flags & (RULE_active|RULE_error|RULE_made)) == RULE_active) + dont(r, 0, 1); + return 0; +} + +/* + * return 1 if name is an initializer + */ + +static int +initializer(char* name) +{ + register char* s; + + if (s = last(name, '/')) + s++; + else + s = name; + return s[0] == 'I' && s[1] == 'N' && s[2] == 'I' && s[3] == 'T'; +} + +/* + * update recursion leaf r and its prerequisites + */ + +static int +update(register Rule_t* r) +{ + register List_t* x; + Buf_t* buf; + + static char cmd[] = "${MAMAKE} -C "; + static char arg[] = " ${MAMAKEARGS}"; + + r->flags |= RULE_made; + if (r->leaf) + r->leaf->flags |= RULE_made; + for (x = r->prereqs; x; x = x->next) + if (x->rule->leaf && !(x->rule->flags & RULE_made)) + update(x->rule); + buf = buffer(); + substitute(buf, cmd); + append(buf, r->name); + substitute(buf, arg); + run(r, use(buf)); + drop(buf); + return 0; +} + +/* + * scan makefile prereqs + */ + +static int +scan(Dict_item_t* item, void* handle) +{ + register Rule_t* r = (Rule_t*)item->value; + register char* s; + register char* t; + register char* u; + register char* w; + Rule_t* q; + int i; + int j; + int k; + int p; + Buf_t* buf; + + static char* files[] = + { + "Nmakefile", + "nmakefile", + "Makefile", + "makefile" + }; + + /* + * drop non-leaf rules + */ + + if (!r->leaf) + return 0; + + /* + * always make initializers + */ + + if (initializer(r->name)) + { + if (!(r->flags & RULE_made)) + update(r); + return 0; + } + buf = buffer(); + for (i = 0; i < elementsof(files); i++) + { + append(buf, r->name); + add(buf, '/'); + append(buf, files[i]); + if (push(use(buf), (Stdio_t*)0, 0)) + { + while (s = input()) + { + j = p = 0; + while (*s) + { + for (k = 1; (i = *s) == ' ' || i == '\t' || i == '"' || i == '\''; s++); + for (t = s; (i = *s) && i != ' ' && i != '\t' && i != '"' && i != '\'' && i != '\\' && i != ':'; s++) + if (i == '/') + t = s + 1; + else if (i == '.' && *(s + 1) != 'c' && *(s + 1) != 'C' && *(s + 1) != 'h' && *(s + 1) != 'H' && t[0] == 'l' && t[1] == 'i' && t[2] == 'b') + *s = 0; + if (*s) + *s++ = 0; + if (!t[0]) + k = 0; + else if ((t[0] == '-' || t[0] == '+') && t[1] == 'l' && t[2]) + { + append(buf, "lib"); + append(buf, t + 2); + t = use(buf); + } + else if (p) + { + if (t[0] == '+' && !t[1]) + p = 2; + else if (p == 1) + { + if (i != ':' || strncmp(s, "command", 7)) + { + append(buf, "lib"); + append(buf, t); + t = use(buf); + } + if (i == ':') + while (*s && (*s == ' ' || *s == '\t')) + s++; + } + } + else if (i == ':') + { + if (j != ':' || !isupper(*t)) + k = 0; + else if (!strcmp(t, "PACKAGE")) + { + p = 1; + k = 0; + } + else + for (u = t; *u; u++) + if (isupper(*u)) + *u = tolower(*u); + else if (!isalnum(*u)) + { + k = 0; + break; + } + } + else if (t[0] != 'l' || t[1] != 'i' || t[2] != 'b') + k = 0; + else + for (u = t + 3; *u; u++) + if (!isalnum(*u)) + { + k = 0; + break; + } + if (k && ((q = (Rule_t*)search(state.leaf, t, NiL)) && q != r || *t++ == 'l' && *t++ == 'i' && *t++ == 'b' && *t && (q = (Rule_t*)search(state.leaf, t, NiL)) && q != r)) + { + for (t = w = r->name; *w; w++) + if (*w == '/') + t = w + 1; + if (t[0] == 'l' && t[1] == 'i' && t[2] == 'b') + t += 3; + for (u = w = q->name; *w; w++) + if (*w == '/') + u = w + 1; + if (strcmp(t, u)) + cons(r, q); + } + j = i; + } + } + pop(); + for (s = 0, w = r->name; *w; w++) + if (*w == '/') + s = w; + if (s) + { + if ((s - r->name) > 3 && *(s - 1) == 'b' && *(s - 2) == 'i' && *(s - 3) == 'l' && *(s - 4) != '/') + { + /* + * foolib : foo : libfoo + */ + + *(s - 3) = 0; + q = (Rule_t*)search(state.leaf, r->name, NiL); + if (q && q != r) + cons(r, q); + for (t = w = r->name; *w; w++) + if (*w == '/') + t = w + 1; + append(buf, "lib"); + append(buf, t); + q = (Rule_t*)search(state.leaf, use(buf), NiL); + if (q && q != r) + cons(r, q); + *(s - 3) = 'l'; + } + else if (((s - r->name) != 3 || *(s - 1) != 'b' || *(s - 2) != 'i' || *(s - 3) != 'l') && (*(s + 1) != 'l' || *(s + 2) != 'i' || *(s + 3) != 'b')) + { + /* + * huh/foobar : lib/libfoo + */ + + s++; + t = s + strlen(s); + while (--t > s) + { + append(buf, "lib/lib"); + appendn(buf, s, t - s); + q = (Rule_t*)search(state.leaf, use(buf), NiL); + if (q && q != r) + cons(r, q); + } + } + } + break; + } + } + drop(buf); + return 0; +} + +/* + * descend into op and its prereqs + */ + +static int +descend(Dict_item_t* item, void* handle) +{ + Rule_t* r = (Rule_t*)item->value; + + if (!state.active && (!(r->flags & RULE_active) || !(r = (Rule_t*)search(state.leaf, r->name, NiL)))) + return 0; + return r->leaf && !(r->flags & RULE_made) ? update(r) : 0; +} + +/* + * append the non-leaf active targets to state.opt + */ + +static int +active(Dict_item_t* item, void* handle) +{ + Rule_t* r = (Rule_t*)item->value; + + if (r->flags & RULE_active) + { + if (r->leaf || search(state.leaf, r->name, NiL)) + state.active = 0; + else + { + add(state.opt, ' '); + append(state.opt, r->name); + } + } + return 0; +} + +/* + * recurse on mamfiles in subdirs matching pattern + */ + +static int +recurse(char* pattern) +{ + register char* s; + register char* t; + Rule_t* r; + Buf_t* buf; + Buf_t* tmp; + struct stat st; + + /* + * first determine the MAM subdirs + */ + + tmp = buffer(); + buf = buffer(); + state.exec = !state.never; + state.leaf = dictionary(); + append(buf, "ls -d "); + append(buf, pattern); + s = use(buf); + push("recurse", popen(s, "r"), STREAM_PIPE); + while (s = input()) + { + append(buf, s); + add(buf, '/'); + append(buf, mamfile); + if (find(tmp, use(buf), &st)) + { + r = rule(s); + if (t = last(r->name, '/')) + t++; + else + t = r->name; + r->leaf = rule(t); + search(state.leaf, t, r); + } + } + pop(); + drop(buf); + drop(tmp); + + /* + * grab the non-leaf active targets + */ + + if (!state.active) + { + state.active = 1; + walk(state.rules, active, NiL); + } + search(state.vars, "MAMAKEARGS", duplicate(use(state.opt) + 1)); + + /* + * scan the makefile and descend + */ + + walk(state.rules, scan, NiL); + state.view = 0; + walk(state.rules, descend, NiL); + return 0; +} + +int +main(int argc, char** argv) +{ + register char** e; + register char* s; + register char* t; + register char* v; + Buf_t* tmp; + int c; + + /* + * initialize the state + */ + + state.id = "mamake"; + state.active = 1; + state.exec = 1; + state.file = mamfile; + state.opt = buffer(); + state.rules = dictionary(); + state.vars = dictionary(); + search(state.vars, "MAMAKE", *argv); + + /* + * parse the options + */ + +#if _PACKAGE_ast + error_info.id = state.id; + for (;;) + { + switch (optget(argv, usage)) + { + case 'e': + append(state.opt, " -e"); + state.explain = 1; + continue; + case 'i': + append(state.opt, " -i"); + state.ignore = 1; + continue; + case 'k': + append(state.opt, " -k"); + state.keepgoing = 1; + continue; + case 'N': + state.never = 1; + /*FALLTHROUGH*/ + case 'n': + append(state.opt, " -n"); + state.exec = 0; + continue; + case 'F': + append(state.opt, " -F"); + state.force = 1; + continue; + case 'K': + continue; + case 'V': + fprintf(stdout, "%s\n", id + 10); + exit(0); + case 'f': + append(state.opt, " -f "); + append(state.opt, opt_info.arg); + state.file = opt_info.arg; + continue; + case 'r': + state.recurse = opt_info.arg; + continue; + case 'C': + state.directory = opt_info.arg; + continue; + case 'D': + append(state.opt, " -D"); + append(state.opt, opt_info.arg); + state.debug = -opt_info.num; + continue; + case 'G': + append(state.opt, " -G"); + search(state.vars, "-debug-symbols", "1"); + continue; + case 'S': + append(state.opt, " -S"); + search(state.vars, "-strip-symbols", "1"); + continue; + case '?': + error(ERROR_USAGE|4, "%s", opt_info.arg); + continue; + case ':': + error(2, "%s", opt_info.arg); + continue; + } + break; + } + if (error_info.errors) + error(ERROR_USAGE|4, "%s", optusage(NiL)); + argv += opt_info.index; +#else + while ((s = *++argv) && *s == '-') + { + if (*(s + 1) == '-') + { + if (!*(s + 2)) + { + append(state.opt, " --"); + argv++; + break; + } + for (t = s += 2; *t && *t != '='; t++); + if (!strncmp(s, "debug-symbols", t - s) && append(state.opt, " -G") || !strncmp(s, "strip-symbols", t - s) && append(state.opt, " -S")) + { + if (*t) + { + v = t + 1; + if (t > s && *(t - 1) == '+') + t--; + c = *t; + *t = 0; + } + else + { + c = 0; + v = "1"; + } + search(state.vars, s - 1, v); + if (c) + *t = c; + continue; + } + usage(); + break; + } + for (;;) + { + switch (*++s) + { + case 0: + break; + case 'e': + append(state.opt, " -e"); + state.explain = 1; + continue; + case 'i': + append(state.opt, " -i"); + state.ignore = 1; + continue; + case 'k': + append(state.opt, " -k"); + state.keepgoing = 1; + continue; + case 'N': + state.never = 1; + /*FALLTHROUGH*/ + case 'n': + append(state.opt, " -n"); + state.exec = 0; + continue; + case 'F': + append(state.opt, " -F"); + state.force = 1; + continue; + case 'G': + append(state.opt, " -G"); + search(state.vars, "-debug-symbols", "1"); + continue; + case 'K': + continue; + case 'S': + append(state.opt, " -S"); + search(state.vars, "-strip-symbols", "1"); + continue; + case 'V': + fprintf(stdout, "%s\n", id + 10); + exit(0); + case 'f': + case 'r': + case 'C': + case 'D': + t = s; + if (!*++s && !(s = *++argv)) + { + report(2, "option value expected", t, (unsigned long)0); + usage(); + } + else + switch (*t) + { + case 'f': + append(state.opt, " -f "); + append(state.opt, s); + state.file = s; + break; + case 'r': + state.recurse = s; + break; + case 'C': + state.directory = s; + break; + case 'D': + append(state.opt, " -D"); + append(state.opt, s); + state.debug = -atoi(s); + break; + } + break; + default: + report(2, "unknown option", s, (unsigned long)0); + case '?': + usage(); + break; + } + break; + } + } +#endif + + /* + * load the environment + */ + + for (e = environ; s = *e; e++) + for (t = s; *t; t++) + if (*t == '=') + { + *t = 0; + search(state.vars, s, t + 1); + *t = '='; + break; + } + + /* + * grab the command line targets and variable definitions + */ + + while (s = *argv++) + { + for (t = s; *t; t++) + if (*t == '=') + { + v = t + 1; + if (t > s && *(t - 1) == '+') + t--; + c = *t; + *t = 0; + search(state.vars, s, v); + tmp = buffer(); + append(tmp, s); + append(tmp, ".FORCE"); + search(state.vars, use(tmp), v); + drop(tmp); + *t = c; + break; + } + if (!*t) + { + /* + * handle a few targets for nmake compatibility + */ + + if (*s == 'e' && !strncmp(s, "error 0 $(MAKEVERSION:", 22)) + exit(1); + if (*s == 'r' && !strcmp(s, "recurse") || *s == 'c' && !strncmp(s, "cc-", 3)) + continue; + rule(s)->flags |= RULE_active; + state.active = 0; + if (state.recurse) + continue; + } + add(state.opt, ' '); + add(state.opt, '\''); + append(state.opt, s); + add(state.opt, '\''); + } + + /* + * initialize the views + */ + + if (state.directory && chdir(state.directory)) + report(3, "cannot change working directory", NiL, (unsigned long)0); + view(); + + /* + * recursion drops out here + */ + + if (state.recurse) + return recurse(state.recurse); + + /* + * read the mamfile(s) and bring the targets up to date + */ + + search(state.vars, "MAMAKEARGS", duplicate(use(state.opt) + 1)); + push(state.file, (Stdio_t*)0, STREAM_MUST); + make(rule("")); + pop(); + + /* + * verify that active targets were made + */ + + if (!state.active && !state.verified) + walk(state.rules, verify, NiL); + + /* + * done + */ + + return state.errors != 0; +} diff --git a/src/cmd/INIT/mamake.rt b/src/cmd/INIT/mamake.rt new file mode 100644 index 0000000..5f7603d --- /dev/null +++ b/src/cmd/INIT/mamake.rt @@ -0,0 +1,40 @@ +NOTE regression tests for the mamake command + +UNIT mamake + +TEST macros + +DATA Mamfile <<'!' +info mam static 00000 1994-07-17 make (AT&T Research) 5.3 2009-05-05 +setv DEFINED defined +setv EMPTY +make all + +exec - echo DEFINED ${DEFINED} +exec - echo DEFINED:VALUE ${DEFINED:VALUE} +exec - echo DEFINED:-VALUE ${DEFINED:-VALUE} +exec - echo DEFINED=VALUE ${DEFINED=VALUE} +exec - echo DEFINED[VALUE] ${DEFINED[VALUE]} +exec - echo DEFINED.COMPONENT ${DEFINED.COMPONENT} +exec - echo DEFINED.COMPONENT[VALUE] ${DEFINED.COMPONENT[VALUE]} + +exec - echo EMPTY ${EMPTY} +exec - echo EMPTY:VALUE ${EMPTY:VALUE} +exec - echo EMPTY:-VALUE ${EMPTY:-VALUE} +exec - echo EMPTY=VALUE ${EMPTY=VALUE} +exec - echo EMPTY[VALUE] ${EMPTY[VALUE]} +exec - echo EMPTY.COMPONENT ${EMPTY.COMPONENT} +exec - echo EMPTY.COMPONENT[VALUE] ${EMPTY.COMPONENT[VALUE]} + +exec - echo __NoT_DeFiNeD__ ${__NoT_DeFiNeD__} +exec - echo __NoT_DeFiNeD__:VALUE ${__NoT_DeFiNeD__:VALUE} +exec - echo __NoT_DeFiNeD__:-VALUE ${__NoT_DeFiNeD__:-VALUE} +exec - echo __NoT_DeFiNeD__=VALUE ${__NoT_DeFiNeD__=VALUE} +exec - echo __NoT_DeFiNeD__[VALUE] ${__NoT_DeFiNeD__[VALUE]} +exec - echo __NoT_DeFiNeD__.COMPONENT ${__NoT_DeFiNeD__.COMPONENT} +exec - echo __NoT_DeFiNeD__.COMPONENT[VALUE] ${__NoT_DeFiNeD__.COMPONENT[VALUE]} + +done all generated virtual +! + +EXEC -n diff --git a/src/cmd/INIT/mamake.tst b/src/cmd/INIT/mamake.tst new file mode 100644 index 0000000..3c7f94d --- /dev/null +++ b/src/cmd/INIT/mamake.tst @@ -0,0 +1,63 @@ +# : : generated from mamake.rt by mktest : : # + +# regression tests for the mamake command + +UNIT mamake + +TEST 01 macros + + EXEC -n + INPUT -n - + INPUT Mamfile $'info mam static 00000 1994-07-17 make (AT&T Research) 5.3 2009-05-05 +setv DEFINED defined +setv EMPTY +make all + +exec - echo DEFINED ${DEFINED} +exec - echo DEFINED:VALUE ${DEFINED:VALUE} +exec - echo DEFINED:-VALUE ${DEFINED:-VALUE} +exec - echo DEFINED=VALUE ${DEFINED=VALUE} +exec - echo DEFINED[VALUE] ${DEFINED[VALUE]} +exec - echo DEFINED.COMPONENT ${DEFINED.COMPONENT} +exec - echo DEFINED.COMPONENT[VALUE] ${DEFINED.COMPONENT[VALUE]} + +exec - echo EMPTY ${EMPTY} +exec - echo EMPTY:VALUE ${EMPTY:VALUE} +exec - echo EMPTY:-VALUE ${EMPTY:-VALUE} +exec - echo EMPTY=VALUE ${EMPTY=VALUE} +exec - echo EMPTY[VALUE] ${EMPTY[VALUE]} +exec - echo EMPTY.COMPONENT ${EMPTY.COMPONENT} +exec - echo EMPTY.COMPONENT[VALUE] ${EMPTY.COMPONENT[VALUE]} + +exec - echo __NoT_DeFiNeD__ ${__NoT_DeFiNeD__} +exec - echo __NoT_DeFiNeD__:VALUE ${__NoT_DeFiNeD__:VALUE} +exec - echo __NoT_DeFiNeD__:-VALUE ${__NoT_DeFiNeD__:-VALUE} +exec - echo __NoT_DeFiNeD__=VALUE ${__NoT_DeFiNeD__=VALUE} +exec - echo __NoT_DeFiNeD__[VALUE] ${__NoT_DeFiNeD__[VALUE]} +exec - echo __NoT_DeFiNeD__.COMPONENT ${__NoT_DeFiNeD__.COMPONENT} +exec - echo __NoT_DeFiNeD__.COMPONENT[VALUE] ${__NoT_DeFiNeD__.COMPONENT[VAL'\ +$'UE]} + +done all generated virtual' + OUTPUT - $'echo DEFINED defined +echo DEFINED:VALUE +echo DEFINED:-VALUE +echo DEFINED=VALUE defined +echo DEFINED[VALUE] ${DEFINED[VALUE]} +echo DEFINED.COMPONENT +echo DEFINED.COMPONENT[VALUE] ${DEFINED.COMPONENT[VALUE]} +echo EMPTY +echo EMPTY:VALUE ${EMPTY:VALUE} +echo EMPTY:-VALUE ${EMPTY:-VALUE} +echo EMPTY=VALUE +echo EMPTY[VALUE] ${EMPTY[VALUE]} +echo EMPTY.COMPONENT +echo EMPTY.COMPONENT[VALUE] ${EMPTY.COMPONENT[VALUE]} +echo __NoT_DeFiNeD__ ${__NoT_DeFiNeD__} +echo __NoT_DeFiNeD__:VALUE ${__NoT_DeFiNeD__:VALUE} +echo __NoT_DeFiNeD__:-VALUE ${__NoT_DeFiNeD__:-VALUE} +echo __NoT_DeFiNeD__=VALUE ${__NoT_DeFiNeD__=VALUE} +echo __NoT_DeFiNeD__[VALUE] ${__NoT_DeFiNeD__[VALUE]} +echo __NoT_DeFiNeD__.COMPONENT +echo __NoT_DeFiNeD__.COMPONENT[VALUE] ${__NoT_DeFiNeD__.COMPONENT[VALUE]}' + ERROR -n - diff --git a/src/cmd/INIT/mamprobe.sh b/src/cmd/INIT/mamprobe.sh new file mode 100644 index 0000000..6933bea --- /dev/null +++ b/src/cmd/INIT/mamprobe.sh @@ -0,0 +1,267 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +### this script contains archaic constructs that work with all sh variants ### +# mamprobe - generate MAM cc probe info +# Glenn Fowler <gsf@research.att.com> + +case $-:$BASH_VERSION in +*x*:[0123456789]*) : bash set -x is broken :; set +ex ;; +esac + +command=mamprobe + +# check the options + +opt= + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) USAGE=$' +[-? +@(#)$Id: mamprobe (AT&T Labs Research) 2011-02-11 $ +] +[+NAME?mamprobe - generate MAM cc probe info] +[+DESCRIPTION?\bmamprobe\b generates MAM (make abstract machine) \bcc\b(1) + probe information for use by \bmamake\b(1). \acc-path\a is the + absolute path of the probed compiler and \ainfo-file\a is where + the information is placed. \ainfo-file\a is usually + \b$INSTALLROOT/lib/probe/C/mam/\b\ahash\a, where \ahash\a is a hash + of \acc-path\a. Any \ainfo-file\a directories are created if needed. + If \ainfo-file\a is \b-\b then the probe information is written to + the standard output.] +[+?\bmamprobe\b and \bmamake\b are used in the bootstrap phase of + \bpackage\b(1) installation before \bnmake\b(1) is built. The + probed variable names are the \bnmake\b(1) names with a \bmam_\b + prefix, \bCC\b converted to \bcc\b, and \b.\b converted to \b_\b. + Additional variables are:]{ + [+_hosttype_?the \bpackage\b(1) host type] + [+mam_cc_L?\b-L\b\adir\a supported] + [+STDCAT?command to execute for \bcat\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] + [+STDCHMOD?command to execute for \bchmod\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] + [+STDCMP?command to execute for \bcmp\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] + [+STDCP?command to execute for \bcp\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] + [+STDED?command to execute for \bed\b(1) or \bex\b(1)] + [+STDEDFLAGS?flags for \bSTDED\b] + [+STDLN?command to execute for \bln\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] + [+STDMV?command to execute for \bmv\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] + [+STDRM?command to execute for \brm\b(1); prefixed by + \bexecrate\b(1) on \b.exe\b challenged systems] +} +[d:debug?Enable probe script debug trace.] + +info-file cc-path + +[+SEE ALSO?\bexecrate\b(1), \bpackage\b(1), \bmamake\b(1), \bnmake\b(1), + \bprobe\b(1)] +' + while getopts -a "$command" "$USAGE" OPT + do case $OPT in + d) opt=-d ;; + esac + done + shift `expr $OPTIND - 1` + ;; +*) while : + do case $# in + 0) break ;; + esac + case $1 in + --) shift + break + ;; + -) break + ;; + -d) opt=-d + ;; + -*) echo $command: $1: unknown option >&2 + ;; + *) break + ;; + esac + set '' + break + done + ;; +esac + +# check the args + +case $1 in +-) ;; +/*) ;; +*) set '' ;; +esac +case $2 in +/*) ;; +*) set '' ;; +esac +case $# in +0|1) echo "Usage: $command info-file cc-path" >&2; exit 2 ;; +esac +info=$1 +shift +cc=$* + +# find the make probe script + +ifs=${IFS-' + '} +IFS=: +set $PATH +IFS=$ifs +script=lib/probe/C/make/probe +while : +do case $# in + 0) echo "$0: ../$script: probe script not found on PATH" >&2 + exit 1 + ;; + esac + case $1 in + '') continue ;; + esac + makeprobe=`echo $1 | sed 's,[^/]*$,'$script,` + if test -x $makeprobe + then break + fi + shift +done + +# create the info dir if necessary + +case $info in +/*) i=X$info + ifs=${IFS-' + '} + IFS=/ + set $i + IFS=$ifs + while : + do i=$1 + shift + case $i in + X) break ;; + esac + done + case $info in + //*) path=/ ;; + *) path= ;; + esac + while : + do case $# in + 0|1) break ;; + esac + comp=$1 + shift + case $comp in + '') continue ;; + esac + path=$path/$comp + if test ! -d $path + then mkdir $path || exit + fi + done + ;; +esac + +# generate info in a tmp file and rename when finished + +case $info in +-) ;; +*) tmp=/tmp/mam$$ + trap "exec >/dev/null; rm -f $tmp" 0 1 2 3 15 + exec > $tmp + echo "probing C language processor $cc for mam information" >&2 + ;; +esac + +echo "note generated by $0 for $cc" + +( + set '' $opt $cc + shift + . $makeprobe "$@" + + case " $CC_DIALECT " in + *" -L "*) echo "CC.L = 1" ;; + esac + +) | sed \ + -e '/^CC\./!d' \ + -e 's/^CC./setv mam_cc_/' \ + -e 's/^\([^=.]*\)\./\1_/' \ + -e 's/^\([^=.]*\)\./\1_/' \ + -e 's/ =//' \ + -e 's/\$("\([^"]*\)")/\1/g' \ + -e 's/\$(\([^)]*\))/${\1}/g' \ + -e 's/\${CC\./${mam_cc_}/g' + +echo 'setv _hosttype_ ${mam_cc_HOSTTYPE}' + +# STD* are standard commands/flags with possible execrate(1) + +if ( +ed <<! +q +! +) < /dev/null > /dev/null 2>&1 +then STDED=ed +else STDED=ex +fi +STDEDFLAGS=- +set STDCAT cat STDCHMOD chmod STDCMP cmp STDCP cp STDLN ln STDMV mv STDRM rm +while : +do case $# in + 0|1) break ;; + esac + p=$2 + for d in /bin /usr/bin /usr/sbin + do if test -x $d/$p + then p=$d/$p + break + fi + done + eval $1=\$p + shift + shift +done +if execrate +then for n in STDCAT STDCHMOD STDCMP STDCP STDLN STDMV STDRM + do eval $n=\"execrate \$$n\" + done +fi +for n in STDCAT STDCHMOD STDCMP STDCP STDED STDEDFLAGS STDLN STDMV STDRM +do eval echo setv \$n \$$n +done + +# all done + +case $info in +-) ;; +*) exec >/dev/null + test -f $info && rm -f $info + cp $tmp $info + chmod -w $info + ;; +esac diff --git a/src/cmd/INIT/mkdir.sh b/src/cmd/INIT/mkdir.sh new file mode 100644 index 0000000..c929e95 --- /dev/null +++ b/src/cmd/INIT/mkdir.sh @@ -0,0 +1,80 @@ +#!/bin/sh +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: mkdir for systems that do not support -p : 2002-09-01 : +MKDIR=/bin/mkdir +CHMOD=chmod +mode= +parents= +while : +do case $1 in + -m) case $# in + 1) echo "mkdir: -m: mode argument expected" >&2 + exit 1 + ;; + esac + shift + mode=$1 + ;; + -m*) mode=`echo X$1 | sed 's/X-m//'` + ;; + -p) parents=1 + ;; + *) break + ;; + esac + shift +done +if test "" != "$parents" +then for d + do if test ! -d $d + then ifs=${IFS-' + '} + IFS=/ + set '' $d + IFS=$ifs + shift + dir=$1 + shift + if test -n "$dir" -a ! -d "$dir" + then $MKDIR "$dir" || exit 1 + if test "" != "$mode" + then $CHMOD "$mode" "$dir" || exit 1 + fi + fi + for d + do dir=$dir/$d + if test ! -d "$dir" + then $MKDIR "$dir" || exit 1 + if test "" != "$mode" + then $CHMOD "$mode" "$dir" || exit 1 + fi + fi + done + fi + done +else $MKDIR "$@" || exit 1 + if test "" != "$mode" + then for d + do $CHMOD "$mode" "$d" || exit 1 + done + fi +fi +exit 0 diff --git a/src/cmd/INIT/mktest.sh b/src/cmd/INIT/mktest.sh new file mode 100755 index 0000000..f24183e --- /dev/null +++ b/src/cmd/INIT/mktest.sh @@ -0,0 +1,641 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: mktest - generate regress or shell regression test scripts + +command=mktest +stdin=8 +stdout=9 +PREFIX=test +STYLE=regress +WIDTH=80 + +eval "exec $stdout>&1" + +case $(getopts '[-][123:xyz]' opt --xyz 2>/dev/null; echo 0$opt) in +0123) ARGV0="-a $command" + USAGE=$' +[-? +@(#)$Id: mktest (AT&T Labs Research) 2010-08-11 $ +] +'$USAGE_LICENSE$' +[+NAME?mktest - generate a regression test scripts] +[+DESCRIPTION?\bmktest\b generates regression test scripts from test + template commands in the \aunit\a.\brt\b file. The generated test + script writes temporary output to '$PREFIX$'\aunit\a.tmp and compares + it to the expected output in '$PREFIX$'\aunit\a.out. Run the test + script with the \b--accept\b option to (re)generate the + '$PREFIX$'\aunit\a.out.] +[s:style?The script style:]:[style:='$STYLE$'] + { + [+regress?\bregress\b(1) command input.] + [+shell?Standalone test shell script.] + } +[w:width?Set the output format width to approximately + \awidth\a.]:[width:='$WIDTH$'] + +unit.rt [ unit [ arg ... ] ] + +[+INPUT FILES?The regression test command file \aunit\a\b.rt\b is a + \bksh\b(1) script that makes calls to the following functions:] + { + [+DATA \afile\a [ - | [ options ]] data]]?Create input data + \afile\a that is empty (-) or contains \adata\a subject to + \bprint\b(1) \aoptions\a or that is a copy of the DATA command + standard input. Set \afile\a to \b-\b to name the standard + input.] + [+DIAGNOSTICS?Diagnostic messages of unspecified format are + expected.] + [+DO \acommand\a [ \aarg\a ... ]]?Execute \acommand\a if the + current test is active.] + [+EXEC [ \aarg\a ... ]]?Run the command under test with + optional arguments. If the standard input is not specified then + the standard input of the previous EXEC is used. The standard + input of the first EXEC in a TEST group is an empty regular + file.] + [+EXPORT \aname\a=\avalue\a ...?Export list for subsequent + commands in the TEST group or for all TEST groups if before + the first TEST group.] + [+IGNORESPACE [ 0 | 1 ] + ?Ignore space differences when comparing expected output.] + [+KEEP \apattern\a ...?File match patterns of files to retain + between TEST groups.] + [+NOTE \acomment\a?\acomment\a is added to the current test + script.] + [+PROG \acommand\a [ \aarg\a ... ]]?Run \acommand\a with + optional arguments.] + [+TEST [ \anumber\a ]] [ \adescription\a ... ]]?Define a new + test group with optional \anumber\a and \adescripion\a.] + [+TWD [ \adir\a ... ]]?Set the temporary test dir to \adir\a. + The default is \aunit\a\b.tmp\b, where \aunit\a is the test + input file sans directory and suffix. If \adir\a matches \b/*\b + then it is the directory name; if \adir\a is non-null then the + prefix \b${TMPDIR:-/tmp}\b is added; otherwise if \adir\a is + omitted then + \b${TMPDIR:-/tmp}/tst-\b\aunit\a-$$-$RANDOM.\b\aunit\a is + used.] + [+UMASK [ \amask\a ]]?Run subsequent tests with \bumask\b(1) + \amask\a. If \amask\a is omitted then the original \bumask\b is + used.] + [+UNIT \acommand\a [ \aarg\a ... ]]?Define the command and + optional default arguments to be tested. \bUNIT\b explicitly + overrides the default command name derived from the test script + file name.] + [+WIDTH \awidth\a?Set the output format width to approximately + \awidth\a.] + } +[+SEE ALSO?\bregress\b(1), \bksh\b(1)] +' + ;; +*) ARGV0="" + USAGE='s: unit.rt [ arg ... ]' + ;; +esac + +typeset ARG SCRIPT UNIT TEMP=${TMPDIR:-/tmp}/$command.$$.tmp WORK +typeset IO INPUT INPUT_N OUTPUT OUTPUT_N ERROR ERROR_N KEEP +typeset -C STATE +typeset -A DATA STATE.RESET REMOVE FORMAT +integer KEEP_UNIT=0 SCRIPT_UNIT=0 TEST=0 CODE=0 EXIT=0 ACCEPT=0 DIAGNOSTICS=0 code + +while getopts $ARGV0 "$USAGE" OPT +do case $OPT in + s) case $OPTARG in + regress|shell) + STYLE=$OPTARG + ;; + *) print -u2 -r -- $command: --style=$OPTARG: regress or shell expected + exit 1 + ;; + esac + ;; + w) WIDTH=$OPTARG + ;; + *) OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 + ;; + esac +done +shift $OPTIND-1 + +typeset SINGLE= quote='%${SINGLE}..${WIDTH}q' + +if [[ $1 == - ]] +then shift +fi +if (( ! $# )) +then + print -u2 -r -- $command: test command script path expected + exit 1 +fi +SCRIPT=$1 +shift +if [[ ! -r $SCRIPT ]] +then print -u2 -r -- $command: $SCRIPT: cannot read + exit 1 +fi +(ulimit -c 0) >/dev/null 2>&1 && ulimit -c 0 +if (( $# )) +then set -A UNIT -- "$@" + KEEP_UNIT=1 +else ARG=${SCRIPT##*/} + set -A UNIT -- "${ARG%.*}" +fi +WORK=${UNIT[0]}.tmp +rm -rf $WORK +mkdir $WORK || exit +export PATH=$PWD:$PATH + +function LINE +{ + if [[ $STYLE == regress ]] + then print -u$stdout + fi +} + +function NOTE +{ + case $STYLE in + regress)LINE + print -u$stdout -r -- '#' "$@" + ;; + shell) print -u$stdout -r -f ": $QUOTE"$'\n' -- "$*" + ;; + esac +} + +function UNIT +{ + (( KEEP_UNIT )) || set -A UNIT -- "$@" + case $STYLE in + regress)LINE + print -u$stdout -r -f $'UNIT' + for ARG in "$@" + do print -u$stdout -r -f " $QUOTE" -- "$ARG" + done + print -u$stdout + ;; + shell) print -u$stdout -r -f $'set x' + for ARG in "$@" + do print -u$stdout -r -f " $QUOTE" -- "$ARG" + done + print -u$stdout + print -u$stdout shift + ;; + esac +} + +function TEST +{ + typeset i + typeset -A REM + if (( ${#STATE.RESET[@]} )) + then unset ${!STATE.RESET[@]} + case $STYLE in + shell) print -u$stdout -r -- unset ${!STATE.RESET[@]} ;; + esac + unset STATE.RESET + typeset -A STATE.RESET + fi + if (( ${#REMOVE[@]} )) + then rm -f -- "${!REMOVE[@]}" + case $STYLE in + shell) print -u$stdout -r -f $'rm -f' + for i in ${!REMOVE[@]} + do print -u$stdout -r -f " $QUOTE" "$i" + done + print -u$stdout + ;; + esac + for i in ${!REMOVE[@]} + do unset REMOVE[$i] + done + fi + rm -rf $WORK/* + if [[ $1 == +([0-9]) ]] + then TEST=${1##0} + shift + else ((TEST++)) + fi + LINE + case $STYLE in + regress)print -u$stdout -r -f "TEST %02d $QUOTE"$'\n' -- $TEST "$*" + ;; + shell) print -u$stdout -r -f ": TEST %02d $QUOTE"$'\n' -- $TEST "$*" + ;; + esac + : > $TEMP.INPUT > $TEMP.in + INPUT= + INPUT_N= + OUTPUT= + OUTPUT_N= + ERROR= + ERROR_N= + UMASK=$UMASK_ORIG + UMASK_DONE=$UMASK + CODE=0 +} + +function TWD +{ + case $STYLE in + regress)LINE + print -u$stdout -r -f $'TWD' + for ARG in "$@" + do print -u$stdout -r -f " $QUOTE" -- "$ARG" + done + print -u$stdout + ;; + esac +} + +function RUN +{ + typeset i n p op unit sep output=1 error=1 exitcode=1 + op=$1 + shift + while : + do case $1 in + ++NOOUTPUT) output= ;; + ++NOERROR) error= ;; + ++NOEXIT) exitcode= ;; + ++*) print -u2 -r -- $command: $0: $1: unknown option; exit 1 ;; + *) break ;; + esac + shift + done + if [[ $op == PROG ]] + then unit=$1 + shift + elif (( ! ${#UNIT[@]} )) + then print -u2 -r -- $command: $SCRIPT: UNIT statement or operand expected + exit 1 + fi + LINE + case $STYLE in + regress)if [[ $op == PROG ]] + then print -u$stdout -r -f $'\t'"$op"$'\t'"$unit" + sep=$' ' + else print -u$stdout -r -f $'\t'"$op" + sep=$'\t' + fi + for ARG in "$@" + do LC_CTYPE=C print -u$stdout -r -f "$sep$QUOTE" -- "$ARG" + sep=$' ' + done + print -u$stdout + [[ ${DATA[-]} || /dev/fd/0 -ef /dev/fd/$stdin ]] || cat > $TEMP.in + IO=$(cat $TEMP.in; print :) + if [[ $IO == ?*$'\n:' ]] + then IO=${IO%??} + n= + else IO=${IO%?} + n=-n + fi + { + [[ $UMASK != $UMASK_ORIG ]] && umask $UMASK + cd $WORK + if [[ $op == PROG ]] + then "$unit" "$@" + code=$? + else "${UNIT[@]}" "$@" + code=$? + fi + cd .. + [[ $UMASK != $UMASK_ORIG ]] && umask $UMASK_ORIG + } < $TEMP.in > $TEMP.out 2> $TEMP.err + if [[ $IO != "$INPUT" || $n != "$INPUT_N" ]] + then INPUT=$IO + INPUT_N=$n + if [[ ${FORMAT[-]} ]] + then print -u$stdout -n -r -- $'\t\tINPUT' + print -u$stdout -r -f " $QUOTE" -- "${FORMAT[-]}" + print -u$stdout -r -f " $QUOTE" -- - + unset FORMAT[-] + else print -u$stdout -n -r -- $'\t\tINPUT' $n - + [[ $IO ]] && LC_CTYPE=C print -u$stdout -r -f " $QUOTE" -- "$IO" + fi + print -u$stdout + unset DATA[-] + fi + for i in ${!DATA[@]} + do if [[ ${FORMAT[$i]} ]] + then print -u$stdout -n -r -- $'\t\tINPUT' + print -u$stdout -r -f " $QUOTE" -- "${FORMAT[$i]}" + print -u$stdout -r -f " $QUOTE" -- "$i" + unset FORMAT[$i] + else case $i in + -) p=$TEMP.in ;; + *) p=$WORK/$i ;; + esac + IO=$(cat $p; print :) + if [[ $IO == ?*$'\n:' ]] + then IO=${IO%??} + n= + else IO=${IO%?} + n=-n + fi + print -u$stdout -n -r -- $'\t\tINPUT' $n + print -u$stdout -r -f " $QUOTE" -- "$i" + [[ $IO ]] && LC_CTYPE=C print -u$stdout -r -f " $QUOTE" -- "$IO" + fi + print -u$stdout + unset DATA[$i] + done + IO=$(cat $TEMP.out; print :) + if [[ $IO == ?*$'\n:' ]] + then IO=${IO%??} + n= + else IO=${IO%?} + n=-n + fi + if [[ $IO != "$OUTPUT" || $n != "$OUTPUT_N" ]] + then OUTPUT=$IO + OUTPUT_N=$n + if [[ $output ]] + then if [[ ! -s $TEMP.out ]] + then print -u$stdout -n -r -- $'\t\tOUTPUT' - + elif cmp -s $TEMP.in $TEMP.out + then OUTPUT=not-$OUTPUT + print -u$stdout -n -r -- $'\t\tSAME OUTPUT INPUT' + else print -u$stdout -n -r -- $'\t\tOUTPUT' $n - + [[ $IO ]] && LC_CTYPE=C print -u$stdout -r -f " $QUOTE" -- "$IO" + fi + print -u$stdout + fi + fi + IO=$(cat $TEMP.err; print :) + IO=${IO//$command\[*([0-9])\]:\ .\[*([0-9])\]:\ @(EXEC|PROG)\[*([0-9])\]:\ /} + if [[ $IO == ?*$'\n:' ]] + then IO=${IO%??} + n= + else IO=${IO%?} + n=-n + fi + if [[ $IO != "$ERROR" || $n != "$ERROR_N" ]] + then ERROR=$IO + ERROR_N=$n + if [[ $error ]] + then print -u$stdout -n -r -- $'\t\tERROR' $n - + [[ $IO ]] && LC_CTYPE=C print -u$stdout -r -f " $QUOTE" -- "$IO" + print -u$stdout + fi + fi + case $output:$error in + :) OUTPUT= + OUTPUT_N= + ERROR= + ERROR_N= + print -u$stdout -r -- $'\t\tIGNORE OUTPUT ERROR' + ;; + :1) OUTPUT= + OUTPUT_N= + print -u$stdout -r -- $'\t\tIGNORE OUTPUT' + ;; + 1:) ERROR= + ERROR_N= + print -u$stdout -r -- $'\t\tIGNORE ERROR' + ;; + esac + if [[ $UMASK_DONE != $UMASK ]] + then UMASK_DONE=$UMASK + print -u$stdout -r -f $'\t\tUMASK %s\n' $UMASK + fi + if (( code != CODE )) + then (( CODE=code )) + if [[ $exitcode ]] + then print -u$stdout -r -f $'\t\tEXIT %d\n' $CODE + fi + fi + ;; + shell) [[ $UMASK != $UMASK_ORIG ]] && print -u$stdout -r -f "{ umask $UMASK; " + if [[ $op == PROG ]] + then print -u$stdout -r -f $'"'"$unit"$'"' + else print -u$stdout -r -f $'"$@"' + fi + for ARG in "$@" + do print -u$stdout -r -f " $QUOTE" -- "$ARG" + done + [[ $UMASK != $UMASK_ORIG ]] && print -u$stdout -r -f "umask $UMASK_ORIG; } " + if [[ ! $output ]] + then print -u$stdout -r -f " >/dev/null" + fi + if [[ ! $error ]] + then if [[ ! $output ]] + then print -u$stdout -r -f " 2>&1" + else print -u$stdout -r -f " 2>/dev/null" + fi + fi + IO=$(cat) + if [[ $IO ]] + then print -u$stdout -r -- "<<'!TEST-INPUT!'" + print -u$stdout -r -- "$IO" + print -u$stdout -r -- !TEST-INPUT! + else print -u$stdout + fi + if [[ $exitcode ]] + then print -u$stdout -r -- $'CODE=$?\ncase $CODE in\n0) ;;\n*) echo exit status $CODE ;;\nesac' + fi + ;; + esac +} + +function DO +{ + LINE + print -r $'\t'DO "$@" +} + +function EXEC +{ + RUN EXEC "$@" +} + +function DATA +{ + typeset f p o + f=$1 + shift + case $f in + -) p=$TEMP.in ;; + *) p=$WORK/$f ;; + esac + case $1 in + '') cat ;; + -) ;; + *) print -r "$@" ;; + esac > $p + DATA[$f]=1 + if (( $# == 1 )) && [[ $1 == -?* ]] + then FORMAT[$f]=$1 + else FORMAT[$f]= + fi + if [[ $f != $KEEP ]] + then REMOVE[$f]=1 + fi + if [[ $STYLE == shell ]] + then { + print -r -f "cat > $QUOTE <<'!TEST-INPUT!'"$'\n' -- "$f" + cat "$p" + print -r -- !TEST-INPUT! + } >&$stdout + fi +} + +function KEEP +{ + typeset p + for p + do if [[ $KEEP ]] + then KEEP=$KEEP'|' + fi + KEEP=$KEEP$p + done +} + +function DIAGNOSTICS +{ + LINE + case $STYLE in + regress) print -u$stdout -r $'DIAGNOSTICS' ;; + shell) DIAGNOSTICS=1 ;; + esac +} + +function EXPORT +{ + typeset x n v + LINE + case $STYLE in + regress) print -u$stdout -r -f $'EXPORT' ;; + shell) print -u$stdout -r -f $'export' ;; + esac + for x + do n=${x%%=*} + v=${x#*=} + export "$x" + print -u$stdout -r -f " %s=$QUOTE" "$n" "$v" + (( TEST )) && STATE.RESET["$n"]=1 + done + print -u$stdout +} + +function PROG +{ + RUN PROG "$@" +} + +function WIDTH +{ + WIDTH=${1:-80} + eval QUOTE='"'$quote'"' +} + +function IGNORESPACE +{ + IGNORESPACE=-b + LINE + print -u$stdout -r IGNORESPACE +} + +function UMASK # [ mask ] +{ + [[ $UMASK_ORIG ]] || UMASK_ORIG=$(umask) + UMASK=$1 + [[ $UMASK ]] || UMASK=$UMASK_ORIG +} + +trap 'CODE=$?; rm -rf $TEMP.* $WORK; exit $CODE' 0 1 2 3 15 + +typeset IGNORESPACE UMASK UMASK_ORIG UMASK_DONE +UMASK_ORIG=$(umask) +IFS=$IFS$'\n' + +print -u$stdout -r "# : : generated from $SCRIPT by $command : : #" +case $STYLE in +shell) cat <<! +ACCEPT=0 +while : +do case \$1 in + -a|--accept) + ACCEPT=1 + ;; + --help|--man) + cat 1>&2 <<!! +Usage: \\\$SHELL $PREFIX${UNIT[0]}.sh [ --accept ] [ unit ... ] + +${UNIT[0]} regression test script. Run this script to generate new +results in $PREFIX${UNIT[0]}.tmp and compare with expected results in +$PREFIX${UNIT[0]}.out. The --accept option generates $PREFIX${UNIT[0]}.tmp +and moves it to $PREFIX${UNIT[0]}.out. +!! + exit 2 + ;; + -*) echo \$0: \$1: invalid option >&2 + exit 1 + ;; + *) break + ;; + esac + shift +done +export COLUMNS=80 +{ +! + ;; +esac + +export COLUMNS=80 + +case $STYLE in +shell) SINGLE='#' + eval QUOTE='"'$quote'"' + . $SCRIPT < /dev/null | sed -e $'s,\\\\n,\n,g' -e $'s,\\\\t,\t,g' -e $'s,\\$\',\',g' + ;; +*) eval QUOTE='"'$quote'"' + : > $TEMP.INPUT > $TEMP.in + eval "exec $stdin<$TEMP.INPUT" + . $SCRIPT <&$stdin + ;; +esac + +case $STYLE in +shell) cat <<! +} > $PREFIX${UNIT[0]}.tmp 2>&1 < /dev/null +case \$ACCEPT in +0) if grep '
$' $PREFIX${UNIT[0]}.tmp >/dev/null + then mv $PREFIX${UNIT[0]}.tmp $PREFIX${UNIT[0]}.junk + sed 's/
$//' < $PREFIX${UNIT[0]}.junk > $PREFIX${UNIT[0]}.tmp + rm -f $PREFIX${UNIT[0]}.junk + fi + if cmp -s $PREFIX${UNIT[0]}.tmp $PREFIX${UNIT[0]}.out + then echo ${UNIT[0]} tests PASSED + rm -f $PREFIX${UNIT[0]}.tmp + else echo ${UNIT[0]} tests FAILED + diff $IGNORESPACE $PREFIX${UNIT[0]}.tmp $PREFIX${UNIT[0]}.out + fi + ;; + +*) mv $PREFIX${UNIT[0]}.tmp $PREFIX${UNIT[0]}.out + ;; +esac +! + ;; +esac diff --git a/src/cmd/INIT/mprobe.sh b/src/cmd/INIT/mprobe.sh new file mode 100644 index 0000000..975ebb1 --- /dev/null +++ b/src/cmd/INIT/mprobe.sh @@ -0,0 +1,30 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: mam probe script +opt= +while : +do case $1 in + -d) opt=-d ;; + -*) ;; + *) break ;; + esac + shift +done +mamprobe $opt - "$1" diff --git a/src/cmd/INIT/nsl.c b/src/cmd/INIT/nsl.c new file mode 100644 index 0000000..e961e01 --- /dev/null +++ b/src/cmd/INIT/nsl.c @@ -0,0 +1,31 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for -lnsl + */ + + +extern void* gethostbyname(); + +int +main() +{ + return gethostbyname(0) == 0; +} diff --git a/src/cmd/INIT/p.c b/src/cmd/INIT/p.c new file mode 100644 index 0000000..387c4bb --- /dev/null +++ b/src/cmd/INIT/p.c @@ -0,0 +1,24 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for prototyping cc + */ + +int main(int argc, char** argv) { return argc || argv; } diff --git a/src/cmd/INIT/package.mk b/src/cmd/INIT/package.mk new file mode 100644 index 0000000..921fa2d --- /dev/null +++ b/src/cmd/INIT/package.mk @@ -0,0 +1,1537 @@ +/* + * source and binary package support + * + * @(#)package.mk (AT&T Research) 2012-02-14 + * + * usage: + * + * cd $INSTALLROOT/lib/package + * nmake -f name [closure] [cyg|exp|lcl|pkg|rpm|tgz] [base|delta] type + * + * where: + * + * name package description file or component + * + * type source build source archive, generates + * $(PACKAGEDIR)/name.version.release.suffix + * binary build binary archive, generates + * $(PACKAGEDIR)/name.version.hosttype.release.suffix + * runtime build binary archive, generates + * $(PACKAGEDIR)/name-run.version.hosttype.release.suffix + * + * NOTE: $(PACKAGEDIR) is in the lowest view and is shared among all views + * + * generated archive member files are $(PACKAGEROOT) relative + * + * main assertions: + * + * NAME [ name=value ] :PACKAGE: component ... + * :OMIT: component ... + * :LICENSE: license-class-pattern + * :CATEGORY: category-id ... + * :COVERS: package ... + * :REQURES: package ... + * :INDEX: index description line + * :DESCRIPTION: + * [ verbose description ] + * :DETAILS: style + * :README: + * readme lines + * :EXPORT: + * name=value + * target :INSTALL: [ source ] + * + * option variables, shown with default values + * + * format=tgz + * archive format + * + * version=YYYY-MM-DD + * package base version (overrides current date) + * + * release=YYYY-MM-DD + * package delta release (overrides current date) + * + * license=type.class + * :LICENSE: type.class pattern override + * + * notice=1 + * include the conspicuous empty notice file + * + * copyright=0 + * do not prepend source file copyright notice + * + * strip=0 + * don't strip non-lcl binary package members + * + * variants=pattern + * include variants matching pattern in binary packages + * + * incremental=[source:1 binary:0] + * if a base archive is generated then also generate an + * incremental delta archive from the previous base + * + * NOTE: the Makerules.mk :PACKAGE: operator defers to :package: when + * a target is specified + */ + +/* these are ast centric -- we'll parameterize another day */ + +org = ast +url = http://www.research.att.com/sw/download + +/* generic defaults */ + +base = +category = utils +checksum = md5 +closure = +copyright = 1 +delta = +format = tgz +incremental = +index = +init = INIT +license = +licenses = $(org) +mamfile = 1 +opt = +name = +notice = +release = +strip = 0 +style = tgz +suffix = tgz +type = +variants = !(cc-g) +vendor = +version = $("":T=R%Y-%m-%d) + +SUM = sum + +package.notice = ------------ NOTICE -- LICENSED SOFTWARE -- SEE README FOR DETAILS ------------ + +package.readme = $(@.package.readme.) + +.package.readme. : + This is a package root directory $PACKAGEROOT. Source and binary + packages in this directory tree are controlled by the command + $() + bin/package + $() + Binary files may be in this directory or in the install root directory + $() + INSTALLROOT=$PACKAGEROOT/arch/`bin/package` + $() + For more information run + $() + bin/package help + $() + Many of the packaged commands self-document via the --man and --html + options; those that do have no separate man page. + $() + Each package is covered by one of the license files + $() + $(PACKAGELIB)/LICENSES/<license> + $() + where <license> is the license type for the package. At the top + of each license file is a URL; the license covers all software that + refers to this URL. For details run + $() + bin/package license [<package>] + $() + Any archives, distributions or packages made from source or + binaries covered by license(s) must contain the corresponding + license file(s)$(notice:?, this README file, and the empty file$$("\n")$$(package.notice)?.?) + +.package.licenses. : .FUNCTION + local I F L R T all save text + L := $(%) + while L == "--*" + I := $(L:O=1) + if I == "--all" + all = 1 + elif I == "--save" + save = 1 + elif I == "--text" + text = 1 + end + L := $(L:O>1) + end + if "$(L)" == "*-*" + L += $(L:/[^-]*-//) $(L:/-.*//) + end + L += $(licenses) + for I $(L:U) + if I == "gpl" + I = gnu + all = + end + if F = "$(I:D=$(PACKAGESRC):B:S=.lic:T=F)" + R += $(F) + if save || text + T := $(.FIND. lib/package .lic $(F):P=W,query=type) + R += $(T:D=$(PACKAGESRC)/LICENSES:B) + end + if save + R += $(F:T=I:N=*.def:D=$(PACKAGESRC):B:S:T=F) + elif ! all + break + end + end + end + return $(R) + +/* + * glob(3) doesn't handle / in alternation -- should it? + */ + +.package.glob. : .FUNCTION + local A D I P S + for I $(%) + if I == "*/*" + D := $(I:C,/.*,,) + if ! "$(A:N=$(D))" + local S.$(D) + A += $(D) + end + S.$(D) += $(I:C,[^/]*/,,) + else + P := $(P)$(S)$(I) + end + S = | + end + if P == "*\|*" + P := ($(P)) + end + for I $(A) + P += $(I)/$(.package.glob. $(S.$(I))) + end + return $(P) + + +.MAKEINIT : .package.init + +.package.init : .MAKE .VIRTUAL .FORCE + local V + V := $(VROOT:T=F:P=L*) + if ! PACKAGEROOT + PACKAGEROOT := $(V:N!=*/arch/+([!/]):O=1) + end + if V == "$(PACKAGEROOT)" + V := + end + V += $(INSTALLROOT) $(PACKAGEROOT) + PACKAGEVIEW := $(V:H=RU) + INSTALLOFFSET := $(INSTALLROOT:C%$(PACKAGEROOT)/%%) + if license + license := $(license)|none.none + end + +PACKAGELIB = lib/package +PACKAGESRC = $(PACKAGEROOT)/$(PACKAGELIB) +PACKAGEBIN = $(INSTALLROOT)/$(PACKAGELIB) +PACKAGEDIR = $(PACKAGESRC)/$(style) +INSTALLOFFSET = $(INSTALLROOT:C%$(PACKAGEROOT)/%%) + +package.omit = -|*/$(init) +package.glob.all = $(INSTALLROOT)/src/*/*/($(MAKEFILES:/:/|/G)) +package.all = $(package.glob.all:P=G:W=O=$(?$(name):A=.VIRTUAL):N!=$(package.omit):T=F:$(PACKAGEVIEW:C,.*,C;^&/;;,:/ /:/G):U) +package.glob.pkg = $(.package.glob. $(~$(name):P=U):C%.*%$(INSTALLROOT)/src/*/&/($(MAKEFILES:/:/|/G))%) $(~$(name):P=U:N=$(name):?$$(INSTALLROOT)/src/$$(name)/($$(MAKEFILES:/:/|/G))??) +package.pkg = $(package.glob.pkg:P=G:D:N!=$(package.omit):T=F:$(PACKAGEVIEW:C,.*,C;^&/;;,:/ /:/G):U) +package.closure = $(closure:?$$(package.all)?$$(package.pkg)?) + +package.init = $(.package.glob. $("$(init)$(name)":P=U):C%.*%$(INSTALLROOT)/src/*/&/($(MAKEFILES:/:/|/G))%:P=G:T=F:D::B) +package.ini = ignore mamprobe manmake package silent +package.src.pat = $(PACKAGESRC)/($(name).(ini|pkg)) +package.src = $(package.src.pat:P=G) $(.package.licenses. --save $(name)) +package.bin = $(PACKAGEBIN)/$(name).ini + +package.mam = --never --force --mam=static --corrupt=accept --clobber --compare --link='lib*.a*' CC=$(CC.DIALECT:N=C++:?CC?cc?) package.license.class=$(license:Q) $(=) 'dontcare test' install test + +op = current +stamp = [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] +source = $(PACKAGEDIR)/$(name).$(version)$(release:?.$(release)??).$(suffix) +binary = $(PACKAGEDIR)/$(name).$(version)$(release:?.$(release)??).$(CC.HOSTTYPE).$(suffix) +runtime = $(PACKAGEDIR)/$(name)-run.$(version)$(release:?.$(release)??).$(CC.HOSTTYPE).$(suffix) +old.new.source = $(PACKAGEDIR)/$(name).$(version).$(old.version).$(suffix) +old.new.binary = $(PACKAGEDIR)/$(name).$(version).$(old.version).$(CC.HOSTTYPE).$(suffix) +old.new.runtime = $(PACKAGEDIR)/$(name)-run.$(version).$(old.version).$(CC.HOSTTYPE).$(suffix) + +source.list = $("$(PACKAGEDIR)/$(name).*$(stamp).$(suffix)":P=G:H=R) +binary.list = $("$(PACKAGEDIR)/$(name).*$(stamp).$(CC.HOSTTYPE).$(suffix)":P=G:H=R) +runtime.list = $("$(PACKAGEDIR)/$(name)-run.*$(stamp).$(CC.HOSTTYPE).$(suffix)":P=G:H>) + +source.ratz = $("$(INSTALLROOT)/src/cmd/$(init)/ratz.c":T=F) +binary.ratz = $("$(INSTALLROOT)/src/cmd/$(init)/ratz":T=F) + +$(init) : .VIRTUAL $(init) + +package.requires = 0 + +":package:" : .MAKE .OPERATOR + local P I R V + P := $(<:O=1) + $(P) : $(>:V) + if ! package.requires + if ! name + name := $(P) + .PACKAGE. := $(P) + if name == "$(init)" + package.omit = - + package.src += $(package.ini:C,^,$(PACKAGEROOT)/bin/,) $(PACKAGESRC)/package.mk + else + $(P) : $(package.init) + end + for I $(<:O>1) + if I == "*=*" + eval + $(I) + end + else + version := $(I) + end + end + LICENSEFILEDEFAULT := $(.package.licenses. $(name):@/ /:/G) + export LICENSEFILEDEFAULT + end + if "$(>)" + for I $(>:V) + $(I) : .VIRTUAL + if I == "/*" + package.dir += $(I:V) + end + end + end + if "$(@)" + $(P).README := $(@) + else + $(P).README := This is the $(P) package. + end + end + +":AUXILIARY:" : .MAKE .OPERATOR + package.auxiliary.$(style) += $(>:N=/*:T=F) $(>:N!=/*:C%^%$(INSTALLROOT)/%:T=F) + +":CATEGORY:" : .MAKE .OPERATOR + if ! package.requires + category := $(>) + end + +.covers. : .FUNCTION + local I C D F K=0 L + for I $(%) + if ! "$(~covers:N=$(I:B))" + if F = "$(I:D:B:S=.pkg:T=F)" + if D = "$(F:T=I)" + covers : $(I:B) + for L $(D) + if L == ":COVERS:" + K = 1 + elif L == ":*:" + if K + break + end + elif K + : $(.covers. $(L)) + end + end + end + else + error $(--exec:?3?1?) $(I): unknown package $(I) + end + end + end + +":COVERS:" : .MAKE .OPERATOR + if ! package.requires + : $(.covers. $(>)) + end + +":DESCRIPTION:" : .MAKE .OPERATOR + if ! package.requires + $(name).README := $(@:V) + end + +":DETAILS:" : .MAKE .OPERATOR + if ! package.requires + details.$(>:O=1) := $(@:V) + end + +":EXPORT:" : .MAKE .OPERATOR + if ! package.requires + export.$(style) := $(@:/$$("\n")/ /G) + end + +":INDEX:" : .MAKE .OPERATOR + if ! package.requires + index := $(>) + end + +":INSTALL:" : .MAKE .OPERATOR + if ! package.requires + local T S F X + S := $(>) + T := $(<) + if "$(exe.$(style))" && "$(T)" == "bin/*([!./])" + T := $(T).exe + end + if ! "$(S)" + S := $(T) + elif "$(exe.$(style))" && "$(S)" == "bin/*([!./])" + S := $(S).exe + end + install.$(style) := $(install.$(style):V)$("\n")install : $$(ROOT)/$(T)$("\n")$$(ROOT)/$(T) : $$(ARCH)/$(S)$("\n\t")cp $< $@ + if strip && "$(T:N=*.exe)" + install.$(style) := $(install.$(style):V)$("\n\t")strip $@ 2>/dev/null + end + X := $(PACKAGEROOT)/arch/$(CC.HOSTTYPE)/$(S) + if strip && "$(X:T=Y)" == "*/?(x-)(dll|exe)" + F := filter $(STRIP) $(STRIPFLAGS) $(X) + end + if "$(filter.$(style):V)" + filter.$(style) := $(filter.$(style):V)$$("\n") + end + filter.$(style) := $(filter.$(style):V);;$(F);$(X);usr/$(T) + end + +":LICENSE:" : .MAKE .OPERATOR + if ! package.requires && ! license + license := $(>) + end + +":OMIT:" : .MAKE .OPERATOR + if ! package.requires + package.omit := $(package.omit)|$(>:C,^,*/,:/ /|/G) + end + +":POSTINSTALL:" : .MAKE .OPERATOR + if ! package.requires + postinstall.$(style) := $(@:V) + end + +":README:" : .MAKE .OPERATOR + if ! package.requires + readme.$(style) := $(@:V) + end + +.requires. : .FUNCTION + local I C D F K=0 L V T M=0 + for I $(%) + if ! "$(~requires:N=$(I:B))" + if F = "$(I:D:B:S=.pkg:T=F)" + if I == "$(init)" + package.omit = - + else + requires : $(I:B) + end + if V = "$(I:D:B=gen/$(I:B):S=.ver:T=F)" + req : $(I:B) + else + error 1 $(I): package should be written before $(P) + end + let package.requires = package.requires + 1 + include "$(F)" + let package.requires = package.requires - 1 + else + error 1 $(I): package not found + end + end + end + +":REQUIRES:" : .MAKE .OPERATOR + : $(.requires. $(>)) + +":TEST:" : .MAKE .OPERATOR + if ! package.requires + local T + T := $(>) + if "$(T)" == "bin/*([!./])" + if "$(exe.$(style))" + T := $(T).exe + end + T := $$(PWD)/$$(ARCH)/$(T) + end + test.$(style) := $(test.$(style):V)$("\n")test : $(T:V)$("\n\t")$(@) + end + +base delta : .MAKE .VIRTUAL .FORCE + op := $(<) + +closure : .MAKE .VIRTUAL .FORCE + $(<) := 1 + +cyg exp lcl pkg rpm tgz : .MAKE .VIRTUAL .FORCE + style := $(<) + +source : .source.init .source.gen .source.$$(style) + +.source.init : .MAKE + local A B D P V I + type := source + if ! "$(incremental)" + incremental = 1 + end + if "$(source.$(name))" + suffix = c + end + : $(.init.$(style)) + : $(details.$(style):V:R) : + A := $(source.list) + B := $(A:N=*.$(stamp).$(suffix):N!=*.$(stamp).$(stamp).*:O=1:T=F) + P := $(A:N=*.$(stamp).$(suffix):N!=*.$(stamp).$(stamp).*:O=2:T=F) + D := $(A:N=*.$(stamp).$(stamp).$(suffix):O=1:T=F) + if op == "delta" + if ! B + error 3 delta requires a base archive + end + base := -z $(B) + deltaversion := $(B:B:/$(name).//) + let deltasince = $(deltaversion:/.*-//) + 1 + deltasince := $(deltaversion:/[^-]*$/$(deltasince:F=%02d)/) + if "$(release)" != "$(stamp)" + release := $("":T=R%Y-%m-%d) + end + source := $(B:D:B:S=.$(release).$(suffix)) + version := $(source:B:B:/$(name).//) + elif B || op == "base" + if op == "base" + for I $(B) $(P) + V := $(I:B:/$(name)\.\([^.]*\).*/\1/) + if V == "$(stamp)" && V != "$(version)" + old.version := $(V) + old.source := $(I) + if "$(old.version)" >= "$(version)" + error 3 $(name): previous base $(old.version) is newer than $(version) + end + break + end + end + else + source := $(B) + end + if B == "$(source)" + if "$(B:D:B:B)" == "$(D:D:B:B)" && "$(B:B::S)" != "$(D:B::S)" + error 3 $(B:B:S): base overwrite would invalidate delta $(D:B:S) + end + error 1 $(B:B:S): replacing current base + end + version := $(source:B:S:/^$(name).\(.*\).$(suffix)$/\1/) + end + PACKAGEGEN := $(PACKAGESRC)/gen + +.source.gen : $$(PACKAGEDIR) $$(PACKAGEGEN) $$(PACKAGEGEN)/SOURCE.html $$(PACKAGEGEN)/BINARY.html $$(PACKAGEGEN)/DETAILS.html + +BINPACKAGE := $(PATH:/:/ /G:X=package:T=F:O=1) + +$$(PACKAGEDIR) $$(PACKAGEGEN) : .IGNORE + [[ -d $(<) ]] || mkdir $(<) + +$$(PACKAGEGEN)/SOURCE.html : $(BINPACKAGE) + $(*) html source > $(<) + +$$(PACKAGEGEN)/BINARY.html : $(BINPACKAGE) + $(*) html binary > $(<) + +$$(PACKAGEGEN)/DETAILS.html : $(BINPACKAGE) + $(*) html intro > $(<) + +.source.exp .source.pkg .source.rpm : .MAKE + error 3 $(style): source package style not supported yet + +exe.cyg = .exe +vendor.cyg = gnu + +.name.cyg : .FUNCTION + local N + N := $(%) + if N == "*-*" + vendor := $(N:/-.*//) + if vendor == "$(vendor.cyg)" + vendor := + N := $(N:/[^-]*-//) + end + N := $(N:/-//G) + end + return $(N) + +.init.cyg : .FUNCTION + local N O + closure = 1 + init = . + strip = 1 + suffix = tar.bz2 + format = tbz + vendor := $(licenses:N!=$(vendor.cyg):O=1) + package.ini := $(package.ini) + package.src.pat := $(package.src.pat) + package.src := $(package.src) + package.bin := $(package.bin) + .source.gen : .CLEAR $(*.source.gen:V:N!=*.html) + name.original := $(name) + name := $(.name.cyg $(name)) + if name != "$(name.original)" + $(name) : $(~$(name.original)) + O := $(~covers) + covers : .CLEAR + for N $(O) + covers : $(.name.cyg $(N)) + end + end + stamp = [0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]-[0-9] + version.original := $(version) + version := $(version:/-//G)-1 + if opt + opt := $(opt)/$(vendor)/ + else + opt := $(name)-$(version)/ + end + if type == "source" + version := $(version)-src + source = $(PACKAGEDIR)/$(name)-$(version)$(release:?.$(release)??).$(suffix) + else + binary = $(PACKAGEDIR)/$(name)-$(version)$(release:?.$(release)??).$(suffix) + end + +.source.cyg : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + integer m=0 o + cat > $tmp/configure <<'!' + echo "you didn't have to do that" + ! + chmod +x $tmp/configure + echo ";;;$tmp/configure;configure" + cat > $tmp/Makefile0 <<'!' + HOSTTYPE := $$(shell bin/package) + ROOT = ../.. + ARCH = arch/$$(HOSTTYPE) + all : + PACKAGEROOT= CYGWIN="$$CYGWIN ntsec binmode" bin/package make $(export.$(style)) + install : all + $(install.$(style):V) + $(test.$(style):V) + ! + echo ";;;$tmp/Makefile0;Makefile" + cat > $tmp/CYGWIN-README <<'!' + $(readme.$(style):@?$$(readme.$$(style))$$("\n\n")??)To build binaries from source into the ./arch/`bin/package` tree run: + $() + make + $() + $(test.$(style):@?To test the binaries after building/installing run:$$("\n\n\t")make test$$("\n\n")??)To build and/or install the binaries run: + $() + make install + $() + The bin/package command provides a command line interface for all package + operations. The $(opt:/.$//) source and binary packages were generated by: + $() + package write cyg base source version=$(version.original) $(name.original) + package write cyg base binary version=$(version.original) $(name.original) + $() + using the $(org)-base package. To download and install the latest + $(org)-base source package in /opt/$(org) run: + $() + PATH=/opt/$(org)/bin:$PATH + cd /opt/$(org) + package authorize "NAME" password "PASSWORD" setup flat source $("\\") + $(url) $("\\") + $(org)-base + package make + $() + and export /opt/$(org)/bin in PATH to use. The NAME and PASSWORD signify your + agreement to the software license(s). All users get the same NAME and PASSWORD. + See $(url) for details. If multiple architectures may be built under + /opt/$(org) then drop "flat" and export /opt/$(org)/arch/`package`/bin in PATH + to use. To update previously downloaded packages from the same url simply run: + $() + cd /opt/$(org) + package setup + package make + $() + To download and install the latest $(org)-base binary package in + /opt/$(org) change "source" to "binary" and omit "package make". + ! + echo ";;;$tmp/CYGWIN-README;CYGWIN-PATCHES/README" + cat > $(source:/-src.$(suffix)//).setup.hint <<'!' + category: $(category:/\(.\).*/\1/U)$(category:/.\(.*\)/\1/L) + requires: cygwin + sdesc: "$(index)" + ldesc: "$($(name.original).README)" + ! + echo ";;;$(source:/-src.$(suffix)//).setup.hint;CYGWIN-PATCHES/setup.hint" + echo ";;;$(BINPACKAGE);bin/package" + cat > $tmp/Makefile <<'!' + :MAKE: + ! + echo ";;;$tmp/Makefile;src/Makefile" + echo ";;;$tmp/Makefile;src/cmd/Makefile" + echo ";;;$tmp/Makefile;src/lib/Makefile" + if [[ '$(mamfile)' == 1 ]] + then cat > $tmp/Mamfile1 <<'!' + info mam static + note source level :MAKE: equivalent + make install + make all + exec - ${MAMAKE} -r '*/*' ${MAMAKEARGS} + done all virtual + done install virtual + ! + echo ";;;$tmp/Mamfile1;src/Mamfile" + cat > $tmp/Mamfile2 <<'!' + info mam static + note component level :MAKE: equivalent + make install + make all + exec - ${MAMAKE} -r '*' ${MAMAKEARGS} + done all virtual + done install virtual + ! + echo ";;;$tmp/Mamfile2;src/cmd/Mamfile" + echo ";;;$tmp/Mamfile2;src/lib/Mamfile" + fi + $(package.src:U:T=F:/.*/echo ";;;&"$("\n")/) + echo ";;;$(PACKAGEGEN)/$(name.original).req" + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + if [[ ! '$(license)' ]] || $(MAKE) --noexec --silent 'exit $$(LICENSECLASS:N=$(license):?0?1?)' . + then if [[ '$(mamfile)' == 1 ]] + then (( o=m )) + s=$( $(MAKE) --noexec --recurse=list recurse 2>/dev/null ) + if [[ $s ]] + then for j in $s + do if [[ -d $j ]] + then cd $j + if [[ ! '$(license)' ]] || $(MAKE) --noexec --silent 'exit $$(LICENSECLASS:N=$(license):?0?1?)' . + then (( m++ )) + $(MAKE) $(package.mam) $(export.$(style):Q) > $tmp/$m.mam + echo ";;;$tmp/$m.mam;$i/$j/Mamfile" + fi + cd $(INSTALLROOT)/$i + fi + done + if (( o != m )) + then (( m++ )) + cat > $tmp/$m.mam <<'!' + info mam static + note subcomponent level :MAKE: equivalent + make install + make all + exec - ${MAMAKE} -r '*' ${MAMAKEARGS} + done all virtual + done install virtual + ! + echo ";;;$tmp/$m.mam;$i/Mamfile" + fi + else (( m++ )) + $(MAKE) $(package.mam) $(export.$(style):Q) > $tmp/$m.mam + echo ";;;$tmp/$m.mam;$i/Mamfile" + fi + fi + $(MAKE) --noexec $(-) $(=) recurse list.package.$(type) package.license.class=$(license:Q) + fi + done + set -- $(package.dir:P=G) + for i + do tw -d $i -e "action:printf(';;;%s;%s\n',path,path);" + done + } | + { + : > $tmp/HEAD + cat > $tmp/README <<'!' + $(package.readme) + ! + echo ";;;$tmp/README;README" + sort -t';' -k5,5 -u + : > $tmp/TAIL + [[ '$(notice)' ]] && echo ";;;$tmp/TAIL;$(package.notice)" + } | + $(PAX) --filter=- \ + --to=ascii \ + --format=$(format) \ + --local \ + -wvf $(source) $(base) \ + $(PACKAGEVIEW:C%.*%-s",^&/,,"%) \ + $(vendor:?-s",^[^/],$(opt)&,"??) + $(SUM) -x $(checksum) < $(source) > $(source:D:B:S=.$(checksum)) + rm -rf $tmp + fi + +.source.lcl : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + integer m=0 o + $(package.src:U:T=F:/.*/echo ";;;&"$("\n")/) + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + $(MAKE) --noexec $(-) $(=) .FILES.+=Mamfile recurse list.package.local + done + set -- $(package.dir:P=G) + for i + do tw -d $i -e "action:printf(';;;%s;%s\n',path,path);" + done + } | + sort -t';' -k5,5 -u | + $(PAX) --filter=- \ + --to=ascii \ + $(op:N=delta:??--format=$(format)?) \ + --local \ + -wvf $(source) $(base) \ + $(op:N=delta:?--format=gzip??) \ + $(PACKAGEVIEW:C%.*%-s",^&/,,"%) + rm -rf $tmp + fi + +.source.tgz : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + integer m=0 o + if [[ '$(init)' == '$(name)' ]] + then cat > $tmp/Makefile <<'!' + :MAKE: + ! + $(CMP) $(CMPFLAGS) $tmp/Makefile $(PACKAGEROOT)/src/Makefile && touch -r $(PACKAGEROOT)/src/Makefile $tmp/Makefile + echo ";;;$tmp/Makefile;src/Makefile" + cp $tmp/Makefile $tmp/Makefile1 + $(CMP) $(CMPFLAGS) $tmp/Makefile1 $(PACKAGEROOT)/src/cmd/Makefile && touch -r $(PACKAGEROOT)/src/cmd/Makefile $tmp/Makefile1 + echo ";;;$tmp/Makefile1;src/cmd/Makefile" + cp $tmp/Makefile $tmp/Makefile2 + $(CMP) $(CMPFLAGS) $tmp/Makefile2 $(PACKAGEROOT)/src/lib/Makefile && touch -r $(PACKAGEROOT)/src/lib/Makefile $tmp/Makefile2 + echo ";;;$tmp/Makefile2;src/lib/Makefile" + if [[ '$(mamfile)' == 1 ]] + then cat > $tmp/Mamfile1 <<'!' + info mam static + note source level :MAKE: equivalent + make install + make all + exec - ${MAMAKE} -r '*/*' ${MAMAKEARGS} + done all virtual + done install virtual + ! + $(CMP) $(CMPFLAGS) $tmp/Mamfile1 $(PACKAGEROOT)/src/Mamfile && touch -r $(PACKAGEROOT)/src/Mamfile $tmp/Mamfile1 + echo ";;;$tmp/Mamfile1;src/Mamfile" + cat > $tmp/Mamfile2 <<'!' + info mam static + note component level :MAKE: equivalent + make install + make all + exec - ${MAMAKE} -r '*' ${MAMAKEARGS} + done all virtual + done install virtual + ! + $(CMP) $(CMPFLAGS) $tmp/Mamfile2 $(PACKAGEROOT)/src/cmd/Mamfile && touch -r $(PACKAGEROOT)/src/cmd/Mamfile $tmp/Mamfile2 + echo ";;;$tmp/Mamfile2;src/cmd/Mamfile" + cp $tmp/Mamfile2 $tmp/Mamfile3 + $(CMP) $(CMPFLAGS) $tmp/Mamfile3 $(PACKAGEROOT)/src/lib/Mamfile && touch -r $(PACKAGEROOT)/src/lib/Mamfile $tmp/Mamfile3 + echo ";;;$tmp/Mamfile3;src/lib/Mamfile" + fi + fi + $(package.src:U:T=F:C%^$(PACKAGEROOT)/%%:C%.*%echo ";;;$(PACKAGEROOT)/&;&"$("\n")%) + if [[ '$(~covers)' ]] + then for i in $(~covers) + do for j in lib pkg + do if [[ -f $(PACKAGESRC)/$i.$j ]] + then echo ";;;$(PACKAGESRC)/$i.$j;$(PACKAGELIB)/$i.$j" + fi + done + for j in ver req + do if [[ -f $(PACKAGEGEN)/$i.$j ]] + then echo ";;;$(PACKAGEGEN)/$i.$j;$(PACKAGELIB)/$i.$j" + fi + done + done + for i in $(~covers:D=$(PACKAGESRC):B:S=.lic:T=F:T=I:N=*.def:D=$(PACKAGESRC):B:S:T=F:B:S) + do echo ";;;$(PACKAGESRC)/$i;$(PACKAGELIB)/$i" + done + fi + if [[ '$(PACKAGEDIR:B)' == '$(style)' ]] + then echo $(name) $(version) $(release|version) 1 > $tmp/t + $(CMP) $(CMPFLAGS) $tmp/t $(PACKAGEGEN)/$(name).ver || cp $tmp/t $(PACKAGEGEN)/$(name).ver + echo ";;;$(PACKAGEGEN)/$(name).ver;$(PACKAGELIB)/$(name).ver" + sed 's,1$,0,' $(~req:D=$(PACKAGEGEN):B:S=.ver:T=F) < /dev/null > $tmp/t + $(CMP) $(CMPFLAGS) $tmp/t $(PACKAGEGEN)/$(name).req || cp $tmp/t $(PACKAGEGEN)/$(name).req + echo ";;;$(PACKAGEGEN)/$(name).req;$(PACKAGELIB)/$(name).req" + { + echo "name='$(name)'" + echo "index='$(index)'" + echo "covers='$(~covers)'" + echo "requires='$(~req)'" + } > $tmp/t + $(CMP) $(CMPFLAGS) $tmp/t $(PACKAGEGEN)/$(name).inx || cp $tmp/t $(PACKAGEGEN)/$(name).inx + { + { + echo '$($(name).README)' + if [[ '$(~covers)' ]] + then echo "This package is a superset of the following package$(~covers:O=2:?s??): $(~covers); you won't need $(~covers:O=2:?these?this?) if you download $(name)." + fi + if [[ '$(~requires)' ]] + then echo 'It requires the following package$(~requires:O=2:?s??): $(~requires).' + fi + } | fmt + package help source + package release $(name) + } > $tmp/t + $(CMP) $(CMPFLAGS) $tmp/t $(PACKAGEGEN)/$(name).README || cp $tmp/t $(PACKAGEGEN)/$(name).README + echo ";;;$(PACKAGEGEN)/$(name).README;$(PACKAGELIB)/$(name).README" + { + echo '.xx title="$(name) package"' + echo '.xx meta.description="$(name) package"' + echo '.xx meta.keywords="software, package"' + echo '.MT 4' + echo '.TL' + echo '$(name) package' + echo '.H 1 "$(name) package"' + echo '$($(name).README)' + set -- $(package.closure:C,.*,$(INSTALLROOT)/&/PROMO.mm,:T=F:D::B) + hot= + for i + do hot="$hot -e s/\\(\\<$i\\>\\)/\\\\h'0*1'\\1\\\\h'0'/" + done + set -- $(package.closure:B) + if (( $# )) + then echo 'Components in this package:' + echo '.P' + echo '.TS' + echo 'center expand;' + echo 'l l l l l l.' + if [[ $hot ]] + then hot="sed $hot" + else hot=cat + fi + for i + do echo $i + done | + pr -6 -t -s' ' | + $hot + echo '.TE' + fi + echo '.P' + if [[ '$(~covers)' ]] + then echo "This package is a superset of the following package$(~covers:O=2:?s??): $(~covers); you won't need $(~covers:O=2:?these?this?) if you download $(name)." + fi + if [[ '$(~requires)' ]] + then echo 'It requires the following package$(~requires:O=2:?s??): $(~requires).' + fi + set -- $(.package.licenses. --all $(name)) + case $# in + 0) ;; + *) case $# in + 1) echo 'The software is covered by this license:' ;; + *) echo 'The software is covered by these licenses:' ;; + esac + echo .BL + for j + do i=$( $(PROTO) -l $j -p -h -o type=usage /dev/null | sed -e 's,.*\[-license?\([^]]*\).*,\1,' ) + echo .LI + echo ".xx link=\"$i\"" + done + echo .LE + echo 'Individual components may be covered by separate licenses;' + echo 'refer to the component source and/or binaries for more information.' + echo .P + ;; + esac + echo 'A recent' + echo '.xx link="release change log"' + echo 'is also included.' + cat $(package.closure:C,.*,$(INSTALLROOT)/&/PROMO.mm,:T=F) < /dev/null + echo '.H 1 "release change log"' + echo '.xx index' + echo '.nf' + package release $(name) | + sed -e 's/:::::::: \(.*\) ::::::::/.fi\$("\n").H 1 "\1 changes"\$("\n").nf/' + echo '.fi' + } | + $(MM2HTML) $(MM2HTMLFLAGS) -o nohtml.ident > $tmp/t + $(STDED) $(STDEDFLAGS) $tmp/t <<'!' + /^<!--LABELS-->$/,/^<!--\/LABELS-->$/s/ changes</</ + /^<!--LABELS-->$/,/^<!--\/LABELS-->$/m/<A name="release change log">/ + w + q + ! + $(CMP) $(CMPFLAGS) $tmp/t $(PACKAGEGEN)/$(name).html || cp $tmp/t $(PACKAGEGEN)/$(name).html + echo ";;;$(PACKAGEGEN)/$(name).html;$(PACKAGELIB)/$(name).html" + if [[ '$(deltasince)' ]] + then { + echo '.xx title="$(name) package"' + echo '.xx meta.description="$(name) package $(version) delta $(release)"' + echo '.xx meta.keywords="software, package, delta"' + echo '.MT 4' + echo '.TL' + echo '$(name) package $(deltaversion) delta $(release)' + echo '.H 1 "$(name) package $(deltaversion) delta $(release) changes"' + echo '.nf' + package release $(deltasince) $(name) | + sed -e 's/:::::::: \(.*\) ::::::::/.H 2 \1/' + echo '.fi' + } | + $(MM2HTML) $(MM2HTMLFLAGS) -o nohtml.ident > $tmp/t + $(CMP) $(CMPFLAGS) $tmp/t $(PACKAGEGEN)/$(name).$(release).html || cp $tmp/t $(PACKAGEGEN)/$(name).$(release).html + echo ";;;$(PACKAGEGEN)/$(name).$(release).html;$(PACKAGELIB)/$(name).$(release).html" + fi + fi + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + if [[ ! '$(license)' ]] || $(MAKE) --noexec --silent 'exit $$(LICENSECLASS:N=$(license):?0?1?)' . + then if [[ '$(mamfile)' == 1 ]] + then (( o=m )) + s=$( $(MAKE) --noexec --recurse=list recurse 2>/dev/null ) + if [[ $s ]] + then for j in $s + do if [[ -d $j ]] + then cd $j + if [[ ! '$(license)' ]] || $(MAKE) --noexec --silent 'exit $$(LICENSECLASS:N=$(license):?0?1?)' . + then (( m++ )) + $(MAKE) $(package.mam) > $tmp/$m.mam + $(CMP) $(CMPFLAGS) $tmp/$m.mam $(PACKAGEROOT)/$i/$j/Mamfile && touch -r $(PACKAGEROOT)/$i/$j/Mamfile $tmp/$m.mam + echo ";;;$tmp/$m.mam;$i/$j/Mamfile" + fi + cd $(INSTALLROOT)/$i + fi + done + if (( o != m )) + then (( m++ )) + cat > $tmp/$m.mam <<'!' + info mam static + note subcomponent level :MAKE: equivalent + make install + make all + exec - ${MAMAKE} -r '*' ${MAMAKEARGS} + done all virtual + done install virtual + ! + $(CMP) $(CMPFLAGS) $tmp/$m.mam $(PACKAGEROOT)/$i/Mamfile && touch -r $(PACKAGEROOT)/$i/Mamfile $tmp/$m.mam + echo ";;;$tmp/$m.mam;$i/Mamfile" + fi + else (( m++ )) + $(MAKE) $(package.mam) > $tmp/$m.mam + $(CMP) $(CMPFLAGS) $tmp/$m.mam $(PACKAGEROOT)/$i/Mamfile && touch -r $(PACKAGEROOT)/$i/Mamfile $tmp/$m.mam + echo ";;;$tmp/$m.mam;$i/Mamfile" + fi + fi + $(MAKE) --noexec $(-) $(=) recurse list.package.$(type) package.license.class=$(license:Q) $(copyright:N=1:??LICENSE=?) + fi + done + set -- $(package.dir:P=G) + for i + do tw -d $i -e "action:printf(';;;%s;%s\n',path,path);" + done + } | + { + : > $tmp/HEAD + [[ '$(notice)' ]] && echo ";;;$tmp/HEAD;$(package.notice)" + cat > $tmp/README <<'!' + $(package.readme) + ! + echo ";;;$tmp/README;README" + $(CMP) $(CMPFLAGS) $tmp/README $(PACKAGEROOT)/README && touch -r $(PACKAGEROOT)/README $tmp/README + sort -t';' -k5,5 -u + : > $tmp/TAIL + [[ '$(notice)' ]] && echo ";;;$tmp/TAIL;$(package.notice)" + } | + $(PAX) --filter=- \ + --to=ascii \ + $(op:N=delta:??--format=$(format)?) \ + --local \ + -wvf $(source) $(base) \ + $(op:N=delta:?--format=gzip??) \ + $(PACKAGEVIEW:C%.*%-s",^&/,,"%) + $(SUM) -x $(checksum) < $(source) > $(source:D:B:S=.$(checksum)) + echo local > $(source:D:B=$(name):S=.tim) + if [[ '$(incremental)' == 1 && '$(old.source)' ]] + then $(PAX) -rf $(source) -wvf $(old.new.source) -z $(old.source) + $(SUM) -x $(checksum) < $(old.new.source) > $(old.new.source:D:B:S=.$(checksum)) + fi + rm -rf $tmp + else if [[ '$(old.source)' ]] && $(CMP) $(CMPFLAGS) $(source.$(name)) $(source) + then : $(name) is up to date + else echo $(name) $(version) $(release|version) 1 > $(PACKAGEGEN)/$(name).ver + : > $(PACKAGEGEN)/$(name).req + { + echo "name='$(name)'" + echo "index='$(index)'" + echo "covers='$(~covers)'" + echo "requires='$(~req)'" + } > $(PACKAGEGEN)/$(name).inx + { + echo '.xx title="$(name) package"' + echo '.xx meta.description="$(name) package"' + echo '.xx meta.keywords="software, package"' + echo '.MT 4' + echo '.TL' + echo '$(name) package' + echo '.H 1' + echo '$($(name).README)' + } | + $(MM2HTML) $(MM2HTMLFLAGS) -o nohtml.ident > $(PACKAGEGEN)/$(name).html + if [[ '$(source.$(name))' ]] + then { + echo '$($(name).README)' + package help source + } > $(PACKAGEGEN)/$(name).README + cp $(source.$(name)) $(source) + $(SUM) -x $(checksum) < $(source) > $(source:D:B:S=.$(checksum)) + fi + echo local > $(source:D:B=$(name):S=.tim) + fi + fi + +binary : .binary.init .binary.gen .binary.$$(style) + +.binary.init : .MAKE + local A B D I P V + type := binary + if ! "$(incremental)" + incremental = 0 + end + if ! "$(~$(name))" + if name == "ratz" + suffix = exe + else + suffix = gz + end + end + : $(.init.$(style)) : + : $(details.$(style):V:R) : + A := $(binary.list) + B := $(A:N=*.$(stamp).$(CC.HOSTTYPE).$(suffix):N!=*.$(stamp).$(stamp).*:O=1:T=F) + P := $(A:N=*.$(stamp).$(CC.HOSTTYPE).$(suffix):N!=*.$(stamp).$(stamp).*:O=2:T=F) + D := $(A:N=*.$(stamp).$(stamp).$(CC.HOSTTYPE).$(suffix):O=1:T=F) + if op == "delta" + if ! B + error 3 delta requires a base archive + end + base := -z $(B) + if "$(release)" != "$(stamp)" + release := $("":T=R%Y-%m-%d) + end + binary := $(B:/$(CC.HOSTTYPE).$(suffix)$/$(release).&/) + version := $(binary:B:B:/$(name).//) + elif B || op == "base" + if op == "base" + for I $(B) $(P) + V := $(I:B:/$(name)\.\([^.]*\).*/\1/) + if V == "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]" && V != "$(version)" + old.version := $(V) + old.binary := $(I) + if "$(old.version)" >= "$(version)" + error 3 $(name): previous base $(old.version) is newer than $(version) + end + break + end + end + else + binary := $(B) + end + if B == "$(binary)" + if "$(B:D:B)" == "$(D:D:B)" && "$(B:S)" != "$(D:S)" + error 3 $(B:B:S): base overwrite would invalidate delta $(D:B:S) + end + error 1 $(B:B:S): replacing current base + end + version := $(binary:B:/$(name).//:/\..*//) + end + PACKAGEGEN := $(PACKAGEBIN)/gen + +.binary.gen : $$(PACKAGEDIR) $$(PACKAGEGEN) + +.binary.exp .binary.pkg .binary.rpm : .MAKE + error 3 $(style): binary package style not supported yet + +.binary.cyg : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + integer m=0 o + { + echo '$($(name.original).README)' | fmt + cat <<'!' + $(readme.$(style):@?$$("\n")$$(readme.$$(style))??) + ! + } > $tmp/README1 + echo ";;;$tmp/README1;usr/share/doc/Cygwin/$(opt:/.$//).README" + { + echo '$($(name.original).README)' | fmt + cat <<'!' + $() + The remainder of this file is the README from the source package + that was used to generate this binary package. It describes + the source build hierarchy, not the current directory. + $() + $(package.readme) + ! + } > $tmp/README2 + echo ";;;$tmp/README2;usr/share/doc/$(opt)README" + package release $(name.original) > $tmp/RELEASE + echo ";;;$tmp/RELEASE;usr/share/doc/$(opt)RELEASE" + cat > $(binary:/.$(suffix)//).setup.hint <<'!' + category: $(category:/\(.\).*/\1/U)$(category:/.\(.*\)/\1/L) + requires: cygwin + sdesc: "$(index)" + ldesc: "$($(name.original).README)" + ! + set -- $(.package.licenses. --text $(name.original):N!=*.lic) + for i + do echo ";;;${i};usr/share/doc/$(opt)LICENSE-${i##*/}" + done + cat <<'!' + $(filter.$(style)) + ! + if [[ '$(postinstall.$(style):V:O=1:?1??)' ]] + then cat >$tmp/postinstall <<'!' + $("#")!/bin/sh + $(postinstall.$(style)) + ! + echo ";;;$tmp/postinstall;etc/postinstall/$(name).sh" + fi + } | + { + : > $tmp/HEAD + [[ '$(notice)' ]] && echo ";;;$tmp/HEAD;$(package.notice)" + sort -t';' -k5,5 -u + : > $tmp/TAIL + [[ '$(notice)' ]] && echo ";;;$tmp/TAIL;$(package.notice)" + } | + $(PAX) --filter=- \ + --to=ascii \ + --format=$(format) \ + --local \ + -wvf $(binary) + $(SUM) -x $(checksum) < $(binary) > $(binary:D:B:S=.$(checksum)) + rm -rf $tmp + fi + +.binary.lcl : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + $(package.src:U:T=F:/.*/echo ";;;&"$("\n")/) + $(package.bin:U:T=F:/.*/echo ";;;&"$("\n")/) + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + $(MAKE) --noexec $(-) --variants=$(variants:Q) $(=) recurse list.package.$(type) package.license.class=$(license:Q) cc- + done + } | + $(PAX) --filter=- \ + --to=ascii \ + $(op:N=delta:??--format=$(format)?) \ + --local \ + --checksum=md5:$(PACKAGEGEN)/$(name).sum \ + --install=$(PACKAGEGEN)/$(name).ins \ + -wvf $(binary) $(base) \ + $(op:N=delta:?--format=gzip??) \ + -s",^$tmp/,$(INSTALLOFFSET)/," \ + $(PACKAGEROOT:C%.*%-s",^&/,,"%) + $(SUM) -x $(checksum) < $(binary) > $(binary:D:B:S=.$(checksum)) + echo local > $(binary:D:B=$(name):S=.$(CC.HOSTTYPE).tim) + rm -rf $tmp + fi + +.binary.tgz : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + if [[ '$(init)' == '$(name)' ]] + then for i in lib32 lib64 + do if [[ -d $(INSTALLROOT)/$i ]] + then echo ";physical;;$(INSTALLROOT)/$i" + fi + done + fi + $(package.src:U:T=F:C%^$(PACKAGEROOT)/%%:C%.*%echo ";;;$(PACKAGEROOT)/&;&"$("\n")%) + $(package.bin:U:T=F:C%^$(INSTALLROOT)/%%:C%.*%echo ";;;$(INSTALLROOT)/&;&"$("\n")%) + $(package.auxiliary.$(style):U:T=F:C%^$(INSTALLROOT)/%%:C%.*%echo ";;;$(INSTALLROOT)/&;&"$("\n")%) + if [[ '$(PACKAGEDIR:B)' == '$(style)' ]] + then echo $(name) $(version) $(release|version) 1 > $(PACKAGEGEN)/$(name).ver + echo ";;;$(PACKAGEGEN)/$(name).ver;$(PACKAGELIB)/$(name).ver" + if [[ '$(~covers)' ]] + then for i in $(~covers) + do for j in lic pkg + do if [[ -f $(PACKAGESRC)/$i.$j ]] + then echo ";;;$(PACKAGESRC)/$i.$j;$(PACKAGELIB)/$i.$j" + fi + done + for j in ver req + do if [[ -f $(PACKAGEGEN)/$i.$j ]] + then echo ";;;$(PACKAGEGEN)/$i.$j;$(PACKAGELIB)/$i.$j" + fi + done + done + for i in $(~covers:D=$(PACKAGESRC):B:S=.lic:T=F:T=I:N=*.def:D=$(PACKAGESRC):B:S:T=F:B:S) + do echo ";;;$(PACKAGESRC)/$i;$(PACKAGELIB)/$i" + done + fi + sed 's,1$,0,' $(~req:D=$(PACKAGEGEN):B:S=.ver:T=F) < /dev/null > $(PACKAGEGEN)/$(name).req + echo ";;;$(PACKAGEGEN)/$(name).req;$(PACKAGELIB)/$(name).req" + { + echo "name='$(name)'" + echo "index='$(index)'" + echo "covers='$(~covers)'" + echo "requires='$(~req)'" + } > $(PACKAGEGEN)/$(name).inx + { + { + echo '$($(name).README)' + if [[ '$(~covers)' ]] + then echo "This package is a superset of the following package$(~covers:O=2:?s??): $(~covers); you won't need $(~covers:O=2:?these?this?) if you download $(name)." + fi + if [[ '$(~requires)' ]] + then echo 'It requires the following package$(~requires:O=2:?s??): $(~requires).' + fi + } | fmt + package help binary + package release $(name) + } > $(PACKAGEGEN)/$(name).README + echo ";;;$(PACKAGEGEN)/$(name).README;$(PACKAGELIB)/$(name).README" + fi + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + $(MAKE) --noexec $(-) --variants=$(variants:Q) $(=) package.strip=$(strip) recurse list.package.$(type) package.license.class=$(license:Q) cc- + done + } | + { + : > $tmp/HEAD + [[ '$(notice)' ]] && echo ";;;$tmp/HEAD;$(package.notice)" + cat > $tmp/README <<'!' + $(package.readme) + ! + echo ";;;$tmp/README;README" + sort -t';' -k5,5 -u + : > $tmp/TAIL + [[ '$(notice)' ]] && echo ";;;$tmp/TAIL;$(package.notice)" + } | + $(PAX) --filter=- \ + --to=ascii \ + $(op:N=delta:??--format=$(format)?) \ + --local \ + --checksum=md5:$(PACKAGEGEN)/$(name).sum \ + --install=$(PACKAGEGEN)/$(name).ins \ + -wvf $(binary) $(base) \ + $(op:N=delta:?--format=gzip??) \ + -s",^$tmp/,$(INSTALLOFFSET)/," \ + $(PACKAGEROOT:C%.*%-s",^&/,,"%) + echo $(binary) >> $(binary:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + $(SUM) -x $(checksum) < $(binary) > $(binary:D:B:S=.$(checksum)) + echo $(binary:D:B:S=.$(checksum)) >> $(binary:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + echo local > $(binary:D:B=$(name):S=.$(CC.HOSTTYPE).tim) + if [[ '$(incremental)' == 1 && '$(old.binary)' ]] + then $(PAX) -rf $(binary) -wvf $(old.new.binary) -z $(old.binary) + echo $(old.new.binary) >> $(binary:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + $(SUM) -x $(checksum) < $(old.new.binary) > $(old.new.binary:D:B:S=.$(checksum)) + echo $(old.new.binary:D:B:S=.$(checksum)) >> $(binary:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + fi + rm -rf $tmp + else if [[ '$(binary.$(name))' ]] + then exe=$(binary.$(name)) + else exe=$(INSTALLROOT)/bin/$(name) + fi + if [[ '$(old.binary)' ]] && $(CMP) $(CMPFLAGS) $exe $(binary) + then : $(name) is up to date + else echo $(name) $(version) $(release|version) 1 > $(PACKAGEGEN)/$(name).ver + : > $(PACKAGEGEN)/$(name).req + { + echo "name='$(name)'" + echo "index='$(index)'" + echo "covers='$(~covers)'" + echo "requires='$(~req)'" + } > $(PACKAGEGEN)/$(name).inx + { + echo '$($(name).README)' + package help binary + } > $(PACKAGEGEN)/$(name).README + case "$(binary)" in + *.gz) gzip < $exe > $(binary) ;; + *) cp $exe $(binary) ;; + esac + $(SUM) -x $(checksum) < $(binary) > $(binary:D:B:S=.$(checksum)) + echo local > $(binary:D:B=$(name):S=.$(CC.HOSTTYPE).tim) + fi + echo $(binary) >> $(binary:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + echo $(binary:D:B:S=.$(checksum)) >> $(binary:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + fi + +runtime : .runtime.init .runtime.gen .runtime.$$(style) + +.runtime.init : .MAKE + local A B D I P V + type := runtime + if ! "$(incremental)" + incremental = 0 + end + if ! "$(~$(name))" + if name == "ratz" + suffix = exe + else + suffix = gz + end + end + : $(.init.$(style)) : + : $(details.$(style):V:R) : + A := $(runtime.list) + B := $(A:N=*.$(stamp).$(CC.HOSTTYPE).$(suffix):N!=*.$(stamp).$(stamp).*:O=1:T=F) + P := $(A:N=*.$(stamp).$(CC.HOSTTYPE).$(suffix):N!=*.$(stamp).$(stamp).*:O=2:T=F) + D := $(A:N=*.$(stamp).$(stamp).$(CC.HOSTTYPE).$(suffix):O=1:T=F) + if op == "delta" + if ! B + error 3 delta requires a base archive + end + base := -z $(B) + if "$(release)" != "$(stamp)" + release := $("":T=R%Y-%m-%d) + end + runtime := $(B:/$(CC.HOSTTYPE).$(suffix)$/$(release).&/) + version := $(runtime:B:B:/$(name).//) + elif B || op == "base" + if op == "base" + for I $(B) $(P) + V := $(I:B:/$(name)-run\.\([^.]*\).*/\1/) + if V == "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]" && V != "$(version)" + old.version := $(V) + old.runtime := $(I) + if "$(old.version)" >= "$(version)" + error 3 $(name): previous base $(old.version) is newer than $(version) + end + break + end + end + else + runtime := $(B) + end + if B == "$(runtime)" + if "$(B:D:B)" == "$(D:D:B)" && "$(B:S)" != "$(D:S)" + error 3 $(B:B:S): base overwrite would invalidate delta $(D:B:S) + end + error 1 $(B:B:S): replacing current base + end + version := $(runtime:B:/$(name)-run.//:/\..*//) + end + PACKAGEGEN := $(PACKAGESRC)/gen + +.runtime.gen : $$(PACKAGEDIR) $$(PACKAGEGEN) + +.runtime.cyg .runtime.exp .runtime.lcl .runtime.pkg .runtime.rpm : .MAKE + error 3 $(style): runtime package style not supported yet + +.runtime.tgz : + if [[ '$(~$(name))' ]] + then tmp=/tmp/pkg$(tmp) + mkdir $tmp + { + if [[ '$(init)' == '$(name)' ]] + then for i in lib32 lib64 + do if [[ -d $(INSTALLROOT)/$i ]] + then echo ";physical;;$(INSTALLROOT)/$i" + fi + done + fi + $(package.src:U:T=F:C%^$(PACKAGEROOT)/%%:C%.*%echo ";;;$(PACKAGEROOT)/&;&"$("\n")%) + $(package.bin:U:T=F:C%^$(INSTALLROOT)/%%:C%.*%echo ";;;$(INSTALLROOT)/&;&"$("\n")%) + $(package.auxiliary.$(style):U:T=F:C%^$(INSTALLROOT)/%%:C%.*%echo ";;;$(INSTALLROOT)/&;&"$("\n")%) + echo $(name) $(version) $(release|version) 1 > $(PACKAGEGEN)/$(name).ver + echo ";;;$(PACKAGEGEN)/$(name).ver;$(PACKAGELIB)/$(name).ver" + if [[ '$(~covers)' ]] + then for i in $(~covers) + do for j in lic pkg + do if [[ -f $(PACKAGESRC)/$i.$j ]] + then echo ";;;$(PACKAGESRC)/$i.$j;$(PACKAGELIB)/$i.$j" + fi + done + for j in ver req + do if [[ -f $(PACKAGEGEN)/$i.$j ]] + then echo ";;;$(PACKAGEGEN)/$i.$j;$(PACKAGELIB)/$i.$j" + fi + done + done + for i in $(~covers:D=$(PACKAGESRC):B:S=.lic:T=F:T=I:N=*.def:D=$(PACKAGESRC):B:S:T=F:B:S) + do echo ";;;$(PACKAGESRC)/$i;$(PACKAGELIB)/$i" + done + fi + sed 's,1$,0,' $(~req:D=$(PACKAGEGEN):B:S=.ver:T=F) < /dev/null > $(PACKAGEGEN)/$(name).req + echo ";;;$(PACKAGEGEN)/$(name).req;$(PACKAGELIB)/$(name).req" + { + echo "name='$(name)'" + echo "index='$(index)'" + echo "covers='$(~covers)'" + echo "requires='$(~req)'" + } > $(PACKAGEGEN)/$(name).inx + { + { + echo '$($(name).README)' + if [[ '$(~covers)' ]] + then echo + echo "This package is a superset of the following package$(~covers:O=2:?s??): $(~covers); you won't need $(~covers:O=2:?these?this?) if you download $(name)." + fi + if [[ '$(~requires)' ]] + then echo + echo 'It requires the following package$(~requires:O=2:?s??): $(~requires).' + fi + echo + echo "To install this $(type) package read the tarball into a directory" + echo "suitable for containing bin and lib subdirectories, and run the" + echo "$(PACKAGELIB)/gen/$(name)-run.ins script to fix up permissions." + echo + echo "To use the package export the bin directory in PATH. The commands and" + echo "libraries use \$PATH to locate dynamic libraries and related data files." + echo + } | fmt + } > $(PACKAGEGEN)/$(name)-run.README + echo ";;;$(PACKAGEGEN)/$(name)-run.README;$(PACKAGELIB)/$(name)-run.README" + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + $(MAKE) --noexec $(-) --variants=$(variants:Q) $(=) package.strip=$(strip) recurse list.package.$(type) package.license.class=$(license:Q) cc- + done + } | + { + : > $tmp/HEAD + [[ '$(notice)' ]] && echo ";;;$tmp/HEAD;$(package.notice)" + cat > $tmp/README <<'!' + $(package.readme) + ! + echo ";;;$tmp/README;README" + sort -t';' -k5,5 -u + : > $tmp/TAIL + [[ '$(notice)' ]] && echo ";;;$tmp/TAIL;$(package.notice)" + } | + $(PAX) --filter=- \ + --to=ascii \ + $(op:N=delta:??--format=$(format)?) \ + --local \ + --checksum=md5:$(PACKAGEGEN)/$(name)-run.sum \ + --install=$(PACKAGEGEN)/$(name)-run.ins \ + -wvf $(runtime) $(base) \ + $(op:N=delta:?--format=gzip??) \ + -s",^$tmp/,$(INSTALLOFFSET)/," \ + $(PACKAGEROOT:C%.*%-s",^&/,,"%) + echo $(runtime) >> $(runtime:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + $(SUM) -x $(checksum) < $(runtime) > $(runtime:D:B:S=.$(checksum)) + echo $(runtime:D:B:S=.$(checksum)) >> $(runtime:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + echo local > $(runtime:D:B=$(name)-run:S=.$(CC.HOSTTYPE).tim) + if [[ '$(incremental)' == 1 && '$(old.runtime)' ]] + then $(PAX) -rf $(runtime) -wvf $(old.new.runtime) -z $(old.runtime) + echo $(old.new.runtime) >> $(runtime:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + $(SUM) -x $(checksum) < $(old.new.runtime) > $(old.new.runtime:D:B:S=.$(checksum)) + echo $(old.new.runtime:D:B:S=.$(checksum)) >> $(runtime:D:B=PACKAGE:S=.$(CC.HOSTTYPE).lst) + fi + rm -rf $tmp + fi + +list.installed list.manifest : + set -- $(package.closure) + for i + do cd $(INSTALLROOT)/$i + ignore $(MAKE) --noexec $(-) $(=) $(<) + done diff --git a/src/cmd/INIT/package.sh b/src/cmd/INIT/package.sh new file mode 100644 index 0000000..3f1ed1b --- /dev/null +++ b/src/cmd/INIT/package.sh @@ -0,0 +1,7302 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2012 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +### this script contains archaic constructs that work with all sh variants ### +# package - source and binary package control +# Glenn Fowler <gsf@research.att.com> + +command=package + +case $-:$BASH_VERSION in +*x*:[0123456789]*) : bash set -x is broken :; set +ex ;; +esac + +# ksh checks -- ksh between 2007-11-05 and 2011-11-11 conflict with new -lcmd -- wea culpa +checksh() +{ + egrep 'Version.*(88|1993)' $1 >/dev/null 2>&1 || + $1 -c '(( .sh.version >= 20111111 ))' >/dev/null 2>&1 +} + +case $_AST_BIN_PACKAGE_:$SHELL:$0 in +1:*|*:/bin/sh:*) + ;; +*:*/*:*/*) + _AST_BIN_PACKAGE_=1 # prevent non-interactive sh .rc referencing bin/package recursion # + export _AST_BIN_PACKAGE_ + if checksh $SHELL + then : no -lcmd conflict : + else case " $* " in + *" debug "*|*" DEBUG "*|*" show "*) + echo $command: $SHELL: warning: possible -lcmd conflict -- falling back to /bin/sh >&2 + ;; + esac + SHELL=/bin/sh + export SHELL + exec $SHELL "$0" "$@" + fi + ;; +esac + +LC_ALL=C +export LC_ALL + +src="cmd contrib etc lib" +use="/usr/common /exp /usr/local /usr/add-on /usr/addon /usr/tools /usr /opt" +usr="/home" +lib="" # nee /usr/local/lib /usr/local/shlib +ccs="/usr/kvm /usr/ccs/bin" +org="gnu GNU" +makefiles="Mamfile Nmakefile nmakefile Makefile makefile" +env="HOSTTYPE NPROC PACKAGEROOT INSTALLROOT PATH" +checksum=md5sum +checksum_commands="$checksum md5" +checksum_empty="d41d8cd98f00b204e9800998ecf8427e" + +package_use='=$HOSTTYPE=$PACKAGEROOT=$INSTALLROOT=$EXECROOT=$CC=' + +PACKAGE_admin_tail_timeout=${PACKAGE_admin_tail_timeout:-"1m"} + +CROSS=0 + +admin_db=admin.db +admin_env=admin.env +admin_ditto="ditto --checksum --delete --verbose" +admin_ditto_update=--update +admin_ditto_skip="OFFICIAL|core|old|*.core|*.tmp|.nfs*" +admin_list='PACKAGE.$type.lst' +admin_ping="ping -c 1 -w 5" + +default_url=default.url +MAKESKIP=${MAKESKIP:-"*[-.]*"} +RATZ=ratz +SED= +TAR=tar +TARFLAGS=xv +TARPROBE=B +TR= + +all_types='*.*|sun4' # all but sun4 match *.* + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) USAGE=$' +[-? +@(#)$Id: package (AT&T Research) 2012-02-29 $ +]'$USAGE_LICENSE$' +[+NAME?package - source and binary package control] +[+DESCRIPTION?The \bpackage\b command controls source and binary + packages. It is a \bsh\b(1) script coded for maximal portability. All + package files are in the \b$PACKAGEROOT\b directory tree. + \b$PACKAGEROOT\b must at minumum contain a \bbin/package\b command or a + \blib/package\b directory. Binary package files are in the + \b$INSTALLROOT\b (\b$PACKAGEROOT/arch/\b\ahosttype\a) tree, where + \ahosttpe\a=`\bpackage\b`. All \aactions\a but \bhost\b and \buse\b + require the current directory to be under \b$PACKAGEROOT\b. See + \bDETAILS\b for more information.] +[+?Note that no environment variables need be set by the user; + \bpackage\b determines the environment based on the current working + directory. The \buse\b action starts a \bsh\b(1) with the environment + initialized. \bCC\b, \bCCFLAGS\b, \bHOSTTYPE\b and \bSHELL\b may be set + by explicit command argument assignments to override the defaults.] +[+?Packages are composed of components. Each component is built and + installed by an \bast\b \bnmake\b(1) makefile. Each package is also + described by an \bnmake\b makefile that lists its components and + provides a content description. The package makefile and component + makefiles provide all the information required to read, write, build + and install packages.] +[+?Package recipients only need \bsh\b(1) and \bcc\b(1) to build and + install source packages, and \bsh\b to install binary packages. + \bnmake\b and \bksh93\b are required to write new packages. An + \b$INSTALLROOT/bin/cc\b script may be supplied for some architectures. + This script supplies a reasonable set of default options for compilers + that accept multiple dialects or generate multiple object/executable + formats.] +[+?The command arguments are composed of a sequence of words: zero or + more \aqualifiers\a, one \aaction\a, and zero or more action-specific + \aarguments\a, and zero or more \aname=value\a definitions. \apackage\a + names a particular package. The naming scheme is a \b-\b separated + hierarchy; the leftmost parts describe ownership, e.g., + \bgnu-fileutils\b, \bast-base\b. If no packages are specified then all + packages are operated on. \boptget\b(3) documentation options are also + supported. The default with no arguments is \bhost type\b.] +[+?The qualifiers are:] + { + [+authorize \aname\a?Remote authorization user name or license + acceptance phrase.] + [+debug|environment?Show environment and actions but do not + execute.] + [+flat?Collapse \b$INSTALLROOT\b { bin fun include lib } onto + \b$PACKAGEROOT\b.] + [+force?Force the action to override saved state.] + [+never?Run make -N and show other actions.] + [+only?Only operate on the specified packages.] + [+password \apassword\a?Remote authorization or license + acceptance password.] + [+quiet?Do not list captured action output.] + [+show?Run make -n and show other actions.] + [+verbose?Provide detailed action output.] + [+DEBUG?Trace the package script actions in detail.] + } +[+?The actions are:] + { + [+admin\b [\ball\b]] [\bdb\b \afile\a]] [\bon\b \apattern\a]][\aaction\a ...]]?Apply + \aaction\a ... to the hosts listed in \afile\a. If \afile\a is + omitted then \badmin.db\b is assumed. The caller must have + \brcp\b(1) and \brsh\b(1) or \bscp\b(1) and \bssh\b(1) access + to the hosts. Output for \aaction\a is saved per-host in the + file \aaction\a\b.log/\b\ahost\a. Logs can be viewed by + \bpackage admin\b [\bon\b \ahost\a]] \bresults\b [\aaction\a]]. + By default only local PACKAGEROOT hosts are selected from + \afile\a; \ball\b selects all hosts. \bon\b \apattern\a selects + only hosts matching the \b|\b separated \apattern\a. \afile\a + contains four types of lines. Blank lines and lines beginning + with \b#\b are ignored. Lines starting with \aid\a=\avalue\a + are variable assignments. Set admin_ping to local conventions + if \"'$admin_ping$'\" fails. If a package list is not specified + on the command line the \aaction\a applies to all packages; a + variable assigment \bpackage\b=\"\alist\a\" applies \aaction\a + to the packages in \alist\a for subsequent hosts in \afile\a. + The remaining line type is a host description consisting of 6 + tab separated fields. The first 3 are mandatory; the remaining + 3 are updated by the \badmin\b action. \afile\a is saved in + \afile\a\b.old\b before update. The fields are:] + { + [+hosttype?The host type as reported by + \"\bpackage\b\".] + [+[user@]]host?The host name and optionally user name + for \brcp\b(1) and \brsh\b(1) access.] + [+[remote::[[master]]::]]]]PACKAGEROOT?The absolute remote package + root directory and optionally the remote protocol (rsh + or ssh) if the directory is on a different server than + the master package root directory. If + \blib/package/admin/'$admin_env$'\b exists under this + directory then it is sourced by \bsh\b(1) before + \aaction\a is done. If this field begins with \b-\b + then the host is ignored. If this field contains \b:\b + then \bditto\b(1) is used to sync the remote \bsrc\b + directory hierarchy to the local one. If [\amaster\a]]: + is specified then the sync is deferred to the \amaster\a + host. If \amaster\a is omitted (two :) then the sync is + disabled. These directories must exist on the remote side: + \blib/package\b, \bsrc/cmd\b, \bsrc/lib\b.] + [+date?\aYYMMDD\a of the last action.] + [+time?Elapsed wall time for the last action.] + [+M T W?The \badmin\b action \bmake\b, \btest\b and + \bwrite\b action error counts. A non-numeric value in + any of these fields disables the corresponding action.] + } + [+clean | clobber?Delete the \barch/\b\aHOSTTYPE\a hierarchy; this + deletes all generated files and directories for \aHOSTTYPE\a. + The heirarchy can be rebuilt by \bpackage make\b.] + [+contents\b [ \apackage\a ... ]]?List description and + components for \apackage\a on the standard output.] + [+copyright\b [ \apackage\a ... ]]?List the general copyright + notice(s) for \apackage\a on the standard output. Note that + individual components in \apackage\a may contain additional or + replacement notices.] + [+export\b [ \avariable\a ...]]?List \aname\a=\avalue\a for + \avariable\a, one per line. If the \bonly\b attribute is + specified then only the variable values are listed. If no + variables are specified then \b'$env$'\b are assumed.] + [+help\b [ \aaction\a ]]?Display help text on the standard + error (standard output for \aaction\a).] + [+host\b [ \aattribute\a ... ]]?List + architecture/implementation dependent host information on the + standard output. \btype\b is listed if no attributes are + specified. Information is listed on a single line in + \aattribute\a order. The attributes are:] + { + [+canon \aname\a?An external host type name to be + converted to \bpackage\b syntax.] + [+cpu?The number of cpus; 1 if the host is not a + multiprocessor.] + [+name?The host name.] + [+rating?The cpu rating in pseudo mips; the value is + useful useful only in comparisons with rating values of + other hosts. Other than a vax rating (mercifully) fixed + at 1, ratings can vary wildly but consistently from + vendor mips ratings. \bcc\b(1) may be required to + determine the rating.] + [+type?The host type, usually in the form + \avendor\a.\aarchitecture\a, with an optional trailing + -\aversion\a. The main theme is that type names within + a family of architectures are named in a similar, + predictable style. OS point release information is + avoided as much as possible, but vendor resistance to + release incompatibilities has for the most part been + futile.] + } + [+html\b [ \aaction\a ]]?Display html help text on the standard + error (standard output for \aaction\a).] + [+install\b [ \aarchitecture\a ... ]] \adirectory\a [ \apackage\a ... ]]?Copy + the package binary hierarchy to \adirectory\a. If + \aarchitecture\a is omitted then all architectures are + installed. If \bflat\b is specified then exactly one + \aarchitecture\a must be specified; this architecture will be + installed in \adirectory\a without the \barch/\b\aHOSTTYPE\a + directory prefixes. Otherwise each architecture will be + installed in a separate \barch/\b\aHOSTTYPE\a subdirectory of + \adirectory\a. The \aarchitecture\a \b-\b names the current + architecture. \adirectory\a must be an existing directory. If + \apackage\a is omitted then all binary packages are installed. + This action requires \bnmake\b.] + [+license\b [ \apackage\a ... ]]?List the source license(s) for + \apackage\a on the standard output. Note that individual + components in \apackage\a may contain additional or replacement + licenses.] + [+list\b [ \apackage\a ... ]]?List the name, version and + prerequisites for \apackage\a on the standard output.] + [+make\b [ \apackage\a ]] [ \aoption\a ... ]] [ \atarget\a ... ]]?Build + and install. The default \atarget\a is \binstall\b, which makes + and installs \apackage\a. If the standard output is a terminal + then the output is also captured in + \b$INSTALLROOT/lib/package/gen/make.out\b. The build is done in + the \b$INSTALLROOT\b directory tree viewpathed on top of the + \b$PACKAGEROOT\b directory tree. If \bflat\b is specified then + the \b$INSTALLROOT\b { bin fun include lib } directories are + linked to the same directories in the package root. Only one + architecture may be \bflat\b. Leaf directory names matching the + \b|\b-separated shell pattern \b$MAKESKIP\b are ignored. The + \bview\b action is done before making. \aoption\a operands are + passed to the underlying make command.] + [+read\b [ \apackage\a ... | \aarchive\a ... ]]?Read the named + package or archive(s). Must be run from the package root + directory. Archives are searched for in \b.\b and + \blib/package/tgz\b. Each package archive is read only once. + The file \blib/package/tgz/\b\apackage\a[.\atype\a]]\b.tim\b + tracks the read time. See the \bwrite\b action for archive + naming conventions. Text file archive member are assumed to be + ASCII or UTF-8 encoded.] + [+regress?\bdiff\b(1) the current and previous \bpackage test\b + results.] + [+release\b [ [\aCC\a]]\aYY-MM-DD\a [ [\acc\a]]\ayy-mm-dd\a ]]]] [ \apackage\a ]]?Display + recent changes for the date range [\aCC\a]]\aYY-MM-DD\a (up to + [\acc\a]]\ayy-mm-dd\a.), where \b-\b means lowest (or highest.) + If no dates are specified then changes for the last 4 months + are listed. \apackage\a may be a package or component name.] + [+remove\b [ \apackage\a ]]?Remove files installed for + \apackage\a.] + [+results\b [ \bfailed\b ]] [ \bpath\b ]] [ \bold\b ]] [\bmake\b | \btest\b | \bwrite\b ]]?List + results and interesting messages captured by the most recent + \bmake\b (default), \btest\b or \bwrite\b action. \bold\b + specifies the previous results, if any (current and previous + results are retained.) \b$HOME/.pkgresults\b, if it exists, + must contain an \begrep\b(1) expression of result lines to be + ignored. \bfailed\b lists failures only and \bpath\b lists the + results file path name only.] + [+setup\b [ beta ]] [ binary ]] [ source ]] [ \aarchitecture\a ... ]] [ \aurl\a ]] [ \apackage\a ... ]]?This + action initializes the current directory as a package root, runs the + \bupdate\b action to download new or out of date packages, and runs the + \bread\b action on those packages. If \bflat\b is specified then the + \b$INSTALLROOT\b { bin fun include lib } directories are linked to the + same directories in the package root. Only one architecture may be + \bflat\b. See the \bupdate\b and \bread\b action descriptions for + argument details.] + [+test\b [ \apackage\a ]]?Run the regression tests for + \apackage\a. If the standard output is a terminal then the + output is also captured in + \b$INSTALLROOT/lib/package/gen/test.out\b. In general a package + must be made before it can be tested. Components tested with + the \bregress\b(1) command require \bksh93\b. If \bonly\b is + also specified then only the listed package components are + tested, otherwise the closure of the components is tested.] + [+update\b [ beta ]] [ binary ]] [ source ]] [\aarchitecture\a ... ]] [ \aurl\a ]] [ \apackage\a ... ]]?Download + the latest release of the selected and required packages from \aurl\a + (e.g., \bhttp://www.research.att.com/sw/download\b) into the directory + \b$PACKAGEROOT/lib/package/tgz\b. \bbeta\b acesses beta packages; + download these at your own risk. If \aarchitecture\a is omitted then + only architectures already present in the \btgz\b directory will be + downloaded. If \aarchitecture\a is \b-\b then all posted architectures + will be downloaded. If \aurl\a matches \b*.url\b then it is interpreted + as a file containing shell variable assignments for \burl\b, + \bauthorize\b and \bpassword\b. If \aurl\a is omitted then the + definitions for \burl\b, \bauthorize\b and \bpassword\b in + \b$PACKAGEROOT/lib/package/tgz/default.url\b, if it exists, are used. + If \b$PACKAGEROOT/lib/package/tgz/default.url\b does not exist then it + is initialized with the current \burl\b, \bauthorize\b and \bpassword\b + values and read permission for the current user only. If \apackage\a is + omitted then only packages already present in the tgz directory will be + downloaded. If \apackage\a is \b-\b then all posted packages will be + downloaded. If \bsource\b and \bbinary\b are omitted then both source + and binary packages will be downloaded. If \bonly\b is specified then + only the named packages are updated; otherwise the closure of required + packages is updated. This action requires \bwget\b(1), \blynx\b(1), + \bcurl\b(1) or a shell that supports io to + \b/dev/tcp/\b\ahost\a/\aport\a.] + [+use\b [ \auid\a | \apackage\a | . [ 32 | 64 ]] | 32 | 64 | - ]] [ command ...]]?Run + \acommand\a, or an interactive shell if \acommand\a is omitted, + with the environment initialized for using the package (can you + say \ashared\a \alibrary\a or \adll\a without cussing?) If + \auid\a or \apackage\a or \a.\a is specified then it is used + to determine a \b$PACKAGEROOT\b, possibly different from + the current directory. For example, to try out bozo`s package: + \bpackage use bozo\b. The \buse\b action may be run from any + directory. If the file \b$INSTALLROOT/lib/package/profile\b is + readable then it is sourced to initialize the environment. 32 or 64 + implies \b$PACKAGEROOT\b of . and specifies the target architecture + word size (which may be silently ignored.)] + [+verify\b [ \apackage\a ]]?Verify installed binary files + against the checksum files in + \b$INSTALLROOT/lib/\b\apackage\a\b/gen/*.sum\b. The checksum + files contain mode, user and group information. If the checksum + matches for a given file then the mode, user and group are + changed as necessary to match the checksum entry. A warning is + printed on the standard error for each mismatch. Requires the + \bast\b package \bcksum\b(1) command.] + [+view\b?Initialize the architecture specific viewpath + hierarchy. If \bflat\b is specified then the \b$INSTALLROOT\b { + bin fun include lib } directories are linked to the same + directories in the package root. Only one architecture may be + \bflat\b. The \bmake\b action implicitly calls this action.] + [+write\b [\aformat\a]] \atype\a ... [ \apackage\a ...]]?Write + a package archive for \apackage\a. All work is done in the + \b$PACKAGEROOT/lib/package\b directory. \aformat\a-specific + files are placed in the \aformat\a subdirectory. A + \apackage\a[.\atype\a]]\b.tim\b file in this directory tracks + the write time and prevents a package from being read in the + same root it was written. If more than one file is generated + for a particular \aformat\a then those files are placed in the + \aformat\a/\apackage\a subdirectory. File names in the + \aformat\a subdirectory will contain the package name, a + \ayyyy-mm-dd\a date, and for binary packages, \aHOSTTYPE\a. If + \apackage\a is omitted then an ordered list of previously + written packages is generated. If \bonly\b is specified then + only the named packages will be written; otherwise prerequisite + packages are written first. Package components must be listed + in \apackage\a\b.pkg\b. \aformat\a may be one of:] + { + [+cyg?Generate a \bcygwin\b package.] + [+exp?Generate an \bexptools\b maintainer source + archive and \aNPD\a file, suitable for \bexpmake\b(1)] + [+lcl?Generate a package archive suitable for + restoration into the local source tree (i.e., the + source is not annotated for licencing.)] + [+pkg?Generate a \bpkgmk\b(1) package suitable for + \bpkgadd\b(1).] + [+rpm?Generate an \brpm\b(1) package.] + [+tgz?Generate a \bgzip\b(1) \btar\b(1) package + archive. This is the default.] + [+tst?Generate a \btgz\b format package archive in the + \btst\b subdirectory. Version state files are not updated.] + } + [+?\btype\b specifies the package type which must be one of + \bsource\b, \bbinary\b or \bruntime\b. A source package + contains the source needed to build the corresponding binary + package. A binary package includes the libraries and headers + needed for compiling and linking against the public interfaces. + A runtime package contains the commands and required dynamic + libraries.] + [+?A package may be either a \bbase\b or \bdelta\b. A base + package contains a complete copy of all components. A delta + package contains only changes from a previous base package. + Delta recipients must have the \bast\b \bpax\b(1) command (in + the \bast-base\b package.) If neither \bbase\b nor \bdelta\b is + specified, then the current base is overwritten if there are no + deltas referring to the current base. Only the \btgz\b and + \blcl\b formats support \bdelta\b. If \bbase\b is specified + then a new base and two delta archives are generated: one delta + to generate the new base from the old, and one delta to + generate the old base from the new; the old base is then + removed. If \bdelta\b is specified then a new delta referring + to the current base is written.] + [+?\apackage\a\b.pkg\b may reference other packages. By default + a pointer to those packages is written. The recipient \bpackage + read\b will then check that all required packages have been + downloaded. If \bclosure\b is specified then the components for + all package references are included in the generated package. + This may be useful for \blcl\b and versioning.] + [+?All formats but \blcl\b annotate each \bsource\b file (not + already annotated) with a license comment as it is written to + the package archive using \bproto\b(1).] + } +[+DETAILS?The package directory hierarchy is rooted at + \b$PACKAGEROOT\b. All source and binaries reside under this tree. A two + level viewpath is used to separate source and binaries. The top view is + architecture specific, the bottom view is shared source. All building + is done in the architecture specific view; no source view files are + intentionally changed. This means that many different binary + architectures can be made from a single copy of the source.] +[+?Independent \b$PACKAGEROOT\b hierarchies can be combined by + appending \b$INSTALLROOT:$PACKAGEROOT\b pairs to \bVPATH\b. The + \bVPATH\b viewing order is from left to right. Each \b$PACKAGEROOT\b + must have a \b$PACKAGEROOT/lib/package\b directory.] +[+?Each package contains one or more components. Component source for + the \afoo\a command is in \b$PACKAGEROOT/src/cmd/\b\afoo\a, and source + for the \abar\a library is in \b$PACKAGEROOT/src/lib/lib\b\abar\a. This + naming is for convenience only; the underlying makefiles handle + inter-component build order. The \bINIT\b component, which contains + generic package support files, is always made first, then the + components named \bINIT\b*, then the component order determined by the + closure of component makefile dependencies.] +[+?\b$PACKAGEROOT/lib/package\b contains package specific files. The + package naming convention is \agroup\a[-\apart\a]]; e.g., \bast-base\b, + \bgnu-fileutils\b. The *\b.pkg\b files are ast \bnmake\b(1) makefiles + that contain the package name, package components, references to other + packages, and a short package description. *\b.pkg\b files are used by + \bpackage write\b to generate new source and binary packages.] +[+?\b$PACKAGEROOT/lib/package/\b\agroup\a\b.lic\b files contain license + information that is used by the \bast\b \bproto\b(1) and \bnmake\b(1) + commands to generate source and binary license strings. \agroup\a is + determined by the first \b:PACKAGE:\b operator name listed in the + component \bnmake\b makefile. \agroup\a\b.lic\b files are part of the + licensing documentation. Each component may have its own \bLICENSE\b file + that overrides the \agroup\a\b.lic\b file. The full text of the licenses + are in the \b$PACKAGEROOT/lib/package/LICENSES\b and + \b$INSTALLROOT/lib/package/LICENSES\b directories.] +[+?A few files are generated in \b$PACKAGEROOT/lib/package/gen\b and + \b$INSTALLROOT/lib/package/gen\b. \apackage\a\b.ver\b contains one line + consisting of \apackage version release\a \b1\b for the most recent + instance of \apackage\a read into \b$PACKAGEROOT\b, where \apackage\a + is the package name, \aversion\a is the \aYYYY-MM-DD\a base version, + and \arelease\a is \aversion\a for the base release or \aYYYY-MM-DD\a + for delta releases. \apackage\a\b.req\b contains *\b.ver\b entries for + the packages required by \apackage\a, except that the fourth field is + \b0\b instead of \b1\b. All packages except \bINIT\b require the + \bINIT\b package. A simple sort of \apackage\a\b.pkg\b and *\b.ver\b + determines if the required package have been read in. Finally, + \apackage\a\b.README\b and \apackage\a\a.html\b contain the README text + for \apackage\a and all its components. Included are all changes added + to the component \bRELEASE\b, \bCHANGES\b or \bChangeLog\b files dated + since the two most recent base releases. Component \bRELEASE\b files + contain tag lines of the form [\aYY\a]]\aYY-MM-DD\a [ \atext\a ]] (or + \bdate\b(1) format dates) followed by README text, in reverse + chronological order (newer entries at the top of the file.) \bpackage + release\b lists this information, and \bpackage contents ...\b lists + the descriptions and components.] +[+?\b$HOSTYPE\b names the current binary architecture and is determined + by the output of \bpackage\b (no arguments.) The \b$HOSTTYPE\b naming + scheme is used to separate incompatible executable and object formats. + All architecture specific binaries are placed under \b$INSTALLROOT\b + (\b$PACKAGEROOT/arch/$HOSTTYPE\b.) There are a few places that match + against \b$HOSTTYPE\b when making binaries; these are limited to + makefile compiler workarounds, e.g., if \b$HOSTTYPE\b matches \bhp.*\b + then turn off the optimizer for these objects. All other architecture + dependent logic is handled either by the \bast\b \biffe\b(1) command or + by component specific configure scripts. Explicit \b$HOSTYPE\b + values matching *,*cc*[,-*,...]] optionally set the default \bCC\b and + \bCCFLAGS\b. This is handy for build farms that support different + compilers on the same architecture.] +[+?Each component contains an \bast\b \bnmake\b(1) makefile (either + \bNmakefile\b or \bMakefile\b) and a \bMAM\b (make abstract machine) + file (\bMamfile\b.) A Mamfile contains a portable makefile description + that is used by \bmamake\b(1) to simulate \bnmake\b. Currently there is + no support for old-make/gnu-make makefiles; if the binaries are just + being built then \bmamake\b will suffice; if source or makefile + modifications are anticipated then \bnmake\b (in the \bast-base\b + package) should be used. Mamfiles are automatically generated by + \bpackage write\b.] +[+?Most component C source is prototyped. If \b$CC\b (default value + \bcc\b) is not a prototyping C compiler then \bpackage make\b runs + \bproto\b(1) on portions of the \b$PACKAGEROOT/src\b tree and places + the converted output files in the \b$PACKAGEROOT/proto/src\b tree. + Converted files are then viewpathed over the original source. + \bproto\b(1) converts an ANSI C subset to code that is compatible with + K&R, ANSI, and C++ dialects.] +[+?All scripts and commands under \b$PACKAGEROOT\b use \b$PATH\b + relative pathnames (via the \bast\b \bpathpath\b(3) function); there + are no imbedded absolute pathnames. This means that binaries generated + under \b$PACKAGEROOT\b may be copied to a different root; users need + only change their \b$PATH\b variable to reference the new installation + root \bbin\b directory. \bpackage install\b installs binary packages in + a new \b$INSTALLROOT\b.] + +[ qualifier ... ] [ action ] [ arg ... ] [ n=v ... ] + +[+SEE ALSO?\bautoconfig\b(1), \bcksum\b(1), \bexecrate\b(1), \bexpmake\b(1), + \bgzip\b(1), \bmake\b(1), \bmamake\b(1), \bnmake\b(1), \bpax\b(1), + \bpkgadd\b(1), \bpkgmk\b(1), \bproto\b(1), \bratz\b(1), \brpm\b(1), + \bsh\b(1), \btar\b(1), \boptget\b(3)] +' + case $* in + help) set -- --man ;; + esac + while getopts -a $command "$USAGE" OPT + do : + done + shift $OPTIND-1 + ;; +esac + +# check the args + +case $AR in +'') AR=ar ;; +esac +case $CC in +'') CC=cc ;; +esac +case $LD in +'') LD=ld ;; +esac +case $NM in +'') NM=nm ;; +esac + +action= +admin_all=1 +admin_on= +authorize= +bit= +exec= +flat=0 +force=0 +global= +hi= +html=0 +ifs=${IFS-' + '} +lo= +make= +makeflags='-k -K' +nmakeflags= +nmakesep= +nl=" +" +noexec= +only=0 +output= +package_src= +password= +quiet=0 +show=: +tab=" " +verbose=0 +AUTHORIZE= +DEBUG= +HURL= +PROTOROOT=- +SHELLMAGIC=- + +unset FIGNORE BINDIR DLLDIR ETCDIR FUNDIR INCLUDEDIR LIBDIR LOCALEDIR MANDIR SHAREDIR 2>/dev/null || true + +while : +do case $# in + 0) set host type ;; + esac + case $1 in + admin|clean|clobber|contents|copyright|export|host|install|license|list|make|read|regress|release|remove|results|setup|test|update|use|verify|view|write|TEST) + action=$1 + shift + break + ;; + authorize) + case $# in + 1) echo $command: $1: authorization user name argument expected >&2; exit 1 ;; + esac + shift + authorize=$1 + shift + continue + ;; + debug|environment) + exec=echo make=echo show=echo + ;; + flat) flat=1 + ;; + force) force=1 + ;; + never) exec=echo noexec=-N + ;; + only) only=1 + ;; + password) + case $# in + 1) echo $command: $1: authorization password argument expected >&2; exit 1 ;; + esac + shift + password=$1 + shift + continue + ;; + quiet) quiet=1 + ;; + show) exec=echo noexec=-n + ;; + verbose)verbose=1 + ;; + DEBUG) DEBUG=1 + PS4='+$LINENO:$SECONDS+ ' + set -x + ;; + help|HELP|html|man|--[?m]*) + case $1 in + help) code=0 + case $2 in + '') exec 1>&2 ;; + esac + ;; + html) code=0 html=1 + ;; + *) code=2 + exec 1>&2 + ;; + esac + case $html in + 1) bO="<HTML> +<HEAD> +<TITLE>$2 package installation instructions</TITLE> +<HEAD> +<BODY bgcolor=white link=teal vlink=dimgray>" + eO='</BODY> +</HTML>' + bH="<CENTER><H3><FONT face=courier color=red>" + eH='</FONT></H3></CENTER>' + bP='<P>' + bL='<P><TABLE cellpadding=0 cellspacing=2>' + bL2='<P><TABLE border=0 cellpadding=0 cellspacing=2>' + eL='</TABLE><P>' + bT='<TR><TD align=right valign=top><B>' + bD='</B></TD><TD align=left>' eD='</TD></TR>' + bB='<B>' eB='</B>' + bI='<I>' eI='</I>' + bX='<PRE>' eX='</PRE>' + bF='<TT>' eF='</TT>' + Camp='&' + Mcurl='<A href=../../man/man1/curl.html>curl</A>(1)' + Mdate='<A href=../../man/man1/date.html>date</A>(1)' + Mfile='<A href=../../man/man1/file.html>file</A>(1)' + Mgunzip='<A href=../../man/man1/gzip.html>gunzip</A>(1)' + Mhurl='<A href=../../man/man1/hurl.html>hurl</A>(1)' + Mlynx='<A href=../../man/man1/lynx.html>lynx</A>(1)' + Mnmake='<A href=../../man/man1/nmake.html>nmake</A>(1)' + Mpackage='<A href=../../man/man1/package.html>package</A>(1)' + Mproto='<A href=../../man/man1/proto.html>proto</A>(1)' + Mratz='<A href=../../man/man1/ratz.html>ratz</A>' + Mtar='<A href=../../man/man1/tar.html>tar</A>(1)' + Mwget='<A href=../../man/man1/wget.html>wget</A>(1)' + ;; + *) bO='' eO='' + bH='' eH=':' + bP='' + bL='' eL='' + bL2='' + bT=' ' + bD=' ' eD='' + bB='' eB='' + bI='' eI='' + bX='' eX='' + bF='"' eF='"' + Camp='&' + Mcurl='curl(1)' + Mdate='date(1)' + Mfile='file(1)' + Mgunzip='gunzip(1)' + Mhurl='hurl(1)' + Mlynx='lynx(1)' + Mnmake='nmake(1)' + Mpackage='package(1)' + Mproto='proto(1)' + Mratz='ratz' + Mtar='tar(1)' + Mwget='wget(1)' + ;; + esac + case $2 in + binary) echo "${bO} +${bH}Binary Package Installation Instructions${eH} +${bL} +${bT}(1)${bD}Do not install packages as ${bI}root/super-user${eI}. Although some components may + have setuid executables, few must be owned by ${bI}root${eI}. These are best + changed manually when the security implications are understood.${eD} +${bT}(2)${bD}Choose a package root directory and cd to it. This will be a local work + area for all packages.${eD} +${bT}(3)${bD}These instructions bypass the ${bI}click to download${eI} package links on the + download site. If you already clicked, or if your system does not have + ${Mcurl}, ${Mhurl}, ${Mlynx} or ${Mwget} then use the alternate instructions + for (3),(4),(5) in plan ${bB}B${eB} below. Plan ${bB}B${eB} installs the ${Mhurl} + script which works with ksh and modern bash. The top level URL is:${bX} + URL=http://www.research.att.com/sw/download${eX}${eD} +${bT}(4)${bD}If the ${bB}bin/package${eB} script does not exist then run:${bX} + test -d bin || mkdir bin + url=\$URL/package + (wget -O bin/package \$url||curl -L \$url||hurl \$url) > bin/package + chmod +x bin/package${eX}${eD} +${bT}(5)${bD}Determine the list of package names you want from the download site, then + use the ${Mpackage} command to do the actual download:${bX} + bin/package authorize \"${bI}NAME${eI}\" password \"${bI}PASSWORD${eI}\" \\ + setup binary \$URL ${bI}PACKAGE${eI} ...${eX} + (Refer to the ${bB}AUTHORIZATION${eB} paragraph on the main download page for + ${bI}NAME${eI}/${bI}PASSWORD${eI} details.) This downloads the closure of the latest + binary package(s); covered and up-to-date packages are not downloaded again unless + ${bB}package force ...${eB} is specified. Package content is verified using ${bB}${checksum}${eB}. + If the package root will contain only one architecture then you can install in ${bB}bin${eB} and + ${bB}lib${eB} instead of ${bB}arch/${eB}${bI}HOSTTYPE${eI}${bB}/bin${eB} and ${bB}arch/${eB}${bI}HOSTTYPE${eI}${bB}/lib${eB} by running this + instead:${bX} + bin/package authorize \"${bI}NAME${eI}\" password \"${bI}PASSWORD${eI}\" \\ + flat setup binary \$URL ${bB}PACKAGE${eB} ...${eX} + To update the same packages from the same URL run:${bX} + bin/package setup binary${eX}${eD} +${bT}(6)${bD}The packaged binaries are position independent, i.e., they do not + contain hard-coded paths. However, commands with related files, like + ${Mfile} and ${Mnmake}, require the path of the bin directory to be + exported in ${bB}PATH${eb}.${eD} +${bT}(7)${bD}You can run the binaries directly from the package root, or you can + install them in a public root (requires the ${bI}AT${Camp}T${eI} ${Mnmake} command):${bX} + bin/package flat install ${bI}DIRECTORY PACKAGE${eI}${eX} + This will install in ${bI}DIRECTORY${eI}${bB}/bin${eB} and ${bI}DIRECTORY${eI}${bB}/lib${eB}. If you want to + preserve the ${bB}arch/${eB}${bI}HOSTTYPE${eI} hierarchy under ${bI}DIRECTORY${eI} then omit the + ${bB}flat${eB} argument. If you don't have ${Mnmake} then the following will do a + flat install:${bX} + cd \$INSTALLROOT + cp -p -r bin lib include ${bI}DIRECTORY${eI}${eX}${eD} +${bT}(8)${bD}To summarize, after the first time, the download cycle for the latest + binary release is:${bX} + bin/package setup binary${eX}${eD}${eL} + +${bH}Binary Package Installation Instructions -- Plan B${eH} +${bL} +${bT}(3)${bD}Create the subdirectory ${bB}lib/package/tgz${eB} and download all package archives + into that directory.${eD} +${bT}(4)${bD}If the ${bB}bin/package${eB} script does not exist then manually read the ${bB}INIT${eB} + binary package:${bX} + gunzip < lib/package/tgz/INIT.${bI}YYYY-MM-DD.HOSTTYPE${eI}.tgz | + ${TAR} ${TARFLAGS}f -${eX} + Note that some browsers automatically unzip downloaded without warning. + If the gunzip fails try: + ${TAR} ${TARFLAGS}f -${eX} lib/package/tgz/INIT.${bI}YYYY-MM-DD.HOSTTYPE${eI}.tgz + If your system does not have ${Mtar} or ${Mgunzip} then download the ${Mratz} + binary package:${bX} + mkdir bin + cp lib/package/tgz/ratz.${bI}YYYY-MM-DD.HOSTTYPE${eI}.exe bin/ratz + chmod +x bin/ratz + bin/ratz -lm < lib/package/tgz/INIT.${bI}YYYY-MM-DD/HOSTTYPE${eI}.tgz +${bT}(5)${bD}Read all unread package archive(s):${bX} + bin/package read${eX} + Both source and binary packages will be read by this step.${eD}${eL}${eO}" + ;; + intro) echo "${bO} +${bH}Package Hierarchy Details${eH} +${bP} +The package directory hierarchy is rooted at ${bB}\$PACKAGEROOT${eB}. All source and +binaries reside under this tree. A two level viewpath is used to separate +source and binaries. The top view is architecture specific, the bottom view +is shared source. All building is done in the architecture specific view; +no source view files are intentionally changed. This means that many +different binary architectures can be made from a single copy of the source. +${bP} +Each package contains one or more components. Component source for the ${bI}FOO${eI} +command is in ${bB}\$PACKAGEROOT/src/cmd/${eB}${bI}FOO${eI}, and source for the ${bI}BAR${eI} library is +in ${bB}\$PACKAGEROOT/src/lib/lib${eB}${bI}BAR${eI}. This naming is for convenience only; the +underlying makefiles handle inter-component build order. The ${bB}INIT${eB} component, +which contains generic package support files, is always made first, then the +components named ${bB}INIT${eB}*, then the order determined by the closure of component +makefile dependencies. +${bP} +${bB}\$PACKAGEROOT/lib/package${eB} contains package specific files. The package naming +convention is ${bI}GROUP${eI}[${bI}-PART${eI}]; e.g., ${bB}ast-base${eB}, ${bB}gnu-fileutils${eB}. The *${bB}.pkg${eB} files +are ${bB}ast${eB} ${Mnmake} makefiles that contain the package name, package components, +references to other packages, and a short package description. *${bB}.pkg${eB} files +are used by ${bF}package write${eF} to generate new source and binary packages. +${bP} +${bB}\$PACKAGEROOT/lib/package/${eB}${bI}GROUP${eI}${bB}.lic${eB} files contain license information that +is used by the ${bB}ast${eB} ${Mproto} and ${Mnmake} commands to generate source and +binary license strings. ${bI}GROUP${eI} is determined by the first ${bB}:PACKAGE:${eB} operator +name listed in the component ${bB}nmake${eB} makefile. ${bI}GROUP${eI}${bB}.lic${eB} files are part of the +licensing documentation. Each component may have its own ${bB}LICENSE${eB} file that +overrides the ${bI}GROUP${eI}${bB}.lic${eB} file. The full text of the licenses are in the +${bB}\$PACKAGEROOT/lib/package/LICENSES${eB} and ${bB}\$INSTALLROOT/lib/package/LICENSES${eB} +directories. +${bP} +A few files are generated in ${bB}\$PACKAGEROOT/lib/package/gen${eB} and +${bB}\$INSTALLROOT/lib/package/gen${eB}. ${bI}PACKAGE${eI}${bB}.ver${eB} contains one line consisting of${bX} + ${bI}PACKAGE VERSION RELEASE${eI} 1${eX} +for the most recent instance of ${bI}PACKAGE${eI} read into ${bB}\$PACKAGEROOT${eB}, where +${bI}PACKAGE${eI} is the package name, ${bI}VERSION${eI} is the ${bI}YYYY-MM-DD${eI} base version, +and ${bI}RELEASE${eI} is ${bI}VERSION${eI} for the base release or ${bI}YYYY-MM-DD${eI} for delta releases. +${bI}PACKAGE${eI}${bB}.req${eB} contains *${bB}.ver${eB} entries for the packages required by +${bI}PACKAGE${eI}, except that the fourth field is 0 instead of 1. All packages +except ${bB}INIT${eB} and ${Mratz} require the ${bB}INIT${eB} package. A simple sort of ${bI}PACKAGE${eI}${bB}.pkg${eB} +and *${bB}.ver${eB} determines if the required package have been read in. Finally, +${bI}PACKAGE${eI}${bB}.README${eB} contains the ${bB}README${eB} text for ${bI}PACKAGE${eI} and all its +components. Included are all changes added to the component ${bB}RELEASE${eB}, +${bB}CHANGES${eB} or ${bB}ChangeLog${eB} files dated since the two most recent base +releases. Component ${bB}RELEASE${eB} files contain tag lines of the form +[${bI}CC${eI}]${bI}YY-MM-DD${eI} [ ${bI}TEXT${eI} ] (or ${Mdate} format dates) followed by README +text, in reverse chronological order (newer entries at the top of the +file.) ${bF}package release${eF} generates this information, and +${bF}package contents ...${eF} lists the descriptions and components. +${bP} +${bB}\$HOSTYPE${eB} names the current binary architecture and is determined by the +output of ${bF}package${eF} (no arguments.) The ${bB}\$HOSTTYPE${eB} naming scheme is used +to separate incompatible executable and object formats. All architecture +specific binaries are placed under ${bB}\$INSTALLROOT${eB} (${bB}\$PACKAGEROOT/arch/\$HOSTTYPE${eB}.) +There are a few places that match against ${bB}\$HOSTTYPE${eB} when making binaries; these +are limited to makefile compiler workarounds, e.g., if ${bB}\$HOSTTYPE${eB} matches +'hp.*' then turn off the optimizer for these objects. All other architecture +dependent logic is handled either by ${bB}\$INSTALLROOT/bin/iffe${eB} or by component +specific configure scripts. Explicit ${bB}\$HOSTYPE${eB} values matching *,*cc*[,-*,...] +optionally set the default ${bB}CC${eB} and ${bB}CCFLAGS${eB}. This is handy for build +farms that support different compilers on the same architecture. +${bP} +Each component contains an ${bB}ast${eB} ${Mnmake} makefile (either ${bB}Nmakefile${eB} or ${bB}Makefile${eB}) +and a ${bI}MAM${eI} (make abstract machine) file (${bB}Mamfile${eB}.) A Mamfile contains a portable +makefile description that is used by ${bB}\$INSTALLROOT/bin/mamake${eB} to simulate +${bB}nmake${eB}. Currently there is no support for old-make/gnu-make makefiles; if +the binaries are just being built then ${bB}mamake${eB} will suffice; if source or +makefile modifications are anticipated then ${bB}nmake${eB} (from the ${bB}ast-open${eB} or +${bB}ast-base${eB} package) should be used. Mamfiles are automatically generated by +${bF}package write${eF}. +${bP} +Most component C source is prototyped. If ${bB}\$CC${eB} (default value ${bB}cc${eB}) is not a +prototyping C compiler then ${bF}package make${eF} runs ${Mproto} on portions of the +${bB}\$PACKAGEROOT/src${eB} tree and places the converted output files in the +${bB}\$PACKAGEROOT/proto/src${eB} tree. Converted files are then viewpathed over the +original source. The ${bB}ast${eB} ${Mproto} command converts an ANSI C subset to code +that is compatible with K&R, ANSI, and C++ dialects. +${bP} +All scripts and commands under ${bB}\$PACKAGEROOT${eB} use ${bB}\$PATH${eB} relative pathnames; +there are no imbedded absolute pathnames. This means that binaries generated +under ${bB}\$PACKAGEROOT${eB} may be copied to a different root; users need only change +their ${bB}\$PATH${eB} variable to reference the new instalation root bin directory. +${bF}package install${eF} installs binary packages in a new ${bB}\$INSTALLROOT${eB}. +${eO}" + ;; + source) echo "${bO} +${bH}Source Package Installation Instructions${eH} +${bL} +${bT}(1)${bD}Do not install packages as ${bI}root/super-user${eI}. Although some components may + have setuid executables, few must be owned by ${bI}root${eI}. These are best + changed manually when the security implications are understood.${eD} +${bT}(2)${bD}Choose a package root directory and cd to it. This will be a local work + area for all packages. +${bT}(3)${bD}These instructions bypass the ${bI}click to download${eI} package links on the + download site. If you already clicked, or if your system does not have + ${Mcurl}, ${Mhurl}, ${Mlynx} or ${Mwget} then use the alternate instructions + for (3),(4),(5) in plan ${bB}B${eB} below. Plan ${bB}B${eB} installs the ${Mhurl} + script which works with ksh and modern bash. The top level URL is:${bX} + URL=http://www.research.att.com/sw/download${eX}${eD} +${bT}(4)${bD}If the ${bB}bin/package${eB} script does not exist then run:${bX} + test -d bin || mkdir bin + url=\$URL/package + (wget -O bin/package \$url||curl -L \$url||hurl \$url) > bin/package + chmod +x bin/package${eX}${eD} +${bT}(5)${bD}Determine the list of package names you want from the download site, then + use the ${Mpackage} command to do the actual download:${bX} + bin/package authorize \"${bI}NAME${eI}\" password \"${bI}PASSWORD${eI}\" \\ + setup source \$URL ${bB}PACKAGE${eB} ...${eX} + (Refer to the ${bB}AUTHORIZATION${eB} paragraph on the main download page for + ${bI}NAME${eI}/${bI}PASSWORD${eI} details.) This downloads the closure of the latest + source package(s); covered and up-to-date packages are not downloaded again unless + ${bB}package force ...${eB} is specified. Package content is verified using ${bB}${checksum}${eB}. + If the package root will contain only one architecture then you can install in ${bB}bin${eB} and + ${bB}lib${eB} instead of ${bB}arch/${eB}${bI}HOSTTYPE${eI}${bB}/bin${eB} and ${bB}arch/${eB}${bI}HOSTTYPE${eI}${bB}/lib${eB} by running this + instead:${bX} + bin/package authorize \"${bI}NAME${eI}\" password \"${bI}PASSWORD${eI}\" \\ + flat setup source \$URL ${bB}PACKAGE${eB} ...${eX} + To update the same packages from the same URL run:${bX} + bin/package setup source${eX}${eD} +${bT}(6)${bD}Build and install; all generated files are placed under ${bB}arch/${eB}${bI}HOSTTYPE${eI} + (${bB}\$INSTALLROOT${eB}), where ${bI}HOSTTYPE${eI} is the output of ${bB}bin/package${eB} (with no + arguments.) ${bI}name=value${eI} arguments are supported; ${bB}CC${eB} and ${bB}debug=1${eB} (compile + with -g instead of -O) are likely candidates. The output is written to + the terminal and captured in ${bB}\$INSTALLROOT/lib/package/gen/make.out${eB}:${bX} + bin/package make${eX}${eD} +${bT}(7)${bD}List make results and interesting errors:${bX} + bin/package results${eX} + Run the regression tests:${bX} + bin/package test${eX} + List test results and errors:${bX} + bin/package results test${eX}${eD} +${bT}(8)${bD}The generated binaries are position independent, i.e., they do not + contain hard-coded paths. However, commands with related files, like + ${Mfile} and ${Mnmake}, require the path of the bin directory to be + exported in ${bB}PATH${eb}.${eD} +${bT}(9)${bD}You can run the binaries directly from the package root, or you can + install them in a public root after you are satisfied with the make and + test actions (requires the ${bI}AT${Camp}T${eI} ${Mnmake} command):${bX} + bin/package flat install ${bI}DIRECTORY PACKAGE${eI}${eX} + This will install in ${bI}DIRECTORY${eI}${bB}/bin${eB} and ${bI}DIRECTORY${eI}${bB}/lib${eB}. If you want to + preserve the ${bB}arch/${eB}${bI}HOSTTYPE${eI} hierarchy under ${bI}DIRECTORY${eI} then omit the + ${bB}flat${eB} argument. If you don't have ${Mnmake} then the following will do a + flat install:${bX} + cd \$INSTALLROOT + cp -p -r bin lib include ${bI}DIRECTORY${eI}${eX}${eD} +${bT}(10)${bD}To summarize, after the first time the download, build, and test cycle + for the latest source release is:${bX} + bin/package setup source + bin/package make + bin/package test${eX}${eD}${eL} + +${bH}Source Package Installation Instructions -- Plan B${eH} +${bL} +${bT}(3)${bD}Create the subdirectory ${bB}lib/package/tgz${eB} and download all package archives + into that directory.${eD} +${bT}(4)${bD}If the ${bB}bin/package${eB} script does not exist then manually read the ${bB}INIT${eB} + source package:${bX} + gunzip < lib/package/tgz/INIT.${bI}YYYY-MM-DD${eI}.tgz | ${TAR} ${TARFLAGS}f -${eX} + Note that some browsers automatically unzip downloaded without warning. + If the gunzip fails try: + ${TAR} ${TARFLAGS}f -${eX} lib/package/tgz/INIT.${bI}YYYY-MM-DD${eI}.tgz + If your system does not have ${Mtar} or ${Mgunzip} then download the ${Mratz} + source package, compile it, and manually read the ${bB}INIT${eB} + source package:${bX} + mkdir bin + cp lib/package/tgz/ratz.${bI}YYYY-MM-DD${eI}.c lib/package/tgz/ratz.c + cc -o bin/ratz lib/package/tgz/ratz.c + bin/ratz -lm < lib/package/tgz/INIT.${bI}YYYY-MM-DD${eI}.tgz +${bT}(5)${bD}Read all unread package archive(s):${bX} + bin/package read${eX} + Both source and binary packages will be read by this step.${eD}${eL}${eO}" + ;; + *) echo "Usage: $command [ qualifier ... ] [ action ] [ arg ... ] [ n=v ... ] + + The $command command controls source and binary packages. It must be run + within the package root directory tree. See \"$command help intro\" for + details. In the following, PACKAGE names either a package or a component + within a package; if omitted, all packages are operated on. The default + action is \"host type\". + + qualifier: + authorize NAME Remote authorization name or license acceptance phrase. + debug|environment Show environment and actions; do not execute. + flat Collapse \$INSTALLROOT { bin fun include lib } onto \$PACKAGEROOT. + force Force the action to override saved state. + never Run make -N; otherwise show other actions. + only Only operate on the specified packages. + password PASSWORD Remote authorization or license acceptance password. + quiet Do not list captured make and test action output. + show Run make -n; otherwise show other actions. + DEBUG Trace the package script actions in detail for debugging. + action: + admin [ all ] [ db FILE ] [ on PATTERN ] [ action ... ] + Apply ACTION ... to the hosts listed in FILE. If FILE is + omitted then "admin.db" is assumed. The caller must have rcp(1) + and rsh(1) or scp(1) and ssh(1) access to the hosts. Output + for the action is saved per-host in ACTION.log/HOST. Logs + can be viewed by \"package admin [on HOST] results [ACTION]\". + By default only local PACKAGEROOT hosts are selected from FILE; + \"all\" selects all hosts. \"on PATTERN\" selects only + hosts matching the | separated PATTERN. FILE contains four + types of lines. Blank lines and lines beginning with # are + ignored. Lines starting with id=value are variable assignments. + Set admin_ping to local conventions if \"$admin_ping\" fails. + If a package list is not specified on the command line the + action applies to all packages; a variable assigment + package=list applies action to the packages in list for + subsequent hosts in FILE. The remaining line type is a host + description consisting of 6 tab separated fields. The first 3 + are mandatory; the remaining 3 are updated by the admin action: + hosttype + The host type as reported by package. + [user@]host + The host name and optionally user name for rcp(1) + and rsh(1) access. + [remote:[[master]:]]PACKAGEROOT + The absolute remote package root directory and + optionally the remote prorocol (rsh or ssh) if + the directory is on a different server than the + master package root directory. If + lib/package/admin/$admin_env exists under + this directory then it is sourced by sh(1) + before ACTION is done. If this field begins with - + then the host is ignored. If this field contains + : then ditto(1) is used to sync the remote src + directory hierarchy to the local one. If [master]: + is specified then the sync is deferred to the + master host. If master is omitted (two :) then + the sync is disabled. These directories must exist + on the remote side: lib/package, src/cmd, src/lib. + date YYMMDD of the last action. + date Elapsed wall time of the last action. + M T W The admin action make, test and write action error + counts. A non-numeric value in any of these fields + disables the corresponding action. + clean | clobber + Delete the arch/HOSTTYPE hierarchy; this deletes all generated + files and directories for HOSTTYPE. The heirarchy can be rebuilt + by package make.] + contents [ package ... ] + List description and components for PACKAGE on the standard + output. + copyright [ package ... ] + List the general copyright notice(s) for PACKAGE on the + standard output. Note that individual components in PACKAGE + may contain additional or replacement notices. + export [ VARIABLE ... ] + List NAME=VALUE for each VARIABLE, one per line. If the + \"only\" attribute is specified then only the variable + values are listed. If no variables are specified then + $env are assumed. + help [ ACTION ] + Display help text on the standard error [ standard output + for ACTION ]. + host [ canon cpu name rating type ... ] + List architecture/implementation dependent host information + on the standard output. type is listed if no attributes are + specified. Information is listed on a single line in attributes + order. The attributes are: + canon The next argument is a host type name to be + converted to package syntax. + cpu The number of cpus; 1 if the host is not a + multiprocessor. + name The host name. + rating The cpu rating in pseudo mips; the value is useful + useful only in comparisons with rating values of + other hosts. Other than a vax rating fixed at 1, + ratings can vary wildly but consistently from + vendor mips ratings. cc(1) may be required to + determine the rating. + type The host type, usually of the form + vendor.architecture, with an optional trailing + -version. The main theme is that type names within + a family of architectures are named in a similar, + predictable style. Os point release information is + avoided as much as possible, but vendor resistance + to release incompatibilities has for the most part + been futile. + html [ ACTION ] + Display html help text on the standard error [ standard output + for ACTION ]. + install [ ARCHITECTURE ... ] DIR [ PACKAGE ... ] + Copy the package binary hierarchy to DIR. If ARCHITECTURE is + omitted then all architectures are installed. If the \"flat\" + attribute is specified then exactly one ARCHITECTURE must be + specified; this architecture will be installed in DIR without + the \"arch/HOSTTYPE\" directory prefixes. Otherwise each + architecture will be installed in a separate \"arch/HOSTTYPE\" + subdirectory of DIR. The ARCHITECTURE - names the current + architecture. DIR must be an existing directory. If PACKAGE + is omitted then all binary packages are installed. This action + requires nmake. + license [ package ... ] + List the source license(s) for PACKAGE on the standard output. + Note that individual components in PACKAGE may contain + additional or replacement licenses. + list [ PACKAGE ... ] + List the name, version and prerequisites for PACKAGE on the + standard output. + make [ PACKAGE ] [ OPTION ... ] [ TARGET ... ] + Build and install. The default TARGET is install, which + makes and installs all packages. If the standard output + is a terminal then the output is also captured in + \$INSTALLROOT/lib/package/gen/make.out. The build is done + in the \$INSTALLROOT directory tree viewpathed on top of + the \$PACKAGEROOT directory tree. If \"flat\" is specified then + the \$INSTALLROOT { bin fun include lib } directories are + linked to the same directories in the package root. Only + one architecture may be flat. Leaf directory names matching + the |-separated shell pattern \$MAKESKIP are ignored. The + view action is done before making. OPTION operands are + passed to the underlying make command. + read [ package ... | archive ... ] + Read the named package archive(s). Must be run from the + package root directory. Archives are searched for in . + and lib/package/tgz. Each package is read only once. The + file lib/package/tgz/package[.type].tim tracks the read time. + See the write action for archive naming conventions. Text + file archive member are assumed to be ASCII or UTF-8 encoded. + regress diff(1) the current and previous package test results. + release [ [CC]YY-MM-DD [ [cc]yy-mm-dd ] ] [ package ] + Display recent changes since [CC]YY-MM-DD (up to [cc]yy-mm-dd), + where - means lowest (or highest.) If no dates are specified + then changes for the last 4 months are listed. PACKAGE may + be a package or component name. + remove PACKAGE + Remove files installed for PACKAGE. + results [ path ] [ old ] [ make | test ] + List results and interesting messages captured by the most + recent make (default), test or write action. old specifies the + previous results, if any (current and previous results are + retained.) $HOME/.pkgresults, if it exists, must contain an + egrep(1) expression of result lines to be ignored. failed lists + failures only and path lists the results file path only. + setup [ beta ] [ binary ] [ source ] [ ARCHITECTURE ... ] [ URL ] [ PACKAGE ... ] + The action initializes the current directory as a package root, + runs the update action to download new or out of date packages, + and runs the read action on those packages. If \"flat\" is + specified then the \$INSTALLROOT { bin fun include lib } + directories are linked to the same directories in the package + root. Only one architecture may be flat. See the update and + read actions for argument details. + test [ PACKAGE ] + Run the regression tests for PACKAGE. If the standard output + is a terminal then the output is also captured in + \$INSTALLROOT/lib/package/gen/test.out. In general a package + must be made before it can be tested. Components tested with + the \bregress\b(1) command require \bksh93\b. If only is + also specified then only the listed package components are + tested, otherwise the closure of the components is tested. + update [ beta ] [ binary ] [ source ] [ ARCHITECTURE ... ] [ URL ] [ PACKAGE ... ] + Download the latest release of the selected and required + packages from URL (e.g., + http://www.research.att.com/sw/download) into the directory + \$PACKAGEROOT/lib/package/tgz. beta acesses beta packages; + download these at your own risk. If ARCHITECTURE is omitted + then only architectures already present in the tgz directory + will be downloaded. If ARCHITECTURE is - then all posted + architectures will be downloaded. If URL matches *.url then + it is interpreted as a file containing shell variable + assignments for url, authorize and password. If URL is + omitted then the definitions for url, authorize and password + in \$PACKAGEROOT/lib/package/tgz/$default_url, if it exists, + are used. If \$PACKAGEROOT/lib/package/tgz/$default_url does + not exist then it is initialized with the current url, + authorize and password values and read permission for the + current user only. If PACKAGE is omitted then only + packages already present in the tgz directory will be + downloaded. If PACKAGE is - then all posted packages will be + downloaded. If source and binary are omitted then both source + and binary packages will be downloaded. If \bonly\b is + specified then only the named packages are updated; otherwise + the closure of required packages is updated. This action + requires wget(1), lynx(1), curl(1) or a shell that supports + io to /dev/tcp/HOST/PORT. + use [ uid | PACKAGE | . [ 32 | 64 ] | 32 | 64 | - ] [ COMMAND ... ] + Run COMMAND or an interactive shell if COMMAND is omitted, with + the environment initialized for using the package (can you say + shared library without cussing?) If uid or PACKAGE or . is + specified then it is used to determine a \$PACKAGEROOT, + possibly different from the current directory. For example, to + try out bozo's package: \"package use bozo\". In this case the + command may be run from any directory. If the file + \$INSTALLROOT/lib/package/profile is readable then it is + sourced to initialize the environment. 32 or 64 implies + \$PACKAGEROOT of . and specifies the target architecture word + size (which may be silently ignored.) + verify [ PACKAGE ] + Verify installed binary files against the checksum files in + \$INSTALLROOT/lib/package/gen/*.sum. The checksum files contain + mode, user and group information. If the checksum matches + for a given file then the mode, user and group are changed + as necessary to match the checksum entry. A warning is printed + on the standard error for each mismatch. Requires the ast + package cksum(1) command. + view + Initialize the architecture specific viewpath hierarchy. The + make action implicitly calls this action. If \"flat\" is specified + then the \$INSTALLROOT { bin fun include lib } directories are + linked to the same directories in the package root. Only one + architecture may be flat. + write [closure] [cyg|exp|lcl|pkg|rpm|tgz|tst] [base|delta] + [binary|runtime|source] PACKAGE + Write a package archive for PACKAGE. All work is done in the + \$PACKAGEROOT/lib/package directory. FORMAT-specific files + are placed in the FORMAT subdirectory. A PACKAGE[.TYPE].tim + file in this directory tracksthe write time and prevents a + package from being read in the same root it was written. If + more than one file is generated for a particular FORMAT then + those files are placed in the FORMAT/PACKAGE subdirectory. + File names in the FORMAT subdirectory will contain the package + name, a YYYY-MM-DD date, and for binary packages, HOSTTYPE. + If PACKAGE is omitted then an ordered list of previously + written packages is generated. If \"only\" is specified then + only the named packages will be written; otherwise + prerequisite packages are written first. Package components + must be listed in PACKAGE.pkg. FORMAT may be one of: + cyg generate a cygwin package + exp generate an exptools(1) maintainer source archive + and NPD file in the exp subdirectory, suitable for + expmake(1); support files are placed in the + exp/PACKAGE subdirectory + lcl generate a package archive or delta in the lcl + subdirectory, suitable for restoration into the + primary source tree (no source licence annotation) + pkg generate a pkgmk(1) package, suitable for pkgadd(1) + rpm generate an rpm(1) package + tgz generate a gzip(1) tar(1) package archive; this is + the default + tst generate tgz FORMAT package archive in the tst + subdirectory; version state files are not updated + The package type must be one of source, binary or runtime. + A source package contains the source needed to build the + corresponding binary package. A binary package includes the + libraries and headers needed for compiling and linking + against the public interfaces. A runtime package contains + the commands and required dynamic libraries. A package may + be either a base or delta. A base package contains a + complete copy of all components. A delta package contains + only changes from a previous base package. Delta recipients + must have the ast pax(1) command (in the ast-base package.) + If neither base nor delta is specified, then the current + base is overwritten if there are no deltas referring to the + current base. Only the tgz and lcl formats support delta. + If base is specified then a new base and two delta archives + are generated: one delta to generate the new base from the + old, and one delta to generate the old base from the new; + the old base is then removed. If delta is specified then a + new delta referring to the current base is written. + package.pkg may reference other packages. By default a + pointer to those packages is written. The recipient package + read will then check that all required packages have been + downloaded. If closure is specified then the components for + all package references are included in the generated + package. This may be useful for lcl and versioning. All + formats but lcl annotate each source file (not already + annotated) with a license comment as it is written to the + package archive using proto(1). + name=value: + variable definition: typically CC=cc or CCFLAGS=-g." + ;; + esac + exit $code + ;; + *=*) set DEFAULT host type "$@" + ;; + *) echo "Usage: $command [ options ] [ qualifier ... ] [ action ] [ arg ... ] [ n=v ... ]" >&2 + exit 2 + ;; + esac + global="$global $1" + shift +done + +# gather HOSTTYPE *,* options +# ,*cc*,-*,... set CC and CCFLAGS + +hostopts() +{ + _ifs_=$IFS + IFS=, + set '' $HOSTTYPE + IFS=$_ifs_ + shift + while : + do case $# in + 0|1) break ;; + esac + shift + case $1 in + *cc*) CC=$1 + while : + do case $# in + 0|1) break ;; + esac + case $2 in + -*) case $assign_CCFLAGS in + ?*) assign_CCFLAGS="$assign_CCFLAGS " ;; + esac + assign_CCFLAGS="$assign_CCFLAGS$2" + shift + ;; + *) break + ;; + esac + done + ;; + esac + done +} + +# collect command line targets and definitions + +case $_PACKAGE_HOSTTYPE_ in +?*) HOSTTYPE=$_PACKAGE_HOSTTYPE_ + KEEP_HOSTTYPE=1 + ;; +*) KEEP_HOSTTYPE=0 + ;; +esac +KEEP_PACKAGEROOT=0 +KEEP_SHELL=0 +USER_VPATH= +args= +assign= +assign_CCFLAGS= +for i +do case $i in + *:*=*) args="$args $i" + continue + ;; + *=*) eval `echo ' ' "$i" | sed 's,^[ ]*\([^=]*\)=\(.*\),n=\1 v='\''\2'\'','` + ;; + esac + case $i in + AR=*|LD=*|NM=*) + assign="$assign $n='$v'" + eval $n='$'v + ;; + CC=*) eval $n='$'v + ;; + CCFLAGS=*) + eval $n='$'v + assign_CCFLAGS="CCFLAGS=\"\$CCFLAGS\"" + ;; + HOSTTYPE=*) + eval $n='$'v + case $HOSTTYPE in + ?*) KEEP_HOSTTYPE=1 ;; + esac + ;; + HURL=*) eval $n='$'v + ;; + PACKAGEROOT=*) + eval $n='$'v + case $PACKAGEROOT in + ?*) KEEP_PACKAGEROOT=1 ;; + esac + ;; + SHELL=*)eval $n='$'v + case $SHELL in + ?*) KEEP_SHELL=1 ;; + esac + ;; + TAR=*) eval $n='$'v + ;; + TARFLAGS=*) + eval $n='$'v + ;; + VPATH=*)eval USER_$n='$'v + ;; + 'debug=1') + makeflags="$makeflags --debug-symbols" + ;; + 'strip=1') + makeflags="$makeflags --strip-symbols" + ;; + *=*) assign="$assign $n='$v'" + ;; + *) args="$args $i" + ;; + esac +done +case $HOSTTYPE in +*,*) hostopts $HOSTTYPE ;; +esac +case $assign_CCFLAGS in +?*) assign="$assign $assign_CCFLAGS" +esac +case $CC in +''|cc) ;; +*) export CC ;; +esac + +# grab action specific args + +case $action in +admin) while : + do case $# in + 0) set list + break + ;; + esac + case $1 in + all) admin_all=1 + ;; + db) case $# in + 1) echo $command: $action: $1: db file argument expected >&2 + exit 1 + ;; + esac + shift + admin_db=$1 + ;; + on) case $# in + 1) echo $command: $action: $1: host pattern argument expected >&2 + exit 1 + ;; + esac + shift + admin_on=$1 + ;; + *) break + ;; + esac + shift + done + admin_action=$1 + admin_args=$* + for i + do case $i in + debug|environment|force|never|only|quiet|show|DEBUG) + ;; + *) admin_action=$i + break + ;; + esac + done + ;; +setup) PACKAGEROOT=${PWD:-`pwd`} + export PACKAGEROOT + KEEP_PACKAGEROOT=1 + ;; +use) case $1 in + .|32|64)case $1 in + 32|64) bit=$1 ;; + esac + shift + + # HOSTTYPE specific setup + + case $HOSTTYPE in + win32.*)sys=uwin + wow=`uname -i` + case $bit in + 32) case $HOSTTYPE in + *-64) HOSTTYPE=${HOSTTYPE%-64} ;; + esac + case $wow in + */32) ;; + *) vpath / /$bit ;; + esac + ;; + 64) case $HOSTTYPE in + *-64) ;; + *) HOSTTYPE=$HOSTTYPE-64 ;; + esac + case $wow in + */32) echo $command: cannot build $bit-bit on $wow $sys >&2; exit 2 ;; + *) vpath / /$bit ;; + esac + ;; + esac + case $bit in + '') PS1="($sys) " ;; + *) PS1="($sys-$bit) " ;; + esac + + $exec umask 002 + $exec unset MAKESKIP + + $exec export P=$PWD + $exec export A=$P/arch/$HOSTTYPE + + $exec export CDPATH=:..:$A/src/cmd:$A/src/lib:$A/src/uwin:$P/lib/package + $exec export INSTALLROOT=$A + $exec export PACKAGEROOT=$P + $exec export PATH=$A/bin:$P/bin:$PATH + $exec export PS1="$PS1" + $exec export VPATH=$A:$P + $exec export nativepp=/usr/lib + + if test '' != "$INSTALLROOT" -a -d $INSTALLROOT/include/ast + then $exec export PACKAGE_ast=$INSTALLROOT + elif test -d ${PWD%/*}/ast/arch/$HOSTTYPE + then $exec export PACKAGE_ast=${PWD%/*}/ast/arch/$HOSTTYPE + fi + + # run the command + + case $# in + 0) case $show in + ':') $exec exec $SHELL ;; + esac + ;; + *) $exec exec $SHELL -c "$@" + ;; + esac + exit + ;; + esac + PACKAGEROOT=${PWD:-`pwd`} + $show export PACKAGEROOT + esac + ;; +esac + +# true if arg is a valid PACKAGEROOT + +packageroot() # dir +{ + test -d $1/lib/$command -o -x $1/bin/$command +} + +# true if arg is executable + +executable() # [!] command +{ + case $1 in + '!') test ! -x "$2" -a ! -x "$2.exe"; return ;; + *) test -x "$1" -o -x "$1.exe"; return ;; + esac +} + +# initialize SHELLMAGIC +# tangible proof of cygwin's disdain for unix (well, this and execrate) + +shellmagic() +{ + case $SHELLMAGIC in + '') ;; + -) if test -f /emx/bin/sh.exe + then SHELLMAGIC='#!/emx/bin/sh.exe'$nl + elif test -f /bin/env.exe + then SHELLMAGIC='#!/bin/env sh'$nl + else SHELLMAGIC= + fi + ;; + esac +} + +# true if arg is executable command on $PATH + +onpath() # command +{ + _onpath_b=$1 + case $_onpath_b in + /*) if executable $_onpath_b + then _onpath_=$_onpath_b + return 0 + fi + return 1 + ;; + esac + IFS=':' + set '' $PATH + IFS=$ifs + shift + for _onpath_d + do case $_onpath_d in + '') _onpath_d=. ;; + esac + if executable "$_onpath_d/$_onpath_b" + then _onpath_=$_onpath_d/$_onpath_b + return 0 + fi + done + return 1 +} + +# true if no nmake or nmake not from AT&T or nmake too old + +nonmake() # nmake +{ + _nonmake_version=`( $1 -n -f - 'print $(MAKEVERSION:@/.*AT&T.* //:/-//G:@/.* .*/19960101/)' . ) </dev/null 2>/dev/null || echo 19840919` + if test $_nonmake_version -lt 20001031 + then return 0 + fi + return 1 +} + +# determine local host attributes + +hostinfo() # attribute ... +{ + case $DEBUG in + 1) set -x ;; + esac + map= + something= + path=$PATH + for i in $ccs + do PATH=$PATH:$i + done + for i in $use + do for j in $org + do PATH=$PATH:$i/$j/bin + done + PATH=$PATH:$i/bin + done + # LD_LIBRARY_PATH may be out of sync with PATH here + case $SED in + '') SED=sed + $SED 1d < /dev/null > /dev/null 2>&1 || + for dir in /bin /usr/bin + do if test -x $dir/$SED + then SED=$dir/$SED + break + fi + done + TR=tr + $TR < /dev/null > /dev/null 2>&1 || + for dir in /bin /usr/bin + do if test -x $dir/$TR + then TR=$dir/$TR + break + fi + done + ;; + esac + case $PACKAGE_PATH in + ?*) for i in `echo $PACKAGE_PATH | $SED 's,:, ,g'` + do PATH=$PATH:$i/bin + done + ;; + esac + + # validate the args + + canon= + cc=$CC + for info + do case $canon in + -) canon=$info + ;; + *) case $info in + */*|*[cC][cC]) + cc=$info + ;; + canon) canon=- + something=1 + ;; + cpu|name|rating|type) + something=1 + ;; + *) echo "$command: $action: $info: unknown attribute" >&2 + exit 1 + ;; + esac + ;; + esac + done + case $canon in + -) echo "$command: $action: canon: host type name expected" >&2 + exit 1 + ;; + esac + case $something in + "") set "$@" type ;; + esac + case $DEBUG in + '') exec 9>&2 + exec 2>/dev/null + ;; + esac + + # compute the info + + _hostinfo_= + for info + do + case $info in + cpu) case $NPROC in + [123456789]*) + _hostinfo_="$_hostinfo_ $NPROC" + continue + ;; + esac + cpu=`grep -ic '^processor[ ][ ]*:[ ]*[0123456789]' /proc/cpuinfo` + case $cpu in + [123456789]*) + _hostinfo_="$_hostinfo_ $cpu" + continue + ;; + esac + cpu=1 + # exact match + set \ + hinv '^Processor [0123456789]' \ + psrinfo 'on-line' \ + 'cat /reg/LOCAL_MACHINE/Hardware/Description/System/CentralProcessor' '.' \ + 'cat /proc/registry/HKEY_LOCAL_MACHINE/Hardware/Description/System/CentralProcessor' '.' \ + + while : + do case $# in + 0) break ;; + esac + i=`$1 2>/dev/null | grep -c "$2"` + case $i in + [123456789]*) + cpu=$i + break + ;; + esac + shift;shift + done + case $cpu in + 0|1) set \ + /bin/mpstat + + while : + do case $# in + 0) break ;; + esac + if executable $1 + then case `$1 | grep -ic '^cpu '` in + 1) cpu=`$1 | grep -ic '^ *[0123456789][0123456789]* '` + break + ;; + esac + fi + shift + done + ;; + esac + case $cpu in + 0|1) # token match + set \ + /usr/kvm/mpstat 'cpu[0123456789]' \ + /usr/etc/cpustatus 'enable' \ + /usr/alliant/showsched 'CE' \ + 'ls /config/hw/system/cpu' 'cpu' \ + prtconf 'cpu-unit' \ + + while : + do case $# in + 0) break ;; + esac + i=`$1 2>/dev/null | $TR ' ' ' + +' | grep -c "^$2"` + case $i in + [123456789]*) + cpu=$i + break + ;; + esac + shift;shift + done + ;; + esac + case $cpu in + 0|1) # special match + set \ + \ + hinv \ + '/^[0123456789][0123456789]* .* Processors*$/' \ + '/[ ].*//' \ + \ + /usr/bin/hostinfo \ + '/^[0123456789][0123456789]* .* physically available\.*$/' \ + '/[ ].*//' \ + + while : + do case $# in + 0) break ;; + esac + i=`$1 2>/dev/null | $SED -e "${2}!d" -e "s${3}"` + case $i in + [123456789]*) + cpu=$i + break + ;; + esac + shift;shift;shift + done + ;; + esac + case $cpu in + 0|1) cpu=`( + cd ${TMPDIR:-/tmp} + tmp=hi$$ + trap 'rm -f $tmp.*' 0 1 2 + cat > $tmp.c <<! +#include <stdio.h> +#include <pthread.h> +int main() +{ + printf("%d\n", pthread_num_processors_np()); + return 0; +} +! + for o in -lpthread '' + do if $CC $o -O -o $tmp.exe $tmp.c $o >/dev/null 2>&1 || + gcc $o -O -o $tmp.exe $tmp.c $o >/dev/null 2>&1 + then ./$tmp.exe + break + fi + done + )` + case $cpu in + [0123456789]*) ;; + *) cpu=1 ;; + esac + ;; + esac + _hostinfo_="$_hostinfo_ $cpu" + ;; + name) _name_=`hostname || uname -n || cat /etc/whoami || echo local` + _hostinfo_="$_hostinfo_ $_name_" + ;; + rating) for rating in `grep -i ^bogomips /proc/cpuinfo 2>/dev/null | $SED -e 's,.*:[ ]*,,' -e 's,\(...*\)\..*,\1,' -e 's,\(\..\).*,\1,'` + do case $rating in + [0123456789]*) break ;; + esac + done + case $rating in + [0123456789]*) ;; + *) cd ${TMPDIR:-/tmp} + tmp=hi$$ + trap 'rm -f $tmp.*' 0 1 2 + cat > $tmp.c <<! +#include <stdio.h> +#include <sys/types.h> +#if TD || TZ +#include <sys/time.h> +#else +extern time_t time(); +#endif +int main() +{ + register unsigned long i; + register unsigned long j; + register unsigned long k; + unsigned long l; + unsigned long m; + unsigned long t; + int x; +#if TD || TZ + struct timeval b; + struct timeval e; +#if TZ + struct timezone z; +#endif +#endif + l = 500; + m = 890; + x = 0; + for (;;) + { +#if TD || TZ +#if TZ + gettimeofday(&b, &z); +#else + gettimeofday(&b); +#endif +#else + t = (unsigned long)time((time_t*)0); +#endif + k = 0; + for (i = 0; i < l; i++) + for (j = 0; j < 50000; j++) + k += j; +#if TD || TZ +#if TZ + gettimeofday(&e, &z); +#else + gettimeofday(&e); +#endif + t = (e.tv_sec - b.tv_sec) * 1000 + (e.tv_usec - b.tv_usec) / 1000; + if (!x++ && t < 1000) + { + t = 10000 / t; + l = (l * t) / 10; + continue; + } +#else + t = ((unsigned long)time((time_t*)0) - t) * 1000; + if (!x++ && t < 20000) + { + t = 200000l / t; + l = (l * t) / 10; + continue; + } +#endif +#if PR + printf("[ k=%lu l=%lu m=%lu t=%lu ] ", k, l, m, t); +#endif + if (t == 0) + t = 1; + break; + } + printf("%lu\n", ((l * m) / 10) / t); + return k == 0; +} +! + rating= + for o in -DTZ -DTD '' + do if $CC $o -O -o $tmp.exe $tmp.c >/dev/null 2>&1 || + gcc $o -O -o $tmp.exe $tmp.c >/dev/null 2>&1 + then rating=`./$tmp.exe` + break + fi + done + case $rating in + [0123456789]*) ;; + *) rating=1 ;; + esac + ;; + esac + _hostinfo_="$_hostinfo_ $rating" + ;; + type|canon) + case $CROSS:$canon in + 0:) case $cc in + cc) case $KEEP_HOSTTYPE:$HOSTTYPE in + 0:?*) if test -d ${PACKAGEROOT:-.}/arch/$HOSTTYPE + then KEEP_HOSTTYPE=1 + fi + ;; + esac + ;; + esac + case $KEEP_HOSTTYPE in + 1) _hostinfo_="$_hostinfo_ $HOSTTYPE" + continue + ;; + esac + ;; + esac + case $cc in + /*) a=`$cc -dumpmachine $CCFLAGS 2>/dev/null` + case $a in + '') case $CCFLAGS in + ?*) a=`$cc -dumpmachine 2>/dev/null` ;; + esac + ;; + esac + case $a in + ''|*' '*|*/*:*) + ;; + *.*-*) _hostinfo_="$_hostinfo_ $a" + continue + ;; + *-*-*) case $canon in + '') canon=$a ;; + esac + ;; + *) _hostinfo_="$_hostinfo_ $a" + continue + ;; + esac + ;; + esac + IFS=: + set /$IFS$PATH + IFS=$ifs + shift + f=../lib/hostinfo/typemap + for i + do case $i in + "") i=. ;; + esac + case $canon in + '') case $cc in + /*|cc) ;; + *) if executable $i/$cc + then a=`$i/$cc -dumpmachine $CCFLAGS 2>/dev/null` + case $a in + '') case $CCFLAGS in + ?*) a=`$cc -dumpmachine 2>/dev/null` ;; + esac + ;; + esac + case $a in + ''|*' '*|*/*:*) + ;; + *-*) canon=$a + ;; + *) _hostinfo_="$_hostinfo_ $a" + continue 2 + ;; + esac + fi + ;; + esac + ;; + esac + if test -f "$i/$f" + then map="`grep -v '^#' $i/$f` $map" + fi + done + + # inconsistent -dumpmachine filtered here + + case -${canon}- in + --|*-powerpc-*) + h=`hostname || uname -n || cat /etc/whoami` + case $h in + '') h=local ;; + esac + a=`arch || uname -m || att uname -m || uname -s || att uname -s` + case $a in + *[\ \ ]*) a=`echo $a | $SED "s/[ ]/-/g"` ;; + esac + case $a in + '') a=unknown ;; + esac + m=`mach || machine || uname -p || att uname -p` + case $m in + *[\ \ ]*) m=`echo $m | $SED "s/[ ]/-/g"` ;; + esac + case $m in + '') m=unknown ;; + esac + x=`uname -a || att uname -a` + case $x in + '') x="unknown $host unknown unknown unknown unknown unknown" ;; + esac + set "" $h $a $m $x + expected=$1 host=$2 arch=$3 mach=$4 os=$5 sys=$6 rel=$7 ver=$8 + ;; + *) case $canon in + *-*) IFS=- + set "" $canon + shift + IFS=$ifs + case $# in + 2) host= mach= arch=$1 os=$2 sys= rel= ;; + *) host= mach=$2 arch=$1 os=$3 sys= rel= ;; + esac + case $os in + [abcdefghijklmnopqrstuvwxyz]*[0123456789]) + eval `echo $os | $SED -e 's/^\([^0123456789.]*\)\.*\(.*\)/os=\1 rel=\2/'` + ;; + esac + ;; + *) arch=$canon mach= os= sys= rel= + ;; + esac + ;; + esac + type=unknown + case $host in + *.*) host=`echo $host | $SED -e 's/\..*//'` ;; + esac + case $mach in + unknown) + mach= + ;; + [Rr][0123][0123456789][0123456789][0123456789]) + mach=mips1 + ;; + [Rr][4][0123456789][0123456789][0123456789]) + mach=mips2 + ;; + [Rr][56789][0123456789][0123456789][0123456789]|[Rr][123456789][0123456789][0123456789][0123456789][0123456789]) + mach=mips4 + ;; + pc) arch=i386 + mach= + ;; + [Pp][Oo][Ww][Ee][Rr][Pp][Cc]) + arch=ppc + mach= + ;; + *) case $arch in + 34[0123456789][0123456789]) + os=ncr + arch=i386 + ;; + esac + ;; + esac + case $canon in + '') set \ + \ + /NextDeveloper -d next - \ + /config/hw/system/cpu -d tandem mach \ + + while : + do case $# in + 0) break ;; + esac + if test $2 $1 + then os=$3 + case $4 in + arch) mach=$arch ;; + mach) arch=$mach ;; + esac + break + fi + shift;shift;shift;shift + done + ;; + esac + case $os in + AIX*|aix*) + type=ibm.risc + ;; + HP-UX) case $arch in + 9000/[78]*) + type=hp.pa + ;; + */*) type=hp.`echo $arch | $SED 's,/,_,g'` + ;; + *) type=hp.$arch + ;; + esac + ;; + [Ii][Rr][Ii][Xx]*) + set xx `hinv | $SED -e '/^CPU:/!d' -e 's/CPU:[ ]*\([^ ]*\)[ ]*\([^ ]*\).*/\1 \2/' -e q | $TR ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` + shift + type=$1 + n= + case $2 in + r[0123][0123456789][0123456789][0123456789]) + n=1 + ;; + r[4][0123][0123456789][0123456789]) + n=2 + ;; + r[4][456789][0123456789][0123456789]|r[5][0123456789][0123456789][0123456789]) + n=3 + ;; + r[6789][0123456789][0123456789][0123456789]|r[123456789][0123456789][0123456789][0123456789][0123456789]) + n=4 + ;; + esac + case $rel in + [01234].*|5.[012]|5.[012].*) + case $n in + 1) ;; + *) n=2 ;; + esac + ;; + 5.*) case $n in + 2) n=3 ;; + esac + ;; + esac + if executable $cc + then a=$cc + else IFS=: + set /$IFS$PATH + IFS=$ifs + shift + for i + do a=$i/$cc + if executable $a + then break + fi + done + fi + split=' +' + a=`strings $a < /dev/null | $SED -e 's/[^abcdefghijklmnopqrstuvwxyz0123456789]/ /g' -e 's/[ ][ ]*/\'"$split"'/g' | $SED -e "/^${type}[0123456789]$/!d" -e "s/^${type}//" -e q` + case $a in + [0123456789]) n=$a ;; + esac + case $n in + 4) a=`$cc -${type}3 2>&1` + case $a in + *unknown*|*install*|*conflict*) + ;; + *) n=3 + ;; + esac + ;; + esac + a=`$cc -show F0oB@r.c 2>&1` + case $n:$a in + [!2]:*mips2*) n=2 ;; + [!23]:*mips3*) n=3 ;; + [!234]:*mips4*) n=4 ;; + esac + case $n:$a in + [!2]:*[Oo]32*) abi=-o32 ;; + [!3]:*[Nn]32*) abi=-n32 ;; + esac + mach=${type}$n + type=sgi.$mach + ;; + OSx*|SMP*|pyramid) + type=pyr + ;; + OS/390) type=mvs.390 + ;; + [Ss][Cc][Oo]*) + type=sco + ;; + [Ss]ol*) + v=`echo $rel | $SED -e 's/^[25]\.//' -e 's/\.[^.]*$//'` + case $v in + [6789]|[1-9][0-9]) + ;; + *) v= + ;; + esac + case $arch in + '') case $mach in + '') arch=sun4 ;; + *) arch=$mach ;; + esac + ;; + esac + case $arch in + sparc) arch=sun4 ;; + esac + type=sol$v.$arch + ;; + [Ss]un*)type=`echo $arch | $SED -e 's/\(sun.\).*/\1/'` + case $type in + sparc) type=sun4 ;; + esac + case $rel in + [01234]*) + ;; + '') case $os in + *[Oo][Ss]) + ;; + *) type=sol.$type + ;; + esac + ;; + *) case $type in + '') case $mach in + sparc*) type=sun4 ;; + *) type=$mach ;; + esac + ;; + esac + v=`echo $rel | $SED -e 's/^[25]\.//' -e 's/\.[^.]*$//'` + case $v in + [6789]|[1-9][0-9]) + ;; + *) v= + ;; + esac + type=sol$v.$type + ;; + esac + case $type in + sun*|*.*) + ;; + *) type=sun.$type + ;; + esac + ;; + [Uu][Nn][Ii][Xx]_[Ss][Vv]) + type=unixware + ;; + UTS*|uts*) + if test -x /bin/u370 -o -x /bin/u390 + then type=uts.390 + else case $arch in + '') arch=$mach ;; + esac + type=uts.$arch + fi + ;; + $host) type=$arch + case $type in + *.*|*[0123456789]*86|*68*) + ;; + *) case $mach in + *[0123456789]*86|*68*|mips) + type=$type.$mach + ;; + esac + ;; + esac + ;; + unknown) + case $arch in + ?*) case $arch in + sun*) mach= ;; + esac + type=$arch + case $mach in + ?*) type=$type.$mach ;; + esac + ;; + esac + ;; + *) case $ver in + FTX*|ftx*) + case $mach in + *[0123456789][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]*) + mach=`echo $mach | $SED -e 's/[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]*$//'` + ;; + esac + type=stratus.$mach + ;; + *) case $arch in + [Oo][Ss][-/.]2) + type=os2 + arch=$rel + ;; + *) type=`echo $os | $SED -e 's/[0123456789].*//' -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789.].*//'` + ;; + esac + case $type in + [Cc][Yy][Gg][Ww][Ii][Nn]_*) + type=cygwin + ;; + [Uu][Ww][Ii][Nn]*|[Ww]indows_[0123456789][0123456789]|[Ww]indows_[Nn][Tt]) + type=win32 + arch=`echo $arch | $SED -e 's/_[^_]*$//'` + ;; + esac + case $arch in + '') case $mach in + ?*) type=$type.$mach ;; + esac + ;; + *) type=$type.$arch ;; + esac + ;; + esac + esac + case $type in + [0123456789]*) + case $mach in + ?*) type=$mach ;; + esac + case $type in + */MC) type=ncr.$type ;; + esac + ;; + *.*) ;; + *[0123456789]*86|*68*) + case $rel in + [34].[0123456789]*) + type=att.$type + ;; + esac + ;; + [abcdefghijklmnopqrstuvwxyz]*[0123456789]) + ;; + [abcdefghijklmnopqrstuvwxyz]*) case $mach in + $type) case $ver in + Fault*|fault*|FAULT*) + type=ft.$type + ;; + esac + ;; + ?*) case $arch in + '') type=$type.$mach ;; + *) type=$type.$arch ;; + esac + ;; + esac + ;; + esac + case $type in + *[-_]32|*[-_]64|*[-_]128) + bits=`echo $type | $SED 's,.*[-_],,'` + type=`echo $type | $SED 's,[-_][0-9]*$,,'` + ;; + *) bits= + ;; + esac + type=`echo $type | $SED -e 's%[-+/].*%%' | $TR ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` + case $type in + *.*) lhs=`echo $type | $SED -e 's/\..*//'` + rhs=`echo $type | $SED -e 's/.*\.//'` + case $rhs in + [x0123456789]*86) rhs=i$rhs ;; + 68*) rhs=m$rhs ;; + esac + case $rhs in + i[x23456789]86|i?[x23456789]86|*86pc) + rhs=i386 ;; + powerpc) rhs=ppc ;; + s[0123456789]*[0123456789]x) + rhs=`echo $rhs | $SED -e 's/x$/-64/'` ;; + esac + case $rhs in + arm[abcdefghijklmnopqrstuvwxyz_][0123456789]*) + rhs=arm ;; + hppa) rhs=pa ;; + esac + case $lhs in + ?*coff|?*dwarf|?*elf) + case $lhs in + ?*coff) x=coff ;; + ?*dwarf)x=coff ;; + ?*elf) x=elf ;; + esac + lhs=`echo ${lhs}XXX | $SED -e "s/${x}XXX//"` + ;; + esac + case $lhs in + bsdi) lhs=bsd ;; + darwin) case $rel in + [01234567].*) lhs=${lhs}7 ;; + esac + ;; + freebsd) case $rel in + [01234].*) lhs=${lhs}4 ;; + [123456789]*.*) lhs=${lhs}`echo $rel | $SED -e 's/\..*//'` ;; + esac + ;; + hpux) lhs=hp ;; + mvs) rhs=390 ;; + esac + case $lhs in + '') type=$rhs ;; + $rhs) type=$lhs ;; + *) type=$lhs.$rhs ;; + esac + ;; + esac + case $type in + sgi.mips*) + case $mach in + mips2) type=sgi.$mach + abi=-o32 + ;; + mips3) type=sgi.$mach + abi=-n32 + ;; + mips[456789]) + type=sgi.$mach + case $abi in + *-n32) ;; + *) abi=-64 ;; + esac + ;; + *) pwd=`pwd` + cd ${TMPDIR:-/tmp} + tmp=hi$$ + trap 'rm -f $tmp.*' 0 1 2 + cat > $tmp.a.c <<! +extern int b(); +int main() { return b(); } +! + cat > $tmp.b.c <<! +int b() { return 0; } +! + abi= + if $cc -c $tmp.a.c + then for i in -n32 -o32 -64 + do if $cc $i -c $tmp.b.c && + $cc -o $tmp.exe $tmp.a.o $tmp.b.o + then abi=$i + for i in 2 3 4 5 6 7 8 9 + do case $i:$abi in + 2:-n32|2:-64|3:-64) + continue + ;; + esac + if $cc $abi -mips$i -c $tmp.b.c && + $cc -o $tmp.exe $tmp.a.o $tmp.b.o + then type=`echo $type | $SED -e 's/.$//'`$i + break + fi + done + break + fi + done + fi </dev/null >/dev/null 2>&1 + rm -f $tmp.* + trap - 0 1 2 + cd $pwd + ;; + esac + case $type$abi in + sgi.mips2-o32) + ;; + sgi.mips3) + type=$type-o32 + ;; + sgi.mips3-n32) + ;; + sgi.mips4) + type=$type-o32 + ;; + sgi.mips[456789]-64) + ;; + *) type=$type$abi + ;; + esac + ;; + *) case $bits in + '') case `file /bin/sh 2>/dev/null` in + *universal*64*) + pwd=`pwd` + cd ${TMPDIR:-/tmp} + tmp=hi$$ + trap 'rm -f $tmp.*' 0 1 2 + cat > $tmp.a.c <<! +int main() { return 0; } +! + if $cc -o $tmp.a.exe $tmp.a.c + then case `file $tmp.a.exe` in + *64*) bits=64 ;; + esac + fi </dev/null >/dev/null 2>&1 + rm -f $tmp.* + trap - 0 1 2 + cd $pwd + ;; + esac + ;; + esac + ;; + esac + case $bits in + 32) case $type in + *.i386) bits= ;; + esac + ;; + esac + case $bits in + ?*) type=$type-$bits ;; + esac + + # last chance mapping + + set "" "" $map + while : + do case $# in + [012]) break ;; + esac + shift;shift + eval " case \$type in + $1) type=\$2; break ;; + esac" + done + _hostinfo_="$_hostinfo_ $type" + ;; + esac + done + set '' $_hostinfo_ + shift + _hostinfo_=$* + + # restore the global state + + PATH=$path + case $DEBUG in + '') exec 2>&9 + exec 9>&- + ;; + esac +} + +# info message + +note() # message ... +{ + echo $command: "$@" >&2 +} + +# cc checks +# +# CC: compiler base name name +# cc: full path, empty if not found + +checkcc() +{ + cc= + if onpath $CC + then cc=$_onpath_ + else case $CC in + cc) if onpath gcc + then CC=gcc + cc=$_onpath_ + fi + ;; + esac + fi + case $cc in + '') case $action in + make|test) note "$CC: not found"; exit 1 ;; + *) note "warning: $CC: not found" ;; + esac + ;; + esac +} + +# some actions have their own PACKAGEROOT or kick out early + +case $action in +host) eval u=$package_use + case $u in + $PACKAGE_USE) + ;; + *) if onpath $0 + then case $_onpath_ in + */arch/$HOSTTYPE/bin/package) + KEEP_HOSTTYPE=1 + ;; + *) KEEP_HOSTTYPE=0 + ;; + esac + else KEEP_HOSTTYPE=0 + fi + ;; + esac + hostinfo $args + echo $_hostinfo_ + exit 0 + ;; +export|setup|use) + x= + ;; +*) x= + eval u=$package_use + case $u in + $PACKAGE_USE) + case :$PATH: in + *:$INSTALLROOT/bin:*) + case $LIBPATH: in + $INSTALLROOT/bin:$INSTALLROOT/lib:*) + case $SHLIB_PATH: in + $INSTALLROOT/lib:*) + x=1 + ;; + esac + ;; + esac + ;; + esac + ;; + esac + ;; +esac +run=- +case $x in +1) : accept the current package use environment + + OK=ok + KSH=$EXECROOT/bin/ksh + MAKE=nmake + NMAKE=$EXECROOT/bin/$MAKE + SUM=$EXECROOT/bin/sum + TEE=$EXECROOT/bin/tee + INITROOT=$PACKAGEROOT/src/cmd/INIT + checkcc + ;; +*) hosttype= + case $KEEP_PACKAGEROOT in + 0) case $action in + use) PACKAGEROOT= + case $show in + echo) exec=echo make=echo show=echo ;; + esac + set '' $args + shift + case $# in + 0) ;; + *) case $1 in + -|.) ;; + /*) PACKAGEROOT=$1 + ;; + *) i=`echo ~$1` + if packageroot $i + then PACKAGEROOT=$i + else for i in `echo $HOME | sed -e 's,/[^/]*$,,'` $usr $use + do if packageroot $i/$1 + then PACKAGEROOT=$i/$1 + break + fi + done + case $PACKAGEROOT in + '') hosttype=$1 ;; + esac + fi + ;; + esac + shift + ;; + esac + run="$@" + ;; + esac + case $PACKAGEROOT in + '') PACKAGEROOT=${PWD:-`pwd`} ;; + esac + + # . must be within the PACKAGEROOT tree + + i=X$PACKAGEROOT + IFS=/ + set $i + IFS=$ifs + while : + do i=$1 + shift + case $i in + X) break ;; + esac + done + case $PACKAGEROOT in + //*) d=/ ;; + *) d= ;; + esac + case $1 in + home) k=1 ;; + *) k=0 ;; + esac + for i + do case $i in + '') continue ;; + esac + d=$d/$i + case $k in + 2) k=1 + ;; + 1) k=0 + ;; + 0) case $i in + arch) k=2 + ;; + *) if packageroot $d + then PACKAGEROOT=$d + fi + ;; + esac + ;; + esac + done + ;; + esac + INITROOT=$PACKAGEROOT/src/cmd/INIT + $show PACKAGEROOT=$PACKAGEROOT + $show export PACKAGEROOT + export PACKAGEROOT + + # initialize the architecture environment + + case $KEEP_HOSTTYPE in + 0) hostinfo type + HOSTTYPE=$_hostinfo_ + ;; + 1) _PACKAGE_HOSTTYPE_=$HOSTTYPE + export _PACKAGE_HOSTTYPE_ + ;; + esac + $show HOSTTYPE=$HOSTTYPE + $show export HOSTTYPE + export HOSTTYPE + INSTALLROOT=$PACKAGEROOT/arch/$HOSTTYPE + case $action in + admin|install|make|read|remove|test|verify|view|write) + ;; + *) if test ! -d $INSTALLROOT + then INSTALLROOT=$PACKAGEROOT + fi + ;; + esac + $show INSTALLROOT=$INSTALLROOT + $show export INSTALLROOT + export INSTALLROOT + + # HOSTTYPE specific package profile + + if test -r $INSTALLROOT/lib/package/profile + then . $INSTALLROOT/lib/package/profile + fi + + # check the basic package hierarchy + + case $action in + export|use) + packageroot $PACKAGEROOT || { + echo "$command: $PACKAGEROOT: invalid package root directory" >&2 + exit 1 + } + case $KEEP_HOSTTYPE:$hosttype in + 0:?*) if test -d ${PACKAGEROOT:-.}/arch/$hosttype + then KEEP_HOSTTYPE=1 + HOSTTYPE=$hosttype + else echo "$command: $hosttype: package root not found" >&2 + exit 1 + fi + ;; + esac + ;; + *) packageroot $PACKAGEROOT || { + case $KEEP_PACKAGEROOT in + 1) ;; + *) echo "$command: $PACKAGEROOT: must be in the package root directory tree" >&2 + exit 1 + ;; + esac + } + + case $action in + admin) ;; + *) for i in arch arch/$HOSTTYPE + do test -d $PACKAGEROOT/$i || $exec mkdir $PACKAGEROOT/$i || exit + done + for i in lib + do test -d $INSTALLROOT/$i || $exec mkdir $INSTALLROOT/$i || exit + done + ;; + esac + + # no $INITROOT means INIT already installed elsewhere + + if test -d $INITROOT + then + # update the basic package commands + + for i in execrate ignore mamprobe silent + do test -h $PACKAGEROOT/bin/$i 2>/dev/null || + case `ls -t $INITROOT/$i.sh $PACKAGEROOT/bin/$i 2>/dev/null` in + "$INITROOT/$i.sh"*) + note update $PACKAGEROOT/bin/$i + shellmagic + case $SHELLMAGIC in + '') $exec cp $INITROOT/$i.sh $PACKAGEROOT/bin/$i || exit + ;; + *) case $exec in + '') { + echo "$SHELLMAGIC" + cat $INITROOT/$i.sh + } > $PACKAGEROOT/bin/$i || exit + ;; + *) echo "{ +echo \"$SHELLMAGIC\" +cat $INITROOT/$i.sh +} > $PACKAGEROOT/bin/$i" + ;; + esac + ;; + esac + $exec chmod +x $PACKAGEROOT/bin/$i || exit + ;; + esac + done + fi + ;; + esac + path=$PATH + PATH=$INSTALLROOT/bin:$PACKAGEROOT/bin:$PATH + checkcc + PATH=$path + case $cc in + ?*) if test -f $INITROOT/hello.c + then + # check if $CC (full path $cc) is a cross compiler + + ( + cd /tmp || exit 3 + cp $INITROOT/hello.c pkg$$.c || exit 3 + $cc -o pkg$$.exe pkg$$.c > pkg$$.e 2>&1 || { + if $cc -Dnew=old -o pkg$$.exe pkg$$.c > /dev/null 2>&1 + then echo "$command: ${warn}$CC: must be a C compiler (not C++)" >&2 + else cat pkg$$.e + echo "$command: ${warn}$CC: failed to compile and link $INITROOT/hello.c -- is it a C compiler?" >&2 + fi + exit 2 + } + if ./pkg$$.exe >/dev/null 2>&1 + then code=0 + else code=1 + fi + rm -f pkg$$.* + exit $code + ) + code=$? + case $code in + 1) CROSS=1 ;; + esac + fi + ;; + esac + EXECTYPE=$HOSTTYPE + EXECROOT=$INSTALLROOT + case $CROSS in + 0) # dll hackery -- why is this so complicated? + + abi= + case $HOSTTYPE in + sgi.mips[0123456789]*) + x=rld + if executable /lib32/$x || executable /lib64/$x + then case $INSTALLROOT in + */sgi.mips[0123456789]*) + u=`echo $INSTALLROOT | sed -e 's,-[^-/]*$,,' -e 's,.$,,'` + ;; + *) u= + ;; + esac + for a in "n=2 v= l=" "n=3 v=N32 l=lib32" "n=4-n32 v=N32 l=lib32" "n=4 v=64 l=lib64" + do eval $a + case $v in + N32) case $n:$HOSTTYPE in + *-n32:*-n32) ;; + *-n32:*) continue ;; + *:*-n32) continue ;; + esac + ;; + esac + case $l in + ?*) if executable ! /$l/$x + then continue + fi + ;; + esac + case $u in + '') case $HOSTTYPE in + sgi.mips$n|sgi.mips$n-*) + abi="$abi 'd=$INSTALLROOT v=$v'" + ;; + *) continue + ;; + esac + ;; + *) if test -d $u$n + then abi="$abi 'd=$u$n v=$v'" + fi + ;; + esac + done + fi + ;; + esac + case $abi in + '') abi="'d=$INSTALLROOT v='" ;; + esac + p=0 + eval " + for a in $abi + do eval \$a + eval \" + case \\\$LD_LIBRARY\${v}_PATH: in + \\\$d/lib:*) + ;; + *) x=\\\$LD_LIBRARY\${v}_PATH + case \\\$x in + ''|:*) ;; + *) x=:\\\$x ;; + esac + LD_LIBRARY\${v}_PATH=\$d/lib\\\$x + export LD_LIBRARY\${v}_PATH + p=1 + ;; + esac + \" + done + " + case $LD_LIBRARY_PATH in + '') ;; + *) for d in $lib + do case $HOSTTYPE in + *64) if test -d ${d}64 + then d=${d}64 + fi + ;; + esac + case :$LD_LIBRARY_PATH: in + *:$d:*) ;; + *) if test -d $d + then LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$d + p=1 + fi + ;; + esac + done + ;; + esac + case $p in + 1) $show LD_LIBRARY_PATH=$LD_LIBRARY_PATH + $show export LD_LIBRARY_PATH + export LD_LIBRARY_PATH + ;; + esac + case $LIBPATH: in + $INSTALLROOT/bin:$INSTALLROOT/lib:*) + ;; + *) case $LIBPATH in + '') LIBPATH=/usr/lib:/lib ;; + esac + LIBPATH=$INSTALLROOT/bin:$INSTALLROOT/lib:$LIBPATH + $show LIBPATH=$LIBPATH + $show export LIBPATH + export LIBPATH + ;; + esac + case $SHLIB_PATH: in + $INSTALLROOT/lib:*) + ;; + *) SHLIB_PATH=$INSTALLROOT/lib${SHLIB_PATH:+:$SHLIB_PATH} + $show SHLIB_PATH=$SHLIB_PATH + $show export SHLIB_PATH + export SHLIB_PATH + ;; + esac + case $DYLD_LIBRARY_PATH: in + $INSTALLROOT/lib:*) + ;; + *) DYLD_LIBRARY_PATH=$INSTALLROOT/lib${DYLD_LIBRARY_PATH:+:$DYLD_LIBRARY_PATH} + $show DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH + $show export DYLD_LIBRARY_PATH + export DYLD_LIBRARY_PATH + ;; + esac + case $_RLD_ROOT in + $INSTALLROOT/arch*) ;; + ':') _RLD_ROOT=$INSTALLROOT/arch:/ ;; + /|*:/) _RLD_ROOT=$INSTALLROOT/arch:$_RLD_ROOT ;; + *) _RLD_ROOT=$INSTALLROOT/arch:$_RLD_ROOT:/ ;; + esac + $show _RLD_ROOT=$_RLD_ROOT + $show export _RLD_ROOT + export _RLD_ROOT + + # now set up PATH + # + # NOTE: PACKAGEROOT==INSTALLROOT is possible for binary installations + + case $PATH: in + $PACKAGEROOT/bin:*) + ;; + *) PATH=$PACKAGEROOT/bin:$PATH + ;; + esac + case $PATH: in + $INSTALLROOT/bin:*) + ;; + *) PATH=$INSTALLROOT/bin:$PATH + ;; + esac + $show PATH=$PATH + $show export PATH + export PATH + ;; + *) for i in package proto nmake + do if onpath $i + then EXECROOT=`echo $_onpath_ | sed -e 's,//*[^/]*//*[^/]*$,,'` + EXECTYPE=`echo $EXECROOT | sed -e 's,.*/,,'` + break + fi + done + case $HOSTTYPE in + $EXECTYPE) + OCC=$CC + CC=cc + hostinfo type + EXECTYPE=$_hostinfo_ + case $HOSTTYPE in + $EXECTYPE) + echo "$command: $CC: seems to be a cross-compiler" >&2 + echo "$command: set HOSTTYPE to something other than the native $EXECTYPE" >&2 + exit 1 + ;; + esac + ;; + esac + $show EXECTYPE=$EXECTYPE + $show export EXECTYPE + export EXECTYPE + ;; + esac + $show EXECROOT=$EXECROOT + $show export EXECROOT + export EXECROOT + + # use these if possible + + OK=ok + KSH=$EXECROOT/bin/ksh + MAKE=nmake + NMAKE=$EXECROOT/bin/$MAKE + SUM=$EXECROOT/bin/sum + TEE=$EXECROOT/bin/tee + + # grab a decent default shell + + case $KEEP_SHELL in + 0) executable "$SHELL" || SHELL= + case $SHELL in + ?*) checksh $SHELL || SHELL= ;; + esac + case $SHELL in + ''|/bin/*|/usr/bin/*) + case $SHELL in + '') SHELL=/bin/sh ;; + esac + for i in ksh sh bash + do if onpath $i && checksh $_onpath_ + then SHELL=$_onpath_ + break + fi + done + ;; + */*ksh) if executable $KSH + then SHELL=$KSH + fi + ;; + esac + ;; + esac + + # $SHELL must be /bin/sh compatible + + case $SHELL in + /bin/sh);; + '') SHELL=/bin/sh + ;; + *) $SHELL -c 'trap "exit 0" 0; exit 1' 2>/dev/null + case $? in + 1) SHELL=/bin/sh + ;; + *) # catch (our own) pipe/socket configuration mismatches + $SHELL -c "date | $SHELL -c 'read x'" + case $? in + 0) ;; + *) SHELL=/bin/sh ;; + esac + ;; + esac + ;; + esac + export SHELL + $show SHELL=$SHELL + $show export SHELL + COSHELL=$SHELL + export COSHELL + $show COSHELL=$COSHELL + $show export COSHELL + + # tame the environment + + case $action in + use) ;; + *) ENV= + ERROR_OPTIONS= + export ENV ERROR_OPTIONS + ;; + esac + + # finalize the views + + case $USER_VPATH in + '') case $VPATH in + ?*) IFS=':' + set '' $VPATH + shift + IFS=$ifs + USER_VPATH= + for i + do case $i in + */arch/$HOSTTYPE) ;; + */arch/*/*) ;; + */arch/*) continue ;; + esac + if packageroot $i + then case $USER_VPATH in + '') USER_VPATH=$i ;; + ?*) USER_VPATH=$USER_VPATH:$i ;; + esac + fi + done + esac + ;; + esac + case $USER_VPATH in + ?*) IFS=':' + set '' $USER_VPATH + shift + IFS=$ifs + USER_VPATH= + USER_VPATH_CHAIN= + p=$PACKAGEROOT + for i + do case $i in + ''|$PACKAGEROOT|$INSTALLROOT) + ;; + ?*) USER_VPATH=$USER_VPATH:$i + USER_VPATH_CHAIN="$USER_VPATH_CHAIN $p $i" + p=$i + case $PROTOROOT in + -) executable $i/bin/mamake && PROTOROOT= ;; + esac + ;; + esac + done + ;; + esac + ;; +esac +PACKAGESRC=$PACKAGEROOT/lib/package +PACKAGEBIN=$INSTALLROOT/lib/package +case $action:$run in +use:-) set '' $args + shift + case $# in + 0) ;; + *) shift ;; + esac + run="$@" + ;; +esac + +# more cygwin hassles + +case $HOSTTYPE in +cygwin.*) + lose= + case $CYGWIN in + *nontsec*) + lose=ntsec + ;; + *ntsec*);; + *) exe=/tmp/pkg$$.exe + rm -f $exe + : > $exe + if test -x $exe + then lose=ntsec + fi + ;; + esac + case $CYGWIN in + *nobinmode*) + case $lose in + '') lose=binmode ;; + *) lose="$lose binmode" ;; + esac + ;; + esac + case $lose in + ?*) echo "$command: $HOSTTYPE: export '$lose' in CYGWIN or languish in windows" >&2 + exit 1 + ;; + esac + ;; +esac + +# set up the view state + +VIEW_bin=$INSTALLROOT VIEW_src=$PACKAGEROOT VIEW_all="$INSTALLROOT $PACKAGEROOT" +if (vpath $INSTALLROOT $PACKAGEROOT $USER_VPATH_CHAIN) >/dev/null 2>&1 && + vpath $INSTALLROOT $PACKAGEROOT $USER_VPATH_CHAIN +then $show vpath $INSTALLROOT $PACKAGEROOT $USER_VPATH_CHAIN +else VPATH=$INSTALLROOT:$PACKAGEROOT$USER_VPATH + $show VPATH=$VPATH + $show export VPATH + export VPATH + IFS=':' + set '' $VPATH + shift + IFS=$ifs + for i + do case $i in + */arch/*/*) + VIEW_src="$VIEW_src $i" + ;; + */arch/*) + VIEW_bin="$VIEW_bin $i" + ;; + *) + VIEW_src="$VIEW_src $i" + ;; + esac + VIEW_all="$VIEW_all $i" + done +fi + +# return 0 if arg in src|bin|all view + +view() # [test] [-|type] [src|bin|all] file +{ + case $1 in + -[dfsx])_view_T_=$1; shift ;; + *) _view_T_=-f ;; + esac + case $1 in + -) _view_t_= ;; + *) _view_t_=$1 ;; + esac + shift + case $1 in + all) shift; _view_v_=$VIEW_all ;; + bin) shift; _view_v_=$VIEW_bin ;; + src) shift; _view_v_=$VIEW_src ;; + *) _view_v_=$VIEW_all ;; + esac + case $1 in + /*) if test $_view_T_ $1 + then _view_=$1 + return 0 + fi + ;; + *) for _view_d_ in $_view_v_ + do if test $_view_T_ $_view_d_/$1 + then _view_=$_view_d_/$1 + return 0 + fi + done + ;; + esac + _view_= + case $_view_t_ in + ?*) echo $command: $1: $_view_t_ not found >&2 ;; + esac + return 1 +} + +# determine the package and targets + +case $action in +admin) case $admin_action in + results)action=$admin_action + set '' $admin_args + shift;shift + admin_args="admin $*" + case $admin_on in + '') target=$admin_args ;; + *) target="on $admin_on $admin_args" ;; + esac + ;; + esac + ;; +release)set '' $args + target= + while : + do shift + case $1 in + -|[0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]|[0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]) + target="$target $1" + ;; + *) break + ;; + esac + done + package=$* + ;; +setup) # { update read } with optional (bin|fun|include|lib) symlinks + # flat option sets up { bin fun include lib } symlinks from + # $INSTALLROOT to $PACKAGEROOT + + # . is the package root + + set '' $args + shift + types= + url= + while : + do case $# in + 0) break ;; + esac + case $1 in + --) shift + break + ;; + flat) flat=1 # backwards compatibility -- documentation dropped + ;; + *://*|*.url) + url=$1 + shift + break + ;; + *) types="$types $1" + ;; + esac + shift + done + if test ! -d $PACKAGEROOT/lib/package/tgz + then $exec mkdir -p $PACKAGEROOT/lib/package/tgz || exit + fi + case " $types " in + *" source "*) + case " $* " in + ' ') ;; + *" INIT "*) + ;; + *) view - all src/cmd/INIT || + set INIT "$@" + ;; + esac + ;; + esac + packages=`$0 $global authorize "$authorize" password "$password" update setup $types $url "$@" PACKAGEROOT=$PACKAGEROOT` + case $packages in + ?*) $0 $global read $packages PACKAGEROOT=$PACKAGEROOT + esac + exit + ;; +*) package= + target= + set '' $args + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + ''|-) target="$target $package" + package= + ;; + *) if view - src "lib/package/$1.pkg" + then package="$package $1" + else target="$target $package $1" + package= + fi + ;; + esac + done + ;; +esac + +# flatten -- assumes symlink support + +case $flat in +1) case $action in + make|read|setup|update|use|view) + if test ! -d $INSTALLROOT + then $exec mkdir -p $INSTALLROOT || exit + fi + for i in bin include lib fun man share + do if test ! -d $INSTALLROOT/../../$i + then $exec mkdir $INSTALLROOT/../../$i + fi + if test ! -d $INSTALLROOT/$i + then if test ! -h $INSTALLROOT/$i + then $exec ln -s ../../$i $INSTALLROOT/$i + fi + elif test ! -h $INSTALLROOT/$i + then for x in $INSTALLROOT/$i/.[a-z]* $INSTALLROOT/$i/* + do if test -f $x -o -d $x + then if test ! -d $INSTALLROOT/$i/$x || test ! -d $INSTALLROOT/../../$i/$x + then $exec mv $x $INSTALLROOT/../../$i + fi + fi + done + $exec rm -rf $INSTALLROOT/$i + $exec ln -s ../../$i $INSTALLROOT/$i + fi + done + ;; + esac + ;; +esac + +# check that cmd args are up to date a.out's + +checkaout() # cmd ... +{ + case $PROTOROOT in + -) PROTOROOT= + case $* in + ratz) if test -f $INITROOT/ratz.c -a -w $PACKAGEROOT + then test -f $INITROOT/hello.c || { + cat > $INITROOT/hello.c <<'!' +#ifndef printf +#include <stdio.h> +#endif +int main() { int new = 0; printf("hello world\n"); return new;} +! + } + test -f $INITROOT/p.c || { + cat > $INITROOT/p.c <<'!' +/* + * small test for prototyping cc + */ + +int main(int argc, char** argv) { return argc || argv; } +! + } + fi + ;; + esac + test -f $INITROOT/hello.c -a -f $INITROOT/p.c -a -w $PACKAGEROOT || { + for i + do onpath $i || { + echo "$command: $i: command not found" >&2 + return 1 + } + done + return 0 + } + case $cc in + '') _PACKAGE_cc=0 + ;; + *) _PACKAGE_cc=1 + test -f $INITROOT/hello.c -a -f $INITROOT/p.c || { + echo "$command: $INITROOT: INIT package source not found" >&2 + return 1 + } + executable $INSTALLROOT/bin/nmake || { + # check for prototyping cc + # NOTE: proto.c must be K&R compatible + + $CC -c $INITROOT/p.c >/dev/null 2>&1 + c=$? + rm -f p.* + test 0 != "$c" && { + checkaout proto || return + PROTOROOT=$PACKAGEROOT/proto + $show PROTOROOT=$PACKAGEROOT/proto + export PROTOROOT + INITPROTO=$PROTOROOT/src/cmd/INIT + note proto convert $PACKAGEROOT/src into $PROTOROOT/src + if test -d $PACKAGEROOT/src/cmd/nmake + then dirs="src/cmd/INIT src/lib/libast src/lib/libardir src/lib/libcoshell src/lib/libpp src/cmd/probe src/cmd/cpp src/cmd/nmake" + else dirs="src" + fi + ( + if test -f $PROTOROOT/UPDATE + then newer="-newer $PROTOROOT/UPDATE" + else newer="" + fi + case $exec in + '') cd $PACKAGEROOT + find $dirs -name '*.[CcHh]' $newer -print | proto -v -L - -C proto + ;; + *) $exec cd $PACKAGEROOT + $exec "find $dirs -name '*.[CcHh]' $newer -print | proto -L - -C proto" + ;; + esac + $exec touch $PROTOROOT/UPDATE + ) + if (vpath $INSTALLROOT - $INSTALLROOT $PROTOROOT $PROTOROOT $PACKAGEROOT) >/dev/null 2>&1 && + vpath $INSTALLROOT - $INSTALLROOT $PROTOROOT $PROTOROOT $PACKAGEROOT + then $show vpath $INSTALLROOT $PROTOROOT $PROTOROOT $PACKAGEROOT $USER_VPATH_CHAIN + else VPATH=$INSTALLROOT:$PROTOROOT:$PACKAGEROOT$USER_VPATH + $show VPATH=$VPATH + export VPATH + fi + } + } + for i in arch arch/$HOSTTYPE arch/$HOSTTYPE/bin + do test -d $PACKAGEROOT/$i || $exec mkdir $PACKAGEROOT/$i || return + done + ;; + esac + ;; + esac + case $_PACKAGE_cc in + '') case $cc in + '') _PACKAGE_cc=0 ;; + *) _PACKAGE_cc=1 ;; + esac + ;; + esac + for i + do eval j=\$_PACKAGE_AOUT_$i + case $j in + '') eval _PACKAGE_AOUT_$i=1 ;; + *) continue ;; + esac + k=$_PACKAGE_cc + if test -f $INITROOT/$i.c + then k=${k}1 + else k=${k}0 + fi + if executable $EXECROOT/bin/$i + then k=${k}1 + else k=${k}0 + fi + : $k : compiler : source : binary : + case $k in + *00) view - bin/$i && continue ;; + esac + case $k in + 000) echo "$command: $i: not found: download the INIT package $HOSTTYPE binary to continue" >&2 + return 1 + ;; + 010) echo "$command: $i: not found: set CC=C-compiler or download the INIT package $HOSTTYPE binary to continue" >&2 + return 1 + ;; + 100) echo "$command: $i: not found: download the INIT package source or $HOSTTYPE binary to continue" >&2 + return 1 + ;; + 110) case $CROSS in + 1) echo "$command: $i: not found: make the local $EXECTYPE binary package before $HOSTTYPE" >&2 + return 1 + ;; + esac + ;; + ?01) : accept binary + continue + ;; + 011) : accept binary + continue + ;; + ??1) case $CROSS in + 1) continue ;; + esac + ;; + esac + case `ls -t $INITROOT/$i.c $INSTALLROOT/bin/$i 2>/dev/null` in + "$INITROOT/$i.c"*) + note update $INSTALLROOT/bin/$i + if test proto != "$i" && executable $INSTALLROOT/bin/proto + then case $exec in + '') $INSTALLROOT/bin/proto -p $INITROOT/$i.c > $i.c || return ;; + *) $exec "$INSTALLROOT/bin/proto -p $INITROOT/$i.c > $i.c" ;; + esac + $exec $CC $CCFLAGS -o $INSTALLROOT/bin/$i $i.c || return + $exec rm -f $i.c + else if test ! -d $INSTALLROOT/bin + then for j in arch arch/$HOSTTYPE arch/$HOSTTYPE/bin + do test -d $PACKAGEROOT/$j || $exec mkdir $PACKAGEROOT/$j || return + done + fi + if test '' != "$PROTOROOT" -a -f $INITPROTO/$i.c + then $exec $CC $CCFLAGS -o $INSTALLROOT/bin/$i $INITPROTO/$i.c || return + else $exec $CC $CCFLAGS -o $INSTALLROOT/bin/$i $INITROOT/$i.c || return + fi + case $i:$exec in + proto:) test -d $INSTALLROOT/include || mkdir $INSTALLROOT/include + $INSTALLROOT/bin/proto -f /dev/null > $i.c + cmp -s $i.c $INSTALLROOT/include/prototyped.h 2>/dev/null || cp $i.c $INSTALLROOT/include/prototyped.h + rm $i.c + ;; + esac + fi + test -f $i.o && $exec rm -f $i.o + i=$PATH + PATH=/bin + PATH=$i + ;; + esac + done + return 0 +} + +# check package requirements against received packages + +requirements() # source|binary [ package ] +{ + case $1 in + binary) r=$VIEW_BIN ;; + source) r=$VIEW_SRC ;; + *) r=$VIEW_ALL ;; + esac + shift + case $1 in + '') x= ;; + *) x=$* ;; + esac + set '' + for d in $r + do set "$@" $d/gen/*.ver + case $x in + '') set "$@" $d/gen/*.req + ;; + *) for p in $x + do set "$@" $d/gen/$p.req + done + ;; + esac + done + shift + e=0 + x=$* + y= + n= + set '' + for i in $x + do p=`echo $i | sed -e 's,.*/,,' -e 's,\....$,,'` + if test -f $i + then set "$@" $i + y="$y $p" + else case $p in + '*') ;; + *) n="$n $p" ;; + esac + fi + done + for i in $n + do case " $y " in + *" $i "*) + ;; + *) echo "$command: $i: must read or write package" >&2 + e=1 + ;; + esac + done + case $e in + 1) exit 1 ;; + esac + shift + test 0 != "$#" && release=`sort -r "$@" | { + q= + e=0 + o= + while read p v r s + do q="$q +$v $r" + case $p in + $o) continue ;; + esac + case $s in + 0) e=1 + case $r in + base) echo "$command: base package $p.$v or newer required" >&2 ;; + *) echo "$command: delta package $p.$v.$r or newer required" >&2 ;; + esac + ;; + esac + o=$p + done + case $e in + 0) echo "$q" | sort | { read v r; read v r; echo $v; } ;; + 1) echo ERROR ;; + esac + }` + case $release in + ERROR) case $force in + 0) exit 1 ;; + esac + ;; + ?*) eval `echo $release | sed -e 's,\(.*\)-\(.*\)-\(.*\),yy=\1 mm=\2 dd=\3,'` + # slide back 4 months + case $mm in + 01) mm=09 dd=1 ;; + 02) mm=10 dd=1 ;; + 03) mm=11 dd=1 ;; + 04) mm=12 dd=1 ;; + 05) mm=01 dd=0 ;; + 06) mm=02 dd=0 ;; + 07) mm=03 dd=0 ;; + 08) mm=04 dd=0 ;; + 09) mm=05 dd=0 ;; + 10) mm=06 dd=0 ;; + 11) mm=07 dd=0 ;; + 12) mm=08 dd=0 ;; + esac + case $dd in + 1) yy=`expr $yy - 1` ;; + esac + release=$yy-$mm-01 + count=1 + lo=$release + release="-f $release -r $count" + ;; + esac +} + +# write ordered package prerequisite list to the standard output + +order() # [ package ] +{ + _order_t_=lib/package/tgz + case $action in + binary) _order_a_=.$HOSTTYPE ;; + *) _order_a_= ;; + esac + _order_n_=$# + case $_order_n_ in + 0) _order_p_= + for _order_v_ in $VIEW_all + do for _order_f_ in $_order_v_/lib/package/*.pkg + do if test -f $_order_f_ + then _order_p_="$_order_p_ $_order_f_" + fi + done + done + set '' $_order_p_ + shift + esac + { + if test ratz != "$*" + then for _order_f_ in ratz INIT + do if view -s - src $_order_t_/$_order_f_$_order_a_.tim + then echo $_order_f_ $_order_f_ + fi + done + fi + for _order_f_ + do while : + do view - src $_order_f_ && break + case $_order_f_ in + *.pkg) ;; + *) _order_f_=$_order_f_.pkg; view - src $_order_f_ && break ;; + esac + case $_order_f_ in + */*) ;; + *) _order_f_=lib/package/$_order_f_; view - src $_order_f_ && break ;; + esac + echo "$command: $_order_f_: not a package" >&2 + continue 2 + done + _order_f_=$_view_ + _order_p_=`echo $_order_f_ | sed -e 's,.*/,,' -e 's,\.pkg$,,'` + case $_order_n_ in + 0) view -s - src $_order_t_/$_order_p_$_order_a_.tim || continue ;; + esac + echo $_order_p_ $_order_p_ + case $_order_p_ in + INIT|ratz) + ;; + *) echo INIT $_order_p_ + ;; + esac + { + req= req_sep= + op=:: + while read line + do IFS=' \\' + set '' $line + IFS=$ifs + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + :*:) op=$1 + ;; + INIT|'$('*|*')') + ;; + *) case $op in + :REQUIRES:) + req="$req$req_sep$1" + req_sep=" " + ;; + esac + ;; + esac + done + done + for _order_i_ in $req + do if view - src lib/package/$_order_i_.pkg + then case $_order_u_ in + 0) view -s - src $_order_t_/$_order_i_$_order_a_.tim || continue ;; + esac + echo $_order_i_ $_order_i_; echo INIT $_order_i_; echo $_order_i_ $_order_p_ + fi + done + } < $_order_f_ + done + } | tsort +} + +# generate the package component list in _components_ + +components() # [ package ] +{ + _components_= + for p + do case $p in + '') ;; + INIT) case " $_components_ " in + *" $p "*) ;; + *) _components_="$_components_ $p" ;; + esac + ;; + *) if view - src lib/package/$p.pkg + then p=$_view_ + op=:: + exec < $p + while read line + do IFS=' \\' + set '' $line + IFS=$ifs + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + :*:) op=$1 + ;; + INIT|'$('*|*')') + ;; + *) case $op in + :PACKAGE:) + case " $_components_ " in + *" $1 "*) ;; + *) _components_="$_components_ $1" ;; + esac + ;; + esac + ;; + esac + done + done + exec < /dev/null + elif test -d $PACKAGEROOT/src/cmd/$p -o -d $PACKAGEROOT/src/lib/$p + then _components_="$_components_ $p" + else echo "$command: $p: package or component not found" >&2 + exit 1 + fi + ;; + esac + done +} + +# list main environment values + +showenv() +{ + case $1 in + ''|make)for __i__ in CC SHELL $env + do eval echo $__i__='$'$__i__ + done + ;; + esac +} + +# capture command output + +capture() # file command ... +{ + case $make:$noexec in + :) case $action in + install|make|view) + o=$action + ;; + *) case $package in + ''|*' '*) + o=$action + ;; + *) o=$package + ;; + esac + ;; + esac + case $action in + write) d=$PACKAGESRC/gen ;; + *) d=$PACKAGEBIN/gen ;; + esac + test -d $d || $exec mkdir $d + o=$d/$o + case $o in + $output)o=$o.out + s= + ;; + *) output=$o + if test -f $o.old + then mv $o.old $o.out.1 + if test -f $o.out + then mv $o.out $o.out.2 + fi + elif test -f $o.out + then for i in `ls -t $o.out.? 2>/dev/null` + do break + done + case $i in + *.1) i=2 ;; + *.2) i=3 ;; + *.3) i=4 ;; + *.4) i=5 ;; + *.5) i=6 ;; + *.6) i=7 ;; + *.7) i=8 ;; + *.8) i=9 ;; + *) i=1 ;; + esac + mv $o.out $o.out.$i + fi + o=$o.out + : > $o + note $action output captured in $o + s="$command: $action start at `date` in $INSTALLROOT" + case $quiet in + 0) trap "echo \"$command: $action done at \`date\`\" in $INSTALLROOT 2>&1 | \$TEE -a $o" 0 1 2 ;; + *) trap "echo \"$command: $action done at \`date\`\" in $INSTALLROOT >> $o" 0 1 2 ;; + esac + ;; + esac + case $quiet in + 0) if executable ! $TEE + then TEE=tee + fi + { + case $s in + ?*) echo "$s" ;; + esac + showenv $action + "$@" + } < /dev/null 2>&1 | $TEE -a $o + ;; + *) { + case $s in + ?*) echo "$s" ;; + esac + showenv $action + "$@" + } < /dev/null > $o 2>&1 + ;; + esac + ;; + *) $make "$@" + ;; + esac +} + +package_install() # dest sum +{ + dest=$1 sum=$2 + ot= + code=0 + sed -e '/ /!d' -e 's,[^ ]* ,,' -e 's, \(arch/[^/]*\)/, \1 ,' -e '/ arch\//!s,^[^ ]* [^ ]* [^ ]*,& .,' -e 's,/\([^ /]*\)$, \1,' $sum | + while read mode user group arch dir file + do case $flat:$arch in + 1:*|?:.)t=$dest/$dir ;; + *) t=$dest/$arch/$dir ;; + esac + case $t in + $ot) ;; + *) if test ! -d "$t" + then $exec mkdir -p "$t" || exit + fi + ot=$t + ;; + esac + case $file in + ?*) case $arch in + .) f=$dir/$file ;; + *) f=$arch/$dir/$file ;; + esac + if test -f "$f" + then t=$t/$file + case $quiet in + 0) echo "$t" ;; + esac + $exec cp -f "$f" "$t" || code=1 + $exec chmod $mode "$t" || code=1 + fi + ;; + esac + done + return $code +} + +package_verify() # sum +{ + $exec $SUM -cp $1 +} + +make_recurse() # dir +{ + for _make_recurse_j in $makefiles + do if view - $1/$_make_recurse_j + then return + fi + done + if test -d $1 + then case $exec in + '') echo :MAKE: > $1/Makefile || exit ;; + *) $exec "echo :MAKE: > $1/Makefile" ;; + esac + fi +} + +get() # host path [ file size ] +{ + case $HURL in + '') HURL=. + for i in wget lynx curl + do if onpath $i + then HURL=$i + break; + fi + done + AUTHORIZE="User-Agent: package AT&T Research\\r\\n" + case $HURL:$authorize in + .:?*) AUTHORIZE="${AUTHORIZE}Authorization: Basic `print -n -r -- $authorize:$password | uuencode -h -x base64`\\r\\n" ;; + esac + ;; + esac + getfd=8 + case $3 in + '') case $HURL in + .) host=$1 + path=$2 + while : + do eval "exec $getfd<> /dev/tcp/$host/80" || exit + case $path in + /*) ;; + *) path=/$path ;; + esac + print "GET $path HTTP/1.0\\r\\nHost: $host\\r\\n$AUTHORIZE\\r" >&$getfd + cat <&8 > get.tmp + got=`sed -e 1q get.tmp` + case $got in + *" "200" "*) + got=`sed -e '1,/^.$/d' -e '/^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ]/!d' get.tmp` + : > get.err + code=0 + break + ;; + *" "30[123]" "*) + got=`sed -e '/^Location: /!d' -e 's,^Location: \(.*\)://\([^/]*\)\(/.*\),prot='\''\1'\'' host='\''\2'\'' path='\''\3'\'',' get.tmp` + case $got in + '') rm get.tmp + echo "$command: $action: $url: redirect error" >&2 + exit 1 + ;; + esac + eval $got + ;; + *) rm get.tmp + echo "$command: $action: $url: $got" >&2 + echo '' "$got" > get.err + code=1 + break + ;; + esac + done + ;; + curl) case $authorize in + '') curl -s -L -o get.tmp http://$1/$2 2> get.err; code=$? ;; + *) curl -s -L -o get.tmp -u "$authorize":"$password" http://$1/$2 2> get.err; code=$? ;; + esac + got=`grep '^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ]' get.tmp 2>/dev/null` + case $code in + 0) if grep '^<H1>Authorization Required</H1>' get.tmp > get.err + then code=1 + fi + ;; + esac + ;; + hurl) case $authorize in + '') hurl http://$1/$2 > get.tmp 2> get.err; code=$? ;; + *) hurl -a "$authorize":"$password" http://$1/$2 > get.tmp 2> get.err; code=$? ;; + esac + got=`grep '^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ]' get.tmp` + ;; + lynx) case $authorize in + '') lynx -source http://$1/$2 > get.tmp 2> get.err; code=$? ;; + *) lynx -source -auth "$authorize":"$password" http://$1/$2 > get.tmp 2> get.err; code=$? ;; + esac + got=`grep '^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ]' get.tmp` + ;; + wget) wget -nv -O get.tmp ${authorize:+--http-user="$authorize"} ${password:+--http-passwd="$password"} http://$1/$2 2> get.err + code=$? + got=`grep '^[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ]' get.tmp 2>/dev/null` + ;; + *) echo $command: $action: $HURL: url get command not found >&2 + exit 1 + ;; + esac + if test 0 != "$code" + then case `cat get.err get.tmp 2>/dev/null` in + *[Aa][Uu][Tt][Hh][Oo][Rr][Ii][SsZz]*|*[Dd][Ee][Nn][Ii][Ee][Dd]*) + echo $command: $action: authorization required -- see $url for license acceptance authorization name and password >&2 + ;; + *) cat get.err + ;; + esac + rm -f get.tmp get.err + echo $command: $action: $2: download failed >&2 + exit 1 + fi + rm -f get.tmp get.err + ;; + *) case $exec in + '') echo "$3 ($4 bytes):" >&2 + case $HURL in + .) eval "exec $getfd<> /dev/tcp/$1/80" || exit + path=$2/$3 + case $path in + /*) ;; + *) path=/$path ;; + esac + print "GET $path HTTP/1.0\\r\\nHost: $host\\r\\n$AUTHORIZE\\r" >&$getfd + read got <&$getfd + case $got in + *" 200 "*) + code=0 + : > get.err + ;; + *) echo '' "$got" > get.err + code=1 + ;; + esac + while read got <&$getfd + do case $got in + ''|?) break ;; + esac + done + cat <&$getfd > get.tmp + ;; + curl) case $authorize in + '') curl -s -L -o get.tmp http://$1/$2/$3 2> get.err; code=$? ;; + *) curl -s -L -o get.tmp -u "$authorize":"$password" http://$1/$2/$3 2> get.err; code=$? + esac + case $code in + 0) if grep '^<H1>Authorization Required</H1>' get.tmp > get.err + then code=1 + fi + ;; + esac + ;; + hurl) case $authorize in + '') ksh -x hurl http://$1/$2/$3 > get.tmp 2> get.err; code=$? ;; + *) ksh -x hurl -a "$authorize":"$password" http://$1/$2/$3 > get.tmp 2> get.err; code=$? ;; + esac + ;; + lynx) case $authorize in + '') lynx -source http://$1/$2/$3 > get.tmp 2> get.err; code=$? ;; + *) lynx -source -auth "$authorize":"$password" http://$1/$2/$3 > get.tmp 2> get.err; code=$? ;; + esac + ;; + wget) wget -nv -O get.tmp ${authorize:+--http-user="$authorize"} ${password:+--http-passwd="$password"} http://$1/$2/$3 2> get.err + code=$? + ;; + *) echo $command: $action: $HURL: url get command not found >&2 + exit 1 + ;; + esac + if test 0 != "$code" + then case `cat get.err get.tmp` in + *[Aa][Uu][Tt][Hh][Oo][Rr][Ii][SsZz]*|*[Dd][Ee][Nn][Ii][Ee][Dd]*) + echo $command: $action: authorization required -- see $url for license acceptance authorization name and password >&2 + ;; + *) cat get.err + ;; + esac + rm get.tmp get.err + echo $command: $action: $3: download failed >&2 + exit 1 + fi + rm get.err + case $checksum:$5 in + :*|*:-) z=`wc -c < get.tmp` + case " $z " in + *" $4 "*) + ;; + *) rm -f get.tmp + echo $command: $3: download error: expected $4 bytes, got $z >&2 + exit 1 + ;; + esac + ;; + *) z=`$checksum < get.tmp | sed -e 's,^[ ][ ]*,,' -e 's,[ ].*,,'` + case " $z " in + *" $5 "*) + ;; + *) rm -f get.tmp + echo $command: $3: download $checksum error: expected $5, got $z >&2 + exit 1 + ;; + esac + ;; + esac + mv get.tmp $3 || exit + ;; + *) echo "$3 ($4 bytes)" >&2 + ;; + esac + esac +} + +# generate copyright notice + +copyright() +{ + if test -f $1.lic + then echo $1 package general copyright notice + echo + proto -c'#' -p -s -l $1.lic -o type=verbose,author='*' /dev/null + return 0 + fi + case $1 in + *-*) eval `echo '' $1 | sed 's/\([^-]*\)-\(.*\)/__j__="\1" __i__="\2"/'` + if copyright $__i__ || copyright $__j__ + then return 0 + fi + ;; + esac + return 1 +} + +# run remote make on host + +remote() # host no-exec-background +{ + host=$1 + background=$2 + eval name=\$${host}_name user=\$${host}_user snarf=\$${host}_snarf type=\$${host}_type rsh=\$${host}_rsh root=\$${host}_root keep=\$${host}_keep log=\$${host}_log + case $keep in + 1*) ;; + *) return ;; + esac + case $host in + $main) ;; + *) case $exec in + '') exec > $admin_log/$log 2>&1 ;; + *) echo "exec > $admin_log/$log 2>&1" ;; + esac + ;; + esac + if $admin_ping $name >/dev/null 2>&1 || $admin_ping $name >/dev/null 2>&1 + then cmd=". ./.profile" + case $root in + .) root= + ;; + *) cmd="$cmd && cd $root" + root=$root/ + ;; + esac + cmd="$cmd && { test -f lib/package/admin/$admin_env && . ./lib/package/admin/$admin_env || true ;} && PATH=\${PWD:-\`pwd\`}/bin:\$PATH \${SHELL:-/bin/sh} -c 'package $admin_args PACKAGEROOT=\${PWD:-\`pwd\`} HOSTTYPE=$type VPATH='" + case $admin_binary in + '') snarf= ;; + esac + case $snarf in + '') $exec $rsh $user$name "$cmd" $background + ;; + *?) rcp=`echo $rsh | sed 's/\(.\).*/\1/'`cp + case $background in + ?*) $exec "{" ;; + esac + $exec $rsh $user$name "$cmd" + eval lst=$admin_list + case $admin_pkgs in + '') filter=cat ;; + *) filter="egrep lib/package/tgz/($admin_pkgs)\\." ;; + esac + if $exec $rcp $user$name:${root}lib/package/tgz/$lst $PACKAGESRC/tgz + then $exec $rcp `$filter $PACKAGESRC/tgz/$lst | sed "s,^,$user$name:,"` $PACKAGESRC/tgz + else echo "$command: $user$name:${root}lib/package/tgz/$lst: not found" >&2 + fi + case $background in + ?*) $exec "} $background" ;; + esac + ;; + esac + else echo "$command: $name: down" >&2 + fi +} + +# update package_src + +checksrc() +{ + case $package_src in + '') package_src=$src + for _i_ in `cd $PACKAGESRC; ls *.def *.lic *.pkg 2>/dev/null | sed 's/[-.].*//'` + do case " $package_src " in + *" $_i_ "*) + ;; + *) package_src="$package_src $_i_" + ;; + esac + done + ;; + esac +} + +# check for native ascii 0:yes 1:no + +__isascii__= + +isascii() +{ + case $__isascii__ in + '') case `echo A | od -o | sed -e 's/[ ]*$//' -e '/[ ]/!d' -e 's/.*[ ]//'` in + 005101|040412) __isascii__=0 ;; + *) __isascii__=1 ;; + esac + esac + return $__isascii__ +} + +case $action in + +admin) while test ! -f $admin_db + do case $admin_db in + /*) echo $command: $action: $admin_db: data file not found >&2 + exit 1 + ;; + esac + view file src lib/package/admin/$admin_db || exit 1 + admin_db=$_view_ + done + admin_components= + case $admin_action in + list) cat $admin_db + exit + ;; + test) set $admin_args + while : + do case $# in + 1) break ;; + esac + shift + case $1 in + *=*) ;; + *) admin_components=-$1 + break + ;; + esac + done + ;; + esac + : all work done in $PACKAGESRC/admin + cd $PACKAGESRC/admin || exit + checksrc + packages= + admin_log=${admin_action}${admin_components}.log + exec < $admin_db || exit + test -d $admin_log || $exec mkdir $admin_log || exit + case $admin_on in + '') admin_on="*" ;; + esac + hostname= + hosts= + logs= + local_hosts= + local_types= + pids= + remote_hosts= + sync_hosts= + admin_host=_admin_host_ + admin_out= + case " $admin_args " in + *" write binary "*|*" write "*" binary "*) + admin_binary=1 + ;; + *) admin_binary= + ;; + esac + case $only in + 1) admin_args="only $admin_args" ;; + esac + trap 'kill $pids >/dev/null 2>&1' 1 2 3 15 + index=0 + while read type host root date time make test write comment + do case $type in + ''|'#'*);; + *=*) eval "$type $host $root $date $time $make $test $write $comment" + ;; + *) case $admin_action in + make|test|write) + eval f='$'$admin_action + case $f in + *[!0123456789]*) continue ;; + esac + ;; + esac + rsh=rsh + case $host in + *@*) IFS=@ + set '' $host + IFS=$ifs + user=${2}@ + host=$3 + ;; + *) user= + ;; + esac + : type=$type host=$host root=$root date=$date time=$time make=$make test=$test write=$write : + name=$host + host=`echo $name | sed 's,[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789],__,g'` + eval x='$'${host}_index + eval ${host}_index=1 + case $x in + 1) i=0 + while : + do case $i in + $index) h='' + break + ;; + esac + i=`expr $i + 1` + eval h='$'${admin_host}${i}_name + case $h in + $host) host=${admin_host}${i} + eval user='$'${host}_user root='$'${host}_rsh:$host:'$'${host}_root + break + ;; + esac + done + ;; + esac + case $root in + *:$name:*)root=`echo '' $root | sed 's,:.*,:,'` ;; + esac + case $root in + *:*:*) index=`expr $index + 1` + host=${admin_host}$index + ;; + *:*) case " $sync_hosts " in + *" $name ${admin_host}"*) + set '' '' $sync_hosts + while : + do shift + shift + case $1 in + $name) host=$2 + break + ;; + esac + done + ;; + *) index=`expr $index + 1` + host=${admin_host}$index + sync_hosts="$sync_hosts $name $host" + ;; + esac + ;; + *) index=`expr $index + 1` + host=${admin_host}$index + ;; + esac + case $root in + -*) continue + ;; + *:*) case $admin_all in + 0) continue ;; + esac + case $root in + *:) root=${root}. ;; + esac + IFS=: + set '' $root + IFS=$ifs + sync=$host + case $hostname in + '') hostinfo name + hostname=$_hostinfo_ + ;; + esac + shift + case $# in + 0) ;; + 1) root=$1 + ;; + 2) rsh=$1 root=$2 + ;; + *) rsh=$1 sync=$2 root=$3 + case $sync in + ${admin_host}*) + ;; + ?*) case " $sync_hosts " in + *" $sync ${admin_host}"*) + set '' '' $sync_hosts + while : + do shift + shift + case $1 in + $sync) sync=$2 + break + ;; + esac + done + ;; + *) index=`expr $index + 1` + x=${admin_host}$index + sync_hosts="$sync_hosts $sync $x" + sync=$x + ;; + esac + ;; + esac + ;; + esac + ;; + *) sync= + ;; + esac + case $name in + $admin_on) + keep=1 + ;; + *) case " $admin_on " in + *" $name "*) keep=1 ;; + *) keep=0 ;; + esac + ;; + esac + case " $admin_out " in + *" $name "*) + log=$name.$type + ;; + *) admin_out="$admin_out $name" + log=$name + ;; + esac + case $sync in + '') local_types="$local_types $type" ;; + esac + case $sync in + $host) remote_hosts="$remote_hosts $host" + ;; + ?*) eval ${sync}_share=\"\$${sync}_share $host\" + ;; + '') local_hosts="$local_hosts $host" + ;; + esac + eval ${host}_name='$'name ${host}_type='$'type ${host}_user='$'user ${host}_sync='$'sync ${host}_snarf='$'sync ${host}_rsh='$'rsh ${host}_root='$'root ${host}_keep='$'keep ${host}_log='$'log + ;; + esac + done + p= + for i in $admin_args + do p="$i $p" + done + admin_pkgs= + for i in $p + do if view - src "lib/package/$i.pkg" + then case $admin_pkgs in + '') admin_pkgs="$i" ;; + *) admin_pkgs="$admin_pkgs|$i" ;; + esac + fi + done + : "admin_binary :" $admin_binary + : "admin_args :" $admin_args + : "admin_pkgs :" $admin_pkgs + : "admin_on :" "$admin_on" + : "local_hosts :" $local_hosts + : "local_types :" $local_types + : "remote_hosts :" $remote_hosts + : "sync_hosts :" $sync_hosts + : "sync_share :" $sync_share + case $admin_binary in + 1) admin_bin_types= + admin_bin_main= + for main in $local_hosts $remote_hosts + do eval share=\$${main}_share keep=\$${main}_keep + case $keep in + 0*) continue ;; + esac + for host in $main $share + do case " $admin_bin_hosts " in + *" $host "*) + continue + ;; + esac + eval type=\$${host}_type + case " $admin_bin_types " in + *" $type "*) + continue + ;; + esac + case " $types " in + " ") ;; + *" $type "*) + ;; + *) continue + ;; + esac + admin_bin_hosts="$admin_bin_hosts $host" + admin_bin_types="$admin_bin_types $type" + case " $admin_bin_hosts " in + *" $main "*) + ;; + *) case " $admin_bin_main " in + *" $main "*) + ;; + *) admin_bin_main="$admin_bin_main $main" + ;; + esac + ;; + esac + done + done + local= + remote= + for host in $admin_bin_main $admin_bin_hosts + do case " $local_hosts " in + *" $host "*) + local="$local $host" + ;; + *) case " $remote_hosts " in + *" $host "*) + remote="$remote $host" + ;; + esac + ;; + esac + done + local_hosts=$local + remote_hosts=$remote + ;; + esac + for host in $remote_hosts $local_hosts + do eval share=\$${host}_share + case $share in + ?*) while : + do oshare=$share + for s in $share + do eval r='$'${s}_share + case $r in + ?*) case " $share " in + *" $r "*) ;; + *) share="$share $r" ;; + esac + ;; + esac + done + case $share in + $oshare) eval ${host}_share="'$share'" + break + ;; + esac + done + ;; + esac + done + for host in $remote_hosts + do eval type=\$${host}_type + case " $local_types " in + *" $type "*) + eval ${host}_snarf= + ;; + esac + eval name=\$${host}_name keep=\$${host}_keep share=\$${host}_share + for share in $share + do eval type=\$${share}_type keep=\$keep\$${share}_keep + case " $local_types " in + *" $type "*) + eval ${share}_snarf= + ;; + esac + done + case $keep in + 0*1*) keep=2$keep ;; + *1*) ;; + *) keep=0 ;; + esac + eval ${host}_keep=$keep + done + for host in $remote_hosts $local_hosts + do eval name=\$${host}_name user=\$${host}_user type=\$${host}_type sync=\$${host}_sync snarf=\$${host}_snarf share=\$${host}_share rsh=\$${host}_rsh root=\$${host}_root keep=\$${host}_keep + case $keep in + 0*) continue ;; + esac + case $sync in + '') case $admin_action in + ditto) continue ;; + esac + case $admin_binary in + 1) case $keep in + 1*|?*1*);; + *) continue ;; + esac + ;; + esac + ;; + esac + eval main_log='$'${host}_log + main= + share_keep= + for i in $host $share + do eval n='$'${i}_name t='$'${i}_type q='$'${i}_sync s='$'${i}_snarf l='$'${i}_log k='$'${i}_keep + case $main:$k in + :*) ;; + *:0) continue ;; + esac + case $admin_binary in + 1) case $s:$q in + :?*) continue ;; + esac + case " $admin_bin_hosts " in + *" $i "*) + ;; + *) continue + ;; + esac + ;; + esac + case $main in + '') main=$i ;; + *) share_keep="$share_keep $i" ;; + esac + echo package "$admin_args" "[ $n $t ]" + case $exec in + '') : > $admin_log/$l ;; + *) $exec ": > $admin_log/$l" ;; + esac + done + host=$main + share=$share_keep + case $force in + 0) admin_ditto_update=--update ;; + *) admin_ditto_update= ;; + esac + case $exec in + '') { + case $admin_binary:$sync in + :?*) eval syncname='$'${sync}_name + test -x $PACKAGEROOT/bin/package && $admin_ditto $admin_ditto_update --remote=$rsh --expr="name=='package'" $PACKAGEROOT/bin $user$syncname:$root/bin + test -d $PACKAGESRC && $admin_ditto $admin_ditto_update --remote=$rsh --expr="if(level>1&&path!='LICENSES/*')status=SKIP;path=='LICENSES*|*.(pkg|lic|def)'" $PACKAGESRC $user$syncname:$root/lib/package + for dir in $package_src + do case $MAKESKIP in + '') expr="--expr=if(name=='$admin_ditto_skip')status=SKIP" ;; + *) expr="--expr=if(name=='$admin_ditto_skip'||level==1&&name=='$MAKESKIP')status=SKIP" ;; + esac + test -d $PACKAGEROOT/src/$dir && $admin_ditto $admin_ditto_update --remote=$rsh "$expr" $PACKAGEROOT/src/$dir $user$syncname:$root/src/$dir + done + ;; + esac + case $admin_action in + ditto) ;; + ?*) pids= + set '' $host $share + while : + do shift + case $# in + 0) break + ;; + 1) remote $1 + ;; + *) remote $1 & + pids="$pids $!" + ;; + esac + done + case $pids in + ?*) wait $pids ;; + esac + ;; + esac + } < /dev/null > $admin_log/$main_log 2>&1 & + pids="$pids $!" + ;; + *) echo "{" + case $admin_binary:$sync in + :?*) eval syncname='$'${sync}_name + test -d $PACKAGESRC && echo $admin_ditto $admin_ditto_update --remote=$rsh --expr="if(level>1)status=SKIP;name=='*.(pkg|lic|def)'" $PACKAGESRC $user$syncname:$root/lib/package + for dir in $package_src + do case $MAKESKIP in + '') expr="--expr=if(name=='$admin_ditto_skip')status=SKIP" ;; + *) expr="--expr=if(name=='$admin_ditto_skip'||level==1&&name=='$MAKESKIP')status=SKIP" ;; + esac + test -d $PACKAGEROOT/src/$dir && echo $admin_ditto $admin_ditto_update --remote=$rsh "$expr" $PACKAGEROOT/src/$dir $user$syncname:$root/src/$dir + done + ;; + esac + case $admin_action in + ditto) ;; + ?*) pids= + set '' $host $share + while : + do shift + case $# in + 0) break + ;; + 1) remote $1 + ;; + *) remote $1 "&" + pids=1 + ;; + esac + done + case $pids in + 1) echo wait ;; + esac + ;; + esac + echo "} < /dev/null > $admin_log/$main_log 2>&1 &" + ;; + esac + eval name='$'${main}_name + hosts="$hosts $name" + logs="$logs $main_log" + for share in $share + do eval keep=\$${share}_keep + case $keep in + 1) eval name='$'${share}_name log='$'${share}_log + hosts="$hosts $name" + logs="$logs $log" + ;; + esac + done + done + case $exec in + '') # track the progress + case $quiet in + 0) cd $admin_log + tail -t $PACKAGE_admin_tail_timeout -f $logs + cd .. + ;; + esac + # wait for the remote actions to complete + wait + trap - 1 2 3 15 + # update the db + exec < $admin_db || exit + exec 9>&1 + D=`date +%y%m%d` + while read line + do set -- $line + case $1 in + ''|'#'*|*=*) + ;; + *) case " $hosts " in + *" $2 "*) + : ast date command assumed : + E=`eval date -E \`egrep '[ ](start|done)[ ][ ]*at[ ]' $admin_log/$2 | sed -e 's/.*[ ][ ]*at[ ][ ]*//' -e 's/[ ][ ]*in[ ].*$//' -e 's/.*/"&"/'\`` + M=$6 T=$7 W=$8 + case $admin_action in + make|view) + M=`egrep -c ']:.* (\*\*\*.* code|don'\''t know) | \*\*\* termination code ' $admin_log/$2` ;; + test) T=`grep -ci 'fail[es]' $admin_log/$2` ;; + *) W=`grep '^[abcdefghijklmnopqrstuvwxyz][abcdefghijklmnopqrstuvwxyz]*:.' $admin_log/$2 | egrep -cv 'start at|done at|output captured|warning:|: package not found|whence: command not found'` ;; + esac + case $1 in + ?|??|???|????|?????|??????|???????) + t1=' ' + ;; + ????????|?????????|??????????|???????????|????????????|?????????????|??????????????|???????????????) + t1=' ' + ;; + *) t1='' + ;; + esac + case $2 in + ?|??|???|????|?????|??????|???????) + t2=' ' + ;; + *) t2='' + ;; + esac + case $3 in + ?|??|???|????|?????|??????|???????) + t3=' ' + ;; + *) t3='' + ;; + esac + case $E in + ?????) E=" $E" ;; + ????) E=" $E" ;; + ???) E=" $E" ;; + ??) E=" $E" ;; + ?) E=" $E" ;; + esac + case $M in + ???) M="$M" ;; + ??) M=" $M" ;; + ?) M=" $M" ;; + '') M=" 0" ;; + esac + case $T in + ???) T="$T" ;; + ??) T=" $T" ;; + ?) T=" $T" ;; + '') T=" 0" ;; + esac + case $W in + ???) W="$W" ;; + ??) W=" $W" ;; + ?) W=" $W" ;; + '') W=" 0" ;; + esac + A=$1$t1 + H=$2$t2 + R=$3$t3 + case $# in + [0-8]) C= + ;; + *) shift 8 + C=" $*" + ;; + esac + echo "$A $H $R $D $E $M $T $W$C" + echo "$A $H $R $D $E $M $T $W$C" >&9 + continue + ;; + esac + ;; + esac + echo "$line" + done > $admin_db.new + mv $admin_db $admin_db.old + mv $admin_db.new $admin_db + ;; + esac + ;; + +clean|clobber) + cd $PACKAGEROOT + $exec rm -rf $INSTALLROOT + exit + ;; + +contents|list) + # all work in $PACKAGESRC + + cd $PACKAGESRC + + # generate the package list + + set '' $target $package + shift + argc=$# + case $# in + 0) set '' *.pkg + case $2 in + '*.pkg') + echo $command: $action: no packages >&2 + exit 1 + ;; + esac + set '' `echo $* | sed 's,\.pkg,,g'` + shift + ;; + esac + sep="$nl " + echo packages in $PACKAGEROOT + case $action in + list) echo + echo "NAME${nl}VERSION${nl}RELEASE${nl}TYPE${nl}STATUS${nl}REQUIRES${nl}----${nl}-------${nl}-------${nl}----${nl}------${nl}--------" | pr -6 -a -o4 -t + ;; + esac + { + omit=: + for pkg + do if test ! -f $pkg.pkg + then echo $command: $action: $pkg: not a package >&2 + else if test -f gen/$pkg.ver + then set '' `cat gen/$pkg.ver` + case $3 in + $2) ver=base ;; + *) ver=$3 ;; + esac + if test -s tgz/$pkg.tim + then sts=local + else sts= + fi + else ver= + sts=unwritten + fi + typ= + txt= + cmp= cmp_sep= + req= req_sep= + op=:: + exec < $pkg.pkg + while read line + do IFS=' \\' + set '' $line + IFS=$ifs + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + :*:) op=$1 + ;; + INIT|'$('*|*')') + ;; + *) case $op in + :DESCRIPTION:) + txt="$txt$sep$line" + break + ;; + :PACKAGE:) + cmp="$cmp$cmp_sep$1" + cmp_sep=$nl + ;; + :REQUIRES:) + req="$req$req_sep$1" + req_sep=" " + ;; + esac + ;; + esac + done + done + exec < /dev/null + case $txt in + ?*) txt="$nl$txt" ;; + esac + case :$ver: in + *::*) ;; + *) case $action in + list) case $sts in + '') case `ls -t "tgz/$pkg.$ver.base" "tgz/$pkg.tim" 2>/dev/null` in + "tgz/$pkg.tim"*) + sts=read + ;; + *) sts=unread + ;; + esac + ;; + esac + echo "$pkg${nl}$ver${nl}base${nl}$typ${nl}$sts${nl}$req" + case $typ in + '') omit=$omit$pkg.$ver.base: ;; + esac + ;; + *) case $req in + ?*) req=": $req" ;; + esac + echo + echo $pkg $ver $req "$txt" + case $cmp in + ?*) echo "${sep}Components in this package:$nl" + echo "$cmp" | pr -4 -o4 -t ;; + esac + ;; + esac + ;; + esac + fi + done + case $argc:$action in + 0:list) if test -d tgz + then cd tgz + # f:file p:package v:version r:release t:type u:update + for f in `find . -name '*?[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.]*' -print | sed 's,^\./,,' | sort -r` + do eval `echo "$f" | sed -e 's,\.c$,,' -e 's,\.gz$,,' -e 's,\.exe$,,' -e 's,\.tgz$,,' -e 's,\([^_.]*\)[_.]\([0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]\)[_.]\([0123456789][0123456789][0123456789][0123456789][^_.]*\)[_.]*\(.*\),p=\1 v=\2 r=\3 t=\4,' -e 's,\([^_.]*\)[_.]\([0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]\)[_.]*\(.*\),p=\1 v=\2 r=base t=\3,'` + case $t in + '') case $omit in + *:$p.$v.$r:*) continue ;; + esac + u=$p.tim + ;; + *) u=$p.$t.tim + ;; + esac + if test -s "$u" + then s=local + elif test -f "$u" + then case `ls -t "$f" "$u" 2>/dev/null` in + "$u"*) s=read ;; + *) s=unread ;; + esac + else s=unread + fi + echo "$p$nl$v$nl$r$nl$t$nl$s$nl" + done + fi + ;; + esac + } | + case $action in + list) pr -6 -a -o4 -t | sort -u ;; + *) cat ;; + esac + case $argc in + 0) if test -d $PACKAGEROOT/arch + then echo + echo architectures in $PACKAGEROOT + echo + for i in `ls $PACKAGEROOT/arch` + do if test -f $PACKAGEROOT/arch/$i/lib/package/gen/host + then h=`cat $PACKAGEROOT/arch/$i/lib/package/gen/host` + else h= + fi + echo $i + echo $h + echo + echo + done | pr -4 -a -o4 -t + fi + ;; + esac + ;; + +copyright) + # all work in $PACKAGESRC + + cd $PACKAGESRC + + # generate the package list + + set '' $target $package + shift + argc=$# + case $# in + 0) set '' `echo *.lic | sed 's,\.lic,,g'` + shift + case $1 in + '*') echo $command: $action: no packages >&2 + exit 1 + ;; + esac + ;; + esac + checkaout proto || exit + for i + do copyright $i + done + ;; + +export) case $INSTALLROOT in + $PACKAGEROOT) + INSTALLROOT=$INSTALLROOT/arch/$HOSTTYPE + ;; + esac + case $only in + 0) v='$i=' ;; + *) v= ;; + esac + set '' $target $package + case $# in + 1) set '' $env ;; + esac + while : + do case $# in + 1) break ;; + esac + shift + i=$1 + eval echo ${v}'$'${i} + done + ;; + +install)cd $PACKAGEROOT + set '' $package + shift + case $only in + 0) set '' `order "$@"` + shift + ;; + esac + case $# in + 0) echo "$command: at least one package name expected" >&2 + exit 1 + ;; + esac + package=$* + requirements - $package + set '' $target + shift + case $1 in + flat) flat=1 # backwards compatibility -- documentation dropped + shift + ;; + esac + case $# in + 0) echo "$command: $action: target directory argument expected" >&2 + exit 1 + ;; + esac + target= + while : + do case $# in + 1) directory=$1 + break + ;; + esac + target="$target $1" + shift + done + if test ! -d $directory + then echo "$command: $action: $directory: target directory not found" >&2 + exit 1 + fi + case $target in + '') cd arch + set '' * + shift + target=$* + cd .. + ;; + esac + code=0 + makecheck=1 + for a in $target + do case $a in + -) a=$HOSTTYPE ;; + esac + case $flat:$a in + 1:*|?:.)dest=$directory + ;; + *) dest=$directory/arch/$a + if test "" = "$exec" -a ! -d $dest + then mkdir -p $dest || { + echo "$command: $dest: destination directory must exist" >&2 + exit 1 + } + fi + ;; + esac + for i in $package + do if test "ratz" = "$i" + then : skip + elif test -f arch/$a/lib/package/gen/$i.sum + then package_install $directory arch/$a/lib/package/gen/$i.sum || code=1 + elif test ! -d arch/$a/bin + then echo "$command: $a: invalid architecture" >&2 + elif test ! -d $dest + then echo "$command: $dest: destination directory must exist" >&2 + else if test "" != "$makecheck" + then if onpath $MAKE + then MAKE=$_onpath_ + else echo "$command: $MAKE: not found" >&2 + exit 1 + fi + makecheck= + fi + if test "" != "$exec" + then ( + trap - 0 1 2 15 + echo "=== $i installation manifest ===" + cd arch/$a + ( + cd lib/package + INSTALLROOT=$PACKAGEROOT/arch/$a + VPATH=$INSTALLROOT:$PACKAGEROOT:$VPATH + export INSTALLROOT VPATH + $MAKE -s $makeflags -f $i.pkg $qualifier list.installed $assign + ) | sort -u + ) + else ( + set - + cd arch/$a + ( + cd lib/package + INSTALLROOT=$PACKAGEROOT/arch/$a + VPATH=$INSTALLROOT:$PACKAGEROOT:$VPATH + export INSTALLROOT VPATH + echo lib/$command + $MAKE -s $makeflags -f $i.pkg $qualifier list.installed $assign + ) | sort -u | pax -drw -ps $dest + ) + fi + fi + done + done + exit $code + ;; + +license)# all work in $PACKAGESRC/LICENSES + + cd $PACKAGESRC/LICENSES || exit + + # generate the package list + + set '' $target $package + shift + argc=$# + case $# in + 0) set '' * + shift + case $1 in + '*') echo $command: $action: no licenses >&2 + exit 1 + ;; + esac + ;; + *) checkaout proto || exit + a= + for i + do while : + do if test -f ../$i.lic + then j=`proto -df -l ../$i.lic -o query=type /dev/null 2>/dev/null` + case $j in + ?*) if test -f $j + then case " $a " in + *" $j "*) ;; + *) a="$a $j" ;; + esac + fi + break + ;; + esac + fi + case $i in + *-*) i=`echo $i | sed 's/-[^-]*$//'` + ;; + *) echo "$command: $i: package license not found" >&2 + break + ;; + esac + done + done + set '' $a + shift + ;; + esac + for i + do case $exec in + '') echo + echo " --- $i source license ---" + echo + cat $i + ;; + *) echo $PACKAGESRC/LICENSES/$i + ;; + esac + done + ;; + +make|view) + cd $PACKAGEROOT + case $package in + '') lic="lib/package/*.lic" + ;; + *) for i in $package + do lic="$lic lib/package/$i.lic" + case $i in + *-*) lic="$lic lib/package/"`echo $i | sed 's,-.*,,'`".lic" ;; + esac + done + ;; + esac + checksrc + requirements source $package + components $package + package=$_components_ + + # check for some required commands + + must="$AR" + warn="$NM yacc bison" + test="$must $warn" + have= + IFS=: + set /$IFS$PATH + IFS=$ifs + shift + for t in $test + do if executable $t + then have="$have $t" + fi + done + for d + do for t in $test + do case " $have " in + *" $t "*) + ;; + *) if executable $d/$t + then have="$have $t" + fi + ;; + esac + done + done + case " $have " in + *" bison "*) ;; + *" yacc "*) have="$have bison" ;; + esac + case " $have " in + *" yacc "*) ;; + *" bison "*) have="$have yacc" ;; + esac + for t in $test + do case " $have " in + *" $t "*) + ;; + *) case " $must " in + *" $t "*) + echo "$command: $t: not found -- must be on PATH to $action" >&2 + exit 1 + ;; + *) echo "$command: warning: $t: not found -- some $action actions may fail" >&2 + ;; + esac + ;; + esac + done + + # verify the top view + + if test ! -d $PACKAGEROOT/src + then note no source packages to make + exit 0 + elif test ! -d $INSTALLROOT/src + then note initialize the $INSTALLROOT view + fi + for i in arch arch/$HOSTTYPE + do test -d $PACKAGEROOT/$i || $exec mkdir $PACKAGEROOT/$i || exit + done + for i in bin bin/$OK bin/$OK/lib fun include lib lib/package lib/package/gen src man man/man1 man/man3 man/man8 + do test -d $INSTALLROOT/$i || $exec mkdir $INSTALLROOT/$i || exit + done + make_recurse src + o= k= + for i in $makefiles + do case $o in + ?*) o="$o -o" k="$k|" ;; + esac + o="$o -name $i" + k="$k$i" + done + o="( $o ) -print" + for d in $package_src + do i=src/$d + if test -d $i + then test -d $INSTALLROOT/$i || $exec mkdir $INSTALLROOT/$i || exit + make_recurse $i + for j in `cd $i; find . $o 2>/dev/null | sed -e 's,^\./,,' -e '/\//!d' -e 's,/[^/]*$,,' | sort -u` + do case $j in + $k|$MAKESKIP) continue ;; + esac + test -d $INSTALLROOT/$i/$j || + $exec mkdir -p $INSTALLROOT/$i/$j || exit + done + fi + done + def= + for i in $lic + do test -f $i || continue + cmp -s $i $INSTALLROOT/$i 2>/dev/null || + $exec cp $PACKAGEROOT/$i $INSTALLROOT/$i + for j in `grep '^. .*\.def$' $i` + do case $j in + .) ;; + *) case " $def " in + *" $i "*) ;; + *) def="$def $i" ;; + esac + ;; + esac + done + done + for i in $def + do i=lib/package/$i + test -f $i || continue + cmp -s $i $INSTALLROOT/$i 2>/dev/null || + $exec cp $PACKAGEROOT/$i $INSTALLROOT/$i + done + + # check $CC and { ar cc ld ldd } intercepts + + h="${HOSTTYPE} ${HOSTTYPE}.*" + case $HOSTTYPE in + *.*) t=`echo $HOSTTYPE | sed 's/[.][^.]*//'` + h="$h $t" + ;; + *) t=$HOSTTYPE + ;; + esac + case $t in + *[0123456789]) + t=`echo $t | sed 's/[0123456789]*$//'` + h="$h $t" + ;; + esac + case $CC in + cc) c=cc + b=$INSTALLROOT/bin/$c + t=$INSTALLROOT/lib/package/gen/$c.tim + intercept=0 + for k in $h + do for s in $INITROOT/$c.$k + do test -x "$s" || continue + if cmp -s "$s" "$b" >/dev/null 2>&1 + then intercept=1 + break 2 + fi + case `ls -t "$t" "$b" "$s" 2>/dev/null` in + $t*) ;; + $b*) cc=$b + ;; + $s*) cd $INSTALLROOT/lib/package/gen + tmp=pkg$$ + eval '$'exec echo "'int main(){return 0;}' > $tmp.c" + if $exec $s -o $tmp.exe $tmp.c >/dev/null 2>&1 && + test -x $tmp.exe + then case $HOSTTYPE in + *.mips*)$s -version >/dev/null 2>&1 || s= ;; + esac + case $s in + ?*) $exec sed "s/^HOSTTYPE=.*/HOSTTYPE=$HOSTTYPE/" < "$s" > "$b" || exit + $exec chmod +x "$b" || exit + cc=$b + intercept=1 + note update $b + ;; + esac + fi + $exec rm -f $tmp.* + $exec touch "$t" + cd $PACKAGEROOT + ;; + esac + break 2 + done + done + case $intercept in + 1) c=ld + b=$INSTALLROOT/bin/$c + for k in $h + do for s in $INITROOT/$c.$k + do test -x "$s" || continue + case `ls -t "$b" "$s" 2>/dev/null` in + $b*) ;; + $s*) $exec cp "$s" "$b" + note update $b + ;; + esac + done + done + ;; + esac + ;; + esac + c=ldd + b=$INSTALLROOT/bin/$c + for t in $h + do s=$INITROOT/$c.$t + test -x "$s" || continue + onpath $c || + case `ls -t "$b" "$s" 2>/dev/null` in + $b*) ;; + $s*) $exec cp "$s" "$b" + note update $b + ;; + esac + done +# following code stubbed out just in case ar.ibm.risc is needed +# c=ar +# b=$INSTALLROOT/bin/$c +# for t in $h +# do s=$INITROOT/$c.$t +# test -x "$s" || continue +# onpath $c || +# case `ls -t "$b" "$s" 2>/dev/null` in +# $b*) ;; +# $s*) x=`$s -tv /foo/bar.a 2>&1 | egrep -i 'option|usage'` +# case $x in +# '') $exec cp "$s" "$b" +# note update $b +# ;; +# esac +# ;; +# esac +# done + case $cc in + /*) ;; + *) echo "$command: $CC: not found -- set CC=C-compiler" >&2 + exit 1 + ;; + esac + case $exec in + '') cd $INSTALLROOT/lib/package/gen + tmp=pkg$$ + echo 'int main(){return 0;}' > $tmp.c + if $CC -o $tmp.exe $tmp.c > /dev/null 2> $tmp.err && + test -x $tmp.exe + then : ok + else echo "$command: $CC: failed to compile this program:" >&2 + cat $tmp.c >&2 + if test -s $tmp.err + then cat $tmp.err >&2 + else echo "$command: $CC: not a C compiler" >&2 + fi + rm -f $tmp.* + exit 1 + fi + rm -f $tmp.* + cd $PACKAGEROOT + ;; + esac + + # remember the default $CC + + case $CC in + cc) ;; + *) if test -x $INSTALLROOT/bin/cc + then case `sed 1q $INSTALLROOT/bin/cc` in + ": $CC :") + CC=cc + export CC + ;; + *) assign="$assign CC=\"\$CC\"" + ;; + esac + else case $CROSS in + 1) assign="$assign CC=\"\$CC\"" + ;; + *) case $exec in + '') { + echo ": $CC :" + echo "$CC \"\$@\"" + } > $INSTALLROOT/bin/cc + chmod +x $INSTALLROOT/bin/cc + ;; + *) note generate a $INSTALLROOT/bin/cc wrapper for $CC + ;; + esac + CC=cc + export CC + ;; + esac + fi + ;; + esac + + # no $INITROOT means INIT already installed elsewhere + + if test -d $INITROOT + then + # update probe scripts + + for i in lib/probe lib/probe/C lib/probe/C/make + do test -d $INSTALLROOT/$i || $exec mkdir $INSTALLROOT/$i || exit + done + i=$INSTALLROOT/lib/probe/C/make/probe + j=$INITROOT/C+probe + k=$INITROOT/make.probe + case `ls -t $i $j $k 2>/dev/null` in + $i*) ;; + *) if test -f $j -a -f $k + then note update $i + shellmagic + case $exec in + '') { + case $SHELLMAGIC in + ?*) echo "$SHELLMAGIC" ;; + esac + cat $j $k + } > $i || exit + ;; + *) echo "{ +echo $SHELLMAGIC +cat $j $k +} > $i" + ;; + esac + $exec chmod +x $i || exit + fi + ;; + esac + fi + + # initialize a few mamake related commands + + checkaout mamake proto ratz release || exit + + # execrate if necessary + + if (execrate) >/dev/null 2>&1 + then execrate=execrate + $make cd $INSTALLROOT/bin + for i in chmod chgrp cmp cp ln mv rm + do if test ! -x $OK/$i -a -x /bin/$i.exe + then shellmagic + case $exec in + '') echo "$SHELLMAGIC"'execrate /bin/'$i' "$@"' > $OK/$i + chmod +x $OK/$i + ;; + *) $exec echo \'"$SHELLMAGIC"'execrate /bin/'$i' "$@"'\'' >' $OK/$i + $exec chmod +x $OK/$i + ;; + esac + fi + done + PATH=$INSTALLROOT/bin/$OK:$PATH + export PATH + else execrate= + fi + case $action in + view) exit 0 ;; + esac + + # all work under $INSTALLROOT/src + + $make cd $INSTALLROOT/src + + # record the build host name + + case $noexec in + '') hostinfo name + echo "$_hostinfo_" | sed 's,\..*,,' > $PACKAGEBIN/gen/host + ;; + esac + + # make in parallel if possible + + case $NPROC in + '') hostinfo cpu + case $_hostinfo_ in + 0|1) ;; + *) NPROC=$_hostinfo_ + $show NPROC=$NPROC + $show export NPROC + export NPROC + ;; + esac + ;; + esac + + # separate flags from target list + + case $target in + *-*) a= + for t in $target + do case $t in + -[eiknFKNV]*|--*-symbols) + makeflags="$makeflags $t" + ;; + -*) nmakeflags="$nmakeflags $t" + ;; + *) a="$a $t" + ;; + esac + done + target=$a + ;; + esac + + # generate nmake first if possible + + if executable ! $NMAKE && test -d $PACKAGEROOT/src/cmd/nmake + then if nonmake $MAKE + then note make $NMAKE with mamake + c=$CC + a=$assign + case $HOSTTYPE in + win32*|cygwin*) + CC="$CC -D_BLD_STATIC" + accept="libast" + case $assign in + *' CC='*) ;; + *) assign="$assign CC=\"\$CC\"" ;; + esac + ;; + *) accept=nmake + ;; + esac + eval capture mamake \$makeflags \$nmakeflags \$noexec install nmake $assign + assign=$a + CC=$c + case $make$noexec in + '') if executable ! $NMAKE + then echo "$command: $action: errors making $NMAKE" >&2 + exit 1 + fi + ;; + *) make=echo + ;; + esac + if test '' != "$PROTOROOT" + then if (vpath $INSTALLROOT - $PROTOROOT - $INSTALLROOT $PACKAGEROOT) >/dev/null 2>&1 && + vpath $INSTALLROOT - $PROTOROOT - $INSTALLROOT $PACKAGEROOT + then $show vpath $INSTALLROOT $PACKAGEROOT $USER_VPATH_CHAIN + else VPATH=$INSTALLROOT:$PACKAGEROOT$USER_VPATH + $show VPATH=$VPATH + export VPATH + fi + fi + note believe generated files for $accept + eval capture \$NMAKE \$makeflags \$nmakeflags \$noexec recurse believe \$nmakesep $accept $assign + $exec touch $INSTALLROOT/bin/.paths + note make the remaining targets with $NMAKE + else eval capture $MAKE \$makeflags \$nmakeflags \$noexec install nmake $assign + case $make$noexec in + '') if executable ! $NMAKE + then echo "$command: $action: errors making $NMAKE" >&2 + exit 1 + fi + ;; + *) make=echo + ;; + esac + fi + fi + + # generate ksh next if possible + + if nonmake $MAKE + then : no need to generate ksh next -- it could be the only package + elif test "$KEEP_SHELL" != 1 -a -d $PACKAGEROOT/src/cmd/ksh93 && executable ! $KSH + then eval capture nmake $nmakeflags \$makeflags \$noexec install ksh93 $assign + case $make$noexec in + '') if executable ! $KSH + then echo "$command: $action: errors making $KSH" >&2 + exit 1 + fi + ;; + *) make=echo + ;; + esac + fi + + # mamprobe data should have been generated by this point + + case $exec in + '') if test ! -f $INSTALLROOT/bin/.paths -o -w $INSTALLROOT/bin/.paths + then nl=" +" + o=`cat $INSTALLROOT/bin/.paths 2>/dev/null` + v= + n= + case $nl$o in + *${nl}FPATH=*|*#FPATH=*|*[Nn][Oo]FPATH=*) + ;; + *) case $n in + '') ;; + *) n="$n$nl" v="$v|" ;; + esac + n="${n}FPATH=../fun" + v="${v}FPATH" + ;; + esac + case $nl$o in + *${nl}BUILTIN_LIB=*|*#BUILTIN_LIB=*|*[Nn][Oo]BUILTIN_LIB=*) + ;; + *) case $n in + '') ;; + *) n="$n$nl" v="$v|" ;; + esac + if grep '^setv mam_cc_DIALECT .* EXPORT=[AD]LL' $INSTALLROOT/lib/probe/C/mam/* >/dev/null 2>&1 + then x= + else x='no' + fi + n="${n}${x}BUILTIN_LIB=cmd" + v="${v}BUILTIN_LIB" + ;; + esac + case $n in + ?*) case $o in + ?*) o=`egrep -v "($v)=" $INSTALLROOT/bin/.paths`$nl ;; + esac + echo "# use { # no NO } prefix instead of XX to permanently disable #$nl$o$n" > $INSTALLROOT/bin/.paths + ;; + esac + fi + ;; + esac + + # run from separate copies since nmake and ksh may be rebuilt + + case $EXECROOT in + $INSTALLROOT) + $make cd $INSTALLROOT/bin + if executable /bin/cp + then cp=/bin/cp + else cp=cp + fi + if executable /bin/mv + then mv=/bin/mv + else mv=mv + fi + if executable /bin/rm + then rm=/bin/rm + else rm=rm + fi + for i in \ + ksh nmake tee cp ln mv rm \ + *ast*.dll *cmd*.dll *dll*.dll *shell*.dll + do executable $i && { + cmp -s $i $OK/$i 2>/dev/null || { + test -f $OK/$i && + $exec $execrate $rm $OK/$i </dev/null + test -f $OK/$i && + $exec $execrate $mv $OK/$i $OK/$i.old </dev/null + test -f $OK/$i && + case $exec:$i in + :nmake|:ksh) + echo "$command: $OK/$i: cannot update [may be in use by a running process] remove manually and try again" >&2 + exit 1 + ;; + esac + $exec $execrate $cp $i $OK/$i + } + } + done + if test -f ../lib/make/makerules.mo + then cmp -s ../lib/make/makerules.mo $OK/lib/makerules.mo || + $exec $execrate $cp -p ../lib/make/makerules.mo $OK/lib/makerules.mo || + $exec $execrate $cp ../lib/make/makerules.mo $OK/lib/makerules.mo + fi + if executable $OK/nmake + then MAKE="$INSTALLROOT/bin/$OK/nmake LOCALRULESPATH=$INSTALLROOT/bin/$OK/lib" + fi + if executable $OK/tee + then TEE=$INSTALLROOT/bin/$OK/tee + fi + if test "$KEEP_SHELL" != 1 && executable $OK/ksh + then SHELL=$INSTALLROOT/bin/$OK/ksh + export SHELL + COSHELL=$SHELL + export COSHELL + fi + case :$PATH: in + *:$INSTALLROOT/bin/$OK:*) + ;; + *) PATH=$INSTALLROOT/bin/$OK:$PATH + export PATH + ;; + esac + $make cd $INSTALLROOT/src + ;; + esac + + # fall back to mamake if nmake not found or too old + + if nonmake $MAKE + then note make with mamake + case $target in + '') target="install" ;; + esac + eval capture mamake \$makeflags \$noexec \$target $assign + else case $target in + '') target="install cc-" ;; + esac + eval capture \$MAKE \$makeflags \$nmakeflags \$noexec recurse \$target \$nmakesep \$package $assign + fi + ;; + +read) case ${PWD:-`pwd`} in + $PACKAGEROOT) + ;; + *) echo "$command: must be in package root directory" >&2 + exit 1 + ;; + esac + PAX= + if onpath pax + then case `$_onpath_ -rw --?meter 2>&1` in + *--meter*) PAX=pax ;; + esac + fi + code=0 + i= + x= + remove= + touch= + set '' $target + case $2 in + lcl|tgz)tgz=$2 + shift 2 + target=$* + ;; + *) tgz=tgz + ;; + esac + set '' $package $target + case $# in + 1) verbose=: + set '' `ls lib/package/$tgz/*?[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.]* 2>/dev/null` + ;; + *) verbose= + ;; + esac + shift + files= + for f + do if test -f "$f" + then : ok + elif test -f "lib/package/$tgz/$f" + then f=lib/package/$tgz/$f + else set '' `ls -r ${f}[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.]* 2>/dev/null` + if test '' != "$2" -a -f "$2" + then f=$2 + else set '' `ls -r lib/package/$tgz/${f}[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.]* 2>/dev/null` + if test '' != "$2" -a -f "$2" + then f=$2 + else echo "$command: $f: package archive not found" >&2 + continue + fi + fi + fi + files="$files $f" + done + case $files in + '') echo "$command: lib/package/$tgz: no package archives" >&2 + exit 1 + ;; + esac + set '' `ls -r $files 2>/dev/null` + shift + f1= f2= f3= f4= + for f + do case $f in + ratz.*|*/ratz.*) + f1="$f1 $f" + ;; + INIT.*|*/INIT.*) + f2="$f2 $f" + ;; + INIT*|*/INIT*) + f3="$f3 $f" + ;; + *) f4="$f4 $f" + ;; + esac + done + gen= + set '' $f1 $f2 $f3 $f4 + while : + do shift + case $# in + 0) break ;; + esac + f=$1 + case $f in + *.gz) : standalone packages unbundled manually + continue + ;; + *.md5) : tarball checksum + continue + ;; + *?[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.]*) + ;; + *) echo "$command: $f: not a package archive" >&2 + code=1 + continue + ;; + esac + case $f in + */*) eval `echo "$f" | sed -e 's,\(.*/\)\(.*\),d=\1 a=\2,'` ;; + *) d= a=$f ;; + esac + # f:file d:dir a:base p:package v:version r:release t:type + eval `echo "$a" | sed -e 's,\.c$,,' -e 's,\.gz$,,' -e 's,\.exe$,,' -e 's,\.tgz$,,' -e 's,\([^_.]*\)[_.]\([0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]\)[_.]\([0123456789][0123456789][0123456789][0123456789][^_.]*\)[_.]*\(.*\),p=\1 v=\2 r=\3 t=\4,' -e 's,\([^_.]*\)[_.]\([0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]\)[_.]*\(.*\),p=\1 v=\2 r=base t=\3,'` + case $r in + base) y=$p.base ;; + *) y=$p.delta ;; + esac + case " $x " in + *" $y "*) + continue + ;; + esac + case $t in + '') w=$PACKAGESRC + q= + Q= + m= + ;; + *) w=$PACKAGEROOT/arch/$t/lib/package + q=".$t" + Q="_$t" + m="[_.]$t" + ;; + esac + u=$d$p$q.tim + if test -s "$u" + then continue + else case $force in + 0) case `ls -t "$f" "$u" 2>/dev/null` in + "$u"*) case $verbose in + 1) note $p already read ;; + esac + continue + ;; + esac + ;; + esac + fi + case $p in + INIT) if test -f $PACKAGEROOT/bin/package + then $exec mv $PACKAGEROOT/bin/package $PACKAGEROOT/bin/package.old + fi + ;; + esac + z= + case $r in + base) # base archive + if test ratz = "$p" + then # ratz packages are not archives + case $t in + '') for i in src src/cmd src/cmd/INIT + do test -d $PACKAGEROOT/$i || $exec mkdir $PACKAGEROOT/$i || exit + done + $exec cp $f $PACKAGEROOT/src/cmd/INIT/$p.c + ;; + *) for i in arch arch/$t arch/$t/bin + do test -d $PACKAGEROOT/$i || $exec mkdir $PACKAGEROOT/$i || exit + done + $exec cp $f $PACKAGEROOT/arch/$t/bin/$p && + $exec chmod +x $PACKAGEROOT/arch/$t/bin/$p + ;; + esac + elif test "" != "$PAX" + then $exec pax -L --from=ascii --local -m -ps -rvf "$f" || { + code=1 + continue + } + else if onpath gunzip && onpath $TAR && isascii + then case $TARPROBE in + ?*) for i in $TARPROBE + do if $TAR ${i}f - /dev/null > /dev/null 2>&1 + then TARFLAGS=$TARFLAGS$i + fi + done + TARPROBE= + ;; + esac + if gunzip -l < "$f" > /dev/null 2>&1 + then case $exec in + '') $exec gunzip < "$f" | $TAR ${TARFLAGS}f - ;; + *) $exec "gunzip < $f | $TAR ${TARFLAGS}f -" ;; + esac || { + code=1 + continue + } + else $exec $TAR ${TARFLAGS}f "$f" || { + code=1 + continue + } + fi + else checkaout ratz && onpath ratz || { + code=1 + continue + } + RATZ=$_onpath_ + case $exec in + '') echo $f: + $exec $RATZ -lm < "$f" + ;; + *) $exec "$RATZ -lm < $f" + ;; + esac || { + code=1 + continue + } + fi + if test -f $PACKAGEBIN/gen/$p.sum + then while read md5 mode usr grp file + do case $file in + -*) file=./$file ;; + esac + case $mode in + [01234567][01234567][01234567][01234567]) + case $grp in + -) ;; + *) $exec chgrp $grp "$file" ;; + esac + case $usr in + -) ;; + *) $exec chown $usr "$file" ;; + esac + $exec chmod $mode "$file" + ;; + esac + done < $PACKAGEBIN/gen/$p.sum + fi + fi + ;; + *) # delta archive + test "" != "$PAX" || { + echo "$command: $f: pax required to read delta archive" >&2 + code=1 + continue + } + case `echo "$v: +$r:" | sort` in + $r:*) y=$p.base + b=${d}${p}_${r}${Q}.tgz + test -f "$b" || b=${d}${p}.${r}${q}.tgz + test -f "$b" || { + case " $gen " in + *" $b "*) + ;; + *) case $# in + 1) echo "$command: $f: base archive $b required to read delta" >&2 + code=1 + ;; + *) shift + y=$1 + shift + set '' $y $f "$@" + esac + continue + ;; + esac + } + # -m with delta bug fixed 2005-02-08 + $exec pax -L --from=ascii --local -ps -rvf "$f" -z "$b" || { + code=1 + continue + } + note $f: generate new base $d$p.$v$q.tgz + $exec pax -rf "$f" -z "$b" -wf $d$p.$v$q.tgz -x tgz || { + code=1 + continue + } + case $exec in + '') echo $p $v $v 1 > $w/gen/$p.ver + ;; + *) z=$d${p}[_.]$v$q.tgz + $exec "echo $p $v $v 1 > $w/gen/$p.ver" + gen="$gen $d$p.$v$q.tgz" + ;; + esac + case " $remove " in + *" $f "*) ;; + *) remove="$remove $f" ;; + esac + ;; + *) b=${d}${p}_${v}${Q}.tgz + test -f "$b" || b=${d}${p}.${v}${q}.tgz + test -f "$b" || { + case " $gen " in + *" $b "*) + ;; + *) case $# in + 1) echo "$command: $f: base archive $b required to read delta" >&2 + code=1 + ;; + *) shift + y=$1 + shift + set '' $y $f "$@" + esac + continue + ;; + esac + } + # -m with delta bug fixed 2005-02-08 + $exec pax -L --from=ascii --local -ps -rvf "$f" -z "$b" || { + code=1 + continue + } + ;; + esac + ;; + *) echo "$command: $f: unknown archive type" >&2 + code=1 + continue + ;; + esac + + # check for ini files + + if executable $w/$p.ini + then $exec $w/$p.ini read || { + code=1 + continue + } + fi + + # add to the obsolete list + + k= + for i in `ls $d$p[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.]????$m* $z 2>/dev/null` + do case $i in + *.md5) continue + ;; + $d${p}[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789][_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]$m*) + ;; + $d${p}[_.][0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]$m*) + continue + ;; + esac + case $k in + ?*) case " $remove " in + *" $k "*) ;; + *) remove="$remove $k" ;; + esac + ;; + esac + k=$i + done + x="$x $y" + case " $touch " in + *" $u "*) ;; + *) touch="$touch $u" ;; + esac + done + if test ! -f $PACKAGEROOT/bin/package -a -f $PACKAGEROOT/bin/package.old + then $exec cp $PACKAGEROOT/bin/package.old $PACKAGEROOT/bin/package + fi + + # drop obsolete archives + + case $remove in + ?*) $exec rm -f $remove ;; + esac + + # mark the updated archives + + case $touch in + ?*) sleep 1; $exec touch $touch ;; + esac + + # check the requirements + + case $code$exec in + 0) requirements - $x ;; + esac + exit $code + ;; + +regress)if test ! -d $PACKAGEBIN/gen + then echo "$command: 'package make' and 'package test' required for regression" >&2 + exit 1 + fi + dir=$PACKAGEBIN/gen + cd $dir + for s in out old + do case `ls -t regress.$s test.$s 2>/dev/null` in + regress*) + ;; + test*) if test -f regress.$s + then $exec mv regress.$s regress.old + fi + case $exec in + '') egrep -i '\*\*\*|FAIL|^TEST.* [123456789][0123456789]* error|core.*dump' test.$s | + sed -e '/\*\*\* [0123456789]/d' \ + -e '/^TEST.\//s,/[^ ]*/,,' \ + -e 's,[ ][ ]*$,,' \ + -e 's/[0123456789][0123456789]*:* \([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789 ]*([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789 ]*[Cc][Oo][Rr][Ee][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789 ]*)\)/\1/' \ + -e 's/\.sh failed at .* with /.sh failed /' \ + > regress.$s + ;; + *) $exec filter test failures from $dir/test.$s to $dir/regress.$s + ;; + esac + ;; + esac + done + if test -f regress.out -a -f regress.old + then $exec diff -b regress.out regress.old + else echo "$command: at least 2 test runs required for regression" >&2 + exit 1 + fi + ;; + +release)count= lo= hi= + checksrc + checkaout release || exit + requirements source $package + components $package + package=$_components_ + set '' $target + shift + case $# in + 0) ;; + *) case $1 in + -|[0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]|[0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]) + case $1 in + -) lo= release= ;; + *) lo=$1 release="-f $1" ;; + esac + shift + case $1 in + -|[0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]|[0123456789][0123456789][0123456789][0123456789]-[0123456789][0123456789]-[0123456789][0123456789]) + case $1 in + -) hi= ;; + *) hi=$1 release="$release -t $1" ;; + esac + shift + ;; + esac + ;; + [0123456789]|[0123456789][0123456789]|[0123456789][0123456789][0123456789]|[0123456789][0123456789][0123456789][0123456789]|[0123456789][0123456789][0123456789][0123456789][0123456789]*) + count=$1 + release="-r $count" + shift + ;; + esac + ;; + esac + case $# in + 0) case $package in + '') package=* ;; + esac + ;; + *) case $package in + '') package=$* + ;; + *) echo $command: $*: lo-date hi-date arguments expected >&2 + exit 1 + ;; + esac + ;; + esac + echo + case $count:$lo:$hi in + ::) echo "All recorded changes follow." ;; + 1::) echo "Changes since the last release follow." ;; + ?*::) echo "Changes since the last $count releases follow." ;; + 1:?*:) echo "Changes since $lo or the last release follow." ;; + *:?*:*) echo "Changes since $lo follow." ;; + *::?*) echo "Changes before $hi follow." ;; + *) echo "Changes between $lo and $hi follow." ;; + esac + x= + for r in $INSTALLROOT $PACKAGEROOT + do for s in $package_src + do d=$r/src/$s + if test -d $d + then cd $d + for i in $package + do if test -h $i 2>/dev/null + then continue + fi + case " $x " in + *" $i "*) continue ;; + esac + for f in RELEASE CHANGES ChangeLog + do if test -f $i/$f + then $exec release $release $i/$f + x="$x $i" + for f in $i/*/$f + do if test -f $f + then $exec release $release $f + fi + done + break + fi + done + done + fi + done + done + ;; + +remove) echo "$command: $action: not implemented yet" >&2 + exit 1 + ;; + +results)set '' $target + shift + def=make + dir=$PACKAGEBIN/gen + case $verbose in + 0) filter=yes ;; + *) filter=cat ;; + esac + path=0 + suf=out + on= + while : + do case $# in + 0) break ;; + esac + case $1 in + --) shift + break + ;; + admin) dir=$PACKAGESRC/admin + ;; + error*|fail*) + filter=errors + ;; + make|test|view|write) + def=$1 + case $filter:$1:$SHELL in + errors:*:*) ;; + *:test:*/ksh*) filter=rt ;; + esac + ;; + old) suf=old + ;; + on) case $# in + 1) echo $command: $action: $1: host pattern argument expected >&2 + exit 1 + ;; + esac + shift + case $on in + ?*) on="$on|" ;; + esac + on="$on$1" + ;; + path) path=1 + ;; + test) def=test + filter=rt + ;; + *) break + ;; + esac + shift + done + case $dir in + */admin)case $on in + '') on="*" ;; + *) on="@($on)" ;; + esac + def=$def.log/$on + ;; + esac + case $# in + 0) set "$def" ;; + esac + m= + t= + for i + do k=0 + eval set '""' $i - $i.$suf - $dir/$i - $dir/$i.$suf - + shift + for j + do case $j in + -) case $k in + 1) continue 2 ;; + esac + ;; + *) if test -f $j + then k=1 + case /$j in + */test.*) t="$t $j" ;; + *) m="$m $j" ;; + esac + fi + ;; + esac + done + echo "$command: $i action output not found" >&2 + exit 1 + done + sep= + case $t in + ?*) case $path in + 0) for j in $t + do echo "$sep==> $j <==" + sep=$nl + case $filter in + cat) $exec cat $j + ;; + errors) $exec egrep -i '\*\*\*|FAIL[ES]|^TEST.* [123456789][0123456789]* error|core.*dump' $j | sed -e '/^TEST.\//s,/[^ ]*/,,' + ;; + rt) $exec rt - $j + ;; + *) $exec egrep -i '^TEST|FAIL' $j + ;; + esac + done + ;; + 1) echo $t + ;; + esac + ;; + esac + case $m in + ?*) case $path in + 0) case $filter in + cat) cat $m + ;; + *) if test -f $HOME/.pkgresults + then i="`cat $HOME/.pkgresults`" + case $i in + '|'*) ;; + *) i="|$i" ;; + esac + else i= + fi + for j in $m + do echo "$sep==> $j <==" + sep=$nl + case $filter in + errors) $exeg egrep '^pax:|\*\*\*' $j + ;; + *) $exec egrep -iv '^($||[\+\[]|cc[^-:]|kill |make.*(file system time|has been replaced)|so|[0123456789]+ error|uncrate |[0123456789]+ block|ar: creat|iffe: test: |conf: (check|generate|test)|[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_][abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789]*=|gsf@research|ar:.*warning|cpio:|ld:.*(duplicate symbol|to obtain more information)|[0123456789]*$|(checking|creating|touch) [/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789])| obsolete predefined symbol | is (almost always misused|dangerous|deprecated|not implemented)| trigraph| assigned to | cast .* different size| integer overflow .*<<| optimization may be attained | passed as |::__builtin|pragma.*prototyped|^creating.*\.a$|warning.*not optimized|exceeds size thresh|ld:.*preempts|is unchanged|with value >=|(-l|lib)\*|/(ast|sys)/(dir|limits|param|stropts)\.h.*redefined|usage|base registers|`\.\.\.` obsolete'"$i" $j | + $exec grep : + ;; + esac + done + ;; + esac + ;; + 1) echo $m + ;; + esac + esac + ;; + +test) requirements source $package + components $package + package=$_components_ + case $only in + 0) only= ;; + 1) only=--recurse=only ;; + esac + + # must have nmake + + if nonmake $MAKE + then echo $command: $action: must have $MAKE to test >&2 + exit 1 + fi + + # all work under $INSTALLROOT/src + + $make cd $INSTALLROOT/src + + # disable core dumps (could be disasterous over nfs) + + (ulimit -c 0) > /dev/null 2>&1 && ulimit -c 0 + + # do the tests + + eval capture \$MAKE \$makeflags \$noexec \$only recurse test \$target \$nmakesep \$package $assign + ;; + +update) # download the latest release.version for selected packages + + # all work in $PACKAGEROOT/lib/package/tgz + + if test ! -d $PACKAGEROOT/lib/package/tgz + then $exec mkdir -p $PACKAGEROOT/lib/package/tgz || exit + $exec cd $PACKAGEROOT/lib/package/tgz + else cd $PACKAGEROOT/lib/package/tgz + fi + + # get the architectures, update query url, and packages + + set '' $args + op=update + tgz=tgz + source= + binary= + setup= + types= + url= + urlfile=$default_url + while : + do shift + case $# in + 0) break ;; + esac + case $1 in + --) shift + break + ;; + beta) op=beta + tgz=beta + ;; + binary) binary=1 + ;; + setup) setup=1 + ;; + source) source=1 + ;; + *://*) url=$1 + shift + break + ;; + *.url) urlfile=$1 + if test ! -s $urlfile + then echo $command: $urlfile: not found >&2; exit 1 + fi + break + ;; + $all_types) + binary=1 + types="$types $1" + ;; + *) break + ;; + esac + done + case $source:$binary in + :) source=1 binary=1 + ;; + :1) case $types in + '') types=$HOSTTYPE ;; + esac + ;; + esac + case $url in + '') case $urlfile in + $default_url) + if test ! -s $urlfile + then echo $command: url argument expected >&2; exit 1 + fi + ;; + *) default_url= + ;; + esac + url= + if grep '^url=' $urlfile >/dev/null + then a=$authorize + p=$password + case $urlfile in + */*) ;; + *) urlfile=./$urlfile ;; + esac + . $urlfile + case $a:$p in + $authorize:$password) + default_url= + ;; + *) case $a in + ?*) authorize=$a ;; + esac + case $p in + ?*) password=$p ;; + esac + ;; + esac + else url=`cat $urlfile` + fi + ;; + esac + case $exec in + ?*) default_url= ;; + esac + + # get the update list + + eval `echo $url | sed 's,\(.*\)://\([^/]*\)/\(.*\),prot=\"\1\" host=\"\2\" dir=\"\3\",'` + get $host $dir/$op.html + + # get/check the package names + + case " $* " in + *" - "*)case $source in + 1) source_packages=$* ;; + *) source_packages= ;; + esac + case $binary in + 1) binary_packages=$* ;; + *) binary_packages= ;; + esac + package_hit=$* + ;; + " ") nl=" +" + case $source in + 1) p= + for f in `ls *.????-??-??.* 2>/dev/null` + do case $f in + *.????-??-??.????-??-??.*.*) + ;; + *.????-??-??.????-??-??.*) + p=$p$nl$f + ;; + *.????-??-??.*.*) + ;; + *.????-??-??.*) + p=$p$nl$f + ;; + esac + done + set '' `echo "$p" | sed 's,\..*,,' | sort -u` + shift + source_packages=$* + ;; + *) source_packages= + ;; + esac + case $binary in + 1) p= + for f in `ls *.????-??-??.* 2>/dev/null` + do case $f in + *.????-??-??.????-??-??.*.*) + p=$p$nl$f + ;; + *.????-??-??.????-??-??.*) + ;; + *.????-??-??.*.*) + p=$p$nl$f + ;; + *.????-??-??.*) + ;; + esac + done + set '' `echo "$p" | sed 's,\..*,,' | sort -u` + shift + binary_packages=$* + ;; + *) binary_packages= + ;; + esac + package_hit="$source_packages $binary_packages" + ;; + *) case $source in + 1) source_packages=$* ;; + *) source_packages= ;; + esac + case $binary in + 1) binary_packages=$* ;; + *) binary_packages= ;; + esac + package_hit= + ;; + esac + + # get the latest updates + + types_test= + types_local= + dir=$dir/$tgz + case $default_url in + ?*) echo "url='$url' authorize='$authorize' password='$password'" > $default_url + case $authorize in + ?*) chmod go-rwx $default_url ;; + esac + ;; + esac + echo "$got" > got.tmp + case $only in + 0) exec < got.tmp + covered= + while read name suffix type base base_size delta delta_size sync sync_size requires covers base_sum delta_sum sync_sum comment + do case $requires in + ''|-*) continue ;; + esac + IFS=: + set '' $requires + IFS=$ifs + case $type in + -) case " $source_packages " in + *" $name "*|*" - "*) + for name + do case " $source_packages " in + *" $name "*) + ;; + *) source_packages="$source_packages $name" + covered=$covered:$covers + ;; + esac + done + ;; + esac + ;; + *) case " $binary_packages " in + *" $name "*|*" - "*) + for name + do case " $binary_packages " in + *" $name "*) + ;; + *) binary_packages="$binary_packages $name" + covered=$covered:$covers + ;; + esac + done + ;; + esac + ;; + esac + done + case $covered in + ?*) x=$source_packages + source_packages= + for name in $x + do case :$covered: in + *:$name:*) ;; + *) source_packages="$source_packages $name" ;; + esac + done + x=$binary_packages + binary_packages= + for name in $x + do case :$covered: in + *:$name:*) ;; + *) binary_packages="$binary_packages $name" ;; + esac + done + ;; + esac + ;; + esac + checksum= + for i in $checksum_commands + do case `( $i ) < /dev/null 2> /dev/null` in + ${checksum_empty}|${checksum_empty}[\ \ ]*) + checksum=$i + break + ;; + esac + done + case $checksum in + '') echo $command: warning: '{' $checksum_commands '}' command not found -- only download sizes will be checked >&2 ;; + esac + exec < got.tmp + while read name suffix type base base_size delta delta_size sync sync_size requires covers base_sum delta_sum sync_sum comment + do case $verbose in + 1) case $type in + -) i= ;; + *) i=.$type ;; + esac + j="$name.$base$i.$suffix" + case $delta in + -) j="$j -" ;; + *) j="$j $name.$base.$delta$i.$suffix" ;; + esac + case $sync in + -) j="$j -" ;; + *) j="$j $name.$base.$sync$i.$suffix" ;; + esac + echo $command: $j $base_size:$base_sum $delta_size:$delta_sum $sync_size:$sync_sum $requires >&2 + esac + case " $package_hit " in + *" $name "*|*" - "*) + ;; + *) package_hit="$package_hit $name" + ;; + esac + case $type in + -) case " $source_packages " in + *" $name "*|*" - "*) + if test -s $name.tim + then continue + fi + lcl=$name.$base.$suffix + if test -f $lcl + then case $checksum:$base_sum in + :*|*:-) size=`wc -c < $lcl | sed 's, ,,g'` sum=$base_sum ;; + *) size=$base_size sum=`$checksum < $lcl | sed -e 's,^[ ][ ]*,,' -e 's,[ ].*,,'` ;; + esac + else size=X sum=X + fi + if test "0" != "$force" -a "X-" = "X$delta" -o "$base_size" != "$size" -o "$base_sum" != "$sum" + then rmt= + case $sync:$sync_size in + -*|*[-:]) + ;; + *) lcl=$name.$base.$sync.$suffix + if test -f $lcl + then rmt=1 + get $host $dir $lcl $sync_size $sync_sum + fi + ;; + esac + case $base:$base_size in + -*|*[-:]) + ;; + *) case $rmt in + '') lcl=$name.$base.$suffix + get $host $dir $lcl $base_size $base_sum + ;; + esac + ;; + esac + fi + case $delta:$delta_size in + -*|*[-:]) + ;; + *) lcl=$name.$delta.$base.$suffix + if test -f $lcl + then case $checksum:$delta_sum in + :*|*:-) size=`wc -c < $lcl | sed 's, ,,g'` sum=$delta_sum ;; + *) size=$base_size sum=`$checksum < $lcl | sed -e 's,^[ ][ ]*,,' -e 's,[ ].*,,'` ;; + esac + else size=X sum=X + fi + if test "0" != "$force" -o "$delta_size" != "$size" -o "$delta_sum" != "$sum" + then get $host $dir $lcl $delta_size $delta_sum + fi + ;; + esac + ;; + esac + ;; + *) case " $binary_packages " in + *" $name "*|*" - "*) + if test -s $name.$type.tim + then continue + fi + case " $types " in + *" - "*);; + " ") case " $types_test " in + *" $type "*) + ;; + *) types_test="$types_test $type" + for i in *.????-??-??.$type.* *.????-??-??.????-??-??.$type.* + do if test -f $i + then types_local="$types_local $type" + fi + break + done + ;; + esac + case " $types_local " in + *" $type "*) + ;; + *) continue + ;; + esac + ;; + *) case " $types " in + *" $type "*) + ;; + *) continue + ;; + esac + ;; + esac + lcl=$name.$base.$type.$suffix + if test -f $lcl + then case $checksum:$base_sum in + :*|*:-) size=`wc -c < $lcl | sed 's, ,,g'` sum=$base_sum ;; + *) size=$base_size sum=`$checksum < $lcl | sed -e 's,^[ ][ ]*,,' -e 's,[ ].*,,'` ;; + esac + else size=X sum=X + fi + if test "0" != "$force" -a "X-" = "X$delta" -o "$base_size" != "$size" -o "$base_sum" != "$sum" + then rmt= + case $sync:$sync_size in + -*|*[-:]) + ;; + *) lcl=$name.$base.$sync.$type.$suffix + if test -f $lcl + then rmt=1 + get $host $dir $lcl $sync_size $sync_sum + fi + ;; + esac + case $base:$base_size in + -*|*[-:]) + ;; + *) case $rmt in + '') lcl=$name.$base.$type.$suffix + get $host $dir $lcl $base_size $base_sum + ;; + esac + ;; + esac + fi + case $delta:$delta_size in + -*|*[-:]) + ;; + *) lcl=$name.$delta.$base.$type.$suffix + if test -f $lcl + then sum=`$checksum < $lcl | sed -e 's,^[ ][ ]*,,' -e 's,[ ].*,,'` + else sum=X + fi + if test -f $lcl + then case $checksum:$delta_sum in + :*|*:-) size=`wc -c < $lcl | sed 's, ,,g'` sum=$delta_sum ;; + *) size=$base_size sum=`$checksum < $lcl | sed -e 's,^[ ][ ]*,,' -e 's,[ ].*,,'` ;; + esac + else size=X sum=X + fi + if test "0" != "$force" -o "$delta_size" != "$size" -o "$delta_sum" != "$sum" + then get $host $dir $lcl $delta_size $delta_sum + fi + ;; + esac + ;; + esac + ;; + esac + done + closure= + for name in $source_packages $binary_packages + do case $name in + -) ;; + *) case " $package_hit " in + *" $name "*) + case $setup in + 1) case " $closure " in + *" $name "*) + ;; + *) closure="$closure $name" + ;; + esac + ;; + esac + ;; + *) echo $command: $name: unknown package >&2 + ;; + esac + ;; + esac + done + exec <&- + rm -f got.tmp + case $closure in + ?*) echo $closure ;; + esac + ;; + +use) # finalize the environment + + x=:.. + for d in `( cd $PACKAGEROOT; ls src/*/Makefile src/*/Nmakefile 2>/dev/null | sed 's,/[^/]*$,,' | sort -u )` + do x=$x:$INSTALLROOT/$d + done + x=$x:$INSTALLROOT + case $CDPATH: in + $x:*) ;; + *) CDPATH=$x:$CDPATH + $show CDPATH=$CDPATH + $show export CDPATH + export CDPATH + ;; + esac + P=$PACKAGEROOT + $show P=$P + $show export P + export P + A=$INSTALLROOT + $show A=$A + $show export A + export A + case $NPROC in + '') hostinfo cpu + case $_hostinfo_ in + 0|1) ;; + *) NPROC=$_hostinfo_ + $show NPROC=$NPROC + $show export NPROC + export NPROC + ;; + esac + ;; + esac + eval PACKAGE_USE=$package_use + export PACKAGE_USE + + # run the command + + case $run in + '') case $show in + ':') $exec exec $SHELL ;; + esac + ;; + *) $exec exec $SHELL -c "$run" + ;; + esac + ;; + +verify) cd $PACKAGEROOT + requirements binary $package + if executable ! $SUM + then echo "$command: $action: $SUM command required" >&2 + exit 1 + fi + case $target in + '') cd arch + set '' * + shift + target=$* + cd .. + ;; + esac + code=0 + for a in $target + do case $package in + '') set '' arch/$a/lib/package/gen/*.sum + shift + if test -f $1 + then for i + do package_verify $i || code=1 + done + else echo "$command: warning: $a: no binary packages" >&2 + fi + ;; + *) for i in $package + do if test -f arch/$a/lib/package/gen/$i.sum + then package_verify arch/$a/lib/package/gen/$i.sum || code=1 + else echo "$command: warning: $a: no binary package for $i" >&2 + fi + done + ;; + esac + done + exit $code + ;; + +write) set '' $target + shift + action= + list= + qualifier= + while : + do case $1 in + base|closure|delta|exp|lcl|pkg|rpm|tgz) + qualifier="$qualifier $1" + ;; + binary) action=$1 + type=$HOSTTYPE + eval list=$PACKAGESRC/tgz/$admin_list + ;; + cyg) qualifier="$qualifier $1" + assign="$assign closure=1" + only=1 + ;; + runtime|source) + action=$1 + ;; + tst) qualifier="$qualifier tgz" + assign="$assign copyright=0 'PACKAGEDIR=\$(PACKAGESRC)/tst'" + ;; + nocopyright) + assign="$assign copyright=0" + ;; + *) break + ;; + esac + shift + done + case $action in + '') echo "$command: binary or source operand expected" >&2 + exit 1 + ;; + esac + set '' "$@" $package + shift + case $only in + 0) set '' `order "$@"` + shift + ;; + esac + case $# in + 0) echo "$command: at least one package name expected" >&2 + exit 1 + ;; + esac + if nonmake $MAKE + then echo "$command: must have $MAKE to generate archives" >&2 + exit 1 + fi + + # all work under $PACKAGEBIN + + $make cd $PACKAGEBIN + case $list in + ?*) $exec rm -f $list ;; + esac + + # go for it + + for package + do if view - all $package.pkg || view - all lib/package/$package.pkg + then eval capture \$MAKE \$makeflags -X ignore \$noexec -f \$package.pkg \$qualifier \$action $assign + else echo "$command: $package: not a package" >&2 + fi + done + ;; + +TEST) set '' $target $package + shift + case $1 in + binary|source) + action=$1 + shift + ;; + esac + order "$@" + ;; + +*) echo "$command: $action: internal error" >&2 + exit 1 + ;; + +esac diff --git a/src/cmd/INIT/probe.win32 b/src/cmd/INIT/probe.win32 new file mode 100644 index 0000000..7939fcc --- /dev/null +++ b/src/cmd/INIT/probe.win32 @@ -0,0 +1,283 @@ +: +# @(#)probe.win32 (AT&T Research) 2010-01-01 +# +# win32 specific make C probe initialization +# wrapped cc's are easy on uwin +# +# 2> easy.err to avoid mysterious hang with bcc + +# begin preamble shared with the pp probe.ini + +IFS=$'\n' + +chmod 777 . # cl.exe setuid workaround + +typeset -A header version + +# we are probing on behalf of libpp and nmake +# so the native preprocessor must be forced in +# order to bootstrap libpp and nmake + +nativepp=-1 +export nativepp + +probe_header=" +stddef.h +" +for inc in syslimits.h winerror.h ostream bits/ctype_base.h stream.h +do echo "#include <$inc>" > easy.c + if $cc -E easy.c > /dev/null 2> easy.err + then probe_header="$probe_header +$inc +" + fi +done + +{ +for i in $probe_header +do echo "#include <$i>" +done +echo '#ifdef __cplusplus' +echo "int _Pr0b3_cplus=__cplusplus;" +echo '#endif' +echo '#ifdef _UWIN' +echo "int _Pr0b3_uwin=_UWIN;" +echo '#endif' +echo '#ifdef __BORLANDC__' +echo "int _Pr0b3_version_BORLAND=__BORLANDC__;" +echo '#endif' +echo '#ifdef __DMC__' +echo "int _Pr0b3_version_DM=__DMC__;" +echo '#endif' +echo '#ifdef _MSC_VER' +echo "int _Pr0b3_version_MS=_MSC_VER;" +echo '#endif' +echo '#ifdef __ICL' +echo "int _Pr0b3_version_ICL=__ICL;" +echo '#endif' +echo '#ifdef __LCC__' +echo "int _Pr0b3_version_LCC=0+__LCC__;" +echo '#endif' +echo '#ifdef __MINGW32__' +echo "int _Pr0b3_version_MINGW=__MINGW32__;" +echo '#endif' +echo '#ifdef __INTERIX' +echo "int _Pr0b3_version_INTERIX=__INTERIX;" +echo '#endif' +echo '#ifdef __WATCOMC__' +echo "int _Pr0b3_version_WATCOM=__WATCOMC__;" +echo '#endif' +} > easy.c + +include= +uwin= +cplus= + +$cc -E easy.c 2>&1 | +egrep -i '^(#(line)? 1 .*\.[hH]| *int +_Pr0b3_[a-zA-Z_]* *= *[0-9])' | +sed -e 's,_Pr0b3_,,' \ + -e 's/.*"\(.*\)".*/\1/' \ + -e 's,^ *,,' \ + -e 's, *$,,' \ + -e 's, *= *,=,' \ + -e 's,^\(.\):[\\/]*,/\1/,' \ + -e 's,[\\/][\\/]*,/,g' \ + -e 's,^\(/.*\)/\(.*\)$,header[\2]="\1",' \ + -e 's, *int *\(.*\);.*,\1,' \ + -e 's,^version_\(.*\)=,version[\1]=,' \ + > easy.sh +. ./easy.sh + +include= +for i in $probe_header +do d=${header[$i]} + if [[ $d ]] + then include="$include +$d" + elif [[ $i == */* ]] + then d=${header[${i##*/}]} + if [[ $d == */${i%/*} ]] + then include="$include +${d%/${i%/*}}" + fi + fi +done + +i=$($cc -V 2> easy.err) +if test "" != "$i" -a -d "$i/include" +then include="$i/include +$include" +fi + +stdinclude= +for inc in $include +do if [[ ${inc%/*} -ef /msdev/platformsdk ]] + then inc=/msdev/platformsdk/${inc##*/} + elif [[ ${inc%/*} -ef /platformsdk ]] + then inc=/platformsdk/${inc##*/} + fi + for dup in $stdinclude + do [[ $inc -ef $dup ]] && continue 2 + done + stdinclude="$stdinclude +$inc" +done + +# end preamble shared with the pp probe.ini + +if [[ ${version[@]} == [0-9]* && $stdinclude ]] +then : the payoff + set -- $cc + cmd=$1 + shift + set -- $(whence $cmd) "$@" + typ=$(package) + dialect="ANSI CLOSURE DYNAMIC EXPORT=DLL LIBPP -I-" + case ${cc##*/} in + *CC*) dialect="$dialect C++" + cplus=1 + ;; + esac + ld=${cc%cc}ld + if [[ ! -x $ld ]] + then ld=${cc%/*}/ld + if [[ ! -x $ld ]] + then case $cc in + */ncc) ld=/usr/bin/nld ;; + *) ld=/usr/bin/ld ;; + esac + fi + fi + { + if $cc -v >/dev/null 2>&1 + then v=$($cc -v 2>/dev/null) + if [[ $v ]] + then print "# ;VERSION;-v;$v;PATH;$cc" + fi + else v= + fi + cat <<! +CC.CC = $* +CC.NATIVE = $* +CC.EXECTYPE = $typ +CC.HOSTTYPE = $typ +CC.ALTPP.FLAGS = -Yp,\$(CPP:D) +CC.ALTPP.ENV = +CC.AR = ar +CC.ARFLAGS = +CC.DEBUG = -g +CC.DIALECT = $dialect +CC.DLL = -D_BLD_DLL +CC.DLLBIG = -D_BLD_DLL +CC.DLL.DEF = -D_BLD_DLL +CC.DLL.DIR = \$(BINDIR) +CC.DLL.LIBRARIES = +CC.DLL.VARIANTS = +CC.DYNAMIC = +CC.EXPORT.DYNAMIC = +CC.LD = $ld +CC.LD.DYNAMIC = -Bdynamic +CC.LD.LAZY = +CC.LD.NOLAZY = +CC.LD.ORIGIN = +CC.LD.RECORD = +CC.LD.NORECORD = +CC.LD.RUNPATH = +CC.LD.STATIC = -Bstatic +CC.LD.STRIP = +CC.LIB.DLL = option +CC.LIB.ALL = -Bwhole-archive +CC.LIB.UNDEF = -Bno-whole-archive +CC.MAKE.OPTIONS = nativepp=0 +CC.NM = nm +CC.NMEDIT = +CC.NMFLAGS = +CC.OPTIMIZE = -O +CC.PIC = +CC.PICBIG = +CC.READONLY = +CC.REPOSITORY = +CC.SHARED = -G +CC.SHARED.LD = $ld +CC.SHARED.REGISTRY = +CC.SHARED.REGISTRY.PATH = +CC.SHELLMAGIC = +CC.SIZE = size +CC.STATIC = -Bstatic +! + inc= + lib= + if [[ ${version[LCC]} ]] + then lib=/lcc + fi + if [[ $stdinclude == *' '* ]] + then stdinclude=${stdinclude//' '/''} + fi + stdinc= + stdlib= + for inc in $stdinclude + do stdinc="$stdinc $inc" + d=${inc%/*}/lib + if [[ -d $d ]] + then stdlib="$stdlib $d" + fi + done + case $uwin in + [0-9]*) cat <<! +CC.STDINCLUDE = /usr/include $stdinc +CC.STDLIB = /usr/lib$lib $stdlib +! + ;; + *) cat <<! +CC.STDINCLUDE = $stdinc +CC.STDLIB = $stdlib +! + ;; + esac + cat <<! +CC.STRICT = +CC.STRIP = strip +CC.STRIP.FLAGS = +CC.PREFIX.ARCHIVE = lib +CC.PREFIX.DYNAMIC = +CC.PREFIX.SHARED = +CC.PREFIX.SYMBOL = _ +CC.SUFFIX.ARCHIVE = .a +CC.SUFFIX.COMMAND = +CC.SUFFIX.DEBUG = .pdb +CC.SUFFIX.DYNAMIC = .dll +CC.SUFFIX.LD = .def .exp .ign .res +CC.SUFFIX.OBJECT = .o +CC.SUFFIX.SHARED = .lib +CC.SUFFIX.SOURCE = .c +CC.SUFFIX.STATIC = +! + if [[ $v ]] + then case $v in + *\"*) v=$(print -r -- | sed -e 's,",\\",g' -e 's,^ ,,' -e 's,.*,"&",') ;; + *\'*) v=\"$v\" ;; + esac + cat <<! +CC.VERSION = -v +CC.VERSION.STRING = $v +! + else cat <<! +CC.VERSION = +CC.VERSION.STRING = +! + fi + if [[ ${version[MINGW]} || ${version[MS]} ]] + then cat <<! +CC.WARN = -Wall +! + else cat <<! +CC.WARN = +! + fi + cat <<! +CC.PREROOT = +CC.UNIVERSE = att +! + } >&3 + exit 0 +fi diff --git a/src/cmd/INIT/proto.c b/src/cmd/INIT/proto.c new file mode 100644 index 0000000..d030a1d --- /dev/null +++ b/src/cmd/INIT/proto.c @@ -0,0 +1,5283 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1990-2012 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ + +/* : : generated by proto : : */ + +#if !defined(__PROTO__) +# if defined(__STDC__) || defined(__cplusplus) || defined(_proto) || defined(c_plusplus) +# if defined(__cplusplus) +# define __LINKAGE__ "C" +# else +# define __LINKAGE__ +# endif +# define __STDARG__ +# define __PROTO__(x) x +# define __OTORP__(x) +# define __PARAM__(n,o) n +# if !defined(__STDC__) && !defined(__cplusplus) +# if !defined(c_plusplus) +# define const +# endif +# define signed +# define void int +# define volatile +# define __V_ char +# else +# define __V_ void +# endif +# else +# define __PROTO__(x) () +# define __OTORP__(x) x +# define __PARAM__(n,o) o +# define __LINKAGE__ +# define __V_ char +# define const +# define signed +# define void int +# define volatile +# endif +# define __MANGLE__ __LINKAGE__ +# if defined(__cplusplus) || defined(c_plusplus) +# define __VARARG__ ... +# else +# define __VARARG__ +# endif +# if defined(__STDARG__) +# define __VA_START__(p,a) va_start(p,a) +# else +# define __VA_START__(p,a) va_start(p) +# endif +# if !defined(__INLINE__) +# if defined(__cplusplus) +# define __INLINE__ extern __MANGLE__ inline +# else +# if defined(_WIN32) && !defined(__GNUC__) +# define __INLINE__ __inline +# endif +# endif +# endif +#endif +#if !defined(__LINKAGE__) +#define __LINKAGE__ /* 2004-08-11 transition */ +#endif +#line 1 "proto.c" + + +#line 151 +# ifndef __STDC__ +# ifndef creat +# define creat _huh_creat +# endif +# if 1 +# ifndef access +# define access _huh_access +# endif +# ifndef ctime +# define ctime _huh_ctime +# endif +# ifndef mkdir +# define mkdir _huh_mkdir +# endif +# endif +# endif + +# include <sys/types.h> +# include <sys/stat.h> +# include <fcntl.h> +# if 1 +# include <stdio.h> +# else +# include <time.h> +# endif + +# ifndef __STDC__ +# undef access +# undef ctime +# undef creat +# undef mkdir +# endif + +# ifndef O_RDONLY +# define O_RDONLY 0 +# endif + +# ifndef S_IRUSR +# define S_IRUSR 0400 +# endif +# ifndef S_IWUSR +# define S_IWUSR 0200 +# endif +# ifndef S_IXUSR +# define S_IXUSR 0100 +# endif +# ifndef S_IRGRP +# define S_IRGRP 0040 +# endif +# ifndef S_IWGRP +# define S_IWGRP 0020 +# endif +# ifndef S_IXGRP +# define S_IXGRP 0010 +# endif +# ifndef S_IROTH +# define S_IROTH 0004 +# endif +# ifndef S_IWOTH +# define S_IWOTH 0002 +# endif +# ifndef S_IXOTH +# define S_IXOTH 0001 +# endif + +# ifndef __STDC__ +# if !_WIN32 && !_WINIX +# define remove(x) unlink(x) +# define rename(x,y) ((link(x,y)||remove(x))?-1:0) +# endif + +# if 1 +extern __MANGLE__ int access __PROTO__((const char*, int)); +extern __MANGLE__ int mkdir __PROTO__((const char*, int)); +# endif + +# endif + +# if 1 +extern __MANGLE__ int utime __PROTO__((const char*, time_t*)); +# endif + + + + + + +int +replace __PARAM__((const char* newfile, const char* oldfile, int preserve), (newfile, oldfile, preserve)) __OTORP__(const char* newfile; const char* oldfile; int preserve;){ + struct stat st; + time_t ut[2]; + + if (stat(oldfile, &st)) + { + if (preserve) + return -1; + st.st_mode = 0; + } + if (remove(oldfile) || rename(newfile, oldfile)) + return -1; + if (st.st_mode &= (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH)) + chmod(oldfile, st.st_mode); + if (preserve) + { + ut[0] = st.st_atime; + ut[1] = st.st_mtime; + preserve = utime(oldfile, ut); + } + return preserve; +} + +# undef utime +# define utime ______utime + +#line 1 "../../lib/libpp/ppproto.c" + +#line 13 +static const char id[] = "\n@(#)$Id: proto (AT&T Research) 2012-04-14 $\000\n"; + +#line 1 "../../lib/libpp/ppfsm.c" + +#line 1 "../../lib/libpp/pplib.h" + +#line 108 +struct ppsymbol; +struct ppindex; + +typedef char* (*PPBUILTIN) __PROTO__((char*, const char*, const char*)); +typedef void (*PPCOMMENT) __PROTO__((const char*, const char*, const char*, int)); +typedef void (*PPINCREF) __PROTO__((const char*, const char*, int, int)); +typedef void (*PPLINESYNC) __PROTO__((int, const char*)); +typedef void (*PPMACREF) __PROTO__((struct ppsymbol*, const char*, int, int, unsigned long)); +typedef int (*PPOPTARG) __PROTO__((int, int, const char*)); +typedef void (*PPPRAGMA) __PROTO__((const char*, const char*, const char*, const char*, int)); + +struct ppinstk +{ + char* nextchr; + struct ppinstk* next; + struct ppinstk* prev; + long* control; + char* buffer; + char* file; + char* prefix; + struct ppsymbol* symbol; + + struct ppindex* index; + int buflen; + + int line; + int vendor; + short fd; + short hide; + short flags; + char type; +}; + + + + + + + + + +struct pplist +{ + char* value; + struct pplist* next; +}; + +struct oplist +{ + int op; + char* value; + struct oplist* next; +}; + +struct pphide +{ + struct ppmacro* macro; + unsigned long flags; + int level; +}; + +struct ppmacstk +{ + struct ppmacstk* next; + struct ppmacstk* prev; + int line; + char* arg[1]; +}; + +struct ppmember +{ + struct ppdirs* archive; + unsigned long offset; + unsigned long size; +}; + +struct counter +{ + int candidate; + int function; + int macro; + int pplex; + int push; + int terminal; + int token; +}; + +struct pptuple +{ + struct pptuple* nomatch; + struct pptuple* match; + char token[1]; +}; + +struct ppfileid +{ + unsigned long st_dev; + unsigned long st_ino; +}; + +struct pathid +{ + char* path; + struct ppfileid id; +}; + +#line 1 "../../lib/libpp/pp.h" + +#line 206 + +#line 217 + +#line 329 +struct ppdirs +{ + char* name; + struct ppdirs* next; + + + unsigned char c; unsigned char index; unsigned char type; union { char* buffer; char* sp; struct ppdirs* subdir; } info; struct ppfileid id; + + +}; + +struct ppkeyword +{ + char* name; + int value; +}; + +struct ppmacro +{ + int arity; + char* value; + + + struct pptuple* tuple; char* formals; int size; + + +}; + +struct ppsymbol +{ + int hash_header; + unsigned long flags; + struct ppmacro* macro; + __V_* value; + + + struct pphide* hidden; + + +}; + +#line 378 +struct ppglobals +{ + const char* version; + char* lineid; + char* outfile; + char* pass; + char* token; + struct ppsymbol* symbol; + + + + char* outb; + char* outbuf; + char* outp; + char* oute; + unsigned long offset; + + + struct ppdirs* lcldirs; struct ppdirs* stddirs; int flags; char* symtab; + + + + struct ppcontext* context; long state; long mode; long option; long test; struct { char* sp; long flags; } filedeps; struct ppdirs* firstdir; struct ppdirs* lastdir; int hide; int column; int pending; char* firstfile; char* lastfile; char* ignore; char* probe; char* filtab; char* prdtab; char* date; char* time; char* maps; long ro_state; long ro_mode; long ro_option; long ro_op[2]; struct pathid cdir; struct pathid hostdir; char* ppdefault; struct ppindex* firstindex; struct ppindex* lastindex; struct oplist* firstop; struct oplist* lastop; struct oplist* firsttx; struct oplist* lasttx; unsigned char arg_file; unsigned char arg_mode; unsigned char arg_style; unsigned char c; unsigned char hosted; unsigned char ignoresrc; unsigned char initialized; unsigned char standalone; unsigned char spare_1; + + + + char* checkpoint; int constack; struct ppinstk* in; char* addp; char* args; char* addbuf; char* catbuf; char* hdrbuf; char* hidebuf; char* path; char* tmpbuf; char* valbuf; char* optflags; int lastout; char* include; char* prefix; struct ppmember* member; int hidden; int hiding; int level; struct { int input; int output; } pool; struct { long ro_state; long ro_mode; long ro_option; long ro_op[2]; int on; char* symtab; } reset; int truncate; struct ppmacstk* macp; char* maxmac; char* mactop; char* toknxt; long* control; long* maxcon; struct oplist* chop; struct ppfile* insert; struct ppfile* original; struct ppdirs* found; int vendor; char* dirtab; char* strtab; PPBUILTIN builtin; PPCOMMENT comment; PPINCREF incref; PPLINESYNC linesync; PPLINESYNC olinesync; PPMACREF macref; PPOPTARG optarg; PPPRAGMA pragma; struct counter counter; char funbuf[256]; + + +}; + + + + + + + +extern __MANGLE__ struct ppglobals pp; +extern __MANGLE__ char _pp_ctype[]; + +extern __MANGLE__ int ppargs __PROTO__((char**, int)); +extern __MANGLE__ void ppcpp __PROTO__((void)); +extern __MANGLE__ void ppcomment __PROTO__((char*, char*, char*, int)); +extern __MANGLE__ __V_* ppcontext __PROTO__((__V_*, int)); +extern __MANGLE__ void pperror __PROTO__((int, ...)); +extern __MANGLE__ void ppincref __PROTO__((char*, char*, int, int)); +extern __MANGLE__ void ppinput __PROTO__((char*, char*, int)); +extern __MANGLE__ int pplex __PROTO__((void)); +extern __MANGLE__ void ppline __PROTO__((int, char*)); +extern __MANGLE__ void ppmacref __PROTO__((struct ppsymbol*, char*, int, int, unsigned long)); +extern __MANGLE__ void ppop __PROTO__((int, ...)); +extern __MANGLE__ void pppragma __PROTO__((char*, char*, char*, char*, int)); +extern __MANGLE__ int ppprintf __PROTO__((char*, ...)); +extern __MANGLE__ int ppsync __PROTO__((void)); + +#line 368 "../../lib/libpp/pplib.h" + +#line 1 "../../lib/libpp/ppdef.h" + +#line 369 "../../lib/libpp/pplib.h" + +#line 1 "../../lib/libpp/ppkey.h" + +#line 16 + +#line 125 +extern __MANGLE__ struct ppkeyword ppkey[]; + +#line 370 "../../lib/libpp/pplib.h" + +#line 683 +struct ppcontext +{ + struct ppdirs* lcldirs; struct ppdirs* stddirs; int flags; char* symtab; + struct ppcontext* context; long state; long mode; long option; long test; struct { char* sp; long flags; } filedeps; struct ppdirs* firstdir; struct ppdirs* lastdir; int hide; int column; int pending; char* firstfile; char* lastfile; char* ignore; char* probe; char* filtab; char* prdtab; char* date; char* time; char* maps; long ro_state; long ro_mode; long ro_option; long ro_op[2]; struct pathid cdir; struct pathid hostdir; char* ppdefault; struct ppindex* firstindex; struct ppindex* lastindex; struct oplist* firstop; struct oplist* lastop; struct oplist* firsttx; struct oplist* lasttx; unsigned char arg_file; unsigned char arg_mode; unsigned char arg_style; unsigned char c; unsigned char hosted; unsigned char ignoresrc; unsigned char initialized; unsigned char standalone; unsigned char spare_1; +}; + +struct ppfile +{ + int hash_header; + struct ppsymbol* guard; + struct ppfile* bound[4]; + int flags; +}; + + + +struct ppindex +{ + struct ppindex* next; + struct ppfile* file; + unsigned long begin; + unsigned long end; +}; + + + +struct ppsymkey +{ + struct ppsymbol sym; + int lex; +}; + +#line 729 +# ifdef __STDC__ + +# include <stdlib.h> +# include <unistd.h> +# include <time.h> +# include <string.h> + +# else + +# define size_t int + +extern __MANGLE__ __V_* realloc __PROTO__((__V_*, size_t)); +extern __MANGLE__ __V_* calloc __PROTO__((size_t, size_t)); +extern __MANGLE__ char* ctime __PROTO__((time_t*)); +extern __MANGLE__ void free __PROTO__((__V_*)); + +# ifndef O_RDONLY + +extern __MANGLE__ int access __PROTO__((const char*, int)); +extern __MANGLE__ int close __PROTO__((int)); +extern __MANGLE__ int creat __PROTO__((const char*, int)); +extern __MANGLE__ void exit __PROTO__((int)); +extern __MANGLE__ int link __PROTO__((const char*, const char*)); +extern __MANGLE__ int open __PROTO__((const char*, int, ...)); +extern __MANGLE__ int read __PROTO__((int, __V_*, int)); +extern __MANGLE__ time_t time __PROTO__((time_t*)); +extern __MANGLE__ int unlink __PROTO__((const char*)); +extern __MANGLE__ int write __PROTO__((int, const __V_*, int)); + +# endif + +# endif + +#line 802 +extern __MANGLE__ void ppassert __PROTO__((int, char*, char*)); +extern __MANGLE__ void ppbuiltin __PROTO__((void)); +extern __MANGLE__ int ppcall __PROTO__((struct ppsymbol*, int)); +extern __MANGLE__ int ppcontrol __PROTO__((void)); +extern __MANGLE__ void ppdump __PROTO__((void)); +extern __MANGLE__ char* ppexpand __PROTO__((char*)); +extern __MANGLE__ long ppexpr __PROTO__((int*)); +extern __MANGLE__ void ppfsm __PROTO__((int, char*)); +extern __MANGLE__ char* ppinstr __PROTO__((struct ppinstk*)); +extern __MANGLE__ char* ppkeyname __PROTO__((int, int)); +extern __MANGLE__ char* pplexstr __PROTO__((int)); +extern __MANGLE__ void ppload __PROTO__((char*)); +extern __MANGLE__ void ppmapinclude __PROTO__((char*, char*)); +extern __MANGLE__ char* ppmodestr __PROTO__((long)); +extern __MANGLE__ int ppmultiple __PROTO__((struct ppfile*, struct ppsymbol*)); +extern __MANGLE__ void ppnest __PROTO__((void)); +extern __MANGLE__ int ppoption __PROTO__((char*)); +extern __MANGLE__ char* ppoptionstr __PROTO__((long)); +extern __MANGLE__ void pppclose __PROTO__((char*)); +extern __MANGLE__ int pppdrop __PROTO__((char*)); +extern __MANGLE__ char* pppopen __PROTO__((char*, int, char*, char*, char*, char*, int)); +extern __MANGLE__ int pppread __PROTO__((char*)); +extern __MANGLE__ int pppredargs __PROTO__((void)); +extern __MANGLE__ void pppush __PROTO__((int, char*, char*, int)); +extern __MANGLE__ struct ppsymbol* pprefmac __PROTO__((char*, int)); +extern __MANGLE__ int ppsearch __PROTO__((char*, int, int)); +extern __MANGLE__ int ppset __PROTO__((long*, long, int)); +extern __MANGLE__ char* ppstatestr __PROTO__((long)); +extern __MANGLE__ char* pptokstr __PROTO__((char*, int)); +extern __MANGLE__ void pptrace __PROTO__((int)); + +#line 11 "../../lib/libpp/ppfsm.c" + +#line 1 "../../lib/libpp/ppfsm.h" + +#line 185 + +#line 249 +extern __MANGLE__ short _pp_fsmtab[(0+28)+1][255+1]; + + + + + +extern __MANGLE__ char _pp_trigraph[255+1]; + +extern __MANGLE__ void _pp_refill __PROTO__((int)); + +#line 12 "../../lib/libpp/ppfsm.c" + + +#line 67 +struct fsminit +{ + int state; + unsigned char ch[4]; + int nextstate; +}; + +static struct fsminit fsminit[] = +{ + + { 0, { 023 }, ((0+28)+11), }, + { 0, { 002 }, (0), }, + { 0, { 001 }, (0+23), }, + { 0, { '.' }, (0+25), }, + { 0, { 021 }, (0+19), }, + { 0, { 'L' }, (0+20), }, + { 0, { 'd', 'e', 'f', 'i' }, (0+1), }, + { 0, { 'r', 's', 't', 'v' }, (0+1), }, + { 0, { 'w', 'N' }, (0+1), }, + { 0, { '"', '\'' }, ((0+28)+3), }, + { 0, { '/' }, (0+12), }, + { 0, { '\n' }, ((0+28)+7), }, + { 0, { ' ','\t','\f','\013' }, (0+27), }, + + + { (0+1), { 023 }, ((0+28)+6), }, + { (0+1), { 021, 001 }, (0+19), }, + { (0+1), { 'a' }, (0+2), }, + { (0+1), { 'e' }, (0+3), }, + { (0+1), { 'f' }, (0+4), }, + { (0+1), { 'h' }, (0+5), }, + { (0+1), { 'l' }, (0+6), }, + { (0+1), { 'n' }, (0+7), }, + { (0+1), { 'o' }, (0+8), }, + { (0+1), { 't' }, (0+9), }, + { (0+1), { 'x' }, (0+10), }, + { (0+1), { 'y' }, (0+11), }, + + + { (0+2), { 023 }, (((0+28)+12)), }, + { (0+2), { 021, 001 }, (0+19), }, + { (0+2), { '_','s','t','a' }, (0+2), }, + { (0+2), { 'r' }, (0+2), }, + + + { (0+3), { 023 }, (((0+28)+12)), }, + { (0+3), { 021, 001 }, (0+19), }, + { (0+3), { 't','u','r','n' }, (0+3), }, + + + { (0+4), { 023 }, (((0+28)+12)), }, + { (0+4), { 021, 001 }, (0+19), }, + + + { (0+5), { 023 }, (((0+28)+12)), }, + { (0+5), { 021, 001 }, (0+19), }, + { (0+5), { 'i','l','e' }, (0+5), }, + + + { (0+6), { 023 }, (((0+28)+12)), }, + { (0+6), { 021, 001 }, (0+19), }, + { (0+6), { 's','e' }, (0+6), }, + + + { (0+7), { 023 }, (((0+28)+12)), }, + { (0+7), { 021, 001 }, (0+19), }, + { (0+7), { 'l','i','n','e' }, (0+7), }, + + + { (0+8), { 023 }, (((0+28)+12)), }, + { (0+8), { 021, 001 }, (0+19), }, + { (0+8), { 'r','i','d','N' }, (0+8), }, + + + { (0+9), { 023 }, (((0+28)+12)), }, + { (0+9), { 021, 001 }, (0+19), }, + { (0+9), { 'a','t','i','c' }, (0+9), }, + + + { (0+10), { 023 }, (((0+28)+12)), }, + { (0+10), { 021, 001 }, (0+19), }, + { (0+10), { 't','e','r','n' }, (0+10), }, + + + { (0+11), { 023 }, (((0+28)+12)), }, + { (0+11), { 021, 001 }, (0+19), }, + { (0+11), { 'p','e','d','f' }, (0+11), }, + + + { (0+12), { 023 }, ((0+28)+0), }, + { (0+12), { '*' }, (0+13), }, + + { (0+12), { '/' }, (0+16), }, + + + + { (0+13), { 023 }, (0+13), }, + { (0+13), { '\n', 002 }, ((0+28)+1), }, + { (0+13), { '/' }, (0+15), }, + { (0+13), { '*' }, (0+14), }, + { (0+13), { '#', ';', ')' }, ((( (0+13))<<(7+1))|(((0+28)+8))), }, + + + { (0+14), { 023 }, (0+13), }, + { (0+14), { '\n', 002 }, ((0+28)+1), }, + { (0+14), { '#', ';', ')' }, ((( (0+13))<<(7+1))|(((0+28)+8))), }, + { (0+14), { '*' }, (0+14), }, + { (0+14), { '/' }, ((0+28)+1), }, + + + { (0+15), { 023 }, (0+13), }, + { (0+15), { '*', '\n', 002 }, ((0+28)+1), }, + { (0+15), { '/' }, (0+15), }, + + + { (0+16), { 023 }, (0+16), }, + { (0+16), { '\n', 002 }, ((0+28)+1), }, + { (0+16), { '/' }, (0+17), }, + { (0+16), { '*' }, (0+18), }, + + + { (0+17), { 023 }, (0+16), }, + { (0+17), { '*', '\n', 002 }, ((0+28)+1), }, + { (0+17), { '/' }, (0+17), }, + + + { (0+18), { 023 }, (0+16), }, + { (0+18), { '\n', 002 }, ((0+28)+1), }, + { (0+18), { '*' }, (0+18), }, + { (0+18), { '/' }, ((0+28)+1), }, + + + { (0+19), { 023 }, ((0+28)+6), }, + { (0+19), { 021, 001 }, (0+19), }, + + + { (0+25), { 023 }, ((0+28)+0), }, + { (0+25), { '.' }, (0+26), }, + { (0+25), { 001 }, (0+23), }, + + + { (0+26), { 023 }, (((( (0401+1))-0401)<<(7+1))|( ((0+28)+14))), }, + { (0+26), { '.' }, (((( (0401+29))-0401)<<(7+1))|( ((0+28)+13))), }, + + + { (0+20), { 023 }, ((0+28)+6), }, + { (0+20), { 021, 001 }, (0+19), }, + { (0+20), { '"', '\'' }, ((( (0+21))<<(7+1))|(((0+28)+8))), }, + + + { (0+21), { 023 }, (0+21), }, + { (0+21), { '"', '\'' }, ((0+28)+4), }, + { (0+21), { '\n', 002 }, ((0+28)+4), }, + { (0+21), { '\\' }, (0+22), }, + + + { (0+22), { 023 }, ((0+28)+5), }, + { (0+22), { '\n', 002 }, ((0+28)+4), }, + + + { (0+23), { 023 }, (((( (0401+1))-0401)<<(7+1))|( ((0+28)+14))), }, + { (0+23), { 021, 001, '.' }, (0+23), }, + { (0+23), { 'e', 'E' }, (0+24), }, + + + { (0+24), { 023 }, (((( (0401+1))-0401)<<(7+1))|( ((0+28)+14))), }, + { (0+24), { 021, 001, '.' }, (0+23), }, + { (0+24), { '+', '-' }, (0+23), }, + + + { (0+27), { 023 }, ((0+28)+15), }, + { (0+27), { ' ', '\t' }, (0+27), }, + { (0+27), { '\f', '\013' }, ((0+28)+10), }, + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#line 528 + { (-1), { 0 }, 0, } +}; + +short _pp_fsmtab[(0+28)+1][255+1]; + +char _pp_trigraph[255+1]; + + +static char spl[] = { '\\', '\r', 0 }; +static char aln[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$@"; + + + + +static char* let = &aln[10]; +static char hex[] = "fedcbaFEDCBA9876543210"; +static char* dec = &hex[12]; +static char* oct = &hex[14]; + + + + + + +void +ppfsm __PARAM__((int op, register char* s), (op, s)) __OTORP__(int op; register char* s;){ + register int c; + register int n; + register int i; + register short* rp; + register struct fsminit* fp; + + + + + + switch (op) + { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + case 4: + for (fp = fsminit;; fp++) + { + if ((n = fp->nextstate) >= (0+28)) n = ~n; + if (fp->state == (-1)) + { + + + + + + + + + + + + + + break; + } + rp = _pp_fsmtab[fp->state]; + for (i = 0; i < sizeof(fp->ch) && (c = fp->ch[i]); i++) + { + switch (c) + { + case 023: + for (c = 0; c <= 255; c++) + rp[c] = n; + + + case 002: + _pp_fsmtab[(0+28)][fp->state+1] = n < 0 ? ~n : n; + continue; + + case 021: + s = let; + break; + + case 003: + s = hex; + break; + + case 001: + s = dec; + break; + + case 022: + s = oct; + break; + + default: + rp[c] = n; + continue; + } + while (c = *s++) + rp[c] = n; + } + } + + + + + + + for (i = 0; i < (0+28); i++) + { + rp = _pp_fsmtab[i]; + s = spl; + while (c = *s++) + if (c != '@' || !(( rp)>=_pp_fsmtab[(0+13)]&&( rp)<=_pp_fsmtab[(0+18)])) + { + if (rp[c] >= 0) rp[c] = ~rp[c]; + rp[c] &= ~(1<<7); + } + rp[0] = ~((0+28)+2); + for (c = 0; c <= 255; c++) + if (rp[c] == i) + rp[c] = 0; + } + _pp_fsmtab[(0+28)][0] = ~((0+28)+2); + + + + + + + + + + + + + + + + + + +#line 707 + break; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#line 860 + } +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#line 18 "../../lib/libpp/ppproto.c" + +#line 1 "../../../include/ast/hashkey.h" + +#line 24 + + +#line 68 +extern __MANGLE__ long strkey __PROTO__((const char*)); + +#line 20 "../../lib/libpp/ppproto.c" + +#line 41 +typedef struct Key_s +{ + const char* name; + size_t size; + int hit; + int val; +} Key_t; + +typedef struct Proto_s +{ + int brace; + int call; + int fd; + char* file; + long flags; + long options; + char* package; + int line; + int test; + + char* tp; + + int iz; + char* ib; + char* ip; + + int oz; + char* ob; + char* op; + char* ox; + + char cc[3]; + char pushback[4]; + + char variadic[256]; + + + + +} Proto_t; + + +#line 171 +static const Key_t pragmas[] = +{ + { "prototyped",sizeof( "prototyped")-1, 0x01, 1}, + { "noprototyped",sizeof( "noprototyped")-1, 0x01, 0}, + { "noticed",sizeof( "noticed")-1, 0x02, 1}, + { "nonoticed",sizeof( "nonoticed")-1, 0x02, 0}, +}; + +static const Key_t notices[] = +{ + { "Copyright",sizeof( "Copyright")-1, 0x02, 1}, + { "COPYRIGHT",sizeof( "COPYRIGHT")-1, 0x02, 1}, + { "copyright",sizeof( "copyright")-1, 0x02, 1}, + { "Public Domain",sizeof( "Public Domain")-1, 0x02, 0}, + { "PUBLIC DOMAIN",sizeof( "PUBLIC DOMAIN")-1, 0x02, 0}, +}; + + + + + + +static char* +number __PARAM__((register char* p, register long n), (p, n)) __OTORP__(register char* p; register long n;){ + register long d; + + for (d = 1000000; d > 1; d /= 10) + if (n >= d) *p++ = '0' + (n / d) % 10; + *p++ = '0' + n % 10; + return p; +} + + + +static int errors; + + +#line 224 + + + + +static int +sstrlen __PARAM__((register const char* s), (s)) __OTORP__(register const char* s;){ + register const char* b; + + for (b = s; *s; s++); + return s - b; +} + + + + + +static int +sstrncmp __PARAM__((register const char* s, register const char* t, register int n), (s, t, n)) __OTORP__(register const char* s; register const char* t; register int n;){ + register const char* e = s + n; + + while (s < e) + { + if (*s != *t || !*s) + return *s - *t; + s++; + t++; + } + return 0; +} + + + + + +static char* +strcopy __PARAM__((register char* s, register const char* t), (s, t)) __OTORP__(register char* s; register const char* t;){ + while (*s++ = *t++); + return s - 1; +} + + + +static void +proto_error __PARAM__((char* iob, int level, char* msg, char* arg), (iob, level, msg, arg)) __OTORP__(char* iob; int level; char* msg; char* arg;){ + register char* p; + char buf[1024]; + + p = strcopy(buf, "proto: "); + if (iob) + { + register Proto_t* proto = (Proto_t*)(iob - sizeof(Proto_t)); + + if (proto->line) + { + if (proto->file) + { + *p++ = '"'; + p = strcopy(p, proto->file); + *p++ = '"'; + *p++ = ','; + *p++ = ' '; + } + p = strcopy(p, "line "); + p = number(p, proto->line); + } + else if (proto->file) + p = strcopy(p, proto->file); + } + else + { + p = strcopy(p, msg); + msg = arg; + arg = 0; + } + if (*(p - 1) != ' ') + { + *p++ = ':'; + *p++ = ' '; + } + if (level == 1) + p = strcopy(p, "warning: "); + p = strcopy(p, msg); + if (arg) + { + *p++ = ' '; + p = strcopy(p, arg); + } + *p++ = '\n'; + write(2, buf, p - buf); + if (level >= 3) + exit(level - 2); + if (level >= 2) + errors++; +} + + + + + +static char* +memcopy __PARAM__((register char* s, register char* t, int n), (s, t, n)) __OTORP__(register char* s; register char* t; int n;){ + register char* e = t + n; + + while (t < e) *s++ = *t++; + return s; +} + +#line 1 "../../lib/libast/port/astlicense.c" + + + +#line 84 +typedef struct Buffer_s +{ + char* buf; + char* nxt; + char* end; + int siz; +} Buffer_t; + +typedef struct Item_s +{ + char* data; + int size; + int quote; +} Item_t; + +typedef struct Id_s +{ + Item_t name; + Item_t value; +} Id_t; + + + + + + + +static const Item_t key[] = +{ + { "author",sizeof( "author")-1,0}, + { "class",sizeof( "class")-1,0}, + { "company",sizeof( "company")-1,0}, + { "component",sizeof( "component")-1,0}, + { "contributor",sizeof( "contributor")-1,0}, + { "corporation",sizeof( "corporation")-1,0}, + { "domain",sizeof( "domain")-1,0}, + { "id",sizeof( "id")-1,0}, + { "incorporation",sizeof( "incorporation")-1,0}, + { "license",sizeof( "license")-1,0}, + { "location",sizeof( "location")-1,0}, + { "name",sizeof( "name")-1,0}, + { "notice",sizeof( "notice")-1,0}, + { "organization",sizeof( "organization")-1,0}, + { "package",sizeof( "package")-1,0}, + { "parent",sizeof( "parent")-1,0}, + { "query",sizeof( "query")-1,0}, + { "since",sizeof( "since")-1,0}, + { "source",sizeof( "source")-1,0}, + { "start",sizeof( "start")-1,0}, + { "type",sizeof( "type")-1,0}, + { "url",sizeof( "url")-1,0}, + { "urlmd5",sizeof( "urlmd5")-1,0}, + { "version",sizeof( "version")-1,0}, + {0} +}; + + + + + +static const Item_t lic[] = +{ + { "none",sizeof( "none")-1, 0}, + { "inline",sizeof( "inline")-1, 12}, + { "test",sizeof( "test")-1, 2}, + { "verbose",sizeof( "verbose")-1, 3}, + { "usage",sizeof( "usage")-1, 4}, + { "open",sizeof( "open")-1, 5}, + { "cpl",sizeof( "cpl")-1, 5}, + { "epl",sizeof( "epl")-1, 5}, + { "bsd",sizeof( "bsd")-1, 5}, + { "zlib",sizeof( "zlib")-1, 5}, + { "mit",sizeof( "mit")-1, 5}, + { "gpl",sizeof( "gpl")-1, 11}, + { "special",sizeof( "special")-1, 12}, + { "nonexclusive",sizeof( "nonexclusive")-1, 12}, + { "noncommercial",sizeof( "noncommercial")-1, 12}, + { "proprietary",sizeof( "proprietary")-1, 15}, + {0} +}; + +typedef struct Notice_s +{ + int test; + int type; + int verbose; + int ids; + Item_t item[(sizeof(key)/sizeof(key[0])-1)]; + Id_t id[64]; + char cc[3]; +} Notice_t; + + + + + +static int +lookup __PARAM__((register const Item_t* item, const char* name, int size), (item, name, size)) __OTORP__(register const Item_t* item; const char* name; int size;){ + register int c; + register int i; + + c = name[0]; + for (i = 0; item[i].data; i++) + if (c == item[i].data[0] && size == item[i].size && !sstrncmp( name, item[i].data, size)) + return i; + return -1; +} + + + + + + +static void +copy __PARAM__((register Buffer_t* b, register char* s, int n), (b, s, n)) __OTORP__(register Buffer_t* b; register char* s; int n;){ + if (n < 0) + n = sstrlen( s); + while (n--) + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( *s++)):(( *s++),(-1))); +} + + +#line 217 +static void +comment __PARAM__((Notice_t* notice, register Buffer_t* b, register char* s, register int n, int u), (notice, b, s, n, u)) __OTORP__(Notice_t* notice; register Buffer_t* b; register char* s; register int n; int u;){ + register int i; + register int m; + register int x; + int cc; + + cc = notice->cc[1]; + if (!s) + { + if (n) + { + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( notice->cc[n > 0 ? 0 : 1])):(( notice->cc[n > 0 ? 0 : 1]),(-1))); + for (i = 0; i < 70; i++) + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( cc)):(( cc),(-1))); + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( notice->cc[n > 0 ? 1 : 2])):(( notice->cc[n > 0 ? 1 : 2]),(-1))); + } + else + s = ""; + } + if (s) + { + if (n > 70) + n = 70; + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( cc)):(( cc),(-1))); + m = (u < 0) ? 1 : (70 - n) / 2; + if ((x = 70 - m - n) < 0) + n--; + while (m-- > 0) + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1))); + while (n-- > 0) + { + i = *s++; + if (u > 0 && i >= 'a' && i <= 'z') + i = i - 'a' + 'A'; + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( i)):(( i),(-1))); + } + while (x-- > 0) + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1))); + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( cc)):(( cc),(-1))); + } + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( '\n')):(( '\n'),(-1))); +} + + + + + +static void +expand __PARAM__((Notice_t* notice, register Buffer_t* b, const Item_t* item), (notice, b, item)) __OTORP__(Notice_t* notice; register Buffer_t* b; const Item_t* item;){ + register char* t; + register char* e; + register int q; + register char* x; + register char* z; + register int c; + int m; + int i; + int k; + + if (t = item->data) + { + q = item->quote; + e = t + item->size; + i = 0; + while (t < e) + { + if (*t == '$' && t < (e + 2) && *(t + 1) == '{') + { + k = m = 0; + x = t += 2; + while (t < e && (c = *t++) != '}') + if (c == '.') + x = t; + else if (c == '-') + { + k = 1; + break; + } + else if (c == '/') + { + m = 1; + break; + } + if ((c = lookup(key, x, t - x - 1)) >= 0 && (x = notice->item[c].data)) + { + z = x + notice->item[c].size; + while (x < z) + { + c = *x++; + if (!m || c >= '0' && c <= '9') + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( c)):(( c),(-1))); + } + } + else if (k) + { + k = 0; + i++; + } + if (k || m) + { + k = 1; + while (t < e) + if ((c = *t++) == '{') + k++; + else if (c == '}' && !--k) + break; + } + } + else if (q > 0 && *t == '\\' && (*(t + 1) == q || *(t + 1) == '\\')) + t++; + else if (*t == '}' && i) + { + t++; + i--; + } + else + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( *t++)):(( *t++),(-1))); + } + } +} + + + + + +static void +copyright __PARAM__((Notice_t* notice, register Buffer_t* b), (notice, b)) __OTORP__(Notice_t* notice; register Buffer_t* b;){ + register char* x; + register char* t; + time_t clock; + + copy(b, "Copyright (c) ", -1); + if (notice->test) + clock = (time_t)1000212300; + else if (!(t = notice->item[18].data)) + { + time(&clock); + t = ctime(&clock) + 20; + } + if ((x = notice->item[19].data) && sstrncmp( t, x, 4) < 0) + t = x; + if ((x = notice->item[17].data) && sstrncmp( x, t, 4) < 0) + { + expand(notice, b, ¬ice->item[17]); + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( '-')):(( '-'),(-1))); + } + copy(b, t, 4); + if (notice->item[15].data) + { + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1))); + expand(notice, b, ¬ice->item[15]); + } + if (notice->item[5].data) + { + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1))); + expand(notice, b, ¬ice->item[5]); + if (notice->item[8].data) + { + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1))); + expand(notice, b, ¬ice->item[8]); + } + } + else if (notice->item[2].data) + { + ((( b)->nxt<( b)->end)?(*( b)->nxt++=( ' ')):(( ' '),(-1))); + expand(notice, b, ¬ice->item[2]); + } +} + +typedef struct Stack_s +{ + char* info; + char* file; + int line; + int size; +} Stack_t; + +static int +push __PARAM__((Stack_t* sp, char* file, char* parent, char* info, int size, Buffer_t* buf), (sp, file, parent, info, size, buf)) __OTORP__(Stack_t* sp; char* file; char* parent; char* info; int size; Buffer_t* buf;){ + char* s; + char* t; + int i; + int n; + char path[1024]; + + if (size <= 8) + { + copy(buf, file, -1); + copy(buf, ": no space", -1); + ((( buf)->nxt<( buf)->end)?(*( buf)->nxt++=( 0)):(( 0),(-1))); + return -1; + } + if (*file != '/' && parent && (s = strrchr(parent, '/'))) + { + n = s - parent + 1; + if ((sstrlen( file) + n + 1) <= sizeof(path)) + { + memcopy( path, parent, n); + strcopy( path + n, file); + file = path; + } + } + if ((i = open(file, O_RDONLY)) < 0) + { + + if (file == path) + for (s = path; *s; s++) + if (s[0] == '/' && s[1] == 'a' && s[2] == 'r' && s[3] == 'c' && s[4] == 'h' && s[5] == '/') + { + t = s; + for (s += 6; *s && *s != '/'; s++); + while (*t++ = *s++); + i = open(file, O_RDONLY); + } + if (i < 0) + { + copy(buf, file, -1); + copy(buf, ": cannot open", -1); + ((( buf)->nxt<( buf)->end)?(*( buf)->nxt++=( 0)):(( 0),(-1))); + return -1; + } + } + n = read(i, info, size - 1); + close(i); + if (n < 0) + { + copy(buf, file, -1); + copy(buf, ": cannot read", -1); + ((( buf)->nxt<( buf)->end)?(*( buf)->nxt++=( 0)):(( 0),(-1))); + return -1; + } + info[n++] = 0; + sp->file = file; + sp->info = info; + sp->line = 0; + sp->size = n; + return 0; +} + + + + + + + +int +astlicense __PARAM__((char* p, int size, char* file, char* options, int cc1, int cc2, int cc3), (p, size, file, options, cc1, cc2, cc3)) __OTORP__(char* p; int size; char* file; char* options; int cc1; int cc2; int cc3;){ + register char* s; + register char* v; + register char* x; + register int c; + int i; + int h; + int k; + int n; + int q; + int contributor; + int first; + int level; + int quote; + char* data; + char tmpbuf[(70+4)]; + char info[8 * 1024]; + Stack_t input[4]; + Notice_t notice; + Item_t item; + Buffer_t buf; + Buffer_t tmp; + + buf.end = (buf.buf = buf.nxt = p) + size; + tmp.end = (tmp.buf = tmp.nxt = tmpbuf) + sizeof(tmpbuf); + level = 0; + data = info; + level = -1; + if (options) + { + level++; + input[level].file = "<options>"; + input[level].info = options; + input[level].line = 0; + } + if (file && *file) + { + if (push(&input[++level], file, 0, data, &info[sizeof(info)] - data, &buf)) + return -1; + data += input[level].size; + } + if (level < 0) + return 0; + s = input[level].info; + notice.test = 0; + notice.type = 0; + notice.verbose = 0; + notice.ids = 0; + notice.cc[0] = cc1; + notice.cc[1] = cc2; + notice.cc[2] = cc3; + for (i = 0; i < (sizeof(key)/sizeof(key[0])-1); i++) + notice.item[i].data = 0; + notice.item[20] = notice.item[1] = lic[notice.type]; + notice.item[20].quote = notice.item[1].quote = 0; + contributor = i = k = 0; + for (;;) + { + first = 1; + while (c = *s) + { + while (c == ' ' || c == '\t' || c == '\n' && ++input[level].line || c == '\r' || c == ',' || c == ';' || c == ')') + c = *++s; + if (!c) + break; + if (c == '#') + { + while (*++s && *s != '\n'); + if (*s) + s++; + input[level].line++; + continue; + } + if (c == '.') + { + while ((c = *++s) && (c == ' ' || c == '\t')); + file = s; + while (c && c != ' ' && c != '\t' && c != '\r' && c != '\n') + c = *++s; + *s = 0; + while (c && c != '\n') + c = *++s; + if (*file) + { + input[level].info = s + (c != 0); + if (++level >= (sizeof(input) / sizeof(input[0])) || push(&input[level], file, input[level-1].file, data, &info[sizeof(info)] - data, &buf)) + return -1; + data += input[level].size; + s = input[level].info; + } + continue; + } + if (c == '\n') + { + s++; + input[level].line++; + continue; + } + if (c == '[') + c = *++s; + x = s; + n = 0; + while (c && c != '+' && c != '=' && c != ']' && c != ')' && c != ',' && c != ' ' && c != '\t' && c != '\n' && c != '\r') + c = *++s; + n = s - x; + h = lookup(key, x, n); + if (c == '+' || c == ']') + c = *++s; + quote = 0; + if (c == '=' || first) + { + if (c == '=') + { + q = ((c = *++s) == '"' || c == '\'') ? *s++ : 0; + if (c == '(') + { + s++; + if (h == 9) + contributor = 0; + else if (h == 4) + contributor = 1; + else + { + q = 1; + i = 0; + for (;;) + { + switch (*s++) + { + case 0: + s--; + break; + case '(': + if (!i) + q++; + continue; + case ')': + if (!i && !--q) + break; + continue; + case '"': + case '\'': + if (!i) + i = *(s - 1); + else if (i == *(s - 1)) + i = 0; + continue; + case '\\': + if (*s == i && i == '"') + i++; + continue; + case '\n': + input[level].line++; + continue; + default: + continue; + } + break; + } + } + continue; + } + v = s; + while ((c = *s) && (q == '"' && (c == '\\' && (*(s + 1) == '"' || *(s + 1) == '\\') && s++ && (quote = q)) || q && c != q || !q && c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != ',' && c != ';')) + { + if (c == '\n') + input[level].line++; + s++; + } + } + else + { + h = 20; + v = x; + } + if (c == '\n') + input[level].line++; + if (contributor) + { + for (i = 0; i < notice.ids; i++) + if (n == notice.id[i].name.size && !sstrncmp( x, notice.id[i].name.data, n)) + break; + if (i < 64) + { + notice.id[i].name.data = x; + notice.id[i].name.size = n; + notice.id[i].name.quote = 0; + notice.id[i].value.data = v; + notice.id[i].value.size = s - v; + notice.id[i].value.quote = quote; + if (notice.ids <= i) + notice.ids = i + 1; + } + } + else if (h == 16) + { + if ((s - v) == 3 && v[0] == 'a' && v[1] == 'l' && v[2] == 'l') + { + for (i = 0; i < (sizeof(key)/sizeof(key[0])-1); i++) + if (notice.item[i].size) + { + expand(¬ice, &buf, &key[i]); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '=')):(( '='),(-1))); + for (h = 0;; h++) + if (h >= notice.item[i].size) + { + h = 0; + break; + } + else if (notice.item[i].data[h] == ' ' || notice.item[i].data[h] == '\t') + break; + if (h) + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\'')):(( '\''),(-1))); + expand(¬ice, &buf, ¬ice.item[i]); + if (h) + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\'')):(( '\''),(-1))); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\n')):(( '\n'),(-1))); + } + } + else + { + if ((h = lookup(key, v, s - v)) < 0) + { + item.data = v; + item.size = s - v; + item.quote = 0; + expand(¬ice, &buf, &item); + } + else + expand(¬ice, &buf, ¬ice.item[h]); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\n')):(( '\n'),(-1))); + } + return (*(( &buf)->nxt>=( &buf)->end?(( &buf)->nxt=( &buf)->end-1):( &buf)->nxt)=0,( &buf)->nxt-( &buf)->buf); + } + else + { + if (h == 20) + switch (c = lookup(lic, v, s - v)) + { + case 0: + return 0; + case 2: + notice.test = 1; + h = -1; + break; + case 3: + notice.verbose = 1; + h = -1; + break; + case 4: + notice.type = c; + h = -1; + break; + case -1: + c = 12; + + default: + notice.type = c; + notice.item[1].data = lic[lic[c].quote].data; + notice.item[1].size = lic[lic[c].quote].size; + if (notice.item[20].data != lic[0].data) + h = -1; + break; + } + if (h >= 0) + { + notice.item[h].data = (notice.item[h].size = s - v) ? v : (char*)0; + notice.item[h].quote = quote; + k = 1; + } + } + } + else + { + if (input[level].file) + { + copy(&buf, "\"", -1); + copy(&buf, input[level].file, -1); + copy(&buf, "\", line ", -1); + x = &tmpbuf[sizeof(tmpbuf)]; + *--x = 0; + n = ++input[level].line; + do *--x = ("0123456789")[n % 10]; while (n /= 10); + copy(&buf, x, -1); + copy(&buf, ": ", -1); + } + copy(&buf, "option error: assignment expected", -1); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( 0)):(( 0),(-1))); + return -1; + } + if (*s) + s++; + first = 0; + } + if (!level--) + break; + s = input[level].info; + } + if (!k) + return 0; + if (notice.type == 1 && (!notice.verbose || !notice.item[12].data)) + return 0; + if (notice.type != 4) + { + if (!notice.type) + notice.type = 12; + comment(¬ice, &buf, ((char*)0), 1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + if (notice.item[14].data) + { + copy(&tmp, "This software is part of the ", -1); + expand(¬ice, &tmp, ¬ice.item[14]); + copy(&tmp, " package", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + if (notice.type >= 5) + { + copyright(¬ice, &tmp); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.type >= 12) + comment( ¬ice, &buf, "All Rights Reserved",sizeof( "All Rights Reserved")-1, 0); + } + if (notice.type == 6 || notice.type == 7) + { + copy(&tmp, notice.item[14].data ? "and": "This software", -1); + copy(&tmp, " is licensed under the", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.type == 7) + copy(&tmp, "Eclipse Public License", -1); + else + copy(&tmp, "Common Public License", -1); + if (notice.item[23].data) + { + copy(&tmp, ", Version ", -1); + expand(¬ice, &tmp, ¬ice.item[23]); + } + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[5].data || notice.item[2].data) + { + copy(&tmp, "by ", -1); + if (notice.item[15].data) + { + expand(¬ice, &tmp, ¬ice.item[15]); + copy(&tmp, " ", -1); + } + if (notice.item[5].data) + { + expand(¬ice, &tmp, ¬ice.item[5]); + if (notice.item[8].data) + { + copy(&tmp, " ", -1); + expand(¬ice, &tmp, ¬ice.item[8]); + } + } + else if (notice.item[2].data) + expand(¬ice, &tmp, ¬ice.item[2]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "A copy of the License is available at",sizeof( "A copy of the License is available at")-1, 0); + if (notice.item[21].data) + { + expand(¬ice, &tmp, ¬ice.item[21]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[22].data) + { + copy(&tmp, "(with md5 checksum ", -1); + expand(¬ice, &tmp, ¬ice.item[22]); + copy(&tmp, ")", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + } + else if (notice.type == 7) + comment( ¬ice, &buf, "http://www.eclipse.org/org/documents/epl-v10.html",sizeof( "http://www.eclipse.org/org/documents/epl-v10.html")-1, 0); + else + comment( ¬ice, &buf, "http://www.opensource.org/licenses/cpl",sizeof( "http://www.opensource.org/licenses/cpl")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 5) + { + copy(&tmp, notice.item[14].data ? "and it": "This software", -1); + copy(&tmp, " may only be used by you under license from", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[i = 5].data) + { + if (notice.item[15].data) + { + expand(¬ice, &tmp, ¬ice.item[i = 15]); + copy(&tmp, " ", -1); + } + expand(¬ice, &tmp, ¬ice.item[5]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + else if (notice.item[i = 2].data) + { + if (notice.item[15].data) + { + expand(¬ice, &tmp, ¬ice.item[i = 15]); + copy(&tmp, " ", -1); + } + expand(¬ice, &tmp, ¬ice.item[2]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + else + i = -1; + if (notice.item[21].data) + { + comment( ¬ice, &buf, "A copy of the Source Code Agreement is available",sizeof( "A copy of the Source Code Agreement is available")-1, 0); + copy(&tmp, "at the ", -1); + if (i >= 0) + expand(¬ice, &tmp, ¬ice.item[i]); + copy(&tmp, " Internet web site URL", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + expand(¬ice, &tmp, ¬ice.item[21]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[22].data) + { + copy(&tmp, "(with an md5 checksum of ", -1); + expand(¬ice, &tmp, ¬ice.item[22]); + copy(&tmp, ")", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + comment(¬ice, &buf, ((char*)0), 0, 0); + } + comment( ¬ice, &buf, "If you have copied or used this software without agreeing",sizeof( "If you have copied or used this software without agreeing")-1, 0); + comment( ¬ice, &buf, "to the terms of the license you are infringing on",sizeof( "to the terms of the license you are infringing on")-1, 0); + comment( ¬ice, &buf, "the license and copyright and are violating",sizeof( "the license and copyright and are violating")-1, 0); + if (i >= 0) + expand(¬ice, &tmp, ¬ice.item[i]); + copy(&tmp, "'s", -1); + if (n >= (70-32)) + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + else + ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1))); + copy(&tmp, "intellectual property rights.", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 11) + { + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "This is free software; you can redistribute it and/or",sizeof( "This is free software; you can redistribute it and/or")-1, 0); + comment( ¬ice, &buf, "modify it under the terms of the GNU General Public License",sizeof( "modify it under the terms of the GNU General Public License")-1, 0); + comment( ¬ice, &buf, "as published by the Free Software Foundation;",sizeof( "as published by the Free Software Foundation;")-1, 0); + comment( ¬ice, &buf, "either version 2, or (at your option) any later version.",sizeof( "either version 2, or (at your option) any later version.")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "This software is distributed in the hope that it",sizeof( "This software is distributed in the hope that it")-1, 0); + comment( ¬ice, &buf, "will be useful, but WITHOUT ANY WARRANTY;",sizeof( "will be useful, but WITHOUT ANY WARRANTY;")-1, 0); + comment( ¬ice, &buf, "without even the implied warranty of MERCHANTABILITY",sizeof( "without even the implied warranty of MERCHANTABILITY")-1, 0); + comment( ¬ice, &buf, "or FITNESS FOR A PARTICULAR PURPOSE.",sizeof( "or FITNESS FOR A PARTICULAR PURPOSE.")-1, 0); + comment( ¬ice, &buf, "See the GNU General Public License for more details.",sizeof( "See the GNU General Public License for more details.")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "You should have received a copy of the",sizeof( "You should have received a copy of the")-1, 0); + comment( ¬ice, &buf, "GNU General Public License",sizeof( "GNU General Public License")-1, 0); + comment( ¬ice, &buf, "along with this software (see the file COPYING.)",sizeof( "along with this software (see the file COPYING.)")-1, 0); + comment( ¬ice, &buf, "If not, a copy is available at",sizeof( "If not, a copy is available at")-1, 0); + comment( ¬ice, &buf, "http://www.gnu.org/copyleft/gpl.html",sizeof( "http://www.gnu.org/copyleft/gpl.html")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 8) + { + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "Redistribution and use in source and binary forms, with or",sizeof( "Redistribution and use in source and binary forms, with or")-1, -1); + comment( ¬ice, &buf, "without modification, are permitted provided that the following",sizeof( "without modification, are permitted provided that the following")-1, -1); + comment( ¬ice, &buf, "conditions are met:",sizeof( "conditions are met:")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, " 1. Redistributions of source code must retain the above",sizeof( " 1. Redistributions of source code must retain the above")-1, -1); + comment( ¬ice, &buf, " copyright notice, this list of conditions and the",sizeof( " copyright notice, this list of conditions and the")-1, -1); + comment( ¬ice, &buf, " following disclaimer.",sizeof( " following disclaimer.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, " 2. Redistributions in binary form must reproduce the above",sizeof( " 2. Redistributions in binary form must reproduce the above")-1, -1); + comment( ¬ice, &buf, " copyright notice, this list of conditions and the",sizeof( " copyright notice, this list of conditions and the")-1, -1); + comment( ¬ice, &buf, " following disclaimer in the documentation and/or other",sizeof( " following disclaimer in the documentation and/or other")-1, -1); + comment( ¬ice, &buf, " materials provided with the distribution.",sizeof( " materials provided with the distribution.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + copy(&tmp, " 3. Neither the name of ", -1); + if (notice.item[i = 15].data || notice.item[i = 5].data || notice.item[i = 2].data) + expand(¬ice, &tmp, ¬ice.item[i]); + else + copy(&tmp, "the copyright holder", -1); + copy(&tmp, " nor the", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), -1); + comment( ¬ice, &buf, " names of its contributors may be used to endorse or",sizeof( " names of its contributors may be used to endorse or")-1, -1); + comment( ¬ice, &buf, " promote products derived from this software without",sizeof( " promote products derived from this software without")-1, -1); + comment( ¬ice, &buf, " specific prior written permission.",sizeof( " specific prior written permission.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND",sizeof( "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND")-1, -1); + comment( ¬ice, &buf, "CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,",sizeof( "CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,")-1, -1); + comment( ¬ice, &buf, "INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF",sizeof( "INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF")-1, -1); + comment( ¬ice, &buf, "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE",sizeof( "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE")-1, -1); + comment( ¬ice, &buf, "DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS",sizeof( "DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS")-1, -1); + comment( ¬ice, &buf, "BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,",sizeof( "BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,")-1, -1); + comment( ¬ice, &buf, "EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED",sizeof( "EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED")-1, -1); + comment( ¬ice, &buf, "TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,",sizeof( "TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,")-1, -1); + comment( ¬ice, &buf, "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON",sizeof( "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON")-1, -1); + comment( ¬ice, &buf, "ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,",sizeof( "ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,")-1, -1); + comment( ¬ice, &buf, "OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY",sizeof( "OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY")-1, -1); + comment( ¬ice, &buf, "OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE",sizeof( "OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE")-1, -1); + comment( ¬ice, &buf, "POSSIBILITY OF SUCH DAMAGE.",sizeof( "POSSIBILITY OF SUCH DAMAGE.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 9) + { + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "This software is provided 'as-is', without any express or implied",sizeof( "This software is provided 'as-is', without any express or implied")-1, -1); + comment( ¬ice, &buf, "warranty. In no event will the authors be held liable for any",sizeof( "warranty. In no event will the authors be held liable for any")-1, -1); + comment( ¬ice, &buf, "damages arising from the use of this software.",sizeof( "damages arising from the use of this software.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "Permission is granted to anyone to use this software for any",sizeof( "Permission is granted to anyone to use this software for any")-1, -1); + comment( ¬ice, &buf, "purpose, including commercial applications, and to alter it and",sizeof( "purpose, including commercial applications, and to alter it and")-1, -1); + comment( ¬ice, &buf, "redistribute it freely, subject to the following restrictions:",sizeof( "redistribute it freely, subject to the following restrictions:")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, " 1. The origin of this software must not be misrepresented;",sizeof( " 1. The origin of this software must not be misrepresented;")-1, -1); + comment( ¬ice, &buf, " you must not claim that you wrote the original software. If",sizeof( " you must not claim that you wrote the original software. If")-1, -1); + comment( ¬ice, &buf, " you use this software in a product, an acknowledgment in the",sizeof( " you use this software in a product, an acknowledgment in the")-1, -1); + comment( ¬ice, &buf, " product documentation would be appreciated but is not",sizeof( " product documentation would be appreciated but is not")-1, -1); + comment( ¬ice, &buf, " required.",sizeof( " required.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, " 2. Altered source versions must be plainly marked as such,",sizeof( " 2. Altered source versions must be plainly marked as such,")-1, -1); + comment( ¬ice, &buf, " and must not be misrepresented as being the original",sizeof( " and must not be misrepresented as being the original")-1, -1); + comment( ¬ice, &buf, " software.",sizeof( " software.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, " 3. This notice may not be removed or altered from any source",sizeof( " 3. This notice may not be removed or altered from any source")-1, -1); + comment( ¬ice, &buf, " distribution.",sizeof( " distribution.")-1, -1); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 10) + { + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "Permission is hereby granted, free of charge, to any person",sizeof( "Permission is hereby granted, free of charge, to any person")-1, 0); + comment( ¬ice, &buf, "obtaining a copy of this software and associated",sizeof( "obtaining a copy of this software and associated")-1, 0); + comment( ¬ice, &buf, "documentation files (the \"Software\"), to deal in the",sizeof( "documentation files (the \"Software\"), to deal in the")-1, 0); + comment( ¬ice, &buf, "Software without restriction, including without limitation",sizeof( "Software without restriction, including without limitation")-1, 0); + comment( ¬ice, &buf, "the rights to use, copy, modify, merge, publish, distribute,",sizeof( "the rights to use, copy, modify, merge, publish, distribute,")-1, 0); + comment( ¬ice, &buf, "sublicense, and/or sell copies of the Software, and to",sizeof( "sublicense, and/or sell copies of the Software, and to")-1, 0); + comment( ¬ice, &buf, "permit persons to whom the Software is furnished to do so,",sizeof( "permit persons to whom the Software is furnished to do so,")-1, 0); + comment( ¬ice, &buf, "subject to the following conditions:",sizeof( "subject to the following conditions:")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "The above copyright notice and this permission notice shall",sizeof( "The above copyright notice and this permission notice shall")-1, 0); + comment( ¬ice, &buf, "be included in all copies or substantial portions of the",sizeof( "be included in all copies or substantial portions of the")-1, 0); + comment( ¬ice, &buf, "Software.",sizeof( "Software.")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + comment( ¬ice, &buf, "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY",sizeof( "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY")-1, 0); + comment( ¬ice, &buf, "KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE",sizeof( "KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE")-1, 0); + comment( ¬ice, &buf, "WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR",sizeof( "WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR")-1, 0); + comment( ¬ice, &buf, "PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS",sizeof( "PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS")-1, 0); + comment( ¬ice, &buf, "OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR",sizeof( "OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR")-1, 0); + comment( ¬ice, &buf, "OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR",sizeof( "OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR")-1, 0); + comment( ¬ice, &buf, "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE",sizeof( "OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE")-1, 0); + comment( ¬ice, &buf, "SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",sizeof( "SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else + { + if (notice.type == 15) + { + if (notice.item[i = 15].data || notice.item[i = 5].data || notice.item[i = 2].data) + { + expand(¬ice, &tmp, ¬ice.item[i]); + copy(&tmp, " - ", -1); + } + else + i = -1; + copy(&tmp, "Proprietary", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1); + comment(¬ice, &buf, ((char*)0), 0, 0); + if (notice.item[21].data) + { + copy(&tmp, "This is proprietary source code", -1); + if (i >= 0) + copy(&tmp, " licensed by", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1); + if (notice.item[15].data) + { + expand(¬ice, &tmp, ¬ice.item[15]); + copy(&tmp, " ", -1); + } + if (notice.item[5].data) + { + expand(¬ice, &tmp, ¬ice.item[5]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1); + } + else if (notice.item[2].data) + { + expand(¬ice, &tmp, ¬ice.item[2]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1); + } + } + else + { + copy(&tmp, "This is unpublished proprietary source code", -1); + if (i >= 0) + copy(&tmp, " of", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1); + if (notice.item[i = 15].data || notice.item[i = 5].data) + expand(¬ice, &tmp, ¬ice.item[i]); + if (notice.item[2].data) + { + if ((( &tmp)->nxt-( &tmp)->buf)) + ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1))); + expand(¬ice, &tmp, ¬ice.item[2]); + } + if ((( &tmp)->nxt-( &tmp)->buf)) + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 1); + comment( ¬ice, &buf, "and is not to be disclosed or used except in",sizeof( "and is not to be disclosed or used except in")-1, 1); + comment( ¬ice, &buf, "accordance with applicable agreements",sizeof( "accordance with applicable agreements")-1, 1); + } + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 13) + { + comment( ¬ice, &buf, "For nonexclusive individual use",sizeof( "For nonexclusive individual use")-1, 1); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 14) + { + comment( ¬ice, &buf, "For noncommercial use",sizeof( "For noncommercial use")-1, 1); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + if (notice.type >= 15 && !notice.item[21].data) + { + comment( ¬ice, &buf, "Unpublished & Not for Publication",sizeof( "Unpublished & Not for Publication")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + if (notice.item[21].data) + { + copy(&tmp, "This software is licensed", -1); + if (notice.item[5].data || notice.item[2].data) + { + copy(&tmp, " by", -1); + if ((notice.item[15].size + (notice.item[5].data ? (notice.item[5].size + notice.item[8].size) : notice.item[2].size)) >= ((70-32) - 6)) + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + else + ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1))); + if (notice.item[15].data) + { + expand(¬ice, &tmp, ¬ice.item[15]); + copy(&tmp, " ", -1); + } + if (notice.item[5].data) + { + expand(¬ice, &tmp, ¬ice.item[5]); + if (notice.item[8].data) + { + copy(&tmp, " ", -1); + expand(¬ice, &tmp, ¬ice.item[8]); + } + } + else if (notice.item[2].data) + expand(¬ice, &tmp, ¬ice.item[2]); + } + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + comment( ¬ice, &buf, "under the terms and conditions of the license in",sizeof( "under the terms and conditions of the license in")-1, 0); + expand(¬ice, &tmp, ¬ice.item[21]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[22].data) + { + copy(&tmp, "(with an md5 checksum of ", -1); + expand(¬ice, &tmp, ¬ice.item[22]); + copy(&tmp, ")", -1); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + comment(¬ice, &buf, ((char*)0), 0, 0); + } + else if (notice.type == 15) + { + comment( ¬ice, &buf, "The copyright notice above does not evidence any",sizeof( "The copyright notice above does not evidence any")-1, 0); + comment( ¬ice, &buf, "actual or intended publication of such source code",sizeof( "actual or intended publication of such source code")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + } + if (v = notice.item[12].data) + { + x = v + notice.item[12].size; + if (*v == '\n') + v++; + item.quote = notice.item[12].quote; + do + { + for (item.data = v; v < x && *v != '\n'; v++); + if ((item.size = v - item.data) && *item.data == '\t') + { + item.data++; + item.size--; + h = 0; + } + else + h = -1; + expand(¬ice, &tmp, &item); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), h); + } while (v++ < x); + if (item.size) + comment(¬ice, &buf, ((char*)0), 0, 0); + } + if (notice.item[13].data) + { + expand(¬ice, &tmp, ¬ice.item[13]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[i = 15].data || notice.item[i = 5].data) + expand(¬ice, &tmp, ¬ice.item[i]); + if (notice.item[2].data) + { + if ((( &tmp)->nxt-( &tmp)->buf)) + ((( &tmp)->nxt<( &tmp)->end)?(*( &tmp)->nxt++=( ' ')):(( ' '),(-1))); + expand(¬ice, &tmp, ¬ice.item[2]); + } + if ((( &tmp)->nxt-( &tmp)->buf)) + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + if (notice.item[10].data) + { + expand(¬ice, &tmp, ¬ice.item[10]); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + comment(¬ice, &buf, ((char*)0), 0, 0); + } + } + if (v = notice.item[0].data) + { + x = v + notice.item[0].size; + q = (x - v) == 1 && (*v == '*' || *v == '-'); + k = q && notice.type != 4 ? -1 : 0; + for (;;) + { + if (!q) + { + while (v < x && (*v == ' ' || *v == '\t' || *v == '\r' || *v == '\n' || *v == ',' || *v == '+')) + v++; + if (v >= x) + break; + item.data = v; + while (v < x && *v != ',' && *v != '+' && *v++ != '>'); + item.size = v - item.data; + item.quote = notice.item[0].quote; + } + h = 0; + for (i = 0; i < notice.ids; i++) + if (q || item.size == notice.id[i].name.size && !sstrncmp( item.data, notice.id[i].name.data, item.size)) + { + h = 1; + if (notice.type == 4) + { + copy(&buf, "[-author?", -1); + expand(¬ice, &buf, ¬ice.id[i].value); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1))); + } + else + { + if (k < 0) + { + comment( ¬ice, &buf, "CONTRIBUTORS",sizeof( "CONTRIBUTORS")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + k = 1; + expand(¬ice, &tmp, ¬ice.id[i].value); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + if (!q) + break; + } + if (q) + break; + if (!h) + { + if (notice.type == 4) + { + copy(&buf, "[-author?", -1); + expand(¬ice, &buf, &item); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1))); + } + else + { + if (k < 0) + { + comment( ¬ice, &buf, "CONTRIBUTORS",sizeof( "CONTRIBUTORS")-1, 0); + comment(¬ice, &buf, ((char*)0), 0, 0); + } + k = 1; + expand(¬ice, &tmp, &item); + comment(¬ice, &buf, (( &tmp)->buf), (( &tmp)->siz=( &tmp)->nxt-( &tmp)->buf,( &tmp)->nxt=( &tmp)->buf,( &tmp)->siz), 0); + } + } + } + if (k > 0) + comment(¬ice, &buf, ((char*)0), 0, 0); + } + if (notice.type == 4) + { + copy(&buf, "[-copyright?", -1); + copyright(¬ice, &buf); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1))); + if (notice.item[21].data) + { + copy(&buf, "[-license?", -1); + expand(¬ice, &buf, ¬ice.item[21]); + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( ']')):(( ']'),(-1))); + } + ((( &buf)->nxt<( &buf)->end)?(*( &buf)->nxt++=( '\n')):(( '\n'),(-1))); + } + else + comment(¬ice, &buf, ((char*)0), -1, 0); + return (*(( &buf)->nxt>=( &buf)->end?(( &buf)->nxt=( &buf)->end-1):( &buf)->nxt)=0,( &buf)->nxt-( &buf)->buf); +} +#line 336 "../../lib/libpp/ppproto.c" + +#line 348 +static char* +linesync __PARAM__((register Proto_t* proto, register char* p, register long n), (proto, p, n)) __OTORP__(register Proto_t* proto; register char* p; register long n;){ + + if (proto->flags & (1L<<13)) + + { + + p = strcopy(p, "\n#line "); + + + + p = number(p, n); + *p++ = '\n'; + } + return p; +} + + + + + + +static char* +init __PARAM__((Proto_t* proto, char* op, int flags), (proto, op, flags)) __OTORP__(Proto_t* proto; char* op; int flags;){ + register char* s; + + if (flags & (1L<<10)) + { + op = strcopy(op, "\ +\n\ +#if !defined(__PROTO__)\n\ +# if defined(__STDC__) || defined(__cplusplus) || defined(_proto) || defined(c_plusplus)\n\ +# if defined(__cplusplus)\n\ +# define __LINKAGE__ \"C\"\n\ +# else\n\ +# define __LINKAGE__\n\ +# endif\n\ +# define __STDARG__\n\ +# define __PROTO__(x) x\n\ +# define __OTORP__(x)\n\ +# define __PARAM__(n,o) n\n\ +# if !defined(__STDC__) && !defined(__cplusplus)\n\ +# if !defined(c_plusplus)\n\ +# define const\n\ +# endif\n\ +# define signed\n\ +# define void int\n\ +# define volatile\n\ +# define __V_ char\n\ +# else\n\ +# define __V_ void\n\ +# endif\n\ +# else\n\ +# define __PROTO__(x) ()\n\ +# define __OTORP__(x) x\n\ +# define __PARAM__(n,o) o\n\ +# define __LINKAGE__\n\ +# define __V_ char\n\ +# define const\n\ +# define signed\n\ +# define void int\n\ +# define volatile\n\ +# endif\n\ +# define __MANGLE__ __LINKAGE__\n\ +# if defined(__cplusplus) || defined(c_plusplus)\n\ +# define __VARARG__ ...\n\ +# else\n\ +# define __VARARG__\n\ +# endif\n\ +# if defined(__STDARG__)\n\ +# define __VA_START__(p,a) va_start(p,a)\n\ +# else\n\ +# define __VA_START__(p,a) va_start(p)\n\ +# endif\n\ +# if !defined(__INLINE__)\n\ +# if defined(__cplusplus)\n\ +# define __INLINE__ extern __MANGLE__ inline\n\ +# else\n\ +# if defined(_WIN32) && !defined(__GNUC__)\n\ +# define __INLINE__ __inline\n\ +# endif\n\ +# endif\n\ +# endif\n\ +#endif\n\ +#if !defined(__LINKAGE__)\n\ +#define __LINKAGE__ /* 2004-08-11 transition */\n\ +#endif\n\ +"); + } + else + op = strcopy(op, "\ +\n\ +#if !defined(__PROTO__)\n\ +#include <prototyped.h>\n\ +#endif\n\ +#if !defined(__LINKAGE__)\n\ +#define __LINKAGE__ /* 2004-08-11 transition */\n\ +#endif\n\ +"); + if (proto->package) + { + s = "\ +#ifndef __MANGLE_%_DATA__\n\ +# ifdef _BLD_%\n\ +# ifdef __EXPORT__\n\ +# define __MANGLE_%_DATA__ __MANGLE__ __EXPORT__\n\ +# else\n\ +# define __MANGLE_%_DATA__ __MANGLE__\n\ +# endif\n\ +# define __MANGLE_%_FUNC__ __MANGLE__\n\ +# else\n\ +# ifdef __IMPORT__\n\ +# define __MANGLE_%_DATA__ __MANGLE__ __IMPORT__\n\ +# else\n\ +# define __MANGLE_%_DATA__ __MANGLE__\n\ +# endif\n\ +# define __MANGLE_%_FUNC__ __MANGLE__\n\ +# endif\n\ +#endif\n\ +"; + for (;;) + { + switch (*op++ = *s++) + { + case 0: + op--; + break; + case '%': + op = strcopy(op - 1, proto->package); + continue; + default: + continue; + } + break; + } + } + return op; +} + + +#line 422 +static char* +nns __PARAM__((register char* s), (s)) __OTORP__(register char* s;){ + while (*s == ' ' || *s == '\t' || *s == '\n') + s++; + return s; +} + + +#line 439 +static int +directive __PARAM__((register char* s, int dir), (s, dir)) __OTORP__(register char* s; int dir;){ + switch (*(s = nns(s))) + { + case 'e': + case 'i': + dir <<= 2; + switch (*++s) + { + case 'f': + dir |= 01; + break; + case 'l': + dir |= 02; + break; + case 'n': + dir |= 03; + break; + } + break; + } + return dir; +} + + + + + + + +static int +lex __PARAM__((register Proto_t* proto, register long flags), (proto, flags)) __OTORP__(register Proto_t* proto; register long flags;){ + register char* ip; + register char* op; + register int c; + register int state; + register short* rp; + char* m; + char* e; + char* t; + char* bp; + char* v; + char* im; + char* ko; + char* aom; + int n; + int line; + int quot; + int brack; + int sub; + int x; + int vc; + + char* ie = 0; + char* om = 0; + char* aim = 0; + char* aie = 0; + char* func = 0; + int call = 0; + int dir = 0; + int group = 0; + int last = 0; + int paren = 0; + + char* qe = 0; + int qn = 0; + int args = 0; + + + do{(ip=proto->ip);(op=proto->op);call=proto->call;}while(0); + + if (flags & (1L<<5)) (ko=op); + + fsm_start: + proto->tp = ip; + state = 0; + bp = ip; + do + { + rp = _pp_fsmtab[state]; + fsm_get: + while (!(state = rp[c = (*(unsigned char*)ip++)])); + fsm_next: + ; + } while (state > 0); + if ((n = ip - bp - 1) > 0) + { + ip = bp; + do switch( n) { default : memcopy( op, ip, n); op += n; ip += n; break; case 7 : * op++ = * ip++; case 6 : * op++ = * ip++; case 5 : * op++ = * ip++; case 4 : * op++ = * ip++; case 3 : * op++ = * ip++; case 2 : * op++ = * ip++; case 1 : * op++ = * ip++; case 0 : break; } while (0); + ip++; + } + state = ~state; + fsm_terminal: + switch ((( state)&((1<<(7+1))-1))) + { + case ((0+28)+11): + if (op > proto->ob && *(op - 1) == '=' && (op == proto->ob + 1 || *(op - 2) != '=')) switch (c) + { + case '+': + case '-': + case '*': + case '&': + (*op++=( ' ')); + break; + } + (*op++=( c)); + break; + + case ((0+28)+0): + (ip--); + c = (*(op-1)); + break; + + case ((0+28)+1): + switch (c) + { + case '\n': + if ((( rp)>=_pp_fsmtab[(0+16)]&&( rp)<=_pp_fsmtab[(0+18)])) goto fsm_newline; + (*op++=( c)); + proto->line++; + rp = _pp_fsmtab[(0+13)]; + break; + case '/': + + if ((flags & ((1L<<5)|(1L<<15))) == (1L<<5)) (op=ko); + else + + (*op++=( c)); + if ((( rp)>=_pp_fsmtab[(0+16)]&&( rp)<=_pp_fsmtab[(0+18)])) + { + rp = _pp_fsmtab[(0+16)]; + break; + } + goto fsm_start; + case (255+1): + break; + default: + + if ((flags & ((1L<<5)|(1L<<15))) == (1L<<5)) (op=ko); + else + + (*op++=( c)); + rp = _pp_fsmtab[(( rp)>=_pp_fsmtab[(0+16)]&&( rp)<=_pp_fsmtab[(0+18)]) ? (0+16) : (0+14)]; + break; + } + bp = ip; + goto fsm_get; + + case ((0+28)+2): + if (c) + { + if (state = _pp_fsmtab[(0+28)][((( rp)-_pp_fsmtab[0])/(255+1))+1]) + goto fsm_terminal; + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return 0; + } + (ip--); + fsm_eob: + if ((flags & ((1L<<1)|((1L<<16))|(1L<<21))) == ((1L<<16)) && (proto->flags & (1L<<16))) + { + + if (!(flags & (1L<<5))) + + flags |= (1L<<24); + c = ip - proto->ib; + if (!(flags & (1L<<15))) + im = proto->tp; + if (ip > proto->ib) + { + n = ip - im; + if (ip - n < proto->ib) + proto->flags |= (1L<<4); + memcopy(proto->ib - n, ip - n, n); + ip = proto->ib; + } + proto->tp -= c; + if (flags & (1L<<15)) + { + im -= c; + ie -= c; + } + if (aim) + aim -= c; + if (aie) + aie -= c; + if ((n = read(proto->fd, ip, proto->iz)) > 0) + { + if ((proto->options & (1L<<0)) && n < proto->iz) + { + proto->flags &= ~(1L<<16); + close(proto->fd); + } + *(ip + n) = 0; + if (state & (1<<7)) + goto fsm_splice; + bp = ip; + goto fsm_get; + } + *ip = 0; + proto->flags &= ~(1L<<16); + close(proto->fd); + } + if (state & (1<<7)) + goto fsm_splice; + + if (!(flags & (1L<<21)) && (state = rp[c = (255+1)])) + { + bp = ip; + goto fsm_next; + } + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return 0; + + case ((0+28)+3): + quot = c; + + if (c == '"' && qe) + { + for (n = 0, t = qe + 1; t < op && (*t == ' ' || *t == '\t' || *t == '\n' && ++n || *t >= 'A' && *t <= 'Z' || *t == '_'); t++); + if (t == op) + { + op = qe; + qe = 0; + qn = n; + } + else (*op++=( c)); + } + else + + (*op++=( c)); + rp = _pp_fsmtab[(0+21)]; + bp = ip; + goto fsm_get; + + case ((0+28)+4): + if (c == quot) + { + + if (!(flags & (1L<<3))) + qe = (c == '"') ? op : (char*)0; + + (*op++=( c)); + + while (qn > 0) + { + qn--; + (*op++=( '\n')); + } + + } + else if (c != '\n' && c != (255+1)) + { + (*op++=( c)); + bp = ip; + goto fsm_get; + } + else + { + + while (qn > 0) + { + qn--; + (*op++=( '\n')); + } + + (ip--); + } + c = (0401+1); + break; + + case ((0+28)+5): + + if (flags & (1L<<0)) (*op++=( c)); + else + + switch (c) + { + case 'a': + n = (('A'==0301)?0057:0007); + goto fsm_oct; + case 'E': + n = (('A'==0301)?0047:0033); + goto fsm_oct; + case 'v': + n = 0013; + goto fsm_oct; + case 'x': + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + lex(proto, (flags & ((1L<<16))) | (1L<<21)); + for (n = x = 0; (c = (*(unsigned char*)ip++)), x < 3; x++) switch (c) + { + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + case '8': case '9': + n = (n << 4) + c - '0'; + break; + case 'a': case 'b': case 'c': case 'd': + case 'e': case 'f': + n = (n << 4) + c - 'a' + 10; + break; + case 'A': case 'B': case 'C': case 'D': + case 'E': case 'F': + n = (n << 4) + c - 'A' + 10; + break; + default: + goto fsm_hex; + } + fsm_hex: + (ip--); + fsm_oct: + (*op++=( ((n >> 6) & 07) + '0')); + (*op++=( ((n >> 3) & 07) + '0')); + (*op++=( (n & 07) + '0')); + break; + default: + (*op++=( c)); + break; + } + rp = _pp_fsmtab[(0+21)]; + bp = ip; + goto fsm_get; + + case ((0+28)+6): + (ip--); + + if ((flags & (1L<<5)) && *proto->tp == 's' && !sstrncmp( proto->tp, "static", 6)) + { + c = ((0500+4)+9); + break; + } + + if (*proto->tp == '_' && !sstrncmp( proto->tp, "__STDPP__directive", 6)) c = '#'; + else c = (0401+0); + + break; + + case ((0+28)+7): + fsm_newline: + proto->line++; + + if (flags & (1L<<5)) + { + if (op != proto->ob && (*(op-1)) != ' ' && (*(op-1)) != '\n') + (*op++=( ' ')); + } + else + + (*op++=( c)); + if (flags & (1L<<3)) + { + + if (flags & (1L<<0)) + { + if (flags & (1L<<5)) (op=ko); + if (flags & (1L<<12)) + { + *(ip - 1) = 0; + op = strcopy(om, "/* "); + op = strcopy(op, im); + op = strcopy(op, " */\n"); + } + flags &= ~((1L<<2)|(1L<<3)|(1L<<7)|(1L<<8)|(1L<<12)|(1L<<15)|(1L<<22)|(1L<<26)); + } + else + + { + if ((flags & ((1L<<2)|(1L<<22))) == ((1L<<2)|(1L<<22))) + { + *(ip - 1) = 0; + op = strcopy(om, "#if defined(__STDC__) || defined(__STDPP__)\n"); + op = strcopy(op, im); + op = strcopy(op, "\n#else\n"); + bp = ip; + ip = im; + *op++ = *ip++; + while (*op = *ip++) + if (*op++ == '#' && *ip != '(') + { + op--; + while (*--op == ' ' || *op == '\t'); + if (*ip == '#') + { + op = strcopy(op + 1, "/**/"); + while (*++ip == ' ' || *ip == '\t'); + } + else + { + if (*op != '"') *++op = '"'; + op++; + while (*ip == ' ' || *ip == '\t') ip++; + while ((c = *ip) >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c == '_') *op++ = *ip++; + while (*ip == ' ' || *ip == '\t') ip++; + if (*ip == '"') ip++; + else *op++ = '"'; + } + } + ip = bp; + op = strcopy(op, "\n#endif\n"); + op = linesync(proto, op, proto->line); + } + flags &= ~((1L<<2)|(1L<<3)|(1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<22)|(1L<<23)|(1L<<25)|(1L<<26)); + } + call = 0; + group = 0; + paren = 0; + last = '\n'; + } + if (paren == 0 && (flags & ((1L<<15)|(1L<<21)|(1L<<23)|(1L<<24))) == (1L<<24)) + { + + if (flags & (1L<<5)) (op=ko); + + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return 0; + } + goto fsm_start; + + case ((0+28)+8): + (*op++=( c)); + rp = _pp_fsmtab[((( state)>>(7+1))&((1<<7)-1))]; + bp = ip; + goto fsm_get; + + case ((0+28)+13): + (*op++=( c)); + c = (((( state)>>(7+1))&((1<<7)-1))+0401); + break; + + case ((0+28)+14): + (ip--); + c = (((( state)>>(7+1))&((1<<7)-1))+0401); + break; + + case (((0+28)+12)): + (ip--); + c = (0401+0); + if (!(flags & (1L<<1))) switch (((((long)( *proto->tp))<<16)|(((long)( *(ip - 1)))<<8)|((long)( ip - proto->tp)))) + { + case ((((long)( 'N'))<<16)|(((long)( 'N'))<<8)|((long)( 3))): + if (proto->tp[1] == 'o') + c = ((0500+4)+6); + break; + case ((((long)( 'd'))<<16)|(((long)( 'o'))<<8)|((long)( 2))): + c = ((0500+4)+6); + break; + case ((((long)( 'e'))<<16)|(((long)( 'e'))<<8)|((long)( 4))): + if (!(flags & (1L<<21)) && (flags & ((1L<<3)|(1L<<25))) != (1L<<3) && !sstrncmp( proto->tp, "else", 4)) + { + c = ((0500+4)+8); + goto fsm_id; + } + break; + case ((((long)( 'e'))<<16)|(((long)( 'n'))<<8)|((long)( 6))): + if (!sstrncmp( proto->tp, "extern", 6)) + c = ((0500+4)+9); + break; + case ((((long)( 'f'))<<16)|(((long)( 'r'))<<8)|((long)( 3))): + if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "for", 3)) + { + c = ((0500+4)+11); + goto fsm_id; + } + break; + case ((((long)( 'i'))<<16)|(((long)( 'f'))<<8)|((long)( 2))): + c = ((0500+4)+13); + break; + case ((((long)( 'i'))<<16)|(((long)( 'e'))<<8)|((long)( 6))): + if (!sstrncmp( proto->tp, "inline", 6) && !(flags & ((1L<<15)|(1L<<23)|(1L<<25)|(1L<<26))) && proto->brace == 0 && paren == 0 && group == 0 && (last == ';' || last == '}' || last == '\n' || last == 0)) + { + flags |= (1L<<23); + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + line = proto->line; + op = strcopy(op - 6, "__INLINE__"); + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + } + break; + case ((((long)( 'r'))<<16)|(((long)( 'n'))<<8)|((long)( 6))): + if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "return", 6)) + { + c = ((0500+4)+17); + goto fsm_id; + } + break; + case ((((long)( 's'))<<16)|(((long)( 'c'))<<8)|((long)( 6))): + if ((proto->options & (1L<<6)) && !sstrncmp( proto->tp, "static", 6)) + { + proto->ox = op - 6; + flags |= (1L<<6); + } + break; + case ((((long)( 't'))<<16)|(((long)( 'f'))<<8)|((long)( 7))): + if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "typedef", 7)) + { + flags |= (1L<<26); + c = ((0500+4)+9); + } + break; + case ((((long)( 'v'))<<16)|(((long)( 't'))<<8)|((long)( 8))): + if (*ip == '(' && !sstrncmp( proto->tp, "va_start", 8)) c = (0500+1); + break; + case ((((long)( 'v'))<<16)|(((long)( 'd'))<<8)|((long)( 4))): + if (!sstrncmp( proto->tp, "void", 4)) + { + if (flags & ((1L<<0)|(1L<<19)|(1L<<10)|(1L<<11))) c = ((0500+4)+30); + else + { + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + line = proto->line; + if (lex(proto, (flags & ((1L<<16))) | (1L<<21)) == '*') + { + memcopy(op - 4, "__V_", 4); + memcopy(ip - 4, "__V_", 4); + } + else c = ((0500+4)+30); + proto->line = line; + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + bp = ip; + } + } + break; + case ((((long)( 'w'))<<16)|(((long)( 'e'))<<8)|((long)( 5))): + if (!(flags & (1L<<21)) && !sstrncmp( proto->tp, "while", 5)) + { + c = ((0500+4)+26); + goto fsm_id; + } + break; + } + + if ((flags & (1L<<0)) && c != ((0500+4)+9)) + c = (0401+0); + + break; + + case ((0+28)+10): + goto fsm_start; + + case ((0+28)+15): + (ip--); + + if ((flags & ((1L<<5)|(1L<<15))) == (1L<<5)) + { + while (op > proto->ob && (*(op - 1) == ' ' || *(op - 1) == '\t')) + op--; + if (op > proto->ob && *(op - 1) != '\n') *op++ = ' '; + } + + goto fsm_start; + + default: + if (state & (1<<7)) + { + if (c == '\\') + { + if (!(n = (*(unsigned char*)ip++))) + { + goto fsm_eob; + fsm_splice: + c = '\\'; + n = (*(unsigned char*)ip++); + } + if (n == '\n') + { + proto->line++; + (*op++=( '\\')); + (*op++=( '\n')); + bp = ip; + goto fsm_get; + } + (ip--); + } + state &= ~(1<<7); + if (state >= (0+28)) + goto fsm_terminal; + rp = _pp_fsmtab[state]; + } + (*op++=( c)); + bp = ip; + goto fsm_get; + } + if (!(flags & ((1L<<10)|(1L<<11)|(1L<<21)))) + { + if (!(flags & (1L<<3))) switch (c) + { + case '(': + + if (!(flags & (1L<<0)) || proto->brace == 0) + + { + if (paren++ == 0) + { + + if (!(flags & (1L<<0)) || group <= 1) + + { + + args = 0; + + if (group++ == 0) group++; + else if (flags & (1L<<8)) call++; + flags |= (1L<<15); + im = ip - 1; + om = op - 1; + } + sub = 0; + } + else if (paren == 2 && !aim) + { + sub++; + if (last == '(') + { + flags &= ~(1L<<15); + om = 0; + } + else if (flags & (1L<<8)) + { + aim = ip - 1; + aom = op - 1; + } + else if ((flags & ((1L<<15)|(1L<<25))) == (1L<<15)) + { + for (m = ip - 2; m > im && (*m == ' ' || *m == '\t'); m--); + if (m != im && sub == 1) + { + m = im + (*nns(ip) == '*'); + } + if (m == im) + { + flags &= ~(1L<<15); + om = 0; + } + } + else if ((flags & (1L<<15)) && sub == 1 && *nns(ip) != '*') + { + flags &= ~(1L<<15); + om = 0; + } + } + flags &= ~(1L<<25); + } + break; + case ')': + + if (!(flags & (1L<<0)) || proto->brace == 0) + + if (--paren == 0) + { + + if (flags & (1L<<0)) + { + if (group != 2) + { + c = (0401+0); + break; + } + group++; + } + + ie = ip; + } + else if (paren == 1 && (flags & (1L<<8)) && !aie) + aie = ip; + break; + case '*': + if (last == '(' && group == 2) + { + group--; + if (paren == 1) + { + flags |= (1L<<8); + aim = aie = 0; + } + } + break; + case '#': + dir = directive(ip, dir); + if (proto->brace == 0 && paren == 0 && last != '=' && (flags & ((1L<<0)|(1L<<1)|(1L<<3)|(1L<<15)|(1L<<19)|(1L<<23)|(1L<<25))) == ((1L<<15)|(1L<<25)) && ((dir & 03) != 03 || ((dir>>2) & 03) != 01)) + flags |= (1L<<3); + else if (!(flags & ((1L<<1)|(1L<<3)))) + { + flags |= (1L<<3); + if (!(flags & (1L<<19))) + { + bp = ip; + while (*ip == ' ' || *ip == '\t') ip++; + if (*ip == 'l' && *++ip == 'i' && *++ip == 'n' && *++ip == 'e') + { + if (*++ip == ' ' || *ip == '\t') + { + proto->line = 0; + while (*++ip >= '0' && *ip <= '9') + proto->line = proto->line * 10 + *ip - '0'; + proto->line--; + } + } + + else if ((flags & ((1L<<0)|(1L<<5))) == (1L<<0)) + { + n = 0; + t = ip + 6; + while (ip < t && *ip >= 'a' && *ip <= 'z') + n = ((( n)<<5)+(( *ip++)-('a'-1))); + switch (n) + { + case ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'l')-('a'-1))))<<5)+(( 's')-('a'-1))))<<5)+(( 'e')-('a'-1))): + case ((( ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'n')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'i')-('a'-1))))<<5)+(( 'f')-('a'-1))): + while (*ip == ' ' || *ip == '\t') ip++; + if (*ip != '\n' && *ip != '/' && *(ip + 1) != '*') + { + flags |= (1L<<12)|(1L<<15); + im = ip; + om = op + (ip - bp); + } + break; + case ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'l')-('a'-1))))<<5)+(( 'i')-('a'-1))))<<5)+(( 'f')-('a'-1))): + case ((( ((( ((( ((( (( 'e')-('a'-1)))<<5)+(( 'r')-('a'-1))))<<5)+(( 'r')-('a'-1))))<<5)+(( 'o')-('a'-1))))<<5)+(( 'r')-('a'-1))): + case ((( (( 'i')-('a'-1)))<<5)+(( 'f')-('a'-1))): + case ((( ((( ((( ((( (( 'i')-('a'-1)))<<5)+(( 'f')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))): + case ((( ((( ((( ((( ((( (( 'i')-('a'-1)))<<5)+(( 'f')-('a'-1))))<<5)+(( 'n')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))): + case ((( ((( ((( ((( (( 'u')-('a'-1)))<<5)+(( 'n')-('a'-1))))<<5)+(( 'd')-('a'-1))))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))): + break; + case ((( ((( ((( ((( ((( (( 'i')-('a'-1)))<<5)+(( 'n')-('a'-1))))<<5)+(( 'c')-('a'-1))))<<5)+(( 'l')-('a'-1))))<<5)+(( 'u')-('a'-1))))<<5)+(( 'd')-('a'-1))): + if (*ip == 'e') ip++; + + case ((( ((( ((( ((( ((( (( 'd')-('a'-1)))<<5)+(( 'e')-('a'-1))))<<5)+(( 'f')-('a'-1))))<<5)+(( 'i')-('a'-1))))<<5)+(( 'n')-('a'-1))))<<5)+(( 'e')-('a'-1))): + case ((( ((( ((( ((( ((( (( 'p')-('a'-1)))<<5)+(( 'r')-('a'-1))))<<5)+(( 'a')-('a'-1))))<<5)+(( 'g')-('a'-1))))<<5)+(( 'm')-('a'-1))))<<5)+(( 'a')-('a'-1))): + if (*ip < 'a' || *ip > 'z') break; + + default: + flags |= (1L<<12)|(1L<<15); + im = bp - 1; + om = op - 1; + break; + } + } + else + + { + if (*ip == 'i' && *++ip == 'n' && *++ip == 'c' && *++ip == 'l' && *++ip == 'u' && *++ip == 'd' && *++ip == 'e') + { + while (*++ip == ' ' || *ip == '\t'); + if (*ip++ == '<' && *ip++ == 's' && *ip++ == 't' && *ip++ == 'd' && *ip++ == 'a' && *ip++ == 'r' && *ip++ == 'g' && *ip++ == '.' && *ip++ == 'h' && *ip++ == '>') + { + op = strcopy(op, "\ +if !defined(va_start)\n\ +#if defined(__STDARG__)\n\ +#include <stdarg.h>\n\ +#else\n\ +#include <varargs.h>\n\ +#endif\n\ +#endif\n\ +"); + op = linesync(proto, op, proto->line); + break; + } + } + else if (*ip == 'd' && *++ip == 'e' && *++ ip == 'f' && *++ip == 'i' && *++ip == 'n' && *++ip == 'e' && (*++ip == ' ' || *ip == '\t')) + { + while (*++ip == ' ' || *ip == '\t'); + if (*ip == 'e' && *++ip == 'x' && *++ ip == 't' && *++ip == 'e' && *++ip == 'r' && *++ip == 'n' && (*++ip == ' ' || *ip == '\t')) + { + t = ip; + while (*++t == ' ' || *t == '\t'); + if (*t == 'e' && *++t == 'x' && *++ t == 't' && *++t == 'e' && *++t == 'r' && *++t == 'n' && (*++t == ' ' || *t == '\t' || *t == '\n' || *t == '\r')) + ip = t; + t = ip; + while (*++t == ' ' || *t == '\t'); + if (*t == '_' && *(t + 1) == '_') + { + op = strcopy(op, "undef __MANGLE__\n"); + op = linesync(proto, op, proto->line); + op = strcopy(op, "#define __MANGLE__ __LINKAGE__"); + break; + } + } + flags |= (1L<<2)|(1L<<15); + im = bp - 1; + om = op - 1; + } + else if (*ip == 'u' && *++ip == 'n' && *++ ip == 'd' && *++ip == 'e' && *++ip == 'f' && (*++ip == ' ' || *ip == '\t')) + { + while (*++ip == ' ' || *ip == '\t'); + if (*ip == 'e' && *++ip == 'x' && *++ ip == 't' && *++ip == 'e' && *++ip == 'r' && *++ip == 'n' && (*++ip == ' ' || *ip == '\t' || *ip == '\n' || *ip == '\r')) + { + op = strcopy(op, "undef __MANGLE__\n"); + op = linesync(proto, op, proto->line); + op = strcopy(op, "#define __MANGLE__ __LINKAGE__"); + break; + } + flags |= (1L<<2)|(1L<<15); + im = bp - 1; + om = op - 1; + } + } + ip = bp; + } + break; + } + else + break; + + case '{': + if (proto->brace++ == 0 && paren == 0) + { + if (last == '=') flags |= (1L<<9); + + else if (flags & (1L<<0)) + { + if ((flags & ((1L<<15)|(1L<<17)|(1L<<23))) == (1L<<15)) + { + if (args) + { + v = number(op, args < 0 ? -args : args); + v = strcopy(v, " argument actual/formal mismatch"); + *v++ = ' '; + v = memcopy(v, im, ie - im); + *v = 0; + proto_error((char*)proto + sizeof(Proto_t), 2, op, ((char*)0)); + } + ip--; + + v = ie; + while (ie < ip) + if (*ie++ == '/' && *ie == '*') + { + e = ie - 1; + while (++ie < ip) + { + if (*ie == '*') + { + while (ie < ip && *ie == '*') ie++; + if (ie < ip && *ie == '/') + { + while (++ie < ip && (*ie == ' ' || *ie == '\t')); + while (e > v && (*(e - 1) == ' ' || *(e - 1) == '\t')) e--; + if (e > v && *e != '\n') *e++ = ' '; + t = ie; + while (--e >= v) + *--t = *e; + v = t; + break; + } + } + } + } + ie = v; + + op = om++; + if (flags & (1L<<5)) + { + v = op; + while (v > ko && *--v != ' '); + if (*v != ' ') + { + om = (v = (op += 4)) + 1; + while (v >= ko + 4) + { + *v = *(v - 4); + v--; + } + memcopy(ko, "int ", 4); + } + if (*v == ' ') + { + while (*(v + 1) == '*') + *v++ = '*'; + *v = '\t'; + if ((v - ko) <= 8) + { + om = (e = ++op) + 1; + while (e > v) + { + *e = *(e - 1); + e--; + } + } + } + om = (v = (op += 7)) + 1; + while (v >= ko + 7) + { + *v = *(v - 7); + v--; + } + memcopy(ko, "extern ", 7); + } + (*op++=( '(')); + t = op; + e = 0; + + while (ie < ip) + { + if ((c = *ie) == ' ' || c == '\t' || c == '\n') + { + while ((c = *++ie) == ' ' || c == '\t' || c == '\n'); + if (ie >= ip) break; + if (c != '*' && op > om) (*op++=( ' ')); + } + if ((n = ((c = *ie) == ',')) || c == ';') + { + if (flags & (1L<<5)) + { + m = op; + while (op > om && ((c = *(op - 1)) == '(' || c == ')' || c == '[' || c == ']')) + op--; + v = op; + while (op > om && (c = *(op - 1)) != ' ' && c != '*') + op--; + while (*(op - 1) == ' ') + op--; + if (!e) + { + e = op; + while (e > om && *(e - 1) == '*') + e--; + } + + + + + if (op <= om) + op = strcopy(op, "int"); + else if (*(op - 1) == ',') + op = strcopy(op, " int"); + + while (v < m) + (*op++=( *v++)); + } + (*op++=( ',')); + if (n) + { + if (x = !e) e = op - 1; + (*op++=( ' ')); + m = t; + while (m < e) + (*op++=( *m++)); + if (x) + { + m = e; + while (*--e != ' '); + while (*(e - 1) == '*') e--; + op -= m - e; + } + } + while ((c = *++ie) == ' ' || c == '\t' || c == '\n'); + if (ie >= ip) (op--); + else (*op++=( ' ')); + if (!n) + { + t = op; + e = 0; + } + } + else if (*ie == '*') + { + if (op > om && (c = *(op - 1)) == ' ') op--; + while (*ie == '*') (*op++=( *ie++)); + while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++; + if (c != '(') (*op++=( ' ')); + } + else if (*ie == '(') + { + if (op > om && *(op - 1) == ' ') op--; + (*op++=( *ie++)); + while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++; + } + else if (*ie == ')') + { + if (op > om && *(op - 1) == '(') + proto_error((char*)proto + sizeof(Proto_t), 1, "function pointer argument prototype omitted", ((char*)0)); + (*op++=( *ie++)); + while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++; + } + else if ((flags & (1L<<5)) && (op == om || *(op - 1) == ' ') && *ie == 'r' && !sstrncmp( ie, "register", 8) && (*(ie + 8) == ' ' || *(ie + 8) == '\t' || *(ie + 8) == '\n')) + { + ie += 8; + if (op > om) (op--); + } + else (*op++=( *ie++)); + } + + if (op <= om) op = strcopy(op, "void"); + (*op++=( ')')); + if (flags & (1L<<5)) + { + (*op++=( ';')); + (*op++=( '\n')); + (proto->op=op); + (ko=op); + } + else + { + (*op++=( '\n')); + (*op++=( *ip)); + } + ip++; + flags &= ~((1L<<15)|(1L<<23)); + } + } + + else if ((flags & ((1L<<15)|(1L<<19)|(1L<<23)|(1L<<25))) == ((1L<<15)|(1L<<25))) + { + line = proto->line; + op = strcopy(om, " __PARAM__("); + op = memcopy(op, im, ie - im); + (*op++=( ',')); + (*op++=( ' ')); + (*op++=( '(')); + flags &= ~((1L<<15)|(1L<<23)); + if (flags & (1L<<27)) + { + if ((vc = ie - im + 1) > sizeof(proto->variadic)) vc = sizeof(proto->variadic); + memcopy(proto->variadic, im, vc); + op = strcopy(op, "va_alist)) __OTORP__(va_dcl)\n{"); + } + else + { + flags |= (1L<<23); + proto->ip = im; + proto->op = op; + group = 0; + brack = 0; + for (;;) + { + switch (lex(proto, (flags & ((1L<<16))) | (1L<<21))) + { + case '[': + brack++; + continue; + case ']': + brack--; + continue; + case '(': + if (paren++) group++; + continue; + case ')': + if (--paren == 0) + { + group = 0; + if (flags & (1L<<15)) + { + flags &= ~((1L<<15)|(1L<<23)); + op = memcopy(op, m, e - m); + } + break; + } + continue; + case ',': + if (paren == 1) + { + group = 0; + if (flags & (1L<<15)) + { + flags &= ~((1L<<15)|(1L<<23)); + op = memcopy(op, m, e - m); + } + (*op++=( ',')); + (*op++=( ' ')); + proto->op = op; + } + continue; + case (0401+0): + if (group <= 1 && !brack) + { + flags |= (1L<<15); + m = proto->tp; + e = proto->ip; + } + continue; + default: + continue; + } + break; + } + (*op++=( ')')); + (*op++=( ')')); + } + if (!(flags & (1L<<23))) + { + flags |= (1L<<23); + proto->op = strcopy(op, " __OTORP__("); + proto->ip = im + 1; + n = *(ie - 1); + *(ie - 1) = ';'; + c = *ie; + *ie = 0; + lex(proto, (flags & ((1L<<16))) | (1L<<1)); + *(ie - 1) = n; + *ie = c; + proto->ip = ie; + op = proto->op; + (*op++=( ')')); + } + if (flags & (1L<<6)) memcopy( proto->ox, "extern", 6); + op = linesync(proto, op, proto->line = line); + if (flags & (1L<<3)) + { + proto->brace = 0; + (*op++=( '\n')); + (*op++=( '#')); + } + else if (!(flags & (1L<<27))) (*op++=( '{')); + } + } + flags &= ~((1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<23)); + call = 0; + group = 0; + break; + case '}': + flags &= ~((1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<23)|(1L<<25)); + if (--proto->brace == 0) + { + flags &= ~((1L<<9)|(1L<<27)|(1L<<28)); + + if (flags & (1L<<5)) (op=ko); + + } + call = 0; + group = 0; + paren = 0; + break; + case '=': + if (last == '?') flags |= (1L<<3); + else if (paren == 0 && (flags & ((1L<<9)|(1L<<15)|(1L<<23))) == (1L<<15)) + { + if (last == ')' && proto->brace && (group != 2 || call != 2)) flags |= (1L<<23); + else goto fsm_statement; + } + goto fsm_other; + case ',': + + if (flags & (1L<<0)) + { + if (paren == 1) args++; + else + { + args--; + flags &= ~(1L<<15); + } + break; + } + + if (paren == 0 && (flags & (1L<<1))) *(op - 1) = c = ';'; + + case ';': + fsm_statement: + if (flags & (1L<<9)) ; + + else if (flags & (1L<<0)) + { + if (paren == 0) + { + if ((flags & (1L<<15)) && last == ')') + flags &= ~(1L<<15); + if (!(flags & (1L<<15))) + { + call = 0; + group = 0; + flags &= ~(1L<<23); + if (flags & (1L<<5)) (op=ko); + if (flags & (1L<<24)) + { + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return 0; + } + } + else + { + args--; + if ((flags & ((1L<<5)|(1L<<23))) == ((1L<<5)|(1L<<23))) + (op=ko); + } + } + } + + else if (paren == 0) + { + if ((flags & ((1L<<15)|(1L<<17)|(1L<<23))) == (1L<<15) && call > 1) + { + if ((flags & (1L<<14)) && func) + { + func[0] = 'F'; + func[1] = 'U'; + func[2] = 'N'; + func[3] = 'C'; + func = 0; + } + if ((flags & ((1L<<1)|(1L<<8))) == (1L<<8) && aim && aie < im) + { + while (aie < ip && (*aie == ' ' || *aie == '\t' || *aie == '\n')) aie++; + v = aim; + while (v < aie) + if (*v++ == ')') break; + while (v < aie && (*v == ' ' || *v == '\t' || *v == '\n')) v++; + if (v == aie || !(flags & (1L<<20))) + { + if (flags & (1L<<20)) n = 3; + else if (v == aie && *v == '(') n = 10; + else n = 11; + ko = op; + om += n; + v = op += n; + while (v >= ko + n) + { + *v = *(v - n); + v--; + } + if (flags & (1L<<20)) memcopy(aom, "(...))", 6); + else if (n == 10) memcopy(aom, "(__VARARG__))", 13); + else + { + ko = strcopy(aom, " __PROTO__("); + ko = memcopy(ko, aim, aie - aim); + *ko = ')'; + if (++ko >= om) + { + *ko++ = ')'; + om = ko; + } + } + } + } + else if (flags & (1L<<26)) + { + op = om; + while (*--op == ' ' || *op == '\t' || *op == '\n'); + if (*op != ')') + { + op = om += 14; + *--op = ')'; + while ((x = *(op - 14)) >= 'A' && x <= 'Z' || x >= 'a' && x <= 'z' || x >= '0' && x <= '9' || x == '_') + *--op = x; + memcopy(op - 13, "(__OTORP__(*)", 13); + } + } + if (flags & (1L<<17)) + ; + else if (flags & (1L<<20)) + { + op = om; + if (!(flags & (1L<<25))) op = strcopy(op, "(...)"); + else op = memcopy(op, im, ie - im); + (*op++=( c)); + } + else + { + if (flags & (1L<<1)) op = strcopy(om, "()"); + else if (!(flags & (1L<<25))) op = strcopy(om, "(__VARARG__)"); + else + { + op = strcopy(om, " __PROTO__("); + op = memcopy(op, im, ie - im); + (*op++=( ')')); + } + if (flags & (1L<<6)) memcopy( proto->ox, "extern", 6); + (*op++=( c)); + } + flags &= ~((1L<<15)|(1L<<27)|(1L<<28)); + if (c == ',' && !(flags & (1L<<8))) + { + call = 1; + group = 0; + break; + } + } + else if (flags & ((1L<<17)|(1L<<23))) call = 0; + if (c == ';') + { + flags &= ~((1L<<6)|(1L<<14)|(1L<<25)|(1L<<26)); + call = 0; + if (flags & (1L<<24)) + { + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return 0; + } + } + else call = call > 1 && c == ','; + group = 0; + flags &= ~((1L<<7)|(1L<<8)|(1L<<15)|(1L<<17)|(1L<<23)); + } + else if (paren == 1 && group == 1 && !(flags & ((1L<<7)|(1L<<14)))) flags |= (1L<<25)|(1L<<17); + break; + case ((0500+4)+6): + case ((0500+4)+13): + flags |= (1L<<25)|(1L<<23); + break; + case ((0500+4)+9): + + if (flags & (1L<<0)) + { + if (proto->brace == 0) + flags |= (1L<<23); + } + else + + if (paren == 0 && !(flags & (1L<<26))) + { + flags |= (1L<<14); + if (!(flags & (1L<<19)) || proto->package) + { + op = strcopy(op, " __MANGLE__"); + if (proto->package) + { + op = strcopy(op - 1, proto->package); + func = op + 1; + op = strcopy(op, "_DATA__"); + } + } + else + func = 0; + } + break; + case (0401+29): + if (paren == 0 && (flags & ((1L<<1)|(1L<<27))) == (1L<<1)) + { + op -= 3; + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return c; + } + if (paren == 1 && !(flags & (1L<<23))) + flags |= (1L<<27); + flags |= (1L<<25); + break; + case ((0500+4)+30): + goto fsm_id; + case (0500+1): + if ((flags & ((1L<<19)|(1L<<27))) == (1L<<27)) + { + flags &= ~(1L<<15); + line = proto->line; + op = strcopy(op - 8, "__VA_START__"); + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + for (;;) + { + switch (lex(proto, (flags & ((1L<<16))) | (1L<<21))) + { + case 0: + case ';': + break; + case (0401+0): + if (!(flags & (1L<<15))) + { + flags |= (1L<<15); + m = proto->tp; + e = proto->ip; + } + continue; + default: + continue; + } + break; + } + do{(ip=proto->ip);(op=proto->op);call=proto->call;}while(0); + if (flags & (1L<<15)) + { + v = m; + n = e - m; + } + else + { + v = "ap"; + n = 2; + } + op = strcopy(op, " __OTORP__("); + proto->ip = proto->variadic; + proto->op = op; + flags &= ~(1L<<15); + group = 0; + bp = proto->ip + 1; + if (*bp == 'r' && !sstrncmp( bp, "register", 8) && (*(bp + 8) == ' ' || *(bp + 8) == '\t')) bp += 9; + for (;;) + { + switch (lex(proto, (flags & ((1L<<16))) | (1L<<21))) + { + case '(': + if (paren++) group++; + continue; + case ')': + if (--paren == 0) + { + if (flags & (1L<<15)) + { + flags &= ~(1L<<15); + if (!(flags & (1L<<28))) + { + op = memcopy(op, m, e - m); + op = strcopy(op, " = "); + } + op = strcopy(op, "va_arg("); + op = memcopy(op, v, n); + (*op++=( ',')); + (*op++=( ' ')); + if (m > bp) op = memcopy(op, bp, m - bp); + else op = strcopy(op, "int "); + if (group > 1) op = strcopy(op, ")()"); + else op = memcopy(op, e, proto->ip - e - 1); + (*op++=( ')')); + (*op++=( ';')); + } + group = 0; + break; + } + continue; + case ',': + if (paren == 1) + { + if (flags & (1L<<15)) + { + flags &= ~(1L<<15); + if (!(flags & (1L<<28))) + { + op = memcopy(op, m, e - m); + op = strcopy(op, " = "); + } + op = strcopy(op, "va_arg("); + op = memcopy(op, v, n); + (*op++=( ',')); + (*op++=( ' ')); + if (m > bp) op = memcopy(op, bp, m - bp); + else op = strcopy(op, "int "); + if (group > 1) op = strcopy(op, ")()"); + else op = memcopy(op, e, proto->ip - e - 1); + (*op++=( ')')); + (*op++=( ';')); + bp = proto->ip + 1; + if (*bp == 'r' && !sstrncmp( bp, "register", 8) && (*(bp + 8) == ' ' || *(bp + 8) == '\t')) bp += 9; + } + group = 0; + proto->op = op; + } + continue; + case (0401+0): + if (group <= 1) + { + flags |= (1L<<15); + m = proto->tp; + e = proto->ip; + } + continue; + default: + continue; + } + break; + } + op = strcopy(op, ")"); + flags |= (1L<<28); + proto->line = line; + call = 0; + break; + } + + case (0401+0): + fsm_id: + + if (flags & (1L<<0)) + { + if (!args && paren == 1) args++; + break; + } + + if (paren == 0) + { + if (last == ')') + { + if (proto->brace == 0 && !(flags & (1L<<1))) flags |= (1L<<23); + call = !call; + } + else if ((flags & (1L<<23)) || c == (0401+0) || c == ((0500+4)+30)) call++; + else flags |= (1L<<23); + if (last == (0401+0)) flags |= (1L<<7); + } + c = (0401+0); + flags |= (1L<<25); + break; + case (0401+1): + if (*proto->tp >= '0' && *proto->tp <= '9') + { + n = 0; + for (;; op--) + { + switch (*(op - 1)) + { + case 'f': + case 'F': + t = op; + while ((c = *--t) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z'); + if (*t == '.') + op--; + n = 0; + break; + case 'l': + case 'L': + if (!(n & 01)) + { + n |= 01; + t = op; + while ((c = *--t) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z'); + if (*t == '.') + { + n = 0; + op--; + break; + } + } + continue; + case 'u': + case 'U': + n |= 02; + continue; + } + break; + } + if (n & 01) + *op++ = 'L'; + if (n & 02) + { + m = op; + t = op = m + 10; + while ((c = *--m) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') + *--t = c; + c = *t; + strcopy(m + 1, "(unsigned)"); + *t = c; + break; + } + } + goto fsm_other; + + case '[': + if ((flags & (1L<<0)) && paren == 0 && group <= 2) flags |= (1L<<23); + + + default: + fsm_other: + + if (flags & (1L<<0)) break; + + flags |= (1L<<25); + if (paren == 0) flags |= (1L<<17); + break; + } + else if (c == '#' && *ip != '(') flags |= (1L<<22); + last = c; + + if ((flags & ((1L<<5)|(1L<<15))) == ((1L<<5)|(1L<<15)) && ((flags & ((1L<<3)|(1L<<23))) || proto->brace || c != '(' && c != ')' && c != '*' && c != (0401+0))) + (op=proto->op); + else + + (proto->op=op); + goto fsm_start; + } + else if (flags & ((1L<<10)|(1L<<11))) + { + + if ((flags & (1L<<29)) && c == '%' && *ip == '{') + t = 0; + else + + { + if (c == '#') + { + for (t = ip; *t == ' ' || *t == '\t'; t++); + if (*t++ == 'i' && *t++ == 'f' && *t++ == 'n' && *t++ == 'd' && *t++ == 'e' && *t++ == 'f') + { + + + + + t = 0; + } + } + else + t = ""; + } + if (t) + { + + n = ip - proto->tp; + ip -= n; + op -= n; + + + + + } + else + while (*ip != '\n') + *op++ = *ip++; + op = init(proto, op, flags); + op = linesync(proto, op, proto->line); + flags &= ~((1L<<10)|(1L<<11)); + proto->flags &= ~((1L<<10)|(1L<<11)); + goto fsm_start; + } + do{(proto->ip=ip);(proto->op=op);proto->flags&=~((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->flags|=flags&((1L<<5)|(1L<<9)|(1L<<17)|(1L<<27)|(1L<<28));proto->call=call;}while(0); + return c; +} + + + + + +void +pppclose __PARAM__((char* iob), (iob)) __OTORP__(char* iob;){ + register Proto_t* proto = (Proto_t*)(iob - sizeof(Proto_t)); + + if (proto->flags & (1L<<16)) close(proto->fd); + free((char*)proto); +} + + +#line 2055 +char* +pppopen __PARAM__((char* file, int fd, char* notice, char* options, char* package, char* comment, int flags), (file, fd, notice, options, package, comment, flags)) __OTORP__(char* file; int fd; char* notice; char* options; char* package; char* comment; int flags;){ + register Proto_t* proto; + register char* iob; + register long n; + register char* s; + char* t; + int pragma; + int clr; + int hit; + int i; + int z; + char* b; + + int comlen; + char com[80]; + + int m = 0; + + static int retain; + + + + + + + if (flags & (1<<0)) flags &= ~(1<<5); + + if (flags & (1<<11)) flags &= ~retain; + else retain &= (1<<6); + if (file && (fd = open(file, O_RDONLY)) < 0) return 0; + + + + + + + + + + + + + + + + + + + + + + + { + + + + + n = (16*1024); + if (!(proto = (( 0)?( Proto_t*)realloc((char*)( 0),sizeof( Proto_t)*( 1)+( 5 * n + 2)):( Proto_t*)calloc(1,sizeof( Proto_t)*( 1)+( 5 * n + 2))))) + return 0; + proto->iz = n; + proto->oz = 3 * n; + proto->flags |= (1L<<16); + } + proto->fd = fd; + proto->package = package; + iob = (char*)proto + sizeof(Proto_t); + proto->op = proto->ob = iob; + proto->ip = proto->ib = iob + proto->oz + n; + if (m) proto->options |= (1L<<0); + if (!comment) + comment = "/*"; + if (!(proto->cc[0] = comment[0])) + notice = options = 0; + else if (comment[1]) + { + proto->cc[1] = comment[1]; + proto->cc[2] = comment[2] ? comment[2] : comment[0]; + } + else + proto->cc[1] = proto->cc[2] = comment[0]; + + + + + + n = read(fd, proto->ip, proto->iz); + if (!(proto->flags & (1L<<16))) + close(fd); + if (n < 0) + { + pppclose(iob); + return 0; + } + *(proto->ip + n) = 0; + + +#line 2165 + if (!notice && !options || (comlen = astlicense(com, sizeof(com), ((char*)0), "type=check", proto->cc[0], proto->cc[1], proto->cc[2])) <= 0) + *com = 0; + + hit = (notice || options) ? 0 : 0x02; + pragma = -1; + s = proto->ip; + m = 80; + while (m-- > 0 && *s && hit != (0x01|0x02)) + { + while (*s == ' ' || *s == '\t') + s++; + if (*s == '#') + { + b = s++; + while (*s == ' ' || *s == '\t') + s++; + if (*s == *"pragma"&& !sstrncmp( s, "pragma", sizeof("pragma") - 1) && (*(s += sizeof("pragma") - 1) == ' ' || *s == '\t')) + { + clr = 0; + while (*s && *s != '\r' && *s != '\n') + { + for (; *s == ' ' || *s == '\t'; s++); + for (t = s; *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n'; s++); + z = s - t; + for (i = 0; i < (sizeof( pragmas)/sizeof( pragmas[0])); i++) + if (pragmas[i].size == z && !sstrncmp( t, pragmas[i].name, z)) + { + clr = 1; + hit |= pragmas[i].hit; + switch (pragmas[i].hit) + { + case 0x02: + notice = options = 0; + break; + case 0x01: + pragma = pragmas[i].val; + break; + } + } + } + if (clr) + { + + if (!(flags & (1<<1)) || (flags & (1<<8))) + + for (; b < s; *b++ = ' '); + } + } + } + else if (*s == *"/* : : generated by proto : : */\n"&& !sstrncmp( s, "/* : : generated by proto : : */\n", sizeof("/* : : generated by proto : : */\n") - 1)) + { + pragma = 0; + break; + } + + else if (*s == '%' && *(s + 1) == '{') + proto->flags |= (1L<<29); + else if (!(hit & 0x02)) + { + if (*s == *com && !sstrncmp( s, com, comlen)) + { + hit |= 0x02; + notice = options = 0; + } + else + for (; *s && *s != '\n' && !(hit & 0x02); s++) + for (i = 0; i < (sizeof( notices)/sizeof( notices[0])); i++) + if (*s == notices[i].name[0] && !sstrncmp( s, notices[i].name, notices[i].size)) + { + s += notices[i].size; + if (notices[i].val) + { + while (*s == ' ' || *s == '\t') + s++; + if (*s == '(' && (*(s + 1) == 'c' || *(s + 1) == 'C') && *(s + 2) == ')' || *s >= '0' && *s <= '9' && *(s + 1) >= '0' && *(s + 1) <= '9') + { + hit |= notices[i].hit; + notice = options = 0; + } + } + else + { + hit |= notices[i].hit; + notice = options = 0; + } + break; + } + } + + while (*s && *s++ != '\n'); + } + if (flags & (1<<10)) proto->flags |= (1L<<20); + if (flags & (1<<12)) proto->test = 1; + if (flags & (1<<2)) proto->options |= (1L<<6); + + if (flags & (1<<0)) pragma = -pragma; + if (flags & (1<<1)) pragma = 0; + if (flags & (1<<7)) proto->flags |= (1L<<13); + if (!(proto->flags & (1L<<29)) && file && (m = sstrlen( file)) > 2 && file[--m] == 'y' && file[--m] == '.') + proto->flags |= (1L<<29); + + if (pragma <= 0) + { + if (flags & (1<<10)) + { + flags &= ~((1<<4)|(1<<5)); + proto->flags |= (1L<<19); + } + else if (!(flags & ((1<<3)|(1<<9)))) + { + pppclose(iob); + return 0; + } + else if ((flags & ((1<<3)|(1<<9))) == (1<<9) || !pragma) + { + proto->flags |= (1L<<18); + if (proto->flags & (1L<<16)) + proto->oz += proto->iz; + proto->iz = n; + if (notice || options) + { + if (proto->cc[0] == '#' && proto->ip[0] == '#' && proto->ip[1] == '!') + { + s = proto->ip; + while (*s && *s++ != '\n'); + m = s - proto->ip; + proto->op = memcopy(proto->op, proto->ip, m); + proto->ip = s; + proto->iz = n -= m; + } + + if (proto->cc[0]) + { + if ((comlen = astlicense(proto->op, proto->oz, notice, options, proto->cc[0], proto->cc[1], proto->cc[2])) < 0) + proto_error((char*)proto + sizeof(Proto_t), 1, proto->op, ((char*)0)); + else + proto->op += comlen; + } + if (!(flags & (1<<0)) && !(proto->flags & (1L<<29))) + + proto->op = linesync(proto, proto->op, 1); + proto->iz += proto->op - proto->ob; + } + memcopy(proto->op, proto->ip, n); + return iob; + } + } + + if (!(retain & (1<<6))) + { + retain |= (1<<6); + ppfsm(4, ((char*)0)); + } + + proto->line = 1; + + if (notice || options || (flags & ((1<<4)|(1<<5)))) + { + + if (notice || options) + { + if ((comlen = astlicense(proto->op, proto->oz, notice, options, proto->cc[0], proto->cc[1], proto->cc[2])) < 0) + proto_error((char*)proto + sizeof(Proto_t), 1, proto->op, ((char*)0)); + else + proto->op += comlen; + } + + if (flags & (1<<5)) + { + proto->flags |= (1L<<11); + if (flags & (1<<11)) + retain |= (1<<5); + } + else if (flags & (1<<4)) + { + if (flags & (1<<11)) retain |= (1<<4); + + if (flags & (1<<0)) + { + *proto->op++ = '#'; + proto->op = strcopy(proto->op, "pragma"); + *proto->op++ = ' '; + proto->op = strcopy(proto->op, pragmas[0].name); + *proto->op++ = '\n'; + } + else + + proto->flags |= (1L<<10); + } + + if (!(flags & (1<<0))) + { + if (proto->flags & (1L<<29)) + { + proto->op = strcopy(proto->op, "\n%{\n"+ !notice); + proto->op = strcopy(proto->op, "/* : : generated by proto : : */\n"); + proto->op = strcopy(proto->op, "%}\n"); + } + else + { + if (n || notice || options) + *proto->op++ = '\n'; + proto->op = strcopy(proto->op, "/* : : generated by proto : : */\n"); + if (n) + proto->op = linesync(proto, proto->op, proto->line); + else if (proto->flags & ((1L<<10)|(1L<<11))) + proto->op = init(proto, proto->op, proto->flags); + } + } + + } + + + proto->file = file; + if (flags & (1<<0)) + { + proto->flags |= (1L<<0); + if (!(flags & (1<<4))) proto->flags |= (1L<<5); + } + + return iob; +} + + + + + + +int +pppread __PARAM__((char* iob), (iob)) __OTORP__(char* iob;){ + register Proto_t* proto = (Proto_t*)(iob - sizeof(Proto_t)); + register int n; + + if (proto->flags & (1L<<18)) + { + if (proto->iz) + { + n = proto->iz; + proto->iz = 0; + } + else if (!(proto->flags & (1L<<16))) n = 0; + else if ((n = read(proto->fd, proto->ob, proto->oz)) <= 0 || (proto->options & (1L<<0)) && n < proto->oz) + { + proto->flags &= ~(1L<<16); + close(proto->fd); + } + } + else + { + if (proto->op == proto->ob) + { + if (proto->flags & (1L<<4)) return -1; + + if (proto->flags & (1L<<29)) + { + register char* ip = proto->ip; + register char* op = proto->ob; + register char* ep = proto->ob + proto->oz - 2; + + if (!*ip) + { + ip = proto->ip = proto->ib; + if (!(proto->flags & (1L<<16))) n = 0; + else if ((n = read(proto->fd, ip, proto->iz)) <= 0 || (proto->options & (1L<<0)) && n < proto->iz) + { + if (n < 0) n = 0; + proto->flags &= ~(1L<<16); + close(proto->fd); + } + ip[n] = 0; + } + if (proto->flags & (1L<<30)) + { + proto->flags &= ~(1L<<30); + if (*ip == '%') + { + *op++ = *ip++; + if (proto->flags & (1L<<31)) proto->flags &= ~(1L<<29); + else proto->flags |= (1L<<31); + } + } + if (proto->flags & (1L<<29)) + while (op < ep && (n = *op++ = *ip)) + { + ip++; + if (n == '%') + { + if (*ip == '%' && (ip == proto->ip + 1 || *(ip - 2) == '\n')) + { + *op++ = *ip++; + if (proto->flags & (1L<<31)) proto->flags &= ~(1L<<29); + else proto->flags |= (1L<<31); + break; + } + if (!*ip) + { + *op++ = '%'; + proto->flags |= (1L<<30); + break; + } + } + else if (n == '\n') proto->line++; + } + proto->op = memcopy(proto->ob, proto->ip, ip - proto->ip); + proto->ip = ip; + } + else + + lex(proto, proto->flags); + if ((proto->flags & ((1L<<4)|(1L<<16))) == (1L<<4)) + proto->op = strcopy(proto->op, "/* NOTE: some constructs may not have been converted */\n"); + } + n = proto->op - proto->ob; + proto->op = proto->ob; + } + return n; +} + + + + + + + + + + + + +#line 269 "proto.c" + + + + + +static int +proto __PARAM__((char* file, char* license, char* options, char* package, char* copy, char* comment, int flags), (file, license, options, package, copy, comment, flags)) __OTORP__(char* file; char* license; char* options; char* package; char* copy; char* comment; int flags;){ + char* b; + char* e; + char* p; + int n; + int m; + int x; + int fd; + char buf[1024]; + + if (file && access(file, 4)) + proto_error(((char*)0), 2, file, "not found"); + else if (b = pppopen(file, 0, license, options, package, comment, flags)) + { + if (!file) + fd = 1; + else if (flags & ((1<<13)<<1)) + { + e = file + sstrlen( file) - 1; + x = *e; + *e = '_'; + if ((fd = creat(file, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) + { + proto_error(b, 2, file, "cannot create temporary file"); + pppclose(b); + return flags | ((1<<13)<<0); + } + *e = x; + } + else if (copy) + { + if (((n = sstrlen( copy)) + sstrlen( file) + 2) > sizeof(buf)) + { + proto_error(b, 2, copy, "copy path too long"); + pppclose(b); + return flags | ((1<<13)<<0); + } + strcopy( buf, copy); + e = buf + n; + if (*file != '/') + *e++ = '/'; + strcopy( e, file); + if ((fd = creat(buf, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) + { + for (e = buf; *e == '/'; e++); + do + { + if (*e == '/') + { + *e = 0; + if (access(buf, 0) && mkdir(buf, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)) + { + proto_error(b, 2, buf, "cannot create copy directory"); + pppclose(b); + return flags | ((1<<13)<<0); + } + *e = '/'; + } + } while (*e++); + if ((fd = creat(buf, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) + { + proto_error(b, 2, buf, "cannot create copy file"); + pppclose(b); + return flags | ((1<<13)<<0); + } + } + file = buf; + } + else + fd = 1; + if (file && (flags & ((1<<13)<<2))) + proto_error(b, 0, "convert to", file); + while ((n = pppread(b)) > 0) + { + p = b; + for (;;) + { + if ((m = write(fd, p, n)) <= 0) + { + proto_error(b, 2, "write error", ((char*)0)); + flags |= ((1<<13)<<0); + break; + } + if ((n -= m) <= 0) + break; + p += m; + } + if (m < 0) + break; + } + if (fd > 1) + close(fd); + if (file && (flags & ((1<<13)<<1))) + { + *e = '_'; + strcopy( b, file); + *e = x; + if (replace(b, file, !(flags & (1<<0)))) + proto_error(b, 2, "cannot rename to", file); + } + pppclose(b); + } + return flags; +} + + + + + +typedef struct Sufcom_s +{ + char suffix[4]; + char comment[4]; +} Sufcom_t; + +static const Sufcom_t sufcom[] = +{ + "c", "/*", + "cpp", "/*", + "cxx", "/*", + "c++", "/*", + "C", "/*", + "CPP", "/*", + "CXX", "/*", + "C++", "/*", + "f", "C", + "F", "C", + "h", "/*", + "hpp", "/*", + "hxx", "/*", + "H", "/*", + "HPP", "/*", + "HXX", "/*", + "ksh", "#", + "KSH", "#", + "l", "/*", + "L", "/*", + "p", "(*)", + "pas", "(*)", + "P", "(*)", + "PAS", "(*)", + "pl", "#", + "PL", "#", + "pl1", "/*", + "pli", "/*", + "PL1", "/*", + "PLI", "/*", + "sh", "#", + "SH", "#", + "sml", "(*)", + "SML", "(*)", + "y", "/*", + "Y", "/*", +}; + + + + + +static char* +type __PARAM__((register char* file, char* comment), (file, comment)) __OTORP__(register char* file; char* comment;){ + register char* suffix; + register int i; + + if (file && (!comment || !*comment)) + { + suffix = 0; + while (*file) + if (*file++ == '.') + suffix = file; + if (suffix && sstrlen( suffix) <= 3) + for (i = 0; i < sizeof(sufcom) / sizeof(sufcom[0]); i++) + if (!strcmp(suffix, sufcom[i].suffix)) + return (char*)sufcom[i].comment; + } + return comment; +} + +int +main __PARAM__((int argc, char** argv), (argc, argv)) __OTORP__(int argc; char** argv;){ + char* b; + char* file; + int fd; + int n; + char* op; + char* oe; + char* comment = 0; + char* copy = 0; + char* list = 0; + char* license = 0; + char* options = 0; + char* package = 0; + int flags = (1<<4); + char buf[1024]; + char opt[4 * 1024]; + + ; + + while ((file = *++argv) && *file == '-' && *(file + 1)) + { + for (;;) + { + switch (*++file) + { + case 0: + break; + case 'c': + if (!*(comment = ++file)) + comment = *++argv; + break; + case 'd': + flags |= (1<<1); + continue; + case 'e': + if (!*(package = ++file) && !(package = *++argv)) + { + file = "??"; + continue; + } + break; + case 'f': + flags |= (1<<3); + continue; + case 'h': + flags &= ~(1<<4); + continue; + case 'i': + flags |= (1<<0); + continue; + case 'l': + if (!*(license = ++file) && !(license = *++argv)) + { + file = "??"; + continue; + } + break; + case 'n': + flags |= (1<<7); + continue; + case 'o': + if (!*(b = ++file) && !(b = *++argv)) + { + file = "??"; + continue; + } + if (!options) + { + options = op = opt; + oe = op + sizeof(opt) - 1; + } + n = sstrlen( b); + if ((n + 1) >= (oe - op)) + proto_error(((char*)0), 3, b, "too many options"); + else + { + *op++ = '\n'; + memcopy( op, b, n + 1); + op += n; + } + break; + case 'p': + flags |= (1<<9); + continue; + case 'r': + flags |= ((1<<13)<<1); + continue; + case 's': + flags |= (1<<5); + continue; + case 't': + flags |= (1<<12); + continue; + case 'v': + flags |= ((1<<13)<<2); + continue; + case 'x': + flags |= (1<<2); + continue; + case 'z': + flags |= (1<<1)|(1<<8); + continue; + case 'C': + if (!*(copy = ++file) && !(copy = *++argv)) + { + file = "??"; + continue; + } + break; + case 'L': + if (!*(list = ++file) && !(list = *++argv)) + { + file = "??"; + continue; + } + break; + case 'P': + case '+': + flags |= (1<<10); + continue; + case 'S': + comment = "#"; + continue; + default: + proto_error(((char*)0), 2, file, "unknown option"); + + case '?': + b = "Usage: proto [-dfhinprstvzP+S] [-C directory] [-e package] [-l file]\n [-o \"name='value' ...\"] [-L file] file ...\n"; + write(2, b, sstrlen( b)); + return 2; + } + break; + } + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + if (list) + { + if (*list == '-' && !*(list + 1)) + fd = 0; + else if ((fd = open(list, O_RDONLY)) < 0) + proto_error(((char*)0), 3, list, "not found"); + do + { + for (b = buf; (n = read(fd, b, 1)) > 0 && *b != '\n' && b < &buf[sizeof(buf) - 1]; b++); + if (b > buf) + { + *b = 0; + flags = proto(buf, license, options, package, copy, type(buf, comment), flags); + } + } while (n > 0); + if (fd > 0) + close(fd); + } + if (file) + do flags = proto(file, license, options, package, copy, type(file, comment), flags); while (file = *++argv); + else if (!list) + flags = proto(file, license, options, package, copy, type(file, comment), flags); + return errors ? 1 : (flags & ((1<<13)<<0)) ? 2 : 0; +} diff --git a/src/cmd/INIT/ratz.c b/src/cmd/INIT/ratz.c new file mode 100644 index 0000000..df7d1e3 --- /dev/null +++ b/src/cmd/INIT/ratz.c @@ -0,0 +1,5293 @@ +/* + * ratz -- read a tar gzip archive from the standard input + * + * coded for portability + * _SEAR_* macros for win32 self extracting archives -- see sear(1). + */ + +static char id[] = "\n@(#)$Id: ratz (Jean-loup Gailly, Mark Adler, Glenn Fowler) 1.2.3 2010-10-10 $\0\n"; + +#if _PACKAGE_ast + +#include <ast.h> +#include <error.h> + +static const char usage[] = +"[-?\n@(#)$Id: ratz (Jean-loup Gailly, Mark Adler, Glenn Fowler) 1.2.3 2010-10-10 $\n]" +"[-author?Jean-loup Gailly]" +"[-author?Mark Adler]" +"[-author?Glenn Fowler <gsf@research.att.com>]" +"[-copyright?Copyright (c) 1995-2005 Jean-loup Gailly and Mark Adler]" +"[-license?http://www.opensource.org/licenses/zlib-license]" +"[+NAME?ratz - read a tar gzip archive]" +"[+DESCRIPTION?\bratz\b extracts files and directories from a tar gzip" +" archive on the standard input. It is a standalone program for systems" +" that do not have \bpax\b(1), \btar\b(1) or \bgunzip\b(1). Only regular" +" files and directories are extracted; all other file types are ignored.]" +"[+?\b.exe\b files generated by \bsear\b(1) are fully functional \bratz\b" +" executables, so any \bratz\b option may be used on a \bsear\b file." +" This allows \bsear\b file contents to be examined and extracted without" +" executing any embedded installation scripts.]" +"[c:cat|uncompress?Uncompress the standard input and copy it to the standard" +" output.]" +#if defined(_SEAR_EXEC) +"[i!:install?Execute the sear installation script.]" +#endif +"[l:local?Reject files that traverse outside the current directory.]" +"[m:meter?Display a one line text meter showing archive read progress.]" +"[n!:convert?In ebcdic environments convert text archive members from ascii" +" to the native ebcdic.]" +"[t:list?List each file path on the standard output but do not extract.]" +"[v:verbose?List each file path on the standard output as it is extracted.]" +"[V?Print the program version and exit.]" +"[+SEE ALSO?\bgunzip\b(1), \bpackage\b(1), \bpax\b(1), \bsear\b(1), \btar\b(1)]" +; + +#else + +#define NiL ((char*)0) + +#endif + +#define METER_width 80 +#define METER_parts 20 + +#ifndef _GUNZIP_H +#define _GUNZIP_H 1 + +/* + * stripped down zlib containing public gzfopen()+gzread() in one file + * USE THE REAL ZLIB AFTER BOOTSTRAP + */ + +#define ZLIB_INTERNAL 1 +#define NO_GZCOMPRESS 1 + +#define gz_headerp voidp + +#include <stdio.h> +#include <sys/types.h> + +#if _PACKAGE_ast || defined(__STDC__) || defined(_SEAR_EXEC) || defined(_WIN32) + +#define FOPEN_READ "rb" +#define FOPEN_WRITE "wb" + +#else + +#define FOPEN_READ "r" +#define FOPEN_WRITE "w" + +#endif + +#ifndef O_BINARY +#define O_BINARY 0 +#endif + +#if _PACKAGE_ast + +#define setmode(d,m) + +#else + +#if !defined(_WINIX) && (_UWIN || __CYGWIN__ || __EMX__) +#define _WINIX 1 +#endif + +#if _WIN32 && !_WINIX + +#include <direct.h> +#include <io.h> +#include <fcntl.h> +#include <windows.h> + +#define access _access +#define chmod _chmod +#define close _close +#define dup _dup +#define lseek _lseek +#define open _open +#define read _read +#define setmode _setmode +#define unlink _unlink + +#define mkdir(a,b) _mkdir(a) + +#else + +#define HAVE_UNISTD_H 1 + +#include <unistd.h> +#include <errno.h> + +#define setmode(d,m) + +#endif + +#if defined(__STDC__) + +#include <stdlib.h> +#include <string.h> + +#endif + +#endif + +#ifndef _ZLIB_H +#define _ZLIB_H 1 + +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.3, July 18th, 2005 + + Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef _ZCONF_H +#define _ZCONF_H 1 + +#if _PACKAGE_ast +#include <ast_std.h> /* for { _WINIX __IMPORT__ __EXPORT__ } */ +#define z_off_t int32_t +#if _typ_int64_t +#define z_off64_t int64_t +#endif +#else +#if !defined(_WINIX) && (_UWIN || __CYGWIN__ || __EMX__) +#define _WINIX 1 +#endif +#endif + +#if _BLD_z && defined(__EXPORT__) +#define ZEXTERN __EXPORT__ +#define ZEXPORT +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include <windows.h> + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if HAVE_UNISTD_H +# include <sys/types.h> /* for off_t */ +# include <unistd.h> /* for SEEK_* and off_t */ +# ifdef VMS +# include <unixio.h> /* for off_t */ +# endif +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +#if defined(__OS400__) +# define NO_vsnprintf +#endif + +#if defined(__MVS__) +# define NO_vsnprintf +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(deflateBound,"DEBND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(compressBound,"CMBND") +# pragma map(inflate_table,"INTABL") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* _ZCONF_H */ + +#define ZLIB_VERSION "1.2.3" +#define ZLIB_VERNUM 0x1230 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) + +#endif /* _ZLIB_H */ + +#ifndef _ZUTIL_H +#define _ZUTIL_H 1 + +#if !_PACKAGE_ast && !defined(STDC) +#if defined(__STDC__) +# include <stddef.h> +#endif +# include <string.h> +# include <stdlib.h> +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +typedef unsigned char uch; +typedef uch FAR uchf; +typedef unsigned short ush; +typedef ush FAR ushf; +typedef unsigned long ulg; + + /* common constants */ + +#ifndef DEF_WBITS +# define DEF_WBITS MAX_WBITS +#endif +/* default windowBits for decompression. MAX_WBITS is for compression only */ + +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +/* default memLevel */ + +#define STORED_BLOCK 0 +#define STATIC_TREES 1 +#define DYN_TREES 2 +/* The three kinds of block type */ + +#define MIN_MATCH 3 +#define MAX_MATCH 258 +/* The minimum and maximum match lengths */ + +#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ + + /* target dependencies */ + +#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) +# define OS_CODE 0x00 +# if defined(__TURBOC__) || defined(__BORLANDC__) +# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) + /* Allow compilation with ANSI keywords only enabled */ + void _Cdecl farfree( void *block ); + void *_Cdecl farmalloc( unsigned long nbytes ); +# else +# include <alloc.h> +# endif +# else /* MSC or DJGPP */ +# include <malloc.h> +# endif +#endif + +#ifdef AMIGA +# define OS_CODE 0x01 +#endif + +#if defined(VAXC) || defined(VMS) +# define OS_CODE 0x02 +# define F_OPEN(name, mode) \ + fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") +#endif + +#if defined(ATARI) || defined(atarist) +# define OS_CODE 0x05 +#endif + +#ifdef OS2 +# define OS_CODE 0x06 +# ifdef M_I86 + #include <malloc.h> +# endif +#endif + +#if defined(MACOS) || defined(TARGET_OS_MAC) +# define OS_CODE 0x07 +# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os +# include <unix.h> /* for fdopen */ +# else +# ifndef fdopen +# define fdopen(fd,mode) NULL /* No fdopen() */ +# endif +# endif +#endif + +#ifdef TOPS20 +# define OS_CODE 0x0a +#endif + +#ifdef WIN32 +# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ +# define OS_CODE 0x0b +# endif +#endif + +#ifdef __50SERIES /* Prime/PRIMOS */ +# define OS_CODE 0x0f +#endif + +#if defined(_BEOS_) || defined(RISCOS) +# define fdopen(fd,mode) NULL /* No fdopen() */ +#endif + +#if (defined(_MSC_VER) && (_MSC_VER > 600)) +# if defined(_WIN32_WCE) +# define fdopen(fd,mode) NULL /* No fdopen() */ +# ifndef _PTRDIFF_T_DEFINED + typedef int ptrdiff_t; +# define _PTRDIFF_T_DEFINED +# endif +# else +# define fdopen(fd,type) _fdopen(fd,type) +# endif +#endif + + /* common defaults */ + +#ifndef OS_CODE +# define OS_CODE 0x03 /* assume Unix */ +#endif + +#ifndef F_OPEN +# define F_OPEN(name, mode) fopen((name), (mode)) +#endif + + /* functions */ + +#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif +#if defined(__CYGWIN__) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif +#ifndef HAVE_VSNPRINTF +# ifdef MSDOS + /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), + but for now we just assume it doesn't. */ +# define NO_vsnprintf +# endif +# ifdef __TURBOC__ +# define NO_vsnprintf +# endif +# ifdef WIN32 + /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ +# if !defined(vsnprintf) && !defined(NO_vsnprintf) +# define vsnprintf _vsnprintf +# endif +# endif +# ifdef __SASC +# define NO_vsnprintf +# endif +#endif +#ifdef VMS +# define NO_vsnprintf +#endif + +#if defined(pyr) +# define NO_MEMCPY +#endif +#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) + /* Use our own functions for small and medium model with MSC <= 5.0. + * You may have to use the same strategy for Borland C (untested). + * The __SC__ check is for Symantec. + */ +# define NO_MEMCPY +#endif +#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) +# define HAVE_MEMCPY +#endif +#ifdef HAVE_MEMCPY +# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ +# define zmemcpy _fmemcpy +# define zmemcmp _fmemcmp +# define zmemzero(dest, len) _fmemset(dest, 0, len) +# else +# define zmemcpy memcpy +# define zmemcmp memcmp +# define zmemzero(dest, len) memset(dest, 0, len) +# endif +#else + extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); + extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); + extern void zmemzero OF((Bytef* dest, uInt len)); +#endif + +/* Diagnostic functions */ +#ifdef Z_DEBUG +# include <stdio.h> + extern int z_verbose; + extern void z_error OF((char *m)); +# define Assert(cond,msg) {if(!(cond)) z_error(msg);} +# define Trace(x) {if (z_verbose>=0) fprintf x ;} +# define Tracev(x) {if (z_verbose>0) fprintf x ;} +# define Tracevv(x) {if (z_verbose>1) fprintf x ;} +# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} +# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} +#else +# define Assert(cond,msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c,x) +# define Tracecv(c,x) +#endif + + +voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); +void zcfree OF((voidpf opaque, voidpf ptr)); + +#define ZALLOC(strm, items, size) \ + (*((strm)->zalloc))((strm)->opaque, (items), (size)) +#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) +#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} +#endif /* _ZUTIL_H */ + +#ifndef _ZUTIL_C +#define _ZUTIL_C + +#if 0 && !_PACKAGE_ast && !defined(STDC) +extern void exit OF((int)); +#endif + +#ifndef HAVE_MEMCPY + +void zmemcpy(dest, source, len) + Bytef* dest; + const Bytef* source; + uInt len; +{ + if (len == 0) return; + do { + *dest++ = *source++; /* ??? to be unrolled */ + } while (--len != 0); +} + +int zmemcmp(s1, s2, len) + const Bytef* s1; + const Bytef* s2; + uInt len; +{ + uInt j; + + for (j = 0; j < len; j++) { + if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; + } + return 0; +} + +void zmemzero(dest, len) + Bytef* dest; + uInt len; +{ + if (len == 0) return; + do { + *dest++ = 0; /* ??? to be unrolled */ + } while (--len != 0); +} +#endif + + +#ifdef SYS16BIT + +#ifdef __TURBOC__ +/* Turbo C in 16-bit mode */ + +# define MY_ZCALLOC + +/* Turbo C malloc() does not allow dynamic allocation of 64K bytes + * and farmalloc(64K) returns a pointer with an offset of 8, so we + * must fix the pointer. Warning: the pointer must be put back to its + * original form in order to free it, use zcfree(). + */ + +#define MAX_PTR 10 +/* 10*64K = 640K */ + +local int next_ptr = 0; + +typedef struct ptr_table_s { + voidpf org_ptr; + voidpf new_ptr; +} ptr_table; + +local ptr_table table[MAX_PTR]; +/* This table is used to remember the original form of pointers + * to large buffers (64K). Such pointers are normalized with a zero offset. + * Since MSDOS is not a preemptive multitasking OS, this table is not + * protected from concurrent access. This hack doesn't work anyway on + * a protected system like OS/2. Use Microsoft C instead. + */ + +voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) +{ + voidpf buf = opaque; /* just to make some compilers happy */ + ulg bsize = (ulg)items*size; + + /* If we allocate less than 65520 bytes, we assume that farmalloc + * will return a usable pointer which doesn't have to be normalized. + */ + if (bsize < 65520L) { + buf = farmalloc(bsize); + if (*(ush*)&buf != 0) return buf; + } else { + buf = farmalloc(bsize + 16L); + } + if (buf == NULL || next_ptr >= MAX_PTR) return NULL; + table[next_ptr].org_ptr = buf; + + /* Normalize the pointer to seg:0 */ + *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; + *(ush*)&buf = 0; + table[next_ptr++].new_ptr = buf; + return buf; +} + +void zcfree (voidpf opaque, voidpf ptr) +{ + int n; + if (*(ush*)&ptr != 0) { /* object < 64K */ + farfree(ptr); + return; + } + /* Find the original pointer */ + for (n = 0; n < next_ptr; n++) { + if (ptr != table[n].new_ptr) continue; + + farfree(table[n].org_ptr); + while (++n < next_ptr) { + table[n-1] = table[n]; + } + next_ptr--; + return; + } + ptr = opaque; /* just to make some compilers happy */ + Assert(0, "zcfree: ptr not found"); +} + +#endif /* __TURBOC__ */ + + +#ifdef M_I86 +/* Microsoft C in 16-bit mode */ + +# define MY_ZCALLOC + +#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) +# define _halloc halloc +# define _hfree hfree +#endif + +voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + return _halloc((long)items, size); +} + +void zcfree (voidpf opaque, voidpf ptr) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + _hfree(ptr); +} + +#endif /* M_I86 */ + +#endif /* SYS16BIT */ + + +#ifndef MY_ZCALLOC /* Any system without a special alloc function */ + +#if 0 && !_PACKAGE_ast +#ifndef STDC +extern voidp malloc OF((uInt size)); +extern voidp calloc OF((uInt items, uInt size)); +extern void free OF((voidpf ptr)); +#endif +#endif + +voidpf zcalloc (opaque, items, size) + voidpf opaque; + unsigned items; + unsigned size; +{ + if (opaque) items += size - size; /* make compiler happy */ + return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : + (voidpf)calloc(items, size); +} + +void zcfree (opaque, ptr) + voidpf opaque; + voidpf ptr; +{ + free(ptr); + if (opaque) return; /* make compiler happy */ +} + +#endif /* MY_ZCALLOC */ + +#endif /* _ZUTIL_C */ + +#ifndef _CRC32_H +#define _CRC32_H 1 + +/* crc32.h -- tables for rapid CRC calculation + * Generated automatically by crc32.c + */ + +#ifndef TBLS +#define TBLS 1 +#endif + +local const unsigned long FAR crc_table[TBLS][256] = +{ + { + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, + 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, + 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, + 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, + 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, + 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, + 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, + 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, + 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, + 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, + 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, + 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, + 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, + 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, + 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, + 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, + 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, + 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, + 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, + 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, + 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, + 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, + 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, + 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, + 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, + 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, + 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, + 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, + 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, + 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, + 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, + 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, + 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, + 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, + 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, + 0x2d02ef8d + }, +}; + +#endif /* _CRC32_H */ + +#ifndef _CRC32_C +#define _CRC32_C 1 + +/* ========================================================================= */ +#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) +#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 + +/* ========================================================================= */ +unsigned long ZEXPORT crc32(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; + unsigned len; +{ + if (buf == Z_NULL) return 0; + +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + +#ifdef BYFOUR + if (sizeof(void *) == sizeof(ptrdiff_t)) { + u4 endian; + + endian = 1; + if (*((unsigned char *)(&endian))) + return crc32_little(crc, buf, len); + else + return crc32_big(crc, buf, len); + } +#endif /* BYFOUR */ + crc = crc ^ 0xffffffff; + while (len >= 8) { + DO8; + len -= 8; + } + if (len) do { + DO1; + } while (--len); + return crc ^ 0xffffffff; +} + +#undef DO1 +#undef DO8 + +#endif /* _CRC32_C */ + +#ifndef _ADLER32_C +#define _ADLER32_C 1 + +#define BASE 65521 /* largest prime smaller than 65536 */ +#define NMAX 5552 +/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ + +#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} +#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); +#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); +#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); +#define DO16(buf) DO8(buf,0); DO8(buf,8); + +/* use NO_DIVIDE if your processor does not do division in hardware */ +#ifdef NO_DIVIDE +# define MOD(a) \ + do { \ + if (a >= (BASE << 16)) a -= (BASE << 16); \ + if (a >= (BASE << 15)) a -= (BASE << 15); \ + if (a >= (BASE << 14)) a -= (BASE << 14); \ + if (a >= (BASE << 13)) a -= (BASE << 13); \ + if (a >= (BASE << 12)) a -= (BASE << 12); \ + if (a >= (BASE << 11)) a -= (BASE << 11); \ + if (a >= (BASE << 10)) a -= (BASE << 10); \ + if (a >= (BASE << 9)) a -= (BASE << 9); \ + if (a >= (BASE << 8)) a -= (BASE << 8); \ + if (a >= (BASE << 7)) a -= (BASE << 7); \ + if (a >= (BASE << 6)) a -= (BASE << 6); \ + if (a >= (BASE << 5)) a -= (BASE << 5); \ + if (a >= (BASE << 4)) a -= (BASE << 4); \ + if (a >= (BASE << 3)) a -= (BASE << 3); \ + if (a >= (BASE << 2)) a -= (BASE << 2); \ + if (a >= (BASE << 1)) a -= (BASE << 1); \ + if (a >= BASE) a -= BASE; \ + } while (0) +# define MOD4(a) \ + do { \ + if (a >= (BASE << 4)) a -= (BASE << 4); \ + if (a >= (BASE << 3)) a -= (BASE << 3); \ + if (a >= (BASE << 2)) a -= (BASE << 2); \ + if (a >= (BASE << 1)) a -= (BASE << 1); \ + if (a >= BASE) a -= BASE; \ + } while (0) +#else +# define MOD(a) a %= BASE +# define MOD4(a) a %= BASE +#endif + +/* ========================================================================= */ +uLong ZEXPORT adler32(adler, buf, len) + uLong adler; + const Bytef *buf; + uInt len; +{ + unsigned long sum2; + unsigned n; + + /* split Adler-32 into component sums */ + sum2 = (adler >> 16) & 0xffff; + adler &= 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (len == 1) { + adler += buf[0]; + if (adler >= BASE) + adler -= BASE; + sum2 += adler; + if (sum2 >= BASE) + sum2 -= BASE; + return adler | (sum2 << 16); + } + + /* initial Adler-32 value (deferred check for len == 1 speed) */ + if (buf == Z_NULL) + return 1L; + + /* in case short lengths are provided, keep it somewhat fast */ + if (len < 16) { + while (len--) { + adler += *buf++; + sum2 += adler; + } + if (adler >= BASE) + adler -= BASE; + MOD4(sum2); /* only added so many BASE's */ + return adler | (sum2 << 16); + } + + /* do length NMAX blocks -- requires just one modulo operation */ + while (len >= NMAX) { + len -= NMAX; + n = NMAX / 16; /* NMAX is divisible by 16 */ + do { + DO16(buf); /* 16 sums unrolled */ + buf += 16; + } while (--n); + MOD(adler); + MOD(sum2); + } + + /* do remaining bytes (less than NMAX, still just one modulo) */ + if (len) { /* avoid modulos if none remaining */ + while (len >= 16) { + len -= 16; + DO16(buf); + buf += 16; + } + while (len--) { + adler += *buf++; + sum2 += adler; + } + MOD(adler); + MOD(sum2); + } + + /* return recombined sums */ + return adler | (sum2 << 16); +} + +#endif /* _ADLER32_C */ + +#ifndef _DEFLATE_H +#define _DEFLATE_H 1 + +/* =========================================================================== + * Internal compression state. + */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define L_CODES (LITERALS+1+LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +#define HEAP_SIZE (2*L_CODES+1) +/* maximum heap size */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define INIT_STATE 42 +#define EXTRA_STATE 69 +#define NAME_STATE 73 +#define COMMENT_STATE 91 +#define HCRC_STATE 103 +#define BUSY_STATE 113 +#define FINISH_STATE 666 +/* Stream status */ + + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data_s { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} FAR ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +typedef struct static_tree_desc_s static_tree_desc; + +typedef struct tree_desc_s { + ct_data *dyn_tree; /* the dynamic tree */ + int max_code; /* largest code with non zero frequency */ + static_tree_desc *stat_desc; /* the corresponding static tree */ +} FAR tree_desc; + +typedef ush Pos; +typedef Pos FAR Posf; +typedef unsigned IPos; + +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +typedef struct internal_state { + z_streamp strm; /* pointer back to this zlib stream */ + int status; /* as the name implies */ + Bytef *pending_buf; /* output still pending */ + ulg pending_buf_size; /* size of pending_buf */ + Bytef *pending_out; /* next pending byte to output to the stream */ + uInt pending; /* nb of bytes in the pending buffer */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + gz_headerp gzhead; /* gzip header information to write */ + uInt gzindex; /* where in extra, name, or comment */ + Byte method; /* STORED (for zip only) or DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ + + uInt w_size; /* LZ77 window size (32K by default) */ + uInt w_bits; /* log2(w_size) (8..16) */ + uInt w_mask; /* w_size - 1 */ + + Bytef *window; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: use the user input buffer as sliding window. + */ + + ulg window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + Posf *prev; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + Posf *head; /* Heads of the hash chains or NIL. */ + + uInt ins_h; /* hash index of string to be inserted */ + uInt hash_size; /* number of elements in hash table */ + uInt hash_bits; /* log2(hash_size) */ + uInt hash_mask; /* hash_size-1 */ + + uInt hash_shift; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + long block_start; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + uInt match_length; /* length of best match */ + IPos prev_match; /* previous match */ + int match_available; /* set if previous match exists */ + uInt strstart; /* start of string to insert */ + uInt match_start; /* start of matching string */ + uInt lookahead; /* number of valid bytes ahead in window */ + + uInt prev_length; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + uInt max_chain_length; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + uInt max_lazy_match; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +# define max_insert_length max_lazy_match + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + int level; /* compression level (1..9) */ + int strategy; /* favor or force Huffman coding*/ + + uInt good_match; + /* Use a faster search when the previous match is longer than this */ + + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + /* Didn't use ct_data typedef below to supress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + struct tree_desc_s l_desc; /* desc. for literal tree */ + struct tree_desc_s d_desc; /* desc. for distance tree */ + struct tree_desc_s bl_desc; /* desc. for bit length tree */ + + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap_len; /* number of elements in the heap */ + int heap_max; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + uch depth[2*L_CODES+1]; + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + uchf *l_buf; /* buffer for literals or lengths */ + + uInt lit_bufsize; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + uInt last_lit; /* running index in l_buf */ + + ushf *d_buf; + /* Buffer for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ + int last_eob_len; /* bit length of EOB code for last block */ + +#ifdef Z_DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +#endif + + ush bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + +} FAR deflate_state; + +/* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} + + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + + /* in trees.c */ +void _tr_init OF((deflate_state *s)); +int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, + int eof)); +void _tr_align OF((deflate_state *s)); +void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, + int eof)); + +#define d_code(dist) \ + ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. _dist_code[256] and _dist_code[257] are never + * used. + */ + +#ifndef Z_DEBUG +/* Inline versions of _tr_tally for speed: */ + +#if defined(GEN_TREES_H) || !defined(STDC) + extern uch _length_code[]; + extern uch _dist_code[]; +#else + extern const uch _length_code[]; + extern const uch _dist_code[]; +#endif + +# define _tr_tally_lit(s, c, flush) \ + { uch cc = (c); \ + s->d_buf[s->last_lit] = 0; \ + s->l_buf[s->last_lit++] = cc; \ + s->dyn_ltree[cc].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +# define _tr_tally_dist(s, distance, length, flush) \ + { uch len = (length); \ + ush dist = (distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ + s->dyn_dtree[d_code(dist)].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +#else +# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +# define _tr_tally_dist(s, distance, length, flush) \ + flush = _tr_tally(s, distance, length) +#endif + +#endif /* _DEFLATE_H */ + +#ifndef _INFTREES_H +#define _INFTREES_H 1 + +typedef struct { + unsigned char op; /* operation, extra bits, table bits */ + unsigned char bits; /* bits in this part of the code */ + unsigned short val; /* offset in table or code value */ +} code; + +/* op values as set by inflate_table(): + 00000000 - literal + 0000tttt - table link, tttt != 0 is the number of table index bits + 0001eeee - length or distance, eeee is the number of extra bits + 01100000 - end of block + 01000000 - invalid code + */ + +/* Maximum size of dynamic tree. The maximum found in a long but non- + exhaustive search was 1444 code structures (852 for length/literals + and 592 for distances, the latter actually the result of an + exhaustive search). The true maximum is not known, but the value + below is more than safe. */ +#define ENOUGH 2048 +#define MAXD 592 + +/* Type of code to build for inftable() */ +typedef enum { + CODES, + LENS, + DISTS +} codetype; + +#endif /* _INFTREES_H */ + +#ifndef _INFLATE_H +#define _INFLATE_H 1 + +/* Possible inflate modes between inflate() calls */ +typedef enum { + HEAD, /* i: waiting for magic header */ + FLAGS, /* i: waiting for method and flags (gzip) */ + TIME, /* i: waiting for modification time (gzip) */ + OS, /* i: waiting for extra flags and operating system (gzip) */ + EXLEN, /* i: waiting for extra length (gzip) */ + EXTRA, /* i: waiting for extra bytes (gzip) */ + NAME, /* i: waiting for end of file name (gzip) */ + COMMENT, /* i: waiting for end of comment (gzip) */ + HCRC, /* i: waiting for header crc (gzip) */ + DICTID, /* i: waiting for dictionary check value */ + DICT, /* waiting for inflateSetDictionary() call */ + TYPE, /* i: waiting for type bits, including last-flag bit */ + TYPEDO, /* i: same, but skip check to exit inflate on new block */ + STORED, /* i: waiting for stored size (length and complement) */ + COPY, /* i/o: waiting for input or output to copy stored block */ + TABLE, /* i: waiting for dynamic block table lengths */ + LENLENS, /* i: waiting for code length code lengths */ + CODELENS, /* i: waiting for length/lit and distance code lengths */ + LEN, /* i: waiting for length/lit code */ + LENEXT, /* i: waiting for length extra bits */ + DIST, /* i: waiting for distance code */ + DISTEXT, /* i: waiting for distance extra bits */ + MATCH, /* o: waiting for output space to copy string */ + LIT, /* o: waiting for output space to write literal */ + CHECK, /* i: waiting for 32-bit check value */ + LENGTH, /* i: waiting for 32-bit length (gzip) */ + DONE, /* finished check, done -- remain here until reset */ + BAD, /* got a data error -- remain here until reset */ + MEM, /* got an inflate() memory error -- remain here until reset */ + SYNC /* looking for synchronization bytes to restart inflate() */ +} inflate_mode; + +/* + State transitions between above modes - + + (most modes can go to the BAD or MEM mode -- not shown for clarity) + + Process header: + HEAD -> (gzip) or (zlib) + (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME + NAME -> COMMENT -> HCRC -> TYPE + (zlib) -> DICTID or TYPE + DICTID -> DICT -> TYPE + Read deflate blocks: + TYPE -> STORED or TABLE or LEN or CHECK + STORED -> COPY -> TYPE + TABLE -> LENLENS -> CODELENS -> LEN + Read deflate codes: + LEN -> LENEXT or LIT or TYPE + LENEXT -> DIST -> DISTEXT -> MATCH -> LEN + LIT -> LEN + Process trailer: + CHECK -> LENGTH -> DONE + */ + +/* state maintained between inflate() calls. Approximately 7K bytes. */ +struct inflate_state { + inflate_mode mode; /* current inflate mode */ + int last; /* true if processing last block */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + int havedict; /* true if dictionary provided */ + int flags; /* gzip header method and flags (0 if zlib) */ + unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ + unsigned long check; /* protected copy of check value */ + unsigned long total; /* protected copy of output count */ + gz_headerp head; /* where to save gzip header information */ + /* sliding window */ + unsigned wbits; /* log base 2 of requested window size */ + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned write; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if needed */ + /* bit accumulator */ + unsigned long hold; /* input bit accumulator */ + unsigned bits; /* number of bits in "in" */ + /* for string and stored block copying */ + unsigned length; /* literal or length of data to copy */ + unsigned offset; /* distance back to copy string from */ + /* for table and code decoding */ + unsigned extra; /* extra bits needed */ + /* fixed and dynamic code tables */ + code const FAR *lencode; /* starting table for length/literal codes */ + code const FAR *distcode; /* starting table for distance codes */ + unsigned lenbits; /* index bits for lencode */ + unsigned distbits; /* index bits for distcode */ + /* dynamic table building */ + unsigned ncode; /* number of code length code lengths */ + unsigned nlen; /* number of length code lengths */ + unsigned ndist; /* number of distance code lengths */ + unsigned have; /* number of code lengths in lens[] */ + code FAR *next; /* next available space in codes[] */ + unsigned short lens[320]; /* temporary storage for code lengths */ + unsigned short work[288]; /* work area for code table building */ + code codes[ENOUGH]; /* space for code tables */ +}; +#endif /* _INFLATE_H */ + +#ifndef _INFTREES_C +#define _INFTREES_C 1 + +#define MAXBITS 15 + +const char inflate_copyright[] = + " inflate 1.2.3 Copyright 1995-2005 Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* + Build a set of tables to decode the provided canonical Huffman code. + The code lengths are lens[0..codes-1]. The result starts at *table, + whose indices are 0..2^bits-1. work is a writable array of at least + lens shorts, which is used as a work area. type is the type of code + to be generated, CODES, LENS, or DISTS. On return, zero is success, + -1 is an invalid code, and +1 means that ENOUGH isn't enough. table + on return points to the next available entry's address. bits is the + requested root table index bits, and on return it is the actual root + table index bits. It will differ if the request is greater than the + longest code or if it is less than the shortest code. + */ +int inflate_table(type, lens, codes, table, bits, work) +codetype type; +unsigned short FAR *lens; +unsigned codes; +code FAR * FAR *table; +unsigned FAR *bits; +unsigned short FAR *work; +{ + unsigned len; /* a code's length in bits */ + unsigned sym; /* index of code symbols */ + unsigned min, max; /* minimum and maximum code lengths */ + unsigned root; /* number of index bits for root table */ + unsigned curr; /* number of index bits for current table */ + unsigned drop; /* code bits to drop for sub-table */ + int left; /* number of prefix codes available */ + unsigned used; /* code entries in table used */ + unsigned huff; /* Huffman code */ + unsigned incr; /* for incrementing code, index */ + unsigned fill; /* index for replicating entries */ + unsigned low; /* low bits for current root entry */ + unsigned mask; /* mask for low root bits */ + code this; /* table entry for duplication */ + code FAR *next; /* next available space in table */ + const unsigned short FAR *base; /* base value table to use */ + const unsigned short FAR *extra; /* extra bits table to use */ + int end; /* use base and extra for symbol > end */ + unsigned short count[MAXBITS+1]; /* number of codes of each length */ + unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ + static const unsigned short lbase[31] = { /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + static const unsigned short lext[31] = { /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196}; + static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0}; + static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64}; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) + count[len] = 0; + for (sym = 0; sym < codes; sym++) + count[lens[sym]]++; + + /* bound code lengths, force root to be within code lengths */ + root = *bits; + for (max = MAXBITS; max >= 1; max--) + if (count[max] != 0) break; + if (root > max) root = max; + if (max == 0) { /* no symbols to code at all */ + this.op = (unsigned char)64; /* invalid code marker */ + this.bits = (unsigned char)1; + this.val = (unsigned short)0; + *(*table)++ = this; /* make a table to force an error */ + *(*table)++ = this; + *bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min <= MAXBITS; min++) + if (count[min] != 0) break; + if (root < min) root = min; + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) return -1; /* over-subscribed */ + } + if (left > 0 && (type == CODES || max != 1)) + return -1; /* incomplete set */ + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) + offs[len + 1] = offs[len] + count[len]; + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) + if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked when a LENS table is being made + against the space in *table, ENOUGH, minus the maximum space needed by + the worst case distance code, MAXD. This should never happen, but the + sufficiency of ENOUGH has not been proven exhaustively, hence the check. + This assumes that when type == LENS, bits == 9. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + switch (type) { + case CODES: + base = extra = work; /* dummy value--not used */ + end = 19; + break; + case LENS: + base = lbase; + base -= 257; + extra = lext; + extra -= 257; + end = 256; + break; + default: /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize state for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = *table; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = (unsigned)(-1); /* trigger new sub-table when len > root */ + used = ((unsigned int)1) << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if (type == LENS && used >= ENOUGH - MAXD) + return 1; + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + this.bits = (unsigned char)(len - drop); + if ((int)(work[sym]) < end) { + this.op = (unsigned char)0; + this.val = work[sym]; + } + else if ((int)(work[sym]) > end) { + this.op = (unsigned char)(extra[work[sym]]); + this.val = base[work[sym]]; + } + else { + this.op = (unsigned char)(32 + 64); /* end of block */ + this.val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = ((unsigned int)1) << (len - drop); + fill = ((unsigned int)1) << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + next[(huff >> drop) + fill] = this; + } while (fill != 0); + + /* backwards increment the len-bit code huff */ + incr = ((unsigned int)1) << (len - 1); + while (huff & incr) + incr >>= 1; + if (incr != 0) { + huff &= incr - 1; + huff += incr; + } + else + huff = 0; + + /* go to next symbol, update count, len */ + sym++; + if (--(count[len]) == 0) { + if (len == max) break; + len = lens[work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) != low) { + /* if first time, transition to sub-tables */ + if (drop == 0) + drop = root; + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = (int)(1 << curr); + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) break; + curr++; + left <<= 1; + } + + /* check for enough space */ + used += ((unsigned int)1) << curr; + if (type == LENS && used >= ENOUGH - MAXD) + return 1; + + /* point entry in root table to sub-table */ + low = huff & mask; + (*table)[low].op = (unsigned char)curr; + (*table)[low].bits = (unsigned char)root; + (*table)[low].val = (unsigned short)(next - *table); + } + } + + /* + Fill in rest of table for incomplete codes. This loop is similar to the + loop above in incrementing huff for table indices. It is assumed that + len is equal to curr + drop, so there is no loop needed to increment + through high index bits. When the current sub-table is filled, the loop + drops back to the root table to fill in any remaining entries there. + */ + this.op = (unsigned char)64; /* invalid code marker */ + this.bits = (unsigned char)(len - drop); + this.val = (unsigned short)0; + while (huff != 0) { + /* when done with sub-table, drop back to root table */ + if (drop != 0 && (huff & mask) != low) { + drop = 0; + len = root; + next = *table; + this.bits = (unsigned char)len; + } + + /* put invalid code marker in table */ + next[huff >> drop] = this; + + /* backwards increment the len-bit code huff */ + incr = ((unsigned int)1) << (len - 1); + while (huff & incr) + incr >>= 1; + if (incr != 0) { + huff &= incr - 1; + huff += incr; + } + else + huff = 0; + } + + /* set return parameters */ + *table += used; + *bits = root; + return 0; +} + +#endif /* _INFTREES_C */ + +#ifndef _INFFAST_C +#define _INFFAST_C 1 + +/* Allow machine dependent optimization for post-increment or pre-increment. + Based on testing to date, + Pre-increment preferred for: + - PowerPC G3 (Adler) + - MIPS R5000 (Randers-Pehrson) + Post-increment preferred for: + - none + No measurable difference: + - Pentium III (Anderson) + - M68060 (Nikl) + */ +#undef OFF /* (ancient) sunos <locale.h> */ +#ifdef POSTINC +# define OFF 0 +# define PUP(a) *(a)++ +#else +# define OFF 1 +# define PUP(a) *++(a) +#endif + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state->mode == LEN + strm->avail_in >= 6 + strm->avail_out >= 258 + start >= strm->avail_out + state->bits < 8 + + On return, state->mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm->avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm->avail_out >= 258 for each loop to avoid checking for + output space. + */ +void inflate_fast(strm, start) +z_streamp strm; +unsigned start; /* inflate()'s starting value for strm->avail_out */ +{ + struct inflate_state FAR *state; + unsigned char FAR *in; /* local strm->next_in */ + unsigned char FAR *last; /* while in < last, enough input available */ + unsigned char FAR *out; /* local strm->next_out */ + unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ + unsigned char FAR *end; /* while out < end, enough space available */ +#ifdef INFLATE_STRICT + unsigned dmax; /* maximum distance from zlib header */ +#endif + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned write; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ + unsigned long hold; /* local strm->hold */ + unsigned bits; /* local strm->bits */ + code const FAR *lcode; /* local strm->lencode */ + code const FAR *dcode; /* local strm->distcode */ + unsigned lmask; /* mask for first level of length codes */ + unsigned dmask; /* mask for first level of distance codes */ + code this; /* retrieved table entry */ + unsigned op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + unsigned len; /* match length, unused bytes */ + unsigned dist; /* match distance */ + unsigned char FAR *from; /* where to copy match from */ + + /* copy state to local variables */ + state = (struct inflate_state FAR *)strm->state; + in = strm->next_in - OFF; + last = in + (strm->avail_in - 5); + out = strm->next_out - OFF; + beg = out - (start - strm->avail_out); + end = out + (strm->avail_out - 257); +#ifdef INFLATE_STRICT + dmax = state->dmax; +#endif + wsize = state->wsize; + whave = state->whave; + write = state->write; + window = state->window; + hold = state->hold; + bits = state->bits; + lcode = state->lencode; + dcode = state->distcode; + lmask = (((unsigned int)1) << state->lenbits) - 1; + dmask = (((unsigned int)1) << state->distbits) - 1; + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + do { + if (bits < 15) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + this = lcode[hold & lmask]; + dolen: + op = (unsigned)(this.bits); + hold >>= op; + bits -= op; + op = (unsigned)(this.op); + if (op == 0) { /* literal */ + Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", this.val)); + PUP(out) = (unsigned char)(this.val); + } + else if (op & 16) { /* length base */ + len = (unsigned)(this.val); + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + len += (unsigned)hold & ((((unsigned int)1) << op) - 1); + hold >>= op; + bits -= op; + } + Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + this = dcode[hold & dmask]; + dodist: + op = (unsigned)(this.bits); + hold >>= op; + bits -= op; + op = (unsigned)(this.op); + if (op & 16) { /* distance base */ + dist = (unsigned)(this.val); + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + if (bits < op) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + } + dist += (unsigned)hold & ((((unsigned int)1) << op) - 1); +#ifdef INFLATE_STRICT + if (dist > dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + hold >>= op; + bits -= op; + Tracevv((stderr, "inflate: distance %u\n", dist)); + op = (unsigned)(out - beg); /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } + from = window - OFF; + if (write == 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + else if (write < op) { /* wrap around window */ + from += wsize + write - op; + op -= write; + if (op < len) { /* some from end of window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = window - OFF; + if (write < len) { /* some from start of window */ + op = write; + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + } + else { /* contiguous in window */ + from += write - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + while (len > 2) { + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + else { + from = out - dist; /* copy direct from output */ + do { /* minimum length is three */ + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } while (len > 2); + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + } + else if ((op & 64) == 0) { /* 2nd level distance code */ + this = dcode[this.val + (hold & ((((unsigned int)1) << op) - 1))]; + goto dodist; + } + else { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + } + else if ((op & 64) == 0) { /* 2nd level length code */ + this = lcode[this.val + (hold & ((((unsigned int)1) << op) - 1))]; + goto dolen; + } + else if (op & 32) { /* end-of-block */ + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } + else { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + } while (in < last && out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + in -= len; + bits -= len << 3; + hold &= (((unsigned int)1) << bits) - 1; + + /* update state and return */ + strm->next_in = in + OFF; + strm->next_out = out + OFF; + strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); + strm->avail_out = (unsigned)(out < end ? + 257 + (end - out) : 257 - (out - end)); + state->hold = hold; + state->bits = bits; + return; +} + +/* + inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): + - Using bit fields for code structure + - Different op definition to avoid & for extra bits (do & for table bits) + - Three separate decoding do-loops for direct, window, and write == 0 + - Special case for distance > 1 copies to do overlapped load and store copy + - Explicit branch predictions (based on measured branch probabilities) + - Deferring match copy and interspersed it with decoding subsequent codes + - Swapping literal/length else + - Swapping window/direct else + - Larger unrolled copy loops (three is about right) + - Moving len -= 3 statement into middle of loop + */ + +#endif /* _INFFAST_C */ + +#ifndef _INFLATE_C +#define _INFLATE_C 1 + +/* function prototypes */ +local void fixedtables OF((struct inflate_state FAR *state)); +local int updatewindow OF((z_streamp strm, unsigned out)); +#ifdef BUILDFIXED + void makefixed OF((void)); +#endif +local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, + unsigned len)); + +int ZEXPORT inflateReset(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + strm->total_in = strm->total_out = state->total = 0; + strm->msg = Z_NULL; + strm->adler = 1; /* to support ill-conceived Java test suite */ + state->mode = HEAD; + state->last = 0; + state->havedict = 0; + state->dmax = 32768; + state->head = Z_NULL; + state->wsize = 0; + state->whave = 0; + state->write = 0; + state->hold = 0; + state->bits = 0; + state->lencode = state->distcode = state->next = state->codes; + Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +int ZEXPORT inflatePrime(strm, bits, value) +z_streamp strm; +int bits; +int value; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; + value &= (1L << bits) - 1; + state->hold += value << state->bits; + state->bits += bits; + return Z_OK; +} + +int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) +z_streamp strm; +int windowBits; +const char *version; +int stream_size; +{ + struct inflate_state FAR *state; + + if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || + stream_size != (int)(sizeof(z_stream))) + return Z_VERSION_ERROR; + if (strm == Z_NULL) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; + } + if (strm->zfree == (free_func)0) strm->zfree = zcfree; + state = (struct inflate_state FAR *) + ZALLOC(strm, 1, sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; + if (windowBits < 0) { + state->wrap = 0; + windowBits = -windowBits; + } + else { + state->wrap = (windowBits >> 4) + 1; +#ifdef GUNZIP + if (windowBits < 48) windowBits &= 15; +#endif + } + if (windowBits < 8 || windowBits > 15) { + ZFREE(strm, state); + strm->state = Z_NULL; + return Z_STREAM_ERROR; + } + state->wbits = (unsigned)windowBits; + state->window = Z_NULL; + return inflateReset(strm); +} + +int ZEXPORT inflateInit_(strm, version, stream_size) +z_streamp strm; +const char *version; +int stream_size; +{ + return inflateInit2_(strm, DEF_WBITS, version, stream_size); +} + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +local void fixedtables(state) +struct inflate_state FAR *state; +{ +#ifndef _INFFIXED_H +#define _INFFIXED_H 1 + static const code lenfix[512] = { + {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, + {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, + {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, + {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, + {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, + {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, + {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, + {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, + {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, + {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, + {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, + {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, + {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, + {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, + {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, + {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, + {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, + {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, + {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, + {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, + {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, + {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, + {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, + {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, + {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, + {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, + {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, + {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, + {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, + {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, + {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, + {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, + {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, + {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, + {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, + {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, + {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, + {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, + {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, + {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, + {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, + {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, + {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, + {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, + {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, + {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, + {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, + {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, + {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, + {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, + {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, + {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, + {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, + {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, + {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, + {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, + {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, + {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, + {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, + {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, + {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, + {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, + {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, + {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, + {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, + {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, + {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, + {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, + {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, + {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, + {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, + {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, + {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, + {0,9,255} + }; + + static const code distfix[32] = { + {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, + {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, + {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, + {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, + {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, + {22,5,193},{64,5,0} + }; +#endif /* _INFFIXED_H */ + state->lencode = lenfix; + state->lenbits = 9; + state->distcode = distfix; + state->distbits = 5; +} + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +local int updatewindow(strm, out) +z_streamp strm; +unsigned out; +{ + struct inflate_state FAR *state; + unsigned copy, dist; + + state = (struct inflate_state FAR *)strm->state; + + /* if it hasn't been done already, allocate space for the window */ + if (state->window == Z_NULL) { + state->window = (unsigned char FAR *) + ZALLOC(strm, ((unsigned int)1) << state->wbits, + sizeof(unsigned char)); + if (state->window == Z_NULL) return 1; + } + + /* if window not in use yet, initialize */ + if (state->wsize == 0) { + state->wsize = ((unsigned int)1) << state->wbits; + state->write = 0; + state->whave = 0; + } + + /* copy state->wsize or less output bytes into the circular window */ + copy = out - strm->avail_out; + if (copy >= state->wsize) { + zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); + state->write = 0; + state->whave = state->wsize; + } + else { + dist = state->wsize - state->write; + if (dist > copy) dist = copy; + zmemcpy(state->window + state->write, strm->next_out - copy, dist); + copy -= dist; + if (copy) { + zmemcpy(state->window, strm->next_out - copy, copy); + state->write = copy; + state->whave = state->wsize; + } + else { + state->write += dist; + if (state->write == state->wsize) state->write = 0; + if (state->whave < state->wsize) state->whave += dist; + } + } + return 0; +} + +/* Macros for inflate(): */ + +/* check function to use adler32() for zlib or crc32() for gzip */ +#ifdef GUNZIP +# define UPDATE(check, buf, len) \ + (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) +#else +# define UPDATE(check, buf, len) adler32(check, buf, len) +#endif + +/* check macros for header crc */ +#ifdef GUNZIP +# define CRC2(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + check = crc32(check, hbuf, 2); \ + } while (0) + +# define CRC4(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + hbuf[2] = (unsigned char)((word) >> 16); \ + hbuf[3] = (unsigned char)((word) >> 24); \ + check = crc32(check, hbuf, 4); \ + } while (0) +#endif + +/* Load registers with state in inflate() for speed */ +#define LOAD() \ + do { \ + put = strm->next_out; \ + left = strm->avail_out; \ + next = strm->next_in; \ + have = strm->avail_in; \ + hold = state->hold; \ + bits = state->bits; \ + } while (0) + +/* Restore state from registers in inflate() */ +#define RESTORE() \ + do { \ + strm->next_out = put; \ + strm->avail_out = left; \ + strm->next_in = next; \ + strm->avail_in = have; \ + state->hold = hold; \ + state->bits = bits; \ + } while (0) + +/* Clear the input bit accumulator */ +#define INITBITS() \ + do { \ + hold = 0; \ + bits = 0; \ + } while (0) + +/* Get a byte of input into the bit accumulator, or return from inflate() + if there is no input available. */ +#define PULLBYTE() \ + do { \ + if (have == 0) goto inf_leave; \ + have--; \ + hold += (unsigned long)(*next++) << bits; \ + bits += 8; \ + } while (0) + +/* Assure that there are at least n bits in the bit accumulator. If there is + not enough available input to do that, then return from inflate(). */ +#define NEEDBITS(n) \ + do { \ + while (bits < (unsigned)(n)) \ + PULLBYTE(); \ + } while (0) + +/* Return the low n bits of the bit accumulator (n < 16) */ +#define BITS(n) \ + ((unsigned)hold & ((((unsigned int)1) << (n)) - 1)) + +/* Remove n bits from the bit accumulator */ +#define DROPBITS(n) \ + do { \ + hold >>= (n); \ + bits -= (unsigned)(n); \ + } while (0) + +/* Remove zero to seven bits as needed to go to a byte boundary */ +#define BYTEBITS() \ + do { \ + hold >>= bits & 7; \ + bits -= bits & 7; \ + } while (0) + +/* Reverse the bytes in a 32-bit value */ +#define REVERSE(q) \ + ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ + (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) + +/* + inflate() uses a state machine to process as much input data and generate as + much output data as possible before returning. The state machine is + structured roughly as follows: + + for (;;) switch (state) { + ... + case STATEn: + if (not enough input data or output space to make progress) + return; + ... make progress ... + state = STATEm; + break; + ... + } + + so when inflate() is called again, the same case is attempted again, and + if the appropriate resources are provided, the machine proceeds to the + next state. The NEEDBITS() macro is usually the way the state evaluates + whether it can proceed or should return. NEEDBITS() does the return if + the requested bits are not available. The typical use of the BITS macros + is: + + NEEDBITS(n); + ... do something with BITS(n) ... + DROPBITS(n); + + where NEEDBITS(n) either returns from inflate() if there isn't enough + input left to load n bits into the accumulator, or it continues. BITS(n) + gives the low n bits in the accumulator. When done, DROPBITS(n) drops + the low n bits off the accumulator. INITBITS() clears the accumulator + and sets the number of available bits to zero. BYTEBITS() discards just + enough bits to put the accumulator on a byte boundary. After BYTEBITS() + and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. + + NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return + if there is no input available. The decoding of variable length codes uses + PULLBYTE() directly in order to pull just enough bytes to decode the next + code, and no more. + + Some states loop until they get enough input, making sure that enough + state information is maintained to continue the loop where it left off + if NEEDBITS() returns in the loop. For example, want, need, and keep + would all have to actually be part of the saved state in case NEEDBITS() + returns: + + case STATEw: + while (want < need) { + NEEDBITS(n); + keep[want++] = BITS(n); + DROPBITS(n); + } + state = STATEx; + case STATEx: + + As shown above, if the next state is also the next case, then the break + is omitted. + + A state may also return if there is not enough output space available to + complete that state. Those states are copying stored data, writing a + literal byte, and copying a matching string. + + When returning, a "goto inf_leave" is used to update the total counters, + update the check value, and determine whether any progress has been made + during that inflate() call in order to return the proper return code. + Progress is defined as a change in either strm->avail_in or strm->avail_out. + When there is a window, goto inf_leave will update the window with the last + output written. If a goto inf_leave occurs in the middle of decompression + and there is no window currently, goto inf_leave will create one and copy + output to the window for the next call of inflate(). + + In this implementation, the flush parameter of inflate() only affects the + return code (per zlib.h). inflate() always writes as much as possible to + strm->next_out, given the space available and the provided input--the effect + documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers + the allocation of and copying into a sliding window until necessary, which + provides the effect documented in zlib.h for Z_FINISH when the entire input + stream available. So the only thing the flush parameter actually does is: + when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it + will return Z_BUF_ERROR if it has not reached the end of the stream. + */ + +int ZEXPORT inflate(strm, flush) +z_streamp strm; +int flush; +{ + struct inflate_state FAR *state; + unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned long hold; /* bit buffer */ + unsigned bits; /* bits in bit buffer */ + unsigned in, out; /* save starting available input and output */ + unsigned copy; /* number of stored or match bytes to copy */ + unsigned char FAR *from; /* where to copy match bytes from */ + code this; /* current decoding table entry */ + code last; /* parent table entry */ + unsigned len; /* length to copy for repeats, bits to drop */ + int ret; /* return code */ +#ifdef GUNZIP + unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ +#endif + static const unsigned short order[19] = /* permutation of code lengths */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + + if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0)) + return Z_STREAM_ERROR; + + state = (struct inflate_state FAR *)strm->state; + if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ + LOAD(); + in = have; + out = left; + ret = Z_OK; + for (;;) + switch (state->mode) { + case HEAD: + if (state->wrap == 0) { + state->mode = TYPEDO; + break; + } + NEEDBITS(16); +#ifdef GUNZIP + if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ + state->check = crc32(0L, Z_NULL, 0); + CRC2(state->check, hold); + INITBITS(); + state->mode = FLAGS; + break; + } + state->flags = 0; /* expect zlib header */ + if (state->head != Z_NULL) + state->head->done = -1; + if (!(state->wrap & 1) || /* check if zlib header allowed */ +#else + if ( +#endif + ((BITS(8) << 8) + (hold >> 8)) % 31) { + strm->msg = (char *)"incorrect header check"; + state->mode = BAD; + break; + } + if (BITS(4) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + DROPBITS(4); + len = BITS(4) + 8; + if (len > state->wbits) { + strm->msg = (char *)"invalid window size"; + state->mode = BAD; + break; + } + state->dmax = ((unsigned int)1) << len; + Tracev((stderr, "inflate: zlib header ok\n")); + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = hold & 0x200 ? DICTID : TYPE; + INITBITS(); + break; +#ifdef GUNZIP + case FLAGS: + NEEDBITS(16); + state->flags = (int)(hold); + if ((state->flags & 0xff) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + if (state->flags & 0xe000) { + strm->msg = (char *)"unknown header flags set"; + state->mode = BAD; + break; + } + if (state->head != Z_NULL) + state->head->text = (int)((hold >> 8) & 1); + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = TIME; + case TIME: + NEEDBITS(32); + if (state->head != Z_NULL) + state->head->time = hold; + if (state->flags & 0x0200) CRC4(state->check, hold); + INITBITS(); + state->mode = OS; + case OS: + NEEDBITS(16); + if (state->head != Z_NULL) { + state->head->xflags = (int)(hold & 0xff); + state->head->os = (int)(hold >> 8); + } + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = EXLEN; + case EXLEN: + if (state->flags & 0x0400) { + NEEDBITS(16); + state->length = (unsigned)(hold); + if (state->head != Z_NULL) + state->head->extra_len = (unsigned)hold; + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + } + else if (state->head != Z_NULL) + state->head->extra = Z_NULL; + state->mode = EXTRA; + case EXTRA: + if (state->flags & 0x0400) { + copy = state->length; + if (copy > have) copy = have; + if (copy) { + if (state->head != Z_NULL && + state->head->extra != Z_NULL) { + len = state->head->extra_len - state->length; + zmemcpy(state->head->extra + len, next, + len + copy > state->head->extra_max ? + state->head->extra_max - len : copy); + } + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + state->length -= copy; + } + if (state->length) goto inf_leave; + } + state->length = 0; + state->mode = NAME; + case NAME: + if (state->flags & 0x0800) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->name != Z_NULL && + state->length < state->head->name_max) + state->head->name[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->name = Z_NULL; + state->length = 0; + state->mode = COMMENT; + case COMMENT: + if (state->flags & 0x1000) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->comment != Z_NULL && + state->length < state->head->comm_max) + state->head->comment[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->comment = Z_NULL; + state->mode = HCRC; + case HCRC: + if (state->flags & 0x0200) { + NEEDBITS(16); + if (hold != (state->check & 0xffff)) { + strm->msg = (char *)"header crc mismatch"; + state->mode = BAD; + break; + } + INITBITS(); + } + if (state->head != Z_NULL) { + state->head->hcrc = (int)((state->flags >> 9) & 1); + state->head->done = 1; + } + strm->adler = state->check = crc32(0L, Z_NULL, 0); + state->mode = TYPE; + break; +#endif + case DICTID: + NEEDBITS(32); + strm->adler = state->check = REVERSE(hold); + INITBITS(); + state->mode = DICT; + case DICT: + if (state->havedict == 0) { + RESTORE(); + return Z_NEED_DICT; + } + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = TYPE; + case TYPE: + if (flush == Z_BLOCK) goto inf_leave; + case TYPEDO: + if (state->last) { + BYTEBITS(); + state->mode = CHECK; + break; + } + NEEDBITS(3); + state->last = BITS(1); + DROPBITS(1); + switch (BITS(2)) { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN; /* decode codes */ + break; + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + case 3: + strm->msg = (char *)"invalid block type"; + state->mode = BAD; + } + DROPBITS(2); + break; + case STORED: + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { + strm->msg = (char *)"invalid stored block lengths"; + state->mode = BAD; + break; + } + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + state->mode = COPY; + case COPY: + copy = state->length; + if (copy) { + if (copy > have) copy = have; + if (copy > left) copy = left; + if (copy == 0) goto inf_leave; + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + break; + } + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + case TABLE: + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + if (state->nlen > 286 || state->ndist > 30) { + strm->msg = (char *)"too many length or distance symbols"; + state->mode = BAD; + break; + } +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + state->have = 0; + state->mode = LENLENS; + case LENLENS: + while (state->have < state->ncode) { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid code lengths set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: code lengths ok\n")); + state->have = 0; + state->mode = CODELENS; + case CODELENS: + while (state->have < state->nlen + state->ndist) { + for (;;) { + this = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(this.bits) <= bits) break; + PULLBYTE(); + } + if (this.val < 16) { + NEEDBITS(this.bits); + DROPBITS(this.bits); + state->lens[state->have++] = this.val; + } + else { + if (this.val == 16) { + NEEDBITS(this.bits + 2); + DROPBITS(this.bits); + if (state->have == 0) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + len = state->lens[state->have - 1]; + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (this.val == 17) { + NEEDBITS(this.bits + 3); + DROPBITS(this.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else { + NEEDBITS(this.bits + 7); + DROPBITS(this.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + if (state->have + copy > state->nlen + state->ndist) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + while (copy--) + state->lens[state->have++] = (unsigned short)len; + } + } + + /* handle error breaks in while */ + if (state->mode == BAD) break; + + /* build code tables */ + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + state->distcode = (code const FAR *)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + if (ret) { + strm->msg = (char *)"invalid distances set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: codes ok\n")); + state->mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + RESTORE(); + inflate_fast(strm, out); + LOAD(); + break; + } + for (;;) { + this = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(this.bits) <= bits) break; + PULLBYTE(); + } + if (this.op && (this.op & 0xf0) == 0) { + last = this; + for (;;) { + this = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + this.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + } + DROPBITS(this.bits); + state->length = (unsigned)this.val; + if ((int)(this.op) == 0) { + Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", this.val)); + state->mode = LIT; + break; + } + if (this.op & 32) { + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } + if (this.op & 64) { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + state->extra = (unsigned)(this.op) & 15; + state->mode = LENEXT; + case LENEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + } + Tracevv((stderr, "inflate: length %u\n", state->length)); + state->mode = DIST; + case DIST: + for (;;) { + this = state->distcode[BITS(state->distbits)]; + if ((unsigned)(this.bits) <= bits) break; + PULLBYTE(); + } + if ((this.op & 0xf0) == 0) { + last = this; + for (;;) { + this = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + this.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + } + DROPBITS(this.bits); + if (this.op & 64) { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + state->offset = (unsigned)this.val; + state->extra = (unsigned)(this.op) & 15; + state->mode = DISTEXT; + case DISTEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + } +#ifdef INFLATE_STRICT + if (state->offset > state->dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + if (state->offset > state->whave + out - left) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + state->mode = MATCH; + case MATCH: + if (left == 0) goto inf_leave; + copy = out - left; + if (state->offset > copy) { /* copy from window */ + copy = state->offset - copy; + if (copy > state->write) { + copy -= state->write; + from = state->window + (state->wsize - copy); + } + else + from = state->window + (state->write - copy); + if (copy > state->length) copy = state->length; + } + else { /* copy from output */ + from = put - state->offset; + copy = state->length; + } + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = *from++; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; + case LIT: + if (left == 0) goto inf_leave; + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; + case CHECK: + if (state->wrap) { + NEEDBITS(32); + out -= left; + strm->total_out += out; + state->total += out; + if (out) + strm->adler = state->check = + UPDATE(state->check, put - out, out); + out = left; + if (( +#ifdef GUNZIP + state->flags ? hold : +#endif + REVERSE(hold)) != state->check) { + strm->msg = (char *)"incorrect data check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: check matches trailer\n")); + } +#ifdef GUNZIP + state->mode = LENGTH; + case LENGTH: + if (state->wrap && state->flags) { + NEEDBITS(32); + if (hold != (state->total & 0xffffffff)) { + strm->msg = (char *)"incorrect length check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: length matches trailer\n")); + } +#endif + state->mode = DONE; + case DONE: + ret = Z_STREAM_END; + goto inf_leave; + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + inf_leave: + RESTORE(); + if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) + if (updatewindow(strm, out)) { + state->mode = MEM; + return Z_MEM_ERROR; + } + in -= strm->avail_in; + out -= strm->avail_out; + strm->total_in += in; + strm->total_out += out; + state->total += out; + if (state->wrap && out) + strm->adler = state->check = + UPDATE(state->check, strm->next_out - out, out); + strm->data_type = state->bits + (state->last ? 64 : 0) + + (state->mode == TYPE ? 128 : 0); + if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) + ret = Z_BUF_ERROR; + return ret; +} + +int ZEXPORT inflateEnd(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->window != Z_NULL) ZFREE(strm, state->window); + ZFREE(strm, strm->state); + strm->state = Z_NULL; + Tracev((stderr, "inflate: end\n")); + return Z_OK; +} + +int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) +z_streamp strm; +const Bytef *dictionary; +uInt dictLength; +{ + struct inflate_state FAR *state; + unsigned long id; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->wrap != 0 && state->mode != DICT) + return Z_STREAM_ERROR; + + /* check for correct dictionary id */ + if (state->mode == DICT) { + id = adler32(0L, Z_NULL, 0); + id = adler32(id, dictionary, dictLength); + if (id != state->check) + return Z_DATA_ERROR; + } + + /* copy dictionary to window */ + if (updatewindow(strm, strm->avail_out)) { + state->mode = MEM; + return Z_MEM_ERROR; + } + if (dictLength > state->wsize) { + zmemcpy(state->window, dictionary + dictLength - state->wsize, + state->wsize); + state->whave = state->wsize; + } + else { + zmemcpy(state->window + state->wsize - dictLength, dictionary, + dictLength); + state->whave = dictLength; + } + state->havedict = 1; + Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +int ZEXPORT inflateGetHeader(strm, head) +z_streamp strm; +gz_headerp head; +{ + struct inflate_state FAR *state; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; + + /* save header structure */ + state->head = head; +#ifdef GUNZIP + head->done = 0; +#endif + return Z_OK; +} + +/* + Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found + or when out of input. When called, *have is the number of pattern bytes + found in order so far, in 0..3. On return *have is updated to the new + state. If on return *have equals four, then the pattern was found and the + return value is how many bytes were read including the last byte of the + pattern. If *have is less than four, then the pattern has not been found + yet and the return value is len. In the latter case, syncsearch() can be + called again with more data and the *have state. *have is initialized to + zero for the first call. + */ +local unsigned syncsearch(have, buf, len) +unsigned FAR *have; +unsigned char FAR *buf; +unsigned len; +{ + unsigned got; + unsigned next; + + got = *have; + next = 0; + while (next < len && got < 4) { + if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) + got++; + else if (buf[next]) + got = 0; + else + got = 4 - got; + next++; + } + *have = got; + return next; +} + +int ZEXPORT inflateSync(strm) +z_streamp strm; +{ + unsigned len; /* number of bytes to look at or looked at */ + unsigned long in, out; /* temporary to save total_in and total_out */ + unsigned char buf[4]; /* to restore bit buffer to byte string */ + struct inflate_state FAR *state; + + /* check parameters */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; + + /* if first time, start search in bit buffer */ + if (state->mode != SYNC) { + state->mode = SYNC; + state->hold <<= state->bits & 7; + state->bits -= state->bits & 7; + len = 0; + while (state->bits >= 8) { + buf[len++] = (unsigned char)(state->hold); + state->hold >>= 8; + state->bits -= 8; + } + state->have = 0; + syncsearch(&(state->have), buf, len); + } + + /* search available input */ + len = syncsearch(&(state->have), strm->next_in, strm->avail_in); + strm->avail_in -= len; + strm->next_in += len; + strm->total_in += len; + + /* return no joy or set up to restart inflate() on a new block */ + if (state->have != 4) return Z_DATA_ERROR; + in = strm->total_in; out = strm->total_out; + inflateReset(strm); + strm->total_in = in; strm->total_out = out; + state->mode = TYPE; + return Z_OK; +} + +/* + Returns true if inflate is currently at the end of a block generated by + Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + implementation to provide an additional safety check. PPP uses + Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored + block. When decompressing, PPP checks that at the end of input packet, + inflate is waiting for these length bytes. + */ +int ZEXPORT inflateSyncPoint(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + return state->mode == STORED && state->bits == 0; +} + +int ZEXPORT inflateCopy(dest, source) +z_streamp dest; +z_streamp source; +{ + struct inflate_state FAR *state; + struct inflate_state FAR *copy; + unsigned char FAR *window; + unsigned wsize; + + /* check input */ + if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || + source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)source->state; + + /* allocate space */ + copy = (struct inflate_state FAR *) + ZALLOC(source, 1, sizeof(struct inflate_state)); + if (copy == Z_NULL) return Z_MEM_ERROR; + window = Z_NULL; + if (state->window != Z_NULL) { + window = (unsigned char FAR *) + ZALLOC(source, ((unsigned int)1) << state->wbits, sizeof(unsigned char)); + if (window == Z_NULL) { + ZFREE(source, copy); + return Z_MEM_ERROR; + } + } + + /* copy state */ + zmemcpy(dest, source, sizeof(z_stream)); + zmemcpy(copy, state, sizeof(struct inflate_state)); + if (state->lencode >= state->codes && + state->lencode <= state->codes + ENOUGH - 1) { + copy->lencode = copy->codes + (state->lencode - state->codes); + copy->distcode = copy->codes + (state->distcode - state->codes); + } + copy->next = copy->codes + (state->next - state->codes); + if (window != Z_NULL) { + wsize = ((unsigned int)1) << state->wbits; + zmemcpy(window, state->window, wsize); + } + copy->window = window; + dest->state = (struct internal_state FAR *)copy; + return Z_OK; +} + +#endif /* _INFLATE_C */ + +#ifndef _GZIO_C +#define _GZIO_C 1 + +typedef voidp gzFile; + +#ifndef Z_BUFSIZE +# ifdef MAXSEG_64K +# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */ +# else +# define Z_BUFSIZE 16384 +# endif +#endif +#ifndef Z_PRINTF_BUFSIZE +# define Z_PRINTF_BUFSIZE 4096 +#endif + +#ifdef __MVS__ +# pragma map (fdopen , "\174\174FDOPEN") + FILE *fdopen(int, const char *); +#endif + +#if 0 && !_PACKAGE_ast +#ifndef STDC +extern voidp malloc OF((uInt size)); +extern void free OF((voidpf ptr)); +#endif +#endif + +#define ALLOC(size) malloc(size) +#define TRYFREE(p) {if (p) free(p);} + +static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */ + +/* gzip flag byte */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define RESERVED 0xE0 /* bits 5..7: reserved */ + +typedef struct gz_stream { + z_stream stream; + int z_err; /* error code for last stream operation */ + int z_eof; /* set if end of input file */ + FILE *file; /* .gz file */ + Byte *inbuf; /* input buffer */ + Byte *outbuf; /* output buffer */ + uLong crc; /* crc32 of uncompressed data */ + char *msg; /* error message */ + char *path; /* path name for debugging only */ + int transparent; /* 1 if input file is not a .gz file */ +#if _PACKAGE_ast + int fatal; /* fatal stream error => all other ops fail */ + int nocrc; /* 1 to skip 'r' crc checks */ + int noclose; /* 1 to skip destroy fclose */ + int verified;/* 2-byte magic read and verified ('v') */ +#endif + char mode; /* 'w' or 'r' */ + z_off_t start; /* start of compressed data in file (header skipped) */ + z_off_t in; /* bytes into deflate or inflate */ + z_off_t out; /* bytes out of deflate or inflate */ + int back; /* one character push-back */ + int last; /* true if push-back is last character */ +} gz_stream; + + +local gzFile gz_open OF((const char *path, const char *mode, FILE* fp)); +local int get_byte OF((gz_stream *s)); +local void check_header OF((gz_stream *s)); +local int destroy OF((gz_stream *s)); +local uLong getLong OF((gz_stream *s)); + +/* =========================================================================== + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb"). The file is given either by FILE pointer + or path name (if fp == 0). + gz_open returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). +*/ +local gzFile gz_open (path, mode, fp) + const char *path; + const char *mode; + FILE *fp; +{ + int err; + int level = Z_DEFAULT_COMPRESSION; /* compression level */ + int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */ + char *p = (char*)mode; + gz_stream *s; + char fmode[80]; /* copy of mode, without the compression level */ + char *m = fmode; + + if (!path || !mode) return Z_NULL; + + s = (gz_stream *)ALLOC(sizeof(gz_stream)); + if (!s) return Z_NULL; + + s->stream.zalloc = (alloc_func)0; + s->stream.zfree = (free_func)0; + s->stream.opaque = (voidpf)0; + s->stream.next_in = s->inbuf = Z_NULL; + s->stream.next_out = s->outbuf = Z_NULL; + s->stream.avail_in = s->stream.avail_out = 0; + s->file = NULL; + s->z_err = Z_OK; + s->z_eof = 0; + s->in = 0; + s->out = 0; + s->back = EOF; + s->crc = crc32(0L, Z_NULL, 0); +#if _PACKAGE_ast + s->fatal = 0; + s->nocrc = 0; + s->verified = 0; +#endif + s->msg = NULL; + s->transparent = 0; + + s->path = (char*)ALLOC(strlen(path)+1); + if (s->path == NULL) { + return destroy(s), (gzFile)Z_NULL; + } + strcpy(s->path, path); /* do this early for debugging */ + + s->mode = '\0'; + do { + if (*p == 'r') s->mode = 'r'; + if (*p == 'w' || *p == 'a') s->mode = 'w'; + if (*p >= '0' && *p <= '9') { + level = *p - '0'; + } else if (*p == 'f') { + strategy = Z_FILTERED; + } else if (*p == 'h') { + strategy = Z_HUFFMAN_ONLY; + } else if (*p == 'R') { + strategy = Z_RLE; +#if _PACKAGE_ast + } else if (*p == 'n') { + s->nocrc = 1; + } else if (*p == 'o') { + s->noclose = 1; + } else if (*p == 'v') { + s->verified = 1; +#endif + } else { + *m++ = *p; /* copy the mode */ + } + } while (*p++ && m != fmode + sizeof(fmode)); + if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL; + + if (s->mode == 'w') { +#ifdef NO_GZCOMPRESS + err = Z_STREAM_ERROR; +#else +#if _PACKAGE_ast + s->nocrc = 0; +#endif + err = deflateInit2(&(s->stream), level, + Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy); + /* windowBits is passed < 0 to suppress zlib header */ + + s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE); +#endif + if (err != Z_OK || s->outbuf == Z_NULL) { + return destroy(s), (gzFile)Z_NULL; + } + } else { + s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); + + err = inflateInit2(&(s->stream), -MAX_WBITS); + /* windowBits is passed < 0 to tell that there is no zlib header. + * Note that in this case inflate *requires* an extra "dummy" byte + * after the compressed stream in order to complete decompression and + * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are + * present after the compressed stream. + */ + if (err != Z_OK || s->inbuf == Z_NULL) { + return destroy(s), (gzFile)Z_NULL; + } + } + s->stream.avail_out = Z_BUFSIZE; + + errno = 0; + + if (!(s->file = fp) && !(s->file = F_OPEN(path, fmode))) { + return destroy(s), (gzFile)Z_NULL; + } + if (s->mode == 'w') { + /* Write a very simple .gz header: + */ + fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1], + Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE); + s->start = 10L; + /* We use 10L instead of ftell(s->file) to because ftell causes an + * fflush on some systems. This version of the library doesn't use + * start anyway in write mode, so this initialization is not + * necessary. + */ + } else { +#if _PACKAGE_ast + sfsetbuf(s->file, (void*)s->file, SF_UNBOUND); +#endif + check_header(s); /* skip the .gz header */ + s->start = ftell(s->file) - s->stream.avail_in; + } + + return (gzFile)s; +} + +/* =========================================================================== + Associate a gzFile with the stdio stream fp. +*/ +gzFile ZEXPORT gzfopen (fp, mode) + FILE* fp; + const char *mode; +{ + FILE* sp = (FILE*)fp; + char name[20]; + + if (!sp) + return (gzFile)Z_NULL; + sprintf(name, "<fd:%d>", fileno(sp)); /* for debugging */ + + return gz_open (name, mode, sp); +} + +/* =========================================================================== + Read a byte from a gz_stream; update next_in and avail_in. Return EOF + for end of file. + IN assertion: the stream s has been sucessfully opened for reading. +*/ +local int get_byte(s) + gz_stream *s; +{ + if (s->z_eof) return EOF; + if (s->stream.avail_in == 0) { + errno = 0; + s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file); + if (s->stream.avail_in == 0) { + s->z_eof = 1; + if (ferror(s->file)) s->z_err = Z_ERRNO; + return EOF; + } + s->stream.next_in = s->inbuf; + } + s->stream.avail_in--; + return *(s->stream.next_in)++; +} + +/* =========================================================================== + Check the gzip header of a gz_stream opened for reading. Set the stream + mode to transparent if the gzip magic header is not present; set s->err + to Z_DATA_ERROR if the magic header is present but the rest of the header + is incorrect. + IN assertion: the stream s has already been created sucessfully; + s->stream.avail_in is zero for the first time, but may be non-zero + for concatenated .gz files. +*/ +local void check_header(s) + gz_stream *s; +{ + int method; /* method byte */ + int flags; /* flags byte */ + uInt len; + int c; + +#if _PACKAGE_ast + if (!s->verified) + for (len = 0; len < 2; len++) { + c = get_byte(s); + if (c != gz_magic[len]) { + if (len != 0) s->stream.avail_in++, s->stream.next_in--; + if (c != EOF) { + s->stream.avail_in++, s->stream.next_in--; + s->transparent = 1; + } + s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END; + return; + } + } +#else + /* Assure two bytes in the buffer so we can peek ahead -- handle case + where first byte of header is at the end of the buffer after the last + gzip segment */ + len = s->stream.avail_in; + if (len < 2) { + if (len) s->inbuf[0] = s->stream.next_in[0]; + errno = 0; + len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file); + if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO; + s->stream.avail_in += len; + s->stream.next_in = s->inbuf; + if (s->stream.avail_in < 2) { + s->transparent = s->stream.avail_in; + return; + } + } + + /* Peek ahead to check the gzip magic header */ + if (s->stream.next_in[0] != gz_magic[0] || + s->stream.next_in[1] != gz_magic[1]) { + s->transparent = 1; + return; + } + s->stream.avail_in -= 2; + s->stream.next_in += 2; +#endif + + /* Check the rest of the gzip header */ + method = get_byte(s); + flags = get_byte(s); + if (method != Z_DEFLATED || (flags & RESERVED) != 0) { + s->z_err = Z_DATA_ERROR; + return; + } + + /* Discard time, xflags and OS code: */ + for (len = 0; len < 6; len++) (void)get_byte(s); + + if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */ + len = (uInt)get_byte(s); + len += ((uInt)get_byte(s))<<8; + /* len is garbage if EOF but the loop below will quit anyway */ + while (len-- != 0 && get_byte(s) != EOF) ; + } + if ((flags & ORIG_NAME) != 0) { /* skip the original file name */ + while ((c = get_byte(s)) != 0 && c != EOF) ; + } + if ((flags & COMMENT) != 0) { /* skip the .gz file comment */ + while ((c = get_byte(s)) != 0 && c != EOF) ; + } + if ((flags & HEAD_CRC) != 0) { /* skip the header crc */ + for (len = 0; len < 2; len++) (void)get_byte(s); + } + s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK; +} + + /* =========================================================================== + * Cleanup then free the given gz_stream. Return a zlib error code. + Try freeing in the reverse order of allocations. + */ +local int destroy (s) + gz_stream *s; +{ + int err = Z_OK; + + if (!s) return Z_STREAM_ERROR; + + TRYFREE(s->msg); + + if (s->stream.state != NULL) { + if (s->mode == 'w') { +#ifdef NO_GZCOMPRESS + err = Z_STREAM_ERROR; +#else + err = deflateEnd(&(s->stream)); +#endif + } else if (s->mode == 'r') { + err = inflateEnd(&(s->stream)); + } + } +#if _PACKAGE_ast + if (s->file != NULL && (s->noclose ? (s->mode == 'r' ? 0 : fflush(s->file)) : fclose(s->file))) { +#else + if (s->file != NULL && fclose(s->file)) { +#endif +#ifdef ESPIPE + if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */ +#endif + err = Z_ERRNO; + } + if (s->z_err < 0) err = s->z_err; + + TRYFREE(s->inbuf); + TRYFREE(s->outbuf); + TRYFREE(s->path); + TRYFREE(s); + return err; +} + +/* =========================================================================== + Reads the given number of uncompressed bytes from the compressed file. + gzread returns the number of bytes actually read (0 for end of file). +*/ +int ZEXPORT gzread (file, buf, len) + gzFile file; + voidp buf; + unsigned len; +{ + gz_stream *s = (gz_stream*)file; + Bytef *start = (Bytef*)buf; /* starting point for crc computation */ + Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */ + + if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR; + + if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1; + if (s->z_err == Z_STREAM_END) return 0; /* EOF */ + + next_out = (Byte*)buf; + s->stream.next_out = (Bytef*)buf; + s->stream.avail_out = len; + + if (s->stream.avail_out && s->back != EOF) { + *next_out++ = s->back; + s->stream.next_out++; + s->stream.avail_out--; + s->back = EOF; + s->out++; + start++; + if (s->last) { + s->z_err = Z_STREAM_END; + return 1; + } + } + + while (s->stream.avail_out != 0) { + + if (s->transparent) { + /* Copy first the lookahead bytes: */ + uInt n = s->stream.avail_in; + if (n > s->stream.avail_out) n = s->stream.avail_out; + if (n > 0) { + zmemcpy(s->stream.next_out, s->stream.next_in, n); + next_out += n; + s->stream.next_out = next_out; + s->stream.next_in += n; + s->stream.avail_out -= n; + s->stream.avail_in -= n; + } + if (s->stream.avail_out > 0) { + s->stream.avail_out -= + (uInt)fread(next_out, 1, s->stream.avail_out, s->file); + } + len -= s->stream.avail_out; + s->in += len; + s->out += len; + if (len == 0) s->z_eof = 1; + return (int)len; + } + if (s->stream.avail_in == 0 && !s->z_eof) { + + errno = 0; + s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file); + if (s->stream.avail_in == 0) { + s->z_eof = 1; + if (ferror(s->file)) { + s->z_err = Z_ERRNO; + break; + } + } + s->stream.next_in = s->inbuf; + } + s->in += s->stream.avail_in; + s->out += s->stream.avail_out; + s->z_err = inflate(&(s->stream), Z_NO_FLUSH); + s->in -= s->stream.avail_in; + s->out -= s->stream.avail_out; + + if (s->z_err == Z_STREAM_END) { + /* Check CRC and original size */ +#if _PACKAGE_ast + if (!s->nocrc) +#endif + s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); + start = s->stream.next_out; + +#if _PACKAGE_ast + if (getLong(s) != s->crc && !s->nocrc) { +#else + if (getLong(s) != s->crc) { +#endif + s->z_err = Z_DATA_ERROR; + } else { + (void)getLong(s); + /* The uncompressed length returned by above getlong() may be + * different from s->out in case of concatenated .gz files. + * Check for such files: + */ + check_header(s); + if (s->z_err == Z_OK) { + inflateReset(&(s->stream)); +#if _PACKAGE_ast + if (!s->nocrc) +#endif + s->crc = crc32(0L, Z_NULL, 0); +#if _PACKAGE_ast + else + s->z_err = Z_STREAM_END; +#endif + } + } + } + if (s->z_err != Z_OK || s->z_eof) break; + } +#if _PACKAGE_ast + if (!s->nocrc) +#endif + s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); + + if (len == s->stream.avail_out && + (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)) + return -1; + return (int)(len - s->stream.avail_out); +} + +/* =========================================================================== + Reads a long in LSB order from the given gz_stream. Sets z_err in case + of error. +*/ +local uLong getLong (s) + gz_stream *s; +{ + uLong x = (uLong)get_byte(s); + int c; + + x += ((uLong)get_byte(s))<<8; + x += ((uLong)get_byte(s))<<16; + c = get_byte(s); + if (c == EOF) s->z_err = Z_DATA_ERROR; + x += ((uLong)c)<<24; + return x; +} + +#endif /* _GZIO_C */ + +#endif /* _GUNZIP_H */ + +#undef local + +#ifndef _RATZ_C +#define _RATZ_C 1 + +#include <sys/stat.h> + +#ifndef S_IRUSR +#define S_IRUSR 0400 +#endif +#ifndef S_IWUSR +#define S_IWUSR 0200 +#endif +#ifndef S_IXUSR +#define S_IXUSR 0100 +#endif +#ifndef S_IRGRP +#define S_IRGRP 0040 +#endif +#ifndef S_IWGRP +#define S_IWGRP 0020 +#endif +#ifndef S_IXGRP +#define S_IXGRP 0010 +#endif +#ifndef S_IROTH +#define S_IROTH 0004 +#endif +#ifndef S_IWOTH +#define S_IWOTH 0002 +#endif +#ifndef S_IXOTH +#define S_IXOTH 0001 +#endif + +/* + * Standard Archive Format + * USTAR - Uniform Standard Tape ARchive + */ + +#define TBLOCK 512 +#define NAMSIZ 100 +#define PFXSIZ 155 + +#define TMODLEN 8 +#define TUIDLEN 8 +#define TGIDLEN 8 +#define TSIZLEN 12 +#define TMTMLEN 12 +#define TCKSLEN 8 + +#define TMAGIC "ustar" /* ustar and a null */ +#define TMAGLEN 6 +#define TVERSION "00" /* 00 and no null */ +#define TVERSLEN 2 +#define TUNMLEN 32 +#define TGNMLEN 32 +#define TDEVLEN 8 +#define TPADLEN 12 + +/* + * values used in typeflag field + */ + +#define REGTYPE '0' /* regular file */ +#define AREGTYPE 0 /* alternate REGTYPE */ +#define LNKTYPE '1' /* hard link */ +#define SYMTYPE '2' /* soft link */ +#define CHRTYPE '3' /* character special */ +#define BLKTYPE '4' /* block special */ +#define DIRTYPE '5' /* directory */ +#define FIFOTYPE '6' /* FIFO special */ +#define CONTTYPE '7' /* reserved */ +#define SOKTYPE '8' /* socket -- reserved */ +#define VERTYPE 'V' /* version -- reserved */ +#define EXTTYPE 'x' /* extended header -- reserved */ + +/* + * bits used in mode field + */ + +#define TSUID 04000 /* set uid on exec */ +#define TSGID 02000 /* set gid on exec */ +#define TSVTX 01000 /* sticky bit -- reserved */ + +/* + * file permissions + */ + +#define TUREAD 00400 /* read by owner */ +#define TUWRITE 00200 /* write by owner */ +#define TUEXEC 00100 /* execute by owner */ +#define TGREAD 00040 /* read by group */ +#define TGWRITE 00020 /* execute by group */ +#define TGEXEC 00010 /* write by group */ +#define TOREAD 00004 /* read by other */ +#define TOWRITE 00002 /* write by other */ +#define TOEXEC 00001 /* execute by other */ + +#define TAR_SUMASK ((1L<<(TCKSLEN-1)*3)-1) + +typedef struct +{ + char name[NAMSIZ]; + char mode[TMODLEN]; + char uid[TUIDLEN]; + char gid[TGIDLEN]; + char size[TSIZLEN]; + char mtime[TMTMLEN]; + char chksum[TCKSLEN]; + char typeflag; + char linkname[NAMSIZ]; + char magic[TMAGLEN]; + char version[TVERSLEN]; + char uname[TUNMLEN]; + char gname[TGNMLEN]; + char devmajor[TDEVLEN]; + char devminor[TDEVLEN]; + char prefix[PFXSIZ]; + char pad[TPADLEN]; +} Header_t; + +static struct +{ + char* id; + unsigned long blocks; + unsigned long files; +} state; + +#if !_PACKAGE_ast + +static void +usage() +{ + fprintf(stderr, "Usage: %s [-clmntvV] < input.tgz\n", state.id); + exit(2); +} + +#endif + +/* + * the X/Open dd EBCDIC table + */ + +static const unsigned char a2e[] = +{ + 0000,0001,0002,0003,0067,0055,0056,0057, + 0026,0005,0045,0013,0014,0015,0016,0017, + 0020,0021,0022,0023,0074,0075,0062,0046, + 0030,0031,0077,0047,0034,0035,0036,0037, + 0100,0132,0177,0173,0133,0154,0120,0175, + 0115,0135,0134,0116,0153,0140,0113,0141, + 0360,0361,0362,0363,0364,0365,0366,0367, + 0370,0371,0172,0136,0114,0176,0156,0157, + 0174,0301,0302,0303,0304,0305,0306,0307, + 0310,0311,0321,0322,0323,0324,0325,0326, + 0327,0330,0331,0342,0343,0344,0345,0346, + 0347,0350,0351,0255,0340,0275,0232,0155, + 0171,0201,0202,0203,0204,0205,0206,0207, + 0210,0211,0221,0222,0223,0224,0225,0226, + 0227,0230,0231,0242,0243,0244,0245,0246, + 0247,0250,0251,0300,0117,0320,0137,0007, + 0040,0041,0042,0043,0044,0025,0006,0027, + 0050,0051,0052,0053,0054,0011,0012,0033, + 0060,0061,0032,0063,0064,0065,0066,0010, + 0070,0071,0072,0073,0004,0024,0076,0341, + 0101,0102,0103,0104,0105,0106,0107,0110, + 0111,0121,0122,0123,0124,0125,0126,0127, + 0130,0131,0142,0143,0144,0145,0146,0147, + 0150,0151,0160,0161,0162,0163,0164,0165, + 0166,0167,0170,0200,0212,0213,0214,0215, + 0216,0217,0220,0152,0233,0234,0235,0236, + 0237,0240,0252,0253,0254,0112,0256,0257, + 0260,0261,0262,0263,0264,0265,0266,0267, + 0270,0271,0272,0273,0274,0241,0276,0277, + 0312,0313,0314,0315,0316,0317,0332,0333, + 0334,0335,0336,0337,0352,0353,0354,0355, + 0356,0357,0372,0373,0374,0375,0376,0377, +}; + +/* + * the X/Open dd IBM table + */ + +static const unsigned char a2i[] = +{ + 0000,0001,0002,0003,0067,0055,0056,0057, + 0026,0005,0045,0013,0014,0015,0016,0017, + 0020,0021,0022,0023,0074,0075,0062,0046, + 0030,0031,0077,0047,0034,0035,0036,0037, + 0100,0132,0177,0173,0133,0154,0120,0175, + 0115,0135,0134,0116,0153,0140,0113,0141, + 0360,0361,0362,0363,0364,0365,0366,0367, + 0370,0371,0172,0136,0114,0176,0156,0157, + 0174,0301,0302,0303,0304,0305,0306,0307, + 0310,0311,0321,0322,0323,0324,0325,0326, + 0327,0330,0331,0342,0343,0344,0345,0346, + 0347,0350,0351,0255,0340,0275,0137,0155, + 0171,0201,0202,0203,0204,0205,0206,0207, + 0210,0211,0221,0222,0223,0224,0225,0226, + 0227,0230,0231,0242,0243,0244,0245,0246, + 0247,0250,0251,0300,0117,0320,0241,0007, + 0040,0041,0042,0043,0044,0025,0006,0027, + 0050,0051,0052,0053,0054,0011,0012,0033, + 0060,0061,0032,0063,0064,0065,0066,0010, + 0070,0071,0072,0073,0004,0024,0076,0341, + 0101,0102,0103,0104,0105,0106,0107,0110, + 0111,0121,0122,0123,0124,0125,0126,0127, + 0130,0131,0142,0143,0144,0145,0146,0147, + 0150,0151,0160,0161,0162,0163,0164,0165, + 0166,0167,0170,0200,0212,0213,0214,0215, + 0216,0217,0220,0232,0233,0234,0235,0236, + 0237,0240,0252,0253,0254,0255,0256,0257, + 0260,0261,0262,0263,0264,0265,0266,0267, + 0270,0271,0272,0273,0274,0275,0276,0277, + 0312,0313,0314,0315,0316,0317,0332,0333, + 0334,0335,0336,0337,0352,0353,0354,0355, + 0356,0357,0372,0373,0374,0375,0376,0377, +}; + +/* + * the mvs OpenEdition EBCDIC table + */ + +static const unsigned char a2o[] = +{ + 0000,0001,0002,0003,0067,0055,0056,0057, + 0026,0005,0025,0013,0014,0015,0016,0017, + 0020,0021,0022,0023,0074,0075,0062,0046, + 0030,0031,0077,0047,0034,0035,0036,0037, + 0100,0132,0177,0173,0133,0154,0120,0175, + 0115,0135,0134,0116,0153,0140,0113,0141, + 0360,0361,0362,0363,0364,0365,0366,0367, + 0370,0371,0172,0136,0114,0176,0156,0157, + 0174,0301,0302,0303,0304,0305,0306,0307, + 0310,0311,0321,0322,0323,0324,0325,0326, + 0327,0330,0331,0342,0343,0344,0345,0346, + 0347,0350,0351,0255,0340,0275,0137,0155, + 0171,0201,0202,0203,0204,0205,0206,0207, + 0210,0211,0221,0222,0223,0224,0225,0226, + 0227,0230,0231,0242,0243,0244,0245,0246, + 0247,0250,0251,0300,0117,0320,0241,0007, + 0040,0041,0042,0043,0044,0045,0006,0027, + 0050,0051,0052,0053,0054,0011,0012,0033, + 0060,0061,0032,0063,0064,0065,0066,0010, + 0070,0071,0072,0073,0004,0024,0076,0377, + 0101,0252,0112,0261,0237,0262,0152,0265, + 0273,0264,0232,0212,0260,0312,0257,0274, + 0220,0217,0352,0372,0276,0240,0266,0263, + 0235,0332,0233,0213,0267,0270,0271,0253, + 0144,0145,0142,0146,0143,0147,0236,0150, + 0164,0161,0162,0163,0170,0165,0166,0167, + 0254,0151,0355,0356,0353,0357,0354,0277, + 0200,0375,0376,0373,0374,0272,0256,0131, + 0104,0105,0102,0106,0103,0107,0234,0110, + 0124,0121,0122,0123,0130,0125,0126,0127, + 0214,0111,0315,0316,0313,0317,0314,0341, + 0160,0335,0336,0333,0334,0215,0216,0337, +}; + +/* + * ascii text vs. control + */ + +static const unsigned char ascii_text[] = +{ + 0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +}; + +static int +block(fp, gz, buf) +FILE* fp; +gzFile gz; +char* buf; +{ + int r; + + if (gz) + r = gzread(gz, buf, sizeof(Header_t)) == sizeof(Header_t); + else + r = fread(buf, sizeof(Header_t), 1, fp) == 1; + if (r) + state.blocks++; + return r; +} + +static int +skip(fp, gz, buf, n) +FILE* fp; +gzFile gz; +char* buf; +unsigned long n; +{ + while (n > 0) + { + if (!block(fp, gz, buf)) + { + fprintf(stderr, "%s: unexpected EOF\n", state.id); + return 1; + } + if (n <= sizeof(Header_t)) + break; + n -= sizeof(Header_t); + } + return 0; +} + +static unsigned long +number(s) +register char* s; +{ + unsigned long n = 0; + + while (*s == ' ') + s++; + while (*s >= '0' && *s <= '7') + n = (n << 3) + (*s++ - '0'); + return n; +} + +#if defined(_SEAR_EXEC) || defined(_SEAR_SEEK) + +#ifndef PATH_MAX +#define PATH_MAX 256 +#endif + +#define EXIT(n) return(sear_exec((char*)0,(char**)0,(char*)0),(n)) + +static int sear_stdin; +static char* sear_tmp; +static char sear_buf[PATH_MAX]; + +static int +sear_seek(off_t offset, int tmp) +{ + int n; + char cmd[PATH_MAX]; + + GetModuleFileName(NULL, cmd, sizeof(cmd)); + sear_stdin = dup(0); + close(0); + if (open(cmd, O_BINARY|O_RDONLY) || lseek(0, offset, 0) != offset) + { + fprintf(stderr, "%s: %s: cannot seek to data offset\n", state.id, cmd); + return -1; + } + if (tmp) + { + if ((n = GetTempPath(sizeof(cmd), cmd)) <= 0 || n > sizeof(cmd)) + { + fprintf(stderr, "%s: cannot determine temporary directory path\n", state.id); + return -1; + } + if (!GetTempFileName(cmd, "SEA", 0, sear_buf)) + { + fprintf(stderr, "%s: cannot determine temporary file path\n", state.id); + return -1; + } + sear_tmp = sear_buf; + if (!DeleteFile(sear_tmp)) + { + fprintf(stderr, "%s: %s: cannot initialize temporary directory\n", state.id, sear_tmp); + return -1; + } + if (!CreateDirectory(sear_tmp, NULL)) + { + fprintf(stderr, "%s: %s: cannot create temporary directory\n", state.id, sear_tmp); + return -1; + } + if (!SetCurrentDirectory(sear_tmp)) + { + fprintf(stderr, "%s: %s: cannot cd to temporary directory\n", state.id, sear_tmp); + return -1; + } + } + return 0; +} + +/* + * remove dir and its subdirs + */ + +static void +sear_rm_r(char* dir) +{ + WIN32_FIND_DATA info; + HANDLE hp; + + if (!SetCurrentDirectory(dir)) + return; + if ((hp = FindFirstFile("*.*", &info)) != INVALID_HANDLE_VALUE) + { + do + { + if (!(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) + { + if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) + SetFileAttributes(info.cFileName, info.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY); + DeleteFile(info.cFileName); + } + else if (info.cFileName[0] != '.' || info.cFileName[1] != 0 && (info.cFileName[1] != '.' || info.cFileName[2] != 0)) + sear_rm_r(info.cFileName); + } while(FindNextFile(hp, &info)); + FindClose(hp); + } + if (SetCurrentDirectory("..")) + RemoveDirectory(dir); +} + +/* + * system(3) without PATH search that should work on all windows variants + */ + +static int +sear_system(const char* command, int nowindow) +{ + PROCESS_INFORMATION pinfo; + STARTUPINFO sinfo; + char* cp; + char path[PATH_MAX]; + int n = *command == '"'; + DWORD flags = NORMAL_PRIORITY_CLASS; + + strncpy(path, &command[n], PATH_MAX - 4); + n = n ? '"' : ' '; + for (cp = path; *cp; *cp++) + if (*cp == n) + break; + *cp = 0; + if (GetFileAttributes(path) == 0xffffffff && GetLastError() == ERROR_FILE_NOT_FOUND) + strcpy(cp, ".exe"); + ZeroMemory(&sinfo, sizeof(sinfo)); + if (nowindow) + flags |= CREATE_NO_WINDOW; + if (!CreateProcess(path, (char*)command, 0, 0, TRUE, flags, NULL, NULL, &sinfo, &pinfo)) + n = GetLastError() == ERROR_FILE_NOT_FOUND ? 127 : 126; + else + { + CloseHandle(pinfo.hThread); + WaitForSingleObject(pinfo.hProcess, INFINITE); + if (!GetExitCodeProcess(pinfo.hProcess, &n)) + n = 1; + CloseHandle(pinfo.hProcess); + Sleep(2 * 1000); + } + return n; +} + +/* + * copy t to f but no farther than e + * next t returned + */ + +static char* +copy(char* t, const char* f, char* e) +{ + while (t < e && *f) + *t++ = *f++; + return t; +} + +/* + * execute cmd, chdir .., and remove sear_tmp + */ + +static int +sear_exec(const char* cmd, char* const* arg, char* operands) +{ + const char* a; + char* b; + char* e; + int r; + int sh; + int nowindow; + char buf[1024]; + + fflush(stdout); + fflush(stderr); + if (sear_tmp) + { + close(0); + dup(sear_stdin); + close(sear_stdin); + nowindow = 0; + if (cmd) + { + if (arg) + for (r = 0; arg[r]; r++) + if (!strcmp(arg[r], "remote")) + { + nowindow = 1; + break; + } + sh = 0; + for (a = cmd; *a && *a != ' '; a++) + if (a[0] == '.' && a[1] == 's' && a[2] == 'h' && (!a[3] || a[3] == ' ')) + { + sh = 1; + break; + } + b = buf; + e = buf + sizeof(buf) - 1; + if (sh || arg) + { + if (sh) + { + b = copy(b, "ksh.exe ", e); + if (*cmd && *cmd != '/') + b = copy(b, "./", e); + } + b = copy(b, cmd, e); + while (a = *arg++) + { + if ((e - b) < 3) + break; + b = copy(b, " \"", e); + b = copy(b, a, e); + b = copy(b, "\"", e); + } + } + if (operands) + { + if (b == buf) + b = copy(b, cmd, e); + b = copy(b, " -- ", e); + b = copy(b, operands, e); + } + if (b > buf) + { + *b = 0; + cmd = (const char*)buf; + } + } + r = cmd ? sear_system(cmd, nowindow) : 1; + sear_rm_r(sear_tmp); + } + else + r = cmd ? 0 : 1; + return r; +} + +#else + +#define EXIT(n) return(n) + +#endif + +int +main(argc, argv) +int argc; +char** argv; +{ + register int c; + register char* s; + register char* t; + register char* e; + unsigned long n; + unsigned long m; + const unsigned char* a2x; + int clear; + int list; + int local; + int meter; + int unzip; + int verbose; + unsigned int mode; + unsigned long total; + off_t pos; + gzFile gz; + FILE* fp; + Header_t header; + unsigned char num[4]; + char path[sizeof(header.prefix) + sizeof(header.name) + 4]; + char buf[sizeof(header)]; +#if defined(_SEAR_OPTS) + char* opts[4]; +#endif + +#if defined(_SEAR_EXEC) || defined(_SEAR_SEEK) + int install = 1; +#endif + + setmode(0, O_BINARY); + setmode(1, O_BINARY); + clear = 0; + list = 0; + local = 0; + meter = 0; + unzip = 0; + verbose = 0; + if (s = *argv) + { + t = s; + while (*s) + if (*s++ == '/') + t = s; + if (!strcmp(t, "gunzip")) + unzip = 1; + state.id = t; + } + else + state.id = "ratz"; + switch ('~') + { + case 0241: + switch ('\n') + { + case 0025: + a2x = a2o; + break; + default: + a2x = a2e; + break; + } + break; + case 0137: + a2x = a2i; + break; + default: + a2x = 0; + break; + } +#if defined(_SEAR_OPTS) + opts[0] = argv[0]; + opts[1] = _SEAR_OPTS; + opts[2] = argv[1]; + opts[3] = 0; + argv = opts; +#endif +#if _PACKAGE_ast + error_info.id = state.id; + for (;;) + { + switch (optget(argv, usage)) + { + case 'c': + unzip = 1; + continue; +#if defined(_SEAR_EXEC) || defined(_SEAR_SEEK) + case 'i': + install = 0; + continue; +#endif + case 'l': + local = 1; + continue; + case 'm': + meter = 1; + continue; + case 'n': + a2x = 0; + continue; + case 't': + list = 1; + continue; + case 'v': + verbose = 1; + continue; + case 'V': + sfprintf(sfstdout, "%s\n", id + 10); + return 0; + case '?': + error(ERROR_USAGE|4, "%s", opt_info.arg); + continue; + case ':': + error(2, "%s", opt_info.arg); + continue; + } + break; + } + if (error_info.errors) + error(ERROR_USAGE|4, "%s", optusage(NiL)); + argv += opt_info.index; +#else + while ((s = *++argv) && *s == '-' && *(s + 1)) + { + if (*(s + 1) == '-') + { + if (!*(s + 2)) + { + argv++; + break; + } + usage(); + break; + } + for (;;) + { + switch (c = *++s) + { + case 0: + break; + case 'c': + unzip = 1; + continue; +#if defined(_SEAR_EXEC) || defined(_SEAR_SEEK) + case 'i': + install = 0; + continue; +#endif + case 'l': + local = 1; + continue; + case 'm': + meter = 1; + continue; + case 'n': + a2x = 0; + continue; + case 't': + list = 1; + continue; + case 'v': + verbose = 1; + continue; + case 'V': + fprintf(stdout, "%s\n", id + 10); + return 0; + default: + fprintf(stderr, "%s: -%c: unknown option\n", state.id, c); + /*FALLTHROUGH*/ + case '?': + usage(); + break; + } + break; + } + } +#endif + +#if defined(_SEAR_SEEK) + if (sear_seek((off_t)_SEAR_SEEK, install && !list)) + { + Sleep(2 * 1000); + return 1; + } +#endif + + /* + * commit on the first gzip magic char + */ + + if ((c = getchar()) == EOF) + EXIT(0); + ungetc(c, stdin); + if (c != gz_magic[0]) + gz = 0; + else if (!(gz = gzfopen(stdin, FOPEN_READ))) + { + fprintf(stderr, "%s: gunzip open error\n", state.id); + EXIT(1); + } + if (unzip) + { + if (!gz) + { + fprintf(stderr, "%s: not a gzip file\n", state.id); + EXIT(1); + } + while ((c = gzread(gz, buf, sizeof(buf))) > 0) + if (fwrite(buf, c, 1, stdout) != 1) + { + fprintf(stderr, "%s: write error\n", state.id); + EXIT(1); + } + if (c < 0) + { + fprintf(stderr, "%s: read error\n", state.id); + EXIT(1); + } + if (fflush(stdout)) + { + fprintf(stderr, "%s: flush error\n", state.id); + EXIT(1); + } + EXIT(0); + } + if (meter) + { + if ((pos = lseek(0, (off_t)0, SEEK_CUR)) < 0) + meter = 0; + else + { + if (lseek(0, (off_t)(-4), SEEK_END) < 0 || read(0, num, 4) != 4) + meter = 0; + else if (!(total = ((num[0]|(num[1]<<8)|(num[2]<<16)|(num[3]<<24)) + sizeof(Header_t) - 1) / sizeof(Header_t))) + total = 1; + lseek(0, pos, SEEK_SET); + } + } + + /* + * loop on all the header blocks + */ + + while (block(stdin, gz, (char*)&header)) + { + /* + * last 2 blocks are NUL + */ + + if (!*header.name) + break; + + /* + * verify the checksum + */ + + s = header.chksum; + e = header.chksum + sizeof(header.chksum); + if (a2x) + { + for (; s < e; s++) + *s = a2x[*(unsigned char*)s]; + s = header.chksum; + } + n = number(s) & TAR_SUMASK; + while (s < e) + *s++ = 040; + m = 0; + s = (char*)&header; + e = (char*)&header + sizeof(header); + while (s < e) + m += *(unsigned char*)s++; + m &= TAR_SUMASK; + if (m != n) + { + if (state.files) + fprintf(stderr, "%s: archive corrupted\n", state.id); + else + fprintf(stderr, "%s: not a tar archive\n", state.id); + fprintf(stderr, "check sum %lu != %lu\n", m, n); + EXIT(1); + } + + /* + * convert to the native charset + */ + + if (a2x) + for (e = (s = (char*)&header) + sizeof(header); s < e; s++) + *s = a2x[*(unsigned char*)s]; + + /* + * get the pathname, type and size + */ + + state.files++; + t = path; + if (!strncmp(header.magic, TMAGIC, sizeof(header.magic)) && *header.prefix) + { + s = header.prefix; + e = header.prefix + sizeof(header.prefix); + while (s < e && (c = *s++)) + *t++ = c; + *t++ = '/'; + } + s = header.name; + e = header.name + sizeof(header.name); + while (s < e && (c = *s++)) + *t++ = c; + *t = 0; + + /* + * verify the dir prefix + */ + + t = 0; + s = path; + while (*s) + if (*s++ == '/') + t = s; + if (t) + { + *--t = 0; + if (!list && access(path, 0)) + { + s = path; + do + { + if (!(c = *s) || c == '/') + { + *s = 0; + if (access(path, 0) && mkdir(path, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)) + { + fprintf(stderr, "%s: %s: cannot create directory\n", state.id, path); + EXIT(1); + } + *s = c; + } + } while (*s++); + } + if (*(t + 1)) + *t = '/'; + else + header.typeflag = DIRTYPE; + } + + /* + * check for non-local paths + */ + + if (local && (path[0] == '/' || path[0] == '.' && path[1] == '.' && (!path[2] || path[2] == '/'))) + { + fprintf(stderr, "%s: %s: non-local path rejected", state.id, path); + if ((header.typeflag == REGTYPE || header.typeflag == AREGTYPE) && (n = number(header.size))) + while (n > 0) + { + if (!block(stdin, gz, buf)) + { + fprintf(stderr, "%s: unexpected EOF\n", state.id); + EXIT(1); + } + if (n <= sizeof(header)) + break; + n -= sizeof(header); + } + continue; + } + + /* + * create and grab the data + */ + + n = number(header.mode); + mode = 0; + if (n & TUREAD) + mode |= S_IRUSR; + if (n & TUWRITE) + mode |= S_IWUSR; + if (n & TUEXEC) + mode |= S_IXUSR; + if (n & TGREAD) + mode |= S_IRGRP; + if (n & TGWRITE) + mode |= S_IWGRP; + if (n & TGEXEC) + mode |= S_IXGRP; + if (n & TOREAD) + mode |= S_IROTH; + if (n & TOWRITE) + mode |= S_IWOTH; + if (n & TOEXEC) + mode |= S_IXOTH; + if (list || meter) + { + if (meter) + { + int i; + int j; + int k; + int n; + int p; + char bar[METER_parts + 1]; + + for (s = path; *s; s++) + if (s[0] == ' ' && s[1] == '-' && s[2] == '-' && s[3] == ' ') + break; + if (*s) + { + if (clear) + { + fprintf(stderr, "%*s", clear, "\r"); + clear = 0; + } + fprintf(stderr, "\n%s\n\n", path); + } + else + { + n = (int)strlen(s = path); + p = (state.blocks * 100) / total; + if (n > (METER_width - METER_parts - 1)) + { + s += n - (METER_width - METER_parts - 1); + n = METER_width - METER_parts - 1; + } + j = n + METER_parts + 2; + if (!clear) + clear = j + 5; + if ((k = clear - j - 5) < 0) + k = 0; + if ((i = (p / (100 / METER_parts))) >= sizeof(bar)) + i = sizeof(bar) - 1; + n = 0; + while (n < i) + bar[n++] = '*'; + while (n < sizeof(bar) - 1) + bar[n++] = ' '; + bar[n] = 0; + clear = fprintf(stderr, "%02d%% |%s| %s%*s", p, bar, s, k, "\r"); + } + } + else + { + if (verbose) + { + switch (header.typeflag) + { + case REGTYPE: + case AREGTYPE: + c = '-'; + break; + case DIRTYPE: + c = 'd'; + break; + case LNKTYPE: + c = 'h'; + break; + case SYMTYPE: + c = 'l'; + break; + default: + c = '?'; + break; + } + printf("%c", c); + m = 0400; + while (m) + { + printf("%c", (n & m) ? 'r' : '-'); + m >>= 1; + printf("%c", (n & m) ? 'w' : '-'); + m >>= 1; + printf("%c", (n & m) ? 'x' : '-'); + m >>= 1; + } + printf(" %10lu ", number(header.size)); + } + switch (header.typeflag) + { + case LNKTYPE: + printf("%s == %s\n", path, header.linkname); + break; + case SYMTYPE: + printf("%s => %s\n", path, header.linkname); + break; + default: + printf("%s\n", path); + break; + } + } + if (list) + { + if (skip(stdin, gz, buf, number(header.size))) + EXIT(1); + continue; + } + } + else if (verbose) + printf("%s\n", path); + switch (header.typeflag) + { + case REGTYPE: + case AREGTYPE: + while (!(fp = fopen(path, FOPEN_WRITE))) + if (unlink(path)) + { + fprintf(stderr, "%s: warning: %s: cannot create file\n", state.id, path); + break; + } + n = number(header.size); + c = a2x ? 0 : -1; + while (n > 0) + { + if (!block(stdin, gz, buf)) + { + fprintf(stderr, "%s: unexpected EOF\n", state.id); + EXIT(1); + } + switch (c) + { + case 0: + if ((m = n) < 4) + { + for (e = (s = buf) + m; s < e; s++) + if (a2x[*(unsigned char*)s] != '\n') + break; + } + else + { + if (m > 256) + m = 256; + for (e = (s = buf) + m; s < e; s++) + if (!ascii_text[*(unsigned char*)s]) + break; + } + if (s < e) + { + c = -1; + break; + } + c = 1; + /*FALLTHROUGH*/ + case 1: + for (e = (s = buf) + sizeof(header); s < e; s++) + *s = a2x[*(unsigned char*)s]; + break; + } + if (fp && fwrite(buf, n > sizeof(header) ? sizeof(header) : n, 1, fp) != 1) + { + fprintf(stderr, "%s: %s: write error\n", state.id, path); + EXIT(1); + } + if (n <= sizeof(header)) + break; + n -= sizeof(header); + } + if (fp && fclose(fp)) + { + fprintf(stderr, "%s: %s: write error\n", state.id, path); + EXIT(1); + } + break; + case DIRTYPE: + if (access(path, 0) && mkdir(path, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)) + { + fprintf(stderr, "%s: %s: cannot create directory\n", state.id, path); + EXIT(1); + } + break; + case SYMTYPE: +#if defined(S_IFLNK) || defined(S_ISLNK) + while (symlink(header.linkname, path)) + if (unlink(path)) + { + fprintf(stderr, "%s: %s: cannot symlink to %s\n", state.id, path, header.linkname); + EXIT(1); + } + continue; +#endif +#if !_WIN32 || _WINIX + case LNKTYPE: + while (link(header.linkname, path)) + if (unlink(path)) + { + fprintf(stderr, "%s: %s: cannot link to %s\n", state.id, path, header.linkname); + EXIT(1); + } + continue; +#endif + default: + fprintf(stderr, "%s: %s: file type %c ignored\n", state.id, path, header.typeflag); + if (skip(stdin, gz, buf, number(header.size))) + EXIT(1); + continue; + } + if (chmod(path, mode)) + fprintf(stderr, "%s: %s: cannot change mode to %03o\n", state.id, path, mode); + } + if (clear) + fprintf(stderr, "%*s", clear, "\r"); + if (!state.files) + fprintf(stderr, "%s: warning: empty archive\n", state.id); + else if (verbose) + fprintf(stderr, "%lu file%s, %lu block%s\n", state.files, state.files == 1 ? "" : "s", state.blocks, state.blocks == 1 ? "" : "s"); +#if defined(_SEAR_EXEC) +#if !defined(_SEAR_ARGS) +#define _SEAR_ARGS 0 +#endif + if (install && sear_exec(_SEAR_EXEC, argv, _SEAR_ARGS)) + { + Sleep(2 * 1000); + return 1; + } +#endif + return 0; +} + +#endif /* _RATZ_C */ diff --git a/src/cmd/INIT/regress.sh b/src/cmd/INIT/regress.sh new file mode 100644 index 0000000..a4417c4 --- /dev/null +++ b/src/cmd/INIT/regress.sh @@ -0,0 +1,1463 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2012 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: regress - run regression tests in command.tst + +command=regress +case $(getopts '[-][123:xyz]' opt --xyz 2>/dev/null; echo 0$opt) in +0123) USAGE=$' +[-? +@(#)$Id: regress (AT&T Research) 2012-02-02 $ +] +'$USAGE_LICENSE$' +[+NAME?regress - run regression tests] +[+DESCRIPTION?\bregress\b runs the tests in \aunit\a, or + \aunit\a\b.tst\b if \aunit\a does not exist. If \acommand\a is omitted + then it is assumed to be the base name of \aunit\a. All testing is done + in the temporary directory \aunit\a\b.tmp\b.] +[+?Default test output lists the \anumber\a and \adescription\a for + each active \bTEST\b group and the \anumber\a:\aline\a for each + individual \bEXEC\b test. Each test that fails results in a diagnostic + that contains the word \bFAILED\b; no other diagnostics contain this + word.] +[b:ignore-space?Ignore space differences when comparing expected + output.] +[i:pipe-input?Repeat each test with the standard input redirected through a + pipe.] +[k:keep?Enable \bcore\b dumps, exit after the first test that fails, + and do not remove the temporary directory \aunit\a\b.tmp\b.] +[l:local-fs?Force \aunit\a\b.tmp\b to be in a local filesystem.] +[o:pipe-output?Repeat each test with the standard output redirected through + a pipe.] +[p:pipe-io?Repeat each test with the standard input and standard output + redirected through pipes.] +[q:quiet?Output information on \bFAILED\b tests only.] +[r!:regular?Run each test with the standard input and standard output + redirected through regular files.] +[t:test?Run only tests matching \apattern\a. Tests are numbered and + consist of at least two digits (0 filled if necessary.) Tests matching + \b+(0)\b are always run.]:[pattern] +[x:trace?Enable debug tracing.] +[v:verbose?List differences between actual (<) and expected (>) output, + errors and exit codes. Also disable long output line truncation.] + +unit [ command [ arg ... ] ] + +[+INPUT FILES?The regression test file \aunit\a\b.tst\b is a \bksh\b(1) + script that is executed in an environment with the following functions + defined:] + { + [+BODY \b{ ... }?Defines the test body; used for complex tests.] + [+CD \b\adirectory\a?Create and change to working directory for + one test.] + [+CLEANUP \b\astatus\a?Called at exit time to remove the + temporary directory \aunit\a\b.tmp\b, list the tests totals via + \bTALLY\b, and exit with status \astatus\a.] + [+COMMAND \b\aarg\a ...?Runs the current command under test with + \aarg\a ... appended to the default args.] + [+CONTINUE?The background job must be running.] + [+COPY \b\afrom to\a?Copy file \afrom\a to \ato\a. \afrom\a may + be a regular file or \bINPUT\b, \bOUTPUT\b or \bERROR\b. Post + test comparisons are still done for \afrom\a.] + [+DIAGNOSTICS \b[ \b1\b | \b0\b | \apattern\a ]]?No argument or an + argument of \b1\b declares that diagnostics are to expected for + the remainder of the current \bTEST\b; \b0\b reverts to the default + state that diagnostics are not expected; otherwise the argument + is a \bksh\b(1) pattern that must match the non-empty contents + of the standard error.] + [+DO \b\astatement\a?Defines additional statements to be executed + for the current test. \astatement\a may be a { ... } group.] + [+EMPTY \bINPUT|OUTPUT|ERROR|SAME?The corresponding file is + expected to be empty.] + [+ERROR \b[ \b-e\b \afilter\a ]] [ \b-n\b ]] \afile\a | - \adata\a ...?The + standard error is expected to match either the contents + of \afile\a or the line \adata\a. \bERROR -n\b does not + append a newline to \adata\a. \afilter\a is a shell command + or pipeline that reads standard input and writes standard + output that is applied to ERROR before comparison with the + expected contents.] + [+EXEC \b[ \aarg\a ... ]]?Runs the command under test with + optional arguments. \bINPUT\b, \bOUTPUT\b, \bERROR\b, \bEXIT\b + and \bSAME\b calls following this \bEXEC\b up until the next + \bEXEC\b or the end of the script provide details for the + expected results. If no arguments are specified then the + arguments from the previious \bEXEC\b in the current \bTEST\b + group are used, or no arguments if this is the first \bEXEC\b + in the group.] + [+EXIT \b\astatus\a?The command exit status is expected to match + the pattern \astatus\a.] + [+EXITED?The background job must have exited.] + [+EXPORT \b[-]] \aname\a=\avalue\a ...?Export environment + variables for one test.] + [+FATAL \b\amessage\a ...?\amessage\a is printed on the standard + error and \bregress\b exits with status \b1\b.] + [+FIFO \bINPUT|OUTPUT|ERROR\b [ \b-n\b ]] \afile\a | - \adata\a ...?The + \bIO\B file is a fifo.] + [+IF \b\acommand\a [\anote\a]]?If the \bsh\b(1) \acommand\a exits + 0 then tests until the next \bELIF\b, \bELSE\b or \bFI\b are + enabled. Otherwise those tests are skipped. \bIF\b ... \bFI\b + may be nested, but must not cross \bTEST\b boundaries. \anote\a + is listed on the standard error if the correspoding test block + is enabled; \bIF\b, \bELIF\b, \bELSE\b may nave a \anote\a + operand.] + [+IGNORE \b\afile\a ...?\afile\a is ignored for subsequent result + comparisons. \afile\a may be \bOUTPUT\b or \bERROR\b.] + [+IGNORESPACE?Ignore space differences when comparing expected + output.] + [+INCLUDE \b\afile\a ...?One or more \afile\a operands are read + via the \bksh\b(1) \b.\b(1) command. \bVIEW\b is used to locate + the files.] + [+INFO \b\adescription\a?\adescription\a is printed on the + standard error.] + [+INITIALIZE?Called by \bregress\b to initialize a each + \bTEST\b group.] + [+INPUT \b[ \b-e\b \afilter\a ]] [ \b-n\b ]] \afile\a | - \adata\a ...?The + standard input is set to either the contents of \afile\a + or the line \adata\a. \bINPUT -n\b does not append a newline + to \adata\a. \afilter\a is a shell command or pipeline that + reads standard input and writes standard output that is + applied to OUTPUT before comparison with the expected contents.] + [+INTRO?Called by \bregress\b to introduce all \bTEST\b + groups.] + [+IO \b[ \bFIFO\b | \bPIPE\b ]] \bINPUT|OUTPUT|ERROR\b [ \b-e\b \afilter\a ]] [ \b-n\b ]] \afile\a | - \adata\a ...?Internal + support for the \bINPUT\b, \bOUTPUT\b and \bERROR\b functions.] + [+JOB \b\aop\a [ ... ]]?Like \bEXEC\b except the command is run + as a background job for the duration of the group or until it + is killed via \bKILL\b.] + [+KEEP \b\apattern\a ...?The temporary directory is cleared for + each test. Files matching \apattern\a are retained between + tests.] + [+KILL \b[ \asignal\a ]]?Kill the background job with \asignal\a + [ \bSIGKILL\b ]].] + [+MOVE \b\afrom to\a?Rename file \afrom\a to \ato\a. \afrom\a may + be a regular file or \bINPUT\b, \bOUTPUT\b or \bERROR\b. Post + test comparisons are ignored for \afrom\a.] + [+NOTE \b\acomment\a?\acomment\a is added to the current test + trace output.] + [+OUTPUT \b[ \b-e\b \afilter\a ]] [ \b-n\b ]] \afile\a | - \adata\a ...?The + standard output is expected to match either the contents + of \afile\a or the line \adata\a. \bOUTPUT -n\b does not + append a newline to \adata\a. \afilter\a is a shell command + or pipeline that reads standard input and writes standard + output that is applied to ERROR before comparison with the + expected contents.] + [+PIPE \bINPUT|OUTPUT|ERROR\b [ \b-n\b ]] \afile\a | - \adata\a ...?The + \bIO\B file is a pipe.] + [+PROG \b\acommand\a [ \aarg\a ... ]]?\acommand\a is run with + optional arguments.] + [+REMOVE \b\afile\a ...?\afile\a ... are removed after the + current test is done.] + [+RUN?Called by \bregress\b to run the current test.] + [+SAME \b\anew old\a?\anew\a is expected to be the same as + \aold\a after the current test completes.] + [+SET \b[\bno\b]]\aname\a[=\avalue\a]]?Set the command line + option --\aname\a. The setting is in effect for all tests until + the next explicit \bSET\b.] + [+TALLY?Called by \bregress\b display the \bTEST\b results.] + [+TEST \b\anumber\a [ \adescription\a ... ]]?Define a new test + group labelled \anumber\a with optional \adescripion\a.] + [+TITLE \b[+]] \atext\a?Set the \bTEST\b output title to + \atext\a. If \b+\b is specified then \atext\a is appended to + the default title. The default title is the test file base + name, and, if different from the test file base name, the test + unit base name.] + [+TWD \b[ \adir\a ... ]]?Set the temporary test dir to \adir\a. + The default is \aunit\a\b.tmp\b, where \aunit\a is the test + input file sans directory and suffix. If \adir\a matches \b/*\b + then it is the directory name; if \adir\a is non-null then the + prefix \b${TMPDIR:-/tmp}\b is added; otherwise if \adir\a is + omitted then + \b${TMPDIR:-/tmp}/tst-\b\aunit\a-$$-$RANDOM.\b\aunit\a is + used.] + [+UMASK \b[ \amask\a ]]?Run subsequent tests with \bumask\b(1) + \amask\a. If \amask\a is omitted then the original \bumask\b is + used.] + [+UNIT \b\acommand\a [ \aarg\a ... ]]?Define the command and + optional default arguments to be tested. \bUNIT\b explicitly + overrides the default command name derived from the test script + file name. A \acommand\a operand with optional arguments + overrides the \bUNIT\b \acommand\a and arguments, with the + exception that if the \bUNIT\b \acommand\a is \b-\b or \b+\b + the \bUNIT\b arguments are appended to the operand or default + unit command and arguments.] + [+VIEW \b\avar\a [ \afile\a ]]?\avar\a is set to the full + pathname of \avar\a [ \afile\a ]] in the current \b$VPATH\b + view if defined.] + } +[+SEE ALSO?\bnmake\b(1), \bksh\b(1)] +' + ;; +*) USAGE='ko:[[no]name[=value]]t:[test]v unit [path [arg ...]]' + ;; +esac + +function FATAL # message +{ + print -r -u2 "$command: $*" + GROUP=FINI + exit 1 +} + +function EMPTY +{ + typeset i + typeset -n ARRAY=$1 + for i in ${!ARRAY[@]} + do unset ARRAY[$i] + done +} + +function INITIALIZE # void +{ + typeset i j + cd "$TWD" + case $KEEP in + "") RM * + ;; + *) for i in * + do case $i in + !($KEEP)) j="$j $i" ;; + esac + done + case $j in + ?*) RM $j ;; + esac + ;; + esac + : >INPUT >OUTPUT.ex >ERROR.ex + BODY="" + COPY="" + DIAGNOSTICS="" + DONE="" + ERROR="" + EXIT=0 + IGNORE="" + INIT="" + INPUT="" + MOVE="" + OUTPUT="" + EMPTY FILE + EMPTY FILTER + EMPTY SAME + EMPTY TYPE +} + +function INTRO +{ + typeset base command + + if [[ ! $TEST_quiet ]] + then base=${REGRESS##*/} + base=${base%.tst} + command=${COMMAND##*/} + command=${command%' '*} + set -- $TITLE + TITLE= + case $1 in + ''|+) if [[ $command == $base ]] + then TITLE=$COMMAND + else TITLE="$COMMAND, $base" + fi + if (( $# )) + then shift + fi + ;; + esac + while (( $# )) + do if [[ $TITLE ]] + then TITLE="$TITLE, $1" + else TITLE="$1" + fi + shift + done + print -u2 "TEST $TITLE" + fi +} + +function TALLY # extra message text +{ + typeset msg + case $GROUP in + INIT) ;; + *) msg="TEST $TITLE, $TESTS test" + case $TESTS in + 1) ;; + *) msg=${msg}s ;; + esac + msg="$msg, $ERRORS error" + case $ERRORS in + 1) ;; + *) msg=${msg}s ;; + esac + if (( $# )) + then msg="$msg, $*" + fi + print -u2 "$msg" + GROUP=INIT + TESTS=0 + ERRORS=0 + ;; + esac +} + +function TITLE # text +{ + TITLE=$@ +} + +function UNWIND +{ + while (( COND > 1 )) + do print -r -u2 "$command: line $LINE: no matching FI for IF on line ${COND_LINE[COND]}" + (( COND-- )) + done + if (( COND > 0 )) + then (( COND = 0 )) + FATAL "line $LINE: no matching FI for IF on line ${COND_LINE[COND+1]}" + fi + if [[ $JOBPID ]] + then if [[ $JOBPID != 0 ]] + then kill -KILL $JOBPID 2>/dev/null + wait + fi + JOBPID= + fi + JOBSTATUS= + JOBOP= + wait +} + +function CLEANUP # status +{ + typeset note + + if [[ $GROUP != INIT ]] + then if [[ ! $TEST_keep ]] + then cd $SOURCE + if [[ $TEST_local ]] + then RM ${TEST_local} + fi + RM "$TWD" + fi + if (( $1 )) && [[ $GROUP != FINI ]] + then note=terminated + fi + fi + TALLY $note + [[ $TEST_keep ]] || UNWIND + exit $1 +} + +function RUN # [ op ] +{ + typeset i r=1 + [[ $UMASK != $UMASK_ORIG ]] && umask $UMASK_ORIG +#print -u2 AHA#$LINENO $0 GROUP=$GROUP ITEM=$ITEM FLUSHED=$FLUSHED JOBOP=$JOBOP + case $GROUP in + INIT) RM "$TWD" + if [[ $TEST_local ]] + then TEST_local=${TMPDIR:-/tmp}/rt-$$/${TWD##*/} + mkdir -p "$TEST_local" && ln -s "$TEST_local" "$TWD" || FATAL "$TWD": cannot create directory + TEST_local=${TEST_local%/*} + else mkdir "$TWD" || FATAL "$TWD": cannot create directory + fi + cd "$TWD" + TWD=$PWD + : > rmu + if rm -u rmu >/dev/null 2>&1 + then TEST_rmu=-u + else rm rmu + fi + if [[ $UNIT ]] + then set -- "${ARGV[@]}" + case $1 in + ""|[-+]*) + UNIT $UNIT "${ARGV[@]}" + ;; + *) UNIT "${ARGV[@]}" + ;; + esac + fi + INTRO + ;; + FINI) ;; + $TEST_select) + if [[ $ITEM == $FLUSHED ]] + then return 0 + fi + FLUSHED=$ITEM + if (( COND_SKIP[COND] )) + then return 1 + fi + ((COUNT++)) + if (( $ITEM <= $LASTITEM )) + then LABEL=$TEST#$COUNT + else LASTITEM=$ITEM + LABEL=$TEST:$ITEM + fi + TEST_file="" + exec >/dev/null + for i in $INPUT + do case " $OUTPUT " in + *" $i "*) + if [[ -f $i.sav ]] + then cp $i.sav $i + COMPARE="$COMPARE $i" + elif [[ -f $i ]] + then cp $i $i.sav + COMPARE="$COMPARE $i" + fi + ;; + esac + done + for i in $OUTPUT + do case " $COMPARE " in + *" $i "*) + ;; + *) COMPARE="$COMPARE $i" + ;; + esac + done + for i in $INIT + do $i $TEST INIT + done +#print -u2 AHA#$LINENO $0 GROUP=$GROUP ITEM=$ITEM JOBOP=$JOBOP JOBPID=$JOBPID JOBSTATUS=$JOBSTATUS + if [[ $JOBPID != 0 && ( $JOBPID || $JOBSTATUS ) ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + RESULTS + elif [[ $BODY ]] + then SHOW=$NOTE + if [[ ! $TEST_quiet ]] + then print -r -u2 " $SHOW" + fi + for i in $BODY + do $i $TEST BODY + done + else SHOW= + if [[ ${TYPE[INPUT]} == PIPE ]] + then if [[ ${TYPE[OUTPUT]} == PIPE ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + cat <$TWD/INPUT | COMMAND "${ARGS[@]}" | cat >$TWD/OUTPUT + RESULTS 'pipe input' + else if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + cat <$TWD/INPUT | COMMAND "${ARGS[@]}" >$TWD/OUTPUT + RESULTS 'pipe io' + fi + elif [[ ${TYPE[OUTPUT]} == PIPE ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + COMMAND "${ARGS[@]}" <$TWD/INPUT | cat >$TWD/OUTPUT + RESULTS 'pipe output' + else if [[ $TEST_regular ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + if [[ ${TYPE[INPUT]} == FIFO ]] + then COMMAND "${ARGS[@]}" >$TWD/OUTPUT + else COMMAND "${ARGS[@]}" <$TWD/INPUT >$TWD/OUTPUT + fi + RESULTS + fi + if [[ $TEST_pipe_input ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + (trap '' PIPE; cat <$TWD/INPUT 2>/dev/null; exit 0) | COMMAND "${ARGS[@]}" >$TWD/OUTPUT + STATUS=$? + RESULTS 'pipe input' + fi + if [[ $TEST_pipe_output ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + COMMAND "${ARGS[@]}" <$TWD/INPUT | cat >$TWD/OUTPUT + STATUS=$? + RESULTS 'pipe output' + fi + if [[ $TEST_pipe_io ]] + then if [[ ! $TEST_quiet ]] + then print -nu2 "$LABEL" + fi + (trap '' PIPE; cat <$TWD/INPUT 2>/dev/null; exit 0) | COMMAND "${ARGS[@]}" | cat >$TWD/OUTPUT + STATUS=$? + RESULTS 'pipe io' + fi + fi + set -- $COPY + COPY="" + while : + do case $# in + 0|1) break ;; + *) cp $1 $2 ;; + esac + shift 2 + done + set -- $MOVE + MOVE="" + while (( $# > 1 )) + do mv $1 $2 + shift 2 + done + fi + for i in $DONE + do $i $TEST DONE $STATUS + done + COMPARE="" + r=0 + ;; + esac + if [[ $COMMAND_ORIG ]] + then COMMAND=$COMMAND_ORIG + COMMAND_ORIG= + ARGS=(${ARGS_ORIG[@]}) + fi + return $r +} + +function DO # cmd ... +{ + [[ $GROUP == $TEST_select ]] || return 1 + (( COND_SKIP[COND] )) && return 1 + [[ $UMASK != $UMASK_ORIG ]] && umask $UMASK + return 0 +} + +function UNIT # cmd arg ... +{ + typeset cmd=$1 + case $cmd in + [-+]) shift + if (( UNIT_READONLY )) + then COMMAND="$COMMAND $*" + else #BUG# ARGV=("${ARGV[@]}" "$@") + set -- "${ARGV[@]}" "$@" + ARGV=("$@") + fi + return + ;; + esac + (( UNIT_READONLY )) && return + if [[ $UNIT ]] && (( $# <= 1 )) + then set -- "${ARGV[@]}" + case $1 in + "") set -- "$cmd" ;; + [-+]*) set -- "$cmd" "${ARGV[@]}" ;; + *) cmd=$1 ;; + esac + fi + UNIT= + COMMAND=$cmd + shift + typeset cmd=$(whence $COMMAND) + if [[ ! $cmd ]] + then FATAL $COMMAND: not found + elif [[ ! $cmd ]] + then FATAL $cmd: not found + fi + case $# in + 0) ;; + *) COMMAND="$COMMAND $*" ;; + esac +} + +function TWD # [ dir ] +{ + case $1 in + '') TWD=${TWD##*/}; TWD=${TMPDIR:-/tmp}/tst-${TWD%.*}-$$-$RANDOM ;; + /*) TWD=$1 ;; + *) TWD=${TMPDIR:-/tmp}/$1 ;; + esac +} + +function TEST # number description arg ... +{ + RUN + LINE=$TESTLINE + UNWIND + COUNT=0 + LASTITEM=0 + case $1 in + -) ((LAST++)); TEST=$LAST ;; + +([0123456789])) LAST=$1 TEST=$1 ;; + *) LAST=0${1/[!0123456789]/} TEST=$1 ;; + esac + NOTE= + if [[ ! $TEST_quiet && $TEST == $TEST_select ]] && (( ! COND_SKIP[COND] )) + then print -r -u2 "$TEST $2" + fi + unset ARGS + unset EXPORT + EXPORTS=0 + TEST_file="" + if [[ $TEST != ${GROUP}* ]] + then GROUP=${TEST%%+([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ])} + if [[ $GROUP == $TEST_select ]] && (( ! COND_SKIP[COND] )) + then INITIALIZE + fi + fi + ((SUBTESTS=0)) + [[ $TEST == $TEST_select ]] && (( ! COND_SKIP[COND] )) +} + +function EXEC # arg ... +{ + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + if ((SUBTESTS++)) + then RUN + fi + case $# in + 0) set -- "${ARGS[@]}" ;; + esac + ITEM=$LINE + NOTE="$(print -r -f '%q ' -- $COMMAND_ORIG "$@")${JOBPID:+&}" + ARGS=("$@") +} + +function JOB # arg ... +{ + JOBPID=0 + EXEC "$@" +} + +function CONTINUE +{ + RUN || return + JOBOP=CONTINUE + ITEM=$LINE + NOTE="$(print -r -f '%q ' -- $JOBOP)" +#print -u2 AHA#$LINENO JOBOP=$JOBOP ITEM=$ITEM NOTE=$NOTE +} + +function EXITED +{ + RUN || return + JOBOP=EXITED + ITEM=$LINE + NOTE="$(print -r -f '%q ' -- $JOBOP)" +#print -u2 AHA#$LINENO JOBOP=$JOBOP ITEM=$ITEM NOTE=$NOTE +} + +function KILL # [ signal ] +{ + RUN || return + JOBOP=$2 + [[ $JOBOP ]] || JOBOP=KILL + ITEM=$LINE + NOTE="$(print -r -f '%q ' -- $JOBOP)" +} + +function CD +{ + RUN + if [[ $GROUP == $TEST_select ]] && (( ! COND_SKIP[COND] )) + then mkdir -p "$@" && cd "$@" || FATAL cannot initialize working directory "$@" + fi +} + +function EXPORT +{ + typeset x n v + if [[ $GROUP == INIT ]] + then for x + do n=${x%%=*} + v=${x#*=} + ENVIRON[ENVIRONS++]=$n="'$v'" + done + else RUN + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + for x + do n=${x%%=*} + v=${x#*=} + EXPORT[EXPORTS++]=$n="'$v'" + done + fi +} + +function FLUSH +{ + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + if ((SUBTESTS++)) + then RUN + fi +} + +function PROG # cmd arg ... +{ + typeset command args + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + ITEM=$LINE + NOTE="$(print -r -f '%q ' -- "$@")" + COMMAND_ORIG=$COMMAND + COMMAND=$1 + shift + ARGS_ORIG=(${ARGS[@]}) + ARGS=("$@") +} + +function NOTE # description +{ + NOTE=$* +} + +function IO # [ PIPE ] INPUT|OUTPUT|ERROR [-f*|-n] file|- data ... +{ + typeset op i v f file type x + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + [[ $UMASK != $UMASK_ORIG ]] && umask $UMASK_ORIG + while : + do case $1 in + FIFO|PIPE) type=$1; shift ;; + *) break ;; + esac + done + op=$1 + shift + [[ $type ]] && TYPE[$op]=$type + FILTER[$op]= + file=$TWD/$op + while : + do case $1 in + -x) x=1 + shift + ;; + -e) (( $# > 1 )) && shift + FILTER[$op]=$1 + shift + ;; + -e*) FILTER[$op]=${1#-e} + shift + ;; + -f*|-n) f=$1 + shift + ;; + *) break + ;; + esac + done + case $# in + 0) ;; + *) case $1 in + -) ;; + *) file=$1 + eval i='$'$op + case " $i " in + *" $file "*) + ;; + *) eval $op='"$'$op' $file"' + ;; + esac + ;; + esac + shift + ;; + esac + case " $IGNORE " in + *" $file "*) + for i in $IGNORE + do case $i in + $file) ;; + *) v="$v $i" ;; + esac + done + IGNORE=$v + ;; + esac + FILE[$op]=$file + case $op in + OUTPUT|ERROR) + file=$file.ex + if [[ $file != /* ]] + then file=$TWD/$file + fi + ;; + esac + #unset SAME[$op] + SAME[$op]= + if [[ $file == /* ]] + then RM $file.sav + else RM $TWD/$file.sav + fi + if [[ $file == */* ]] + then mkdir -p ${file%/*} + fi + if [[ $file != */ ]] + then if [[ $type == FIFO ]] + then rm -f $file + mkfifo $file + fi + if [[ ${TYPE[$op]} != FIFO ]] + then if [[ $JOBOP ]] + then case $#:$f in + 0:) ;; + *:-f) printf -- "$@" ;; + *:-f*) printf -- "${f#-f}""$@" ;; + *) print $f -r -- "$@" ;; + esac >> $file + else case $#:$f in + 0:) ;; + *:-f) printf -- "$@" ;; + *:-f*) printf -- "${f#-f}""$@" ;; + *) print $f -r -- "$@" ;; + esac > $file + fi + elif [[ $#:$f != 0: ]] + then case $#:$f in + *:-f) printf -- "$@" ;; + *:-f*) printf -- "${f#-f}""$@" ;; + *) print $f -r -- "$@" ;; + esac >> $file & + fi + if [[ $x ]] + then chmod +x $file + fi + fi +} + +function INPUT # file|- data ... +{ + IO $0 "$@" +} + +function COPY # from to +{ + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + COPY="$COPY $@" +} + +function MOVE # from to +{ + typeset f + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + for f + do case $f in + INPUT|OUTPUT|ERROR) + f=$TWD/$f + ;; + /*) ;; + *) f=$PWD/$f + ;; + esac + MOVE="$MOVE $f" + done +} + +function SAME # new old +{ + typeset i file v + if [[ $GROUP != $TEST_select ]] || (( COND_SKIP[COND] )) + then return + fi + case $# in + 2) case $1 in + INPUT) cat $2 > $1; return ;; + esac + SAME[$1]=$2 + file=$1 + COMPARE="$COMPARE $1" + ;; + 3) SAME[$2]=$3 + file=$2 + eval i='$'$1 + case " $i " in + *" $2 "*) + ;; + *) eval $1='"$'$1' $2"' + ;; + esac + COMPARE="$COMPARE $2" + ;; + esac + case " $IGNORE " in + *" $file "*) + for i in $IGNORE + do case $i in + $file) ;; + *) v="$v $i" ;; + esac + done + IGNORE=$v + ;; + esac +} + +function OUTPUT # file|- data ... +{ + IO $0 "$@" +} + +function ERROR # file|- data ... +{ + IO $0 "$@" +} + +function RM # rm(1) args +{ + if [[ ! $TEST_rmu ]] + then chmod -R u+rwx "$@" >/dev/null 2>&1 + fi + rm $TEST_rmu $TEST_rmflags "$@" +} + +function REMOVE # file ... +{ + typeset i + for i + do RM $i $i.sav + done +} + +function IGNORE # file ... +{ + typeset i + for i + do case $i in + INPUT|OUTPUT|ERROR) + i=$TWD/$i + ;; + esac + case " $IGNORE " in + *" $i "*) + ;; + *) IGNORE="$IGNORE $i" + ;; + esac + done +} + +function KEEP # pattern ... +{ + typeset i + for i + do case $KEEP in + "") KEEP="$i" ;; + *) KEEP="$KEEP|$i" ;; + esac + done +} + +function DIAGNOSTICS # [ 1 | 0 ] +{ + case $#:$1 in + 0:|1:1) DIAGNOSTICS=1 + EXIT='*' + ;; + 1:|1:0) DIAGNOSTICS="" + EXIT=0 + ;; + *) DIAGNOSTICS=$1 + EXIT='*' + ;; + esac +} + +function IGNORESPACE +{ + : ${IGNORESPACE=-b} +} + +function EXIT # status +{ + EXIT=$1 +} + +function INFO # info description +{ + typeset -R15 info=$1 + if [[ ! $1 ]] + then info=no + fi + shift + if [[ ! $TEST_quiet ]] + then print -r -u2 "$info " "$@" + fi +} + +function COMMAND # arg ... +{ + typeset input + ((TESTS++)) + case " ${ENVIRON[*]} ${EXPORT[*]}" in + *' 'LC_ALL=*) + ;; + *' 'LC_+([A-Z])=*) + EXPORT[EXPORTS++]="LC_ALL=" + ;; + esac + if [[ $TEST_keep ]] + then ( + PS4='' + set -x + print -r -- "${ENVIRON[@]}" "${EXPORT[@]}" "PATH=$PATH" $COMMAND "$@" + ) 2>&1 >/dev/null | + sed -e 's,^print -r -- ,,' -e 's,$, "$@",' >$TWD/COMMAND + chmod +x $TWD/COMMAND + fi + if [[ $UMASK != $UMASK_ORIG ]] + then : >$TWD/ERROR + umask $UMASK + fi + if [[ ${TYPE[INPUT]} == FIFO && ${FILE[INPUT]} == */INPUT ]] + then input="< ${FILE[INPUT]}" + fi + if [[ $TEST_trace ]] + then set +x + eval print -u2 "$PS4" "${ENVIRON[@]}" "${EXPORT[@]}" PATH='$PATH' '$'COMMAND '"$@"' '$input' '"2>$TWD/ERROR"' '"${JOBPID:+&}"' + fi + eval "${ENVIRON[@]}" "${EXPORT[@]}" PATH='$PATH' '$'COMMAND '"$@"' $input "2>$TWD/ERROR" "${JOBPID:+&}" + STATUS=$? + [[ $TEST_trace ]] && set -x + if [[ $JOBPID ]] + then JOBPID=$! + fi + [[ $UMASK != $UMASK_ORIG ]] && umask $UMASK_ORIG + return $STATUS +} + +function RESULTS # pipe* +{ + typeset i j k s failed ignore io op + if [[ $1 ]] + then io="$1 " + fi + [[ $JOBOP || $JOBPID || $JOBSTATUS ]] && sleep 1 + for i in $COMPARE $TWD/OUTPUT $TWD/ERROR + do case " $IGNORE $ignore $MOVE " in + *" $i "*) continue ;; + esac + ignore="$ignore $i" + op=${i##*/} + if [[ ${FILTER[$op]} ]] + then eval "{ ${FILTER[$op]} ;} < $i > $i.fi" + mv $i.fi $i + fi + j=${SAME[$op]} + if [[ ! $j ]] + then if [[ $i == /* ]] + then k=$i + else k=$TWD/$i + fi + for s in ex sav err + do [[ -f $k.$s ]] && break + done + j=$k.$s + fi + if [[ "$DIAGNOSTICS" && $i == */ERROR ]] + then if [[ $STATUS == 0 && ! -s $TWD/ERROR || $DIAGNOSTICS != 1 && $(<$i) != $DIAGNOSTICS ]] + then failed=$failed${failed:+,}DIAGNOSTICS + if [[ $TEST_verbose && $DIAGNOSTICS != 1 ]] + then print -u2 " ===" "diagnostic pattern '$DIAGNOSTICS' did not match" ${i#$TWD/} "===" + cat $i >&2 + fi + fi + continue + fi + diff $IGNORESPACE $i $j >$i.diff 2>&1 + if [[ -s $i.diff ]] + then failed=$failed${failed:+,}${i#$TWD/} + if [[ $TEST_verbose ]] + then print -u2 " ===" diff $IGNORESPACE ${i#$TWD/} "<actual >expected ===" + cat $i.diff >&2 + fi + fi + done + if [[ $JOBOP ]] + then if [[ $JOBPID ]] && ! kill -0 $JOBPID 2>/dev/null + then wait $JOBPID + JOBSTATUS=$? + JOBPID= + fi +#print -u2 AHA#$LINENO JOBOP=$JOBOP JOBPID=$JOBPID JOBSTATUS=$JOBSTATUS + case $JOBOP in + CONTINUE) + if [[ ! $JOBPID ]] + then failed=$failed${failed:+,}EXITED + fi + ;; + EXITED) if [[ $JOBPID ]] + then failed=$failed${failed:+,}RUNNING + fi + ;; + *) if [[ ! $JOBPID ]] + then failed=$failed${failed:+,}EXITED + fi + if ! kill -$JOBOP $JOBPID 2>/dev/null + then failed=$failed${failed:+,}KILL-$JOBOP + fi + ;; + esac + JOBOP= + fi + if [[ ! $failed && $STATUS != $EXIT ]] + then failed="exit code $EXIT expected -- got $STATUS" + fi + if [[ $failed ]] + then ((ERRORS++)) + if [[ ! $TEST_quiet ]] + then SHOW="FAILED ${io}[ $failed ] $NOTE" + print -r -u2 " $SHOW" + fi + if [[ $TEST_keep ]] + then GROUP=FINI + exit + fi + elif [[ ! $TEST_quiet ]] + then SHOW=$NOTE + print -r -u2 " $SHOW" + fi +} + +function SET # [no]name[=value] +{ + typeset i r + if [[ $TEST ]] + then RUN + fi + for i + do if [[ $i == - ]] + then r=1 + elif [[ $i == + ]] + then r= + else if [[ $i == no?* ]] + then i=${i#no} + v= + elif [[ $i == *=* ]] + then v=${i#*=} + if [[ $v == 0 ]] + then v= + fi + i=${i%%=*} + else v=1 + fi + i=${i//-/_} + if [[ $r ]] + then READONLY[$i]=1 + elif [[ ${READONLY[$i]} ]] + then continue + fi + eval TEST_$i=$v + fi + done +} + +function VIEW # var [ file ] +{ + nameref var=$1 + typeset i bwd file pwd view root offset + if [[ $var ]] + then return 0 + fi + case $# in + 1) file=$1 ;; + *) file=$2 ;; + esac + pwd=${TWD%/*} + bwd=${PMP%/*} + if [[ -r $file ]] + then if [[ ! -d $file ]] + then var=$PWD/$file + return 0 + fi + for i in $file/* + do if [[ -r $i ]] + then var=$PWD/$file + return 0 + fi + break + done + fi + for view in ${VIEWS[@]} + do case $view in + /*) ;; + *) view=$pwd/$view ;; + esac + case $offset in + '') case $pwd in + $view/*) offset=${pwd#$view} ;; + *) offset=${bwd#$view} ;; + esac + ;; + esac + if [[ -r $view$offset/$file ]] + then if [[ ! -d $view$offset/$file ]] + then var=$view$offset/$file + return 0 + fi + for i in $view$offset/$file/* + do if [[ -f $i ]] + then var=$view$offset/$file + return 0 + fi + break + done + fi + done + var= + return 1 +} + +function INCLUDE # file ... +{ + typeset f v x + for f + do if VIEW v $f || [[ $PREFIX && $f != /* ]] && VIEW v $PREFIX$f + then x=$x$'\n'". $v" + else FATAL $f: not found + fi + done + [[ $x ]] && trap "$x" 0 +} + +function UMASK # [ mask ] +{ + if (( $# )) + then UMASK=$1 + else UMASK=$UMASK_ORIG + fi +} + +function PIPE # INPUT|OUTPUT|ERROR file|- data ... +{ + IO $0 "$@" +} + +function FIFO # INPUT|OUTPUT|ERROR file|- data ... +{ + IO $0 "$@" +} + +function IF # command(s) [note] +{ + [[ $GROUP == $TEST_select ]] || return + RUN + (( COND++ )) + COND_LINE[COND]=$LINE + if (( COND > 1 && COND_SKIP[COND-1] )) + then (( COND_KEPT[COND] = 1 )) + (( COND_SKIP[COND] = 1 )) + elif eval "{ $1 ;} >/dev/null 2>&1" + then (( COND_KEPT[COND] = 1 )) + (( COND_SKIP[COND] = 0 )) + [[ $2 && ! $TEST_quiet ]] && print -u2 "NOTE $2" + else (( COND_KEPT[COND] = 0 )) + (( COND_SKIP[COND] = 1 )) + fi +} + +function ELIF # command(s) [note] +{ + [[ $GROUP == $TEST_select ]] || return + RUN + if (( COND <= 0 )) + then FATAL line $LINE: no matching IF for ELIF + fi + if (( COND_KEPT[COND] )) + then (( COND_SKIP[COND] = 0 )) + elif eval "$* > /dev/null 2>&1" + then (( COND_KEPT[COND] = 1 )) + (( COND_SKIP[COND] = 0 )) + [[ $2 && ! $TEST_quiet ]] && print -u2 "NOTE $2" + else (( COND_SKIP[COND] = 1 )) + fi +} + +function ELSE # [note] +{ + [[ $GROUP == $TEST_select ]] || return + RUN + if (( COND <= 0 )) + then FATAL line $LINE: no matching IF for ELSE + fi + if (( COND_KEPT[COND] )) + then (( COND_SKIP[COND] = 1 )) + else (( COND_KEPT[COND] = 1 )) + (( COND_SKIP[COND] = 0 )) + [[ $1 && ! $TEST_quiet ]] && print -u2 "NOTE $1" + fi +} + +function FI +{ + [[ $GROUP == $TEST_select ]] || return + RUN + if (( COND <= 0 )) + then FATAL line $LINE: no matching IF for FI on line $LINE + fi + (( ! COND_KEPT[COND] )) && [[ $1 && ! $TEST_quiet ]] && print -u2 "NOTE $1" + (( COND-- )) +} + +# main + +integer ERRORS=0 ENVIRONS=0 EXPORTS=0 TESTS=0 SUBTESTS=0 LINE=0 TESTLINE=0 +integer ITEM=0 LASTITEM=0 COND=0 UNIT_READONLY=0 COUNT +typeset ARGS COMMAND COPY DIAGNOSTICS ERROR EXEC FLUSHED=0 GROUP=INIT +typeset IGNORE INPUT KEEP OUTPUT TEST SOURCE MOVE NOTE UMASK UMASK_ORIG +typeset ARGS_ORIG COMMAND_ORIG TITLE UNIT ARGV PREFIX OFFSET IGNORESPACE +typeset COMPARE MAIN JOBPID='' JOBSTATUS='' +typeset TEST_file TEST_keep TEST_pipe_input TEST_pipe_io TEST_pipe_output TEST_local +typeset TEST_quiet TEST_regular=1 TEST_rmflags='-rf --' TEST_rmu TEST_select + +typeset -A SAME VIEWS FILE TYPE READONLY FILTER +typeset -a COND_LINE COND_SKIP COND_KEPT ENVIRON EXPORT +typeset -Z LAST=00 + +unset FIGNORE + +while getopts -a $command "$USAGE" OPT +do case $OPT in + b) (( $OPTARG )) && IGNORESPACE=-b + ;; + i) SET - pipe-input=$OPTARG + ;; + k) SET - keep=$OPTARG + ;; + l) SET - local + ;; + o) SET - pipe-output=$OPTARG + ;; + p) SET - pipe-io=$OPTARG + ;; + q) SET - quiet=$OPTARG + ;; + r) SET - regular=$OPTARG + ;; + t) if [[ $TEST_select ]] + then TEST_select="$TEST_select|${OPTARG//,/\|}" + else TEST_select="${OPTARG//,/\|}" + fi + ;; + x) SET - trace=$OPTARG + ;; + v) SET - verbose=$OPTARG + ;; + *) GROUP=FINI + exit 2 + ;; + esac +done +shift $OPTIND-1 +case $# in +0) FATAL test unit name omitted ;; +esac +export COLUMNS=80 +SOURCE=$PWD +PATH=$SOURCE:${PATH#?(.):} +PATH=${PATH%%:?(.)}:/usr/5bin:/bin:/usr/bin +UNIT=$1 +shift +if [[ -f $UNIT && ! -x $UNIT ]] +then REGRESS=$UNIT +else REGRESS=${UNIT%.tst} + REGRESS=$REGRESS.tst + [[ -f $REGRESS ]] || FATAL $REGRESS: regression tests not found +fi +UNIT=${UNIT##*/} +UNIT=${UNIT%.tst} +MAIN=$UNIT +if [[ $VPATH ]] +then set -A VIEWS ${VPATH//:/' '} + OFFSET=${SOURCE#${VIEWS[0]}} + if [[ $OFFSET ]] + then OFFSET=${OFFSET#/}/ + fi +fi +if [[ $REGRESS == */* ]] +then PREFIX=${REGRESS%/*} + if [[ ${#VIEWS[@]} ]] + then for i in ${VIEWS[@]} + do PREFIX=${PREFIX#$i/} + done + fi + PREFIX=${PREFIX#$OFFSET} + if [[ $PREFIX ]] + then PREFIX=$PREFIX/ + fi +fi +TWD=$PWD/$UNIT.tmp +PMP=$(pwd -P)/$UNIT.tmp +UMASK_ORIG=$(umask) +UMASK=$UMASK_ORIG +ARGV=("$@") +if [[ ${ARGV[0]} && ${ARGV[0]} != [-+]* ]] +then UNIT "${ARGV[@]}" + UNIT_READONLY=1 +fi +trap 'code=$?; CLEANUP $code' EXIT +if [[ ! $TEST_select ]] +then TEST_select="[0123456789]*" +fi +TEST_select="@($TEST_select|+(0))" +if [[ $TEST_trace ]] +then export PS4=':$LINENO: ' + typeset -ft $(typeset +f) + set -x +fi +if [[ $TEST_verbose ]] +then typeset SHOW +else typeset -L70 SHOW +fi +if [[ ! $TEST_keep ]] && (ulimit -c 0) >/dev/null 2>&1 +then ulimit -c 0 +fi +set --pipefail + +# some last minute shenanigans + +alias BODY='BODY=BODY; function BODY' +alias CONTINUE='LINE=$LINENO; CONTINUE' +alias DO='(( $ITEM != $FLUSHED )) && RUN DO; DO &&' +alias DONE='DONE=DONE; function DONE' +alias EXEC='LINE=$LINENO; EXEC' +alias EXITED='LINE=$LINENO; EXITED' +alias INIT='INIT=INIT; function INIT' +alias JOB='LINE=$LINENO; JOB' +alias KILL='LINE=$LINENO; KILL' +alias PROG='LINE=$LINENO; FLUSH; PROG' +alias TEST='TESTLINE=$LINENO; TEST' +alias IF='LINE=$LINENO; FLUSH; IF' +alias ELIF='LINE=$LINENO; FLUSH; ELIF' +alias ELSE='LINE=$LINENO; FLUSH; ELSE' +alias FI='LINE=$LINENO; FLUSH; FI' + +# do the tests + +. $REGRESS +RUN +GROUP=FINI diff --git a/src/cmd/INIT/release.c b/src/cmd/INIT/release.c new file mode 100644 index 0000000..7b4b1b0 --- /dev/null +++ b/src/cmd/INIT/release.c @@ -0,0 +1,366 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#pragma prototyped + +/* + * release -- list recent release changes + * + * coded for portability + */ + +static char id[] = "\n@(#)$Id: release (AT&T Research) 2000-01-28 $\0\n"; + +#if _PACKAGE_ast + +#include <ast.h> +#include <error.h> + +static const char usage[] = +"[-?\n@(#)$Id: release (AT&T Research) 2000-01-28 $\n]" +USAGE_LICENSE +"[+NAME?release - list recent changes]" +"[+DESCRIPTION?\brelease\b lists the changes within the date range specified" +" by the \b--from\b and \b--to\b options. The input files are assumed to" +" contain date tag lines of the form [\acc\a]]\ayy-mm-dd\a [ \atext\a ]]" +" (or \bdate\b(1) default format), where \acc\a is determined by a Y2K" +" window year of 69 (we can produce an example coding dated 1991 - this" +" can be patented?, how about 1+1=2?.) The date tag lines are followed by" +" \areadme\a text in reverse chronological order (newer entries at the" +" top of the file.) If no selection options are spcified then all" +" changes are listed. If no \afile\a operands are specified then the" +" standard input is read.]" +"[+?The entries for each \afile\a are annotated with the file directory name.]" +"[f:from?Entries older than \adate\a are omitted.]:[date]" +"[r:release?List all changes that include the first \acount\a release marks." +" A release mark has a date tag followed by optional space and at least" +" three \b-\b characters. Changes from release mark \acount\a+1 are not" +" listed. If there are no release marks then the date range is used;" +" if there is at least one release mark then the date range is ignored" +" and at most \acount\a release marks will be listed.]#[count]" +"[t:to?Entries newer than \adate\a are omitted.]:[date]" +"[V?Print the program version and exit.]" + +"\n" +"\n[ file ... ]\n" +"\n" + +"[+SEE ALSO?\bpackage\b(1)]" +; + +#else + +#define elementsof(x) ((int)(sizeof(x)/sizeof(x[0]))) + +#define NiL ((char*)0) + +#endif + +#include <stdio.h> +#include <unistd.h> +#include <ctype.h> +#include <sys/types.h> + +#if !_PACKAGE_ast && defined(__STDC__) +#include <stdlib.h> +#include <string.h> +#endif + +static char mon[] = "janfebmaraprmayjunjulaugsepoctnovdec"; +static char day[] = "sunmontuewedthufrisat"; + +#if !_PACKAGE_ast + +static void +usage() +{ + fprintf(stderr, "Usage: release [-V] [-h hi-date] [-l lo-date] [-r count] [ file ...]\n"); + exit(2); +} + +#endif + +static unsigned long +number(register char* s, char** e) +{ + unsigned long q = 0; + + while (isspace(*s)) + s++; + while (isdigit(*s)) + q = q * 10 + *s++ - '0'; + if (e) + *e = s; + return q; +} + +unsigned long +string(register char* s, char* tab, int num, int siz, char** e) +{ + register int i; + register int j; + char buf[16]; + + while (isspace(*s)) + s++; + for (i = 0; i < siz; i++) + buf[i] = isupper(s[i]) ? tolower(s[i]) : s[i]; + for (i = 0; i < num; i += siz) + for (j = 0; j < siz && buf[j] == tab[j+i]; j++) + if (j == (siz - 1)) + { + *e = s + siz; + return i / siz + 1; + } + return 0; +} + +static unsigned long +date(char* s, char** e) +{ + char* t; + unsigned long y; + unsigned long m; + unsigned long d; + + if (isdigit(*s)) + { + y = number(s, &t); + if (*t != '-') + return 0; + switch (t - s) + { + case 2: + y += 1900; + if (y <= 1969) + y += 100; + break; + case 4: + if (y < 1969) + return 0; + break; + } + if (!(m = number(++t, &s))) + return 0; + if ((s - t) != 2 || *s != '-' || m < 1 || m > 12) + return 0; + if (!(d = number(++s, &t))) + return 0; + if ((t - s) != 2 || d < 1 || d > 31) + return 0; + } + else + { + if (string(s, day, elementsof(day), 3, &t)) + s = t; + if (!(m = string(s, mon, elementsof(mon), 3, &t))) + return 0; + if (!(d = number(t, &s))) + return 0; + for (y = 1969; *s; s++) + if ((y = number(s, &t)) && (t - s) == 4) + { + if (y < 1969) + return 0; + break; + } + } + if (e) + { + while (isspace(*t)) + t++; + *e = t; + } + return ((y - 1969) * 13 + m) * 32 + d; +} + +int +main(int argc, char** argv) +{ + register char* s; + register char* u; + register char* v; + char* p; + char* e; + int i; + unsigned long t; + unsigned long lo; + unsigned long hi; + int mk; + FILE* f; + char buf[1024]; + + mk = 0; + lo = hi = 0; +#if _PACKAGE_ast + error_info.id = "release"; + for (;;) + { + switch (optget(argv, usage)) + { + case 'f': + if (!(lo = date(opt_info.arg, &e)) || *e) + { + error(2, "%s: invalid from date [%s]", opt_info.arg, e); + return 1; + } + continue; + case 'r': + mk = opt_info.num + 1; + continue; + case 't': + if (!(hi = date(opt_info.arg, &e)) || *e) + { + error(2, "%s: invalid to date [%s]", opt_info.arg, e); + return 1; + } + continue; + case 'V': + sfprintf(sfstdout, "%s\n", id + 10); + return 0; + case '?': + error(ERROR_USAGE|4, "%s", opt_info.arg); + continue; + case ':': + error(2, "%s", opt_info.arg); + continue; + } + break; + } + if (error_info.errors) + error(ERROR_USAGE|4, "%s", optusage(NiL)); + argv += opt_info.index; +#else + while ((s = *++argv) && *s == '-' && *(s + 1)) + { + if (*(s + 1) == '-') + { + if (!*(s + 2)) + { + argv++; + break; + } + usage(); + break; + } + for (;;) + { + switch (i = *++s) + { + case 0: + break; + case 'f': + case 't': + if (!*(v = ++s) && !(v = *++argv)) + { + s = "??"; + continue; + } + if (!(t = date(v, &e)) || *e) + { + fprintf(stderr, "release: -%c%s: invalid date [%s]\n", i, s, e); + return 1; + } + switch (i) + { + case 'f': + lo = t; + break; + case 't': + hi = t; + break; + } + break; + case 'r': + if (!*(v = ++s) && !(v = *++argv)) + { + s = "??"; + continue; + } + mk = number(v, &e) + 1; + if (*e) + { + fprintf(stderr, "release: -%c%s: invalid count\n", i, s); + return 1; + } + break; + case 'V': + fprintf(stdout, "%s\n", id + 10); + return 0; + default: + fprintf(stderr, "release: -%c: unknown option\n", i); + /*FALLTHROUGH*/ + case '?': + usage(); + break; + } + break; + } + } +#endif + do + { + if (!(p = *argv++) || !*p || *p == '-' && !*(p + 1)) + { + argv--; + p = ""; + f = stdin; + } + else if (!(f = fopen(p, "r"))) + { + fprintf(stderr, "release: %s: cannot read", p); + return 1; + } + while (s = fgets(buf, sizeof(buf), f)) + { + if (t = date(s, &e)) + { + if (mk && e[0] == '-' && e[1] == '-' && e[2] == '-' && !--mk) + break; + if (t < lo) + break; + if (hi && t > hi) + continue; + if (p) + { + if (*p) + { + for (u = v = p; *p; p++) + if (*p == '/') + { + v = u; + u = p + 1; + } + printf("\n:::::::: "); + while ((i = *v++) && i != '/') + fputc(i, stdout); + printf(" ::::::::\n\n"); + } + p = 0; + } + } + if (!p) + fputs(s, stdout); + } + if (f == stdin) + break; + fclose(f); + } while (*argv); + return 0; +} diff --git a/src/cmd/INIT/rt.sh b/src/cmd/INIT/rt.sh new file mode 100644 index 0000000..2b8b840 --- /dev/null +++ b/src/cmd/INIT/rt.sh @@ -0,0 +1,479 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +: rt - nmake test output filter + +command=rt +flags='--silent --keepgoing' +failed=0 +heading=1 +verbose=0 + +case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in +0123) ARGV0="-a $command" + USAGE=$' +[-? +@(#)$Id: rt (AT&T Research) 2010-07-27 $ +] +'$USAGE_LICENSE$' +[+NAME?rt - run "nmake test" and filter output] +[+DESCRIPTION?\brt\b runs \vnmake test\v and filters the regression + test output to contain only test summary lines. If no \atest\a + operands are specified then \btest\b is assumed. If \b-\b is + specified then the \afile\a operands, or the standard input + if no \afile\a operands are specified, are filtered instead + of the output from \bnmake\b.] +[f:failed?Only list failed test results.] +[h!:heading?Enable per-file heading when more than one \afile\a operand + follows \b-\b.] +[v:verbose?Run with \vREGRESSFLAGS=-v\v.] + +[ test ... | - [ file ... ] ] + +[+SEE ALSO?\bnmake\b(1), \bregress\b(1)] +[+CAVEATS?\brt\b guesses the regression test output style. Garbled + output indicates a bad guess.] +' + ;; +*) ARGV0="" + USAGE="fhv" + ;; +esac + +function usage +{ + OPTIND=0 + getopts $ARGV0 "$USAGE" OPT '-?' + exit 2 +} + +while getopts $ARGV0 "$USAGE" OPT +do case $OPT in + f) failed=1 ;; + h) heading=0 ;; + v) (( verbose=$OPTARG )) && flags="$flags REGRESSFLAGS=-v" ;; + esac +done +shift `expr $OPTIND - 1` + +ifs=${IFS:-$' \t\n'} +set -o noglob +component= +dots='............................................' +bad=' ***' +style=unknown +integer tests errors signals lineno=0 skip=0 +typeset -l lower + +function results # tests errors signals +{ + integer t=$1 e=$2 s=$3 + typeset label note + if [[ $style != unknown ]] && (( errors >= 0 )) + then style=unknown + if (( !failed || errors )) + then if (( failed )) + then print -r -n -- "$unit" + fi + if (( t >= 0 )) + then if (( t == 1)) + then label="test " + else label=tests + fi + printf $'%s%5d %s' "$prefix" "$t" "$label" + prefix= + else prefix="$prefix..........." + fi + if (( s )) + then label=signal + (( e=s )) + else label=error + fi + if (( e != 1)) + then label=${label}s + fi + if (( e == 1 )) + then note=" $bad" + elif (( e > 1 )) + then note=$bad + fi + printf $'%s%5d %s%s\n' "$prefix" "$e" "$label" "$note" + fi + fi +} + +function unit +{ + typeset x + if [[ $component ]] + then x=${component##*/} + if [[ " $x " != *' '$unit' '* && " $unit " != *' '$x' '* ]] + then if [[ $component == cmd/?*lib/* ]] + then unit="$unit $x" + else unit="$x $unit" + fi + fi + fi + unit="$unit ${dots:1:${#dots}-${#unit}}" + if [[ $1 ]] + then unit="$unit..........." + fi + if (( ! failed )) + then print -r -n -- "$unit" + fi +} + +if [[ $1 == - ]] +then shift + if (( $# <= 1 )) + then heading=0 + fi + if (( heading )) + then for i + do print test heading $i + cat -- "$i" + done + else cat "$@" + fi +else if [[ $1 == *=* ]] + then set test "$@" + elif (( ! $# )) + then set test + fi + nmake "$@" $flags 2>&1 +fi | +while read -r line +do set '' $line + shift + case $line in + TEST[' ']*', '*' error'*) + IFS=${IFS}"," + set '' $line + IFS=$ifs + set '' $* + while : + do case $2 in + '') break + ;; + error|errors) + errors=$1 + break + ;; + test|tests) + tests=$1 + ;; + esac + shift + done + results $tests $errors + continue + ;; + TEST[' ']*) + results $tests $errors + IFS=${IFS}"," + set '' $line + IFS=$ifs + set '' $* + unit=${3##*/} + case $4 in + [a-zA-Z]*) unit="$unit $4" ;; + esac + unit + prefix= + errors=0 + signals=0 + style=regress + continue + ;; + 'pathname and options of item under test') + read -r line || break + results $tests $errors $signals + set '' $line + unit=${2##*/} + unit + tests=0 + errors=0 + signals=0 + style=script + continue + ;; + 'test heading '*) + if (( heading )) + then if (( heading > 1 )) + then print + else heading=2 + fi + set '' $line + shift 3 + print -r -- "==> $* <==" + fi + continue + ;; + 'test '*' begins at '????-??-??+??:??:??|'test '*' begins at '*' '*' '*' '*' '*) + results $tests $errors $signals + unit=${2##*/} + unit=${unit%.sh} + unit + prefix= + tests=-1 + errors=0 + signals=0 + style=shell + continue + ;; + 'test '*' at '????-??-??+??:??:??' [ '*' ]'|'test '*' at '*' '*' '*' '*' '*) + case $line in + *' [ '*test*error*' ]') + while : + do case $1 in + '[') tests=$2 + errors=$4 + if (( errors > 256 )) + then (( signals++ )) + fi + break + ;; + esac + shift + done + ;; + *' [ '*test*signal*' ]') + while : + do case $1 in + '[') tests=$2 + signals=$4 + if (( signals )) + then (( errors++ )) + fi + break + ;; + esac + shift + done + ;; + *) if [[ $3 != passed ]] + then (( errors )) || (( errors++ )) + fi + ;; + esac + results $tests $errors $signals + continue + ;; + '## ---'*(-)'--- ##') + (( ++lineno > skip )) || continue + read -r line || break + lower=$line + set '' $lower + case $lower in + '##'*'test suite:'*'##') + results $tests $errors $signals + set -- ${lower//*suite:} + set -- ${*//[.#]/} + unit=$* + if [[ $unit == *' tests' ]] + then unit=${unit/' tests'/} + fi + main=$unit + prefix= + tests=0 + errors=0 + signals=0 + category= + style=autotest + (( skip = lineno + 1 )) + unit + continue + ;; + esac + ;; + +(-)) case $style in + regress) continue ;; + esac + (( ++lineno > skip )) || continue + read -r line || break + set '' $line + case $line in + 'Running tests for '*) + results $tests $errors $signals + shift 4 + unit= + while (( $# )) + do if [[ $1 == on ]] + then break + fi + if [[ $unit ]] + then unit="$unit " + fi + unit=$unit${1##*/} + shift + done + main=$unit + prefix= + tests=-1 + errors=-1 + category= + style=perl + (( skip = lineno + 1 )) + continue + ;; + *' : '*)results $tests $errors $signals + unit=${2##*/} + unit=${unit%.sh} + unit + prefix= + tests=0 + errors=0 + signals=0 + style=timing + (( skip = lineno + 1 )) + continue + ;; + esac + ;; + +([0-9])*([a-zA-Z0-9])' '*) + case $style in + script) case $line in + *FAILED*|*failed*) + (( errors++ )) + ;; + *) (( tests++ )) + ;; + esac + ;; + esac + ;; + make:*|'make ['*']:'*) + case $line in + *': warning:'*|*'making test'*|*'action'?(s)' failed'*|*': *** '*) + ;; + *) results $tests $errors $signals + print -r -u2 -- "$line" + ;; + esac + continue + ;; + +([/a-zA-Z_0-9]):) + component=${line%:} + ;; + '') continue + ;; + esac + case $style in + autotest) + case $line in + +([0-9]):*ok) + (( tests++ )) + ;; + +([0-9]):*FAILED*) + (( tests++ )) + (( errors++ )) + if (( $verbose )) + then if [[ ! $prefix ]] + then prefix=$unit + print + fi + print -r -- " ${line//*'FAILED '/}" + fi + ;; + esac + continue + ;; + perl) case $line in + *'........ '*) + if [[ $1 == */* ]] + then cat=${1%%/*} + if [[ $cat != $category ]] + then results $tests $errors $signals + category=$cat + unit="$main $category" + unit + prefix= + tests=0 + errors=0 + signals=0 + fi + (( tests++ )) + case $line in + *' ok') ;; + *) (( errors++ )) + if (( $verbose )) + then if [[ ! $prefix ]] + then prefix=$unit + print + fi + print -r -- "$line" + fi + ;; + esac + else results $tests $errors $signals + case $line in + *' ok') errors=0 ;; + *) errors=1 ;; + esac + unit="$main $1" + unit + if (( $verbose && errors )) + then prefix=$unit + print + shift 2 + print -r -- "$@" + else prefix= + fi + results $tests $errors $signals + tests=-1 + errors=-1 + category= + fi + style=perl + ;; + esac + continue + ;; + esac + case $line in + *FAILED*|*failed*) + (( errors++ )) + ;; + *) case $style in + regress)case $line in + ['<>']*);; + *) continue ;; + esac + ;; + script) continue + ;; + shell) ((errors++ )) + ;; + timing) (( tests++ )) + continue + ;; + unknown)continue + ;; + esac + ;; + esac + if (( $verbose )) + then if [[ ! $prefix ]] + then prefix=$unit + print + fi + print -r -- "$line" + fi +done +results $tests $errors $signals diff --git a/src/cmd/INIT/silent.sh b/src/cmd/INIT/silent.sh new file mode 100644 index 0000000..be99aa6 --- /dev/null +++ b/src/cmd/INIT/silent.sh @@ -0,0 +1,42 @@ +######################################################################## +# # +# This software is part of the ast package # +# Copyright (c) 1994-2011 AT&T Intellectual Property # +# and is licensed under the # +# Eclipse Public License, Version 1.0 # +# by AT&T Intellectual Property # +# # +# A copy of the License is available at # +# http://www.eclipse.org/org/documents/epl-v10.html # +# (with md5 checksum b35adb5213ca9657e911e9befb180842) # +# # +# Information and Software Systems Research # +# AT&T Research # +# Florham Park NJ # +# # +# Glenn Fowler <gsf@research.att.com> # +# # +######################################################################## +# non-ksh stub for the nmake silent prefix +# @(#)silent (AT&T Research) 1992-08-11 + +case $-:$BASH_VERSION in +*x*:[01234567899]*) : bash set -x is broken :; set +ex ;; +esac + +while : +do case $# in + 0) exit 0 ;; + esac + case $1 in + *=*) case $RANDOM in + $RANDOM)`echo $1 | sed "s/\\([^=]*\\)=\\(.*\\)/eval \\1='\\2'; export \\1/"` ;; + *) export "$1" ;; + esac + shift + ;; + *) break + ;; + esac +done +"$@" diff --git a/src/cmd/INIT/socket.c b/src/cmd/INIT/socket.c new file mode 100644 index 0000000..51d74eb --- /dev/null +++ b/src/cmd/INIT/socket.c @@ -0,0 +1,33 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +/* + * small test for -lnsl + */ + +#ifndef socket +#include <sys/types.h> +#include <sys/socket.h> +#endif + +int +main() +{ + return socket(0, 0, 0) < 0; +} diff --git a/src/cmd/INIT/w.c b/src/cmd/INIT/w.c new file mode 100644 index 0000000..0f6bc7d --- /dev/null +++ b/src/cmd/INIT/w.c @@ -0,0 +1,30 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#ifndef DONTCARE +#include <wchar.h> +#include <wctype.h> +#endif + +int +main() +{ + wchar_t w = ' '; + return iswspace(w) == 0; +} diff --git a/src/cmd/INIT/w2.c b/src/cmd/INIT/w2.c new file mode 100644 index 0000000..00efd25 --- /dev/null +++ b/src/cmd/INIT/w2.c @@ -0,0 +1,27 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1994-2011 AT&T Intellectual Property * +* and is licensed under the * +* Eclipse Public License, Version 1.0 * +* by AT&T Intellectual Property * +* * +* A copy of the License is available at * +* http://www.eclipse.org/org/documents/epl-v10.html * +* (with md5 checksum b35adb5213ca9657e911e9befb180842) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#include <wchar.h> + +int +main() +{ + wchar_t w = ' '; + return iswspace(w) == 0; +} |