:

# Glenn Fowler

# AT&T Research

#

# @(#)pp.probe (AT&T Research) 2009-02-02

#

# C probe for libpp

#

# NOTE: C.probe must be included or .'d here

#

ppdef=$dir/pp.def

ppkey=$dir/pp.key

ppsym=$dir/ppsym

for f in $ppdef $ppkey $ppsym

do test -f $f || { echo "$0: $f: not found" >&4; exit 1 ;}

done

sed -e "/^#/d" -e "s/[ ].*//" < $ppdef > all.pp

system=

release=

version=

architecture=

cpu=

model=

machine=

undef_predef=

#

# path cleanup

#

for i in stdinclude usrinclude

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

id="::IDENT::`date`::IDENT::"

echo '#assert test(ok)

#if #test(ok)

#else

(

#endif' > assert.$src

echo '#ifdef __BASE_FILE__

int ok;

#else

(

#endif' > basefile.$src

cat > catlit1.i <<'!'

char test[] = "te"

"st";

!

cat > catlit2.i <<'!'

char test[] = "te\

st";

!

echo '#define g(a,b) a ## b

volatile int a;

const int g(x,y)=1;

extern int c(int);' > compat.$src

echo > cpp.$src

echo "#defincl <x.h>" > defincl.$src

echo 'int a$b;' > dollar.$src

echo "#eject" > eject.$src

echo "#if 0

(

#else if 1

int x;

#else

(

#endif" > elseif.$src

echo "#define _CAT(a,b,c) a##b##c

#define hdra hdrx

#define hdr _CAT(<,hdra,.h>)

#include hdr" > hdra.$src

echo "#define _XAT(a,b,c) a##b##c

#define _CAT(a,b,c) _XAT(a,b,c)

#define hdra hdrx

#define hdr _CAT(<,hdra,.h>)

#include hdr" > hdrx.$src

echo "int f(){return 0;}" > hdrx.h

echo "#ident \"$id\"" > ident.$src

echo "#import \"import.h\"" > import.$src

echo "int aaa;" > import.h

echo "#include <inc_next.h>" > inc_next.$src

mkdir inc0 inc1

echo "#include_next <inc_next.h>" > inc0/inc_next.h

echo 'char s[] = "INCLUDE_NEXT";' > inc1/inc_next.h

echo '# 1 "linefile.i"

# 1 "linefile.i"

int i;' > linefile1.i

echo '# 1 "linefile.i"

# 1

int i;' > linefile2.i

echo "int i = 0;" > lineid1.i

echo '# 1 "t.c"

int i = 0;' > lineid2.i

echo '# 1 "t.c"

int i = 0;' > lineid3.$src

echo "#include <stdio.h>" > linetype.$src

echo '#include <sys/types.h>

main()

{

return sizeof(LONGLONG) != 8;

}' > longlong.$src

echo '#include "once.h"

#include "once.h"' > once.$src

echo '#ifdef once

allmultiple

#else

#define once

#endif' > once.h

echo "extern int a,b;int f(){return a + = b;}" > opspace.$src

echo "int f(){return(0);} // ((" > pluscom.$src

echo "class x {int n;} m;" > plusplus.$src

echo > preinc.$src

echo '// splice \

(

int x = 1;' > plusspl.$src

echo "int stdc_default_value = __STDC__ ;" > stdc.$src

echo 'char xxx[] = "abc

(";' > span.$src

echo '#define g(a,b) a\

b

int ab,xy;

#define xy XY

char* g(x,y);' > splice.$src

{

echo 'int a\ '

echo 'b = 1;'

} > splicesp.$src

echo '#define g(a,b) a/**/b

int g(x,y)=1;' > trans.$src

echo '#define m 65

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 65

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 64

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 63

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 62

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 61

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 60

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 59

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 58

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 57

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 56

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 55

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 54

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 53

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 52

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 51

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 50

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 49

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 48

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 47

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 46

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 45

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 44

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 43

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 42

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 41

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 40

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 39

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 38

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 37

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 36

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 35

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 34

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 33

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 32

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 31

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 30

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxxx 29

#define xxxxxxxxxxxxxxxxxxxxxxxxxxxx 28

#define xxxxxxxxxxxxxxxxxxxxxxxxxxx 27

#define xxxxxxxxxxxxxxxxxxxxxxxxxx 26

#define xxxxxxxxxxxxxxxxxxxxxxxxx 25

#define xxxxxxxxxxxxxxxxxxxxxxxx 24

#define xxxxxxxxxxxxxxxxxxxxxxx 23

#define xxxxxxxxxxxxxxxxxxxxxx 22

#define xxxxxxxxxxxxxxxxxxxxx 21

#define xxxxxxxxxxxxxxxxxxxx 20

#define xxxxxxxxxxxxxxxxxxx 19

#define xxxxxxxxxxxxxxxxxx 18

#define xxxxxxxxxxxxxxxxx 17

#define xxxxxxxxxxxxxxxx 16

#define xxxxxxxxxxxxxxx 15

#define xxxxxxxxxxxxxx 14

#define xxxxxxxxxxxxx 13

#define xxxxxxxxxxxx 12

#define xxxxxxxxxxx 11

#define xxxxxxxxxx 10

#define xxxxxxxxx 9

#define xxxxxxxx 8

#define xxxxxxx 7

#define xxxxxx 6

#define xxxxx 5

#define xxxx 4

#define xxx 3

#define xx 2

#define x 1

#if xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx != m

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

#endif' > truncate.$src

cat > zeof.c <<'!'

char* foo = "az";

!

allmultiple=

assert=

basefile=

compatibility=1

defincl=

dollar=

eject=

elseif=

headerexpand=

headerexpandall=

hostedtransition=

ident=

import=

include_next=

linefile=

lineid=

linetype=

nocatliteral=

opspace=

pluscom=

plusplus=

plussplice=

redef=

reguard=

reserved=

spaceout=

splicecat=

splicespace=

strict=

stringspan=

transition=

truncate=

zeof=

$cc -c assert.$src && assert=1

$cc -c basefile.$src && basefile=__BASE_FILE__

if $cc -E defincl.$src

then case "`$cc -E defincl.$src | grep -c 'defincl'`" in

0) defincl=1 ;;

esac

fi

if $cc -c catlit1.i 2>e

then if $cc -c catlit2.i 2>f

then if test `wc -c < f` -gt `wc -c < e`

then nocatliteral=1

fi

else nocatliteral=1

fi

fi

$cc -c dollar.$src && dollar=1

$cc -c elseif.$src && elseif=1

if $cc -I. -c hdra.$src

then headerexpandall=1

elif $cc -I. -c hdrx.$src

then headerexpand=1

fi

if $cc -E eject.$src

then case "`$cc -E eject.$src | grep -c 'eject'`" in

0) eject=1 ;;

esac

fi

$cc -S ident.$src && grep "$id" ident.s && ident=1

{ $cc -E import.$src | grep aaa ;} && import=1

{ $cc -E -Iinc0 -Iinc1 inc_next.$src | grep INCLUDE_NEXT ;} && include_next=1

if $cc -c linefile1.i

then $cc -c linefile2.i

case $? in

0) ;;

*) linefile=1 ;;

esac

fi

if $cc -c lineid1.i 2>b

then $cc -c lineid2.i 2>e

c=$?

else $cc -c lineid3.c 2>e

c=$?

fi

case $c in

0) case `wc -l < b` in

`wc -l < e`) ;;

