tinfer.c

Bug Summary

File:	src/tinfer.c
Warning:	line 1620, column 41 Access to field 'first' results in a dereference of a null pointer (loaded from variable 'nstab')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name tinfer.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/kfp/aldor/aldor/aldor/src -fcoverage-compilation-dir=/home/kfp/aldor/aldor/aldor/src -resource-dir /usr/local/lib/clang/18 -D PACKAGE_NAME="aldor" -D PACKAGE_TARNAME="aldor" -D PACKAGE_VERSION="1.4.0" -D PACKAGE_STRING="aldor 1.4.0" -D PACKAGE_BUGREPORT="aldor@xinutec.org" -D PACKAGE_URL="" -D PACKAGE="aldor" -D VERSION="1.4.0" -D YYTEXT_POINTER=1 -D HAVE_STDIO_H=1 -D HAVE_STDLIB_H=1 -D HAVE_STRING_H=1 -D HAVE_INTTYPES_H=1 -D HAVE_STDINT_H=1 -D HAVE_STRINGS_H=1 -D HAVE_SYS_STAT_H=1 -D HAVE_SYS_TYPES_H=1 -D HAVE_UNISTD_H=1 -D STDC_HEADERS=1 -D HAVE_LIBREADLINE=1 -D HAVE_READLINE_READLINE_H=1 -D HAVE_READLINE_HISTORY=1 -D HAVE_READLINE_HISTORY_H=1 -D USE_GLOOP_SHELL=1 -D GENERATOR_COROUTINES=0 -D HAVE_DLFCN_H=1 -D LT_OBJDIR=".libs/" -I . -D VCSVERSION="2c53e759f1e00e345f8b172e7139debda72fda13" -internal-isystem /usr/local/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-empty-body -Wno-enum-compare -Wno-missing-field-initializers -Wno-unused -Wno-unused-parameter -Wno-error=format -Wno-error=type-limits -Wno-error=strict-aliasing -Wno-sign-compare -Wno-error=shift-negative-value -Wno-error=clobbered -std=c99 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2026-01-15-223856-845667-1 -x c tinfer.c
1/****************************************************************************
*
* tinfer.c: Type inference.
*
* Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
*
***************************************************************************/

9#include "ablogic.h"
10#include "abpretty.h"
11#include "comsg.h"
12#include "debug.h"
13#include "fluid.h"
14#include "format.h"
15#include "lib.h"

17#include "opsys.h"
18#include "sefo.h"
19#include "spesym.h"
20#include "stab.h"
21#include "store.h"
22#include "strops.h"
23#include "syme.h"
24#include "table.h"
25#include "tconst.h"
26#include "terror.h"
27#include "tfcond.h"
28#include "tfsat.h"
29#include "ti_bup.h"
30#include "ti_sef.h"
31#include "ti_tdn.h"
32#include "ti_top.h"
33#include "tinfer.h"
34#include "tposs.h"
35#include "tqual.h"


38/*****************************************************************************
*
* :: Selective debug stuff
*
****************************************************************************/

44Bool	tipAddDebug		= false((int) 0);
45Bool	tipApplyDebug		= false((int) 0);
46Bool	tipAssignDebug		= false((int) 0);
47Bool	tipDeclareDebug		= false((int) 0);
48Bool	tipDefineDebug		= false((int) 0);
49Bool	tipFarDebug		= false((int) 0);
50Bool	tipIdDebug		= false((int) 0);
51Bool	tipLitDebug		= false((int) 0);
52Bool	tipEmbedDebug		= false((int) 0);
53Bool	tipExtendDebug		= false((int) 0);

55Bool	titfDebug		= false((int) 0);
56Bool	titfOneDebug		= false((int) 0);
57Bool	titfStabDebug		= false((int) 0);
58Bool	abExpandDebug		= false((int) 0);

60extern Bool symeRefreshDebug;

62#define titfDEBUGif (!titfDebug) { } else afprintf		DEBUG_IF(titf)if (!titfDebug) { } else		afprintf
63#define titfOneDEBUGif (!titfOneDebug) { } else afprintf		DEBUG_IF(titfOne)if (!titfOneDebug) { } else	afprintf
64#define titfStabDEBUGif (!titfStabDebug) { } else afprintf		DEBUG_IF(titfStab)if (!titfStabDebug) { } else	afprintf
65#define abExpandDEBUGif (!abExpandDebug) { } else afprintf		DEBUG_IF(abExpand)if (!abExpandDebug) { } else	afprintf
66#define symeRefreshDEBUGif (!symeRefreshDebug) { } else afprintf	DEBUG_IF(symeRefresh)if (!symeRefreshDebug) { } else	afprintf

68extern Bool tipExtendDebug;
69#define tipExtendDEBUGif (!tipExtendDebug) { } else afprintf		DEBUG_IF(tipExtend)if (!tipExtendDebug) { } else	afprintf

71void
72tiReportStore(String s)
73{
static ULong	obytes = 0;
ULong		nbytes = stoBytesAlloc;

if (nbytes > obytes) {
if (s) fprintf(osStdout, "%s", s);
fprintf(osStdout, "Store  %8ld B  delta  %8ld\n",
	nbytes, nbytes - obytes);
obytes = nbytes;
}
83}

85/*****************************************************************************
*
* :: Local Declarations
*
****************************************************************************/

91/*
* DefaultState
*/

95enum def_state {
DEF_State_No,		/* No special action for defaults. */
DEF_State_NotYet,	/* Skip defaults when walking an absyn. */
DEF_State_Yes,		/* Walk defaults when walking an absyn. */
DEF_State_LIMIT
100};

102typedef Enum(def_state)enum def_state	DefaultState;

104/* typeInferTForms helper functions. */

106localstatic SymbolList	tiTfDeclarees		= 0;
107localstatic SymbolList	tiTfDefinees		= 0;
108localstatic DefaultState	tiTfDoingDefault	= DEF_State_No;

110localstatic SymbolList	tiTfGetDeclarees	(TFormUses);
111localstatic SymbolList	tiTfPushDeclarees	(SymbolList);
112localstatic void		tiTfPopDeclarees	(SymbolList);

114localstatic Symbol		tiTfUsesSymbol		(TFormUses);
115localstatic void		tiTfPushDefinee0	(Symbol);

117localstatic Bool		tiTfIsBoundary		(TFormUses);

119/* typeInferTForms cases. */

121localstatic void		tiTfOne			(Stab, TFormUses, TForm);
122localstatic void		tiTfSort		(Stab, TFormUsesList);
123localstatic void		tiTfCycle		(Stab, TFormUsesList);
124localstatic void		tiTfDefault		(Stab, TFormUsesList);
125localstatic Bool		tiTfDefaultSyntax	(Stab, TForm);
126localstatic void		tiTfDefaultSyntaxMap	(Stab, TForm);
127localstatic Bool		tiTfDefaultSyntaxDefine	(Stab, TForm);

129extern void		tiTfPrint		(FILE *, Stab, String,
				 TFormUsesList);
131extern void		tiTfEnter		(FILE *, String,
				 TFormUses, TForm);
133extern void		tiTfExit		(FILE *, String,
				 TFormUses, TForm);

136#define tiTfPrintDb(v)if (vDebug) tiTfPrint	if (DEBUG(v)vDebug) tiTfPrint
137#define tiTfEnterDb(v)if (vDebug) tiTfEnter	if (DEBUG(v)vDebug) tiTfEnter
138#define tiTfExitDb(v)if (vDebug) tiTfExit	if (DEBUG(v)vDebug) tiTfExit

140/* typeInferTForms phases. */

142localstatic TFormUsesList	tiTfPartition		(Stab, TFormUsesList);
143localstatic TFormUsesList	tiTfSyntax		(Stab, TFormUsesList);
144localstatic TFormUsesList	tiTfSelect		(Stab, TFormUsesList);

146localstatic Bool		tiTfSyntax1		(Stab, TFormUses, TForm,
				 AbSynList);
148localstatic Bool		tiTfFloat1		(Stab, TForm);
149localstatic void		tiTfMap1		(Stab, TFormUses, TForm,
				 AbSynList);
151localstatic Bool		tiTfDefine1		(Stab, TFormUses, TForm,
				 AbSynList);
153localstatic void		tiTfThird1		(Stab, TFormUses, TForm,
				 AbSynList);
155localstatic void		tiTfCategory1		(Stab, TFormUses, TForm,
				 AbSynList);
157localstatic void		tiTfUnknown1		(Stab, TFormUses, TForm,
				 AbSynList);
159localstatic void		tiTfPending1		(Stab, TForm);
160localstatic void		tiTfBottomUp1		(Stab, TFormUses, TForm);
161localstatic void		tiTfAudit1		(Stab, TForm);
162localstatic void		tiTfTopDown1		(Stab, TForm);
163localstatic void		tiTfMeaning1		(Stab, TForm);
164localstatic void		tiTfExtend1		(Stab, TFormUses);
165localstatic void		tiTfImport1		(Stab, TFormUses);
166localstatic void		tiTfDefault1		(Stab, Sefo);
167localstatic void 		tiTfCascades1           (Stab stab, TFormUses tfu);
168/* typeInferTForms topological sorting. */

170localstatic Table		tiTfGetDeclareeTable	(TFormUsesList);
171localstatic void		tiTfFreeDeclareeTable	(Table);
172localstatic void		tiTfCollectHasDependees	(TFormUsesList, TFormUses);
173localstatic void		tiTfCollectDependees	(Table, TFormUses, TForm);
174localstatic void		tiTfCollectSefoDependees(Table, TFormUses, Sefo);
175localstatic void		tiTfCollectSymDependees	(Table, TFormUses, Symbol);
176localstatic void		tiTfAddDependee		(TFormUses, TFormUses);
177localstatic void		tiTfFreeDependees	(TFormUsesList);
178localstatic void		tiTfFreeCDependees	(TFormUsesList);

180localstatic TFormUsesList	tiTopForward		(TFormUsesList);
181localstatic TFormUsesList	tiTopReverse		(TFormUsesList);
182localstatic TFormUsesList	tiTopCForward		(TFormUsesList);
183localstatic TFormUsesList	tiTopCReverse		(TFormUsesList);
184localstatic TFormUsesList	tiTopSort		(TFormUsesList);
185localstatic TFormUsesList	tiTopCycle		(TFormUsesList);

187/* tiTopClique helper functions. */

189localstatic TFormUsesList	tiTopClique		(TFormUsesList);
190localstatic TFormUses		tiTopCliqueUnion	(TFormUsesList);
191localstatic TFormUses		tiTopCliqueRep		(TFormUses);
192localstatic void		tiTopCliqueMark		(TFormUsesList, Bool);
193localstatic void		tiTopCliqueAddVertex	(TFormUses);
194localstatic void		tiTopCliqueAddCVertex	(TFormUses);
195localstatic void		tiTopCliqueDelCVertex	(TFormUses);
196localstatic void		tiTopCliqueAddEdge	(TFormUses, TFormUses);
197localstatic void		tiTopCliqueDelEdge	(TFormUses, TFormUses);
198localstatic Bool		tiTopEqual		(TFormUses, TFormUses);

200/*****************************************************************************
*
* :: Main entry points for type inference
*
****************************************************************************/

206localstatic Bool	tqShouldImport	  (TQual);
207localstatic TForm     tiGetTopLevelTForm(AbLogic context, AbSyn type);
208localstatic Bool 	tiCheckSymeConditionalImplementation(Stab stab, Syme syme, Syme implSyme);

210void
211tinferInit()
212{
TiTopLevel topLevel = (TiTopLevel) stoAlloc(OB_Other0, sizeof(*topLevel));

topLevel->terrorTypeConstFailed = terrorTypeConstFailed;
topLevel->tiBottomUp = tiBottomUp;
topLevel->tiTopDown = tiTopDown;
topLevel->tiCanSefo = tiCanSefo;
topLevel->tiGetTopLevelTForm = tiGetTopLevelTForm;

topLevel->tiUnaryToRaw = tiUnaryToRaw;
topLevel->tiRawToUnary = tiRawToUnary;
topLevel->tiSefo = tiSefo;	
topLevel->tiTfSefo = tiTfSefo;
topLevel->typeInferTForms = typeInferTForms;

topLevel->tqShouldImport = tqShouldImport;
topLevel->typeInferTForm = typeInferTForm;

tiTopLevelInit(topLevel);

232}

234/*
* Type inference consists of two passes:


* 1) a bottom up pass which constructs a set of possible types for each node
* 2) a top down pass which restricts each node to a unique type.
*/

242TForm
243typeInferAs(Stab stab, AbSyn absyn, TForm type)
244{
if (abState(absyn)((absyn)->abHdr.state) != AB_State_HasUnique) {
tiBottomUp    (stab, absyn, type);
typeInferAudit(stab, absyn);
tiTopDown     (stab, absyn, type);
}
return abTUnique(absyn)((absyn)->abHdr.type.unique);
251}

253TForm
254typeInfer(Stab stab, AbSyn absyn)
255{
TForm	tf;

tcInit();
typeInferTForms(stab);
tf = typeInferAs(stab, absyn, tfUnknown);
tcFini();

return tf;
264}

266Bool
267typeInferAudit(Stab stab, AbSyn absyn)
268{
return terrorAuditPoss(true1, absyn);
270}

272void
273typeInferCheck(Stab stab, AbSyn absyn, TForm type)
274{
Syme	syme = abSyme(absyn)((absyn)->abHdr.seman ? (absyn)->abHdr.seman->syme :
 0);
TForm	tf;

if (abIsNothing(absyn)((absyn)->abHdr.tag == (AB_Nothing)))
return;

if (type == tfDomain && syme &&
   (symeIsLibrary(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Library) || symeIsArchive(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Archive)))
return;

if (abState(absyn)((absyn)->abHdr.state) != AB_State_HasUnique)
return;

tf = abTUnique(absyn)((absyn)->abHdr.type.unique);
if (!tfIsUnknown(tf)(((tf)->tag) == TF_Unknown) && !tfSatValues(tf, type)) {
abState(absyn)((absyn)->abHdr.state) = AB_State_Error;
abTPoss(absyn)((absyn)->abHdr.type.poss) = tpossSingleton(tf);
tiTopDown(stab, absyn, type);
}
294}

296void
297tiTfSefo(Stab stab, TForm tf)
298{
Length	i;

if (!tfNeedsSefo(tf)((tf)->state == TF_State_NeedsSefo))
return;
tfClrNeedsSefo(tf)((tf)->state = ((tf)->state == TF_State_NeedsSefo) ? TF_State_Meaning
 : (tf)->state);

if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)->
tag)) < TF_ABSYN_LIMIT) && tiCanSefo(tfGetExpr(tf)((tf)->__absyn)))
tiSefo(stab, tfGetExpr(tf)((tf)->__absyn));

if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)->
tag)) < TF_NODE_LIMIT))
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
	tiTfSefo(stab, tfArgv(tf)((tf)->argv)[i]);

if (tfTagHasSymes(tfTag(tf)((tf)->tag)) && tfSymes(tf)((tf)->symes) == listNil(Syme)((SymeList) 0)) {
tfGetSymes(stab, tf, tfExpr(tf)tfToAbSyn(tf));
}
315}

317/*
* Make sure that the category exports of context are visible in stab.
*/
320void
321tiWithSymes(Stab stab, TForm context)
322{
SymeList	mods;
SymeList	symes;
SymeList	csymes = listNil(Syme)((SymeList) 0);
SymeList	esymes = listNil(Syme)((SymeList) 0);
Stab		wstab = stab;
while (wstab && stabGetSelf(wstab) == NULL((void*)0)) wstab = cdr(wstab)((wstab)->rest);
tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, ">>tiWithSymes:\n");

mods = listNConcat(Syme)(Syme_listPointer->NConcat)(tfGetSelfFrStab(wstab),
		 listCopy(Syme)(Syme_listPointer->Copy)(tfGetCatSelf(context)));

symes = tfGetCatExports(context);

