case $-:$BASH_VERSION in
*x*:[0123456789]*) : bash set -x is broken :; set +ex ;;
esac
command=iffe
version=2011-01-07
compile() {
"$@" 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() {
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 ' ?*) _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() {
case $1 in
'<') shift ;;
*) return ;;
esac
case $1 in
X|X11*) i="openwin"
case $1 in
X) set X11 ;;
esac
case $1 in
X11) case $ 1) set $1 6 5 4 ;;
esac
;;
esac
;;
*) i=
;;
esac
pth="{ usr . - . contrib local $i - . share - . lib - $1"
i=$1
while :
do shift
case $ 0) break ;;
esac
case $1 in
'>') shift; break ;;
esac
pth="$pth ${i}R$1 ${i}.$1"
done
pth="$pth . } $*"
}
is() {
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 $ 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 $ 0) mm="no" ;;
*) mm=$* ;;
esac
;;
*) mm=
;;
esac
case $debug in
0) echo " $mm" >&$stderr ;;
*) echo "$command: ... $mm" >&$stderr ;;
esac
;;
esac
}
report() {
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
copy() {
case $shell in
ksh) case $1 in
-) print -r - "$2" ;;
*) print -r - "$2" > "$1" ;;
esac
;;
*) case $1 in
-) if cat <<!
$2
!
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 <<!
$2
!
"
fi
;;
*) if cat > "$1" <<!
$2
!
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 > '$1' <<!
$2
!
"
fi
;;
esac
;;
esac
}
checkread()
{
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 $2) posix_noglob="set -f" posix_glob="set +f" ;;
*) case `(set -F && set x * && echo $ 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=
case $1 in
-) out=-; shift ;;
esac
set=
case `(getopts '[-][123:xyz]' opt --xyz; echo 0$opt) 2>/dev/null` in
0123) USAGE=$'
[-?
@(]
'$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.][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 output file. See \bproto\b(1).]
[P:pragma?Emits \b[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 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:]{
[+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ [+ }
[+?= \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 \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 \b 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 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 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:]{
[+ [+api \aname\a \aYYYYMMDD\a \asymbol ...\a?Emit api compatibility tests
for \aname\a and \b 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 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 exists. The \b [+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 \aheader\a to subsequent tests.]
[+ver \aname\a \aYYYYMMDD\a?\b \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 \avalue\a defined in the headers. The definition is \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. 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), \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*.*" EXIT
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="noext='*[<"][Ss][Tt][Dd][Ii][Oo].[Hh][">]*|*<ast.h>*|*<sfio.h>*'
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 $ 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 $ 0) case $ifstack in
?*) echo "$command: $file$line: missing endif" >&$stderr
exit 1
;;
esac
set set out +
;;
esac
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
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
case $1 in
""|"#"*)continue
;;
inc) case $ifelse in
DONE|SKIP) set ''; shift; continue ;;
esac
shift
case $ 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 $ 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 '/^ 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 $ 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=" 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 $ 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 $ 0) ;;
*) shift ;;
esac
;;
esac
;;
esac
;;
-*|+*|'('*|*'{'|'"'*'"'|'<'*'>')
arg=-
;;
*) arg=$1
shift
;;
esac
;;
esac
;;
esac
case $1 in
'('*|'"'*'"'|'<'*'>')
while :
do case $ 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 $ 0) break ;;
esac
case $1 in
"") ;;
"#"*) set x
;;
"=") shift
set=$*
case $set in
"") set=" " ;;
esac
while :
do case $ 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 $ 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" 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
"") # 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
;;
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)cat <<!
/* $* */
!
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
(
int x;
"
if compile $cc -c $tmp.c <&$nullin >&$nullout
then success -
else failure -
cat <<!
#define $x$arg $v
!
usr="$usr${nl} 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_
"
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 $ 0) break ;;
esac
t=$1
shift
case $t in
":") break ;;
esac
v="$v $t"
done
;;
*) v=$*
;;
esac
cat <<!
extern $t $x$v;
!
case $prototyped in
'') usr="$usr${nl}extern $t $x$v;" ;;
esac
else failure -
case $in in
"") while :
do case $ 0) break ;;
esac
case $1 in
":") break ;;
esac
done
;;
esac
fi
continue
;;
header|include|reference)
while :
do case $ 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)
;;
*) cat <<!
!
;;
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)
;;
*) cat <<!
!
;;
esac
usr="$usr${nl}#include <$x>"
else gothdr="$gothdr - $x"
fi
;;
esac
done
continue
;;
print) case $in in
"") v=
while :
do case $ 0) break ;;
esac
t=$1
shift
case $t in
":") break ;;
esac
v="$v $t"
done
;;
*) v=$*
;;
esac
cat <<!
$*
!
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 $ 0) break ;;
esac
case $1 in
:) break ;;
esac
shift
done
;;
esac
;;
esac
argx=1
argv=$*
while :
do
cc="$cc $mac"
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
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
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
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 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
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 " done
esac
case $apis in
?*) for api in $apis
do map=
sep=
eval syms='"${'api_sym_${api}'}"'
set x x `echo "$syms" | sort -t: -u -k 1,1 -k 2,2nr | sed 's/\(.*\):\(.*\)/\1 \2/'`
sym=
while :
do shift 2
case $ [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 '/^ sed '/^ ;;
*) (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
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'`
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
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
for x in $lib $deflib
do case $shell in
ksh) eval 'c=${x *) 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
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
'')
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 $ 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.*
;;
esac
ccflags=$reallystatic
;;
*) ccflags=
;;
esac
set x $mac
e=1
while :
do o=
shift
while :
do case $ 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 $ 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
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 $ 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
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
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
if compile $cc -E $tmp.c <&$nullin >$tmp.i
then j=`sed -e '/^ 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 $ 0) break ;;
esac
case $1 in
=) break ;;
esac
case $w in
'') w=$1 ;;
*) w="$w $1" ;;
esac
shift
done
case $1 in
=) shift
case $ 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_
"
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 '/^ ?*) 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) {
cat <<!
:
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]*\).*/ ;;
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