*) lineid=line ;;

esac

;;

*) lineid=line

;;

esac

if $cc -E linetype.$src | grep '^[ ]*#[ ]*[0123456789]*[ ]*".*"[ ]*[12]' > linetype

then if grep '^[ ]*#[ ]*[0123456789]*[ ]*".*"[ ]*[12][ ][ ]*3' linetype

then linetype=2

else linetype=1

fi

fi

{ $cc -E once.$src | grep allmultiple ;} && allmultiple=1

$cc -c plusplus.$src && plusplus=1

$cc -c span.$src && stringspan=1

$cc -c splice.$src && splicecat=1

$cc -c splicesp.$src && splicespace=1

exec < $ppkey

while read keyword type alternate comment

do case $keyword in

.) break ;;

""|"#") continue ;;

esac

case $type in

""|".") type= ;;

*) type="=$type" ;;

esac

for pre in '' _ __

do for suf in '' _ __

do case $suf in

'') sep= ;;

*) sep=. ;;

esac

case ,,$alternate, in

*,$pre$sep$suf,*)

key=$pre$keyword$suf

undef="$undef $key"

echo "int f(){

int $key = 0;

return $key;

}

#undef $key

int g(){

int $key = 0;

return $key;

}" > key.$src

$cc -c key.$src >/dev/null 2>&1 || reserved="$reserved $key$type"