for (; symes; symes = cdr(symes)((symes)->rest)) {
Syme		syme = car(symes)((symes)->first), xsyme = NULL((void*)0);
Symbol		sym  = symeId(syme)((syme)->id);
TForm		tf   = symeType(syme);

if (DEBUG(tipAdd)tipAddDebug) {
	afprintf(dbOut, "  looking for: %pSyme\n", syme);
}

/* Look for syme in the capsule. */
if ((xsyme = stabGetExportMod(wstab, mods, sym, tf))) {
	if (tiCheckSymeConditionalImplementation(wstab, syme, xsyme))
		tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [export]\n");
	else {
		tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [conditional override]\n");
		esymes = listCons(Syme)(Syme_listPointer->Cons)(syme, esymes);
	}
}

else {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [category]\n");
	csymes = listCons(Syme)(Syme_listPointer->Cons)(syme, csymes);
}
}

for (; esymes != listNil(Syme)((SymeList) 0); esymes = cdr(esymes)((esymes)->rest)) {
Syme 	esyme = car(esymes)((esymes)->first);
Symbol	sym  = symeId(esyme)((esyme)->id);
TForm	tf   = symeType(esyme);
Syme xsyme = stabGetExportMod(wstab, mods, sym, tf);
if (symeCondition(esyme) == listNil(Sefo)((SefoList) 0)) {
	symeSetDefinitionConditions(xsyme, listNil(AbSyn))(symeSetFieldVal = ((AInt) (((AbSynList) 0))), (((((xsyme)->
kind == SYME_Trigger ? libGetAllSymes((xsyme)->lib) : ((void
*)0)), (xsyme))->locmask) & (1 << (SYFI_DefinitionConditions
))) ? (((xsyme)->fieldv)[symeIndex(xsyme,SYFI_DefinitionConditions
)] = (symeSetFieldVal)) : !((xsyme)->full) && symeSetFieldVal
 == (symeFieldInfo[SYFI_DefinitionConditions].def) ? symeSetFieldVal
 : symeSetFieldFn(xsyme,SYFI_DefinitionConditions,symeSetFieldVal
));
}
else {
	symeSetDefinitionConditions(xsyme,(symeSetFieldVal = ((AInt) ((AbSyn_listPointer->Cons)(abNewAndAll
(sposNone, (AbSynList) symeCondition(esyme)), ((AbSynList) (SYFI_DefinitionConditions
 < (8 * sizeof(int)) && !(((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
hasmask) & (1 << (SYFI_DefinitionConditions))) ? (symeFieldInfo
[SYFI_DefinitionConditions].def) : (((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
locmask) & (1 << (SYFI_DefinitionConditions))) ? ((
((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme)->
lib) : ((void*)0)), (xsyme))->locmask) & (1 << (
SYFI_DefinitionConditions))) ? ((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] : (symeFieldInfo[SYFI_DefinitionConditions
].def)) : symeGetFieldFn(xsyme,SYFI_DefinitionConditions)))))
), (((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme
)->lib) : ((void*)0)), (xsyme))->locmask) & (1 <<
 (SYFI_DefinitionConditions))) ? (((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] = (symeSetFieldVal)) : !((
xsyme)->full) && symeSetFieldVal == (symeFieldInfo
[SYFI_DefinitionConditions].def) ? symeSetFieldVal : symeSetFieldFn
(xsyme,SYFI_DefinitionConditions,symeSetFieldVal))
				    listCons(AbSyn)(abNewAndAll(sposNone,(symeSetFieldVal = ((AInt) ((AbSyn_listPointer->Cons)(abNewAndAll
(sposNone, (AbSynList) symeCondition(esyme)), ((AbSynList) (SYFI_DefinitionConditions
 < (8 * sizeof(int)) && !(((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
hasmask) & (1 << (SYFI_DefinitionConditions))) ? (symeFieldInfo
[SYFI_DefinitionConditions].def) : (((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
locmask) & (1 << (SYFI_DefinitionConditions))) ? ((
((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme)->
lib) : ((void*)0)), (xsyme))->locmask) & (1 << (
SYFI_DefinitionConditions))) ? ((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] : (symeFieldInfo[SYFI_DefinitionConditions
].def)) : symeGetFieldFn(xsyme,SYFI_DefinitionConditions)))))
), (((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme
)->lib) : ((void*)0)), (xsyme))->locmask) & (1 <<
 (SYFI_DefinitionConditions))) ? (((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] = (symeSetFieldVal)) : !((
xsyme)->full) && symeSetFieldVal == (symeFieldInfo
[SYFI_DefinitionConditions].def) ? symeSetFieldVal : symeSetFieldFn
(xsyme,SYFI_DefinitionConditions,symeSetFieldVal))
								(AbSynList) symeCondition(esyme)),(symeSetFieldVal = ((AInt) ((AbSyn_listPointer->Cons)(abNewAndAll
(sposNone, (AbSynList) symeCondition(esyme)), ((AbSynList) (SYFI_DefinitionConditions
 < (8 * sizeof(int)) && !(((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
hasmask) & (1 << (SYFI_DefinitionConditions))) ? (symeFieldInfo
[SYFI_DefinitionConditions].def) : (((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
locmask) & (1 << (SYFI_DefinitionConditions))) ? ((
((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme)->
lib) : ((void*)0)), (xsyme))->locmask) & (1 << (
SYFI_DefinitionConditions))) ? ((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] : (symeFieldInfo[SYFI_DefinitionConditions
].def)) : symeGetFieldFn(xsyme,SYFI_DefinitionConditions)))))
), (((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme
)->lib) : ((void*)0)), (xsyme))->locmask) & (1 <<
 (SYFI_DefinitionConditions))) ? (((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] = (symeSetFieldVal)) : !((
xsyme)->full) && symeSetFieldVal == (symeFieldInfo
[SYFI_DefinitionConditions].def) ? symeSetFieldVal : symeSetFieldFn
(xsyme,SYFI_DefinitionConditions,symeSetFieldVal)) 
						    symeDefinitionConditions(xsyme)))(symeSetFieldVal = ((AInt) ((AbSyn_listPointer->Cons)(abNewAndAll
(sposNone, (AbSynList) symeCondition(esyme)), ((AbSynList) (SYFI_DefinitionConditions
 < (8 * sizeof(int)) && !(((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
hasmask) & (1 << (SYFI_DefinitionConditions))) ? (symeFieldInfo
[SYFI_DefinitionConditions].def) : (((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
locmask) & (1 << (SYFI_DefinitionConditions))) ? ((
((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme)->
lib) : ((void*)0)), (xsyme))->locmask) & (1 << (
SYFI_DefinitionConditions))) ? ((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] : (symeFieldInfo[SYFI_DefinitionConditions
].def)) : symeGetFieldFn(xsyme,SYFI_DefinitionConditions)))))
), (((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme
)->lib) : ((void*)0)), (xsyme))->locmask) & (1 <<
 (SYFI_DefinitionConditions))) ? (((xsyme)->fieldv)[symeIndex
(xsyme,SYFI_DefinitionConditions)] = (symeSetFieldVal)) : !((
xsyme)->full) && symeSetFieldVal == (symeFieldInfo
[SYFI_DefinitionConditions].def) ? symeSetFieldVal : symeSetFieldFn
(xsyme,SYFI_DefinitionConditions,symeSetFieldVal));
}
}


symes = symeListSubstCat(wstab, mods, context, csymes);

symes = symeListCheckWithCondition(symes);
symes = symeListMakeLazyConditions(symes);

stabPutMeanings(stab, symes);

/*!! listFree(Syme)(mods); */
listFree(Syme)(Syme_listPointer->Free)(symes);
listFree(Syme)(Syme_listPointer->Free)(csymes);

tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "<<tiWithSymes:\n");
390}

392localstatic SymeList
393symeListSetImplicit(Stab stab, SymeList symes)
394{
SymeList	result = listNil(Syme)((SymeList) 0);

for (;symes;symes = cdr(symes)((symes)->rest))
{
Syme	syme	= car(symes)((symes)->first);
Symbol	id	= symeId(syme)((syme)->id);
TForm	tf	= symeType(syme);


/* Look for this syme in the stab */
syme = stabDefExport(stab, id, tf, (Doc)0);


/* Syme must not have a const lib: it's local */
if (symeConstLib(syme)) symeSetConstLib(syme, (Lib)0);


/* Mark as implicit */
symeSetImplicit(syme)(symeSetFieldVal = ((AInt) (((AInt) (SYFI_ExtraBits < (8 *
 sizeof(int)) && !(((((syme)->kind == SYME_Trigger
 ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->
hasmask) & (1 << (SYFI_ExtraBits))) ? (symeFieldInfo
[SYFI_ExtraBits].def) : (((((syme)->kind == SYME_Trigger ?
 libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->locmask
) & (1 << (SYFI_ExtraBits))) ? ((((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_ExtraBits)))
 ? ((syme)->fieldv)[symeIndex(syme,SYFI_ExtraBits)] : (symeFieldInfo
[SYFI_ExtraBits].def)) : symeGetFieldFn(syme,SYFI_ExtraBits))
) | (0x0001))), (((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->locmask) & (1
 << (SYFI_ExtraBits))) ? (((syme)->fieldv)[symeIndex
(syme,SYFI_ExtraBits)] = (symeSetFieldVal)) : !((syme)->full
) && symeSetFieldVal == (symeFieldInfo[SYFI_ExtraBits
].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_ExtraBits
,symeSetFieldVal));;


/* Add to the list of results */
result = listCons(Syme)(Syme_listPointer->Cons)(syme, result);
}

return result;
421}

423localstatic Bool
424tiCheckSymeConditionalImplementation(Stab stab, Syme syme, Syme implSyme)
425{
SefoList condition = symeCondition(syme);
AbSynList implCondition = symeDefinitionConditions(implSyme)((AbSynList) (SYFI_DefinitionConditions < (8 * sizeof(int)
) && !(((((implSyme)->kind == SYME_Trigger ? libGetAllSymes
((implSyme)->lib) : ((void*)0)), (implSyme))->hasmask) &
 (1 << (SYFI_DefinitionConditions))) ? (symeFieldInfo[SYFI_DefinitionConditions
].def) : (((((implSyme)->kind == SYME_Trigger ? libGetAllSymes
((implSyme)->lib) : ((void*)0)), (implSyme))->locmask) &
 (1 << (SYFI_DefinitionConditions))) ? ((((((implSyme)->
kind == SYME_Trigger ? libGetAllSymes((implSyme)->lib) : (
(void*)0)), (implSyme))->locmask) & (1 << (SYFI_DefinitionConditions
))) ? ((implSyme)->fieldv)[symeIndex(implSyme,SYFI_DefinitionConditions
)] : (symeFieldInfo[SYFI_DefinitionConditions].def)) : symeGetFieldFn
(implSyme,SYFI_DefinitionConditions)));
AbSynList tmp;
SefoList tmpSefo;
AbLogic implAbLog, conditionAbLog;
Bool result;

if (implCondition == listNil(AbSyn)((AbSynList) 0))
return true1;
/* Need to check that implCondition implies condition */
/* First, unconditional implies it does */
for (tmp = implCondition; tmp != listNil(AbSyn)((AbSynList) 0); tmp = cdr(tmp)((tmp)->rest)) {
if (car(tmp)((tmp)->first) == NULL((void*)0))
	return true1;
}

for (tmp = implCondition; tmp != listNil(AbSyn)((AbSynList) 0); tmp = cdr(tmp)((tmp)->rest)) {
tiBottomUp(stab, car(tmp)((tmp)->first), tfUnknown);
tiTopDown(stab, car(tmp)((tmp)->first), tfUnknown);
}

implAbLog = ablogFalse();
for (tmp = implCondition; tmp != listNil(AbSyn)((AbSynList) 0); tmp = cdr(tmp)((tmp)->rest)) {
implAbLog = ablogOr(ablogFrSefo(car(tmp)((tmp)->first)), implAbLog);
}
conditionAbLog = ablogTrue();
for (tmpSefo = condition; tmpSefo != listNil(Sefo)((SefoList) 0); tmpSefo = cdr(tmpSefo)((tmpSefo)->rest)) {
conditionAbLog = ablogAnd(ablogFrSefo(car(tmpSefo)((tmpSefo)->first)), conditionAbLog);
}

result = ablogImplies(conditionAbLog,
	      ablogAnd(abCondKnown != NULL((void*)0)
		       ? abCondKnown
		       : ablogTrue(),
		       implAbLog));

return result;
463}

465/*
* Make sure that the category exports of context are visible in capsule.
* Return the symes which could not be found in the add. Tell the caller
* about symes we've added to the stab.
*/
470SymeList
471tiAddSymes(Stab astab, AbSyn capsule, TForm base, TForm context, SymeList *p)
472{
Bool		hasImplicit;
SymeList	mods;
SymeList	symes;
SymeList	isymes = listNil(Syme)((SymeList) 0);
SymeList	asymes = listNil(Syme)((SymeList) 0);
SymeList	csymes = listNil(Syme)((SymeList) 0);
SymeList	dsymes = listNil(Syme)((SymeList) 0);
SymeList	usymes = listNil(Syme)((SymeList) 0);
SymeList	aself  = tfGetSelfFrStab(astab);
Syme		asyme  = (aself ? car(aself)((aself)->first) : NULL((void*)0));

tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "(tiAddSymes:\n");


/*
* If the caller wants to know which symes we have added to
* the stab then we MUST initialise our workspace now.
*/
if (p) *p = listNil(Syme)((SymeList) 0);


/* We can't do anything with unknown contexts */
tfFollow(context)((context) = tfFollowFn(context));
if (tfIsUnknown(context)(((context)->tag) == TF_Unknown))
return dsymes;

/* Does the context satisfy DenseStorageCategory? */
hasImplicit = tfCatHasImplicit(context);


mods = listNConcat(Syme)(Syme_listPointer->NConcat)(listCopy(Syme)(Syme_listPointer->Copy)(tfGetDomSelf(base)),
		 listCopy(Syme)(Syme_listPointer->Copy)(tfGetCatSelf(context)));
mods = listNConcat(Syme)(Syme_listPointer->NConcat)(aself, mods);

symes = tfGetCatExports(context);	
for ( ; symes; symes = cdr(symes)((symes)->rest)) {
Syme		syme = car(symes)((symes)->first), xsyme = NULL((void*)0);
Symbol		sym  = symeId(syme)((syme)->id);
TForm		tf   = symeType(syme);

tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  looking for: %pSyme %pAbSynList ", syme, symeCondition(syme));

/* Look for syme in the capsule. */
if ((xsyme = stabGetDomainExportMod(astab, mods, sym, tf)) != NULL((void*)0)
    && tiCheckSymeConditionalImplementation(astab, syme, xsyme)) {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [export]\n");
	symeImplAddInherit(xsyme, base, syme);
}

/* Look for syme in the base. */
else if ((xsyme = tfHasDomExportMod(base, mods, sym, tf))
	 != NULL((void*)0)) {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [add chain]\n");
	/*!! if (!symeIsSelfSelf(xsyme)) */
		asymes = listCons(Syme)(Syme_listPointer->Cons)(xsyme, asymes);
}

/* Look for syme in the defaults. */
else if (symeHasDefault(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0080))) {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [default]\n");
	/*!! if (!symeIsSelfSelf(syme)) */
		csymes = listCons(Syme)(Syme_listPointer->Cons)(syme, csymes);
}

/* Look for the syme in the implicits */
else if (hasImplicit &&
	((xsyme = tfImplicitExport(astab,mods,syme))!=NULL((void*)0))) {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [implicit]\n");
	isymes = listCons(Syme)(Syme_listPointer->Cons)(xsyme, isymes);
}

/* Look for syme in the conditional symes. */
else if (symeCondition(syme)) {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [conditional]\n");
	/*!! if (!symeIsSelfSelf(syme)) */
		usymes = listCons(Syme)(Syme_listPointer->Cons)(syme, usymes);
}

/* The add doesn't satisfy its context. */
else {
	tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "  [missing]\n");
	dsymes = listCons(Syme)(Syme_listPointer->Cons)(syme, dsymes);
}
}

if (asymes != listNil(Syme)((SymeList) 0)) {
symes = symeListSubstCat(astab, mods, tfUnknown, asymes);
stabPutMeanings(astab, symes);
if (p) *p = listNConcat(Syme)(Syme_listPointer->NConcat)(*p, listCopy(Syme)(Syme_listPointer->Copy)(symes));
listFree(Syme)(Syme_listPointer->Free)(symes);
}

if (isymes != listNil(Syme)((SymeList) 0)) { /* IMPLICIT */
SymeList symes;
symes = symeListSubstCat(astab, mods, tfUnknown, isymes);
symes = symeListSetImplicit(astab, symes);
/* ******************** CHECK THIS ******************** */
/* No need to stabPutMeanings as they ought to be there */
/* ******************** CHECK THIS ******************** */
if (p) *p = listNConcat(Syme)(Syme_listPointer->NConcat)(*p, listCopy(Syme)(Syme_listPointer->Copy)(symes));
listFree(Syme)(Syme_listPointer->Free)(symes);
}

if (csymes != listNil(Syme)((SymeList) 0)) {
SymeList symes;
csymes = symeListSubstCat(astab, mods, context, csymes);
symes = symeListCheckAddConditions(csymes);
stabPutMeanings(astab, symes);
if (p) *p = listNConcat(Syme)(Syme_listPointer->NConcat)(*p, listCopy(Syme)(Syme_listPointer->Copy)(symes));
listFree(Syme)(Syme_listPointer->Free)(symes);
}

if (usymes != listNil(Syme)((SymeList) 0)) {
SymeList symes;
symes = symeListSubstCat(astab, mods, context, usymes);
symes = symeListCheckAddConditions(symes);
dsymes = listNConcat(Syme)(Syme_listPointer->NConcat)(symes, dsymes);
}
if (asyme && (asymes || csymes || dsymes || isymes)
  && !symeIsExtend(asyme)(((((asyme)->kind == SYME_Trigger ? libGetAllSymes((asyme)
->lib) : ((void*)0)), (asyme))->kind) == SYME_Extend))
{
Syme	xself = stabDefExtend(astab, ssymSelf, context);
symeAddExtendee(xself, asyme);
symeSetExtension(asyme, xself)symeXSetExtension(asyme, (AInt) xself);
stabExtendMeanings(astab, xself);
}

/*!! listFree(Syme)(mods); */
listFree(Syme)(Syme_listPointer->Free)(asymes);
/*!! listFree(Syme)(isymes); */

tipAddDEBUGif (!tipAddDebug) { } else afprintf(dbOut, "tiAddSymes %pSymeList)\n", dsymes);

dsymes = listNReverse(Syme)(Syme_listPointer->NReverse)(dsymes);
return dsymes;
608}

610localstatic TForm 
611tiGetTopLevelTForm(AbLogic context, AbSyn type)
612{
TForm tf;

tf = tiGetTFormContext(stabFile(), context, type);
1
Calling 'tiGetTFormContext'→

return tf;
618}

620/*
*  Get a cached or create and cache a new type form for the expression.
*  It is most likely placed there by scobind.
*/
624TForm
625tiGetTForm(Stab stab, AbSyn type)
626{
return tiGetTFormContext(stab, ablogTrue(), type);
628}

630TForm
631tiGetTFormContext(Stab stab, AbLogic context, AbSyn type)
632{
TForm	tf, ntf;

if (abTForm(type)((type)->abHdr.seman ? (type)->abHdr.seman->tform : 0
)) {
2
←
Assuming field 'seman' is null→
3
←
'?' condition is false→
/* This is a little hacky... we just want to ensure
 * that if 'type' has an attached tform, then that
 * tform in turn should have a decent looking sefo
 * attached */
abSetTForm(type, tfFollowFn(abTForm(type)((type)->abHdr.seman ? (type)->abHdr.seman->tform : 0
)));
if (!tfHasExpr(abTForm(type))((((type)->abHdr.seman ? (type)->abHdr.seman->tform :
 0))->__absyn != 0))
	tfToAbSyn(abTForm(type)((type)->abHdr.seman ? (type)->abHdr.seman->tform : 0
));
}
tf  = abTForm(type)((type)->abHdr.seman ? (type)->abHdr.seman->tform : 0
) ? (abTForm(type)((type)->abHdr.seman ? (type)->abHdr.seman->tform : 0
)) : tfSyntaxFrAbSyn(stab, type);
4
←
Taking false branch→
5
←
'?' condition is false→
6
←
'?' condition is false→

/* Transfer semantics from type to tf. */
if (abIsSefo(type)(((type)->abHdr.state) == AB_State_HasUnique) && tfHasExpr(tf)((tf)->__absyn != 0) && !abIsSefo(tfGetExpr(tf))(((((tf)->__absyn))->abHdr.state) == AB_State_HasUnique
)) {
7
←
Assuming field 'state' is not equal to AB_State_HasUnique→
abTransferSemantics(type, tfGetExpr(tf)((tf)->__absyn));
}

if (!tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning)) {
8
←
Assuming field 'state' is >= TF_State_Meaning→
9
←
Taking false branch→
tfMergeConditions(tf, stab, tfCondEltNewKnown(stab, context));
}

ntf = typeInferTForm(stab, tf);
10
←
Calling 'typeInferTForm'→
tfTransferSemantics(ntf, tf);

/* Transfer semantics from tf to type. */
if (type != tfGetExpr(tf)((tf)->__absyn))
if (!abIsSefo(type)(((type)->abHdr.state) == AB_State_HasUnique) &&
    abIsSefo(tfGetExpr(ntf))(((((ntf)->__absyn))->abHdr.state) == AB_State_HasUnique
) && !tfIsUnknown(tfTUnique(ntf))(((((((ntf)->__absyn))->abHdr.type.unique))->tag) ==
 TF_Unknown))
	abTransferSemantics(tfGetExpr(ntf)((ntf)->__absyn), type);

if (!abIsSefo(type)(((type)->abHdr.state) == AB_State_HasUnique)) {
abState(type)((type)->abHdr.state) = AB_State_HasUnique;
abTUnique(type)((type)->abHdr.type.unique) = tfUnknown;
}

tfFollow(tf)((tf) = tfFollowFn(tf));
return abSetTForm(type, tf);
671}

673Bool
674tiMergeSyme(Syme syme, SymeList symes)
675{
SymeList sl = symes;

while (sl != listNil(Syme)((SymeList) 0)) {
if (symeEqualModConditions(listNil(Syme)((SymeList) 0), syme, car(sl)((sl)->first)))
	return false((int) 0);
sl = cdr(sl)((sl)->rest);
}
return true1;
684}

686Syme
687tiGetMeaning(Stab stab, AbSyn absyn, TForm type)
688{
SatMask		mask = tfSatBupMask();
Length		nsymec, psymec;
Syme		nsyme, psyme, syme;
SymeList	symes, nsymes, sl;

symes = stabGetMeanings(stab, abCondKnown, abIdSym(absyn)((absyn)->abId.sym));
nsymes = listNil(Syme)((SymeList) 0);		/* Possible (non-pending) meanings */
nsymec = 0;			/* Number of non-pending matches */
psymec = 0;			/* Number of all possible matches */
nsyme = NULL((void*)0);
psyme = NULL((void*)0);

for (sl = symes; sl; sl = cdr(sl)((sl)->rest)) {
Syme	syme = car(sl)((sl)->first);
TForm	mtype = symeType(syme);
SatMask	result;

result = tfSat1(mask, absyn, mtype, type);
if (tfSatSucceed(result)) {
	if (!tfSatPending(result)
	    && symeUseIdentifier(absyn, syme)
	    && tiMergeSyme(syme, nsymes)) {
		nsymec += 1;
		nsyme = syme;
		nsymes = listCons(Syme)(Syme_listPointer->Cons)(syme, nsymes);
	}
	psymec += 1;
	psyme = syme;
}

}

syme = NULL((void*)0);
if (psymec == 1 && !tfIsUnknown(symeType(psyme))(((symeType(psyme))->tag) == TF_Unknown))
syme = psyme;

else if (nsymec == 1 && !tfIsUnknown(symeType(nsyme))(((symeType(nsyme))->tag) == TF_Unknown))
syme = nsyme;

else if (nsymec == 0 && psymec > 0)
terrorApplyNotAnalyzed(absyn, absyn, type);

else
terrorNotUniqueMeaning(ALDOR_E_TinNMeanings165, absyn, nsymes,
		       symes, symString(abIdSym(absyn))((((absyn)->abId.sym))->str), type);

listFree(Syme)(Syme_listPointer->Free)(nsymes);

return syme;
738}

740Syme
741tiGetExtendee(Stab stab, AbSyn absyn, TForm type)
742{
Symbol		sym = absyn->abId.sym;
int		n;
SymeList	ml0, ml, okSymes = listNil(Syme)((SymeList) 0);
Syme		syme = NULL((void*)0);

ml0 = stabGetMeanings(stab, abCondKnown, sym);

for (n = 0, ml = ml0; ml; ml = cdr(ml)((ml)->rest)) {
Syme	msyme = car(ml)((ml)->first);
TForm	mtype = symeType(msyme);
if (tfCanExtend(mtype, type)) {
	if (n > 0) okSymes = listCons(Syme)(Syme_listPointer->Cons)(syme, okSymes);
	syme = msyme;
	n += 1;
}
}

if (n != 1 || tfIsUnknown(symeType(syme))(((symeType(syme))->tag) == TF_Unknown)) {
if (n > 0) okSymes = listCons(Syme)(Syme_listPointer->Cons)(syme, okSymes);
terrorNotUniqueMeaning(ALDOR_E_TinNMeanings165, absyn, okSymes, ml0,
		       symString(sym)((sym)->str), type);

syme = NULL((void*)0);
}

listFree(Syme)(Syme_listPointer->Free)(okSymes);

return syme;
771}

773localstatic Bool tiCheckLambda0(TForm tf);

775Bool
776tiCheckLambdaType(TForm tf)
777{
if (tfIsDomainMap(tf) || tfIsCategoryMap(tf))
return false((int) 0);

return tiCheckLambda0(tf);
782}

784localstatic Bool
785tiCheckLambda0(TForm tf)
786{
if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))
tiCheckLambda0(tfMapRet(tf)tfFollowArg(tf, 1));

return !(tfSatDom(tf) || tfSatCat(tf));
791}


794/*****************************************************************************
*
* :: Packed map embeddings
*
****************************************************************************/

800localstatic AbSyn
801abNewRawOf(AbSyn arg)
802{
AbSyn	op = abNewId(abPos(arg), symIntern("raw"))abNew(AB_Id, (spstackFirst((arg)->abHdr.pos)),1, symProbe(
"raw", 1 | 2));
AbSyn	ab = abNewApply1(abPos(arg), op, arg)abNew(AB_Apply, (spstackFirst((arg)->abHdr.pos)),2, op,arg
);

return ab;
807}

809localstatic AbSyn
810abNewBoxOf(AbSyn arg)
811{
AbSyn	op = abNewId(abPos(arg), symIntern("box"))abNew(AB_Id, (spstackFirst((arg)->abHdr.pos)),1, symProbe(
"box", 1 | 2));
AbSyn	ab = abNewApply1(abPos(arg), op, arg)abNew(AB_Apply, (spstackFirst((arg)->abHdr.pos)),2, op,arg
);

return ab;
816}

818Bool
819tiUnaryToRaw(Stab stab, AbSyn ab, TForm tf)
820{
AbSyn	imp = abImplicit(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->implicit : 0
);

if (!imp) {
imp = sefoCopy(ab);
if (abState(imp)((imp)->abHdr.state) != AB_State_HasUnique) {
	abState(imp)((imp)->abHdr.state) = AB_State_HasUnique;
	abTUnique(imp)((imp)->abHdr.type.unique) = tf;
}
imp = abNewRawOf(imp);
abSetImplicit(ab, imp);
}

tiBottomUp(stab, imp, tfUnknown);
tiTopDown (stab, imp, tfUnknown);
if (abState(imp)((imp)->abHdr.state) == AB_State_HasUnique) {
abAddTContext(ab, AB_Embed_UnaryToRaw(((AbEmbed) 1) << 10));
return true1;
}
else
return false((int) 0);
841}

843Bool
844tiRawToUnary(Stab stab, AbSyn ab, TForm tf)
845{
AbSyn	imp = abImplicit(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->implicit : 0
);

if (!imp) {
imp = sefoCopy(ab);
if (abState(imp)((imp)->abHdr.state) != AB_State_HasUnique) {
	abState(imp)((imp)->abHdr.state) = AB_State_HasUnique;
	abTUnique(imp)((imp)->abHdr.type.unique) = tf;
}
imp = abNewBoxOf(abNewRawOf(imp));
abSetImplicit(ab, imp);
}

tiBottomUp(stab, imp, tf);
tiTopDown (stab, imp, tf);
if (abState(imp)((imp)->abHdr.state) == AB_State_HasUnique) {
abAddTContext(ab, AB_Embed_RawToUnary(((AbEmbed) 1) << 11));
return true1;
}
else
return false((int) 0);
866}

868/*****************************************************************************
*
* :: tiDefine
*
****************************************************************************/

874TForm
875tiDefineFilter(AbSyn absyn, TForm type)
876{
AbSyn		lhs = absyn->abDefine.lhs;
if (abHasTag(lhs, AB_Declare)((lhs)->abHdr.tag == (AB_Declare)))
return abTForm(lhs->abDeclare.type)((lhs->abDeclare.type)->abHdr.seman ? (lhs->abDeclare
.type)->abHdr.seman->tform : 0);
else
return type;
882}

884TPoss
885tiDefineTPoss(AbSyn absyn)
886{
AbSyn		lhs = absyn->abDefine.lhs;
if (abHasTag(lhs, AB_Declare)((lhs)->abHdr.tag == (AB_Declare)))
return abReferTPoss(lhs);
else
return abReferTPoss(absyn);
892}

894/*****************************************************************************
*
* :: typeInferTForms
*
****************************************************************************/

900TForm
901typeInferTForm(Stab stab, TForm tf)
902{
DefaultState	wasDoingDefaults = tiTfDoingDefault;
tfFollow(tf)((tf) = tfFollowFn(tf));

tiTfDoingDefault = DEF_State_Yes;
tiTfOne(stab, NULL((void*)0), tf);
11
←
Calling 'tiTfOne'→
tiTfDoingDefault = wasDoingDefaults;

return tf;
911}

913void
914typeInferTForms(Stab stab)
915{
TFormUsesList	tful0, tful1, tful2, tful;
static ULong	serialNo = 0, depthNo = 0, serialMax = 0;
ULong		serialThis;

/* Maybe should check cdr(stab), and use extreme caution */


if (car(stab)((stab)->first)->isChecked) return;
car(stab)((stab)->first)->isChecked = true1;

tful0 = listReverse(TFormUses)(TFormUses_listPointer->Reverse)(car(stab)((stab)->first)->tformsUsed.list);

serialNo += 1;
depthNo  += 1;
serialThis = serialNo;
if (serialMax == 0) serialMax = stabMaxSerialNo();
tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, stab, ">>typeInferTForms:", tful0);
titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "->Titf: %*s%ld/%ld\n", (int)depthNo, "",
      serialThis, serialMax);

for (tful = tful0; tful; tful = tful1) {
DefaultState	wasDoingDefaults = tiTfDoingDefault;

if (false((int) 0)) {
	tiTfDoingDefault = DEF_State_NotYet;
	tiTfOne(stab, car(tful)((tful)->first), car(tful)((tful)->first)->tf);
	tiTfDoingDefault = DEF_State_Yes;
	tiTfDefault(stab, tful);
}
else if (cdr(tful)((tful)->rest) == NULL((void*)0) || tiTfIsBoundary(car(tful)((tful)->first))) {
	tiTfDoingDefault = DEF_State_Yes;
	tful1 = cdr(tful)((tful)->rest);
	tiTfOne(stab, car(tful)((tful)->first), car(tful)((tful)->first)->tf);
}
else {
	tful1 = tiTfPartition(stab, tful);
	tful2 = listCopyTo(TFormUses)(TFormUses_listPointer->CopyTo)(tful, tful1);

	tiTfDoingDefault = DEF_State_NotYet;
	tiTfSort(stab, tful2);
	tiTfDoingDefault = DEF_State_Yes;
	tiTfDefault(stab, tful2);
	listFree(TFormUses)(TFormUses_listPointer->Free)(tful2);
}
tiTfDoingDefault = wasDoingDefaults;
}

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "<-Titf: %*s%ld/%ld\n", (int)depthNo, "",
      serialThis, serialMax);
tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, stab, "<<typeInferTForms:", tful0);
depthNo -=1;

listFree(TFormUses)(TFormUses_listPointer->Free)(tful0);
969}

971localstatic void
972tiTfSort(Stab stab, TFormUsesList tful0)
973{
Table		tbl;
TFormUsesList	tful, before, cycle, after;
Bool		allBefore = false((int) 0);
titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[sorting %d tfus]\n",
      (int) listLength(TFormUses)(TFormUses_listPointer->_Length)(tful0));

/* Collect the type forms used to declare each symbol. */
tbl = tiTfGetDeclareeTable(tful0);
		      
/* Collect the type forms used to declare symbols in each type form. */
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest))
tiTfCollectDependees(tbl, car(tful)((tful)->first), car(tful)((tful)->first)->tf);

/* Collect the dependencies which arise from has questions. */
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest))
tiTfCollectHasDependees(tful0, car(tful)((tful)->first));

/* Free the table of type forms used to declare each symbol. */
tiTfFreeDeclareeTable(tbl);

/* Perform a topological sort on the type forms. */
before = tiTopForward	(tful0);
after  = tiTopReverse	(tful0);
cycle  = tiTopCycle	(tful0);

if (DEBUG(titf)titfDebug) {
tiTfPrint(dbOut, stab, ">>tiTfSort[before]:", before);
tiTfPrint(dbOut, stab, ">>tiTfSort[after ]:", after);
tiTfPrint(dbOut, stab, ">>tiTfSort[cycle ]:", cycle);
}
if (DEBUG(titfStab)titfStabDebug) {
allBefore = (!cycle && !after);
if (allBefore) fprintf(dbOut, "[all before]\n");
}

/* Process the type forms in before. */
if (DEBUG(titfStab)titfStabDebug) {
if (!allBefore)
	fprintf(dbOut, "[%d before]",
		(int) listLength(TFormUses)(TFormUses_listPointer->_Length)(before));
}
for (tful = before; tful; tful = cdr(tful)((tful)->rest)) {
if (DEBUG(titfStab)titfStabDebug) {
	if (!allBefore)
		fprintf(dbOut, ".");
}
tiTfOne(stab, car(tful)((tful)->first), car(tful)((tful)->first)->tf);
}
if (DEBUG(titfStab)titfStabDebug) {if (!allBefore) fnewline(dbOut);}

/* Process the type forms in cycle. */
if (cycle) {
TFormUsesList	clique = tiTopClique(cycle);
titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[%d cliques]\n",
	      (int) listLength(TFormUses)(TFormUses_listPointer->_Length)(clique));
for (tful = clique; tful; tful = cdr(tful)((tful)->rest)) {
	TFormUsesList	clq = car(tful)((tful)->first)->cdependents;
	titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[clique]\n");
	tiTfCycle(stab, clq);
}
tiTfFreeCDependees(clique);
listFree(TFormUses)(TFormUses_listPointer->Free)(clique);
}

/* Process the type forms in after. */
if (DEBUG(titfStab)titfStabDebug) {
if (!allBefore)
	fprintf(dbOut, "[%d after]",
		(int) listLength(TFormUses)(TFormUses_listPointer->_Length)(after));
}
for (tful = after; tful; tful = cdr(tful)((tful)->rest)) {
titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, ".");
tiTfOne(stab, car(tful)((tful)->first), car(tful)((tful)->first)->tf);
}
if (DEBUG(titfStab)titfStabDebug) {if (!allBefore) fnewline(dbOut);}

/* Free the lists of dependencies between type forms. */
tiTfFreeDependees(tful0);

listFree(TFormUses)(TFormUses_listPointer->Free)(before);
listFree(TFormUses)(TFormUses_listPointer->Free)(after);
listFree(TFormUses)(TFormUses_listPointer->Free)(cycle);
1056}

1058localstatic void
1059tiTfOne(Stab stab, TFormUses tfu, TForm tf)
1060{
tiTfEnterDb(titf)if (titfDebug) tiTfEnter(dbOut, "tiTfOne", tfu, tf);
12
←
Assuming 'titfDebug' is 0→
13
←
Taking false branch→

/* tfu == NULL just means that typeInferTForm doesn't have a tfu. */

if (tiTfSyntax1(stab, tfu, tf, listNil(AbSyn)((AbSynList) 0))) {
14
←
Calling 'tiTfSyntax1'→
if (tfu == NULL((void*)0)) return;
}

if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax) || tfIsPending(tf)(((tf)->state)==TF_State_Pending) || tfu == NULL((void*)0)) {
tiTfPending1	(stab, tf);
tiTfBottomUp1	(stab, tfu, tf);
tiTfAudit1	(stab, tf);
tiTfTopDown1	(stab, tf);
tiTfMeaning1	(stab, tf);
}

if (tfu) {
tiTfExtend1(stab, tfu);
tiTfImport1(stab, tfu);
tiTfCascades1(stab, tfu);
}

tiTfExitDb(titf)if (titfDebug) tiTfExit(dbOut, "tiTfOne", tfu, tf);
1084}

1086localstatic void
1087tiTfCycle(Stab stab, TFormUsesList tful)
1088{
TFormUsesList	tful0, tfl;

tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, stab, ">>tiTfCycle:", tful);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[syntax]\n");
tful  = tiTfSyntax	(stab, tful);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[select]\n");
tful0 = tiTfSelect	(stab, tful);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[pending]\n");
for (tfl=tful0; tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfPending1(stab, car(tfl)((tfl)->first)->tf);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[bottom up]\n");
for (tfl=tful0; tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfBottomUp1(stab, car(tfl)((tfl)->first), car(tfl)((tfl)->first)->tf);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[audit]\n");
for (tfl=tful0; tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfAudit1(stab, car(tfl)((tfl)->first)->tf);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[top down]\n");
for (tfl=tful0; tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfTopDown1(stab, car(tfl)((tfl)->first)->tf);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[meaning]\n");
for (tfl=tful0; tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfMeaning1(stab, car(tfl)((tfl)->first)->tf);

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[extend]\n");
for (tfl=tful;  tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfExtend1(stab, car(tfl)((tfl)->first));

titfStabDEBUGif (!titfStabDebug) { } else afprintf(dbOut, "[import]\n");
for (tfl=tful;  tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfImport1(stab, car(tfl)((tfl)->first));

for (tfl=tful;  tfl; tfl=cdr(tfl)((tfl)->rest))
tiTfCascades1(stab, car(tfl)((tfl)->first));

tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, stab, "<<titfCycle:", tful);

listFree(TFormUses)(TFormUses_listPointer->Free)(tful0);
1133}

1135localstatic void
1136tiTfDefault(Stab stab, TFormUsesList tful0)
1137{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TForm		tf = car(tful)((tful)->first)->tf;

if (!tiTfDefaultSyntax(stab, tf))
	tiTfDefault1(stab, tfGetExpr(tf)((tf)->__absyn));
}

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest))
tiTfImport1(stab, car(tful)((tful)->first));
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest))
tiTfCascades1(stab, car(tful)((tful)->first));
1151}

1153localstatic Bool
1154tiTfDefaultSyntax(Stab stab, TForm tf)
1155{
Bool	result = true1;

if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) 
tiTfDefaultSyntaxMap(stab, tf);

else if (tfIsDefine(tf)(((tf)->tag) == TF_Define))
result = tiTfDefaultSyntaxDefine(stab, tf);

else
result = false((int) 0);

return result;
1168}

1170localstatic void
1171tiTfDefaultSyntaxMap(Stab stab, TForm tf)
1172{
AbSyn	ab = tfGetExpr(tf)((tf)->__absyn);
Stab	nstab = (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) ? abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) : stab);
TForm	tfarg = tfMapArg(tf)tfFollowArg(tf, 0);
TForm	tfret = tfMapRet(tf)tfFollowArg(tf, 1);

tiTfDefault1(nstab, tfGetExpr(tfarg)((tfarg)->__absyn));
if (!tiTfDefaultSyntax(nstab, tfret))
tiTfDefault1(nstab, tfGetExpr(tfret)((tfret)->__absyn));
1181}

1183localstatic Bool
1184tiTfDefaultSyntaxDefine(Stab stab, TForm tf)
1185{
TForm	tfd = tfDefineDecl(tf)tfFollowArg(tf, 0);
AbSyn	abd = tfGetExpr(tfd)((tfd)->__absyn);
Bool	result = true1;

if (abd && abHasTag(abd, AB_Declare)((abd)->abHdr.tag == (AB_Declare)))
abd = abd->abDeclare.type;
else
return false((int) 0);

if (!abd)
result = false((int) 0);

else if (abIsTheId(abd, ssymCategory)(((abd)->abHdr.tag == (AB_Id)) && ((abd)->abId.
sym)==(ssymCategory))) {
tiTfDefault1(stab, abd);
tiTfDefault1(stab, tfGetExpr(tfDefineVal(tf))((tfFollowArg(tf, 1))->__absyn));
}

else if (abHasTag(abd, AB_With)((abd)->abHdr.tag == (AB_With))) {
tiTfDefault1(stab, abd);
/* default inside an add means something else */
}

else
result = false((int) 0);

return result;
1212}

1214void
1215tiTfPrint(FILE *fout, Stab stab, String str, TFormUsesList tful0)
1216{
TFormUsesList	tful;
Length		i;

fprintf(dbOut, "%s\n", str);
if (stab) {
fprintf(dbOut, "Symbol Table Level %ld.",
	car(stab)((stab)->first)->lexicalLevel);
findent += 2;
fnewline(dbOut);
fprintf(dbOut, "Declaree stack is: ");
listPrint(Symbol)(Symbol_listPointer->Print)(dbOut, tiTfDeclarees, symPrint);
fnewline(dbOut);
fprintf(dbOut, "Definee stack is: ");
listPrint(Symbol)(Symbol_listPointer->Print)(dbOut, tiTfDefinees, symPrint);
fnewline(dbOut);
fprintf(dbOut, "Pending type forms:");
if (tful0) fnewline(dbOut);
}

for (i = 0, tful = tful0; tful; i += 1, tful = cdr(tful)((tful)->rest)) {
fnewline(dbOut);
fprintf(dbOut, "%d. ", (int) i);
tfuPrint(dbOut, car(tful)((tful)->first));
}

findent -= 2;
fnewline(dbOut);
1244}

1246void
1247tiTfEnter(FILE *fout, String str, TFormUses tfu, TForm tf)
1248{
fprintf(fout, ">>%s:\n", str);
findent += 2;
fnewline(fout);
if (tfu) tfuPrint(fout, tfu); else tfPrint(fout, tf);
findent -= 2;
fnewline(fout);
1255}

1257void
1258tiTfExit(FILE *fout, String str, TFormUses tfu, TForm tf)
1259{
fprintf(fout, "<<%s:\n", str);
findent += 2;
fnewline(fout);
if (tfu) tfuPrint(fout, tfu); else tfPrint(fout, tf);
findent -= 2;
fnewline(fout);
1266}

1268/*****************************************************************************
*
* :: typeInferTForms helper functions
*
****************************************************************************/

1274localstatic SymbolList
1275tiTfGetDeclarees(TFormUses tfu)
1276{
TForm	tf;

if (tfu == 0) return listNil(Symbol)((SymbolList) 0);

tf = tfu->tf;
tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfIsWith(tf)(((tf)->tag) == TF_With) || (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && tfIsWith(tfMapRet(tf))(((tfFollowArg(tf, 1))->tag) == TF_With)))
return tfu->declarees;
else
return listNil(Symbol)((SymbolList) 0);
1288}

1290localstatic SymbolList
1291tiTfPushDeclarees(SymbolList sl)
1292{
SymbolList	ol = tiTfDeclarees;
tiTfDeclarees = listNConcat(Symbol)(Symbol_listPointer->NConcat)(listCopy(Symbol)(Symbol_listPointer->Copy)(sl),
			    tiTfDeclarees);
return ol;
1297}

1299localstatic void
1300tiTfPopDeclarees(SymbolList ol)
1301{
tiTfDeclarees = listFreeTo(Symbol)(Symbol_listPointer->FreeTo)(tiTfDeclarees, ol);
1303}

1305localstatic Symbol
1306tiTfUsesSymbol(TFormUses tfu)
1307{
Symbol	sym = NULL((void*)0);

if (tfu && tfu->declarees && cdr(tfu->declarees)((tfu->declarees)->rest) == listNil(Symbol)((SymbolList) 0))
sym = car(tfu->declarees)((tfu->declarees)->first);
return sym;
1313}

1315localstatic void
1316tiTfPushDefinee0(Symbol sym)
1317{
tiTfDefinees = listCons(Symbol)(Symbol_listPointer->Cons)(sym, tiTfDefinees);
1319}

1321void
1322tiTfPushDefinee(AbSyn lhs)
1323{
Symbol	sym;

if (abTag(lhs)((lhs)->abHdr.tag) == AB_Comma) {
int i;
for (i=0; i<abArgc(lhs)((lhs)->abHdr.argc); i++) {
	tiTfPushDefinee(lhs->abComma.argv[i]);
}
}
else {
lhs = abDefineeIdOrElse(lhs, NULL((void*)0));
sym = lhs ? lhs->abId.sym : NULL((void*)0);
tiTfPushDefinee0(sym);
}
1337}

1339void
1340tiTfPopDefinee(AbSyn lhs)
1341{
if (abTag(lhs)((lhs)->abHdr.tag) == AB_Comma) {
int i;
for (i=0; i<abArgc(lhs)((lhs)->abHdr.argc); i++) {
	tiTfPopDefinee(lhs->abComma.argv[i]);
}
}
else {
tiTfDefinees = listFreeCons(Symbol)(Symbol_listPointer->FreeCons)(tiTfDefinees);
}

1352}

1354void
1355tiTfPopDefinee0(Symbol sym)
1356{
tiTfDefinees = listFreeCons(Symbol)(Symbol_listPointer->FreeCons)(tiTfDefinees);
1358}

1360Bool
1361tiTfDoDefault(Sefo sefo)
1362{
/* Skip AB_Default trees if we will traverse them later. */
if (abTag(sefo)((sefo)->abHdr.tag) != AB_Default)
return true1;
if (tiTfDoingDefault == DEF_State_NotYet)
return false((int) 0);
return true1;
1369}

1371localstatic Bool
1372tiTfIsBoundary(TFormUses tfu)
1373{
return tfu->isExplicitImport || tfu->isParamImport;
1375}

1377localstatic Bool
1378tqShouldImport(TQual tq)
1379{
TForm	tf;
Symbol	sym = NULL((void*)0);

if (tq == NULL((void*)0))
return false((int) 0);

tf = tqBase(tq)((tq)->base);

tfFollow(tf)((tf) = tfFollowFn(tf));
if (tfIsNotDomain(tf)((((tf)->tag) == TF_Type) || (((tf)->tag) == TF_With) ||
 ((((tf)->tag) == TF_Syntax) && ((((tf)->__absyn
))->abHdr.tag == (AB_With))) || (((tf)->tag) == TF_Join
) || (((tf)->tag) == TF_If) || (((tf)->tag) == TF_Third
)) || tfSatDom(tf) || tfSatCat(tf))
return false((int) 0);

if (tfIsVariable(tf)(((tf)->tag) == TF_Variable) || tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) || tfIsMulti(tf)(((tf)->tag) == TF_Multiple))
return false((int) 0);

if (tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id))
sym = tfIdSym(tf)(((tf)->__absyn)->abId.sym);
else if (tfIsApply(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Apply) && abTag(tfApplyOp(tf))(((((tf)->__absyn)->abApply.op))->abHdr.tag) == AB_Id)
sym = tfApplyOp(tf)(((tf)->__absyn)->abApply.op)->abId.sym;
else
return true1;