;;

esac

done

done

done

$cc -c opspace.$src && opspace=1

case $plusplus in

"") $cc -c compat.$src && compatibility=

$cc -c pluscom.$src && pluscom=1

;;

esac

case $plusplus$pluscom in

?*) $cc -c plusspl.$src || plussplice=1 ;;

esac

case $plusplus in

?*) mkdir reguard

cd reguard

echo '#include "ptrone.h"

#include "ptrdef.h"

int main () { return gt(2,1) + gt(2.0,1.0); }' > ptr.$src

echo '#include "ptrone.h"

template<class T> int gt(T a, T b) { return a > b; }' > ptrdef.$src

echo 'template<class T> int gt(T a, T b);' > ptrdef.h

echo '/* empty */' > ptrone.h

if $cc -E ptr.$src > x.i && $cc x.i

then echo '#ifndef _PTRONE_H

#define _PTRONE_H

static int xxx;

#endif' > ptrone.h

if $cc -E ptr.$src > x.i && echo "#define _PTRONE_H" >> x.i && $cc x.i

then reguard=1

fi

fi

cd ..

rm -rf reguard

;;

esac

stdc=`$cc -E stdc.$src | sed -e '/stdc_default_value/!d' -e 's/.*=[ ]*//' -e 's/[ ]*;.*//'`

case $stdc in

0) $cc -c trans.$src && transition=1 ;;

[0123456789]*) ;;

*) stdc= ;;

esac

truncate=`$cc -E truncate.$src | grep '^[ ]*[0123456789]'`

$cc -c zeof.c || zeof=1

echo "$predef" >> all.pp

{

case $ppopt$ppenv in

?*) ppcmd=cpp

ppdir=.

eval $ppenv '$'cc -Dmycpp -E '$'ppopt cpp.$src

;;

esac

eval set x $probe_verbose

shift

x=

for o in "$@"

do set x `$cc $o -c cpp.$src 2>&1`

while :

do shift

case $# in

0) break ;;

esac

case $1 in

*[\\/]rm)

;;

[\\/]*) case " $x " in

*" $1 "*) ;;

*) test -x $1 && x="$x $1" ;;

esac

;;

esac

done

case $x in

?*) for f in $x

do cp $f x && chmod u+w x && strip x && f=x

$ppsym < $f

done

break

;;

esac

done

} 3>&- 3>&1 >/dev/null |

sed -e '/^ppsymbol$/d' -e '/^.$/d' -e '/^..$/d' -e '/[ABCDEFGHIJKLMNOPQRSTUVWXYZ].*[abcdefghijklmnopqrstuvwxyz]/d' -e '/[abcdefghijklmnopqrstuvwxyz].*[ABCDEFGHIJKLMNOPQRSTUVWXYZ]/d' |

cat - all.pp |

sort -u |

{

for i in 0 1 2 3 4 5

do echo "struct { char* name; long value; } predef[] = {" > cpp$i.$src

done

while read sym junk

do case $sym in

_*) set 0 ${sym}

;;

*_) continue

;;

[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]*)

set 1 ${sym} 2 _${sym} 3 _${sym}_ 4 __${sym} 5 __${sym}__

;;

*) continue

;;

esac

while :

do case $# in

0|1) break ;;

esac

{

echo "#ifdef $2"

echo "\"$2\" , (long) $2 -1,"

echo "#endif"

} >> cpp$1.$src

shift

shift

done

done

for i in 0 1 2 3 4 5

do echo "\"\", 0 };" >> cpp$i.$src

done

}

preval="`for i in 0 1 2 3 4 5;do $cc -E cpp$i.$src;done | sed -e '/\".*\".*,.*,/!d' -e 's/[^\"]*\"\\([^\"]*\\)\"[ ]*,[ ]*([ ]*long[ ]*)[ ]*\\(.*\\)[ ]*-[ ]*1[ ]*,[ ]*\$/\\1 \\2 =/g'` `$cc -dM -E stdc.$src | sed -e '/[ ]*#[ ]*define/!d' -e '/\"/d' -e 's/[ ]*#[ ]*define[ ]*\\([abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]*\\)[ ]*\\(.*\\)/\\1 \\2 =/'`"

for i in bufld namei quota reboot utsname vfs

do echo "#include <sys/$i.h>" > t.$src

if $cc -E t.$src

then x=1

else x=0

fi

eval sys_$i=$x

done

echo "char* fun() { return (char*)__FUNCTION__; }

int main() { return !fun(); }" > fun.$src

rm -f fun.exe

if $cc -o fun.exe fun.$src && test -x fun.exe

then undef_predef="$undef_predef __FUNCTION__"

fi

case "`grep -c '__STDC__[-0 ]*[=!]=[ ]*0' $usrinclude/stdio.h 2>/dev/null`" in

0) ;;

*) hostedtransition=1 ;;

esac

mapinclude=

for i in builtins

do echo "#include <$i.h>" > t.$src

if $cc -E t.$src

then mapinclude="$mapinclude <$i.h>=\".\""

fi

done

#

# the payoff

#

exec >&3

case "$compatibility:$transition:$dollar" in

::) strict=1 ;;

esac

case $version_stamp in

?*) echo "/* $version_stamp" ;;

*) echo "/* $cc" ;;

esac

echo "*/"

case $plusplus:$stdc in

1:?*) preval="$preval = __STDC__ $stdc ="

redef="$redef __STDC__"

;;

esac

ppbuiltin=0

set x $preval

shift

case $# in

0) ;;

*) echo

echo "#pragma pp:predefined"

predef=

while :

do case $# in

0) break ;;

esac

m=$1

shift

case $m in

*'('*) i=`echo "$m" | sed 's,(.*,,'` ;;

*) i=$m ;;

esac

predef="$predef

$i"

eval predef_$i=0

while :

do case $1 in

'=') break ;;

*) shift ;;

esac

done

while :

do case $1 in

'=') shift ;;

*) break ;;

esac

done

done

for i in $undef

do case " $redef " in

*" $i "*) ;;

*) eval predef_$i=3 ;;

esac

done

set $preval

while :

do case $# in

0) break ;;

esac

m=$1

shift

case $m in

*'('*) i=`echo "$m" | sed 's,(.*,,'` ;;

*) i=$m ;;

esac

case $i in

'=') continue ;;

esac

v=

while :

do case $1 in

'=') break ;;

esac

v="$v $1"

shift

done

while :

do case $1 in

'=') shift ;;

*) break ;;

esac

done

case $i in

__LCC__)strict=2 ;;

_*) ;;

*) eval j=\$predef_$i

case $j in

0) eval predef_$i=1

echo "#define $m$v"

case $strict in

1) strict= ;;

esac

;;

esac

;;

esac

done

nopredef=0

while :

do set $preval

while :

do case $# in

0) break ;;

esac

m=$1

shift

case $m in

*'('*) i=`echo "$m" | sed 's,(.*,,'` ;;

*) i=$m ;;

esac

v=

while :

do case $1 in

'=') break ;;

esac

v="$v $1"

shift

done

while :

do case $1 in

'=') shift ;;

*) break ;;

esac

done

case $nopredef in

2) ;;

*) case $v in

' '*' '*)

nopredef=1

continue

;;

' '[0123456789]*|' '"'"*"'"*)

;;

*) case $1 in

_*) ;;

*) nopredef=1

continue

;;

esac

;;

esac

;;

esac

eval j=\$predef_$i

case $j in

0) case $ppbuiltin in

2) echo "#pragma pp:builtin"