if (sym == ssymSelf)
return false((int) 0);

if (listMemq(Symbol)(Symbol_listPointer->Memq)(tiTfDeclarees, sym) ||
   listMemq(Symbol)(Symbol_listPointer->Memq)(tiTfDefinees,  sym))
return false((int) 0);

return true1;
1410}

1412/*****************************************************************************
*
* :: typeInferTForms phases
*
****************************************************************************/

1418/* Return the first group of tforms from tful which s/b inferred as a group. */
1419localstatic TFormUsesList
1420tiTfPartition(Stab stab, TFormUsesList tful0)
1421{
TFormUsesList	tful;

for (tful = cdr(tful0)((tful0)->rest); tful; tful = cdr(tful)((tful)->rest))
if (tiTfIsBoundary(car(tful)((tful)->first)))
	break;

return tful;
1429}

1431/* Fill in syntax type forms which appear as type form components. */
1432localstatic TFormUsesList
1433tiTfSyntax(Stab stab, TFormUsesList tful0)
1434{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest))
tiTfSyntax1(stab, car(tful)((tful)->first), car(tful)((tful)->first)->tf, listNil(AbSyn)((AbSynList) 0));

return tful0;
1441}

1443/* Select the syntax type forms. */
1444localstatic TFormUsesList
1445tiTfSelect(Stab stab, TFormUsesList tful)
1446{
TFormUsesList	tful0 = listNil(TFormUses)((TFormUsesList) 0);

tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, stab, ">>tiTfSelect:", tful);

for (; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);

if (tfIsSyntax(tfu->tf)(((tfu->tf)->tag) == TF_Syntax))
	tful0 = listCons(TFormUses)(TFormUses_listPointer->Cons)(tfu, tful0);
}

tful0 = listNReverse(TFormUses)(TFormUses_listPointer->NReverse)(tful0);

tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, stab, "<<tiTfSelect:", tful0);

return tful0;
1463}

1465localstatic Bool
1466tiTfSyntax1(Stab stab, TFormUses tfu, TForm tf, AbSynList params)
1467{
Bool	result = true1;

if (!tfIsPending(tf)(((tf)->state)==TF_State_Pending))
15
←
Assuming field 'state' is equal to TF_State_Pending→
16
←
Taking false branch→
result = false((int) 0);

else if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
17
←
Assuming field 'tag' is not equal to TF_Syntax→
result = tiTfFloat1(stab, tf);

else if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))
18
←
Taking false branch→
19
←
Assuming field 'tag' is not equal to TF_Map→
20
←
Assuming field 'tag' is not equal to TF_PackedMap→
21
←
Taking false branch→
tiTfMap1(stab, tfu, tf, params);

else if (tfIsDefine(tf)(((tf)->tag) == TF_Define))
22
←
Assuming field 'tag' is equal to TF_Define→
23
←
Taking true branch→
result = tiTfDefine1(stab, tfu, tf, params);
24
←
Calling 'tiTfDefine1'→

else
result = false((int) 0);

return result;
1486}

1488localstatic Bool
1489tiTfFloat1(Stab stab, TForm tf)
1490{
TForm	ntf;
Stab	nstab;

nstab = tfFloat(stab, tf);
if (nstab == NULL((void*)0))
return false((int) 0);

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfFloat1", NULL((void*)0), tf);

ntf = typeInferTForm(nstab, tf);
tfTransferSemantics(ntf, tf);

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfFloat1", NULL((void*)0), tf);

return true1;
1506}

1508localstatic void
1509tiTfMap1(Stab stab, TFormUses tfu, TForm tf, AbSynList params)
1510{
AbSyn	ab = tfGetExpr(tf)((tf)->__absyn);
Stab	nstab = (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) ? abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) : stab);
TForm	tfarg = tfMapArg(tf)tfFollowArg(tf, 0);
TForm	tfret = tfMapRet(tf)tfFollowArg(tf, 1);
Length	i;

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfMap1", NULL((void*)0), tf);

if (nstab != stab) {
stabSeeOuterImports(nstab);
stabGetSubstable(nstab);
typeInferTForms(nstab);
}

if (tfIsMulti(tfarg)(((tfarg)->tag) == TF_Multiple))
for (i = 0; i < tfArgc(tfarg)((tfarg)->argc); i += 1)
	typeInferTForm(nstab, tfFollowArg(tfarg, i));
typeInferTForm(nstab, tfarg);

params = listCons(AbSyn)(AbSyn_listPointer->Cons)(abMapArg(ab)((ab)->abApply.argv[0]), params);
if (!tiTfSyntax1(nstab, tfu, tfret, params))
typeInferTForm(nstab, tfret);
listFreeCons(AbSyn)(AbSyn_listPointer->FreeCons)(params);

tiTfBottomUp1	(stab, tfu, tf);
tiTfAudit1	(stab, tf);
tiTfTopDown1	(stab, tf);
tiTfMeaning1	(stab, tf);

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfMap1", NULL((void*)0), tf);
1541}

1543localstatic Bool
1544tiTfDefine1(Stab stab, TFormUses tfu, TForm tf, AbSynList params)
1545{
TForm	tfd = tfDefineDecl(tf)tfFollowArg(tf, 0);
AbSyn	abd = tfGetExpr(tfd)((tfd)->__absyn);
Bool	result = true1;

if (abd && abHasTag(abd, AB_Declare)((abd)->abHdr.tag == (AB_Declare)))
25
←
Assuming 'abd' is non-null→
26
←
Assuming field 'tag' is equal to AB_Declare→
27
←
Taking true branch→
abd = abd->abDeclare.type;
else
return false((int) 0);

if (!abd)
28
←
Assuming 'abd' is non-null→
29
←
Taking false branch→
result = false((int) 0);

else if (abIsUnknown(abd)((abd)->abHdr.tag == (AB_Blank)))
30
←
Assuming field 'tag' is not equal to AB_Blank→
tiTfUnknown1(stab, tfu, tf, params);

else if (abIsTheId(abd, ssymCategory)(((abd)->abHdr.tag == (AB_Id)) && ((abd)->abId.
sym)==(ssymCategory)))
31
←
Taking false branch→
32
←
Assuming field 'tag' is equal to AB_Id→
33
←
Assuming 'ssymCategory' is equal to field 'sym'→
34
←
Taking true branch→
tiTfThird1(stab, tfu, tf, params);
35
←
Calling 'tiTfThird1'→

else /* if (abHasTag(abd, AB_With)) */
tiTfCategory1(stab, tfu, tf, params);

return result;
1568}

1570localstatic void
1571tiTfThird1(Stab stab, TFormUses tfu, TForm tf, AbSynList params)
1572{
TForm	tfc = tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0);
TForm	tfw = tfDefineVal(tf)tfFollowArg(tf, 1);
Symbol	sym = tiTfUsesSymbol(tfu);
AbSyn	ab, abc, abw;

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfThird1", tfu, tf);
36
←
Assuming 'titfOneDebug' is 0→
37
←
Taking false branch→

tiTfPushDefinee0(sym);

abw = tfExpr(tfw)tfToAbSyn(tfw);

typeInferAs(stab, abw, tfCategory);

tiTfOne(stab, NULL((void*)0), tfw);
/* typeInferTForm(stab, tfw); */
if (tfIsSyntax(tfc)(((tfc)->tag) == TF_Syntax))
38
←
Assuming field 'tag' is not equal to TF_Syntax→
39
←
Taking false branch→
tfForwardFrSyntax(tfc, tfThirdFrTForm(tfw));
tiTfPopDefinee0(sym);

ab  = tfExpr(tf)tfToAbSyn(tf);
abc = abDefineDecl(ab)((ab)->abDefine.lhs)->abDeclare.type;
abw = abDefineVal(ab)((ab)->abDefine.rhs);

abTransferSemantics(tfGetExpr(tfc)((tfc)->__absyn), abc);
abTransferSemantics(tfGetExpr(tfw)((tfw)->__absyn), abw);

abSetPos(abc, abPos(tfGetExpr(tfc)))((abc)->abHdr.pos=spstackSetFirst ((abc)->abHdr.pos,((spstackFirst
((((tfc)->__absyn))->abHdr.pos)))));
abSetPos(abw, abPos(tfGetExpr(tfw)))((abw)->abHdr.pos=spstackSetFirst ((abw)->abHdr.pos,((spstackFirst
((((tfw)->__absyn))->abHdr.pos)))));

if (abState(ab)((ab)->abHdr.state) != AB_State_HasUnique) {
40
←
Assuming field 'state' is equal to AB_State_HasUnique→
41
←
Taking false branch→
abTUnique(ab)((ab)->abHdr.type.unique) = tfType;
abState(ab)((ab)->abHdr.state) = AB_State_HasUnique;
}

tfFollow(tfc)((tfc) = tfFollowFn(tfc));
tfSetPending(tfc)(((tfc)->state)=TF_State_Pending);
tfSetPending(tf)(((tf)->state)=TF_State_Pending);

if (sym && sym != ssymJoin) {
42
←
Assuming 'sym' is non-null→
43
←
Assuming 'sym' is not equal to 'ssymJoin'→
44
←
Taking true branch→
AbSyn		abd;
TForm		tfd;
Syme		pp;
AbSynList	pl;
Stab		nstab = (abStab(abw)((abw)->abHdr.seman ? (abw)->abHdr.seman->stab : 0) ? abStab(abw)((abw)->abHdr.seman ? (abw)->abHdr.seman->stab : 0) : stab);
45
←
Assuming field 'seman' is non-null→
46
←
'?' condition is true→
47
←
Assuming the condition is true→
48
←
'?' condition is true→
49
←
Assuming field 'seman' is null→
50
←
'?' condition is false→
51
←
'nstab' initialized to a null pointer value→

abd = abNewDefineLhs(sym, params);
tfd = tiGetTForm(stab, abd);
pp = symeNewExport(ssymSelfSelf, tfd, car(nstab)((nstab)->first));
52
←
Access to field 'first' results in a dereference of a null pointer (loaded from variable 'nstab')
symeSetDefault(pp)(((((pp)->kind == SYME_Trigger ? libGetAllSymes((pp)->lib
) : ((void*)0)), (pp))->bits) |= (0x0080));
tfSetSymes(tfc, listCons(Syme)(pp, listNil(Syme)))((tfc)->symes = ((Syme_listPointer->Cons)(pp, ((SymeList
) 0))));
}

tfSetMeaning(tfc)(((tfc)->state)=TF_State_Meaning);
tfCheckConsts(tfc);

tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
tfCheckConsts(tf);
tiTfMeaning1(stab, tf);

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfThird1", tfu, tf);
1633}

1635/*
* This function adds as many symes from the specified list to
* the symes of tf as possible. We leave out %% symes because
* they cause too many problems and probably ought not to be
* seen in tfSymes() for add bodies. Hopefully this function
* won't be invoked too many times (just once for each add in
* a program) so its O(N^2) cost won't hurt too much.
*/
1643localstatic void
1644tiAppendSymes(TForm tf, SymeList symes)
1645{
SymeList originals = tfSymes(tf)((tf)->symes);
SymeList additions = listNil(Syme)((SymeList) 0);


/* Check each syme in symes */
for (;symes;symes = cdr(symes)((symes)->rest))
{
Syme syme = car(symes)((symes)->first);


/* Skip %% */
if (symeIsSelfSelf(syme)(((syme)->id) == ssymSelfSelf)) continue;


/* Skip symes already in tfSymes(tf) */
if (symeListMember(syme, originals, symeEqual)) continue;


/* Remember this additional syme */
additions = listCons(Syme)(Syme_listPointer->Cons)(syme, additions);
}


/* Do nothing if nothing to add */
if (!additions) return;


/* Reverse the new list */
additions = listNReverse(Syme)(Syme_listPointer->NReverse)(additions);


/* Debugging */
if (DEBUG(symeRefresh)symeRefreshDebug) {
(void)fprintf(dbOut, "-----------> (extra)\n");
symeListPrintDb(additions);
(void)fprintf(dbOut, "\n\n");
}


/* Append onto tfSymes(tf) */
originals = listNConcat(Syme)(Syme_listPointer->NConcat)(originals, additions);


/* Unnecessary, but makes things obvious */
tfSetSymes(tf, originals)((tf)->symes = (originals));
1691}


1694localstatic void
1695tiTfCategory1(Stab stab, TFormUses tfu, TForm tf, AbSynList params)
1696{
TForm	tfw = tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0);
TForm	tfa = tfDefineVal(tf)tfFollowArg(tf, 1);
Symbol	sym = tiTfUsesSymbol(tfu);
AbSyn	ab, abw, aba, abt = NULL((void*)0);
Stab	nstab;

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfCategory1", NULL((void*)0), tf);

tiTfPushDefinee0(sym);

typeInferTForm(stab, tfw);

/* Process the add tform (tfa) to get the add symes, but
* without analyzing the add body, to avoid unnecessary
* dependencies between type forms.
* The add body will be analyzed in its normal sequence.
*/
aba = tfGetExpr(tfa)((tfa)->__absyn);
if (tfIsSyntax(tfa)(((tfa)->tag) == TF_Syntax))
tfForwardFrSyntax(tfa, tfPending(stab, aba));
tfFollow(tfa)((tfa) = tfFollowFn(tfa));

/* Identify % in the add body (aba) with the definee. */
if (abTag(aba)((aba)->abHdr.tag) == AB_Sequence && abArgc(aba)((aba)->abHdr.argc) > 0)
aba = abArgv(aba)((aba)->abGen.data.argv)[abArgc(aba)((aba)->abHdr.argc) - 1];
nstab = abStab(aba)((aba)->abHdr.seman ? (aba)->abHdr.seman->stab : 0);
if (nstab == NULL((void*)0)) nstab = stab;

if (sym) {
SymeList	aself  = tfGetSelfFrStab(nstab);
Syme		asyme  = (aself ? car(aself)((aself)->first) : NULL((void*)0));
Syme		xsyme;
AbSyn		abd;
AbSynList	pl;
TForm		tfd, val;

if (asyme) {
	Stab	istab = (params ? stab : nstab);
	abd = abNewDefineLhs(sym, params);
	tfd = tfSyntaxFrAbSyn(istab, abd);
	tfd = tfDefineOfType(tfd);
	xsyme = stabDefExtend(nstab, ssymSelf, tfd);
	symeAddExtendee(xsyme, asyme);
	symeSetExtension(asyme, xsyme)symeXSetExtension(asyme, (AInt) xsyme);
	stabExtendMeanings(nstab, xsyme);

	if (nstab != stab) {
		stabSeeOuterImports(nstab);
		stabGetSubstable(nstab);
	}

	typeInferAs(istab, abd, tfType);
	val = tfDefineVal(tfd)tfFollowArg(tfd, 1);
	if (tfIsSyntax(val)(((val)->tag) == TF_Syntax)) {
		tfMeaningFrSyntax(istab, abd, val);
		tfSetMeaningArgs(tfd);
	}
	abt = abd;
}
}

if (nstab != stab) {
stabSeeOuterImports(nstab);
stabGetSubstable(nstab);
}

if (nstab != stab) {
/*!! Try to fill the types for parameterized add symes. */
if (params) typeInferTForms(nstab);
tfSetSymes(tfa, stabGetExportedSymes(nstab))((tfa)->symes = (stabGetExportedSymes(nstab)));
tfGetSelf(nstab, tfa);
}
tfSetMeaning(tfa)(((tfa)->state)=TF_State_Meaning);
tfCheckConsts(tfa);

tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
tfCheckConsts(tf);