ppbuiltin=1

;;

esac

eval predef_$i=2

echo "#define $m$v"

;;

1) case $m in

$i) eval predef_$i=2

eval j=\$predef___${i}__

case $j in

[12]) ;;

*) case $ppbuiltin in

2) echo "#pragma pp:builtin"

ppbuiltin=1

;;

esac

eval predef___${i}__=2

echo "#define __${i}__$v"

;;

esac

;;

esac

;;

esac

done

case $nopredef in

2) break ;;

esac

echo "#pragma pp:nopredefined"

case $nopredef in

0) break ;;

esac

ppbuiltin=2

nopredef=2

done

;;

esac

case $basefile in

?*) case $ppbuiltin in

0|2) ppbuiltin=1

echo "#pragma pp:builtin"

;;

esac

echo "#define $basefile #(BASE)"

;;

esac

case $ppbuiltin in

1) echo "#pragma pp:nobuiltin" ;;

esac

eval set x $probe_longlong

shift

x=

for o in "$@"

do rm -f longlong.$exe

if $cc -DLONGLONG="$o" -o longlong.$exe longlong.$src &&

./longlong.$exe

then x=1

break

fi

done

case $x in

'') eval set x $probe_longlong_t

shift

for o in "$@"

do rm -f longlong.$exe

if $cc -DLONGLONG="$o" -o longlong.$exe longlong.$src &&

./longlong.$exe

then echo "#define <long long> $o"

break

fi

done

;;

esac

echo

for i in `echo "$predef" | sed -e 's/^__*\(.*\)_*\$/\1/' -e '/^[abcdefghijklmnopqrstuvwxyz][abcdefghijklmnopqrstuvwxyz]*[0123456789][abcdefghijklmnopqrstuvwxyz0123456789]*\$/!d'` `echo "$predef" | sed -e 's/^__*\(.*\)_*\$/\1/' -e '/^[abcdefghijklmnopqrstuvwxyz][abcdefghijklmnopqrstuvwxyz]*\$/!d'`

do case $i in

*ix) ;;

*) architecture=$i

break

;;

esac

done

for i in `sed -e '/^#/d' -e '/:architecture:/!d' -e 's/[ ].*//' < $ppdef`

do eval j="\" \$predef_$i \$predef__${i} \$predef__${i}_ \$predef___${i} \$predef___${i}__ \""

case $j in

*" 2 "*)architecture=$i

break

;;

esac

done

for i in `sed -e '/^#/d' -e '/:machine:/!d' -e 's/[ ].*//' < $ppdef`

do eval j="\" \$predef_$i \$predef__${i} \$predef__${i}_ \$predef___${i} \$predef___${i}__ \""

case $j in

*" 2 "*)machine="$machine $i" ;;

esac

done

case $sys_bufld$sys_reboot$sys_utsname in

1??) release=research

version=9

;;

01?) release=bsd

case $sys_quota in

0) case $sys_vfs in

0) version=4.1

;;

esac

;;

1) case $sys_namei in

0) version=4.2

;;

1) version=4.3

;;

esac

;;

esac

;;

001) release=V

;;

esac

for i in `sed -e '/^#/d' -e '/:release:/!d' -e 's/[ ].*//' < $ppdef`

do eval j=\$predef_$i

case $j in

2) release="$release $i" ;;

esac

done

for i in `sed -e '/^#/d' -e '/:system:/!d' -e 's/[ ].*//' < $ppdef`

do eval j=\$predef_$i

case $j in

2) system="$system $i" ;;

esac

done

case $release in

topix) release="$release V"

;;

esac

case $assert in

?*) for i in $predef

do case $i in

_*|*_) ;;

*) for p in architecture cpu machine system

do echo "#if #$p($i)

eval \"case \\\" \$$p \\\" in *\\\" $i \\\"*) ;; *) $p=\\\"$i \$$p\\\" ;; esac\"

: avoid string literal concatenation

#endif"

done

;;

esac

done > t.$src

eval "`$cc -E t.$src`"

set x x $prepred

while :

do shift

shift

case $# in

[01]) break ;;

esac

eval "

case \" \$$1 \" in