if (abTag(aba)((aba)->abHdr.tag) == AB_Add) {
AbSyn		base    = aba->abAdd.base;
AbSyn		capsule = aba->abAdd.capsule;
AbSynList	extl = tfu ? tfu->extension : NULL((void*)0);
SymeList	extras;

tiGetTForm(nstab, base);
for (; extl; extl = cdr(extl)((extl)->rest)) {
	AbSyn	ab0 = car(extl)((extl)->first);
	Syme	syme = abSyme(ab0)((ab0)->abHdr.seman ? (ab0)->abHdr.seman->syme : 0);
	Syme	extension = symeExtension(syme);
	TForm	tf = symeType(extension);
	Syme	osyme;

	assert(ab0 && abHasTag(ab0, AB_Id))do { if (!(ab0 && ((ab0)->abHdr.tag == (AB_Id)))) _do_assert
(("ab0 && abHasTag(ab0, AB_Id)"),"tinfer.c",1789); } while
 (0);
	assert(syme && symeIsExport(syme))do { if (!(syme && (((((syme)->kind == SYME_Trigger
 ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->
kind) == SYME_Export))) _do_assert(("syme && symeIsExport(syme)"
),"tinfer.c",1790); } while (0);
	assert(extension && symeIsExtend(extension))do { if (!(extension && (((((extension)->kind == SYME_Trigger
 ? libGetAllSymes((extension)->lib) : ((void*)0)), (extension
))->kind) == SYME_Extend))) _do_assert(("extension && symeIsExtend(extension)"
),"tinfer.c",1791); } while (0);
	assert(listMemq(Syme)(symeExtendee(extension), syme))do { if (!((Syme_listPointer->Memq)(symeExtendee(extension
), syme))) _do_assert(("listMemq(Syme)(symeExtendee(extension), syme)"
),"tinfer.c",1792); } while (0);

	osyme = tiGetExtendee(stab, ab0, tf);
	if (osyme) {
		TForm	otf = symeType(osyme);
		if (tfIsAnyMap(otf)((((otf)->tag) == TF_Map) || (((otf)->tag) == TF_PackedMap
)))
			otf = tfExtendeeSubst(nstab, otf, tf);
		tiWithSymes(nstab, otf);
	}
}
tiAddSymes(nstab, capsule, abTForm(base)((base)->abHdr.seman ? (base)->abHdr.seman->tform : 0
), tfw, &extras);

/* When is tfu allowed to be NULL? */
if (tfu) {
	listFree(AbSyn)(AbSyn_listPointer->Free)(tfu->extension);
	tfu->extension = NULL((void*)0);
}

/* Add the new symes to tfSymes for the add */
tiAppendSymes(tfa, extras);
}
if (abt && tfu)
tfu->extension = listCons(AbSyn)(AbSyn_listPointer->Cons)(abt, listNil(AbSyn)((AbSynList) 0));

tiTfPopDefinee0(sym);

ab  = tfExpr(tf)tfToAbSyn(tf);
abw = abDefineDecl(ab)((ab)->abDefine.lhs)->abDeclare.type;
aba = abDefineVal(ab)((ab)->abDefine.rhs);

abTransferSemantics(tfGetExpr(tfw)((tfw)->__absyn), abw);
abTransferSemantics(tfGetExpr(tfa)((tfa)->__absyn), aba);

abSetPos(abw, abPos(tfGetExpr(tfw)))((abw)->abHdr.pos=spstackSetFirst ((abw)->abHdr.pos,((spstackFirst
((((tfw)->__absyn))->abHdr.pos)))));
abSetPos(aba, abPos(tfGetExpr(tfa)))((aba)->abHdr.pos=spstackSetFirst ((aba)->abHdr.pos,((spstackFirst
((((tfa)->__absyn))->abHdr.pos)))));

if (abState(ab)((ab)->abHdr.state) != AB_State_HasUnique) {
abTUnique(ab)((ab)->abHdr.type.unique) = tfType;
abState(ab)((ab)->abHdr.state) = AB_State_HasUnique;
}
tiTfMeaning1(stab, tfDefineDecl(tf)tfFollowArg(tf, 0));
tiTfMeaning1(stab, tf);

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfCategory1", NULL((void*)0), tf);
1836}

1838localstatic void
1839tiTfUnknown1(Stab stab, TFormUses tfu, TForm tf, AbSynList params)
1840{
TForm	tfl = tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0);
TForm	tfr = tfDefineVal(tf)tfFollowArg(tf, 1);
Symbol	sym = tiTfUsesSymbol(tfu);
AbSyn	ab, abl, abr;

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfUnknown1", NULL((void*)0), tf);

tiTfPushDefinee0(sym);

typeInferAs(stab, tfExpr(tfr)tfToAbSyn(tfr), tfUnknown);
if (tfIsSyntax(tfr)(((tfr)->tag) == TF_Syntax))
tfMeaningFrSyntax(stab, tfGetExpr(tfr)((tfr)->__absyn), tfr);
tfFollow(tfr)((tfr) = tfFollowFn(tfr));

typeInferTForm(stab, tfl);

tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
tfCheckConsts(tf);

tiTfPopDefinee0(sym);

ab  = tfExpr(tf)tfToAbSyn(tf);
abl = abDefineDecl(ab)((ab)->abDefine.lhs)->abDeclare.type;
abr = abDefineVal(ab)((ab)->abDefine.rhs);

abTransferSemantics(tfGetExpr(tfl)((tfl)->__absyn), abl);
abTransferSemantics(tfGetExpr(tfr)((tfr)->__absyn), abr);

abSetPos(abl, abPos(tfGetExpr(tfl)))((abl)->abHdr.pos=spstackSetFirst ((abl)->abHdr.pos,((spstackFirst
((((tfl)->__absyn))->abHdr.pos)))));
abSetPos(abr, abPos(tfGetExpr(tfr)))((abr)->abHdr.pos=spstackSetFirst ((abr)->abHdr.pos,((spstackFirst
((((tfr)->__absyn))->abHdr.pos)))));

if (abState(ab)((ab)->abHdr.state) != AB_State_HasUnique) {
abTUnique(ab)((ab)->abHdr.type.unique) = tfType;
abState(ab)((ab)->abHdr.state) = AB_State_HasUnique;
}
tiTfMeaning1(stab, tf);

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfUnknown1", NULL((void*)0), tf);
1879}

1881/* Convert syntax tforms to pending tforms. */
1882localstatic void
1883tiTfPending1(Stab stab, TForm tf)
1884{
tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfPending1", NULL((void*)0), tf);
tfPendingFrSyntax(stab, tfGetExpr(tf)((tf)->__absyn), tf);
tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfPending1", NULL((void*)0), tf);
1888}

1890localstatic AbLogic tiTfCondition(Stab stab, TForm tf);
1891/* Perform bottom-up analysis to generate tposs sets. */
1892localstatic void
1893tiTfBottomUp1(Stab stab, TFormUses tfu, TForm tf)
1894{
Scope("tiTfBottomUp1")String scopeName = ("tiTfBottomUp1"); int fluidLevel0 = (scopeLevel
++, fluidLevel);
SymbolList	ol = listNil(Symbol)((SymbolList) 0);
AbSyn		absyn = tfGetExpr(tf)((tf)->__absyn);
TForm		type = tfTypeTuple;
AbLogic    fluid(abCondKnown)fluidSave_abCondKnown = ( fluidStack = (fluidLevel==fluidLimit
) ? fluidGrow() : fluidStack, fluidStack[fluidLevel].scopeName
 = scopeName, fluidStack[fluidLevel].scopeLevel = scopeLevel,
 fluidStack[fluidLevel].pglobal = (Pointer) &(abCondKnown
), fluidStack[fluidLevel].pstack = (Pointer) &fluidSave_abCondKnown
, fluidStack[fluidLevel].size = sizeof(abCondKnown), fluidLevel
++, (abCondKnown) );

abCondKnown = tiTfCondition(stab, tf);

if (abUse(absyn)((absyn)->abHdr.use) == AB_Use_Define || abUse(absyn)((absyn)->abHdr.use) == AB_Use_Assign)
type = tfUnknown;
else if (abUse(absyn)((absyn)->abHdr.use) == AB_Use_Except)
type = tfTuple(tfCategory);

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfBottomUp1", tfu, tf);
ol = tiTfPushDeclarees(tiTfGetDeclarees(tfu));
tiBottomUp(stab, absyn, type);
tiTfPopDeclarees(ol);
tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfBottomUp1", tfu, tf);

Return(Nothing){ fluidUnwind(fluidLevel0, ((int) 0)); return ;; };
1915}

1917localstatic AbLogic
1918tiTfCondition(Stab stab, TForm tf)
1919{
Scope("tiTfCondition")String scopeName = ("tiTfCondition"); int fluidLevel0 = (scopeLevel
++, fluidLevel);
AbSynList condition = tfConditionalAbSyn(tf);
AbSyn	absyn = tfGetExpr(tf)((tf)->__absyn);
AbLogic rule = ablogTrue();
AbLogic fluid(abCondKnown)fluidSave_abCondKnown = ( fluidStack = (fluidLevel==fluidLimit
) ? fluidGrow() : fluidStack, fluidStack[fluidLevel].scopeName
 = scopeName, fluidStack[fluidLevel].scopeLevel = scopeLevel,
 fluidStack[fluidLevel].pglobal = (Pointer) &(abCondKnown
), fluidStack[fluidLevel].pstack = (Pointer) &fluidSave_abCondKnown
, fluidStack[fluidLevel].size = sizeof(abCondKnown), fluidLevel
++, (abCondKnown) );

while (condition != listNil(AbSyn)((AbSynList) 0)) {
Stab cstab = stab;/*tfConditionalStab(tf);*/
AbSyn ab = car(condition)((condition)->first);

assert(cstab != NULL)do { if (!(cstab != ((void*)0))) _do_assert(("cstab != NULL")
,"tinfer.c",1930); } while (0);
if (DEBUG(titf)titfDebug) {
	afprintf(dbOut, "Condition: ");
	abPrintDb(car(condition)((condition)->first));
}
if (abContains(ab, absyn)) {
	condition = cdr(condition)((condition)->rest);
	continue;
}
abCondKnown = rule;
tiBottomUp(cstab, ab, tfUnknown);
tiTopDown (cstab, ab, tfUnknown);
rule = ablogAnd(rule, ablogFrSefo(ab));
condition = cdr(condition)((condition)->rest);
}
TfCond conds = tfConditions(tf);

Return(rule){ fluidUnwind(fluidLevel0, ((int) 0)); return rule;; };
1948}

1950/* Audit the bottom-up type analysis phase. */
1951localstatic void
1952tiTfAudit1(Stab stab, TForm tf)
1953{
tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfAudit1", NULL((void*)0), tf);
typeInferAudit(stab, tfGetExpr(tf)((tf)->__absyn));
tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfAudit1", NULL((void*)0), tf);
1957}

1959/* Perform top-down analysis to generate semantics for each AbSyn. */
1960localstatic void
1961tiTfTopDown1(Stab stab, TForm tf)
1962{
Scope("tiTfTopDown1")String scopeName = ("tiTfTopDown1"); int fluidLevel0 = (scopeLevel
++, fluidLevel);
AbSyn		absyn = tfGetExpr(tf)((tf)->__absyn);
TForm		type = tfTypeTuple;
AbLogic         fluid(abCondKnown)fluidSave_abCondKnown = ( fluidStack = (fluidLevel==fluidLimit
) ? fluidGrow() : fluidStack, fluidStack[fluidLevel].scopeName
 = scopeName, fluidStack[fluidLevel].scopeLevel = scopeLevel,
 fluidStack[fluidLevel].pglobal = (Pointer) &(abCondKnown
), fluidStack[fluidLevel].pstack = (Pointer) &fluidSave_abCondKnown
, fluidStack[fluidLevel].size = sizeof(abCondKnown), fluidLevel
++, (abCondKnown) );

abCondKnown = tiTfCondition(stab, tf);

if (abUse(absyn)((absyn)->abHdr.use) == AB_Use_Define || abUse(absyn)((absyn)->abHdr.use) == AB_Use_Assign)
type = tfUnknown;
else if (abUse(absyn)((absyn)->abHdr.use) == AB_Use_Except)
type = tfTuple(tfCategory);

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfTopDown1", NULL((void*)0), tf);
tiTopDown(stab, absyn, type);
tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfTopDown1", NULL((void*)0), tf);

Return(Nothing){ fluidUnwind(fluidLevel0, ((int) 0)); return ;; };
1980}

1982/* Convert the pending type forms to full type forms. */
1983localstatic void
1984tiTfMeaning1(Stab stab, TForm tf)
1985{
tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfMeaning1", NULL((void*)0), tf);
tfMeaning(stab, tfGetExpr(tf)((tf)->__absyn), tf);
tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfMeaning1", NULL((void*)0), tf);
1989}

1991/* Fill the extension type using the type form as the type of an extendee. */
1992localstatic void
1993tiTfExtend1(Stab stab, TFormUses tfu)
1994{
AbSynList	alist;

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfExtend1", tfu, tfu->tf);

for (alist = tfu->extendees; alist; alist = cdr(alist)((alist)->rest)) {
AbSyn	ab = car(alist)((alist)->first), abt;
Syme	syme = abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0), osyme = NULL((void*)0);
Syme	extension = symeExtension(syme);
TForm	tf = symeType(extension);
TFormUses tu0;

titfOneDEBUGif (!titfOneDebug) { } else afprintf(dbOut, "Syme: %pSyme TForm: %pTForm\n", syme, tf);

assert(ab && abHasTag(ab, AB_Id))do { if (!(ab && ((ab)->abHdr.tag == (AB_Id)))) _do_assert
(("ab && abHasTag(ab, AB_Id)"),"tinfer.c",2008); } while
 (0);
assert(syme && symeIsExport(syme))do { if (!(syme && (((((syme)->kind == SYME_Trigger
 ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->
kind) == SYME_Export))) _do_assert(("syme && symeIsExport(syme)"
),"tinfer.c",2009); } while (0);
assert(extension && symeIsExtend(extension))do { if (!(extension && (((((extension)->kind == SYME_Trigger
 ? libGetAllSymes((extension)->lib) : ((void*)0)), (extension
))->kind) == SYME_Extend))) _do_assert(("extension && symeIsExtend(extension)"
),"tinfer.c",2010); } while (0);
assert(listMemq(Syme)(symeExtendee(extension), syme))do { if (!((Syme_listPointer->Memq)(symeExtendee(extension
), syme))) _do_assert(("listMemq(Syme)(symeExtendee(extension), syme)"
),"tinfer.c",2011); } while (0);

if (tfIsExtendTemplate(tf)) {
	SymeList	extendee = symeExtendee(extension);
	Length		argc = listLength(Syme)(Syme_listPointer->_Length)(extendee);

	osyme = tiGetExtendee(stab, ab, tf);
	if (osyme == NULL((void*)0)) continue;

	tf = tfExtendEmpty(tf, argc + 1);
	symeSetType(extension, tf);

	tfExtendFill(tf, tfExtendNext(tf), symeType(osyme));
	symeAddExtendee(extension, osyme);
	symeSetExtension(osyme, extension)symeXSetExtension(osyme, (AInt) extension);
}

symeSetExtension(syme, NULL)symeXSetExtension(syme, (AInt) ((void*)0));

tfExtendFill(tf, tfExtendNext(tf), symeType(syme));

abt = tfGetExpr(symeType(syme))((symeType(syme))->__absyn);
tu0 = stabFindTFormUses(stab, abt);
abt = tu0 && tu0->extension ? car(tu0->extension)((tu0->extension)->first) : NULL((void*)0);
if (abt && osyme && abIsId(abt)((abt)->abHdr.tag == (AB_Id)) && abSyme(abt)((abt)->abHdr.seman ? (abt)->abHdr.seman->syme : 0) == osyme) {
	abState(abt)((abt)->abHdr.state) = AB_State_AbSyn;
	typeInferAs(stab, abt, tfType);
}

symeSetExtension(syme, extension)symeXSetExtension(syme, (AInt) extension);

if (tfExtendDone(tf)(tfExtendNext(tf) == (((((tf)->tag) == TF_Map) || (((tf)->
tag) == TF_PackedMap)) ? ((tfFollowArg(tf, 1))->argc) : ((
tf)->argc)))) {
	if (DEBUG(tipExtend)tipExtendDebug) {
		fprintf(dbOut, "titfExtend1:\n");
		symePrint(dbOut, extension);
		fnewline(dbOut);
	}
	tfExtendSubst(stab, tf);
	tfExtendFinish(tf);
	stabExtendMeanings(stab, extension);
}
}

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfExtend1", tfu, tfu->tf);
2055}

2057localstatic void
2058typeInferTFormList(Stab stab, TFormList tfl)
2059{
for (; tfl; tfl = cdr(tfl)((tfl)->rest)) {
TForm	tf = car(tfl)((tfl)->first);
if (tfIsJoin(tf)(((tf)->tag) == TF_Join)) {
	Length	i;
	for (i = 0; i < tfJoinArgc(tf)((tf)->argc); i += 1)
		typeInferTForm(stab, tfJoinArgN(tf, i)tfFollowArg(tf, i));
	tfSetMeaningArgs(tf);
	assert(tfIsMeaning(tf))do { if (!((((tf)->state)>=TF_State_Meaning))) _do_assert
(("tfIsMeaning(tf)"),"tinfer.c",2067); } while (0);
}
else
	typeInferTForm(stab, tf);
}
2072}

2074/* Import the exports from each type form. */
2075localstatic void
2076tiTfImport1(Stab stab, TFormUses tfu)
2077{
Scope("tiTfImport1")String scopeName = ("tiTfImport1"); int fluidLevel0 = (scopeLevel
++, fluidLevel);
AbLogic    fluid(abCondKnown)fluidSave_abCondKnown = ( fluidStack = (fluidLevel==fluidLimit
) ? fluidGrow() : fluidStack, fluidStack[fluidLevel].scopeName
 = scopeName, fluidStack[fluidLevel].scopeLevel = scopeLevel,
 fluidStack[fluidLevel].pglobal = (Pointer) &(abCondKnown
), fluidStack[fluidLevel].pstack = (Pointer) &fluidSave_abCondKnown
, fluidStack[fluidLevel].size = sizeof(abCondKnown), fluidLevel
++, (abCondKnown) );

TForm	tf = tfFollow(tfu->tf)((tfu->tf) = tfFollowFn(tfu->tf));
abCondKnown = tiTfCondition(stab, tf);

tiTfEnterDb(titfOne)if (titfOneDebug) tiTfEnter(dbOut, "tiTfImport1", tfu, tf);

if (tiTfDoingDefault == DEF_State_NotYet )
Return(Nothing){ fluidUnwind(fluidLevel0, ((int) 0)); return ;; };

if (tfu->exports)
typeInferTFormList(stab, tqQual(tfu->exports)((tfu->exports)->qual));

if (tqShouldImport(tfu->imports)) {
TQualList cascades;
typeInferTFormList(stab, tqQual(tfu->imports)((tfu->imports)->qual));

if (tfQueries(tf)((tf)->queries))
	typeInferTFormList(stab, tfQueries(tf)((tf)->queries));

cascades = stabImportFrom(stab, tfu->imports);

if (tfu != NULL((void*)0))
	tfu->cascades = cascades;
else
	tiTfImportCascades(stab, cascades);
}
else if (tfu->isCategoryImport)
tiWithSymes(stab, tf);
else if (tfu->isCatConditionImport) {
Syme self;
Stab sstab = stab;
TForm cond;
assert(sstab)do { if (!(sstab)) _do_assert(("sstab"),"tinfer.c",2112); } while
 (0); /* -- MND -- */
self = NULL((void*)0);   /* Avoid uninitialized msg */
while ( sstab && (self = stabGetSelf(sstab)) == NULL((void*)0))
	sstab = cdr(sstab)((sstab)->rest);
cond = tfIf(tfHas(self, tf), tf, tfNone()tfMulti(0));
tfSetMeaning(cond)(((cond)->state)=TF_State_Meaning);
tiWithSymes(stab, cond);
}
else if (tfu->isExplicitImport) {
String s = tfPretty(tf);
comsgWarning(abNewNothing(car(stab)->spos)abNew(AB_Nothing, ((stab)->first)->spos,0 ), ALDOR_W_StabNotImporting142, s);
strFree(s);
}

tiTfExitDb(titfOne)if (titfOneDebug) tiTfExit(dbOut, "tiTfImport1", tfu, tf);
Return(Nothing){ fluidUnwind(fluidLevel0, ((int) 0)); return ;; };
2128}

2130void
2131tiTfCascades1(Stab stab, TFormUses tfu)
2132{
tiTfImportCascades(stab, tfu->cascades);
2134}

2136void
2137tiTfImportCascades(Stab stab, TQualList list)
2138{
TQualList ql;

for (ql = list; ql; ql = cdr(ql)((ql)->rest)) {
TQual innerTq = car(ql)((ql)->first);
if (!tqShouldImport(innerTq))
	continue;
if (tqIsQualified(innerTq)((innerTq)->isQual == 1)) {
	stabImportFrom(stab, innerTq);
}
else {
	TQualList moreImports;
	TForm innerTf = tqBase(innerTq)((innerTq)->base);
	TForm tf = stabFindOuterTForm(stab, tfExpr(innerTf)tfToAbSyn(innerTf));
	if (tf != NULL((void*)0)) {
		tf = typeInferTForm(stab, tf);
		if (tfQueries(tf)((tf)->queries))
			typeInferTFormList(stab, tfQueries(tf)((tf)->queries));

		innerTf = tf;
	}
	innerTq = tqNewUnqualified(innerTf);
	moreImports = stabImportFrom(stab, innerTq);
	ql = listNConcat(TQual)(TQual_listPointer->NConcat)(ql, listCopy(TQual)(TQual_listPointer->Copy)(moreImports));
	tqFree(innerTq);
}
}
2165}


2168/* Type infer the default clauses for each type form. */
2169localstatic void
2170tiTfDefault1(Stab stab, Sefo sefo)
2171{
if (abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0
))
stab = abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0
);

if (abTag(sefo)((sefo)->abHdr.tag) == AB_Default) {
abState(sefo)((sefo)->abHdr.state) = AB_State_AbSyn;
typeInferAs(stab, sefo, tfUnknown);
}
else if (!abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
Length i;
for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1)
	tiTfDefault1(stab, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
}
2184}

2186/*****************************************************************************
*
* :: typeInferTForms topological sorting
*
****************************************************************************/

2192localstatic Table
2193tiTfGetDeclareeTable(TFormUsesList tful0)
2194{
Table		tbl = tblNew((TblHashFun) 0, (TblEqFun) 0);
TFormUsesList	tful, tfl;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
SymbolList	dl = tfu->declarees;

for (; dl; dl = cdr(dl)((dl)->rest)) {
	tfl = (TFormUsesList) tblElt(tbl, car(dl)((dl)->first),
				     listNil(TFormUses)((TFormUsesList) 0));
	tblSetElt(tbl, car(dl)((dl)->first), listCons(TFormUses)(TFormUses_listPointer->Cons)(tfu, tfl));
}
}

if (DEBUG(titf)titfDebug) {
fprintf(dbOut, ">>tiTfGetDeclareeTable:\n");
tblPrint(dbOut, tbl, (TblPrKeyFun) symPrint,
	 (TblPrEltFun) tfulPrint);
fnewline(dbOut);
}

return tbl;
2217}

2219localstatic void
2220tiTfFreeDeclareeTable(Table tbl)
2221{
tblFreeDeeply(tbl,
             (TblFreeKeyFun) 0, (TblFreeEltFun) listFree(TFormUses)(TFormUses_listPointer->Free));
2224}

2226localstatic void
2227tiTfCollectHasDependees(TFormUsesList tful, TFormUses S)
2228{
TFormList	hl;

for (hl = tfQueries(S->tf)((S->tf)->queries); hl; hl = cdr(hl)((hl)->rest)) {
TForm		cat = car(hl)((hl)->first);
TFormUsesList	tfl;
for (tfl = tful; tfl; tfl = cdr(tfl)((tfl)->rest))
	if (cat == car(tfl)((tfl)->first)->tf)
		tiTfAddDependee(S, car(tfl)((tfl)->first));
}
2238}

2240localstatic void
2241tiTfCollectDependees(Table tbl, TFormUses S, TForm tf)
2242{
Symbol		sym = tiTfUsesSymbol(S);
AbSynList	al, l;

if (sym && tfIsCategoryMap(tf))
tiTfCollectSymDependees(tbl, S, sym);
for (al = S->extendees; al; al = cdr(al)((al)->rest))
tiTfCollectSefoDependees(tbl, S, car(al)((al)->first));
tiTfCollectSefoDependees(tbl, S, tfGetExpr(tf)((tf)->__absyn));
l = tfConditionalAbSyn(tf);
while (l != listNil(AbSyn)((AbSynList) 0)) {
tiTfCollectSefoDependees(tbl, S, car(l)((l)->first));
l = cdr(l)((l)->rest);
}
2256}

2258localstatic void
2259tiTfCollectSefoDependees(Table tbl, TFormUses S, Sefo sefo)
2260{
if (abIsStrTag(abTag(sefo))( AB_STR_START <= (((sefo)->abHdr.tag)) && (((sefo
)->abHdr.tag)) < AB_STR_LIMIT)) {
Symbol		sym = NULL((void*)0);

if (abTag(sefo)((sefo)->abHdr.tag) == AB_LitInteger)
	sym = ssymTheInteger;
else if (abTag(sefo)((sefo)->abHdr.tag) == AB_LitString)
	sym = ssymTheString;
else if (abTag(sefo)((sefo)->abHdr.tag) == AB_LitFloat)
	sym = ssymTheFloat;

assert(sym)do { if (!(sym)) _do_assert(("sym"),"tinfer.c",2271); } while
 (0);
tiTfCollectSymDependees(tbl, S, sym);
}

else if (abIsSymTag(abTag(sefo))( (((sefo)->abHdr.tag)) < AB_SYM_LIMIT))
tiTfCollectSymDependees(tbl, S, abLeafSym(sefo)((sefo)->abGen.data.sym));

else if (tiTfDoDefault(sefo)) {
Length	i;
for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1)
	tiTfCollectSefoDependees(tbl, S, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
}
2283}

2285localstatic void
2286tiTfCollectSymDependees(Table tbl, TFormUses S, Symbol sym)
2287{
TFormUsesList	tfl;

tfl = (TFormUsesList) tblElt(tbl, sym, listNil(TFormUses)((TFormUsesList) 0));
for (; tfl; tfl = cdr(tfl)((tfl)->rest))
tiTfAddDependee(S, car(tfl)((tfl)->first));
2293}

2295localstatic void
2296tiTfAddDependee(TFormUses S, TFormUses T)
2297{
/* T must be type analyzed before S. */
if (S != T && !listMemq(TFormUses)(TFormUses_listPointer->Memq)(S->dependees, T)) {
listPush(TFormUses, T, S->dependees)(S->dependees = (TFormUses_listPointer->Cons)(T, S->
dependees));
listPush(TFormUses, S, T->dependents)(T->dependents = (TFormUses_listPointer->Cons)(S, T->
dependents));
T->nafter  += 1;
S->nbefore += 1;
}
2305}

2307localstatic void
2308tiTfFreeDependees(TFormUsesList tful0)
2309{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);

listFree(TFormUses)(TFormUses_listPointer->Free)(tfu->dependents);
listFree(TFormUses)(TFormUses_listPointer->Free)(tfu->dependees);

tfu->nbefore	= 0;
tfu->nafter	= 0;
tfu->dependents	= listNil(TFormUses)((TFormUsesList) 0);
tfu->dependees	= listNil(TFormUses)((TFormUsesList) 0);
}
2323}

2325localstatic void
2326tiTfFreeCDependees(TFormUsesList tful0)
2327{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);

listFree(TFormUses)(TFormUses_listPointer->Free)(tfu->cdependents);
listFree(TFormUses)(TFormUses_listPointer->Free)(tfu->cdependees);

tfu->ncbefore	= 0;
tfu->ncafter	= 0;
tfu->cdependents= listNil(TFormUses)((TFormUsesList) 0);
tfu->cdependees	= listNil(TFormUses)((TFormUsesList) 0);
}
2341}

2343localstatic TFormUsesList
2344tiTopForward(TFormUsesList tful0)
2345{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
tfu->inDegree = tfu->nbefore;
tfu->outEdges = tfu->dependents;
assert(tfu->nbefore == listLength(TFormUses)(tfu->dependees))do { if (!(tfu->nbefore == (TFormUses_listPointer->_Length
)(tfu->dependees))) _do_assert(("tfu->nbefore == listLength(TFormUses)(tfu->dependees)"
),"tinfer.c",2352); } while (0);
assert(tfu->nafter == listLength(TFormUses)(tfu->dependents))do { if (!(tfu->nafter == (TFormUses_listPointer->_Length
)(tfu->dependents))) _do_assert(("tfu->nafter == listLength(TFormUses)(tfu->dependents)"
),"tinfer.c",2353); } while (0);
}

return tiTopSort(tful0);
2357}

2359localstatic TFormUsesList
2360tiTopReverse(TFormUsesList tful0)
2361{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
tfu->inDegree = tfu->nafter;
tfu->outEdges = tfu->dependees;
assert(tfu->nbefore == listLength(TFormUses)(tfu->dependees))do { if (!(tfu->nbefore == (TFormUses_listPointer->_Length
)(tfu->dependees))) _do_assert(("tfu->nbefore == listLength(TFormUses)(tfu->dependees)"
),"tinfer.c",2368); } while (0);
assert(tfu->nafter == listLength(TFormUses)(tfu->dependents))do { if (!(tfu->nafter == (TFormUses_listPointer->_Length
)(tfu->dependents))) _do_assert(("tfu->nafter == listLength(TFormUses)(tfu->dependents)"
),"tinfer.c",2369); } while (0);
}

return listNReverse(TFormUses)(TFormUses_listPointer->NReverse)(tiTopSort(tful0));
2373}

2375localstatic TFormUsesList
2376tiTopCForward(TFormUsesList tful0)
2377{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
tfu->inDegree = tfu->ncbefore;
tfu->outEdges = tfu->cdependents;
assert(tfu->ncbefore==listLength(TFormUses)(tfu->cdependees))do { if (!(tfu->ncbefore==(TFormUses_listPointer->_Length
)(tfu->cdependees))) _do_assert(("tfu->ncbefore==listLength(TFormUses)(tfu->cdependees)"
),"tinfer.c",2384); } while (0);
assert(tfu->ncafter==listLength(TFormUses)(tfu->cdependents))do { if (!(tfu->ncafter==(TFormUses_listPointer->_Length
)(tfu->cdependents))) _do_assert(("tfu->ncafter==listLength(TFormUses)(tfu->cdependents)"
),"tinfer.c",2385); } while (0);
}

return tiTopSort(tful0);
2389}

2391localstatic TFormUsesList
2392tiTopCReverse(TFormUsesList tful0)
2393{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
tfu->inDegree = tfu->ncafter;
tfu->outEdges = tfu->cdependees;
assert(tfu->ncbefore==listLength(TFormUses)(tfu->cdependees))do { if (!(tfu->ncbefore==(TFormUses_listPointer->_Length
)(tfu->cdependees))) _do_assert(("tfu->ncbefore==listLength(TFormUses)(tfu->cdependees)"
),"tinfer.c",2400); } while (0);
assert(tfu->ncafter==listLength(TFormUses)(tfu->cdependents))do { if (!(tfu->ncafter==(TFormUses_listPointer->_Length
)(tfu->cdependents))) _do_assert(("tfu->ncafter==listLength(TFormUses)(tfu->cdependents)"
),"tinfer.c",2401); } while (0);
}

return tiTopSort(tful0);
2405}

2407/* Use tfu->inDegree and tfu->outEdges to perform a topological sort. */
2408localstatic TFormUsesList
2409tiTopSort(TFormUsesList tful0)
2410{
TFormUsesList	tful, stack, result;

/* tful collects the type forms which can now be first. */
stack = listNil(TFormUses)((TFormUsesList) 0);
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest))
if (car(tful)((tful)->first)->inDegree == 0)
	stack = listCons(TFormUses)(TFormUses_listPointer->Cons)(car(tful)((tful)->first), stack);