*\" $2 \"*) ;;

*) $1=\"$2 \$$1\" ;;

esac

"

done

;;

esac

case $system in

"") system=unix ;;

esac

case $architecture in

ibm|uts|u370) model=370

architecture=ibm

;;

m*68*) architecture=m68000

for i in $predef

do case $i in

m*68*[123456789][0123456789])

model=`echo $i | sed 's/.*\(..\)/\1/'`

break

;;

esac

done

;;

u3b?*) model=`echo $architecture | sed 's/u3b//'`

architecture=3b

;;

u3b) case $model in

"") model=20 ;;

esac

architecture=3b

;;

vax[0123456789]*)

model=`echo $architecture | sed 's/vax//'`

architecture=vax

;;

hp[0123456789]*s[0123456789])

case $release in

[abcdefghijklmnopqrstuvwxyz]*.[abcdefghijklmnopqrstuvwxyz]*.*)

version=$release

release=V

;;

esac

architecture="$architecture `echo $architecture | sed 's/s.*//'`"

;;

esac

case $hosttype in

*.*) i=`echo $hosttype | sed -e 's,.*\.,,'` ;;

*) i=$hosttype ;;

esac

case $i in

unknown);;

?*) case " $architecture " in

*" $i "*) ;;

*) architecture="$architecture $i" ;;

esac

;;

esac

case $architecture in

"") echo "$cc: warning: architecture not determined" >&4

set x $machine

architecture=$2

;;

esac

echo "#define #hosttype($hosttype)"

for i in $system

do echo "#define #system($i)"

done

case $release in

"") echo "#define #release()" ;;

*) for i in $release

do echo "#define #release($i)"

case $i in

V) echo "#define #release(system5)" ;; # compatibility

esac

done

;;

esac

echo "#define #version($version)"

case $architecture in

"") echo "#define #architecture()" ;;

*) for i in `echo $architecture | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`

do echo "#define #architecture($i)"

done

;;

esac

echo "#define #model($model)"

case $machine in

"") case $architecture:$model in

?*:?*) set x $architecture; machine="$2/$model $architecture" ;;

*) machine=$architecture ;;

esac

;;

*) machine="$machine $architecture"

;;

esac

case $machine in

"") echo "#define #machine()" ;;

*) j=

for i in `echo $machine | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`

do case " $i " in

*" $j "*)

;;

*) j="$j $i"

echo "#define #machine($i)"

;;

esac

done

;;

esac

for i in $cpu

do echo "#define #cpu($i)"

done

echo "#define #addressing()"

for i in $ATTRIBUTES

do eval d=\$$i

n=`echo $i | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`

echo "#define #$n($d)"

done

case $stdc in

?*) echo "#define #dialect(ansi)" ;;

esac

case $plusplus in

?*) echo "#define #dialect(C++)" ;;

esac

case $hosted in

"") echo "#define #dialect(cross)" ;;

esac

case $so:$dynamic:$static in

::) ;;

*) echo "#define #dialect(dynamic)" ;;

esac

echo

case $undef_predef in

?*) for m in $undef_predef

do echo "#undef $m"

done

echo

;;

esac

case $plusplus in

?*) echo "#pragma pp:plusplus" ;;

esac

case $reserved in

?*) echo "#pragma pp:reserved" $reserved ;;

esac

case $nocatliteral in

?*) echo "#pragma pp:nocatliteral" ;;

esac

case $opspace in

?*) echo "#pragma pp:opspace" ;;

esac

case $pluscom in

?*) echo "#pragma pp:pluscomment" ;;

esac

case $plussplice in

?*) echo "#pragma pp:plussplice" ;;

esac

case $reguard in

?*) echo "#pragma pp:reguard" ;;

esac

case $splicecat in

?*) echo "#pragma pp:splicecat" ;;

esac

case $splicespace in

?*) echo "#pragma pp:splicespace" ;;

esac

case $stringspan in

?*) echo "#pragma pp:stringspan" ;;

esac

case $stdc in

"") echo "#pragma pp:compatibility"

;;

0) echo "#pragma pp:transition"

;;

1) case $strict in

?*) echo "#pragma pp:strict" ;;

esac

;;

esac

case $hostedtransition in

1) echo "#pragma pp:hostedtransition" ;;

esac

case $stdc in

?*) case $ppopt$ppenv in

"") spaceout=1

echo "#pragma pp:spaceout"

;;

esac

;;

esac

case $truncate in

?*) echo "#pragma pp:truncate $truncate" ;;

esac

case $zeof in

?*) echo "#pragma pp:zeof" ;;

esac

case $dollar in

1) echo '#pragma pp:id "$"' ;;

esac

cdir=-I+C

hdir=-I+H

set x $stdinclude

while :

do shift

case $# in

0) break ;;

esac

case $1 in

$cdir|$hdir)

;;

-I+C) cdir=$1

echo "#pragma pp:nocdir"

;;

-I-C) cdir=$1

echo "#pragma pp:cdir"

;;

-I+H) hdir=$1

echo "#pragma pp:nohostdir"

;;

-I-H) hdir=$1

echo "#pragma pp:hostdir"

;;

-I*) ;;

*) echo "#pragma pp:include \"$1\""

;;

esac

done

case $usrinclude in

/usr/include)

;;

?*) echo "#pragma pp:standard \"$usrinclude\""

;;

esac

case $plusplus in

?*) case $usrinclude in

?*) if grep plusplus $usrinclude/ctype.h >/dev/null 2>&1

then echo '#pragma pp:nocdir "-"'

fi

;;

esac

;;

esac

case $mapinclude in

?*) echo "#pragma pp:mapinclude hosted$mapinclude" ;;

esac

case $linefile in

?*) echo "#pragma pp:linefile" ;;

esac

case $lineid in

?*) echo "#pragma pp:lineid line" ;;

esac

case $linetype in

1) echo "#pragma pp:linetype" ;;

?*) echo "#pragma pp:linetype $linetype" ;;

esac

case $allmultiple in

"") echo "#pragma pp:noallmultiple" ;;

esac

case $defincl in

1) echo '#pragma pp:map "/#(pragma )?defincl>/"' ;;

esac

case $eject in

1) echo '#pragma pp:map "/#(pragma )?eject>/"' ;;

esac

case $elseif in

1) echo "#pragma pp:elseif" ;;

esac

case $headerexpand in

1) echo "#pragma pp:headerexpand" ;;

esac

case $headerexpandall in

1) echo "#pragma pp:headerexpandall" ;;

esac

case $ident in

1) echo '#pragma pp:map "/#(pragma )?ident>/" "/#(pragma )?/###/"' ;;

*) echo '#pragma pp:map "/#(pragma )?ident>/"' ;;

esac

case $import in

1) echo '#pragma pp:map "/#(pragma )?import>/" "/#(pragma )?import(.*)/__STDPP__IMPORT__(\2)/"

#macdef __STDPP__IMPORT__(x)

#pragma pp:noallmultiple

#include x

#pragma pp:allmultiple

#endmac' ;;

esac

case $include_next in

1) echo '#pragma pp:map "/#include_next>/" ",[^\<]*\<,#include <.../,"' ;;

esac

echo '#pragma pp:map "/#pragma lint:/" ",#pragma lint:(.*),##/*\1*/,u"'

echo '#pragma pp:map "/#(pragma )?sccs>/"'

case $stdc:$spaceout in

1:) case ' '$reserved' ' in

*' 'asm' '*|*' 'asm=*)

echo "#macdef asm"

echo "#pragma pp:spaceout"

echo "#undef asm"

echo "asm"

echo "#endmac"

;;

esac

;;

esac

if $cc -E preinc.$src > preinc.out

then for f in `sed -e 's,\\\\,/,g' -e 's,"[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]:/,"/,g' -e '/^#[line ]*[0123456789][0123456789]*[ ][ ]*"[\\/]/!d' -e 's/^#[line ]*[0123456789][0123456789]*[ ][ ]*".*[\\/]\(.*\)".*/\1/' preinc.out | sort -u`

do case $f in

*preinc.$src*)

;;

*) echo "#include <$f>"

;;

esac

done

fi