result = listNil(TFormUses)((TFormUsesList) 0);
while (stack) {
/* Pop the next type form to be processed. */
TFormUses	next = car(stack)((stack)->first);
stack = listFreeCons(TFormUses)(TFormUses_listPointer->FreeCons)(stack);

assert(next->inDegree == 0)do { if (!(next->inDegree == 0)) _do_assert(("next->inDegree == 0"
),"tinfer.c",2425); } while (0);
if (next->sortMark == false((int) 0)) {
	result = listCons(TFormUses)(TFormUses_listPointer->Cons)(next, result);
	next->sortMark = true1;
}

/* Unmark the type forms which depend on next. */
for (tful = next->outEdges; tful; tful = cdr(tful)((tful)->rest)) {
	TFormUses	tfu = car(tful)((tful)->first);

	/* Assert that tfu is not yet on the list. */
	assert (tfu->inDegree > 0)do { if (!(tfu->inDegree > 0)) _do_assert(("tfu->inDegree > 0"
),"tinfer.c",2436); } while (0);

	/* If all of the type forms on which tfu depends
	 * have been processed, then tfu can be next.
	 */
	if ((tfu->inDegree -= 1) == 0)
		stack = listCons(TFormUses)(TFormUses_listPointer->Cons)(tfu, stack);
}
}

result = listNReverse(TFormUses)(TFormUses_listPointer->NReverse)(result);
return result;
2448}

2450localstatic TFormUsesList
2451tiTopCycle(TFormUsesList tful0)
2452{
TFormUsesList	tful, cycle;

/* Collect any type forms which participate in a cycle. */
cycle = listNil(TFormUses)((TFormUsesList) 0);
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
if (tfu->sortMark == false((int) 0))
	cycle = listCons(TFormUses)(TFormUses_listPointer->Cons)(tfu, cycle);

tfu->sortMark = false((int) 0);
tfu->inDegree = 0;
tfu->outEdges = listNil(TFormUses)((TFormUsesList) 0);
}

cycle = listNReverse(TFormUses)(TFormUses_listPointer->NReverse)(cycle);
return cycle;
2469}

2471/*****************************************************************************
*
* :: tiTopClique
*
****************************************************************************/

2477/* Topologically sort the cliques in the graph. */
2478localstatic TFormUsesList
2479tiTopClique(TFormUsesList tful0)
2480{
TFormUsesList	tful, tfl, graph, result;

tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, NULL((void*)0), ">>tiTopClique:", tful0);

/* Mark the nodes in the clique graph without adding their edges. */
tiTopCliqueMark(tful0, true1);

/* For each vertex, add the edges and sort to find the cliques. */
graph = listCopy(TFormUses)(TFormUses_listPointer->Copy)(tful0);
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first), crep;
TFormUsesList	before, after, cycle;

/* Add the edges of V to the clique graph. */
tiTopCliqueAddVertex(tfu);

/* Perform a topological sort on the graph. */
before = tiTopCForward	(graph);
after  = tiTopCReverse	(graph);
cycle  = tiTopCycle	(graph);

if (cycle) {
	/* Remove the cycle from the graph. */
	for (tfl = cycle; tfl; tfl = cdr(tfl)((tfl)->rest))
		listPop(TFormUses,car(tfl),graph,tiTopEqual)(graph = (TFormUses_listPointer->NRemove)(graph, ((tfl)->
first), tiTopEqual));

	/* Mark the cycle as part of the same clique. */
	crep = tiTopCliqueUnion(cycle);
	listPush(TFormUses, crep, graph)(graph = (TFormUses_listPointer->Cons)(crep, graph));
}

listFree(TFormUses)(TFormUses_listPointer->Free)(before);
listFree(TFormUses)(TFormUses_listPointer->Free)(after);
listFree(TFormUses)(TFormUses_listPointer->Free)(cycle);
}

/* Topologically sort the final clique graph. */
result = tiTopCForward(graph);

/* Free the clique graph. */
tiTfFreeCDependees(tful0);

/* Collect the cliques on their canonical representative. */
for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
TFormUses	crep = tiTopCliqueRep(tfu);
listPush(TFormUses, tfu, crep->cdependents)(crep->cdependents = (TFormUses_listPointer->Cons)(tfu,
 crep->cdependents));
}
for (tful = result; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
tfu->cdependents = listNReverse(TFormUses)(TFormUses_listPointer->NReverse)(tfu->cdependents);
}
tiTopCliqueMark(tful0, false((int) 0));

tiTfPrintDb(titf)if (titfDebug) tiTfPrint(dbOut, NULL((void*)0), "<<tiTopClique:", result);

return result;
2538}

2540localstatic TFormUses
2541tiTopCliqueUnion(TFormUsesList cycle)
2542{
TFormUsesList	tful;
TFormUses	nrep = car(cycle)((cycle)->first);

/* Mark the nodes in the cycle with a new canonical representative. */
for (tful = cdr(cycle)((cycle)->rest); tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
assert(tfu->crep == NULL)do { if (!(tfu->crep == ((void*)0))) _do_assert(("tfu->crep == NULL"
),"tinfer.c",2549); } while (0);
tfu->crep = nrep;
}

/* Move edges to the new canonical representative. */
for (tful = cdr(cycle)((cycle)->rest); tful; tful = cdr(tful)((tful)->rest))
tiTopCliqueAddCVertex(car(tful)((tful)->first));

/* Delete edges to non-canonical nodes. */
for (tful = cycle; tful; tful = cdr(tful)((tful)->rest))
tiTopCliqueDelCVertex(car(tful)((tful)->first));

return nrep;
2562}

2564localstatic TFormUses
2565tiTopCliqueRep(TFormUses S)
2566{
if (S->crep) {
S->crep = tiTopCliqueRep(S->crep);
return S->crep;
}
else
return S;
2573}

2575localstatic void
2576tiTopCliqueMark(TFormUsesList tful0, Bool mark)
2577{
TFormUsesList	tful;

for (tful = tful0; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
tfu->sortMark	= false((int) 0);
tfu->cmarked	= true1;
tfu->crep	= NULL((void*)0);
}
2586}

2588localstatic void
2589tiTopCliqueAddVertex(TFormUses S)
2590{
TFormUsesList	tful;

for (tful = S->dependees; tful; tful = cdr(tful)((tful)->rest))
tiTopCliqueAddEdge(car(tful)((tful)->first), S);

for (tful = S->dependents; tful; tful = cdr(tful)((tful)->rest))
tiTopCliqueAddEdge(S, car(tful)((tful)->first));
2598}

2600localstatic void
2601tiTopCliqueAddCVertex(TFormUses S)
2602{
TFormUsesList	tful;

for (tful = S->cdependees; tful; tful = cdr(tful)((tful)->rest))
tiTopCliqueAddEdge(car(tful)((tful)->first), S);

for (tful = S->cdependents; tful; tful = cdr(tful)((tful)->rest))
tiTopCliqueAddEdge(S, car(tful)((tful)->first));
2610}

2612localstatic void
2613tiTopCliqueDelCVertex(TFormUses S)
2614{
TFormUsesList	tful;

for (tful = S->cdependees; tful; ) {
TFormUses	tfu = car(tful)((tful)->first);
tful = cdr(tful)((tful)->rest);		/* cdr before delete */
tiTopCliqueDelEdge(tfu, S);
}

for (tful = S->cdependents; tful; ) {
TFormUses	tfu = car(tful)((tful)->first);
tful = cdr(tful)((tful)->rest);		/* cdr before delete */
tiTopCliqueDelEdge(S, tfu);
}
2628}

2630/* Add an edge from S to T to the clique graph. */
2631localstatic void
2632tiTopCliqueAddEdge(TFormUses S, TFormUses T)
2633{
S = tiTopCliqueRep(S);
T = tiTopCliqueRep(T);

if (S == T) return;
if (S->cmarked == false((int) 0) || T->cmarked == false((int) 0)) return;
if (listMemq(TFormUses)(TFormUses_listPointer->Memq)(S->cdependents, T)) return;
assert(!listMemq(TFormUses)(T->cdependees, S))do { if (!(!(TFormUses_listPointer->Memq)(T->cdependees
, S))) _do_assert(("!listMemq(TFormUses)(T->cdependees, S)"
),"tinfer.c",2640); } while (0);

listPush(TFormUses, T, S->cdependents)(S->cdependents = (TFormUses_listPointer->Cons)(T, S->
cdependents));
listPush(TFormUses, S, T->cdependees)(T->cdependees = (TFormUses_listPointer->Cons)(S, T->
cdependees));
T->ncbefore += 1;
S->ncafter  += 1;

assert(T->ncbefore == listLength(TFormUses)(T->cdependees))do { if (!(T->ncbefore == (TFormUses_listPointer->_Length
)(T->cdependees))) _do_assert(("T->ncbefore == listLength(TFormUses)(T->cdependees)"
),"tinfer.c",2647); } while (0);
assert(S->ncafter  == listLength(TFormUses)(S->cdependents))do { if (!(S->ncafter == (TFormUses_listPointer->_Length
)(S->cdependents))) _do_assert(("S->ncafter == listLength(TFormUses)(S->cdependents)"
),"tinfer.c",2648); } while (0);
2649}

2651localstatic void
2652tiTopCliqueDelEdge(TFormUses S, TFormUses T)
2653{
if (S == tiTopCliqueRep(S) && T == tiTopCliqueRep(T)) return;
assert(listMemq(TFormUses)(S->cdependents, T))do { if (!((TFormUses_listPointer->Memq)(S->cdependents
, T))) _do_assert(("listMemq(TFormUses)(S->cdependents, T)"
),"tinfer.c",2655); } while (0);
assert(listMemq(TFormUses)(T->cdependees,  S))do { if (!((TFormUses_listPointer->Memq)(T->cdependees,
 S))) _do_assert(("listMemq(TFormUses)(T->cdependees, S)")
,"tinfer.c",2656); } while (0);

listPop(TFormUses, T, S->cdependents, tiTopEqual)(S->cdependents = (TFormUses_listPointer->NRemove)(S->
cdependents, T, tiTopEqual));
listPop(TFormUses, S, T->cdependees,  tiTopEqual)(T->cdependees = (TFormUses_listPointer->NRemove)(T->
cdependees, S, tiTopEqual));
T->ncbefore -= 1;
S->ncafter  -= 1;

assert(!listMemq(TFormUses)(S->cdependents, T))do { if (!(!(TFormUses_listPointer->Memq)(S->cdependents
, T))) _do_assert(("!listMemq(TFormUses)(S->cdependents, T)"
),"tinfer.c",2663); } while (0);
assert(!listMemq(TFormUses)(T->cdependees,  S))do { if (!(!(TFormUses_listPointer->Memq)(T->cdependees
, S))) _do_assert(("!listMemq(TFormUses)(T->cdependees, S)"
),"tinfer.c",2664); } while (0);

assert(T->ncbefore == listLength(TFormUses)(T->cdependees))do { if (!(T->ncbefore == (TFormUses_listPointer->_Length
)(T->cdependees))) _do_assert(("T->ncbefore == listLength(TFormUses)(T->cdependees)"
),"tinfer.c",2666); } while (0);
assert(S->ncafter  == listLength(TFormUses)(S->cdependents))do { if (!(S->ncafter == (TFormUses_listPointer->_Length
)(S->cdependents))) _do_assert(("S->ncafter == listLength(TFormUses)(S->cdependents)"
),"tinfer.c",2667); } while (0);
2668}

2670localstatic Bool
2671tiTopEqual(TFormUses tfu0, TFormUses tfu1)
2672{
return tfu0 == tfu1;
2674}

2676/******************************************************************************
*
* :: SetSoftMissing, GetSoftMissing
*
*****************************************************************************/

2682/* When tiSoftMissing is `on', then the compiler will give a warning msg
* (instead of an error msg) when a domain implementation is missing some
* exports.
*/
2686static Bool tiSoftMissing = false((int) 0);

2688void
2689tiSetSoftMissing(Bool state)
2690{
tiSoftMissing = state;
2692}

2694Bool
2695tiIsSoftMissing() { return tiSoftMissing; }

2697/******************************************************************************
*
* :: abExpandDefs (normalise a piece of absyn)
*
*****************************************************************************/

2703AbSyn
2704abExpandDefs(Stab stab, AbSyn ab)
2705{
TForm	tf = (TForm)NULL((void*)0);
int	i;
AbSyn	newAb, tmpAb, def;
TPoss tp;

/* Safety check */
assert(ab != 0)do { if (!(ab != 0)) _do_assert(("ab != 0"),"tinfer.c",2712);
 } while (0);


/* Deal with the simple cases. */
if (abIsNothing(ab)((ab)->abHdr.tag == (AB_Nothing))) return ab;


/* Bad absyn gets thrown back immediately */
if (abState(ab)((ab)->abHdr.state) == AB_State_Error) return ab;


/* Local copy of the abstract syntax node. */
newAb = (AbSyn)sefoCopy((Sefo)ab);


/*
* We MUST have a unique type for this to work. Type
* inferring at this level is dangerous and may blow
* up in our face (eg if still in tibupSelect).
*/
if (abState(newAb)((newAb)->abHdr.state) == AB_State_HasPoss)
{
TPoss tp = abTPoss(newAb)((newAb)->abHdr.type.poss);

/* Ensure that type inference is complete */
if (!tpossIsUnique(tp))
	typeInferAs(stab, newAb, tfUnknown);
}
else if (abState(newAb)((newAb)->abHdr.state) == AB_State_AbSyn)
typeInferAs(stab, newAb, tfUnknown);


/* Hopefully we have a unique type or singleton tposs */
switch (abState(newAb)((newAb)->abHdr.state))
{
  case AB_State_HasUnique:
tf = abTUnique(newAb)((newAb)->abHdr.type.unique);
break;
  case AB_State_HasPoss:
tp = abTPoss(newAb)((newAb)->abHdr.type.poss);
if (tpossIsUnique(tp))
	tf = tpossUnique(tp);
break;
  default:
break;
}


/* If we still don't have a unique type then give up */
if (!tf) return ab;


/* Recursively expand the definition */
switch (abTag(newAb)((newAb)->abHdr.tag)) {
  case AB_Not:
tmpAb = newAb->abNot.expr;
tmpAb = abExpandDefs(stab, tmpAb);
newAb->abNot.expr = tmpAb;
break;
  case AB_And:
if (abArgc(newAb)((newAb)->abHdr.argc) != 0) {
	for (i = 0; i < abArgc(newAb)((newAb)->abHdr.argc); i++) {
		tmpAb = newAb->abAnd.argv[i];
		tmpAb = abExpandDefs(stab, tmpAb);
		newAb->abAnd.argv[i] = tmpAb;
	}
}
break;
  case AB_Or:
if (abArgc(newAb)((newAb)->abHdr.argc) != 0) {
	for (i = 0; i < abArgc(newAb)((newAb)->abHdr.argc); i++) {
		tmpAb = newAb->abOr.argv[i];
		tmpAb = abExpandDefs(stab, tmpAb);
		newAb->abOr.argv[i] = tmpAb;
	}
}
break;
  case AB_Id:
/*
 * If this symbol is a constant definition then we want
 * to replace it with the definition body. This assumes
 * that the correct RHS of a definition can always be obtained
 * and therefore requires that the definition has lexical
 * scoping. Dynamically scoped constants (fluids) are
 * hopefully impossible.
 *
 * Only perform substitutions on definitions
 */
if (!((tfTag(tf)((tf)->tag) == TF_Define) && tfHasExpr(tf)((tf)->__absyn != 0)))
	break;


/* Get the absyn for the definition */
def = tfGetExpr(tf)((tf)->__absyn);


/* Safety check: I'm paranoid */
if (abTag(def)((def)->abHdr.tag) != AB_Define)
	break;


/* Use the expanded RHS of the definition */
def = def->abDefine.rhs;


/* A little bit of debugging info */
if (DEBUG(abExpand)abExpandDebug) {
	(void)fprintf(dbOut,
		      "abExpand: %s --> %s",
		      abPretty(newAb),
		      abPretty(def));
	fnewline(dbOut);
}


/* I really hope this can't loop */
newAb = abExpandDefs(stab, def);
break;
  case AB_Test:
tmpAb = newAb->abTest.cond;
tmpAb = abExpandDefs(stab, tmpAb);
newAb->abTest.cond = tmpAb;
break;
  default:
ab = newAb;
break;
}

return newAb;
2841}

