tform.c

Bug Summary

File:	src/tform.c
Warning:	line 4494, column 8 Access to field 'kind' results in a dereference of a null pointer
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 tform.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 tform.c
1/* Some issues:
  Rep == Record(c: Cross(T: TFormSubType, T))

  import from Rep
  anyTForm(T: TFormSubType, t: T): % == per [pair(T, t)]

  local unwrap(atf: %): (T: TFormSubType, t: T) ==
      pp: Cross(T: TFormSubType, t: T) == rep(atf).c
      pp

  local pair(T: TFormSubType, t: T): (T1: TFormSubType, t: T1)  == (T, t)

  -- local functions aren't needed

Rep == Foo -> Bar
   maps are not equal to defined constants
17*/

19/*****************************************************************************
*
* tform.c: Type forms.
*
* Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
*
****************************************************************************/

27#include "ablogic.h"
28#include "abpretty.h"
29#include "absub.h"
30#include "archive.h"
31#include "axlobs.h"
32#include "bigint.h"
33#include "comsg.h"
34#include "debug.h"
35#include "fint.h"
36#include "format.h"
37#include "freevar.h"
38#include "lib.h"
39#include "sefo.h"
40#include "spesym.h"
41#include "stab.h"
42#include "store.h"
43#include "strops.h"
44#include "symbol.h"
45#include "symeset.h"
46#include "tconst.h"
47#include "tfcond.h"
48#include "tfsat.h"
49#include "ti_sef.h"
50#include "ti_top.h"
51#include "tinfer.h"
52#include "tposs.h"
53#include "tqual.h"
54#include "ttable.h"
55#include "util.h"

57Bool	tfDebug			= false((int) 0);
58Bool	tfExprDebug		= false((int) 0);
59Bool	tfCrossDebug		= false((int) 0);
60Bool	tfFloatDebug		= false((int) 0);
61Bool	tfHasDebug		= false((int) 0);
62Bool	tfHashDebug		= false((int) 0);
63Bool	tfImportDebug		= false((int) 0);
64Bool	tfMapDebug		= false((int) 0);
65Bool	tfMultiDebug		= false((int) 0);
66Bool	tfCatDebug		= false((int) 0);
67Bool	tfWithDebug		= false((int) 0);
68Bool	tfCascadeDebug		= false((int) 0);
69Bool	tfParentDebug		= false((int) 0);
70Bool	symeRefreshDebug	= false((int) 0);

72#define tfDEBUGif (!tfDebug) { } else afprintf			DEBUG_IF(tf)if (!tfDebug) { } else		afprintf
73#define tfExprDEBUGif (!tfExprDebug) { } else afprintf		DEBUG_IF(tfExpr)if (!tfExprDebug) { } else	afprintf
74#define tfCrossDEBUGif (!tfCrossDebug) { } else afprintf		DEBUG_IF(tfCross)if (!tfCrossDebug) { } else	afprintf
75#define tfFloatDEBUGif (!tfFloatDebug) { } else afprintf		DEBUG_IF(tfFloat)if (!tfFloatDebug) { } else	afprintf
76#define tfHasDEBUGif (!tfHasDebug) { } else afprintf		DEBUG_IF(tfHas)if (!tfHasDebug) { } else		afprintf
77#define tfHashDEBUGif (!tfHashDebug) { } else afprintf		DEBUG_IF(tfHash)if (!tfHashDebug) { } else	afprintf
78#define tfImportDEBUGif (!tfImportDebug) { } else afprintf		DEBUG_IF(tfImport)if (!tfImportDebug) { } else	afprintf
79#define tfMapDEBUGif (!tfMapDebug) { } else afprintf		DEBUG_IF(tfMap)if (!tfMapDebug) { } else		afprintf
80#define tfMultiDEBUGif (!tfMultiDebug) { } else afprintf		DEBUG_IF(tfMulti)if (!tfMultiDebug) { } else	afprintf
81#define tfCatDEBUGif (!tfCatDebug) { } else afprintf		DEBUG_IF(tfCat)if (!tfCatDebug) { } else		afprintf
82#define tfWithDEBUGif (!tfWithDebug) { } else afprintf		DEBUG_IF(tfWith)if (!tfWithDebug) { } else	afprintf
83#define tfCascadeDEBUGif (!tfCascadeDebug) { } else afprintf		DEBUG_IF(tfCascade)if (!tfCascadeDebug) { } else	afprintf
84#define tfParentDEBUGif (!tfParentDebug) { } else afprintf		DEBUG_IF(tfParent)if (!tfParentDebug) { } else	afprintf
85#define symeRefreshDEBUGif (!symeRefreshDebug) { } else afprintf	DEBUG_IF(symeRefresh)if (!symeRefreshDebug) { } else	afprintf

87#define	TFormBuiltinSefo
88#undef	UseTypeVariables


91/*
* tfMaxBaseSearchDepth defines the number of times that a tform
* can be expanded by tfDefineeType1() before we give up: it should
* never be reached. Make sure that it is large enough for all normal
* tforms to be completely expanded yet small enough to prevent bad
* tforms from killing performance. Use -Wcheck to see if we ever
* reach the limit.
* 
* !!! To do: this ought to be a command-line switch.
*/
101int tfMaxBaseSearchDepth = 20;


104SymeList
105tfSetSymesFn(TForm tf, SymeList sl)
106{
tf->symes = sl;
return sl;
109}

111/******************************************************************************
*
* :: Local operations
*
*****************************************************************************/

117/*
* Type form constructors.
*/
120localstatic TForm		tfNewSymbol		(TFormTag);
121localstatic TForm		tfNewSyntax		(AbSyn);
122localstatic TForm		tfNewNode		(TFormTag, Length, ...);
123localstatic TForm		tfNewBuiltin		(TForm, Symbol);

125/*
* Type form syntax.
*/
128localstatic void		tfSetExpr		(TForm, AbSyn);
129localstatic AbSyn		tfToAbSyn0		(TForm, Bool);

131localstatic Bool		tfOwnsExpr		(TForm);
132localstatic AbSyn		tfDisownExpr		(TForm, Bool);
133localstatic void		tfPendingFrSyntaxMap	(Stab, AbSyn, TForm);
134localstatic void		tfPendingFrSyntaxDefine	(Stab, AbSyn, TForm);
135localstatic void		tfp0FoamType		(TForm);

137localstatic Bool		tfMeaningEqual		(Sefo, Sefo);

139/*
* Type form floating.
*/
142/*local ULong		tfOuterDepth		(Stab, TForm);*/
143/*local ULong		abOuterDepth		(Stab, AbSyn);*/

145/*
* Type form representational symes.
*/
148localstatic Syme		tfNewRepSyme		(Stab, Symbol, TForm, Hash);
149localstatic SymeList		tfSymesFrDeclare	(Sefo);
150localstatic SymeList		tfSymesFrCross		(TForm);
151localstatic SymeList		tfSymesFrMulti		(TForm);
152localstatic SymeList		tfSymesFrMap		(TForm);
153localstatic SymeList		tfSymesFrEnum		(Stab, TForm, Sefo);
154localstatic void		tfCheckDenseArgs	(TForm, Sefo);
155localstatic SymeList		tfSymesFrRawRecord	(Stab, TForm, Sefo);
156localstatic SymeList		tfSymesFrRecord		(Stab, TForm, Sefo);
157localstatic SymeList		tfSymesFrUnion		(Stab, TForm, Sefo);
158localstatic SymeList		tfSymesFrTrailingArray	(Stab, TForm, Sefo);
159localstatic SymeList		tfSymesFrAdd		(Sefo);
160localstatic SymeList		tfSymesFrDefault	(Sefo);

162localstatic AbSyn		tfSymesToAdd		(SymeList);

164localstatic void		tfGetExportError	(TForm, String);

166localstatic TForm		tfCatExportsPendingFrWith(Sefo);
167localstatic Bool		tfHasSymesFrDefault	(Sefo);

169localstatic SymeList		tfGetCatSelfFrWith	(Sefo);

171localstatic Syme		symeListFindExport	(SymeList, Syme, SymeList);
172localstatic void		tfJoinExports		(Syme, Syme);
173localstatic Bool		tfJoinExportToList	(SymeList, SymeList, Syme,
				 Sefo);
175localstatic SymeList		tfMeetExportLists	(SymeList, SymeList, SymeList,
				 Sefo);

178localstatic SymeList		tfAddDomExports		(TForm, SymeList);
179localstatic SymeList		tfAddCatExports		(TForm, SymeList);
180localstatic SymeList		tfAddThdExports		(TForm, SymeList);
181localstatic SymeList		tfAddHasExports		(TForm, TForm);

183localstatic SymeList		tfGetCatExportsFrParents(SymeList);
184localstatic SymeList		tfGetCatExportsCond	(SymeList, SefoList, Bool);
185localstatic SymeList		tfGetCatExportsFilterTable(SymeTSet, SymeList);

187localstatic SymeList		tfGetCatExportsFrWith	(TForm);
188localstatic SymeList		tfGetCatExportsFrIf	(TForm);
189localstatic SymeList		tfGetCatExportsFrJoin	(TForm);
190localstatic SymeList		tfGetCatExportsFrMeet	(TForm);

192localstatic Syme		tfGetBuiltinSyme	(TForm, Symbol);

194localstatic SymeList		tfGetThdConstants	(TForm);
195localstatic SymeList		tfGetCatConstantsFrWith	(Sefo);

197localstatic TQualList		tfGetCascadesFrStab	(Stab);
198localstatic TQualList		tfGetCatCascadesFrWith	(TForm);
199localstatic TQualList		tfGetCascadesFrTrailingArray(TForm tf);

201localstatic TForm		tfIsIdempotent		(TForm);
202localstatic void		tfForwardIdempotent	(TForm, TForm);
203localstatic void		tfExtendFinishTwins	(Stab, Syme);

205/******************************************************************************
*
* :: Type imports and exports
*
*****************************************************************************/

211localstatic void		tfSetDomImports		(TForm, SymeSet);
212localstatic void		tfSetDomExports		(TForm, SymeList);

214localstatic SymeSet 		tfStabCreateDomImportSet(Stab stab, TForm tf);
215/******************************************************************************
*
* :: Debugging facilities
*
*****************************************************************************/

221/*
* Debugging function designed to fully expand a tform so that
* there aren't any TF_Subst or TF_Follow nodes and that all
* symes have been triggered.
*/
226TForm
227tfFollowFully(TForm tf)
228{
int i;

tf = tfFollowFn(tf);

if (tf) {
for (i = 0;i < tfArgc(tf)((tf)->argc); i++)
	tfArgv(tf)((tf)->argv)[i] = tfFollowFully(tfArgv(tf)((tf)->argv)[i]);
}

return tf;
239}

241void
242tformDump(TForm tf)
243{
/* Display the origin of tforms */
if (tfHasExpr(tf)((tf)->__absyn != 0))
{
AbSyn	expr = tfGetExpr(tf)((tf)->__absyn);

(void)tfPrintDb(tf);
spstackPrintDb(expr->abHdr.pos);
fnewline(dbOut);
}
253}

255/******************************************************************************
*
* :: Basic operations
*
*****************************************************************************/

261/*
* Type form constructors.
*/


266/* For breakpoints */
267localstatic void tfBreak(TForm tf);
268static TForm tfBreakVal;

270TForm
271tfNewEmpty(TFormTag tag, Length argc)
272{
TForm	tf;
Length	i;

tf = (TForm) stoAlloc((unsigned)OB_TForm(14 + 8), sizeof(*tf)+argc*sizeof(tf));

tf->tag		= tag;
tf->ownSyntax	= false((int) 0);
tf->hasSelf	= false((int) 0);
tf->hasSelfSelf	= false((int) 0);
tf->hasCascades	= false((int) 0);
tf->raw		= FOAM_LIMIT;
tf->hash	= 0;
tf->__absyn	= 0;
tf->intStepNo	= intStepNo;

tf->argc	= argc;
tf->argv	= (argc ? (TForm *) (tf + 1) : NULL((void*)0));

tf->stab	= NULL((void*)0);
tf->self	= listNil(Syme)((SymeList) 0);
tf->selfself	= listNil(Syme)((SymeList) 0);
tf->parents	= listNil(Syme)((SymeList) 0);
tf->symes	= listNil(Syme)((SymeList) 0);

tf->domExports	= listNil(Syme)((SymeList) 0);
tf->catExports	= listNil(Syme)((SymeList) 0);
tf->thdExports	= listNil(Syme)((SymeList) 0);
tf->domExportNames = NULL((void*)0);

tf->domImports	= NULL((void*)0);

tf->consts	= listNil(TConst)((TConstList) 0);
tf->queries	= listNil(TForm)((TFormList) 0);
tf->cascades	= listNil(TQual)((TQualList) 0);

tf->conditions = NULL((void*)0);;

tf->sigma	= NULL((void*)0);
tf->fv		= NULL((void*)0);
tf->rho		= NULL((void*)0);

tf->__mark	= 0;
tf->parent	= NULL((void*)0);
tf->libNum	= TYPE_NUMBER_UNASSIGNED(0x7FFFFFFF);

tf->tests = listNil(Sefo)((SefoList) 0);

for (i = 0; i < argc; i += 1) tf->argv[i] = 0;

tfSetTForm(tf)(((tf)->state)=TF_State_TForm);
tfp0FoamType(tf);

tfBreak(tf);

return tf;
328}

330localstatic void
331tfBreak(TForm tf)
332{
if (tf == tfBreakVal) {
printf("breakpoint");
}
336}

338localstatic TForm
339tfNewSymbol(TFormTag tag)
340{
TForm	tf = tfNewEmpty(tag, int0((int) 0));
tfToAbSyn(tf);
tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
return tf;
345}

347TForm
348tfNewAbSyn(TFormTag tag, AbSyn ab)
349{
TForm	tf = tfNewEmpty(tag, int0((int) 0));
tfSetExpr(tf, ab);
return tf;
353}

355localstatic TForm
356tfNewSyntax(AbSyn ab)
357{
/* we leave one slot for TF_Forward transmogrification */
TForm	tf = tfNewEmpty(TF_Syntax, 1);
tfSetPending(tf)(((tf)->state)=TF_State_Pending);
tfSetExpr(tf, ab);
tf->argc = 0;
return tf;
364}

366localstatic TForm
367tfNewNode(TFormTag tag, Length argc, ...)
368{
TForm	tf;
Length	i;
va_list argp;

tf = tfNewEmpty(tag, argc);

va_start(argp, argc)__builtin_va_start(argp, argc);
for (i = 0; i < argc; i += 1)
tfArgv(tf)((tf)->argv)[i] = va_arg(argp, TForm)__builtin_va_arg(argp, TForm);
va_end(argp)__builtin_va_end(argp);

return tf;
381}

383localstatic TForm
384tfNewBuiltin(TForm tf, Symbol sym)
385{
Syme	syme = tfGetBuiltinSyme(tf, sym);
return syme ? tfFrSyme(stabGlobal(), syme) : tfUnknown;
388}

390/*
* Basic TForm operations.
*/

394void
395tfInitBasicTypes(TForm tf)
396{
static Bool	isInit = false((int) 0);

if (isInit) return;

tfBoolean	= tfNewBuiltin(tf, ssymBoolean);
tfTextWriter	= tfNewBuiltin(tf, ssymTextWriter);
tfMachineInteger= tfNewBuiltin(tf, ssymMachineInteger);

isInit = true1;
406}

408void
409tfInit(void)
410{
static Bool	isInit = false((int) 0);
int		i;

if (isInit) return;

abUnknown = abNewBlank(sposNone, symIntern("?"))abNew(AB_Blank, sposNone,1, symProbe("?", 1 | 2));

tfUnknown	= tfNewSymbol(TF_Unknown);
tfExit		= tfNewSymbol(TF_Exit);
tfTest		= tfNewSymbol(TF_Test);
tfLiteral	= tfNewSymbol(TF_Literal);
tfType		= tfNewSymbol(TF_Type);
tfCategory	= tfNewSymbol(TF_Category);

tfDomain	= tfWith(tfNone()tfMulti(0), tfNone()tfMulti(0));
tfTypeTuple	= tfTuple(tfType);

tfBoolean	= tfUnknown;
tfTextWriter	= tfUnknown;
tfMachineInteger = tfUnknown;

for (i = TF_START; i < TF_LIMIT; i++)
tformInfo(i)tformInfoTable[(int)(i) - (int)TF_START].hash = strHash(tformInfo(i)tformInfoTable[(int)(i) - (int)TF_START].str);

/* syme.c checks */

for (i=SYME_FIELD_START; i<SYME_FIELD_LIMIT; i++)
assert(symeFieldInfo[i].tag == i)do { if (!(symeFieldInfo[i].tag == i)) _do_assert(("symeFieldInfo[i].tag == i"
),"tform.c",438); } while (0);

isInit = true1;
441}


444void
445tfFree(TForm tf)
446{
if (tfOwnsExpr(tf)) abFree(tfGetExpr(tf)((tf)->__absyn));

listFree(Syme)(Syme_listPointer->Free)(tf->symes);
listFree(Syme)(Syme_listPointer->Free)(tf->self);

/* A type form does not own its domExports. */
symeSetFree(tf->domImports);

stoFree((Pointer) tf);
456}

458int
459tfPrint(FILE *fout, TForm tf)
460{
return tformPrint(fout, tf);
462}

464int
465tfPrintDb(TForm tf)
466{
int rc = tformPrint(dbOut, tf);
fnewline(dbOut);
return rc;
470}

472Bool
473tfEqual(TForm t1, TForm t2)
474{
return tformEqual(t1, t2);
476}

478#define		tfHashArg(h, hi){ h ^= (h << 8); h += (hi) + 200041; h &= 0x3FFFFFFF
; } {	\
h ^= (h << 8);			\
h += (hi) + 200041;		\
h &= 0x3FFFFFFF;		\
482}

484Hash
485tfHash(TForm tf)
486{
Hash		h = 0;
Length		i;
SymeList	symes;
static int serial = 0;
int this = serial++;

tfFollow(tf)((tf) = tfFollowFn(tf));
tfHashDEBUGif (!tfHashDebug) { } else afprintf(dbOut, "(hash %d %pTForm\n", this, tf);
if (!tfIsDefine(tf)(((tf)->tag) == TF_Define))
tf = tfDefineeType(tf);

if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT))
h = 0;
else if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)->
tag)) < TF_ABSYN_LIMIT)) {
h = abHashModDeclares(tfGetExpr(tf)((tf)->__absyn));
}
else if (tfIsDefine(tf)(((tf)->tag) == TF_Define)) {
tfHashArg(h, tfHash(tfDefineeType(tf))){ h ^= (h << 8); h += (tfHash(tfDefineeType(tf))) + 200041
; h &= 0x3FFFFFFF; };
tfHashArg(h, tfHash(tfDefineVal(tf))){ h ^= (h << 8); h += (tfHash(tfFollowArg(tf, 1))) + 200041
; h &= 0x3FFFFFFF; };
}
else if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)->
tag)) < TF_NODE_LIMIT)) {
for (h = 0, i = 0; i < tfArgc(tf)((tf)->argc); i += 1) {
	tfHashArg(h, tfHash(tfArgv(tf)[i])){ h ^= (h << 8); h += (tfHash(((tf)->argv)[i])) + 200041
; h &= 0x3FFFFFFF; };
}
}
else
bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag)
, 513, "tform.c");

if (tfTagHasSymes(tfTag(tf)((tf)->tag))) {
for (symes = tfSymes(tf)((tf)->symes); symes; symes = cdr(symes)((symes)->rest))
	tfHashArg(h, strHash(symeString(car(symes)))){ h ^= (h << 8); h += (strHash(((((((symes)->first))
->id))->str))) + 200041; h &= 0x3FFFFFFF; };
}

h += tformInfo(tfTag(tf))tformInfoTable[(int)(((tf)->tag)) - (int)TF_START].hash + 200063;
h &= 0x3FFFFFFF;
tfHashDEBUGif (!tfHashDebug) { } else afprintf(dbOut, " hash %d = %d)\n", this, h);
return h;
524}

526TForm
527tfFrSyme(Stab stab, Syme syme)
528{
return tfFullFrAbSyn(stab, abFrSyme(syme));
530}

532TForm
533tfFrSelf(Stab stab, TForm tf)
534{
return tfFrSyme(stab, car(tfDefSelf(stab, tf))((tfDefSelf(stab, tf))->first));
536}

538void tfTestPush(TForm tf, Sefo sf)
539{
tf->tests = listCons(Sefo)(Sefo_listPointer->Cons)(sf, tf->tests);
541}

543void tfTestPop(TForm tf, Sefo sf)
544{
assert(car(tf->tests) == sf)do { if (!(((tf->tests)->first) == sf)) _do_assert(("car(tf->tests) == sf"
),"tform.c",545); } while (0);
tf->tests = cdr(tf->tests)((tf->tests)->rest);
547}

549Bool tfTestSeen(TForm tf, Sefo sf)
550{
SefoList ll = tf->tests;
for (; ll != listNil(Sefo)((SefoList) 0); ll = cdr(ll)((ll)->rest)) {
if (sf == car(ll)((ll)->first)) {
	return true1;
}
}
return false((int) 0);
558}


561/*****************************************************************************
*
* :: Declarations for tfPending
*
****************************************************************************/

567localstatic Syme	tfp0SpecialSyme (Stab, Syme syme, Symbol, Bool);
568localstatic Syme	tfp0IdSyme	(Stab, Syme, Symbol);
569localstatic Syme	tfp0OpSyme	(Stab, Syme, Symbol, Length);
570localstatic TForm	tfp0IdTForm	(Symbol);
571localstatic TForm	tfp0OpTForm	(Symbol, Length);

573localstatic TForm	tfp0General	(Stab, AbSyn);
574localstatic TForm	tfp0Float	(Stab, AbSyn);

576localstatic TForm	tfpNothing	(Stab, AbSyn);
577localstatic TForm	tfpBlank	(Stab, AbSyn);
578localstatic TForm	tfpId		(Stab, AbSyn);
579localstatic TForm	tfpDeclare	(Stab, AbSyn);
580localstatic TForm	tfpDefine	(Stab, AbSyn);
581localstatic TForm	tfpAssign	(Stab, AbSyn);
582localstatic TForm	tfpComma	(Stab, AbSyn);
583localstatic TForm	tfpAdd		(Stab, AbSyn);
584localstatic TForm	tfpWith		(Stab, AbSyn);
585localstatic TForm	tfpIf		(Stab, AbSyn);
586localstatic TForm	tfpExcept	(Stab, AbSyn);
587localstatic TForm	tfpApply	(Stab, AbSyn);

589/*****************************************************************************
*
* :: tfPending
*
****************************************************************************/
594localstatic AbSynList tfpConditions;

596TForm
597tfPending(Stab stab, AbSyn ab)
598{
TForm		tf;
static int	serialNo = 0, depthNo = 0;
int		serialThis;

serialNo += 1;
depthNo	 += 1;
serialThis = serialNo;
tfExprDEBUGif (!tfExprDebug) { } else afprintf(dbOut, "%*s(tfPending %d= %pAbSyn\n",
    depthNo, "", serialThis, ab);


/* The stab is used to look up meanings for ids without them. */

if (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0))
stab = abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0);

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Nothing:	tf = tfpNothing (stab, ab); break;
case AB_Blank:		tf = tfpBlank	(stab, ab); break;
case AB_Id:		tf = tfpId	(stab, ab); break;
case AB_Declare:	tf = tfpDeclare (stab, ab); break;
case AB_Define:		tf = tfpDefine	(stab, ab); break;
case AB_Assign:		tf = tfpAssign	(stab, ab); break;
case AB_Comma:		tf = tfpComma	(stab, ab); break;
case AB_Add:		tf = tfpAdd	(stab, ab); break;
case AB_With:		tf = tfpWith	(stab, ab); break;
case AB_If:		tf = tfpIf	(stab, ab); break;
case AB_Apply:		tf = tfpApply	(stab, ab); break;
case AB_Except:		tf = tfpExcept  (stab, ab); break;
default:		tf = tfp0General(stab, ab); break;
}

tfExprDEBUGif (!tfExprDebug) { } else afprintf(dbOut, "%*s %d %pTForm)\n", depthNo, "", serialThis, tf);
depthNo -= 1;

tfSetExpr(tf, ab);
tfSetPending(tf)(((tf)->state)=TF_State_Pending);
return tf;
637}

639Syme
640tfpOpSyme(Stab stab, Symbol sym, Length argc)
641{
return tfp0OpSyme(stab, NULL((void*)0), sym, argc);
643}

645/*****************************************************************************
*
* :: tfPending helper functions
*
****************************************************************************/

651localstatic TForm tf0MapRetFrPending(Stab stab, TForm tf);

653localstatic Syme
654tfp0SpecialSyme(Stab stab, Syme syme, Symbol sym, Bool op)
655{
TForm tf;
SymeList	sl;

if (syme != NULL((void*)0)) {
tf = symeType(syme);
if (op) {
	tf = tf0MapRetFrPending(stab, tf);
}
if (tf && tfSatType(tf))
	return syme;
}

for (sl = stabGetMeanings(stab, NULL((void*)0), sym); sl; sl = cdr(sl)((sl)->rest)) {
Syme	syme = car(sl)((sl)->first);

/*!! Need to check some condition to ensure this syme
 *!! is really special.	 This one doesn't do it.
if (!symeTop(syme))
	continue;
 */

tf = symeType(syme);
if (op) {
	tf = tf0MapRetFrPending(stab, tf);
}

if (tf && tfSatType(tf))
	return syme;
}

return NULL((void*)0);
687}

689localstatic TForm
690tf0MapRetFrPending(Stab stab, TForm tf)
691{
tf = tfFollowOnly(tf);

if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))
tf = tfMapRet(tf)tfFollowArg(tf, 1);
else if (tfIsMapSyntax(tf)((((tf)->tag) == TF_Syntax) && (((((((tf)->__absyn
))->abHdr.tag == (AB_Apply)) && (((((((tf)->__absyn
))->abApply.op))->abHdr.tag == (AB_Id)) && ((((
((tf)->__absyn))->abApply.op))->abId.sym)==(ssymArrow
))) && (((((tf)->__absyn))->abHdr.argc)-1) == 2
) || ((((((tf)->__absyn))->abHdr.tag == (AB_Apply)) &&
 (((((((tf)->__absyn))->abApply.op))->abHdr.tag == (
AB_Id)) && ((((((tf)->__absyn))->abApply.op))->
abId.sym)==(ssymPackedArrow))) && (((((tf)->__absyn
))->abHdr.argc)-1) == 2)))) {
AbSyn	ab = tfGetExpr(tf)((tf)->__absyn);
tf = tfSyntaxFrAbSyn(stab, abApplyArg(ab, 1)((ab)->abApply.argv[1]));
tfFollow(tf)((tf) = tfFollowFn(tf));
}
else
return NULL((void*)0);

return tf;
705}

707Syme
708tfpIdSyme(Stab stab, Symbol sym)
709{
return tfp0IdSyme(stab, NULL((void*)0), sym);
711}

713localstatic Syme
714tfp0IdSyme(Stab stab, Syme syme, Symbol sym)
715{
Syme	rsyme = 0;

if ((sym == ssymExit)		||
   (sym == ssymType)		||
   (sym == ssymCategory)	||
   (sym == ssymTest)		||
   (sym == ssymLiteral))
rsyme = tfp0SpecialSyme(stab, syme, sym, false((int) 0));

return rsyme;
726}

728localstatic Syme
729tfp0OpSyme(Stab stab, Syme syme, Symbol sym, Length argc)
730{
Syme	rsyme = 0;

if ((argc == 2 && sym == ssymArrow)		||
   (argc == 2 && sym == ssymPackedArrow)	||
   (argc == 1 && sym == ssymTuple)		||
   (argc == 1 && sym == ssymGenerator)		||
   (argc == 1 && sym == ssymXGenerator)	||
   (argc == 1 && sym == ssymReference)		||
   (argc == 1 && sym == ssymRaw)		||

   (sym == ssymCross)		||
   (sym == ssymEnum)		||
   (sym == ssymRawRecord)	||
   (sym == ssymRecord)		||
   (sym == ssymTrailingArray)	||
   (sym == ssymUnion)		||
   (sym == ssymMeet)		||
   (sym == ssymJoin))
rsyme = tfp0SpecialSyme(stab, syme, sym, true1);

return rsyme;
752}

754localstatic TForm
755tfp0IdTForm(Symbol sym)
756{
TForm	tf = NULL((void*)0);

    if (sym == ssymExit)	tf = tfExit;
else if (sym == ssymType)	tf = tfType;
else if (sym == ssymCategory)	tf = tfThird(listNil(Syme)((SymeList) 0));
else if (sym == ssymTest)	tf = tfTest;
else if (sym == ssymLiteral)	tf = tfLiteral;

return tf;
766}

768localstatic TForm
769tfp0OpTForm(Symbol sym, Length argc)
770{
TFormTag	tag = TF_General;
TForm		tf;

    if (sym == ssymArrow)		tag = TF_Map;
else if (sym == ssymPackedArrow)	tag = TF_PackedMap;
else if (sym == ssymTuple)		tag = TF_Tuple;
else if (sym == ssymGenerator)		tag = TF_Generator;
else if (sym == ssymXGenerator)		tag = TF_XGenerator;
else if (sym == ssymReference)		tag = TF_Reference;
else if (sym == ssymRaw)		tag = TF_Raw;

else if (sym == ssymCross)		tag = TF_Cross;
else if (sym == ssymEnum)		tag = TF_Enumerate;
else if (sym == ssymRecord)		tag = TF_Record;
else if (sym == ssymRawRecord)		tag = TF_RawRecord;
else if (sym == ssymTrailingArray)	tag = TF_TrailingArray;
else if (sym == ssymUnion)		tag = TF_Union;
else if (sym == ssymJoin)		tag = TF_Join;
else if (sym == ssymMeet)		tag = TF_Meet;

tf = tfNewEmpty(tag, argc);
return tf;
793}

795localstatic TForm
796tfp0General(Stab stab, AbSyn ab)
797{
return tfNewAbSyn(TF_General, ab);
799}

801localstatic TForm
802tfp0Float(Stab stab, AbSyn ab)
803{
TForm	tf, ntf;
Stab	nstab;

tf    = tfSyntaxFrAbSyn(stab, ab);
if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
tfMergeConditions(tf, stab, 
		  tfpConditions == listNil(AbSyn)((AbSynList) 0) 
		  ? NULL((void*)0) : tfCondEltNew(stab, tfpConditions));

nstab = tfFloat(stab, tf);

if (nstab == NULL((void*)0))
return tfPendingFrSyntax(stab, ab, tf);

ntf = tiTopFns()->typeInferTForm(nstab, tf);
tfTransferSemantics(ntf, tf);


return tf;
823}

825localstatic void
826tfp0FoamType(TForm tf)
827{
FoamTag		tag = FOAM_LIMIT;

switch (tfTag(tf)((tf)->tag)) {
case TF_With:
tag = FOAM_Word;
break;
case TF_Map:
tag = FOAM_Clos;
break;
case TF_PackedMap:
tag = FOAM_Clos;
break;
case TF_Generator:
tag = FOAM_Clos;
break;
case TF_Multiple:
tag = FOAM_NOp;
break;
case TF_RawRecord:
tag = FOAM_RRec;
break;
case TF_Record:
tag = FOAM_Rec;
break;
case TF_Reference:
tag = FOAM_Clos;
break;
case TF_Cross:
tag = FOAM_Word;
break;
case TF_Tuple:
tag = FOAM_Word;
break;
case TF_TrailingArray:
tag = FOAM_TR;
break;
default:
break;
}

tfFoamType(tf)((tf)->raw) = tag;
869}

871/*****************************************************************************
*
* :: tfPending cases
*
****************************************************************************/
876localstatic Bool tfSymesEqModExtends(Syme syme1, Syme syme2);

878localstatic TForm
879tfpNothing(Stab stab, AbSyn ab)
880{
return tfNone()tfMulti(0);
882}

884localstatic TForm
885tfpBlank(Stab stab, AbSyn ab)
886{
TForm	tf;

889#ifdef UseTypeVariables
tf = tfNewNode(TF_Variable, 1, tfUnknown);
891#else
tf = tfUnknown;
893#endif

return tf;
896}

898localstatic TForm
899tfpId(Stab stab, AbSyn ab)
900{
Symbol	sym = ab->abId.sym;
Syme	syme, absyme;
TForm	tf;

tf = abTForm(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->tform : 0);
if (abIsTheId(ab, ssymCategory)(((ab)->abHdr.tag == (AB_Id)) && ((ab)->abId.sym
)==(ssymCategory)) && tf && tfIsDefine(tf)(((tf)->tag) == TF_Define)) {
TForm	tfc = tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0);
TForm	tfw = tfDefineVal(tf)tfFollowArg(tf, 1);
if (tfIsSyntax(tfw)(((tfw)->tag) == TF_Syntax))
	tfw = tfPendingFrSyntax(stab, tfGetExpr(tfw)((tfw)->__absyn), tfw);
if (tfIsSyntax(tfc)(((tfc)->tag) == TF_Syntax))
	tfForwardFrSyntax(tfc, tfThirdFrTForm(tfw));
tfFollow(tfc)((tfc) = tfFollowFn(tfc));
tfSetPending(tfc)(((tfc)->state)=TF_State_Pending);
return tfc;
}

absyme = abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0);
syme = tfp0IdSyme(stab, absyme, sym);

if (! syme)
/* This sym is not one of the known special type syms. */
tf = tfp0General(stab, ab);

else if (absyme && symeOriginal(absyme) == symeOriginal(syme))
/* This syme is one of the known special type symes. */
tf = tfp0IdTForm(sym);

else if (!absyme && listMemq(Syme)(Syme_listPointer->Memq)(stabGetMeanings(stab, NULL((void*)0), sym), syme))
/* This ab could be one of the known special type forms. */
/* Don't try to do any type inference here. */
tf = tfp0IdTForm(sym);

else
/* This ab is not one of the known special type forms. */
tf = tfp0General(stab, ab);

if (sym == ssymBoolean && tfBoolean == tfUnknown)
tfBoolean = tf;
if (sym == ssymTextWriter && tfTextWriter == tfUnknown)
tfTextWriter = tf;
if (sym == ssymMachineInteger && tfMachineInteger == tfUnknown)
tfMachineInteger = tf;

return tf;
946}

948localstatic TForm
949tfpDeclare(Stab stab, AbSyn ab)
950{
TForm	tf;

tf = tfNewNode(TF_Declare, 1, tfp0Float(stab, ab->abDeclare.type));

return tf;
956}

958localstatic TForm
959tfpDefine(Stab stab, AbSyn ab)
960{
AbSyn	lhs, rhs;
TForm	tfl, tfr;

lhs = ab->abDefine.lhs;
rhs = ab->abDefine.rhs;
if (abTag(lhs)((lhs)->abHdr.tag) != AB_Declare)
lhs = abNewDeclare(abPos(ab), lhs, abNewNothing(abPos(ab)))abNew(AB_Declare, (spstackFirst((ab)->abHdr.pos)),2, lhs,abNew
(AB_Nothing, (spstackFirst((ab)->abHdr.pos)),0 ));

tfl = tfp0Float(stab, lhs);
tfr = tfSyntaxFrAbSyn(stab, rhs);

return tfNewNode(TF_Define, 2, tfl, tfr);
973}

975localstatic TForm
976tfpAssign(Stab stab, AbSyn ab)
977{
AbSyn	lhs, rhs;
TForm	tfl, tfr;

lhs = ab->abAssign.lhs;
rhs = ab->abAssign.rhs;
if (abTag(lhs)((lhs)->abHdr.tag) != AB_Declare)
lhs = abNewDeclare(abPos(ab), lhs, abNewNothing(abPos(ab)))abNew(AB_Declare, (spstackFirst((ab)->abHdr.pos)),2, lhs,abNew
(AB_Nothing, (spstackFirst((ab)->abHdr.pos)),0 ));

tfl = tfp0Float(stab, lhs);
tfr = tfSyntaxFrAbSyn(stab, rhs);

return tfNewNode(TF_Assign, 2, tfl, tfr);
990}

992localstatic TForm
993tfpComma(Stab stab, AbSyn ab)
994{
TForm	tf;
Length	i, argc;

argc = abArgc(ab)((ab)->abHdr.argc);
if (argc == 1)
tf = tfp0Float(stab, abArgv(ab)((ab)->abGen.data.argv)[0]);
else {
tf = tfNewEmpty(TF_Multiple, argc);
for (i = 0; i < argc; i += 1)
	tfArgv(tf)((tf)->argv)[i] = tfp0Float(stab, abArgv(ab)((ab)->abGen.data.argv)[i]);
}

return tf;
1008}

1010localstatic TForm
1011tfpAdd(Stab stab, AbSyn ab)
1012{
TForm	tf;

tf = tfNewNode(TF_Add, 1, tfp0Float(stab, ab->abAdd.base));

return tf;
1018}

1020localstatic TForm
1021tfpWith(Stab stab, AbSyn ab)
1022{
TForm	tf;

tf = tfNewNode(TF_With, 2,
       tfp0Float(stab, ab->abWith.base),
       tfp0Float(stab, ab->abWith.within));

return tf;
1030}

1032localstatic TForm
1033tfpExcept(Stab stab, AbSyn ab)
1034{
TForm tf;

tf = tfNewNode(TF_Except, 2,
       tfp0Float(stab, ab->abExcept.type),
       tfp0Float(stab, ab->abExcept.except));

return tf;
1042}

1044localstatic TForm
1045tfpIf(Stab stab, AbSyn ab)
1046{
TForm	test, thenAlt, elseAlt;
TForm	tf;

test = tfp0Float(stab, ab->abIf.test);

tfpConditions = listCons(AbSyn)(AbSyn_listPointer->Cons)(ab->abIf.test, tfpConditions);
thenAlt = tfp0Float(stab, ab->abIf.thenAlt);
tfpConditions = cdr(tfpConditions)((tfpConditions)->rest);

elseAlt = tfp0Float(stab, ab->abIf.elseAlt);

tf = tfNewNode(TF_If, 3, test, thenAlt, elseAlt);

return tf;
1061}

1063localstatic TForm
1064tfpApply(Stab stab, AbSyn ab)
1065{
AbSyn	op;
Symbol	sym;
Length	i, argc;
Syme	syme;
Syme    opSyme;
TForm	tf;

op = abApplyOp(ab)((ab)->abApply.op);
if (abTag(op)((op)->abHdr.tag) != AB_Id)
return tfp0General(stab, ab);

sym  = op->abId.sym;
argc = abApplyArgc(ab)(((ab)->abHdr.argc)-1);
opSyme = abSyme(op)((op)->abHdr.seman ? (op)->abHdr.seman->syme : 0);

syme = tfp0OpSyme(stab, opSyme, sym, argc);

if (syme == NULL((void*)0))
/* This op is not one of the known special tform ops. */
tf = tfp0General(stab, ab);

else if (abSyme(op)((op)->abHdr.seman ? (op)->abHdr.seman->syme : 0) 
 && tfSymesEqModExtends(symeOriginal(abSyme(op)((op)->abHdr.seman ? (op)->abHdr.seman->syme : 0)), 
			symeOriginal(syme))) {
/* This syme is one of the known special tform ops. */
tf = tfp0OpTForm(sym, argc);
for (i = 0; i < argc; i += 1)
	tfArgv(tf)((tf)->argv)[i] = tfp0Float(stab, abApplyArg(ab, i)((ab)->abApply.argv[i]));
}

else if (abSyme(op)((op)->abHdr.seman ? (op)->abHdr.seman->syme : 0) == NULL((void*)0) &&
 listMemq(Syme)(Syme_listPointer->Memq)(stabGetMeanings(stab, NULL((void*)0), sym), syme)) {
/* This op could be one of the known special tform ops. */
/* Don't try to do any type inference here. */
tf = tfp0OpTForm(sym, argc);
for (i = 0; i < argc; i += 1)
	tfArgv(tf)((tf)->argv)[i] = tfp0Float(stab, abApplyArg(ab, i)((ab)->abApply.argv[i]));
}

else
/* This op is not one of the known special tforms ops. */
tf = tfp0General(stab, ab);

return tf;
1110}

1112/* 
* tfPending may have to avoid symeEqual, as we might not
* yet know enough about types.  NB: There might be a better
* test for this case (where we get an extended meaning in 
* the above fn).
*/
1118localstatic Bool
1119tfSymesEqModExtends(Syme syme1, Syme syme2)
1120{
SymeList exts;

if (syme1 == syme2)
return true1;
if (symeIsExtend(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)
->lib) : ((void*)0)), (syme2))->kind) == SYME_Extend)) {
for (exts = symeExtendee(syme2); exts ; exts = cdr(exts)((exts)->rest)) {
	if (tfSymesEqModExtends(car(exts)((exts)->first), syme1))
		return true1;
}	
}

if (!symeIsExtend(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)
->lib) : ((void*)0)), (syme1))->kind) == SYME_Extend))
return false((int) 0);

for (exts = symeExtendee(syme1); exts ; exts = cdr(exts)((exts)->rest)) {
if (tfSymesEqModExtends(car(exts)((exts)->first), syme2))
	return true1;
}
return false((int) 0);
1140}

1142/*****************************************************************************
*
* :: Declarations for tfMeaning
*
****************************************************************************/

1148localstatic TForm	tfm0General	(Stab, AbSyn, TForm);
1149localstatic TForm	tfm0Args	(Stab, TForm);
1150localstatic void	tfm0FoamType	(TForm);

1152localstatic TForm	tfmNothing	(Stab, AbSyn, TForm);
1153localstatic TForm	tfmBlank	(Stab, AbSyn, TForm);
1154localstatic TForm	tfmId		(Stab, AbSyn, TForm);
1155localstatic TForm	tfmDeclare	(Stab, AbSyn, TForm);
1156localstatic TForm	tfmDefine	(Stab, AbSyn, TForm);
1157localstatic TForm	tfmAssign	(Stab, AbSyn, TForm);
1158localstatic TForm	tfmComma	(Stab, AbSyn, TForm);
1159localstatic TForm	tfmAdd		(Stab, AbSyn, TForm);
1160localstatic TForm	tfmWith		(Stab, AbSyn, TForm);
1161localstatic TForm	tfmIf		(Stab, AbSyn, TForm);
1162localstatic TForm	tfmApply	(Stab, AbSyn, TForm);
1163localstatic TForm 	tfmExcept	(Stab, AbSyn, TForm);

1165/*****************************************************************************
*
* :: tfMeaning
*
****************************************************************************/

1171TForm
1172tfMeaning(Stab stab, AbSyn ab, TForm tf)
1173{
static int	serialNo = 0, depthNo = 0;
int		serialThis;

tfFollow(tf)((tf) = tfFollowFn(tf));

assert(!tfIsSyntax(tf))do { if (!(!(((tf)->tag) == TF_Syntax))) _do_assert(("!tfIsSyntax(tf)"
),"tform.c",1179); } while (0);
if (tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning))
return tf;
tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);

if (!abIsSefo(ab)(((ab)->abHdr.state) == AB_State_HasUnique)) {
tfm0Args(stab, tf);
tfGetSymes(stab, tf, ab);
tfCheckConsts(tf);
return tf;
}
if (!abIsSefo(tfGetExpr(tf))(((((tf)->__absyn))->abHdr.state) == AB_State_HasUnique
))
abTransferSemantics(ab, tfGetExpr(tf)((tf)->__absyn));

serialNo += 1;
depthNo	 += 1;
serialThis = serialNo;
if (DEBUG(tfExpr)tfExprDebug) {
fprintf(dbOut, "->tfm: %*s%d= ", depthNo, "", serialThis);
abPrettyPrint(dbOut, ab);
fnewline(dbOut);
}

/* The stab is used to look up meanings for ids without them. */
if (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0))
stab = abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0);

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Nothing:	tf = tfmNothing (stab, ab, tf); break;
case AB_Blank:		tf = tfmBlank	(stab, ab, tf); break;
case AB_Id:		tf = tfmId	(stab, ab, tf); break;
case AB_Declare:	tf = tfmDeclare (stab, ab, tf); break;
case AB_Define:		tf = tfmDefine	(stab, ab, tf); break;
case AB_Assign:		tf = tfmAssign	(stab, ab, tf); break;
case AB_Comma:		tf = tfmComma	(stab, ab, tf); break;
case AB_Add:		tf = tfmAdd	(stab, ab, tf); break;
case AB_With:		tf = tfmWith	(stab, ab, tf); break;
case AB_If:		tf = tfmIf	(stab, ab, tf); break;
case AB_Apply:		tf = tfmApply	(stab, ab, tf); break;
case AB_Except:		tf = tfmExcept	(stab, ab, tf); break;
default:		tf = tfm0General(stab, ab, tf); break;
}

tfCheckConsts(tf);
tfm0FoamType(tf);

if (DEBUG(tfExpr)tfExprDebug) {
fprintf(dbOut, "<-tfm: %*s%d= ", depthNo, "", serialThis);
tfPrint(dbOut, tf);
fnewline(dbOut);
}
depthNo -= 1;

return tf;
1233}

1235void
1236tfSetMeaningArgs(TForm tf)
1237{
Length	i;

tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
if (!tfIsMeaning(tfFollowArg(tf, i))(((tfFollowArg(tf, i))->state)>=TF_State_Meaning))
	tfSetTForm(tf)(((tf)->state)=TF_State_TForm);
1244}

1246/*****************************************************************************
*
* :: tfMeaning helper functions
*
****************************************************************************/

1252localstatic TForm
1253tfm0General(Stab stab, AbSyn ab, TForm tf)
1254{
return tf;
1256}

1258localstatic TForm
1259tfm0Args(Stab stab, TForm tf)
1260{
Length	i, argc = tfArgc(tf)((tf)->argc);

for (i = 0; i < argc; i += 1) {
TForm	tfarg = tfArgv(tf)((tf)->argv)[i];
tfMeaning(stab, tfGetExpr(tfarg)((tfarg)->__absyn), tfarg);
}

return tf;
1269}

1271localstatic void
1272tfm0FoamType(TForm tf)
1273{
AbSyn	ab;
Syme	syme;
TForm	ntf;
Bool	chk = false((int) 0);
Symbol	sym;
FoamTag	tag = FOAM_LIMIT;

ab = tfGetExpr(tf)((tf)->__absyn);
if (ab == NULL((void*)0)) return;

syme = abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0);
if (syme == NULL((void*)0)) return;

switch (symeKind(syme)((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind)) {
case SYME_Export:
ntf = tfDefineeType(symeType(syme));
chk = tfIsType(ntf)(((ntf)->tag) == TF_Type);
break;
case SYME_Import:
ntf = tfDefineeType(symeExporter(syme));
chk = tfIsTheId(ntf, ssymMachine)(((((ntf)->tag) == TF_General) && ((((ntf)->__absyn
))->abHdr.tag) == AB_Id) && (((ntf)->__absyn)->
abId.sym) == (ssymMachine)) || tfIsTheId(ntf, ssymBasic)(((((ntf)->tag) == TF_General) && ((((ntf)->__absyn
))->abHdr.tag) == AB_Id) && (((ntf)->__absyn)->
abId.sym) == (ssymBasic));
break;
default:
break;
}

if (chk == false((int) 0)) return;
sym = symeId(syme)((syme)->id);

    if (sym == ssymBool)	tag = FOAM_Bool;
else if (sym == ssymByte)	tag = FOAM_Byte;
else if (sym == ssymHInt)	tag = FOAM_HInt;
else if (sym == ssymSInt)	tag = FOAM_SInt;
else if (sym == ssymBInt)	tag = FOAM_BInt;
else if (sym == ssymChar)	tag = FOAM_Char;
else if (sym == ssymSFlo)	tag = FOAM_SFlo;
else if (sym == ssymDFlo)	tag = FOAM_DFlo;
else if (sym == ssymNil)	tag = FOAM_Nil;
else if (sym == ssymPtr)	tag = FOAM_Ptr;
else if (sym == ssymArr) 	tag = FOAM_Arr;
tfFoamType(tf)((tf)->raw) = tag;
1315}

1317/*****************************************************************************
*
* :: tfMeaning cases
*
****************************************************************************/

1323localstatic TForm
1324tfmNothing(Stab stab, AbSyn ab, TForm tf)
1325{
assert(tfIsNone(tf))do { if (!(((((tf)->tag) == TF_Multiple) && tfMultiArgc
(tf) == 0))) _do_assert(("tfIsNone(tf)"),"tform.c",1326); } while
 (0);
return tfm0General(stab, ab, tf);
1328}

1330localstatic TForm
1331tfmBlank(Stab stab, AbSyn ab, TForm tf)
1332{
1333#ifdef UseTypeVariables
assert(tfIsVariable(tf))do { if (!((((tf)->tag) == TF_Variable))) _do_assert(("tfIsVariable(tf)"
),"tform.c",1334); } while (0);
1335#else
assert(tfIsUnknown(tf))do { if (!((((tf)->tag) == TF_Unknown))) _do_assert(("tfIsUnknown(tf)"
),"tform.c",1336); } while (0);
1337#endif

return tfm0General(stab, ab, tf);
1340}

1342localstatic TForm
1343tfmId(Stab stab, AbSyn ab, TForm tf)
1344{
Syme	syme = abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0);

/*!! assert(syme); */
if (!syme) return tf;

if (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))
tfSetSymes(tf, listCons(Syme)(syme, listNil(Syme)))((tf)->symes = ((Syme_listPointer->Cons)(syme, ((SymeList
) 0))));

return tf;
1354}

1356localstatic TForm
1357tfmDeclare(Stab stab, AbSyn ab, TForm tf)
1358{
assert(tfIsDeclare(tf))do { if (!((((tf)->tag) == TF_Declare))) _do_assert(("tfIsDeclare(tf)"
),"tform.c",1359); } while (0);
tfMeaning(stab, ab->abDeclare.type, tfDeclareType(tf)tfFollowArg(tf, 0));
tfSetSymes(tf, tfSymesFrDeclare(ab))((tf)->symes = (tfSymesFrDeclare(ab)));
return tf;
1363}

1365localstatic TForm
1366tfmDefine(Stab stab, AbSyn ab, TForm tf)
1367{
AbSyn	lhs, rhs;
TForm	tfl, tfr;

lhs = ab->abDefine.lhs;
rhs = ab->abDefine.rhs;

tfl = tfArgv(tf)((tf)->argv)[0];
tfr = tfArgv(tf)((tf)->argv)[1];

assert(tfIsDefine(tf))do { if (!((((tf)->tag) == TF_Define))) _do_assert(("tfIsDefine(tf)"
),"tform.c",1377); } while (0);
if (abTag(lhs)((lhs)->abHdr.tag) != AB_Declare)
lhs = tfGetExpr(tfl)((tfl)->__absyn);

tfMeaning(stab, lhs, tfl);
if (tfIsSyntax(tfr)(((tfr)->tag) == TF_Syntax)) {
if (tfSatType(tfl))
	tfForwardFrSyntax(tfr, tfp0Float(stab, rhs));
else
	tfForwardFrSyntax(tfr, tfNewAbSyn(TF_General, rhs));
}
tfMeaning(stab, rhs, tfr);

return tf;
1391}

1393localstatic TForm
1394tfmAssign(Stab stab, AbSyn ab, TForm tf)
1395{
AbSyn	lhs, rhs;
TForm	tfl, tfr;

lhs = ab->abDefine.lhs;
rhs = ab->abDefine.rhs;

tfl = tfArgv(tf)((tf)->argv)[0];
tfr = tfArgv(tf)((tf)->argv)[1];

assert(tfIsAssign(tf))do { if (!((((tf)->tag) == TF_Assign))) _do_assert(("tfIsAssign(tf)"
),"tform.c",1405); } while (0);
if (abTag(lhs)((lhs)->abHdr.tag) != AB_Declare)
lhs = tfGetExpr(tfl)((tfl)->__absyn);

tfMeaning(stab, lhs, tfl);
if (tfIsSyntax(tfr)(((tfr)->tag) == TF_Syntax)) {
if (tfSatType(tfl))
	tfForwardFrSyntax(tfr, tfp0Float(stab, rhs));
else
	tfForwardFrSyntax(tfr, tfNewAbSyn(TF_General, rhs));
}
tfMeaning(stab, rhs, tfr);

return tf;
1419}

1421localstatic TForm
1422tfmComma(Stab stab, AbSyn ab, TForm tf)
1423{
Length	i, argc;

argc = abArgc(ab)((ab)->abHdr.argc);
if (argc == 1) {
tfSetTForm(tf)(((tf)->state)=TF_State_TForm);
tfMeaning(stab, abArgv(ab)((ab)->abGen.data.argv)[0], tf);
}
else {
assert(tfIsMulti(tf) && argc == tfMultiArgc(tf))do { if (!((((tf)->tag) == TF_Multiple) && argc ==
 tfMultiArgc(tf))) _do_assert(("tfIsMulti(tf) && argc == tfMultiArgc(tf)"
),"tform.c",1432); } while (0);
for (i = 0; i < argc; i += 1)
	tfMeaning(stab, abArgv(ab)((ab)->abGen.data.argv)[i], tfArgv(tf)((tf)->argv)[i]);
tfSetSymes(tf, tfSymesFrMulti(tf))((tf)->symes = (tfSymesFrMulti(tf)));
}

return tf;
1439}

1441localstatic TForm
1442tfmAdd(Stab stab, AbSyn ab, TForm tf)
1443{
assert(tfIsAdd(tf))do { if (!((((tf)->tag) == TF_Add))) _do_assert(("tfIsAdd(tf)"
),"tform.c",1444); } while (0);

tfMeaning(stab, ab->abAdd.base, tfAddBase(tf)tfFollowArg(tf, 0));
tfSetSymes(tf, tfSymesFrAdd(ab))((tf)->symes = (tfSymesFrAdd(ab)));
tfGetSelf(stab, tf);

return tf;
1451}

1453localstatic TForm
1454tfmWith(Stab stab, AbSyn ab, TForm tf)
1455{
assert(tfIsWith(tf))do { if (!((((tf)->tag) == TF_With))) _do_assert(("tfIsWith(tf)"
),"tform.c",1456); } while (0);

tfMeaning(stab, ab->abWith.base,   tfWithBase(tf)tfFollowArg(tf, 0));
tfMeaning(stab, ab->abWith.within, tfWithWithin(tf)tfFollowArg(tf, 1));
tfGetSelf(stab, tf);

return tf;
1463}

1465localstatic TForm
1466tfmExcept(Stab stab, AbSyn ab, TForm tf)
1467{
assert(tfIsExcept(tf))do { if (!((((tf)->tag) == TF_Except))) _do_assert(("tfIsExcept(tf)"
),"tform.c",1468); } while (0);

tfMeaning(stab, ab->abExcept.type,   tfExceptType(tf)tfFollowArg(tf, 0));
tfMeaning(stab, ab->abExcept.except, tfExceptExcept(tf)tfFollowArg(tf, 1));

return tf;
1474}

1476localstatic TForm
1477tfmIf(Stab stab, AbSyn ab, TForm tf)
1478{
assert(tfIsIf(tf))do { if (!((((tf)->tag) == TF_If))) _do_assert(("tfIsIf(tf)"
),"tform.c",1479); } while (0);

tfMeaning(stab, ab->abIf.test,    tfIfTest(tf)tfFollowArg(tf, 0));
tfMeaning(stab, ab->abIf.thenAlt, tfIfThen(tf)tfFollowArg(tf, 1));
tfMeaning(stab, ab->abIf.elseAlt, tfIfElse(tf)tfFollowArg(tf, 2));
tfGetSelf(stab, tf);

return tf;
1487}

1489localstatic TForm
1490tfmApply(Stab stab, AbSyn ab, TForm tf)
1491{
if (!tfIsGeneral(tf)(((tf)->tag) == TF_General)) {
Length		i, argc = abApplyArgc(ab)(((ab)->abHdr.argc)-1);
assert(argc == tfArgc(tf))do { if (!(argc == ((tf)->argc))) _do_assert(("argc == tfArgc(tf)"
),"tform.c",1494); } while (0);
for (i = 0; i < argc; i += 1)
	tfMeaning(stab, abApplyArg(ab, i)((ab)->abApply.argv[i]), tfArgv(tf)((tf)->argv)[i]);
}

tfGetSymes(stab, tf, ab);

return tf;
1502}

1504void
1505tfGetSymes(Stab stab, TForm tf, AbSyn ab)
1506{
SymeList	symes = listNil(Syme)((SymeList) 0);
assert(ab)do { if (!(ab)) _do_assert(("ab"),"tform.c",1508); } while (0
);

switch (tfTag(tf)((tf)->tag)) {
case TF_Map:
case TF_PackedMap:
symes = tfSymesFrMap(tf);
break;
case TF_Cross:
symes = tfSymesFrCross(tf);
break;
case TF_Enumerate:
symes = tfSymesFrEnum(stab, tf, ab);
break;
case TF_RawRecord:
symes = tfSymesFrRawRecord(stab, tf, ab);
break;
case TF_Record:
symes = tfSymesFrRecord(stab, tf, ab);
break;
case TF_TrailingArray:
symes = tfSymesFrTrailingArray(stab, tf, ab);
break;
case TF_Union:
symes = tfSymesFrUnion(stab, tf, ab);
break;
default:
break;
}

tfSetSymes(tf, symes)((tf)->symes = (symes));
1538}

1540/******************************************************************************
*
* :: tfToAbSyn
*
*****************************************************************************/

1546AbSyn
1547tfToAbSyn(TForm tf)
1548{
return tfToAbSyn0(tf, false((int) 0));
1550}

1552AbSyn
1553tfToAbSynPretty(TForm tf)
1554{
return tfToAbSyn0(tf, true1);
1556}

1558localstatic AbSyn
1559tfToAbSyn0(TForm tf, Bool pretty)
1560{
AbSyn	ab;
Syme	syme;
Length	i;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfHasExpr(tf)((tf)->__absyn != 0) && !pretty)
return tfGetExpr(tf)((tf)->__absyn);

if (DEBUG(tfExpr)tfExprDebug) {
fprintf(dbOut, "tfToAbSyn -> ");
tfPrint(dbOut, tf);
fnewline(dbOut);
}

switch (tfTag(tf)((tf)->tag)) {
case TF_Unknown:
ab = abUnknown;
break;
case TF_Exit:
ab = abNewId(sposNone, ssymExit)abNew(AB_Id, sposNone,1, ssymExit);
break;
case TF_Literal:
ab = abNewId(sposNone, ssymLiteral)abNew(AB_Id, sposNone,1, ssymLiteral);
break;
case TF_Test:
ab = abNewId(sposNone, ssymTest)abNew(AB_Id, sposNone,1, ssymTest);
break;
case TF_Type:
ab = abNewId(sposNone, ssymType)abNew(AB_Id, sposNone,1, ssymType);
break;
case TF_Category:
ab = abNewId(sposNone, ssymCategory)abNew(AB_Id, sposNone,1, ssymCategory);
break;

case TF_Syntax:
ab = tfGetExpr(tf)((tf)->__absyn);
break;
case TF_General:
ab = tfGetExpr(tf)((tf)->__absyn);
break;

case TF_Add:
ab = abNewAdd(sposNone,abNew(AB_Add, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfSymesToAdd(((tf)->symes)))
	      tfDisownExpr(tfAddBase(tf), pretty),abNew(AB_Add, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfSymesToAdd(((tf)->symes)))
	      tfSymesToAdd(tfSymes(tf)))abNew(AB_Add, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfSymesToAdd(((tf)->symes)));
break;
case TF_Assign:
ab = abNewAssign(sposNone,abNew(AB_Assign, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty))
		 tfDisownExpr(tfAssignDecl(tf), pretty),abNew(AB_Assign, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty))
		 tfDisownExpr(tfAssignVal(tf), pretty))abNew(AB_Assign, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty));
break;
case TF_Cross:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymCross)abNew(AB_Id, sposNone,1, ssymCross);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Declare:
syme = tfDeclareSyme(tf);
if (syme)
	ab = abFrSyme(syme);
else
	ab = abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
ab = abNewDeclare(sposNone, ab,abNew(AB_Declare, sposNone,2, ab,tfDisownExpr(tfFollowArg(tf,
 0), pretty))
		  tfDisownExpr(tfDeclareType(tf), pretty))abNew(AB_Declare, sposNone,2, ab,tfDisownExpr(tfFollowArg(tf,
 0), pretty));
break;
case TF_Define:
ab = abNewDefine(sposNone,abNew(AB_Define, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty)) 
		 tfDisownExpr(tfDefineDecl(tf), pretty),abNew(AB_Define, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty))
		 tfDisownExpr(tfDefineVal(tf), pretty))abNew(AB_Define, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty));
break;
case TF_Enumerate:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymEnum)abNew(AB_Id, sposNone,1, ssymEnum);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Generator:
ab = abNewApply1(sposNone, abNewId(sposNone, ssymGenerator),abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymGenerator
),tfDisownExpr(tfFollowArg(tf, 0), pretty))
		 tfDisownExpr(tfGeneratorArg(tf), pretty))abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymGenerator
),tfDisownExpr(tfFollowArg(tf, 0), pretty));
break;
case TF_If:
ab = abNewIf(sposNone,abNew(AB_If, sposNone,3, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfDisownExpr(tfFollowArg(tf, 1), pretty),tfDisownExpr(tfFollowArg
(tf, 2), pretty))
	     tfDisownExpr(tfIfTest(tf), pretty),abNew(AB_If, sposNone,3, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfDisownExpr(tfFollowArg(tf, 1), pretty),tfDisownExpr(tfFollowArg
(tf, 2), pretty))
	     tfDisownExpr(tfIfThen(tf), pretty),abNew(AB_If, sposNone,3, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfDisownExpr(tfFollowArg(tf, 1), pretty),tfDisownExpr(tfFollowArg
(tf, 2), pretty))
	     tfDisownExpr(tfIfElse(tf), pretty))abNew(AB_If, sposNone,3, tfDisownExpr(tfFollowArg(tf, 0), pretty
),tfDisownExpr(tfFollowArg(tf, 1), pretty),tfDisownExpr(tfFollowArg
(tf, 2), pretty));
break;
case TF_Join:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymJoin)abNew(AB_Id, sposNone,1, ssymJoin);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Map:
ab = abNewApply2(sposNone, abNewId(sposNone, ssymArrow),abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymArrow
),tfDisownExpr(tfFollowArg(tf, 0), pretty),tfDisownExpr(tfFollowArg
(tf, 1), pretty))
		 tfDisownExpr(tfMapArg(tf), pretty),abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymArrow
),tfDisownExpr(tfFollowArg(tf, 0), pretty),tfDisownExpr(tfFollowArg
(tf, 1), pretty))
		 tfDisownExpr(tfMapRet(tf), pretty))abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymArrow
),tfDisownExpr(tfFollowArg(tf, 0), pretty),tfDisownExpr(tfFollowArg
(tf, 1), pretty));
break;
case TF_Meet:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymMeet)abNew(AB_Id, sposNone,1, ssymMeet);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Multiple:
ab = abNewEmpty(AB_Comma, tfArgc(tf)((tf)->argc));
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abArgv(ab)((ab)->abGen.data.argv)[i] = tfDisownExpr(tfArgv(tf)((tf)->argv)[i], pretty);
break;
case TF_PackedMap:
ab = abNewApply2(sposNone, abNewId(sposNone, ssymPackedArrow),abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymPackedArrow
),tfDisownExpr(tfFollowArg(tf, 0), pretty),tfDisownExpr(tfFollowArg
(tf, 1), pretty))
		 tfDisownExpr(tfMapArg(tf), pretty),abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymPackedArrow
),tfDisownExpr(tfFollowArg(tf, 0), pretty),tfDisownExpr(tfFollowArg
(tf, 1), pretty))
		 tfDisownExpr(tfMapRet(tf), pretty))abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymPackedArrow
),tfDisownExpr(tfFollowArg(tf, 0), pretty),tfDisownExpr(tfFollowArg
(tf, 1), pretty));
break;
case TF_Raw:
ab = abNewApply1(sposNone, abNewId(sposNone, ssymRaw),abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymRaw)
,tfDisownExpr(tfFollowArg(tf, 0), pretty))
		 tfDisownExpr(tfRawArg(tf), pretty))abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymRaw)
,tfDisownExpr(tfFollowArg(tf, 0), pretty));
break;
case TF_RawRecord:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymRawRecord)abNew(AB_Id, sposNone,1, ssymRawRecord);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Record:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymRecord)abNew(AB_Id, sposNone,1, ssymRecord);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Reference:
ab = abNewApply1(sposNone, abNewId(sposNone, ssymReference),abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymReference
),tfDisownExpr(tfFollowArg(tf, 0), pretty))
		 tfDisownExpr(tfReferenceArg(tf), pretty))abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymReference
),tfDisownExpr(tfFollowArg(tf, 0), pretty));
break;
case TF_TrailingArray: 
ab = abNewApply2(sposNone, abNewId(sposNone, ssymTrailingArray),abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymTrailingArray
),tfDisownExpr(((tf)->argv)[0], pretty),tfDisownExpr(((tf)
->argv)[1], pretty))
		 tfDisownExpr(tfArgv(tf)[0], pretty),abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymTrailingArray
),tfDisownExpr(((tf)->argv)[0], pretty),tfDisownExpr(((tf)
->argv)[1], pretty))
		 tfDisownExpr(tfArgv(tf)[1], pretty))abNew(AB_Apply, sposNone,3, abNew(AB_Id, sposNone,1, ssymTrailingArray
),tfDisownExpr(((tf)->argv)[0], pretty),tfDisownExpr(((tf)
->argv)[1], pretty));
break;
case TF_Third:
ab = tfDisownExpr(tfThirdRestrictions(tf)tfFollowArg(tf, 0), pretty);
if (pretty)
	ab = abNewDefine(sposNone,abNew(AB_Define, sposNone,2, abNew(AB_Id, sposNone,1, ssymCategory
),ab)
			 abNewId(sposNone, ssymCategory), ab)abNew(AB_Define, sposNone,2, abNew(AB_Id, sposNone,1, ssymCategory
),ab);
else
	ab = abNewApply1(sposNone,abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymThird
),ab)
			 abNewId(sposNone, ssymThird), ab)abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymThird
),ab);
break;
case TF_Tuple:
ab = abNewApply1(sposNone, abNewId(sposNone, ssymTuple),abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymTuple
),tfDisownExpr(tfFollowArg(tf, 0), pretty))
		 tfDisownExpr(tfTupleArg(tf), pretty))abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymTuple
),tfDisownExpr(tfFollowArg(tf, 0), pretty));
break;
case TF_Union:
ab = abNewEmpty(AB_Apply, tfArgc(tf)((tf)->argc) + 1);
abApplyOp(ab)((ab)->abApply.op) = abNewId(sposNone, ssymUnion)abNew(AB_Id, sposNone,1, ssymUnion);
for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1 )
	abSetApplyArg(ab, i,((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)))
		      tfDisownExpr(tfArgv(tf)[i], pretty))((ab)->abApply.argv[i] = (tfDisownExpr(((tf)->argv)[i],
 pretty)));
break;
case TF_Variable:
ab = abNewBlank(sposNone, ssymVariable)abNew(AB_Blank, sposNone,1, ssymVariable);
break;
case TF_With: {
AbSyn	abbase, abwith;

if (tfIsNone(tfWithBase(tf))((((tfFollowArg(tf, 0))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 0)) == 0))
	abbase = abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
else
	abbase = tfDisownExpr(tfWithBase(tf)tfFollowArg(tf, 0), pretty);

if (pretty && tfUseCatExports(tf)(((((tfFollowArg(tf, 0))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 0)) == 0) && ((((tfFollowArg(tf, 1))
->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg(
tf, 1)) == 0)))
	abwith = tfSymesToWith(tfGetCatExports(tf));
else if (tfIsNone(tfWithWithin(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)) == 0))
	abwith = abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
else
	abwith = tfDisownExpr(tfWithWithin(tf)tfFollowArg(tf, 1), pretty);

ab = abNewWith(sposNone, abbase, abwith)abNew(AB_With, sposNone,2, abbase,abwith);
break;
}
case TF_XGenerator:
ab = abNewApply1(sposNone, abNewId(sposNone, ssymXGenerator),abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymXGenerator
),tfDisownExpr(tfFollowArg(tf, 0), pretty))
		 tfDisownExpr(tfGeneratorArg(tf), pretty))abNew(AB_Apply, sposNone,2, abNew(AB_Id, sposNone,1, ssymXGenerator
),tfDisownExpr(tfFollowArg(tf, 0), pretty));
break;
case TF_Except:
ab = abNewExcept(sposNone,abNew(AB_Except, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty)) 
		 tfDisownExpr(tfExceptType(tf), pretty),abNew(AB_Except, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty))
		 tfDisownExpr(tfExceptExcept(tf), pretty))abNew(AB_Except, sposNone,2, tfDisownExpr(tfFollowArg(tf, 0),
 pretty),tfDisownExpr(tfFollowArg(tf, 1), pretty));
break;

default:
bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag)
, 1759, "tform.c");
NotReached(ab = abNewNothing(sposNone)){(void)bug("Not supposed to reach line %d in file: %s\n",1760
, "tform.c");};
}

if (DEBUG(tfExpr)tfExprDebug) {
fprintf(dbOut, "tfToAbSyn <- ");
abPrettyPrintClippedIn(dbOut, ab, 65, 1);
fnewline(dbOut);
}

if (!pretty) {
tfSetExpr(tf, ab);
tfOwnExpr(tf);
}
return ab;
1774}

1776/******************************************************************************
*
* :: Type form syntax.
*
*****************************************************************************/

1782localstatic void
1783tfSetExpr(TForm tf, AbSyn ab)
1784{
if (!tfHasExpr(tf)((tf)->__absyn != 0))
tf->__absyn = ab;

if (!abTForm(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->tform : 0))
abSetTForm(ab, tf);

return;
1792}

1794localstatic Bool
1795tfOwnsExpr(TForm tf)
1796{
return tf->ownSyntax;
1798}

1800/*
* tfOwnExpr assumes that tfExpr(tf) was just constructed
* from newly created abstract syntax nodes.
*/
1804void
1805tfOwnExpr(TForm tf)
1806{
tf->ownSyntax = true1;
return;
1809}

1811/* Release any ownership interest that tf has in ab. */
1812void
1813tfReleaseExpr(TForm tf, AbSyn ab)
1814{
if (tf->__absyn == ab) {
tf->__absyn = 0;
tf->ownSyntax = false((int) 0);
}
1819}

1821/*
* Return an abstract syntax tree which the caller
* is allowed/required to free.
*/
1825localstatic AbSyn
1826tfDisownExpr(TForm tf, Bool pretty)
1827{
AbSyn	ab = tfToAbSyn0(tf, pretty);

if (DEBUG(tfExpr)tfExprDebug) {
fprintf(dbOut, "tfDisownExpr -> ");
tfPrint(dbOut, tf);
fnewline(dbOut);
abPrettyPrintClippedIn(dbOut, ab, 65, 1);
fnewline(dbOut);
}

if (!pretty) {
if (!tfOwnsExpr(tf)) ab = sefoCopy(ab);
tf->ownSyntax = false((int) 0);
}
return ab;
1843}

1845/* Transfer the type form semantics from ntf to tf. */
1846void
1847tfTransferSemantics(TForm ntf, TForm tf)
1848{
if (!abIsSefo(tfGetExpr(tf))(((((tf)->__absyn))->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), tfGetExpr(tf)((tf)->__absyn));
tfCopyState(tf, ntf)(((tf)->state) = ((ntf)->state));
}
1854}

1856/******************************************************************************
*
* :: Type form construction path.
*
*****************************************************************************/

1862/*
* Create a syntactic tform.
*/
1865TForm
1866tfSyntaxFrAbSyn(Stab stab, AbSyn ab)
1867{
Stab	nstab = (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) ? abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) : stab);
TForm	tf, tfret;

if ((tf = abTForm(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->tform : 0)) != NULL((void*)0))
return tf;

if (abIsTheId(ab, ssymCategory)(((ab)->abHdr.tag == (AB_Id)) && ((ab)->abId.sym
)==(ssymCategory)))
return tfCategory;

if (abIsId(ab)((ab)->abHdr.tag == (AB_Id)) && abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0) && symeIsParam(abSyme(ab))(((((((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0
))->kind == SYME_Trigger ? libGetAllSymes((((ab)->abHdr
.seman ? (ab)->abHdr.seman->syme : 0))->lib) : ((void
*)0)), (((ab)->abHdr.seman ? (ab)->abHdr.seman->syme
 : 0)))->kind) == SYME_Param)) {
Stab rstab = stabFindLevel(stab, abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0));
stab = rstab;
    
}
if ((tf = stabGetTForm(stab, ab, NULL((void*)0))) != NULL((void*)0))
return tf;

if (abIsAnyMap(ab)(((((ab)->abHdr.tag == (AB_Apply)) && (((((ab)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((ab)->
abApply.op))->abId.sym)==(ssymArrow))) && (((ab)->
abHdr.argc)-1) == 2) || ((((ab)->abHdr.tag == (AB_Apply)) &&
 (((((ab)->abApply.op))->abHdr.tag == (AB_Id)) &&
 ((((ab)->abApply.op))->abId.sym)==(ssymPackedArrow))) &&
 (((ab)->abHdr.argc)-1) == 2))) {
tfret = tfSyntaxFrAbSyn(nstab, abMapRet(ab)((ab)->abApply.argv[1]));
tf = tfSyntaxMap(nstab, ab, tfret);
}
else
tf = tfNewSyntax(ab);

stabDefTForm(stab, tf);

return tf;
1895}

1897/*
* Create a map type form with syntactic parts.
*/
1900TForm
1901tfSyntaxMap(Stab stab, AbSyn map, TForm tfret)
1902{
AbSyn	ab, abarg = abMapArg(map)((map)->abApply.argv[0]);
Length	i, argc = abArgc(abarg)((abarg)->abHdr.argc);
TForm	tf, tfarg;

if (abTag(abarg)((abarg)->abHdr.tag) == AB_Comma && argc != 1) {
tfarg = tfNewEmpty(TF_Multiple, argc);
for (i = 0; i < argc; i += 1)
	tfArgv(tfarg)((tfarg)->argv)[i] =
		tfSyntaxFrAbSyn(stab, abArgv(abarg)((abarg)->abGen.data.argv)[i]);
abSetPos(tfExpr(tfarg), abPos(abarg))((tfToAbSyn(tfarg))->abHdr.pos=spstackSetFirst ((tfToAbSyn
(tfarg))->abHdr.pos,((spstackFirst((abarg)->abHdr.pos))
)));
}
else
tfarg = tfSyntaxFrAbSyn(stab, abarg);

tf = tfAnyMap(tfarg, tfret, abIsPackedMap(map)((((map)->abHdr.tag == (AB_Apply)) && (((((map)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((map)->
abApply.op))->abId.sym)==(ssymPackedArrow))) && ((
(map)->abHdr.argc)-1) == 2));
ab = tfExpr(tf)tfToAbSyn(tf);

tfSetPending(tf)(((tf)->state)=TF_State_Pending);
abSetTForm(map, tf);
abTransferSemantics(map, ab);

abSetPos(ab, abPos(map))((ab)->abHdr.pos=spstackSetFirst ((ab)->abHdr.pos,((spstackFirst
((map)->abHdr.pos)))));
abSetPos(abApplyOp(ab), abPos(abApplyOp(map)))((((ab)->abApply.op))->abHdr.pos=spstackSetFirst ((((ab
)->abApply.op))->abHdr.pos,((spstackFirst((((map)->abApply
.op))->abHdr.pos)))));

return tf;
1928}

1930void
1931tfSyntaxConditions(Stab stab, TForm tf, TfCondElt conditions)
1932{
int i;
if (DEBUG(tf)tfDebug) {
if (conditions != NULL((void*)0))
	afprintf(dbOut, "Adding Condition: %pTForm - %pAbSynList %d\n", 
		 tf, conditions->list,
		 tfIsSyntax(tf)(((tf)->tag) == TF_Syntax) || tfIsMap(tf)(((tf)->tag) == TF_Map) || tfIsEmptyMulti(tf)((((tf)->tag) == TF_Multiple) && tfMultiArgc(tf) ==
 0) || tfIsWith(tf)(((tf)->tag) == TF_With));
}

if (!tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning))
tfMergeConditions(tf, stab, conditions);

for (i=0; i<tfArgc(tf)((tf)->argc); i++) {
tfSyntaxConditions(stab, tfArgv(tf)((tf)->argv)[i], conditions);
}
1947}


1950/*
* Create a define type form with syntactic parts.
*/
1953TForm
1954tfSyntaxDefine(Stab stab, AbSyn lhs, AbSyn rhs)
1955{
TForm	tf, tflhs, tfrhs;
AbSyn	ab;

if (abHasTag(rhs, AB_Label)((rhs)->abHdr.tag == (AB_Label)))
rhs = rhs->abLabel.expr;

tflhs = tfNewNode(TF_Declare, 1, tfNewSyntax(lhs));
tfrhs = tfNewSyntax(rhs);
tf = tfNewNode(TF_Define, 2, tflhs, tfrhs);

ab = tfExpr(tf)tfToAbSyn(tf);

abTransferSemantics(lhs, ab->abDefine.lhs);
abTransferSemantics(rhs, ab->abDefine.rhs);

tfSetPending(tf)(((tf)->state)=TF_State_Pending);
abSetTForm(lhs, tf);

stabDefTForm(stab, tf);

return tf;
1977}

1979TForm
1980tfSyntaxDefineMap(Stab stab, AbSyn ab, AbSyn rhs)
1981{
Stab	nstab = (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) ? abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) : stab);
TForm	tf, tfret;

assert(abIsAnyLambda(rhs))do { if (!((((rhs)->abHdr.tag == (AB_Lambda)) || ((rhs)->
abHdr.tag == (AB_PLambda))))) _do_assert(("abIsAnyLambda(rhs)"
),"tform.c",1985); } while (0);

tfret = tfSyntaxDefine(nstab, abMapRet(ab)((ab)->abApply.argv[1]), rhs->abLambda.body);
tf = tfSyntaxMap(nstab, ab, tfret);

stabDefTForm(stab, tf);

return tf;
1993}

1995/*
* Create a template type form for an extension.
*/
1998TForm
1999tfSyntaxExtend(Stab stab, AbSyn id, AbSyn type)
2000{
Stab	nstab = (abStab(type)((type)->abHdr.seman ? (type)->abHdr.seman->stab : 0
) ? abStab(type)((type)->abHdr.seman ? (type)->abHdr.seman->stab : 0
) : stab);
TForm	tf;

if (abIsAnyMap(type)(((((type)->abHdr.tag == (AB_Apply)) && (((((type)
->abApply.op))->abHdr.tag == (AB_Id)) && ((((type
)->abApply.op))->abId.sym)==(ssymArrow))) && ((
(type)->abHdr.argc)-1) == 2) || ((((type)->abHdr.tag ==
 (AB_Apply)) && (((((type)->abApply.op))->abHdr
.tag == (AB_Id)) && ((((type)->abApply.op))->abId
.sym)==(ssymPackedArrow))) && (((type)->abHdr.argc
)-1) == 2))) {
tf = tfSyntaxExtendMap(nstab, type, tfUnknown);
tfSetStab(tf, nstab)((tf)->stab = (nstab));
}
else
tf = tfUnknown;

return tfDeclare(id, tf);
2012}

2014TForm
2015tfSyntaxExtendMap(Stab stab, AbSyn map, TForm tfret)
2016{
AbSyn	abarg = abMapArg(map)((map)->abApply.argv[0]);
Length	i, argc = abArgc(abarg)((abarg)->abHdr.argc);
TForm	tfarg;

if (abTag(abarg)((abarg)->abHdr.tag) == AB_Comma && argc != 1) {
tfarg = tfNewEmpty(TF_Multiple, argc);
for (i = 0; i < argc; i += 1) {
	AbSyn	id = abDefineeId(abarg->abComma.argv[i]);
	tfArgv(tfarg)((tfarg)->argv)[i] = tfDeclare(id, tfUnknown);
}
}
else {
AbSyn id = abDefineeId(abarg);
tfarg = tfDeclare(id, tfUnknown);
}

return tfAnyMap(tfarg, tfret, abIsPackedMap(map)((((map)->abHdr.tag == (AB_Apply)) && (((((map)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((map)->
abApply.op))->abId.sym)==(ssymPackedArrow))) && ((
(map)->abHdr.argc)-1) == 2));
2034}

2036/*
* Create non-forwarding tform from type analysed abstract syntax.
*/
2039TForm
2040tfFullFrAbSyn(Stab stab, Sefo sefo)
2041{
TForm tf;

if ((tf = abTForm(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0
)) != NULL((void*)0))
return tfMeaningFrSyntax(stab, sefo, tf);

else if ((tf = stabGetTForm(stab, sefo, NULL((void*)0))) != NULL((void*)0))
return tfMeaningFrSyntax(stab, sefo, tf);

if (abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0
))
stab = abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0
);

tf = tfMeaning(stab, sefo, tfPending(stab, sefo));
stabDefTForm(stab, tf);

return tf;
2057}

2059/*
* Create a forwarding tform from a syntax tform.
* The new tform may be a full tform or a pending tform.
*/
2063TForm
2064tfForwardFrSyntax(TForm otf, TForm ntf)
2065{
if (!tfIsSyntax(otf)(((otf)->tag) == TF_Syntax)) return otf;
assert(otf != ntf)do { if (!(otf != ntf)) _do_assert(("otf != ntf"),"tform.c",2067
); } while (0);
assert(!tfIsForward(ntf))do { if (!(!(((ntf)->tag) == TF_Forward))) _do_assert(("!tfIsForward(ntf)"
),"tform.c",2068); } while (0);

otf->tag     = TF_Forward;
otf->argc    = 1;
otf->argv[0] = ntf;

tfCopyQueries	(ntf, otf);	/* queries (ntf) := queries (otf) */
tfCopyState	(otf, ntf)(((otf)->state) = ((ntf)->state));	/* state   (otf) := state   (ntf) */
tfCopySelf	(ntf, otf);	/* self    (ntf) := self    (otf) */
tcMove		(ntf, otf);	/* const   (ntf) := const   (otf) */

return otf;
2080}

2082/*
* Create a pending tform from a syntax tform.
*/
2085TForm
2086tfPendingFrSyntax(Stab stab, AbSyn ab, TForm tf)
2087{
tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax)) {
TForm tfp = tfPending(stab, ab);
/* This test is probably too weak */
if (!tfIsId(tfp)((((tfp)->tag) == TF_General) && ((((tfp)->__absyn
))->abHdr.tag) == AB_Id))
	tfSetConditions(tfFollowOnly(tfp), tfConditions(tf))(tfFollowOnly(tfp)->conditions = (tfConditions(tf)));
tfForwardFrSyntax(tf, tfFollowOnly(tfp));
}
else if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) {
assert(abIsAnyMap(ab))do { if (!((((((ab)->abHdr.tag == (AB_Apply)) && (
((((ab)->abApply.op))->abHdr.tag == (AB_Id)) &&
 ((((ab)->abApply.op))->abId.sym)==(ssymArrow))) &&
 (((ab)->abHdr.argc)-1) == 2) || ((((ab)->abHdr.tag == (
AB_Apply)) && (((((ab)->abApply.op))->abHdr.tag
 == (AB_Id)) && ((((ab)->abApply.op))->abId.sym
)==(ssymPackedArrow))) && (((ab)->abHdr.argc)-1) ==
 2)))) _do_assert(("abIsAnyMap(ab)"),"tform.c",2098); } while
 (0);
tfPendingFrSyntaxMap(stab, ab, tf);
}

else if (tfIsDefine(tf)(((tf)->tag) == TF_Define) && abHasTag(ab, AB_Define)((ab)->abHdr.tag == (AB_Define)))
tfPendingFrSyntaxDefine(stab, ab, tf);

return tf;
2106}

2108localstatic void
2109tfPendingFrSyntaxMap(Stab stab, AbSyn ab, TForm tf)
2110{
AbSyn	abarg = abMapArg(ab)((ab)->abApply.argv[0]);
AbSyn	abret = abMapRet(ab)((ab)->abApply.argv[1]);
TForm	tfarg = tfMapArg(tf)tfFollowArg(tf, 0);
TForm	tfret = tfMapRet(tf)tfFollowArg(tf, 1);
Length	i;

if (tfIsMulti(tfarg)(((tfarg)->tag) == TF_Multiple))
for (i = 0; i < tfArgc(tfarg)((tfarg)->argc); i += 1) {
	TForm	tfi = tfFollowArg(tfarg, i);
	AbSyn	abi = abArgv(abarg)((abarg)->abGen.data.argv)[i];
	tfPendingFrSyntax(stab, abi, tfi);
}

if (abTag(abarg)((abarg)->abHdr.tag) == AB_Comma && abArgc(abarg)((abarg)->abHdr.argc) == 1)
abarg = abArgv(abarg)((abarg)->abGen.data.argv)[0];

tfPendingFrSyntax(stab, abarg, tfarg);
tfPendingFrSyntax(stab, abret, tfret);
2129}

2131localstatic void
2132tfPendingFrSyntaxDefine(Stab stab, AbSyn ab, TForm tf)
2133{
AbSyn	abdec = abDefineDecl(ab)((ab)->abDefine.lhs);
AbSyn	abval = abDefineVal(ab)((ab)->abDefine.rhs);
TForm	tfdec = tfDefineDecl(tf)tfFollowArg(tf, 0);
TForm	tfval = tfDefineVal(tf)tfFollowArg(tf, 1);

tfPendingFrSyntax(stab, abdec, tfdec);
tfPendingFrSyntax(stab, abval, tfval);
2141}

2143/*
* Create a meaningful tform from a syntax tform.
*/
2146TForm
2147tfMeaningFrSyntax(Stab stab, Sefo sefo, TForm tf)
2148{
TForm	ntf, stf;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (!abIsSefo(sefo)(((sefo)->abHdr.state) == AB_State_HasUnique))
return tf;

stf = abTForm(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0
);
tfFollow(stf)((stf) = tfFollowFn(stf));

/* Convert syntax tforms to pending tforms. */
if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
ntf = tfPending(stab, sefo);

/* Avoid using pending tforms which don't have semantics. */
else if (tfIsPending(tf)(((tf)->state)==TF_State_Pending) && !abIsSefo(tfGetExpr(tf))(((((tf)->__absyn))->abHdr.state) == AB_State_HasUnique
))
ntf = tfPending(stab, sefo);

/* Avoid using tforms with different semantics. */
else if (tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning) && tf != stf &&
!tfMeaningEqual(sefo, tfGetExpr(tf)((tf)->__absyn)))
ntf = tfPending(stab, sefo);

/* Convert pending tforms to meaningful tforms. */
else
ntf = tf;

ntf = tfMeaning(stab, sefo, ntf);

if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
tfForwardFrSyntax(tf, ntf);

return ntf;
2182}

2184/* Quickie version of sefoEqual since we can't use sefoEqual
* inside tfMeaningFrSyntax.
*/
2187localstatic Bool
2188tfMeaningEqual(Sefo sefo1, Sefo sefo2)
2189{
Bool	result;

if (sefo1 == sefo2)
result = true1;

else if (!sefo1 || !sefo2)
result = false((int) 0);

else if (abTag(sefo1)((sefo1)->abHdr.tag) != abTag(sefo2)((sefo2)->abHdr.tag))
result = false((int) 0);
else if (abIsLeaf(sefo1)(((sefo1)->abHdr.tag) < AB_NODE_START))
result = abSyme(sefo1)((sefo1)->abHdr.seman ? (sefo1)->abHdr.seman->syme :
 0) == abSyme(sefo2)((sefo2)->abHdr.seman ? (sefo2)->abHdr.seman->syme :
 0);

else
result = false((int) 0);

return result;
2207}

2209/******************************************************************************
*
* :: Type form floating.
*
*****************************************************************************/

2215/*
* Float a type form to its natural level. Return 0 if floating
* not done.
*/
2219Stab
2220tfFloat(Stab stab, TForm tf)
2221{
ULong	odepth, ndepth;
TForm	outerTf = NULL((void*)0);

if (!tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
return NULL((void*)0);

odepth = stabLevelNo(stab)(((stab)->first)->lexicalLevel);
ndepth = tfOuterDepth(stab, tf);
if (ndepth >= odepth) {
/* No floating needed - clean up conditions */
tfFloatConditions(stab, tf);
return NULL((void*)0);
}
while (stabLevelNo(stab)(((stab)->first)->lexicalLevel) > ndepth) {
stab = cdr(stab)((stab)->rest);
outerTf = stabGetTForm(stab, tfGetExpr(tf)((tf)->__absyn), NULL((void*)0));
if (outerTf && tfQueries(outerTf)((outerTf)->queries)) break;
}

if (! outerTf) {
outerTf = tfNewSyntax(tfGetExpr(tf)((tf)->__absyn));
tfSetConditions(outerTf, tfFloatConditions(stab, tf))(outerTf->conditions = (tfFloatConditions(stab, tf))); 
stabDefTForm(stab, outerTf);
}

if (tf == outerTf)
return NULL((void*)0);

if (DEBUG(tfFloat)tfFloatDebug) {
fprintf(dbOut, "Floating from stab level %lu to level %lu.",
	odepth, ndepth);
findent += 2;
fnewline(dbOut);
fprintf(dbOut,"Inner tform = ");
tfPrint(dbOut, tf);
fnewline(dbOut);
fprintf(dbOut,"Outer tform = ");
tfPrint(dbOut, outerTf);
findent -= 2;
fnewline(dbOut);
}
outerTf = tfFollowOnly(outerTf);
tf = tfForwardFrSyntax(tf, outerTf);
tf->conditions = NULL((void*)0);

return stab;
2268}

2270/*
* Compute the outermost symbol table depth for which the interpretation
* of tf is known to be the same as it is in stab.
*/
2274ULong
2275tfOuterDepth(Stab stab, TForm tf)
2276{
ULong		depth;
TFormList	hl;

depth = abOuterDepth(stab, tfGetExpr(tf)((tf)->__absyn));
for (hl = tfQueries(tf)((tf)->queries); hl; hl = cdr(hl)((hl)->rest)) {
ULong	d = tfOuterDepth(stab, car(hl)((hl)->first));
if (d > depth) depth = d;
}

return depth;
2287}

2289/*
* Compute the outermost symbol table depth for which the interpretation
* of ab is known to be the same as it is in stab.
*/
2293localstatic ULong abOuterDepth0	(Stab stab, Stab istab, AbSyn ab);

2295ULong
2296abOuterDepth(Stab stab, AbSyn ab)
2297{
return abOuterDepth0(stab, stab, ab);
2299}

2301localstatic ULong
2302abOuterDepth0(Stab stab, Stab istab, AbSyn ab)
2303{
SymeList	sl;
ULong	depth;
Symbol  sym;
Length	i;

if (abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0))
istab = abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0);

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_LitInteger: 
sym = ssymTheInteger;
goto handle_id;
break;
case AB_LitString: 
sym = ssymTheString;
goto handle_id;
break;
case AB_LitFloat: 
sym = ssymTheFloat;
goto handle_id;
break;
case AB_Id: {
sym = ab->abId.sym;

/* Do not float the symbol Category. */
2329handle_id:		
if (sym == ssymCategory)
	return stabLevelNo(stab)(((stab)->first)->lexicalLevel);

/* Do not float symbols with no meanings. */
sl = stabGetMeanings(istab, NULL((void*)0), sym);
if (sl == listNil(Syme)((SymeList) 0))
	return stabLevelNo(stab)(((stab)->first)->lexicalLevel);

depth = 0;
for (; sl; sl = cdr(sl)((sl)->rest)) {
	Syme	syme = car(sl)((sl)->first);
	ULong	d = symeDefLevelNo(syme)(symeDefLevel(syme)->lexicalLevel);
	
	/* Ignore locally defined symbol meanings */
	if (d > stabLevelNo(stab)(((stab)->first)->lexicalLevel)) {
		d = 0;
	}
	/* Do not float to stabGlobal. */
	/* Do not float to a level where sym is assigned. */
	/* Do not float to a level where sym is extended. */
	/* Do not float if a type is not yet analyzed. */
	/* Except if is `%', then just wing it... */
	else if (sym == ssymSelf)
		;
	else if (d == 0 ||
	    symeIsLexVar(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_LexVar) ||
	    symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend) ||
	    (!symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Import) &&
	     (tfIsUnknown(symeType(syme))(((symeType(syme))->tag) == TF_Unknown) ||
	      tfIsSyntax(symeType(syme))(((symeType(syme))->tag) == TF_Syntax))))
		d += 1;
	if (d > depth) depth = d;
}

/* Do not float to a level where sym is extended. */
for (; stab; stab = cdr(stab)((stab)->rest)) {
	ULong	d = car(stab)((stab)->first)->lexicalLevel + 1;
	sl = car(stab)((stab)->first)->extendSymes;
	for (; d > depth && sl; sl = cdr(sl)((sl)->rest)) {
		Syme	syme = car(sl)((sl)->first);
		if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend) && symeId(syme)((syme)->id) == sym)
			depth = d;
	}
}
if (DEBUG(tfFloat)tfFloatDebug) {
	Buffer buf = bufNew();
	bufPrintf(buf, "AbSyn: %s [%pAbSyn] %d\n", symString(sym)((sym)->str), ab, depth);
	fprintf(dbOut, "%s", bufLiberate(buf));
}
break;
}
case AB_PretendTo:
case AB_Declare:
case AB_Apply: 
case AB_Comma:
case AB_With:
case AB_Has:
case AB_RestrictTo:
case AB_And:
case AB_Or:
case AB_If:
case AB_Test:
depth = 1;
for (i = 0; i < abArgc(ab)((ab)->abHdr.argc); i += 1) {
	ULong	d = abOuterDepth0(stab, istab, abArgv(ab)((ab)->abGen.data.argv)[i]);
	if (d > depth) depth = d;
}
break;
default:
depth = stabLevelNo(stab)(((stab)->first)->lexicalLevel);
break;
}

assert(depth > 0 || stab != istab)do { if (!(depth > 0 || stab != istab)) _do_assert(("depth > 0 || stab != istab"
),"tform.c",2403); } while (0);
return depth;
2405}


2408/******************************************************************************
*
* :: Type form semantics.
*
*****************************************************************************/

2414/******************************************************************************
*
* :: Type form has questions.
*
*****************************************************************************/

2420TFormList
2421tfCopyQueries(TForm to, TForm from)
2422{
if (tfQueries(from)((from)->queries) == listNil(TForm)((TFormList) 0))
return tfQueries(to)((to)->queries);

/*
* No sense in duplicating queries. In fact we ought to do better
* than this and compute the set union of both sets of queries.
* That way we don't duplicate them.
*/
if (tfQueries(from)((from)->queries) == tfQueries(to)((to)->queries))
return tfQueries(to)((to)->queries);

tfSetQueries(to, listConcat(TForm)(tfQueries(from), tfQueries(to)))(((to)->queries) = ((TForm_listPointer->Concat)(((from)
->queries), ((to)->queries))));

if (tfHasSelf(to)((to)->hasSelf)) /* Ooops: see stabIsImportedTForm */
tfHasSelf(to)((to)->hasSelf) = false((int) 0);
if (tfDomExports(to))
tfSetDomExports(to, listNil(Syme)((SymeList) 0));
if (tfDomImports(to)) {
symeSetFree(tfDomImports(to));
tfSetDomImports(to, NULL((void*)0));
}

return tfQueries(to)((to)->queries);
2446}

2448TForm
2449tfAddQuery(TForm tf, TForm cat)
2450{
tfDEBUGif (!tfDebug) { } else afprintf(dbOut, "Adding query %pTForm %pTForm\n", tf, cat);
tfSetQueries(tf, listCons(TForm)(cat, tfQueries(tf)))(((tf)->queries) = ((TForm_listPointer->Cons)(cat, ((tf
)->queries))));
return cat;
2454}

2456/******************************************************************************
*
* :: Type form sefo accessors.
*
*****************************************************************************/

2462TForm
2463abGetCategory(AbSyn ab)
2464{
TForm	cat = tfUnknown;

if (abState(ab)((ab)->abHdr.state) == AB_State_HasUnique)
cat = abTUnique(ab)((ab)->abHdr.type.unique);

else if (abState(ab)((ab)->abHdr.state) == AB_State_HasPoss && tpossIsUnique(abTPoss(ab)((ab)->abHdr.type.poss)))
cat = tpossUnique(abTPoss(ab)((ab)->abHdr.type.poss));

else if (abTag(ab)((ab)->abHdr.tag) == AB_Id && abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0))
cat = symeType(abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0));

else if (abTForm(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->tform : 0))
cat = tfGetCategory(abTForm(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->tform : 0));

else if (tiTopFns()->tiCanSefo(ab)) {
tiTopFns()->tiSefo(stabFile(), ab);
if (abState(ab)((ab)->abHdr.state) == AB_State_HasUnique)
	cat = abTUnique(ab)((ab)->abHdr.type.unique);
}

return cat;
2486}

2488SymeList
2489abGetCatExports(Sefo cat)
2490{
if (abIsNotNothing(cat)!((cat)->abHdr.tag == (AB_Nothing)) && abState(cat)((cat)->abHdr.state) == AB_State_HasUnique)
return tfGetThdExports(abTUnique(cat)((cat)->abHdr.type.unique));
else
return listNil(Syme)((SymeList) 0);
2495}

2497SymeList
2498abGetCatSelf(Sefo cat)
2499{
if (abIsNotNothing(cat)!((cat)->abHdr.tag == (AB_Nothing)) && abState(cat)((cat)->abHdr.state) == AB_State_HasUnique)
return tfGetThdSelf(abTUnique(cat)((cat)->abHdr.type.unique));
else
return listNil(Syme)((SymeList) 0);
2504}

2506/******************************************************************************
*
* :: Type form symbol table.
*
*****************************************************************************/

2512Stab
2513tfDefStab(Stab stab, TForm tf)
2514{
Stab	nstab = NULL((void*)0);

if (tfStab(tf)((tf)->stab))
return tfStab(tf)((tf)->stab);

if (tfHasExpr(tf)((tf)->__absyn != 0)) {
nstab = abStab(tfGetExpr(tf))((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->stab : 0);
if (nstab == NULL((void*)0)) {
	nstab = stabPushLevel(stab, sposNone, long0((long) 0));
	abSetStab(tfGetExpr(tf)((tf)->__absyn), nstab);
}
}
else
nstab = stabPushLevel(stab, sposNone, long0((long) 0));

tfSetStab(tf, nstab)((tf)->stab = (nstab));
return nstab;
2532}

2534Stab
2535tfGetStab(TForm tf)
2536{
Stab	stab = NULL((void*)0);

if (tfStab(tf)((tf)->stab))
return tfStab(tf)((tf)->stab);

if (tfHasExpr(tf)((tf)->__absyn != 0))
stab = abStab(tfGetExpr(tf))((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->stab : 0);

tfSetStab(tf, stab)((tf)->stab = (stab));
return stab;
2547}

2549/******************************************************************************
*
* :: Type form category.
*
*****************************************************************************/

2555/*
* Anything that might have a later extend.... 
*/

2559#define		tfp0IsSpecialTag(tag)((tag) == TF_Tuple || (tag) == TF_Record || (tag) == TF_RawRecord
 || (tag) == TF_Reference || (tag) == TF_Generator || (tag) ==
 TF_Union || (tag) == TF_TrailingArray || (tag) == TF_Enumerate
)		\
((tag) == TF_Tuple 	 	|| (tag) == TF_Record \
|| (tag) == TF_RawRecord	|| (tag) == TF_Reference \
|| (tag) == TF_Generator	|| (tag) == TF_Union \
|| (tag) == TF_TrailingArray   || (tag) == TF_Enumerate)

2565TForm
2566tfGetCategory(TForm tf)
2567{
TForm	cat = tfUnknown;

if (tfHasUnique(tf)(((tf)->__absyn != 0) && ((((tf)->__absyn))->
abHdr.state) == AB_State_HasUnique) && !tfIsUnknown(tfTUnique(tf))(((((((tf)->__absyn))->abHdr.type.unique))->tag) == TF_Unknown
))
cat = tfTUnique(tf)((((tf)->__absyn))->abHdr.type.unique);

else if (tfHasPoss(tf)(((tf)->__absyn != 0) && ((((tf)->__absyn))->
abHdr.state) == AB_State_HasPoss) && tpossIsUnique(tfTPoss(tf)((((tf)->__absyn))->abHdr.type.poss)))
cat = tpossUnique(tfTPoss(tf)((((tf)->__absyn))->abHdr.type.poss));

else if (tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id) && tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))
cat = symeType(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0));

else if (tfNeedsSefo(tf)((tf)->state == TF_State_NeedsSefo)) {
tiTopFns()->tiTfSefo(stabFile(), tf);
cat = tfGetCategory(tf);
}

2584#ifdef TFormBuiltinSefo
else if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT) && abSyme(tfExpr(tf))((tfToAbSyn(tf))->abHdr.seman ? (tfToAbSyn(tf))->abHdr.
seman->syme : 0))
cat = symeType(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0));

2588#endif
else if (tfp0IsSpecialTag(tfTag(tf))((((tf)->tag)) == TF_Tuple || (((tf)->tag)) == TF_Record
 || (((tf)->tag)) == TF_RawRecord || (((tf)->tag)) == TF_Reference
 || (((tf)->tag)) == TF_Generator || (((tf)->tag)) == TF_Union
 || (((tf)->tag)) == TF_TrailingArray || (((tf)->tag)) ==
 TF_Enumerate) && tiTopFns()->tiCanSefo(tfExpr(tf)tfToAbSyn(tf))) {
tiTopFns()->tiSefo(stabFile(), tfExpr(tf)tfToAbSyn(tf));
if (tfHasUnique(tf)(((tf)->__absyn != 0) && ((((tf)->__absyn))->
abHdr.state) == AB_State_HasUnique))
	cat = tfTUnique(tf)((((tf)->__absyn))->abHdr.type.unique);
}

if (tfIsDefine(cat)(((cat)->tag) == TF_Define) && tfDefineVal(cat)tfFollowArg(cat, 1) == tf)
cat = tfDefineDecl(cat)tfFollowArg(cat, 0);

return cat;
2599}

2601/******************************************************************************
*
* :: Type form symbol meanings for self.
*
*****************************************************************************/

2607SymeList
2608tfCopySelf(TForm to, TForm from)
2609{
if (!tfHasSelf(to)((to)->hasSelf) && tfSelf(to)((to)->self) == listNil(Syme)((SymeList) 0)) {
tfSetSelf(to, listCopy(Syme)(tfSelf(from)))((to)->self = ((Syme_listPointer->Copy)(((from)->self
))));
tfHasSelf(to)((to)->hasSelf) = tfHasSelf(from)((from)->hasSelf);
}

return tfSelf(to)((to)->self);
2616}

2618SymeList
2619tfAddSelf(TForm tf, SymeList self2)
2620{
SymeList	self1  = tfSelf(tf)((tf)->self);
SymeList	result = listNil(Syme)((SymeList) 0);

for (; self2; self2 = cdr(self2)((self2)->rest))
if (!symeListMember(car(self2)((self2)->first), self1, symeEq))
	result = listCons(Syme)(Syme_listPointer->Cons)(car(self2)((self2)->first), result);

result = listNConcat(Syme)(Syme_listPointer->NConcat)(self1, listNReverse(Syme)(Syme_listPointer->NReverse)(result));
tfSetSelf(tf, result)((tf)->self = (result));

return result;
2632}

2634SymeList
2635tfUnionSelf(TForm tf, SymeList self2)
2636{
return tfAddSelf(tf, self2);
2638}

2640SymeList
2641tfGetSelfFrStab(Stab stab)
2642{
SymeList	symes = listNil(Syme)((SymeList) 0);
Syme		syme = stabGetSelf(stab);

if (syme) symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

return symes;
2649}

2651SymeList
2652tfGetSelf(Stab stab, TForm tf)
2653{
return tfSetSelf(tf, tfGetSelfFrStab(stab))((tf)->self = (tfGetSelfFrStab(stab)));
2655}

2657SymeList
2658tfDefSelf(Stab stab, TForm tf)
2659{
SymeList	symes;
Syme		syme;
TForm		ntf;

if (tfSelf(tf)((tf)->self) || tfGetSelf(stab, tf))
return tfSelf(tf)((tf)->self);

ntf = tfDefineOfType(tf);
stab = tfDefStab(stab, tf);
syme = stabDefLexVar(stab, ssymSelf, ntf);
stabSetSubstable(stab)(((stab)->first)->isSubstable=1);

symes = listCons(Syme)(Syme_listPointer->Cons)(syme, listNil(Syme)((SymeList) 0));
tfSetSelf(tf, symes)((tf)->self = (symes));
return symes;
2675}

2677/*
* Called on a domain to get the symbol meaning(s) for %.
*/
2680SymeList
2681tfGetDomSelf(TForm tf)
2682{
TForm		cat;
TFormList	hl;

tf = tfDefineeType(tf);

if (tfHasSelf(tf)((tf)->hasSelf) && tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id) && symeExtension(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))) {
return tfGetDomSelf(tfFrSyme(stabFile(), symeExtensionFull(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))));
}

if (tfHasSelf(tf)((tf)->hasSelf))
return tfSelf(tf)((tf)->self);

cat = tfGetCategory(tf);
if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown))
return tfSelf(tf)((tf)->self);
if (!tfIsAdd(tf)(((tf)->tag) == TF_Add) && !tfHasCatExports(cat))
return tfSelf(tf)((tf)->self);

if (DEBUG(tfImport)tfImportDebug) {
fprintf(dbOut, "(tfGetDomSelf:  from ");
tfPrint(dbOut, tf);
fnewline(dbOut);
}

if (tfIsArchive(tf) || tfIsLibrary(tf))
tfAddSelf(tf, listNil(Syme)((SymeList) 0));
else if (tfIsAdd(tf)(((tf)->tag) == TF_Add) && tfGetStab(tf))
tfAddSelf(tf, tfGetSelfFrStab(tfGetStab(tf)));
else 
tfAddSelf(tf, tfGetCatSelf(cat));

for (hl = tfQueries(tf)((tf)->queries); hl; hl = cdr(hl)((hl)->rest))
tfAddSelf(tf, tfGetCatSelf(car(hl)((hl)->first)));

tfImportDEBUGif (!tfImportDebug) { } else afprintf(dbOut, ")\n");

tfHasSelf(tf)((tf)->hasSelf) = true1;
return tfSelf(tf)((tf)->self);
2721}

2723/*
* Called on a category to get the symbol meaning(s) for %.
*/
2726SymeList
2727tfGetCatSelf(TForm cat)
2728{
tfFollow(cat)((cat) = tfFollowFn(cat));

if (tfIsDefine(cat)(((cat)->tag) == TF_Define)) {
if (tfHasSelf(cat)((cat)->hasSelf) || !tfHasCatExports(cat))
	return tfSelf(cat)((cat)->self);

tfAddSelf(cat, tfGetDomSelf(tfDefineVal(cat)tfFollowArg(cat, 1)));
tfAddSelf(cat, tfGetCatSelf(tfDefineeType(cat)));

tfHasSelf(cat)((cat)->hasSelf) = true1;
return tfSelf(cat)((cat)->self);
}

cat = tfDefineeType(cat);

if (tfHasSelf(cat)((cat)->hasSelf))
return tfSelf(cat)((cat)->self);

if (!tfHasCatExports(cat))
return tfSelf(cat)((cat)->self);

if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0))
return tfSelf(cat)((cat)->self);

if (DEBUG(tfCat)tfCatDebug) {
fprintf(dbOut, "(tfGetCatSelf:  from ");
tfPrint(dbOut, cat);
fnewline(dbOut);
}

if (tfIsWith(cat)(((cat)->tag) == TF_With)) {
TForm		tfb = tfWithBase(cat)tfFollowArg(cat, 0);
TForm		tfw = tfWithWithin(cat)tfFollowArg(cat, 1);
SymeList	wself;

tfAddSelf(cat, tfGetCatSelf(tfb));

tfFollow(tfw)((tfw) = tfFollowFn(tfw));
if (tfHasSelf(tfw)((tfw)->hasSelf))
	wself = tfSelf(tfw)((tfw)->self);

else if (tfIsDeclare(tfw)(((tfw)->tag) == TF_Declare))
	wself = listNil(Syme)((SymeList) 0);

else if (tfHasExpr(tfw)((tfw)->__absyn != 0))
	wself = tfGetCatSelfFrWith(tfGetExpr(tfw)((tfw)->__absyn));
else
	wself = tfGetCatSelf(tfw);

tfAddSelf(tfw, wself);

tfHasSelf(tfw)((tfw)->hasSelf) = true1;

if (tfHasExpr(cat)((cat)->__absyn != 0))
	tfAddSelf(cat, abSelf(tfGetExpr(cat))((((cat)->__absyn))->abHdr.seman ? (((cat)->__absyn)
)->abHdr.seman->self : 0));

tfAddSelf(cat, wself);
}

else if (tfIsIf(cat)(((cat)->tag) == TF_If)) {
tfAddSelf(cat, tfGetCatSelf(tfIfThen(cat)tfFollowArg(cat, 1)));
tfAddSelf(cat, tfGetCatSelf(tfIfElse(cat)tfFollowArg(cat, 2)));
}

else if (tfIsJoin(cat)(((cat)->tag) == TF_Join) || tfIsMeet(cat)(((cat)->tag) == TF_Meet)) {
Length	i, argc = tfArgc(cat)((cat)->argc);
for (i = 0; i < argc; i += 1)
	tfAddSelf(cat, tfGetCatSelf(tfFollowArg(cat, i)));
}

else
tfAddSelf(cat, tfGetThdSelf(tfGetCategory(cat)));

if (DEBUG(tfCat)tfCatDebug) {
fprintf(dbOut, ")\n");
fnewline(dbOut);
}

tfHasSelf(cat)((cat)->hasSelf) = true1;
return tfSelf(cat)((cat)->self);
2809}

2811/*
* Called on a third-order type to get the symbol meaning(s) for %.
*/
2814SymeList
2815tfGetThdSelf(TForm thd)
2816{
thd = tfDefineeType(thd);

if (tfHasSelf(thd)((thd)->hasSelf))
return tfSelf(thd)((thd)->self);

if (!tfHasThdExports(thd))
return tfSelf(thd)((thd)->self);

if (tfIsThird(thd)(((thd)->tag) == TF_Third))
tfAddSelf(thd, tfGetCatSelf(tfThirdRestrictions(thd)tfFollowArg(thd, 0)));

tfHasSelf(thd)((thd)->hasSelf) = true1;
return tfSelf(thd)((thd)->self);
2830}

2832/*
* tfGet...Self helper functions.
*/

2836localstatic SymeList
2837tfGetCatSelfFrWith(Sefo sefo)
2838{
SymeList	csymes, symes;
Length		i, argc;
Sefo		*argv;
TForm		cat;

AB_SEQ_ITER(sefo, argc, argv){ switch (((sefo)->abHdr.tag)) { case AB_Nothing: argc = 0
; argv = 0; break; case AB_Sequence: argc = ((sefo)->abHdr
.argc); argv = ((sefo)->abGen.data.argv); break; default: argc
 = 1; argv = &sefo; break; }; };

symes = listNil(Syme)((SymeList) 0);
for (i = 0; i < argc; i++) {
Sefo	id = abDefineeIdOrElse(argv[i], NULL((void*)0));

if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Nothing)
	continue;

/* Defaults package. */
else if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default)
	continue;
/* Explicit declaration. */
else if (id && abTag(argv[i])((argv[i])->abHdr.tag) != AB_Id)
	continue;

/* Category expression. */
else if (!tfIsUnknown(cat = abGetCategory(argv[i]))(((cat = abGetCategory(argv[i]))->tag) == TF_Unknown) &&
	 tfSatCat(cat)) {
	csymes = tfGetThdSelf(cat);
	symes = symeListUnion(symes, csymes, symeEq);
}
}

return symes;
2869}

2871/******************************************************************************
*
* :: Type form parent symes.
*
*****************************************************************************/

2877localstatic SymeList		tfGetCatParentsFrWith	(TForm);
2878localstatic SymeList		tfGetCatParentsFrIf	(TForm);
2879localstatic SymeList		tfGetCatParentsFrJoin	(TForm);
2880localstatic SymeList		tfGetCatParentsFrInner	(TForm);

2882localstatic SymeList		abGetCatParents		(Sefo);

2884localstatic void tfValidateDomExports(TForm tf);
2885localstatic void tfValidateDomExportsParam(TForm tf);
2886localstatic void tfValidateDomImports(TForm tf);
2887localstatic void tfValidateDomImportsParam(TForm tf);
2888localstatic void tfValidateCheckConstInfo(TForm tf, SymeList symes, String type);

2890/*
* Called on a semantic category form to get the symbol meaning for %%
* to serve as a representation of all of the exports of the category.
*/
2894SymeList
2895abGetCatSelfSelf(Sefo sefo)
2896{
TForm		thd;
AbSub		sigma;
SymeList	symes;

if (!tfIsUnknown(thd = abGetCategory(sefo))(((thd = abGetCategory(sefo))->tag) == TF_Unknown))
return tfGetThdSelfSelf(thd);

else if (abHasTag(sefo, AB_Id)((sefo)->abHdr.tag == (AB_Id)))
thd = symeType(abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0
));

/*!! We really should handle curried categories. */
else if (abHasTag(sefo, AB_Apply)((sefo)->abHdr.tag == (AB_Apply))) {
TForm	tf = symeType(abSyme(abApplyOp(sefo))((((sefo)->abApply.op))->abHdr.seman ? (((sefo)->abApply
.op))->abHdr.seman->syme : 0));
tfFollow(tf)((tf) = tfFollowFn(tf));
assert(tfIsAnyMap(tf))do { if (!(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))) _do_assert(("tfIsAnyMap(tf)"),"tform.c",2911); } while (
0);
thd = tfMapRet(tf)tfFollowArg(tf, 1);
}

else
return listNil(Syme)((SymeList) 0);

sigma = tfSatSubList(sefo);
/*!! assert(sigma); */
if (sigma == NULL((void*)0)) return listNil(Syme)((SymeList) 0);

symes = symeListSubstSigma(sigma, tfGetThdSelfSelf(thd));
absFree(sigma);
return symes;
2925}

2927/*
* Called on a category to get the symbol meaning for %%
* to serve as a representation of all of the exports of the category.
*/
2931SymeList
2932tfGetCatSelfSelf(TForm cat)
2933{
SymeList	symes = listNil(Syme)((SymeList) 0);

cat = tfDefineeType(cat);

if (tfHasSelfSelf(cat)((cat)->hasSelfSelf) ||
   tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0))
return tfSelfSelf(cat)((cat)->selfself);

if (tfIsId(cat)((((cat)->tag) == TF_General) && ((((cat)->__absyn
))->abHdr.tag) == AB_Id) || tfIsApply(cat)((((cat)->tag) == TF_General) && ((((cat)->__absyn
))->abHdr.tag) == AB_Apply)) {
if (tfHasUnique(cat)(((cat)->__absyn != 0) && ((((cat)->__absyn))->
abHdr.state) == AB_State_HasUnique) && !tfIsUnknown(tfTUnique(cat))(((((((cat)->__absyn))->abHdr.type.unique))->tag) ==
 TF_Unknown))
	symes = abGetCatSelfSelf(tfGetExpr(cat)((cat)->__absyn));
else if (tfIsGeneral(cat)(((cat)->tag) == TF_General) && tiTopFns()->tiCanSefo(tfGetExpr(cat)((cat)->__absyn))) {
	tiTopFns()->tiSefo(stabFile(), tfGetExpr(cat)((cat)->__absyn));
	symes = abGetCatSelfSelf(tfGetExpr(cat)((cat)->__absyn));
}
else
	/* Don't cache if semantics may come later. */
	return symes;
}

tfHasSelfSelf(cat)((cat)->hasSelfSelf) = true1;
tfSelfSelf(cat)((cat)->selfself) = symes;
tfAuditExportList(symes);
return symes;
2958}

2960/*
* Called on a third-order type to get the symbol meaning for %%
* to serve as a representation of all of the exports of the third-order type.
*/
2964SymeList
2965tfGetThdSelfSelf(TForm thd)
2966{
SymeList	symes;

thd = tfDefineeType(thd);

if (tfHasSelfSelf(thd)((thd)->hasSelfSelf) || tfNeedsSefo(thd)((thd)->state == TF_State_NeedsSefo) ||
   tfIsUnknown(thd)(((thd)->tag) == TF_Unknown) || tfIsNone(thd)((((thd)->tag) == TF_Multiple) && tfMultiArgc(thd)
 == 0))
return tfSelfSelf(thd)((thd)->selfself);

if (tfIsThird(thd)(((thd)->tag) == TF_Third))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfSymes(thd)((thd)->symes));
else
symes = listNil(Syme)((SymeList) 0);

tfHasSelfSelf(thd)((thd)->hasSelfSelf) = true1;
tfSelfSelf(thd)((thd)->selfself) = symes;
tfAuditExportList(symes);
return symes;
2984}

2986/*
* Called on a category to get the symbol meanings which serve as
* 'parents' of all of the exports of the category.
*/
2990SymeList
2991tfGetCatParents(TForm cat, Bool top)
2992{
SymeList	symes;

tfFollow(cat)((cat) = tfFollowFn(cat));
if (tfIsDefineOfType(cat))
return tfGetCatParents(tfGetCategory(tfDefineVal(cat)tfFollowArg(cat, 1)), top);

cat = tfDefineeType(cat);

if (tfCatExports(cat) || tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfCatExports(cat));

else if (tfIsWith(cat)(((cat)->tag) == TF_With) && tfUseCatExports(cat)(((((tfFollowArg(cat, 0))->tag) == TF_Multiple) &&
 tfMultiArgc(tfFollowArg(cat, 0)) == 0) && ((((tfFollowArg
(cat, 1))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg
(cat, 1)) == 0)))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfParents(cat)((cat)->parents));

else if (!tfHasCatExports(cat))
symes = tfCatExports(cat);

else if (tfIsWith(cat)(((cat)->tag) == TF_With))
symes = tfGetCatParentsFrWith(cat);

else if (tfIsIf(cat)(((cat)->tag) == TF_If))
symes = tfGetCatParentsFrIf(cat);

else if (tfIsJoin(cat)(((cat)->tag) == TF_Join))
symes = tfGetCatParentsFrJoin(cat);

else if (tfIsMeet(cat)(((cat)->tag) == TF_Meet))
symes = tfGetCatExportsFrMeet(cat);

else if (top)
symes = tfGetThdParents(tfGetCategory(cat));

else if (tfIsDeclare(cat)(((cat)->tag) == TF_Declare))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfSymes(cat)((cat)->symes));

else
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfGetCatSelfSelf(cat));

tfAuditExportList(symes);
return symes;
3033}

3035/*
* Called on a third-order type to get the symbol meanings which serve as
* 'parents' of all of the exports of the third-order type.
*/
3039SymeList
3040tfGetThdParents(TForm thd)
3041{
SymeList	symes;

thd = tfDefineeType(thd);

if (tfThdExports(thd) || tfIsUnknown(thd)(((thd)->tag) == TF_Unknown) || tfIsNone(thd)((((thd)->tag) == TF_Multiple) && tfMultiArgc(thd)
 == 0))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfThdExports(thd));

else if (tfIsThird(thd)(((thd)->tag) == TF_Third) && tfUseThdExports(thd)(((((tfFollowArg(thd, 0))->tag) == TF_Multiple) &&
 tfMultiArgc(tfFollowArg(thd, 0)) == 0)))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfParents(thd)((thd)->parents));

else if (tfIsThird(thd)(((thd)->tag) == TF_Third))
symes = tfGetCatParents(tfThirdRestrictions(thd)tfFollowArg(thd, 0), false((int) 0));

else
symes = listNil(Syme)((SymeList) 0);

tfAuditExportList(symes);
return symes;
3060}

3062/*
* tfGet...Parents helper functions.
*/

3066localstatic SymeList
3067tfGetCatParentsFrWith(TForm cat)
3068{
TForm		tfb = tfWithBase(cat)tfFollowArg(cat, 0);
TForm		tfw = tfWithWithin(cat)tfFollowArg(cat, 1);
SymeList	bsymes, wsymes;

bsymes = tfGetCatParents(tfb, false((int) 0));

tfFollow(tfw)((tfw) = tfFollowFn(tfw));
wsymes = tfGetCatParentsFrInner(tfw);

return listNConcat(Syme)(Syme_listPointer->NConcat)(bsymes, wsymes);
3079}

3081localstatic SymeList
3082abGetCatParents(Sefo sefo)
3083{
SymeList	xsymes, isymes, dsymes, csymes, symes;
Length		i, argc;
Sefo		*argv;
Sefo		id;
TForm		cat;

AB_SEQ_ITER(sefo, argc, argv){ switch (((sefo)->abHdr.tag)) { case AB_Nothing: argc = 0
; argv = 0; break; case AB_Sequence: argc = ((sefo)->abHdr
.argc); argv = ((sefo)->abGen.data.argv); break; default: argc
 = 1; argv = &sefo; break; }; };

xsymes = isymes = dsymes = listNil(Syme)((SymeList) 0);
for (i = 0; i < argc; i++) {
id = abDefineeIdOrElse(argv[i], NULL((void*)0));

if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Nothing)
	continue;

/* Defaults package. */
else if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default) {
	AbSyn	def = argv[i]->abDefault.body;
	symes = tfSymesFrDefault(def);
	dsymes = listNConcat(Syme)(Syme_listPointer->NConcat)(symes, dsymes);
}

/* Explicit declaration. */
else if (id && abTag(argv[i])((argv[i])->abHdr.tag) != AB_Id) {
	assert(abSyme(id))do { if (!(((id)->abHdr.seman ? (id)->abHdr.seman->syme
 : 0))) _do_assert(("abSyme(id)"),"tform.c",3108); } while (0
);
	xsymes = listCons(Syme)(Syme_listPointer->Cons)(abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0), xsymes);
}
/* Category expression. */
else if (!tfIsUnknown(cat = abGetCategory(argv[i]))(((cat = abGetCategory(argv[i]))->tag) == TF_Unknown)) {
	csymes = listCopy(Syme)(Syme_listPointer->Copy)(tfGetThdSelfSelf(cat));
	if (csymes == listNil(Syme)((SymeList) 0))
		csymes = tfGetThdParents(cat);
	if (csymes == listNil(Syme)((SymeList) 0))
		csymes = tfGetThdExports(cat);
	isymes = listNConcat(Syme)(Syme_listPointer->NConcat)(isymes, csymes);
}
}

/* Mark the symes which have a default implementation. */
dsymes = listNReverse(Syme)(Syme_listPointer->NReverse)(dsymes);
for (; dsymes; dsymes = listFreeCons(Syme)(Syme_listPointer->FreeCons)(dsymes)) {
Syme	dsyme = car(dsymes)((dsymes)->first);
Syme	xsyme = NULL((void*)0);

/* If the default is one of our exports, just mark it. */
for (symes = xsymes; !xsyme && symes; symes = cdr(symes)((symes)->rest))
	if (symeEqual(car(symes)((symes)->first), dsyme)) {
		xsyme = car(symes)((symes)->first);
		symeSetDefault(xsyme)(((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme)
->lib) : ((void*)0)), (xsyme))->bits) |= (0x0080));
		symeSetSrcPos(xsyme, symeSrcPos(dsyme))(symeSetFieldVal = ((AInt) (((SrcPos) (SYFI_SrcPos < (8 * sizeof
(int)) && !(((((dsyme)->kind == SYME_Trigger ? libGetAllSymes
((dsyme)->lib) : ((void*)0)), (dsyme))->hasmask) & (
<< (SYFI_SrcPos))) ? (symeFieldInfo[SYFI_SrcPos].def)
 : (((((dsyme)->kind == SYME_Trigger ? libGetAllSymes((dsyme
)->lib) : ((void*)0)), (dsyme))->locmask) & (1 <<
 (SYFI_SrcPos))) ? ((((((dsyme)->kind == SYME_Trigger ? libGetAllSymes
((dsyme)->lib) : ((void*)0)), (dsyme))->locmask) & (
<< (SYFI_SrcPos))) ? ((dsyme)->fieldv)[symeIndex(dsyme
,SYFI_SrcPos)] : (symeFieldInfo[SYFI_SrcPos].def)) : symeGetFieldFn
(dsyme,SYFI_SrcPos))))), (((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
locmask) & (1 << (SYFI_SrcPos))) ? (((xsyme)->fieldv
)[symeIndex(xsyme,SYFI_SrcPos)] = (symeSetFieldVal)) : !((xsyme
)->full) && symeSetFieldVal == (symeFieldInfo[SYFI_SrcPos
].def) ? symeSetFieldVal : symeSetFieldFn(xsyme,SYFI_SrcPos,symeSetFieldVal
));
	}

/* If the default is inherited, use the default syme. */
if (xsyme == NULL((void*)0)) {
	xsymes = listCons(Syme)(Syme_listPointer->Cons)(dsyme, xsymes);
	symeSetDefault(dsyme)(((((dsyme)->kind == SYME_Trigger ? libGetAllSymes((dsyme)
->lib) : ((void*)0)), (dsyme))->bits) |= (0x0080));
}
}

xsymes = listNReverse(Syme)(Syme_listPointer->NReverse)(xsymes);
return listNConcat(Syme)(Syme_listPointer->NConcat)(isymes, xsymes);
3145}

3147localstatic SymeList
3148tfGetCatParentsFrIf(TForm cat)
3149{
SymeList	tsymes, esymes, symes = listNil(Syme)((SymeList) 0);
Sefo	 	cond;

if (tfParents(cat)((cat)->parents))
return listCopy(Syme)(Syme_listPointer->Copy)(tfParents(cat)((cat)->parents));
cond = tfIfCond(cat)tfToAbSyn(tfFollowArg(cat, 0));

if (abState(cond)((cond)->abHdr.state) != AB_State_HasUnique) {
/* This is seriously not nice, as calling
 * tiSefo will be expensive here
 */
tiTopFns()->tiSefo(stabFile(), cond);
}

tsymes = tfGetCatParentsFrInner(tfIfThen(cat)tfFollowArg(cat, 1));
tsymes = symeListAddCondition(tsymes, cond, true1);

esymes = tfGetCatParentsFrInner(tfIfElse(cat)tfFollowArg(cat, 2));
esymes = listCopy(Syme)(Syme_listPointer->Copy)(esymes);
symes = listNConcat(Syme)(Syme_listPointer->NConcat)(tsymes, esymes);
tfSetParents(cat, listCopy(Syme)(symes))((cat)->parents = ((Syme_listPointer->Copy)(symes)));
return symes;
3172}

3174localstatic SymeList
3175tfGetCatParentsFrJoin(TForm cat)
3176{
SymeList	nsymes, symes = listNil(Syme)((SymeList) 0);
Length		i;

for (i = 0; i < tfJoinArgc(cat)((cat)->argc); i += 1) {
nsymes = tfGetCatParents(tfJoinArgN(cat, i)tfFollowArg(cat, i), false((int) 0));
symes = listNConcat(Syme)(Syme_listPointer->NConcat)(symes, nsymes);
}

return symes;
3186}

3188/*
* This handles the case where the TForm could be
* a declaration (or sequence of)
*/
3192localstatic SymeList
3193tfGetCatParentsFrInner(TForm cat)
3194{
SymeList symes;

if (tfIsDeclare(cat)(((cat)->tag) == TF_Declare))
symes = listCopy(Syme)(Syme_listPointer->Copy)(tfSymes(cat)((cat)->symes));
else if (tfHasExpr(cat)((cat)->__absyn != 0))
symes = abGetCatParents(tfGetExpr(cat)((cat)->__absyn));
else
symes = tfGetCatParents(cat, false((int) 0));

return symes;
3205}
3206/******************************************************************************
*
* :: Type form predicates to determine if the exports can be computed.
*
*****************************************************************************/

3212void
3213tfAuditExportList(SymeList symes)
3214{
for (; symes; symes = cdr(symes)((symes)->rest))
if (!symeIsExport(car(symes))(((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes
((((symes)->first))->lib) : ((void*)0)), (((symes)->
first)))->kind) == SYME_Export) && !symeIsExtend(car(symes))(((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes
((((symes)->first))->lib) : ((void*)0)), (((symes)->
first)))->kind) == SYME_Extend))
	bug("tfAuditExportList");
3218}

3220localstatic void
3221tfGetExportError(TForm tf, String order)
3222{
if (DEBUG(tf)tfDebug) {
fprintf(dbOut, "No semantics for %s:  ", order);
tfPrint(dbOut, tf);
fnewline(dbOut);
}
/* "Implementation restriction:
  import from %s before its exports could be determined." */
/* comsgWarning(tfExpr(tf), ALDOR_W_TinEarlyImport, order); */
3231}

3233/*
* There's a few cases where we stamp a real const number on symes from categories.
* This leads to incorrect inlining later on.  While the underlying bug isn't fixed,
* the code below provides a workaround.
*/
3238localstatic void
3239tfValidateDomExports(TForm tf)
3240{
Syme syme;

tfAuditExportList(tfDomExports(tf));

if (!tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id))
return;
syme = tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0);
if (syme && symeIsParam(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Param)) {
tfValidateDomExportsParam(tf);
}
3251}

3253localstatic void
3254tfValidateDomImports(TForm tf)
3255{
Syme syme;

if (!tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id))
return;
syme = tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0);
if (syme && symeIsParam(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Param)) {
tfValidateDomImportsParam(tf);
}
3264}

3266localstatic void
3267tfValidateDomExportsParam(TForm tf)
3268{
tfValidateCheckConstInfo(tf, tfDomExports(tf), "exports");
3270}

3272localstatic void
3273tfValidateDomImportsParam(TForm tf)
3274{
if (tfDomImports(tf))
tfValidateCheckConstInfo(tf, symeSetList(tfDomImports(tf)), "imports");
3277}

3279localstatic void
3280tfValidateCheckConstInfo(TForm tf, SymeList symes, String type)
3281{
while (symes != listNil(Syme)((SymeList) 0)) {
Syme syme = car(symes)((symes)->first);
symes = cdr(symes)((symes)->rest);

if (symeConstNum(syme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !(
((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_ConstInfo
))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_ConstInfo)))
 ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme
)->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_ConstInfo))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ConstInfo
)] : (symeFieldInfo[SYFI_ConstInfo].def)) : symeGetFieldFn(syme
,SYFI_ConstInfo))) & 0xFFFF) != SYME_NUMBER_UNASSIGNED(0x7FFF)) {
  /* Code here patches a bug where there should not be a const here
    afprintf(dbOut, "Type: %s Syme %s.%d %pSyme %pTForm\n",
		 type,
		 libToStringShort(symeConstLib(syme)), symeConstNum(syme),
		 syme, tf);
	bugWarning("Syme with const num found in parameterised domain %s",
		   abPretty(tfExpr(tf)));
  */
	symeSetConstLib(syme, NULL((void*)0));
	symeSetConstNum(syme, SYME_NUMBER_UNASSIGNED(0x7FFF));
}

}
3300}

3302Bool
3303tfHasCatExports(TForm cat)
3304{
return tfCatExportsPending(cat) == NULL((void*)0);
3306}

3308Bool
3309tfHasThdExports(TForm thd)
3310{
return tfThdExportsPending(thd) == NULL((void*)0);
3312}

3314Bool
3315tfHasCatExportsFrWith(Sefo sefo)
3316{
return tfCatExportsPendingFrWith(sefo) == NULL((void*)0);
3318}

3320TForm
3321tfCatExportsPending(TForm cat)
3322{
TForm	pending;

cat = tfDefineeTypeSubst(cat);

if (tfCatExports(cat))
return NULL((void*)0);

if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0))
return NULL((void*)0);

if (!tfIsMeaning(cat)(((cat)->state)>=TF_State_Meaning)) {
assert(tfIsPending(cat))do { if (!((((cat)->state)==TF_State_Pending))) _do_assert
(("tfIsPending(cat)"),"tform.c",3334); } while (0);
return cat;
}

if (tfIsWith(cat)(((cat)->tag) == TF_With)) {
TForm		tfb = tfWithBase(cat)tfFollowArg(cat, 0);
TForm		tfw = tfWithWithin(cat)tfFollowArg(cat, 1);

pending = tfCatExportsPending(tfb);
if (pending) return pending;

tfFollow(tfw)((tfw) = tfFollowFn(tfw));
if (tfCatExports(tfw))
	pending = NULL((void*)0);
else if (tfIsDeclare(tfw)(((tfw)->tag) == TF_Declare))
	pending = (tfSymes(tfw)((tfw)->symes) ? NULL((void*)0) : tfUnknown);
else if (tfHasExpr(tfw)((tfw)->__absyn != 0))
	pending = tfCatExportsPendingFrWith(tfGetExpr(tfw)((tfw)->__absyn));
else
	pending = tfCatExportsPending(tfw);
	
if (pending && tfIsUnknown(pending)(((pending)->tag) == TF_Unknown)) {
	assert(tfIsPending(tfw))do { if (!((((tfw)->state)==TF_State_Pending))) _do_assert
(("tfIsPending(tfw)"),"tform.c",3356); } while (0);
	return tfw;
}
if (pending) return pending;

return NULL((void*)0);
}

else if (tfIsIf(cat)(((cat)->tag) == TF_If)) {
pending = tfCatExportsPending(tfIfThen(cat)tfFollowArg(cat, 1));
if (pending) return pending;

pending = tfCatExportsPending(tfIfElse(cat)tfFollowArg(cat, 2));
if (pending) return pending;

return NULL((void*)0);
}

else if (tfIsJoin(cat)(((cat)->tag) == TF_Join) || tfIsMeet(cat)(((cat)->tag) == TF_Meet)) {
Length	i, argc = tfArgc(cat)((cat)->argc);

for (i = 0; i < argc; i += 1) {
	pending = tfCatExportsPending(tfFollowArg(cat, i));
	if (pending) return pending;
}

return NULL((void*)0);
}

else
return tfThdExportsPending(tfGetCategory(cat));
3387}

3389localstatic TForm
3390tfCatExportsPendingFrWith(Sefo sefo)
3391{
Length		i, argc;
Sefo		*argv;
TForm		pending;

AB_SEQ_ITER(sefo, argc, argv){ switch (((sefo)->abHdr.tag)) { case AB_Nothing: argc = 0
; argv = 0; break; case AB_Sequence: argc = ((sefo)->abHdr
.argc); argv = ((sefo)->abGen.data.argv); break; default: argc
 = 1; argv = &sefo; break; }; };

for (i = 0; i < argc; i += 1) {
AbSyn	id = abDefineeIdOrElse(argv[i], NULL((void*)0));

if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Nothing)
	continue;

/* Defaults package. */
else if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default) {
	AbSyn	def = argv[i]->abDefault.body;
	if (!tfHasSymesFrDefault(def))
		return tfUnknown;
}

/* Explicit declaration. */
else if (id && abTag(argv[i])((argv[i])->abHdr.tag) != AB_Id) {
	if (!abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0))
		return tfUnknown;
}

/* Category expression. */
else if (abState(argv[i])((argv[i])->abHdr.state) == AB_State_HasUnique &&
	 tfSatCat(abTUnique(argv[i])((argv[i])->abHdr.type.unique))) {
	pending = tfThdExportsPending(abTUnique(argv[i])((argv[i])->abHdr.type.unique));
	if (pending) return pending;
}
}

return NULL((void*)0);
3426}

3428localstatic Bool
3429tfHasSymesFrDefault(Sefo sefo)
3430{
Length		i, argc;
Sefo		*argv;
Sefo		id;

switch (abTag(sefo)((sefo)->abHdr.tag)) {
case AB_Nothing:
argc = 0;
argv = 0;
break;
case AB_If:
argc = 2;
argv = &sefo->abIf.thenAlt;
break;
case AB_Sequence:
argc = abArgc(sefo)((sefo)->abHdr.argc);
argv = abArgv(sefo)((sefo)->abGen.data.argv);
break;
default:
id = abDefineeIdOrElse(sefo, NULL((void*)0));
if (id && !abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0)) return false((int) 0);
return true1;
}

for (i = 0; i < argc; i += 1) {
if (!tfHasSymesFrDefault(argv[i]))
	return false((int) 0);
}

return true1;
3460}


3463#define tfTUniqueOrZero(tf)(((tf)->__absyn != 0) ? ((((tf)->__absyn))->abHdr.type
.unique) : ((void*)0)) (tfHasExpr(tf)((tf)->__absyn != 0) ? abTUnique(tfGetExpr(tf))((((tf)->__absyn))->abHdr.type.unique) : NULL((void*)0))

3465TForm
3466tfThdExportsPending(TForm thd)
3467{
      TForm inthd = thd;
/* in bad case we come in here with a Define or a Declare (in the case of == Bug) */
      thd = tfDefineeTypeSubst(thd);
if (tfThdExports(thd))
return NULL((void*)0);

if (tfIsUnknown(thd)(((thd)->tag) == TF_Unknown) || tfIsNone(thd)((((thd)->tag) == TF_Multiple) && tfMultiArgc(thd)
 == 0))
return NULL((void*)0);

if (!tfIsMeaning(thd)(((thd)->state)>=TF_State_Meaning)) {
assert(tfIsPending(thd))do { if (!((((thd)->state)==TF_State_Pending))) _do_assert
(("tfIsPending(thd)"),"tform.c",3478); } while (0);
return thd;
}

if (tfIsThird(thd)(((thd)->tag) == TF_Third)) {
 /* in bad case thd is now a Third whose argv[0] is the rhs of the category */
 if tfIsJoin(tfThirdRestrictions(thd))(((tfFollowArg(thd, 0))->tag) == TF_Join) {
 /* if it is a Join, thd->argv[0]->argv[0..] are the arguments argn of the Join
    and argn->__absyn->abHdr.type.unique would be their Defines
    We will loop indefinitely if one of these Defines is the original.
 */
   Length i, all;
   TForm candidate;
   all = tfJoinArgc(tfThirdRestrictions(thd))((tfFollowArg(thd, 0))->argc);
   for (i=0 ; i < all ; i+=1) {
     candidate = tfTUniqueOrZero(tfJoinArgv(tfThirdRestrictions(thd))[i])(((((tfFollowArg(thd, 0))->argv)[i])->__absyn != 0) ? (
(((((tfFollowArg(thd, 0))->argv)[i])->__absyn))->abHdr
.type.unique) : ((void*)0));
     if (candidate == inthd) { 
fprintf(stderrstderr,"Oops - circular category definition\n");
fflush(stderrstderr);
abPrintDb(inthd->__absyn);
exit(1);
     }
   } /* for */
   return tfCatExportsPending(tfThirdRestrictions(thd)tfFollowArg(thd, 0));

 } /* if Join */
 else if tfIsWith(tfThirdRestrictions(thd))(((tfFollowArg(thd, 0))->tag) == TF_With){
 /* if it is a With, thd->argv[0]->argv[1..] are the arguments argn of the With
    and argn->__absyn->abHdr.type.unique would be their Defines
    We will loop indefinitely if one of these Defines is the original.
 */
   Length i;
   TForm candidate;
   for (i=0 ; i < tfArgc(tfThirdRestrictions(thd))((tfFollowArg(thd, 0))->argc) ; i+=1) {
     candidate = tfTUniqueOrZero(tfArgv(tfThirdRestrictions(thd))[i])(((((tfFollowArg(thd, 0))->argv)[i])->__absyn != 0) ? (
(((((tfFollowArg(thd, 0))->argv)[i])->__absyn))->abHdr
.type.unique) : ((void*)0));
     if (candidate == inthd) { 
fprintf(stderrstderr,"Oops - circular category definition\n");
fflush(stderrstderr);
abPrintDb(inthd->__absyn);
exit(1);
     }
   }
 }
 else if tfIsGeneral(tfThirdRestrictions(thd))(((tfFollowArg(thd, 0))->tag) == TF_General){
   /* if it is a General we need to check circularity in case inthd is a Declare
    */
   if ( tfIsDeclare(inthd)(((inthd)->tag) == TF_Declare) && 
 (tfTUniqueOrZero(tfThirdRestrictions(thd))(((tfFollowArg(thd, 0))->__absyn != 0) ? ((((tfFollowArg(thd
, 0))->__absyn))->abHdr.type.unique) : ((void*)0))->argv[0] == inthd) && 
 (tfTUniqueOrZero(tfThirdRestrictions(thd))(((tfFollowArg(thd, 0))->__absyn != 0) ? ((((tfFollowArg(thd
, 0))->__absyn))->abHdr.type.unique) : ((void*)0))->argv[1] == thd->argv[0])) {
fprintf(stderrstderr,"Oops - circular category definition\n");
fflush(stderrstderr);
abPrintDb(inthd->__absyn);
exit(1);

      }
 }
 return tfCatExportsPending(tfThirdRestrictions(thd)tfFollowArg(thd, 0));
}

else
return NULL((void*)0);
3539}

3541/******************************************************************************
*
* :: Type form exported symes.
*
*****************************************************************************/

3547/* Find the syme in symes corresponding to syme.  Return NULL on failure. */ 
3548localstatic Syme
3549symeListFindExport(SymeList mods, Syme syme1, SymeList symes)
3550{
Syme		syme = NULL((void*)0);

for (; !syme && symes; symes = cdr(symes)((symes)->rest)) {
Syme	syme2 = car(symes)((symes)->first);

if (symeEqualModConditions(mods, syme1, syme2))
	syme = syme2;
}

return syme;
3561}

3563/* Incorporate default/constant number/condition info from syme2 into syme1. */
3564localstatic void
3565tfJoinExports(Syme syme1, Syme syme2)
3566{
if (!symeHasDefault(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)
->lib) : ((void*)0)), (syme1))->bits) & (0x0080)) && symeHasDefault(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)
->lib) : ((void*)0)), (syme2))->bits) & (0x0080))) {
symeSetDefault(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)
->lib) : ((void*)0)), (syme1))->bits) |= (0x0080));
symeTransferImplInfo(syme1, syme2);
}

if (symeCondition(syme1) &&
   !symeCondition(syme2))
symeSetCondition(syme1, listNil(Sefo)((SefoList) 0));
3575}

3577localstatic Bool
3578tfJoinExportToList(SymeList mods, SymeList symes, Syme syme2, Sefo cond)
3579{
Bool	merge = false((int) 0);

for (; !merge && symes; symes = cdr(symes)((symes)->rest)) {
Syme	syme1 = car(symes)((symes)->first);

/* Decide if the two meanings can be merged into one. */
if (!symeEqualModConditions(mods, syme1, syme2))
	merge = false((int) 0);

else if (!symeCondition(syme1))
	merge = true1;

else if (symeCondition(syme2))
	merge = sefoListEqualMod(mods, symeCondition(syme1),
				 symeCondition(syme2));
else
	merge = (cond == NULL((void*)0));

if (merge) {
	tfJoinExports(syme1, syme2);
	symeAddTwin(syme1, syme2);
}
}
return merge;
3604}

3606SymeList
3607tfJoinExportLists(SymeList mods, SymeList symes1, SymeList symes2, Sefo cond)
3608{
SymeList	result = symes1, next, lst;
Table		symesByName = tblNew((TblHashFun) symHashFn, (TblEqFun) symEqual);

for (lst = symes1; lst; lst = cdr(lst)((lst)->rest)) {
Syme syme = car(lst)((lst)->first);
SymeList sl = (SymeList) tblElt(symesByName, symeId(syme)((syme)->id), listNil(Syme)((SymeList) 0));
tblSetElt(symesByName, symeId(syme)((syme)->id), listCons(Syme)(Syme_listPointer->Cons)(syme, sl));
}

for (; symes2; symes2 = cdr(symes2)((symes2)->rest)) {
Syme	syme2 = car(symes2)((symes2)->first);
SymeList namedSymes = tblElt(symesByName, symeId(syme2)((syme2)->id), listNil(Syme)((SymeList) 0));

if (!tfJoinExportToList(mods, namedSymes, syme2, cond)) {
	Syme	syme1 = symeCopy(syme2);
	if (cond) symeAddCondition(syme1, cond, true1);
	next = listCons(Syme)(Syme_listPointer->Cons)(syme1, listNil(Syme)((SymeList) 0));
	result = listNConcat(Syme)(Syme_listPointer->NConcat)(result, next);
	symeAddTwin(syme1, syme2);
	tblSetElt(symesByName, symeId(syme2)((syme2)->id), listCons(Syme)(Syme_listPointer->Cons)(syme1, namedSymes));
}
}
tblFreeDeeply(symesByName, NULL((void*)0), (TblFreeEltFun) listFree(Syme)(Syme_listPointer->Free));
return result;
3633}

3635localstatic SymeList
3636tfMeetExportLists(SymeList mods, SymeList symes1, SymeList symes2, Sefo cond)
3637{
SymeList	result = listNil(Syme)((SymeList) 0);

for (; symes1; symes1 = cdr(symes1)((symes1)->rest)) {
Syme	syme1 = car(symes1)((symes1)->first);
Syme	syme2 = symeListFindExport(mods, syme1, symes2);

if (syme2) {
	/*!! Combine default/const num./condition info. */;
	if (cond) symeAddCondition(syme1, cond, true1);
	result = listCons(Syme)(Syme_listPointer->Cons)(syme1, result);
}
}

result = listNReverse(Syme)(Syme_listPointer->NReverse)(result);
return result;
3653}

3655localstatic SymeList
3656tfAddDomExports(TForm tf, SymeList symes)
3657{
SymeList	nsymes;
SymeList	mods = tfGetDomSelf(tf);

nsymes = tfJoinExportLists(mods, tfDomExports(tf), symes, NULL((void*)0));

tfSetDomExports(tf, nsymes);

return nsymes;
3666}

3668localstatic SymeList
3669tfAddCatExports(TForm tf, SymeList symes)
3670{
SymeList	nsymes;
SymeList	mods = tfGetCatSelf(tf);

nsymes = tfJoinExportLists(mods, tfCatExports(tf), symes, NULL((void*)0));

tfSetCatExports(tf, nsymes);

return nsymes;
3679}

3681localstatic SymeList
3682tfAddThdExports(TForm tf, SymeList symes)
3683{
SymeList	nsymes;
SymeList	mods = tfGetThdSelf(tf);

nsymes = tfJoinExportLists(mods, tfThdExports(tf), symes, NULL((void*)0));

tfSetThdExports(tf, nsymes);

return nsymes;
3692}

3694localstatic SymeList
3695tfAddHasExports(TForm tf, TForm cat)
3696{
Sefo		cond = NULL((void*)0);
SymeList	nsymes;
SymeList	mods = tfGetDomSelf(tf);

cat = tfDefineeType(cat);
if (tfHasExpr(tf)((tf)->__absyn != 0) && tfHasExpr(cat)((cat)->__absyn != 0))
cond = abNewHas(sposNone, tfGetExpr(tf), tfGetExpr(cat))abNew(AB_Has, sposNone,2, ((tf)->__absyn),((cat)->__absyn
));

nsymes = tfGetCatExports(cat);
nsymes = tfJoinExportLists(mods, tfDomExports(tf), nsymes, cond);

tfSetDomExports(tf, nsymes);

return nsymes;
3711}

3713/*
* tfMangleSymes(tf, cat, exports, symes) takes the type "tf",
* its category "cat", a list of category exports "exports"
* from the category of "cat" and a list of domain exports
* "symes" from the add body of "cat". The implementation
* details from "symes" are transferred into "exports".
*
* Note that the symes in "exports" are modified in-place.
*/
3722SymeList
3723tfMangleSymes(TForm tf, TForm cat, SymeList esymes, SymeList symes)
3724{
SymeList	sl, exports = esymes;
SymeList	mods = tfGetDomSelf(tf);


/* Stop if we have nothing to do */
if (!symes || !exports) return esymes;


/* Add in self from the category (??? needed ???) */
mods = listNConcat(Syme)(Syme_listPointer->NConcat)(mods, listCopy(Syme)(Syme_listPointer->Copy)(tfGetCatSelf(cat)));


/* Shift defnNum and constNum from symes into tfDomExports(tf) */
for (;exports; exports = cdr(exports)((exports)->rest))
{
Syme	syme = car(exports)((exports)->first);
TForm	stf  = symeType(syme);
int	cnum = symeConstNum(syme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !(
((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_ConstInfo
))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_ConstInfo)))
 ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme
)->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_ConstInfo))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ConstInfo
)] : (symeFieldInfo[SYFI_ConstInfo].def)) : symeGetFieldFn(syme
,SYFI_ConstInfo))) & 0xFFFF);


/* Skip symes that aren't exports */
if (!symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Export))
	continue;


/* Skip symes that are okay */
if (cnum != SYME_NUMBER_UNASSIGNED(0x7FFF))
	continue;


/* Search for this syme in symes */
for (sl = symes;sl;sl = cdr(sl)((sl)->rest))
{
	Syme	csyme = car(sl)((sl)->first);
	TForm	cstf  = symeType(csyme);
	int	ccnum = symeConstNum(csyme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !(
((((csyme)->kind == SYME_Trigger ? libGetAllSymes((csyme)->
lib) : ((void*)0)), (csyme))->hasmask) & (1 << (
SYFI_ConstInfo))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((
((csyme)->kind == SYME_Trigger ? libGetAllSymes((csyme)->
lib) : ((void*)0)), (csyme))->locmask) & (1 << (
SYFI_ConstInfo))) ? ((((((csyme)->kind == SYME_Trigger ? libGetAllSymes
((csyme)->lib) : ((void*)0)), (csyme))->locmask) & (
<< (SYFI_ConstInfo))) ? ((csyme)->fieldv)[symeIndex
(csyme,SYFI_ConstInfo)] : (symeFieldInfo[SYFI_ConstInfo].def)
) : symeGetFieldFn(csyme,SYFI_ConstInfo))) & 0xFFFF);
	int	cdnum = symeDefnNum(csyme)((int) (SYFI_DefnNum < (8 * sizeof(int)) && !(((((
csyme)->kind == SYME_Trigger ? libGetAllSymes((csyme)->
lib) : ((void*)0)), (csyme))->hasmask) & (1 << (
SYFI_DefnNum))) ? (symeFieldInfo[SYFI_DefnNum].def) : (((((csyme
)->kind == SYME_Trigger ? libGetAllSymes((csyme)->lib) :
 ((void*)0)), (csyme))->locmask) & (1 << (SYFI_DefnNum
))) ? ((((((csyme)->kind == SYME_Trigger ? libGetAllSymes(
(csyme)->lib) : ((void*)0)), (csyme))->locmask) & (
<< (SYFI_DefnNum))) ? ((csyme)->fieldv)[symeIndex(
csyme,SYFI_DefnNum)] : (symeFieldInfo[SYFI_DefnNum].def)) : symeGetFieldFn
(csyme,SYFI_DefnNum)));


	/* Skip symes that aren't exports */
	if (!symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Export))
		continue;


	/* Skip symes with no defn or const number */
	if (!cdnum && (ccnum == SYME_NUMBER_UNASSIGNED(0x7FFF)))
		continue;


	/* Do the names match? */
	if (symeId(syme)((syme)->id) != symeId(csyme)((csyme)->id))
		continue;


	/* Do the types match? */
	if (!tformEqualMod(mods, stf, cstf))
		continue;


	/* DEBUGGING */
	tfImportDEBUGif (!tfImportDebug) { } else afprintf(dbOut, "\t* %d --> %d, %d --> %d [%s]\n",
			 symeDefnNum(syme)((int) (SYFI_DefnNum < (8 * sizeof(int)) && !(((((
syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib
) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_DefnNum
))) ? (symeFieldInfo[SYFI_DefnNum].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_DefnNum))) ?
 ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)
->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_DefnNum))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_DefnNum
)] : (symeFieldInfo[SYFI_DefnNum].def)) : symeGetFieldFn(syme
,SYFI_DefnNum))),
			 symeDefnNum(csyme)((int) (SYFI_DefnNum < (8 * sizeof(int)) && !(((((
csyme)->kind == SYME_Trigger ? libGetAllSymes((csyme)->
lib) : ((void*)0)), (csyme))->hasmask) & (1 << (
SYFI_DefnNum))) ? (symeFieldInfo[SYFI_DefnNum].def) : (((((csyme
)->kind == SYME_Trigger ? libGetAllSymes((csyme)->lib) :
 ((void*)0)), (csyme))->locmask) & (1 << (SYFI_DefnNum
))) ? ((((((csyme)->kind == SYME_Trigger ? libGetAllSymes(
(csyme)->lib) : ((void*)0)), (csyme))->locmask) & (
<< (SYFI_DefnNum))) ? ((csyme)->fieldv)[symeIndex(
csyme,SYFI_DefnNum)] : (symeFieldInfo[SYFI_DefnNum].def)) : symeGetFieldFn
(csyme,SYFI_DefnNum))),
			 symeConstNum(syme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !(
((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_ConstInfo
))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_ConstInfo)))
 ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme
)->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_ConstInfo))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ConstInfo
)] : (symeFieldInfo[SYFI_ConstInfo].def)) : symeGetFieldFn(syme
,SYFI_ConstInfo))) & 0xFFFF),
			 symeConstNum(csyme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !(
((((csyme)->kind == SYME_Trigger ? libGetAllSymes((csyme)->
lib) : ((void*)0)), (csyme))->hasmask) & (1 << (
SYFI_ConstInfo))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((
((csyme)->kind == SYME_Trigger ? libGetAllSymes((csyme)->
lib) : ((void*)0)), (csyme))->locmask) & (1 << (
SYFI_ConstInfo))) ? ((((((csyme)->kind == SYME_Trigger ? libGetAllSymes
((csyme)->lib) : ((void*)0)), (csyme))->locmask) & (
<< (SYFI_ConstInfo))) ? ((csyme)->fieldv)[symeIndex
(csyme,SYFI_ConstInfo)] : (symeFieldInfo[SYFI_ConstInfo].def)
) : symeGetFieldFn(csyme,SYFI_ConstInfo))) & 0xFFFF),
			 symePretty(syme));


	/* Transfer implementation details */
	symeTransferImplInfo(syme, csyme);
}
}


/* Return a copy of the modified symes */
return esymes;
3801}

3803SymbolTSet
3804tfGetDomExportNames(TForm tf)
3805{
SymeList exports;
SymbolTSet symbols;

if (tfDomExportNames(tf))
return tfDomExportNames(tf);

exports = tfGetDomExports(tf);

symbols = tsetCreate(Symbol)(Symbol_tsetPointer->Create)();

while (exports != listNil(Syme)((SymeList) 0)) {
tsetAdd(Symbol)(Symbol_tsetPointer->Add)(symbols, symeId(car(exports))((((exports)->first))->id));
exports = cdr(exports)((exports)->rest);
}

return symbols;
3822}

3824/*
* Called on a domain to get the symbol meanings which are
* exported from the domain.
*/
3828SymeList
3829tfGetDomExports(TForm tf)
3830{
TFormList	hl;

tf = tfDefineeType(tf);

tf = tfIgnoreExceptions(tf);

if (tfHasSelf(tf)((tf)->hasSelf) && tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id) && symeExtension(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))) {
return tfGetDomExports(tfFrSyme(stabFile(), symeExtensionFull(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))));
}

if (tfDomExports(tf) || tfIsUnknown(tf)(((tf)->tag) == TF_Unknown) || tfIsNone(tf)((((tf)->tag) == TF_Multiple) && tfMultiArgc(tf) ==
 0))
return tfDomExports(tf);

if (!tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning)) {
tfGetExportError(tf, "domain");
return tfDomExports(tf);
}

if (DEBUG(tfImport)tfImportDebug) {
fprintf(dbOut, "(tfGetDomExports:  from ");
tfPrint(dbOut, tf);
fnewline(dbOut);
}

/*
* Collect the domain exports from the type form.
*/
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
)))
tfSetDomExports(tf, listNil(Syme)((SymeList) 0));

else if (tfIsAdd(tf)(((tf)->tag) == TF_Add))
tfSetDomExports(tf, tfSymes(tf)((tf)->symes));

else if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT) || tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
tfSetDomExports(tf, listNil(Syme)((SymeList) 0));

else if (tfIsLibrary(tf))
tfSetDomExports(tf, libGetSymes(tfLibraryLib(tf)));

else if (tfIsArchive(tf))
tfSetDomExports(tf, arGetSymes(tfArchiveAr(tf)));

else {
SymeList exps, vexps;
TForm cat, val = (TForm)NULL((void*)0);
if (tfIsEnum(tf)(((tf)->tag) == TF_Enumerate) || tfIsRecord(tf)(((tf)->tag) == TF_Record) || tfIsRawRecord(tf)(((tf)->tag) == TF_RawRecord) ||
    tfIsTrailingArray(tf)(((tf)->tag) == TF_TrailingArray) || tfIsUnion(tf)(((tf)->tag) == TF_Union))
	tfSetDomExports(tf, listCopy(Syme)(Syme_listPointer->Copy)(tfSymes(tf)((tf)->symes)));
tfGetDomSelf(tf);
cat = tfGetCategory(tf);
tfFollow(cat)((cat) = tfFollowFn(cat));

assert(tfIsDefine(cat) ? (tfDefineVal(cat) != tf) : true)do { if (!((((cat)->tag) == TF_Define) ? (tfFollowArg(cat,
 1) != tf) : 1)) _do_assert(("tfIsDefine(cat) ? (tfDefineVal(cat) != tf) : true"
),"tform.c",3883); } while (0);

exps = tfGetCatExports(cat);
if (tfIsDefine(cat)(((cat)->tag) == TF_Define))
	val = tfDefineVal(cat)tfFollowArg(cat, 1);

if (DEBUG(symeRefresh)symeRefreshDebug) {
	if (val && !tfIsAdd(val)(((val)->tag) == TF_Add)) {
		(void)fprintf(dbOut, "\n-------- (not add)\n");
		(void)tfPrintDb(val);
	}
}

if (val && tfIsAdd(val)(((val)->tag) == TF_Add)) {
	vexps = tfGetDomExports(val);
	exps = tfMangleSymes(tf, cat, exps, vexps);
}
tfAddDomExports(tf, exps);
tfGetDomCascades(tf);
}

/*
* Collect the conditional exports from the has questions.
*/
for (hl = tfQueries(tf)((tf)->queries); hl; hl = cdr(hl)((hl)->rest))
tfAddHasExports(tf, car(hl)((hl)->first));

tfImportDEBUGif (!tfImportDebug) { } else afprintf(dbOut, ")\n");

tfValidateDomExports(tf);
return tfDomExports(tf);
3914}

3916/*
* Called on a category to get the symbol meanings which are
* exported by domains of this category.
*/
3920SymeList
3921tfGetCatExports(TForm cat)
3922{
static int count = 0;
int serialThis = count++;
tfFollow(cat)((cat) = tfFollowFn(cat));
if (tfIsDefineOfType(cat))
5
←
Taking false branch→
return tfGetDomExports(tfDefineVal(cat)tfFollowArg(cat, 1));

cat = tfDefineeType(cat);

if (tfCatExports(cat) || tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0) ||
6
←
Assuming the condition is false→
7
←
Assuming field 'tag' is not equal to TF_Unknown→
8
←
Assuming field 'tag' is not equal to TF_Multiple→
9
←
Taking false branch→
   !tfHasCatExports(cat))
return tfCatExports(cat);

if (!tfIsMeaning(cat)(((cat)->state)>=TF_State_Meaning)) {
10
←
Taking false branch→
tfGetExportError(cat, "category");
return tfCatExports(cat);
}

if (DEBUG(tfCat)tfCatDebug) {
11
←
Assuming 'tfCatDebug' is not equal to 0→
12
←
Taking true branch→
afprintf(dbOut, "(tfGetCatExports:%d:  from %pTForm\n", serialThis, cat);
}

tfGetCatSelf(cat);
tfGetCatCascades(cat);

if (tfIsWith(cat)(((cat)->tag) == TF_With) && tfUseCatExports(cat)(((((tfFollowArg(cat, 0))->tag) == TF_Multiple) &&
 tfMultiArgc(tfFollowArg(cat, 0)) == 0) && ((((tfFollowArg
(cat, 1))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg
(cat, 1)) == 0)))
13
←
Assuming field 'tag' is equal to TF_With→
14
←
Assuming field 'tag' is not equal to TF_Multiple→
tfAddCatExports(cat,tfGetCatExportsFrParents(tfParents(cat)((cat)->parents)));

else if (tfIsWith(cat)(((cat)->tag) == TF_With))
15
←
Taking true branch→
tfGetCatExportsFrWith(cat);
16
←
Calling 'tfGetCatExportsFrWith'→

else if (tfIsIf(cat)(((cat)->tag) == TF_If))
tfGetCatExportsFrIf(cat);

else if (tfIsJoin(cat)(((cat)->tag) == TF_Join))
tfGetCatExportsFrJoin(cat);

else if (tfIsMeet(cat)(((cat)->tag) == TF_Meet))
tfGetCatExportsFrMeet(cat);

else
tfAddCatExports(cat, tfGetThdExports(tfGetCategory(cat)));

if (DEBUG(tfCat)tfCatDebug) {
SymeList symes = tfCatExports(cat);
if (symes) {
	int n = 0;
	afprintf(dbOut, " Exports for %pTForm: [\n", cat);
	while (symes != listNil(Syme)((SymeList) 0)) {
		Syme syme = car(symes)((symes)->first);
		symes = cdr(symes)((symes)->rest);

		afprintf(dbOut,
			 "%d  %s %s %pAbSynList\n", n, symeString(syme)((((syme)->id))->str), symeHasDefault(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0080)) ? "DEF" : "NO",
			 symeCondition(syme));
		afprintf(dbOut,
			 "%d  %s: %pTForm\n", n, symeString(syme)((((syme)->id))->str), symeType(syme));
		n++;
	}
	afprintf(dbOut, " ]\n", cat);
}
}

tfCatDEBUGif (!tfCatDebug) { } else afprintf(dbOut, " %d)\n", serialThis);

tfAuditExportList(tfCatExports(cat));
return tfCatExports(cat);
3989}

3991/*
* Called on the type of a category to get the symbol meanings which are
* exported by domains of this category.
*/
3995SymeList
3996tfGetThdExports(TForm thd)
3997{
thd = tfDefineeType(thd);

if (tfThdExports(thd) || tfIsUnknown(thd)(((thd)->tag) == TF_Unknown) || tfIsNone(thd)((((thd)->tag) == TF_Multiple) && tfMultiArgc(thd)
 == 0) ||
   !tfHasThdExports(thd))
return tfThdExports(thd);

if (!tfIsMeaning(thd)(((thd)->state)>=TF_State_Meaning)) {
tfGetExportError(thd, "third-order type");
return tfThdExports(thd);
}

if (DEBUG(tfCat)tfCatDebug) {
fprintf(dbOut, "(tfGetThdExports:  from ");
tfPrint(dbOut, thd);
fnewline(dbOut);
}

tfGetThdSelf(thd);
tfGetThdCascades(thd);

if (tfIsThird(thd)(((thd)->tag) == TF_Third) && tfUseThdExports(thd)(((((tfFollowArg(thd, 0))->tag) == TF_Multiple) &&
 tfMultiArgc(tfFollowArg(thd, 0)) == 0))) {
tfAddThdExports(thd,tfGetCatExportsFrParents(tfParents(thd)((thd)->parents)));
tfAddThdExports(thd,tfSymes(thd)((thd)->symes));
}

else if (tfIsThird(thd)(((thd)->tag) == TF_Third)) {
tfAddThdExports(thd,tfGetCatExports(tfThirdRestrictions(thd)tfFollowArg(thd, 0)));
tfAddThdExports(thd,tfSymes(thd)((thd)->symes));
}

tfCatDEBUGif (!tfCatDebug) { } else afprintf(dbOut, ")\n");

tfAuditExportList(tfThdExports(thd));
return tfThdExports(thd);
4032}

4034/*
* tfGet...Exports helper functions.
*/

4038localstatic SymeList
4039tfGetCatExportsFrParents(SymeList symes)
4040{
static int count = 0;
SymeTSet	oldTbl = tsetCreateCustom(Syme)(Syme_tsetPointer->CreateCustom)(symeHashFn, symeEqual);
SymeList	nsymes;
SymeList	queue = listCopy(Syme)(Syme_listPointer->Copy)(symes);
SymeList	xsymes = listNil(Syme)((SymeList) 0);
SefoList	cond;

while (queue) {
int serialThis = count++;
Syme		syme = car(queue)((queue)->first);
SymeList	cell = queue;
queue = cdr(queue)((queue)->rest);

/* Move syme to xsymes. */
setcdr(cell, xsymes)((cell)->rest = (xsymes));
xsymes = cell;

if (!symeIsSelfSelf(syme)(((syme)->id) == ssymSelfSelf)) continue;

if (DEBUG(tfParent)tfParentDebug) {
	afprintf(dbOut, "(tfCatExports:%d: expanding %pTForm %pAbSynList\n",
		 serialThis,
		 symeType(syme), symeCondition(syme));
}

nsymes = tfGetCatParents(symeType(syme), true1);
cond = symeCondition(syme);
if (cond) nsymes = tfGetCatExportsCond(nsymes, cond, true1);

if (DEBUG(tfParent)tfParentDebug) {
	afprintf(dbOut, "tfCatExports:%d: into %pSymeList)\n", serialThis, nsymes);
}

nsymes = tfGetCatExportsFilterTable(oldTbl, nsymes);
tsetAddAll(Syme)(Syme_tsetPointer->AddAll)(oldTbl, nsymes);
queue = listNConcat(Syme)(Syme_listPointer->NConcat)(listCopy(Syme)(Syme_listPointer->Copy)(nsymes), queue);
}
tsetFree(Syme)(Syme_tsetPointer->Free)(oldTbl);

return listNReverse(Syme)(Syme_listPointer->NReverse)(xsymes);
4081}

4083localstatic SymeList
4084tfGetCatExportsCond(SymeList symes0, SefoList conds0, Bool pos)
4085{
SymeList	symes, nsymes = listNil(Syme)((SymeList) 0);
SefoList	conds;
SefoList reversedConds0 = listReverse(Sefo)(Sefo_listPointer->Reverse)(conds0);

/* Reverse conditions so that any dependency in evaluation is preserved.
* For example S has Ring and X has Algebra S
*/
for (symes = symes0; symes; symes = cdr(symes)((symes)->rest)) {
Syme syme = car(symes)((symes)->first);
Syme nsyme;
if (listContainsAllq(Sefo)(Sefo_listPointer->ContainsAllq)(symeCondition(syme), conds0)) {
	nsymes = listCons(Syme)(Syme_listPointer->Cons)(syme, nsymes);
}
else {
	nsyme = symeCopy(syme);
	for (conds = reversedConds0; conds; conds = cdr(conds)((conds)->rest)) {
		symeAddCondition(nsyme, car(conds)((conds)->first), pos);
	}
	nsymes = listCons(Syme)(Syme_listPointer->Cons)(nsyme, nsymes);
}
}
listFree(Sefo)(Sefo_listPointer->Free)(reversedConds0);

return listNReverse(Syme)(Syme_listPointer->NReverse)(nsymes);
4110}

4112localstatic SymeList
4113tfGetCatExportsFilterTable(SymeTSet oldTbl, SymeList nsymes)
4114{
SymeList	symes, rsymes = listNil(Syme)((SymeList) 0);

/* Remove symes for %% which have been seen before. */
for (symes = nsymes; symes; symes = cdr(symes)((symes)->rest))
if (!(symeIsSelfSelf(car(symes))(((((symes)->first))->id) == ssymSelfSelf) &&
      tsetMember(Syme)(Syme_tsetPointer->Member)(oldTbl, car(symes)((symes)->first))))
	rsymes = listCons(Syme)(Syme_listPointer->Cons)(car(symes)((symes)->first), rsymes);

listFree(Syme)(Syme_listPointer->Free)(nsymes);
return listNReverse(Syme)(Syme_listPointer->NReverse)(rsymes);
4125}

4127localstatic SymeList
4128tfGetCatExportsFrWith(TForm cat)
4129{
TForm		tfb = tfWithBase(cat)tfFollowArg(cat, 0);
TForm		tfw = tfWithWithin(cat)tfFollowArg(cat, 1);
SymeList	bsymes, wsymes;

bsymes = tfGetCatExports(tfb);

tfFollow(tfw)((tfw) = tfFollowFn(tfw));
if (tfCatExports(tfw))
17
←
Assuming the condition is false→
18
←
Taking false branch→
wsymes = tfCatExports(tfw);

else if (tfIsDeclare(tfw)(((tfw)->tag) == TF_Declare))
19
←
Assuming field 'tag' is not equal to TF_Declare→
20
←
Taking false branch→
wsymes = tfSymes(tfw)((tfw)->symes);

else if (tfHasExpr(tfw)((tfw)->__absyn != 0))
21
←
Assuming field '__absyn' is not equal to null→
22
←
Taking true branch→
wsymes = tfGetCatImportsFrWith(tfGetExpr(tfw)((tfw)->__absyn), bsymes);
23
←
Calling 'tfGetCatImportsFrWith'→

else
wsymes = tfGetCatExports(tfw);

tfSetCatExports(tfw, wsymes);

tfAddCatExports(cat, bsymes);
tfAddCatExports(cat, wsymes);

return tfCatExports(cat);
4155}

4157localstatic SymeList
4158tfGetCatExportsFrIf(TForm cat)
4159{
SymeList	tsymes, esymes, symes = listNil(Syme)((SymeList) 0);
SymeList	mods = tfGetCatSelf(cat);
Sefo		cond;

tfFollow(cat->argv[0])((cat->argv[0]) = tfFollowFn(cat->argv[0]));

if (tfNeedsSefo(cat->argv[0])((cat->argv[0])->state == TF_State_NeedsSefo)) 
tiTopFns()->tiTfSefo(stabFile(), cat->argv[0]);

cond = tfIfCond(cat)tfToAbSyn(tfFollowArg(cat, 0));
tsymes = tfGetCatExports(tfIfThen(cat)tfFollowArg(cat, 1));
symes = tfJoinExportLists(mods, symes, tsymes, cond);

cond = abNewNot(sposNone, cond)abNew(AB_Not, sposNone,1, cond);
esymes = tfGetCatExports(tfIfElse(cat)tfFollowArg(cat, 2));
symes = tfJoinExportLists(mods, symes, esymes, cond);

tfSetCatExports(cat, symes);

return symes;
4180}

4182localstatic SymeList
4183tfGetCatExportsFrJoin(TForm cat)
4184{
SymeList	nsymes, symes = tfCatExports(cat);
SymeList	mods = tfGetCatSelf(cat);
Length		i;

for (i = 0; i < tfJoinArgc(cat)((cat)->argc); i += 1) {
nsymes = tfGetCatExports(tfJoinArgN(cat, i)tfFollowArg(cat, i));
symes = tfJoinExportLists(mods, symes, nsymes, NULL((void*)0));
}

tfSetCatExports(cat, symes);

return symes;
4197}

4199localstatic SymeList
4200tfGetCatExportsFrMeet(TForm cat)
4201{
SymeList	nsymes, symes = tfCatExports(cat);
SymeList	mods = tfGetCatSelf(cat);
Length		i;

nsymes = tfGetCatExports(tfMeetArgN(cat, int0)tfFollowArg(cat, ((int) 0)));
symes = tfJoinExportLists(mods, symes, nsymes, NULL((void*)0));
for (i = 1; i < tfMeetArgc(cat)((cat)->argc); i += 1) {
nsymes = tfGetCatExports(tfMeetArgN(cat, i)tfFollowArg(cat, i));
symes = tfMeetExportLists(mods, symes, nsymes, NULL((void*)0));
}

tfSetCatExports(cat, symes);

return symes;
4216}

4218/******************************************************************************
*
* :: Type form imported symes.
*
*****************************************************************************/

4224Syme
4225tfHasDomExportMod(TForm tf, SymeList mods, Symbol sym, TForm type)
4226{
SymeList	sl;

for (sl = tfGetDomExports(tf); sl; sl = cdr(sl)((sl)->rest)) {
Syme syme = car(sl)((sl)->first);
if (symeId(syme)((syme)->id) != sym) continue;
if (!tformEqualMod(mods, symeType(syme), type)) continue;
return syme;
}
return NULL((void*)0);
4236}

4238Syme
4239tfHasDomImport(TForm tf, Symbol sym, TForm type)
4240{
SymeList	sl;

for (sl = tfGetDomImportsByName(tf, sym); sl; sl = cdr(sl)((sl)->rest)) {
Syme syme = car(sl)((sl)->first);
assert(symeId(syme) == sym)do { if (!(((syme)->id) == sym)) _do_assert(("symeId(syme) == sym"
),"tform.c",4245); } while (0);
if (tformEqual(symeType(syme), type))
	return syme;
}
return NULL((void*)0);
4250}

4252localstatic Syme
4253tfGetBuiltinSyme(TForm tf, Symbol sym)
4254{
SymeList	symes;
Syme		syme0 = NULL((void*)0);

assert(tfDomImports(tf))do { if (!(tfDomImports(tf))) _do_assert(("tfDomImports(tf)")
,"tform.c",4258); } while (0);
for (symes = symeSetList(tfDomImports(tf)); symes; symes = cdr(symes)((symes)->rest)) {
Syme	syme = car(symes)((symes)->first);
if (symeId(syme)((syme)->id) == sym)
	syme0 = syme;
}
return syme0;
4265}

4267/******************************************************************************
*
* :: Type imports and exports
*
*****************************************************************************/

4273extern SymeSet
4274tfDomImports(TForm tf)
4275{
return tf->domImports;
4277}

4279extern void
4280tfSetDomImports(TForm tf, SymeSet symeSet)
4281{
tf->domImports = symeSet;
4283}

4285extern SymeList
4286tfDomExports(TForm tf)
4287{
return tf->domExports;
4289}

4291extern void
4292tfSetDomExports(TForm tf, SymeList symeList)
4293{
tf->domExports = symeList;
4295}

4297extern SymbolTSet
4298tfDomExportNames(TForm tf)
4299{
return tf->domExportNames;
4301}

4303extern void
4304tfSetDomExportNames(TForm tf, SymbolTSet symbols)
4305{
tf->domExportNames = symbols;
4307}

4309extern SymeList
4310tfCatExports(TForm tf)
4311{
return tf->catExports;
4313}

4315extern void
4316tfSetCatExports(TForm tf, SymeList symeList)
4317{
tf->catExports = symeList;
4319}

4321extern SymeList
4322tfThdExports(TForm tf)
4323{
return tf->thdExports;
4325}

4327extern void
4328tfSetThdExports(TForm tf, SymeList symeList)
4329{
tf->thdExports = symeList;
4331}


4334/*
* Called on a domain to get the symbol meanings to include
* in the current scope. Use this in preference to the older
* tfGetDomImports() to reduce the chance of polluting the
* top-level stab for the current file.
*/

4341localstatic Bool
4342tfImportsPending(TForm tf)
4343{
return symeSetList(tfDomImports(tf)) == listNil(Syme)((SymeList) 0);
4345}

4347SymeList
4348tfStabGetDomImports(Stab stab, TForm tf)
4349{
return symeSetList(tfStabGetDomImportSet(stab, tf));
4351}

4353SymeSet
4354tfStabGetDomImportSet(Stab stab, TForm tf)
4355{
tf = tfDefineeType(tf);

tf = tfIgnoreExceptions(tf);

if (tfDomImports(tf) && !tfImportsPending(tf))
return tfDomImports(tf);
if (tfDomImports(tf)) {
symeSetFree(tfDomImports(tf));
tfSetDomImports(tf, NULL((void*)0));
}
tfStabCreateDomImportSet(stab, tf);

return tfDomImports(tf);
4369}

4371localstatic SymeSet
4372tfStabCreateDomImportSet(Stab stab, TForm tf)
4373{
static int count = 0;
int serialThis = count++;
SymeSet  symeSet;
SymeList xsymes, symes;

if (DEBUG(tfImport)tfImportDebug) {
afprintf(dbOut, "(tfStabGetDomImports:%d: from %pTForm\n", serialThis, tf);
}

xsymes = tfGetDomExports(tf);

symes = symeListSubstSelf(stab, tf, xsymes);

if (tfConditions(tf) != NULL((void*)0)) {
SymeList sl = symes;
while (sl != listNil(Syme)((SymeList) 0)) {
	Syme syme = car(sl)((sl)->first);
	TForm symeTf = symeType(syme);
	tfDEBUGif (!tfDebug) { } else afprintf(dbOut, "%d: Setting imported condition %s %pTForm\n",
		serialThis, symeString(syme)((((syme)->id))->str), symeTf);
	tfSetConditions(symeTf, tfConditions(tf))(symeTf->conditions = (tfConditions(tf)));
	symeSetConditionContext(syme, tfConditionalAbSyn(tf))(symeSetFieldVal = ((AInt) (tfConditionalAbSyn(tf))), (((((syme
)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) :
 ((void*)0)), (syme))->locmask) & (1 << (SYFI_ConditionContext
))) ? (((syme)->fieldv)[symeIndex(syme,SYFI_ConditionContext
)] = (symeSetFieldVal)) : !((syme)->full) && symeSetFieldVal
 == (symeFieldInfo[SYFI_ConditionContext].def) ? symeSetFieldVal
 : symeSetFieldFn(syme,SYFI_ConditionContext,symeSetFieldVal)
);
	sl = cdr(sl)((sl)->rest);
}

}

symes = symeListCheckCondition(symes);

symeSet = symeSetFrSymes(symes);

tfSetDomImports(tf, symeSet);

if (tfIsBasicLib(tf))
tfInitBasicTypes(tf);

if (DEBUG(tfImport)tfImportDebug) {
symeListPrintDb(symes);
fprintf(dbOut, " %d)\n", serialThis);
tfPrint(dbOut, tf);
fnewline(dbOut);
}

tfValidateDomImports(tf);

return symeSet;
4420}

4422/*
* Called on a domain to get the symbol meanings to include
* in the current scope. This may cause tforms to be imported
* into stabFile() which can cause grief (e.g. bug1192) so
* use tfStabGetDomImports() if you have a localised stab.
*/
4428SymeList
4429tfGetDomImports(TForm tf)
4430{
/*
* This use of stabFile() is extremely unfortunate because it
* associates the tform with the top-level of the file being
* compiled. This allows inner symbols to escape their stab
* levels and jump directly to the top.
*/
return symeSetList(tfStabGetDomImportSet(stabFile(), tf));
4438}

4440SymeSet
4441tfGetDomImportSet(TForm tf)
4442{
/*
* This use of stabFile() is extremely unfortunate because it
* associates the tform with the top-level of the file being
* compiled. This allows inner symbols to escape their stab
* levels and jump directly to the top.
*/
return tfStabGetDomImportSet(stabFile(), tf);
4450}

4452SymeList
4453tfGetDomImportsByName(TForm tf, Symbol sym)
4454{
return tfStabGetDomImportsByName(stabFile(), tf, sym);
4456}

4458SymeList
4459tfStabGetDomImportsByName(Stab stab, TForm tf, Symbol sym)
4460{
return symeSetSymesForSymbol(tfStabGetDomImportSet(stab, tf), sym);
4462}

4464SymeList
4465tfGetCatImportsFrWith(Sefo sefo, SymeList bsymes)
4466{
SymeList	xsymes, isymes, dsymes, csymes, symes;
Length		i, argc;
Sefo		*argv;
Sefo		id;
TForm		cat;

/*!! assert(tfHasCatExportsFrWith(sefo)); */

AB_SEQ_ITER(sefo, argc, argv){ switch (((sefo)->abHdr.tag)) { case AB_Nothing: argc = 0
; argv = 0; break; case AB_Sequence: argc = ((sefo)->abHdr
.argc); argv = ((sefo)->abGen.data.argv); break; default: argc
 = 1; argv = &sefo; break; }; };
24
←
Control jumps to the 'default' case at line 4475→

xsymes = isymes = dsymes = listNil(Syme)((SymeList) 0);
25
←
 Execution continues on line 4477→
for (i = 0; i < argc; i++) {
26
←
Loop condition is true.  Entering loop body→
id = abDefineeIdOrElse(argv[i], NULL((void*)0));

if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Nothing)
27
←
Assuming field 'tag' is not equal to AB_Nothing→
28
←
Taking false branch→
	continue;

/* Defaults package. */
else if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default) {
29
←
Assuming field 'tag' is not equal to AB_Default→
	AbSyn	def = argv[i]->abDefault.body;
	symes = tfSymesFrDefault(def);
	dsymes = listNConcat(Syme)(Syme_listPointer->NConcat)(symes, dsymes);
}

/* Explicit declaration. */
else if (id && abTag(argv[i])((argv[i])->abHdr.tag) != AB_Id) {
30
←
Assuming 'id' is non-null→
31
←
Assuming field 'tag' is not equal to AB_Id→
	assert(abSyme(id))do { if (!(((id)->abHdr.seman ? (id)->abHdr.seman->syme
 : 0))) _do_assert(("abSyme(id)"),"tform.c",4493); } while (0
);
32
←
Taking true branch→
33
←
Assuming field 'seman' is null→
34
←
'?' condition is false→
35
←
Taking true branch→
	if (symeIsExport(abSyme(id))(((((((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0
))->kind == SYME_Trigger ? libGetAllSymes((((id)->abHdr
.seman ? (id)->abHdr.seman->syme : 0))->lib) : ((void
*)0)), (((id)->abHdr.seman ? (id)->abHdr.seman->syme
 : 0)))->kind) == SYME_Export))
36
←
Loop condition is false.  Exiting loop→
37
←
'?' condition is false→
38
←
Access to field 'kind' results in a dereference of a null pointer
		xsymes = listCons(Syme)(Syme_listPointer->Cons)(abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0), xsymes);
}

/* Category expression. */
else if (!tfIsUnknown(cat = abGetCategory(argv[i]))(((cat = abGetCategory(argv[i]))->tag) == TF_Unknown) &&
	 tfSatCat(cat)) {
	csymes = tfGetThdExports(cat);
	isymes = symeListUnion(isymes, csymes, symeEqual);
}
}

/* Mark the symes which have a default implementation. */
dsymes = listNReverse(Syme)(Syme_listPointer->NReverse)(dsymes);
for (; dsymes; dsymes = listFreeCons(Syme)(Syme_listPointer->FreeCons)(dsymes)) {
Syme	dsyme = car(dsymes)((dsymes)->first);
Syme	xsyme = NULL((void*)0);

/* If the default is one of our exports, just mark it. */
for (symes = xsymes; !xsyme && symes; symes = cdr(symes)((symes)->rest))
	if (symeEqual(car(symes)((symes)->first), dsyme)) {
		xsyme = car(symes)((symes)->first);
		symeSetDefault(xsyme)(((((xsyme)->kind == SYME_Trigger ? libGetAllSymes((xsyme)
->lib) : ((void*)0)), (xsyme))->bits) |= (0x0080));
		symeSetSrcPos(xsyme, symeSrcPos(dsyme))(symeSetFieldVal = ((AInt) (((SrcPos) (SYFI_SrcPos < (8 * sizeof
(int)) && !(((((dsyme)->kind == SYME_Trigger ? libGetAllSymes
((dsyme)->lib) : ((void*)0)), (dsyme))->hasmask) & (
<< (SYFI_SrcPos))) ? (symeFieldInfo[SYFI_SrcPos].def)
 : (((((dsyme)->kind == SYME_Trigger ? libGetAllSymes((dsyme
)->lib) : ((void*)0)), (dsyme))->locmask) & (1 <<
 (SYFI_SrcPos))) ? ((((((dsyme)->kind == SYME_Trigger ? libGetAllSymes
((dsyme)->lib) : ((void*)0)), (dsyme))->locmask) & (
<< (SYFI_SrcPos))) ? ((dsyme)->fieldv)[symeIndex(dsyme
,SYFI_SrcPos)] : (symeFieldInfo[SYFI_SrcPos].def)) : symeGetFieldFn
(dsyme,SYFI_SrcPos))))), (((((xsyme)->kind == SYME_Trigger
 ? libGetAllSymes((xsyme)->lib) : ((void*)0)), (xsyme))->
locmask) & (1 << (SYFI_SrcPos))) ? (((xsyme)->fieldv
)[symeIndex(xsyme,SYFI_SrcPos)] = (symeSetFieldVal)) : !((xsyme
)->full) && symeSetFieldVal == (symeFieldInfo[SYFI_SrcPos
].def) ? symeSetFieldVal : symeSetFieldFn(xsyme,SYFI_SrcPos,symeSetFieldVal
));
	}

/* If the default is inherited, use the default syme. */
if (xsyme == NULL((void*)0)) {
	xsymes = listCons(Syme)(Syme_listPointer->Cons)(dsyme, xsymes);
	symeSetDefault(dsyme)(((((dsyme)->kind == SYME_Trigger ? libGetAllSymes((dsyme)
->lib) : ((void*)0)), (dsyme))->bits) |= (0x0080));
}
}

xsymes = listNReverse(Syme)(Syme_listPointer->NReverse)(xsymes);
return symeListUnion(isymes, xsymes, symeEqual);
4529}

4531/******************************************************************************
*
* :: Type form constant definitions.
*
*****************************************************************************/

4537SymeList
4538tfGetDomConstants(TForm tf)
4539{
tf = tfDefineeType(tf);

return tfGetCatConstants(tfGetCategory(tf));
4543}

4545SymeList
4546tfGetCatConstants(TForm cat)
4547{
SymeList	symes;

tfFollow(cat)((cat) = tfFollowFn(cat));
if (tfIsDefine(cat)(((cat)->tag) == TF_Define)) {
if (tfIsDefineOfType(cat))
	return tfGetDomConstants(tfDefineVal(cat)tfFollowArg(cat, 1));
cat = tfDefineVal(cat)tfFollowArg(cat, 1);
tfFollow(cat)((cat) = tfFollowFn(cat));
return tfSymes(cat)((cat)->symes);
}

cat = tfDefineeType(cat);

if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0))
symes = listNil(Syme)((SymeList) 0);

else if (tfIsWith(cat)(((cat)->tag) == TF_With)) {
TForm		tfb = tfWithBase(cat)tfFollowArg(cat, 0);
TForm		tfw = tfWithWithin(cat)tfFollowArg(cat, 1);
SymeList	bsymes, wsymes;

bsymes = tfGetCatConstants(tfb);

/*!! tfCatExports will find the constant numbers from any
 *!! defaults in the with, but not from any categories.
 *!! We could save the constant symes in the tform.
 */
tfFollow(tfw)((tfw) = tfFollowFn(tfw));
if (tfCatExports(tfw))
	wsymes = tfCatExports(tfw);

else if (tfIsDeclare(tfw)(((tfw)->tag) == TF_Declare))
	wsymes = tfSymes(tfw)((tfw)->symes);

else if (tfHasExpr(tfw)((tfw)->__absyn != 0))
	wsymes = tfGetCatConstantsFrWith(tfGetExpr(tfw)((tfw)->__absyn));

else
	wsymes = tfGetCatConstants(tfw);

symes = symeListUnion(bsymes, wsymes, symeEq);
}

else if (tfIsIf(cat)(((cat)->tag) == TF_If))
symes = listNConcat(Syme)(Syme_listPointer->NConcat)(tfGetCatConstants(tfIfThen(cat)tfFollowArg(cat, 1)),
			  tfGetCatConstants(tfIfElse(cat)tfFollowArg(cat, 2)));

else if (tfIsJoin(cat)(((cat)->tag) == TF_Join) || tfIsMeet(cat)(((cat)->tag) == TF_Meet)) {
Length		i, argc = tfArgc(cat)((cat)->argc);
SymeList	nsymes;

symes = listNil(Syme)((SymeList) 0);
for (i = 0; i < argc; i += 1) {
	nsymes = tfGetCatConstants(tfFollowArg(cat, i));
	symes = symeListUnion(symes, nsymes, symeEq);
}
}

else
symes = tfGetThdConstants(tfGetCategory(cat));

return symes;
4610}

4612localstatic SymeList
4613tfGetThdConstants(TForm thd)
4614{
SymeList	symes = listNil(Syme)((SymeList) 0);

thd = tfDefineeType(thd);

if (tfIsThird(thd)(((thd)->tag) == TF_Third))
symes = tfGetCatConstants(tfThirdRestrictions(thd)tfFollowArg(thd, 0));

return symes;
4623}

4625/*
* tfGetCatConstants helper functions.
*/

4629localstatic SymeList
4630tfGetCatConstantsFrWith(Sefo sefo)
4631{
SymeList	csymes, symes = listNil(Syme)((SymeList) 0);
Length		i, argc;
Sefo		*argv;

AB_SEQ_ITER(sefo, argc, argv){ switch (((sefo)->abHdr.tag)) { case AB_Nothing: argc = 0
; argv = 0; break; case AB_Sequence: argc = ((sefo)->abHdr
.argc); argv = ((sefo)->abGen.data.argv); break; default: argc
 = 1; argv = &sefo; break; }; };

for (i = 0; i < argc; i++) {
Sefo	id = abDefineeIdOrElse(argv[i], NULL((void*)0));

if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Nothing)
	continue;

/* Defaults package. */
else if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default)
	continue;

/* Explicit declaration. */
else if (id && abTag(argv[i])((argv[i])->abHdr.tag) != AB_Id)
	continue;

/* Category expression. */
else if (abState(argv[i])((argv[i])->abHdr.state) == AB_State_HasUnique &&
	 tfSatCat(abTUnique(argv[i])((argv[i])->abHdr.type.unique))) {
	csymes = tfGetThdConstants(abTUnique(argv[i])((argv[i])->abHdr.type.unique));
	symes = listNConcat(Syme)(Syme_listPointer->NConcat)(csymes, symes);
}
}

return symes;
4661}

4663/******************************************************************************
*
* :: Type form cascaded imports.
*
*****************************************************************************/

4669/*
* Called on a domain to get the cascaded imports which are supplied
* by the domain.
*/
4673TQualList
4674tfGetDomCascades(TForm tf)
4675{
TForm		cat;
TQualList	ql;

tf = tfDefineeType(tf);

if (tfHasCascades(tf)((tf)->hasCascades))
return tfCascades(tf)((tf)->cascades);

if (tfIsUnknown(tf)(((tf)->tag) == TF_Unknown) || tfIsNone(tf)((((tf)->tag) == TF_Multiple) && tfMultiArgc(tf) ==
 0))
return listNil(TQual)((TQualList) 0);

if (!tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning)) {
tfGetExportError(tf, "domain");
return listNil(TQual)((TQualList) 0);
}

cat = tfGetCategory(tf);
if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown))
return listNil(TQual)((TQualList) 0);
if (!tfHasCatExports(cat))
return listNil(TQual)((TQualList) 0);

if (DEBUG(tfCascade)tfCascadeDebug) {
fprintf(dbOut, "tfGetDomCascades:  from ");
tfPrint(dbOut, tf);
findent += 2;
fnewline(dbOut);
}

/*
* Collect the domain cascades from the type form.
*/
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
)))
ql = listNil(TQual)((TQualList) 0);

else if (tfIsRecord(tf)(((tf)->tag) == TF_Record) || tfIsRawRecord(tf)(((tf)->tag) == TF_RawRecord) || tfIsUnion(tf)(((tf)->tag) == TF_Union))
ql = tqListFrArgs(tfGetStab(tf), tfArgv(tf)((tf)->argv), tfArgc(tf)((tf)->argc));
else if (tfIsTrailingArray(tf)(((tf)->tag) == TF_TrailingArray))
ql = tfGetCascadesFrTrailingArray(tf);
else if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT) || tfIsSyntax(tf)(((tf)->tag) == TF_Syntax) || tfIsAdd(tf)(((tf)->tag) == TF_Add))
ql = listNil(TQual)((TQualList) 0);

/*!! Perhaps this can be expanded later. */
else if (tfIsLibrary(tf) || tfIsArchive(tf))
ql = listNil(TQual)((TQualList) 0);
else
ql = listCopy(TQual)(TQual_listPointer->Copy)(tfGetCatCascades(tfGetCategory(tf)));

if (DEBUG(tfCascade)tfCascadeDebug) {
fprintf(dbOut, "domain cascades:");
fnewline(dbOut);
listPrint(TQual)(TQual_listPointer->Print)(dbOut, ql, tqPrint);
findent -= 2;
fnewline(dbOut);
}

tfHasCascades(tf)((tf)->hasCascades) = true1;
tfSetCascades(tf, ql)(((tf)->cascades) = (ql));
return ql;
4735}

4737/*
* Called on a category to get the cascaded imports which are supplied
* by the category.
*/
4741TQualList
4742tfGetCatCascades(TForm cat)
4743{
TQualList	ql;

tfFollow(cat)((cat) = tfFollowFn(cat));

if (tfIsDefine(cat)(((cat)->tag) == TF_Define)) {
TQualList	ql2;

if (tfHasCascades(cat)((cat)->hasCascades) || !tfIsMeaning(cat)(((cat)->state)>=TF_State_Meaning))
	return tfCascades(cat)((cat)->cascades);

ql = listCopy(TQual)(TQual_listPointer->Copy)
	(tfGetDomCascades(tfDefineVal(cat)tfFollowArg(cat, 1)));

ql2 = listCopy(TQual)(TQual_listPointer->Copy)
	(tfGetCatCascades(tfDefineeType(cat)));
ql = listNConcat(TQual)(TQual_listPointer->NConcat)(ql, ql2);

tfHasCascades(cat)((cat)->hasCascades) = true1;
tfSetCascades(cat, ql)(((cat)->cascades) = (ql));
return ql;
}

cat = tfDefineeType(cat);

if (tfHasCascades(cat)((cat)->hasCascades))
return tfCascades(cat)((cat)->cascades);

if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown) || tfIsNone(cat)((((cat)->tag) == TF_Multiple) && tfMultiArgc(cat)
 == 0))
return listNil(TQual)((TQualList) 0);

if (!tfIsMeaning(cat)(((cat)->state)>=TF_State_Meaning)) {
tfGetExportError(cat, "category");
return listNil(TQual)((TQualList) 0);
}

if (DEBUG(tfCat)tfCatDebug) {
fprintf(dbOut, "(tfGetCatCascades:  from ");
tfPrint(dbOut, cat);
fnewline(dbOut);
}

if (tfIsWith(cat)(((cat)->tag) == TF_With))
ql = tfGetCatCascadesFrWith(cat);

else if (tfIsIf(cat)(((cat)->tag) == TF_If)) {
TQualList	ql1, ql2;

ql1 = listCopy(TQual)(TQual_listPointer->Copy)(tfGetCatCascades(tfIfThen(cat)tfFollowArg(cat, 1)));
ql2 = listCopy(TQual)(TQual_listPointer->Copy)(tfGetCatCascades(tfIfElse(cat)tfFollowArg(cat, 2)));
ql = listNConcat(TQual)(TQual_listPointer->NConcat)(ql1, ql2);
}

else if (tfIsJoin(cat)(((cat)->tag) == TF_Join) || tfIsMeet(cat)(((cat)->tag) == TF_Meet)) {
Length		i, argc = tfArgc(cat)((cat)->argc);
TQualList	nql;

ql = listNil(TQual)((TQualList) 0);
for (i = 0; i < argc; i += 1) {
	nql = tfGetCatCascades(tfFollowArg(cat, i));
	ql = listNConcat(TQual)(TQual_listPointer->NConcat)(ql, listCopy(TQual)(TQual_listPointer->Copy)(nql));
}
}

else
ql = listCopy(TQual)(TQual_listPointer->Copy)(tfGetThdCascades(tfGetCategory(cat)));

tfCatDEBUGif (!tfCatDebug) { } else afprintf(dbOut, ")\n");

tfHasCascades(cat)((cat)->hasCascades) = true1;
tfSetCascades(cat, ql)(((cat)->cascades) = (ql));
return ql;
4815}

4817/*
* Called on a third-order type to get the cascaded imports which are supplied
* by the third-order type.
*/
4821TQualList
4822tfGetThdCascades(TForm thd)
4823{
TQualList	ql;

thd = tfDefineeType(thd);

if (tfHasCascades(thd)((thd)->hasCascades))
return tfCascades(thd)((thd)->cascades);

if (tfIsUnknown(thd)(((thd)->tag) == TF_Unknown) || tfIsNone(thd)((((thd)->tag) == TF_Multiple) && tfMultiArgc(thd)
 == 0))
return listNil(TQual)((TQualList) 0);

if (DEBUG(tfCat)tfCatDebug) {
fprintf(dbOut, "(tfGetThdCascades:  from ");
tfPrint(dbOut, thd);
fnewline(dbOut);
}

if (tfIsThird(thd)(((thd)->tag) == TF_Third)) {
ql = tfGetCatCascades(tfThirdRestrictions(thd)tfFollowArg(thd, 0));
ql = listCopy(TQual)(TQual_listPointer->Copy)(ql);
}

else
ql = listNil(TQual)((TQualList) 0);

tfCatDEBUGif (!tfCatDebug) { } else afprintf(dbOut, ")\n");

tfHasCascades(thd)((thd)->hasCascades) = true1;
tfSetCascades(thd, ql)(((thd)->cascades) = (ql));
return ql;
4853}

4855/*
* tfGet...Cascades helper functions.
*/

4859localstatic TQualList
4860tfGetCascadesFrStab(Stab stab)
4861{
TFormUsesList	tful;
TQualList	ql = listNil(TQual)((TQualList) 0);

for (tful = car(stab)((stab)->first)->tformsUsed.list; tful; tful = cdr(tful)((tful)->rest)) {
TFormUses	tfu = car(tful)((tful)->first);
if (tfu->exports) ql = listCons(TQual)(TQual_listPointer->Cons)(tfu->exports, ql);
}

return ql;
4871}

4873localstatic TQualList
4874tfGetCatCascadesFrWith(TForm cat)
4875{
TForm		tfb = tfWithBase(cat)tfFollowArg(cat, 0);
TForm		tfw = tfWithWithin(cat)tfFollowArg(cat, 1);
TQualList	bql, wql, ql;

bql = tfGetCatCascades(tfb);

if (tfCascades(tfw)((tfw)->cascades))
wql = tfCascades(tfw)((tfw)->cascades);

else if (tfGetStab(cat))
wql = tfGetCascadesFrStab(tfGetStab(cat));

else
wql = tfGetCatCascades(tfw);

ql = listNConcat(TQual)(TQual_listPointer->NConcat)(listCopy(TQual)(TQual_listPointer->Copy)(bql), listCopy(TQual)(TQual_listPointer->Copy)(wql));

return ql;
4894}


4897localstatic TQualList
4898tfGetCascadesFrTrailingArray(TForm tf)
4899{
TQualList ql = listNil(TQual)((TQualList) 0);
TForm atf, itf, *tfv;
Stab stab;
Length tfc;

if (tfArgc(tf)((tf)->argc) != 2) return listNil(TQual)((TQualList) 0);
stab = tfGetStab(tf);

itf = tfTrailingIArg(tf)tfFollowArg(tf,((int) 0));
atf = tfTrailingAArg(tf)tfFollowArg(tf,1);

tfv = tfIsMulti(itf)(((itf)->tag) == TF_Multiple) ? tfMultiArgv(itf)((itf)->argv): &itf;
tfc = tfIsMulti(itf)(((itf)->tag) == TF_Multiple) ? tfMultiArgc(itf): 1;
ql = listNConcat(TQual)(TQual_listPointer->NConcat)(ql, tqListFrArgs(stab, tfv, tfc));

tfv = tfIsMulti(atf)(((atf)->tag) == TF_Multiple) ? tfMultiArgv(atf)((atf)->argv): &atf;
tfc = tfIsMulti(atf)(((atf)->tag) == TF_Multiple) ? tfMultiArgc(atf): 1;
ql = listNConcat(TQual)(TQual_listPointer->NConcat)(ql, tqListFrArgs(stab, tfv, tfc));

return ql;
4920}


4923/******************************************************************************
*
* :: Type form representational symes.
*
*****************************************************************************/

4929localstatic SymeList tfSymesFrDepGroup(Stab, TForm, TForm, SymeList);

4931Bool
4932tfTagHasSymes(TFormTag tag)
4933{
switch (tag) {
case TF_Declare:
case TF_Cross:
case TF_Map:
case TF_PackedMap:
case TF_Multiple:
case TF_Enumerate:
case TF_RawRecord:
case TF_Record:
case TF_TrailingArray:
case TF_Union:
case TF_Add:
case TF_Third:
return true1;
default:
return false((int) 0);
}
4951}

4953Bool
4954tfSymeInducesDependency(Syme syme, TForm tf)
4955{
Stab	stab = tfGetStab(tf);
Bool	result = false((int) 0);

if (stab && symeDefLevel(syme) == car(stab)((stab)->first))
result = !symeUnused(syme)(((UShort) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->locmask) & (1
 << (SYFI_UsedDepth))) ? ((syme)->fieldv)[symeIndex(
syme,SYFI_UsedDepth)] : (symeFieldInfo[SYFI_UsedDepth].def)))
 == (0x7FFF)) || tfIsCategoryMap(tf);

tfMapDEBUGif (!tfMapDebug) { } else afprintf(dbOut, "tformSymeInducesDependency: %s %pSyme %pTForm\n", boolToString(result)((result) ? "true" : "false"),
   syme, tf);
tfMapDEBUGif (!tfMapDebug) { } else afprintf(dbOut, "tformSymeInducesDependency: %pSyme Lvl %s unused: %s catMap %s\n", 
   syme,
   boolToString(stab && symeDefLevel(syme) == car(stab))((stab && symeDefLevel(syme) == ((stab)->first)) ?
 "true" : "false"),
   boolToString(symeUnused(syme))(((((UShort) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->locmask) & (1
 << (SYFI_UsedDepth))) ? ((syme)->fieldv)[symeIndex(
syme,SYFI_UsedDepth)] : (symeFieldInfo[SYFI_UsedDepth].def)))
 == (0x7FFF))) ? "true" : "false"),
   boolToString(tfIsCategoryMap(tf))((tfIsCategoryMap(tf)) ? "true" : "false"));

return result;
4971}

4973/*
* Functions to extract representational symes
* from fully-analysed abstract syntax.
*/

4978localstatic Syme
4979tfNewRepSyme(Stab stab, Symbol sym, TForm tf, Hash code)
4980{
Syme	syme = symeNewExport(sym, tf, car(stab)((stab)->first));
symeSetSpecial(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) |= (0x0002));
symeAddHash(syme, code);
return syme;
4985}

4987localstatic SymeList
4988tfSymesFrDeclare(Sefo sefo)
4989{
SymeList	symes = listNil(Syme)((SymeList) 0);
Sefo		id    = abDefineeIdOrElse(sefo, NULL((void*)0));
Syme		syme  = id ? abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0) : NULL((void*)0);

if (syme) symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
return symes;
4996}

4998localstatic SymeList
4999tfSymesFrCross(TForm tf)
5000{
SymeList	symes = listNil(Syme)((SymeList) 0);
Length		i, argc = tfArgc(tf)((tf)->argc);

if (DEBUG(tfCross)tfCrossDebug) {
fprintf(dbOut, "tfSymesFrCross:");
fnewline(dbOut);
fprintf(dbOut, "  tf:");
tfPrint(dbOut, tf);
fnewline(dbOut);
}

for (i = 0; i < argc; i += 1) {
TForm	tfi = tfCrossArgN(tf, i)tfFollowArg(tf, i);
Syme	syme = tfDefineeSyme(tfi);

if (syme != 0 && tfSymeInducesDependency(syme, tf))
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

if (DEBUG(tfCross)tfCrossDebug) {
fprintf(dbOut, "  symes:");
fnewline(dbOut);
listPrint(Syme)(Syme_listPointer->Print)(dbOut, symes, symePrint);
fnewline(dbOut);
}

return symes;
5029}

5031localstatic SymeList
5032tfSymesFrMulti(TForm tf)
5033{
SymeList	symes = listNil(Syme)((SymeList) 0);
Length		i, argc = tfArgc(tf)((tf)->argc);

if (DEBUG(tfMulti)tfMultiDebug) {
fprintf(dbOut, "tfSymesFrMulti:");
fnewline(dbOut);
fprintf(dbOut, "  tf:");
tfPrint(dbOut, tf);
fnewline(dbOut);
}

for (i = 0; i < argc; i += 1) {
TForm	tfi = tfMultiArgN(tf, i)tfFollowArg(tf, i);
Syme	syme = tfDefineeSyme(tfi);

if (syme != 0 && tfSymeInducesDependency(syme, tf))
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

if (DEBUG(tfMulti)tfMultiDebug) {
fprintf(dbOut, "  symes:");
fnewline(dbOut);
listPrint(Syme)(Syme_listPointer->Print)(dbOut, symes, symePrint);
fnewline(dbOut);
}

return symes;
5062}

5064localstatic SymeList
5065tfSymesFrMap(TForm tf)
5066{
SymeList	symes = listNil(Syme)((SymeList) 0);
Length		i, argc = tfMapArgc(tf);

if (DEBUG(tfMap)tfMapDebug) {
fprintf(dbOut, "tfSymesFrMap:");
fnewline(dbOut);
fprintf(dbOut, "  tf:");
tfPrint(dbOut, tf);
fnewline(dbOut);
}

for (i = 0; i < argc; i += 1) {
TForm	tfi = tfMapArgN(tf, i);
Syme	syme = tfDefineeSyme(tfi);

if (syme != 0 && tfSymeInducesDependency(syme, tf))
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

if (DEBUG(tfMap)tfMapDebug) {
fprintf(dbOut, "  symes:");
fnewline(dbOut);
listPrint(Syme)(Syme_listPointer->Print)(dbOut, symes, symePrint);
fnewline(dbOut);
}

return symes;
5095}

5097localstatic SymeList
5098tfSymesFrEnum(Stab stab, TForm tf, Sefo sefo)
5099{
Syme		syme;
SymeList	symes = listNil(Syme)((SymeList) 0);
Length		i, argc = abApplyArgc(sefo)(((sefo)->abHdr.argc)-1);
TForm		me = tfFrSelf(stab, tf);
TForm		tfm;
Hash		code = abHash(sefo);

/*
*  = : (me, me) -> Boolean
* ~= : (me, me) -> Boolean
*/

/*
* An unfixed compiler bug means that parts of Salli programs
* (and thus libAldor) are tinfered with (tfBoolean == tfUnknown).
* The correct fix is to ensure that tfBoolean has been imported
* into every scope that needs it before we get this far.
*/
tfm = tfMulti(2, me, me);
if (tfBoolean == tfUnknown) comsgFatal(sefo, ALDOR_F_BugNoBoolean367);
tfm = tfMap(tfm, tfBoolean);

syme = tfNewRepSyme(stab, ssymEquals, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

syme = tfNewRepSyme(stab, ssymNotEquals, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

for (i = 0; i < argc; i += 1) {
Sefo	argi = abDefineeIdOrElse(abApplyArg(sefo, i)((sefo)->abApply.argv[i]), NULL((void*)0));

if (! argi) continue;
assert(abTag(argi) == AB_Id)do { if (!(((argi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(argi) == AB_Id"
),"tform.c",5132); } while (0);

/*
 * ni : E
 */
syme = tfNewRepSyme(stab, argi->abId.sym, me, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

stabSetSubstable(stab)(((stab)->first)->isSubstable=1);
return symes;
5144}

5146localstatic void
5147tfCheckDenseArgs(TForm tf, Sefo sefo)
5148{
Length	i;
Length	argc = abApplyArgc(sefo)(((sefo)->abHdr.argc)-1);

for (i = 0;i < argc; i++)
{
TForm	tfarg = tfArgv(tf)((tf)->argv)[i];
Sefo	argi = abDefineeIdOrElse(abApplyArg(sefo, i)((sefo)->abApply.argv[i]), NULL((void*)0));

if (!tfDomHasImplicit(tfarg))
{
	String cat = symString(ssymImplPAOps)((ssymImplPAOps)->str);
	comsgError(argi, ALDOR_E_TinPackedNotSat189, cat);
}
}
5163}

5165localstatic SymeList
5166tfSymesFrRawRecord(Stab stab, TForm tf, Sefo sefo)
5167{
SymeList	symes = listNil(Syme)((SymeList) 0);
Syme		syme;
Length		i, argc = abApplyArgc(sefo)(((sefo)->abHdr.argc)-1);
TForm		tfc, tfm, me = tfFrSelf(stab, tf);
Hash		code = abHash(sefo);

/*
* First ensure that all types have DenseStorageCategory.
* We ought to do this in libraries with the definition
* of RawRecord() but we also do it here for safety. The
* sting in the tail is that we never want to check the
* initial definition `RawRecord(T:Tuple Type): ...'.
*/
if ((argc != 1) || !tfIsTypeTuple(tfCatFrDom(tfArgv(tf)((tf)->argv)[0])))
tfCheckDenseArgs(tf, sefo);

/*
*   [ ... ]:   (T1, T2, ... TN) -> %
*   rawrecord: (T1, T2, ... TN) -> %
*   explode:   % -> (T1, T2, ... TN)
*   dispose!:  % -> ()
*   apply:     (%, Enumerate(ti:Type)) -> Ti
*   set!:      (%, Enumerate(ti:Type), Ti) -> Ti
*/


/* Create the argument type for RawRecord: (t1:T1, ..., tN:TN) */
tfc = tfNewEmpty(TF_Multiple, argc);
for (i = 0; i < argc; i += 1) tfc->argv[i] = tf->argv[i];
tfSetStab(tfc, abStab(sefo))((tfc)->stab = (((sefo)->abHdr.seman ? (sefo)->abHdr
.seman->stab : 0)));
tfSetSymes(tfc, tfSymesFrMulti(tfc))((tfc)->symes = (tfSymesFrMulti(tfc)));
tfSetStab(tfc, NULL)((tfc)->stab = (((void*)0)));


/* Now create the type: (t1:T1, ..., tN:TN) -> % */
tfm  = tfMap(tfc, me);
tfSetStab(tfm, abStab(sefo))((tfm)->stab = (((sefo)->abHdr.seman ? (sefo)->abHdr
.seman->stab : 0)));
tfSetSymes(tfm, tfSymesFrMap(tfm))((tfm)->symes = (tfSymesFrMap(tfm)));
tfSetStab(tfm, NULL)((tfm)->stab = (((void*)0)));

tfSetSymes(tf, tfSymes(tfm))((tf)->symes = (((tfm)->symes)));


/* [ ... ] */
syme = tfNewRepSyme(stab, ssymBracket, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);


/* rawrecord( ... ) */
syme = tfNewRepSyme(stab, ssymTheRawRecord, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);


      /* Reverse map: % -> (T1, T2, ..., TN) */
tfm  = tfMap(me, tfc);


/* explode: % -> (T1, T2, ..., TN) */
syme = tfNewRepSyme(stab, ssymTheExplode, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);


/* Void map: % -> () */
tfc = tfMulti(int0((int) 0));
tfm = tfMap(me, tfc);


/* dispose!: % -> () */
syme = tfNewRepSyme(stab, ssymTheDispose, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);


/* Create the `apply' and `set!' exports */
for (i = 0; i < argc; i += 1) {
TForm	tfi  = tf->argv[i];
TForm	tfit = tfDefineeType(tfi);
Syme	si   = tfDefineeSyme(tfi);
Sefo	argi = abDefineeIdOrElse(abApplyArg(sefo, i)((sefo)->abApply.argv[i]), NULL((void*)0));
TForm	tfe;

if (!si || !argi) continue;
assert(abTag(argi) == AB_Id)do { if (!(((argi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(argi) == AB_Id"
),"tform.c",5249); } while (0);

/* apply: (%, Enumerate(ti: Type)) -> Ti */
tfe   = tfEnum(stab, argi);
tfm   = tfMap(tfMulti(2, me, tfe), tfi);
syme  = tfNewRepSyme(stab, ssymApply, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

/* set!: (%, Enumerate(ti: Type), Ti) -> Ti */
if (!listMemq(Syme)(Syme_listPointer->Memq)(tfSymes(tf)((tf)->symes), si)) {
	tfm  = tfMap(tfMulti(3, me, tfe, tfi), tfi);
	syme = tfNewRepSyme(stab, ssymSetBang, tfm, code);
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
}

symes = tfSymesFrDepGroup(stab, me, tfc, symes);
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

stabSetSubstable(stab)(((stab)->first)->isSubstable=1);
return symes;
5270}

5272localstatic SymeList
5273tfSymesFrRecord(Stab stab, TForm tf, Sefo sefo)
5274{
SymeList	symes = listNil(Syme)((SymeList) 0);
Syme		syme;
Length		i, argc = abApplyArgc(sefo)(((sefo)->abHdr.argc)-1);
TForm		tfc, tfm, me = tfFrSelf(stab, tf);
Hash		code = abHash(sefo);

/*
* [ ]:	     (A1, ..., AN) -> me
* record:   (A1, ..., AN) -> me
* explode:  me -> (A1, ..., AN)
* dispose!: me -> ()
*/

tfc = tfNewEmpty(TF_Multiple, argc);
for (i = 0; i < argc; i += 1) tfc->argv[i] = tf->argv[i];
tfSetStab(tfc, abStab(sefo))((tfc)->stab = (((sefo)->abHdr.seman ? (sefo)->abHdr
.seman->stab : 0)));
tfSetSymes(tfc, tfSymesFrMulti(tfc))((tfc)->symes = (tfSymesFrMulti(tfc)));
tfSetStab(tfc, NULL)((tfc)->stab = (((void*)0)));

tfm  = tfMap(tfc, me);
tfSetStab(tfm, abStab(sefo))((tfm)->stab = (((sefo)->abHdr.seman ? (sefo)->abHdr
.seman->stab : 0)));
tfSetSymes(tfm, tfSymesFrMap(tfm))((tfm)->symes = (tfSymesFrMap(tfm)));
tfSetStab(tfm, NULL)((tfm)->stab = (((void*)0)));

tfSetSymes(tf, tfSymes(tfm))((tf)->symes = (((tfm)->symes)));

syme = tfNewRepSyme(stab, ssymBracket, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

syme = tfNewRepSyme(stab, ssymTheRecord, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

tfm  = tfMap(me, tfc);

syme = tfNewRepSyme(stab, ssymTheExplode, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

tfc = tfMulti(int0((int) 0));
tfm = tfMap(me, tfc);

syme = tfNewRepSyme(stab, ssymTheDispose, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

for (i = 0; i < argc; i += 1) {
TForm	tfi  = tf->argv[i];
TForm	tfit = tfDefineeType(tfi);
Syme	si   = tfDefineeSyme(tfi);
Sefo	argi = abDefineeIdOrElse(abApplyArg(sefo, i)((sefo)->abApply.argv[i]), NULL((void*)0));
TForm	tfe;

if (!si || !argi) continue;
assert(abTag(argi) == AB_Id)do { if (!(((argi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(argi) == AB_Id"
),"tform.c",5326); } while (0);

/*
 * apply: (me, Enumerate(ni: Type)) -> Ai
 * set!:  (me, Enumerate(ni: Type), Ai) -> Ai
 */

tfe = tfEnum(stab, argi);

tfm  = tfMap(tfMulti(2, me, tfe), tfi);
syme = tfNewRepSyme(stab, ssymApply, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

if (!listMemq(Syme)(Syme_listPointer->Memq)(tfSymes(tf)((tf)->symes), si)) {
	tfm  = tfMap(tfMulti(3, me, tfe, tfi), tfi);
	syme = tfNewRepSyme(stab, ssymSetBang, tfm, code);
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
}

symes = tfSymesFrDepGroup(stab, me, tfc, symes);
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

stabSetSubstable(stab)(((stab)->first)->isSubstable=1);
return symes;
5351}

5353localstatic SymeList
5354tfSymesFrDepGroup(Stab stab, TForm me, TForm tfc, SymeList symes)
5355{
return symes;
5357}

5359localstatic SymeList
5360tfSymesFrTrailingArray(Stab stab, TForm tf, Sefo sefo)
5361{
SymeList	symes = listNil(Syme)((SymeList) 0);
Syme		syme;
Length		i, iargc, aargc;
TForm 		me = tfFrSelf(stab, tf);
TForm		atf, itf, tfc, tfm;
Sefo		isefo, asefo;
Hash		code = abHash(sefo);

/* We might have an invalid TForm here... */
if (tfArgc(tf)((tf)->argc) != 2) return listNil(Syme)((SymeList) 0);

/*
* TrailingArray((i1: I1, i2: I2..., IN), (A1,A2,...AN))
* [ ]:	     	    (I1, ..., IN) -> Tuple Cross A -> me
* trailingArray:   (A1, ..., AN) -> Tuple Cross A -> me
* dispose!: me -> ()
*/

itf = tfTrailingIArg(tf)tfFollowArg(tf,((int) 0));
atf = tfTrailingAArg(tf)tfFollowArg(tf,1);
aargc = tfAsMultiArgc(atf);
iargc = tfAsMultiArgc(itf);

isefo = abApplyArg(sefo, int0)((sefo)->abApply.argv[((int) 0)]);
asefo = abApplyArg(sefo, 1)((sefo)->abApply.argv[1]);

if (!tfIsMulti(itf)(((itf)->tag) == TF_Multiple)) itf = tfMulti(1, itf);
if (!tfIsMulti(atf)(((atf)->tag) == TF_Multiple)) atf = tfMulti(1, atf);
tfc = tfNewEmpty(TF_Multiple, 3);
tfc->argv[0] = tfMachineInteger;
tfc->argv[1] = tfCrossFrMulti(itf);
tfc->argv[2] = tfCrossFrMulti(atf);
tfSetStab(tfc, abStab(sefo))((tfc)->stab = (((sefo)->abHdr.seman ? (sefo)->abHdr
.seman->stab : 0)));
tfSetSymes(tfc, tfSymesFrMulti(tfc))((tfc)->symes = (tfSymesFrMulti(tfc)));
tfSetStab(tfc, NULL)((tfc)->stab = (((void*)0)));

tfm  = tfMap(tfc, me);
tfSetStab(tfm, abStab(sefo))((tfm)->stab = (((sefo)->abHdr.seman ? (sefo)->abHdr
.seman->stab : 0)));
tfSetSymes(tfm, tfSymesFrMap(tfm))((tfm)->symes = (tfSymesFrMap(tfm)));
tfSetStab(tfm, NULL)((tfm)->stab = (((void*)0)));

syme = tfNewRepSyme(stab, ssymTheTrailingArray, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

syme = tfNewRepSyme(stab, ssymBracket, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

tfc = tfMulti(int0((int) 0));
tfm = tfMap(me, tfc);

syme = tfNewRepSyme(stab, ssymTheDispose, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

for (i = 0; i < iargc; i += 1) {
TForm	tfi  = tfAsMultiArgN(itf, iargc, i);
Syme	si   = tfDefineeSyme(tfi);
Sefo	argi = abDefineeIdOrElse(abArgvAs(AB_Comma, isefo)(((isefo)->abHdr.tag == (AB_Comma)) ? ((isefo)->abGen.data
.argv) : &(isefo))[i], NULL((void*)0));
TForm	tfe;

if (!si || !argi) continue;
assert(abTag(argi) == AB_Id)do { if (!(((argi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(argi) == AB_Id"
),"tform.c",5422); } while (0);

/*
 * apply: (me, 'ni') -> Ii
 * set!:  (me, 'ni', Ii) -> Ii
 */

tfe = tfEnum(stab, argi);

tfm  = tfMap(tfMulti(2, me, tfe), tfi);
syme = tfNewRepSyme(stab, ssymApply, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

if (!listMemq(Syme)(Syme_listPointer->Memq)(tfSymes(tf)((tf)->symes), si)) {
	tfm  = tfMap(tfMulti(3, me, tfe, tfi), tfi);
	syme = tfNewRepSyme(stab, ssymSetBang, tfm, code);
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}

}

for (i = 0; i < aargc; i++) {
TForm	tfi  = tfAsMultiArgN(atf, aargc, i);
Syme	si   = tfDefineeSyme(tfi);
Sefo	argi = abDefineeIdOrElse(abArgvAs(AB_Comma, asefo)(((asefo)->abHdr.tag == (AB_Comma)) ? ((asefo)->abGen.data
.argv) : &(asefo))[i], NULL((void*)0));
TForm	tfe;

if (!si || !argi) continue;
assert(abTag(argi) == AB_Id)do { if (!(((argi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(argi) == AB_Id"
),"tform.c",5450); } while (0);
/*
 * apply: (me, MachineInteger, 'ni') -> Ai
 * set!:  (me, MachineInteger, 'ni', Ii) -> Ai
 */
tfe = tfEnum(stab, argi);

tfm  = tfMap(tfMulti(3, me, tfMachineInteger, tfe), tfi);
syme = tfNewRepSyme(stab, ssymApply, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

if (!listMemq(Syme)(Syme_listPointer->Memq)(tfSymes(tf)((tf)->symes), si)) {
	tfm  = tfMap(tfMulti(4, me, tfMachineInteger, tfe, tfi), tfi);
	syme = tfNewRepSyme(stab, ssymSetBang, tfm, code);
	symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}
}

symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

stabSetSubstable(stab)(((stab)->first)->isSubstable=1);
5471#if 0
tfPrintDb(tf);
abPrintDb(sefo);
symeListPrintDb(symes);
5475#endif	
return symes;
5477}

5479localstatic SymeList
5480tfSymesFrUnion(Stab stab, TForm tf, Sefo sefo)
5481{
Syme		syme;
SymeList	symes = listNil(Syme)((SymeList) 0);
Length		i, argc = abApplyArgc(sefo)(((sefo)->abHdr.argc)-1);
TForm		me = tfFrSelf(stab, tf), tfm, tfc;
Hash		code = abHash(sefo);

/*
* dispose!: me -> ()
*/
tfc = tfMulti(int0((int) 0));
tfm = tfMap(me, tfc);

syme = tfNewRepSyme(stab, ssymTheDispose, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

for (i = 0; i < argc; i += 1) {
TForm	tfi = tf->argv[i];
TForm	tfit = tfDefineeType(tfi);
Sefo	argi = abDefineeIdOrElse(abApplyArg(sefo, i)((sefo)->abApply.argv[i]), NULL((void*)0));
TForm	tfe;
TForm   tfc;
Syme    prmi, vali;
String  pname;
if (! argi) continue;
assert(abTag(argi) == AB_Id)do { if (!(((argi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(argi) == AB_Id"
),"tform.c",5506); } while (0);

/*
 * [ ]:	    Ai -> me
 * union:   Ai -> me
 */
tfe  = tfEnum(stab, argi);
pname = strPrintf("!%s", argi->abId.sym->str);
prmi = symeNewParam(symIntern(pname)symProbe(pname, 1 | 2), tfe, car(stab)((stab)->first));
strFree(pname);
vali = symeNewImport(argi->abId.sym, tfe, car(stab)((stab)->first),
		       tfe);
symeSetSpecial(vali)(((((vali)->kind == SYME_Trigger ? libGetAllSymes((vali)->
lib) : ((void*)0)), (vali))->bits) |= (0x0002));
tfc  = tfDeclare(abFrSyme(prmi), tfe);
tfc  = tfDefine(tfc, abFrSyme(vali));
tfc  = tfMulti(2, tfi, tfc);
tfm  = tfMap(tfc, me);
syme = tfNewRepSyme(stab, ssymBracket, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

syme = tfNewRepSyme(stab, ssymTheUnion, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

/*
 * case:  (me, Enumerate(ni: Type)) -> Boolean
 * apply: (me, Enumerate(ni: Type)) -> Ai
 * set!:  (me, Enumerate(ni: Type), Ai) -> Ai
 */
tfe = tfEnum(stab, argi);
tfc = tfMulti(2, me, tfe);

/*
 * An unfixed compiler bug means that parts of Salli
 * programs (and thus libAldor) are tinfered with
 * (tfBoolean == tfUnknown). The correct fix is to
 * ensure that tfBoolean has been imported into every
 * scope that needs it before we get this far.
 */
if (tfBoolean == tfUnknown)
	comsgFatal(sefo, ALDOR_F_BugNoBoolean367);
tfm = tfMap(tfc, tfBoolean);
syme = tfNewRepSyme(stab, ssymTheCase, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

tfm = tfMap(tfc, tfi);
syme = tfNewRepSyme(stab, ssymApply, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);

tfm  = tfMap(tfMulti(3, me, tfe, tfi), tfi);
syme = tfNewRepSyme(stab, ssymSetBang, tfm, code);
symes = listCons(Syme)(Syme_listPointer->Cons)(syme, symes);
}

symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);

stabSetSubstable(stab)(((stab)->first)->isSubstable=1);
return symes;
5563}

5565localstatic SymeList
5566tfSymesFrAdd(Sefo sefo)
5567{
assert(abStab(sefo))do { if (!(((sefo)->abHdr.seman ? (sefo)->abHdr.seman->
stab : 0))) _do_assert(("abStab(sefo)"),"tform.c",5568); } while
 (0);
return stabGetExportedSymes(abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0
));
5570}

5572Bool
5573tfHasPrint(Stab stab, TForm tf)
5574{
TForm tfm;
TForm me = tfFrSelf(stab, tf);
SymeList mods = tfGetDomSelf(tf);
Syme thePrint;

tfm = tfMap(tfMulti(2, tfTextWriter, me), tfTextWriter);
thePrint = tfHasDomExportMod(tf, mods, ssymPrint, tfm);

return thePrint != NULL((void*)0);
5584}

5586/* tfSymesFrDefault handles conditionals spectacularly badly.
* It isn't clear how to modify tfGetCat{Exports,Parents}FrWith
* to do the right thing, even if we manage to remember what the
* conditions are.  Modifying the meanings in place is probably 
* doomed.
*/

5593localstatic SymeList
5594tfSymesFrDefault(Sefo sefo)
5595{
SymeList	symes = listNil(Syme)((SymeList) 0);
Length		i, argc;
Sefo		*argv;
Sefo		id;

switch (abTag(sefo)((sefo)->abHdr.tag)) {
case AB_Nothing:
argc = 0;
argv = 0;
break;
case AB_Sequence:
argc = abArgc(sefo)((sefo)->abHdr.argc);
argv = abArgv(sefo)((sefo)->abGen.data.argv);
break;
case AB_If:
argc = 2;
argv = &sefo->abIf.thenAlt;
break;
default:
id = abDefineeIdOrElse(sefo, NULL((void*)0));
assert(id == NULL || abSyme(id))do { if (!(id == ((void*)0) || ((id)->abHdr.seman ? (id)->
abHdr.seman->syme : 0))) _do_assert(("id == NULL || abSyme(id)"
),"tform.c",5616); } while (0);
if (id && abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0) && symeIsExport(abSyme(id))(((((((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0
))->kind == SYME_Trigger ? libGetAllSymes((((id)->abHdr
.seman ? (id)->abHdr.seman->syme : 0))->lib) : ((void
*)0)), (((id)->abHdr.seman ? (id)->abHdr.seman->syme
 : 0)))->kind) == SYME_Export))
	symes = listCons(Syme)(Syme_listPointer->Cons)(abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0), symes);
return symes;
}

symes = listNil(Syme)((SymeList) 0);
for (i = 0; i < argc; i += 1) {
symes = listNConcat(Syme)(Syme_listPointer->NConcat)(tfSymesFrDefault(argv[i]), symes);
}

return symes;
5628}


5631/*
* Functions to construct abstract syntax from representational symes.
*/

5635localstatic AbSyn
5636tfSymesToAdd(SymeList symes)
5637{
/*!!*/
return abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
5640}

5642AbSyn
5643tfSymesToWith(SymeList symes)
5644{
AbSyn		ab;
AbSynList	decls;
Length		argc;

decls = listNil(AbSyn)((AbSynList) 0);
for ( ; symes; symes = cdr(symes)((symes)->rest)) {
Syme	syme = car(symes)((symes)->first);
AbSyn	id, type, decl;

id    = abFrSyme(syme);
type  = sefoCopy(tfExpr(symeType(syme))tfToAbSyn(symeType(syme)));

decl  = abNewDeclare(sposNone, id, type)abNew(AB_Declare, sposNone,2, id,type);
decls = listCons(AbSyn)(AbSyn_listPointer->Cons)(decl, decls);
}

argc = listLength(AbSyn)(AbSyn_listPointer->_Length)(decls);
switch (argc) {
case 0:
ab = abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
break;
case 1:
ab = car(decls)((decls)->first);
break;
default:
ab = abNewSequenceL(sposNone, listNReverse(AbSyn)(decls))abNewOfList(AB_Sequence,sposNone,(AbSyn_listPointer->NReverse
)(decls));
break;
}

listFree(AbSyn)(AbSyn_listPointer->Free)(decls);
return ab;
5676}

5678AbSyn
5679tfWithFrAdd(AbSyn ab)
5680{
return tfSymesToWith(listNReverse(Syme)(Syme_listPointer->NReverse)(tfSymesFrAdd(ab)));
5682}


5685/******************************************************************************
*
* :: Specific import/export selection
*
*****************************************************************************/

5691/*
* Select an import from an exporter. Wonder if tformEqualMod works?
*/
5694Syme
5695tfGetDomImport(TForm tf, String name, Bool (*tfCheck)(TForm))
5696{
Syme	result = tfGetDomExport(tf, name, tfCheck);

/* Did we find the export? */
if (result)
{
SymeList	symes;

/* Convert the export into an import */
symes  = listSingleton(Syme)(Syme_listPointer->Singleton)(result);
symes  = symeListSubstSelf(stabFile(), tf, symes);
result = car(symes)((symes)->first);
}


/* Return the export (or nothing) */
return result;
5713}

5715/*
* Select an export from an exporter. Wonder if tformEqualMod works?
*/
5718Syme
5719tfGetDomExport(TForm tf, String name, Bool (*tfCheck)(TForm))
5720{
Syme		op = (Syme)NULL((void*)0);
SymeList	symes = tfGetDomExports(tf);


/* Search for the specified export */
for (;!op && symes; symes = cdr(symes)((symes)->rest))
{
Syme	syme = car(symes)((symes)->first);


/* Does this export have the correct name? */
if (!strEqual(name, symeString(syme)((((syme)->id))->str))) continue;


/* Check the type */
if (!tfCheck(symeType(syme))) continue;


/* Found it (assume type is correct) */
op = syme;
}


/* Return the export (or nothing) */
return op;
5746}


5749/******************************************************************************
*
* :: Special type forms
*
*****************************************************************************/

5755/*
* Type form utility functions
*/

5759/* Find the symbol in a Declare/Define/Assign type form. */
5760Symbol
5761tfDefineeSymbol(TForm tf)
5762{
tfFollow(tf)((tf) = tfFollowFn(tf));

while (tfTag(tf)((tf)->tag) != TF_Declare) {
switch (tfTag(tf)((tf)->tag)) {
case TF_Assign:
	tf = tfAssignDecl(tf)tfFollowArg(tf, 0);
	break;
case TF_Define:
	tf = tfDefineDecl(tf)tfFollowArg(tf, 0);
	break;
case TF_Multiple:
	if (tfMultiArgc(tf) == 1) {
		tf = tfMultiArgN(tf, int0)tfFollowArg(tf, ((int) 0));
		break;
	}
	/* fall through */
default:
	return NULL((void*)0);
}
tf = tfFollowSubst(tf);
}
return tfDeclareId(tf);
5785}

5787/* Find the syme in a Declare/Define/Assign type form. */
5788Syme
5789tfDefineeSyme(TForm tf)
5790{
tf = tfFollowOnly(tf);

while (tfTag(tf)((tf)->tag) != TF_Declare)
switch (tfTag(tf)((tf)->tag)) {
case TF_Syntax: {
	AbSyn	id = abDefineeIdOrElse(tfExpr(tf)tfToAbSyn(tf), NULL((void*)0));
	if (id && abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0))
		return abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0);
	else
		return NULL((void*)0);
	break;
}
case TF_Subst:
	if (tfDefineeSyme(tfSubstArg(tf)tfFollowArg(tf, 0)))
		tfFollow(tf)((tf) = tfFollowFn(tf));
	else
		return NULL((void*)0);
	break;
case TF_Assign:
	tf = tfAssignDecl(tf)tfFollowArg(tf, 0);
	break;
case TF_Define:
	tf = tfDefineDecl(tf)tfFollowArg(tf, 0);
	break;
case TF_Multiple:
	if (tfMultiArgc(tf) == 1)
		tf = tfMultiArgN(tf, int0)tfFollowArg(tf, ((int) 0));
	else
		return NULL((void*)0);
	break;
default:
	return NULL((void*)0);
}

return tfDeclareSyme(tf);
5826}

5828/* Find the type in a Declare/Define/Assign type form. */
5829localstatic TForm
5830tfDefineeType0(TForm tf, Bool subst)
5831{
Bool	done = false((int) 0);

while (!done) {
if (subst)
	tfFollow(tf)((tf) = tfFollowFn(tf));
else
	tf = tfFollowSubst(tf);

switch (tfTag(tf)((tf)->tag)) {
case TF_Declare:
	tf = tfDeclareType(tf)tfFollowArg(tf, 0);
	break;
case TF_Assign:
	tf = tfAssignDecl(tf)tfFollowArg(tf, 0);
	break;
case TF_Define:
	if (tfIsDefineOfType(tf)) {
		TForm	cat = tfGetCategory(tfDefineVal(tf)tfFollowArg(tf, 1));
		if (tfIsUnknown(cat)(((cat)->tag) == TF_Unknown))
			tf = tfDefineDecl(tf)tfFollowArg(tf, 0);
		else
			tf = cat;
	}
	else
		tf = tfDefineDecl(tf)tfFollowArg(tf, 0);
	break;
default:
	done = true1;
	break;
}
}

return tf;
5865}

5867/*
* Walk down the definitions/declares/assigns to get the base type.
* This is essentially a function to compute the normal-form of tf
* when this is possible. Unfortunately some type definitions cause
* us to expand a type to the same tform and we end up looping. To
* prevent this we keep a list of all expansions and check that we
* haven't come across this one before. Since it is most likely that
* the previous tform will be the same as the current one we trace
* backwards towards the original tform.
*
* One further twist - we don't want to expand % so we stop as soon
* as we come across it. We might also want to stop at %% but they
* are quite a rare beast.
*
* Yet another twist - we may not want to replace definitions with
* the original `add' expression: if `notAdd' is true then we stop
* before replacing a tform with an add expression. Might want to
* extend this later for `with'.
*
* Problem - we don't want to replace definitions whose type is not
* known with their value as we lose information.
*/
5889localstatic TForm
5890tfDefineeType1(TForm tf, Bool subst, Bool notAdd)
5891{
Length		depth = 0;
Bool		done = false((int) 0);
TFormList	seen = listNil(TForm)((TFormList) 0);
TFormList	tfs;


/* Continually expand tf */
while (!done)
{
/* Stop this time unless there is a reason not to */
done = true1;


/* Be brutal ... */
tf = tfDefineeType0(tf, subst);


/* We don't expand % */
if (tfIsSelf(tf)(((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id) && (((tf)->__absyn)->
abId.sym) == (ssymSelf))) break;


/* Check previous tforms in case of cycles */
for (tfs = seen;tfs;tfs = cdr(tfs)((tfs)->rest))
{
	/* Have we seen this tform before? */
	if (tfEqual(car(tfs)((tfs)->first), tf))
		goto byeBye; /* Yes */
}


/* No - are we in too deep? */
if (depth > tfMaxBaseSearchDepth)
{
	bugWarning("tfDefineeType1: too deep");
	break; /* Yes */
}


/* No - push tform onto the list of tforms seen */
seen = listCons(TForm)(TForm_listPointer->Cons)(tf, seen);
depth++;


/* See if we can expand further */
if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)->
tag)) < TF_ABSYN_LIMIT))
{
	TForm	tfn	= (TForm) NULL((void*)0);
	Sefo	sefo	= tfGetExpr(tf)((tf)->__absyn);
	TForm	cat	= abGetCategory(sefo);


	/* Did we get anything useful? */
	switch (tfTag(cat)((cat)->tag))
	{
	   case TF_Assign:
		tfn  = tfAssignVal(cat)tfFollowArg(cat, 1);
		done = false((int) 0); /* Not finished yet */
		break;
	   case TF_Define:
		tfn  = tfDefineVal(cat)tfFollowArg(cat, 1);
		done = false((int) 0); /* Not finished yet */
		break;
	   default:
		/* Finished */
		break;
	}


	/* We must tread carefully again */
	if (!done)
	{
		/* Must have something to replace */
		if (!tfn)
		{
			done = true1;
			continue;
		}


		/* Can't replace with add unless OK'd */
		if (notAdd && (tfTag(tfn)((tfn)->tag) == TF_Add))
		{
			done = true1;
			continue;
		}


		/* Special tforms are fine */
		if (!tfIsAbSyn(tfn)( TF_ABSYN_START <= (((tfn)->tag)) && (((tfn)->
tag)) < TF_ABSYN_LIMIT))
		{
			/* Do the replacement */
			tf = tfn;
			continue;
		}


		/* Get the absyn */
		sefo = tfGetExpr(tfn)((tfn)->__absyn);


		/* Don't replace if it is a sequence */
		if (!abHasTag(sefo, AB_Sequence)((sefo)->abHdr.tag == (AB_Sequence)))
			tf = tfn;
		else
			done = true1;
	}
}
}


/* Common exit-point */
6003byeBye:
listFree(TForm)(TForm_listPointer->Free)(seen);
return tf;
6006}

6008TForm
6009tfDefineeType(TForm tf)
6010{
return tfDefineeType0(tf, true1);
6012}

6014TForm
6015tfDefineeTypeSubst(TForm tf)
6016{
return tfDefineeType0(tf, false((int) 0));
6018}

6020TForm
6021tfDefineeBaseType(TForm tf)
6022{
/* Normalise tf if possible */
extern Bool stabDumbImport(void);
return tfDefineeType1(tf, true1, !stabDumbImport()); /* true); */
6026}

6028/*
* Same as tfDefineeType but if it can be expanded
* further then we do so.
*/
6032TForm
6033tfDefineeMaybeType(TForm tf)
6034{
/* Deal with delta-equality */
if (tfIsAbSynTag(tfTag(tf))( TF_ABSYN_START <= (((tf)->tag)) && (((tf)->
tag)) < TF_ABSYN_LIMIT))
tf = tfDefineeBaseType(tf);
return tf;
6039}

6041/*
* Type form symbols
*/

6045/* These are initialized in tfInit(). */
6046AbSyn	abUnknown;
6047TForm	tfUnknown;
6048TForm	tfExit;
6049TForm	tfLiteral;
6050TForm	tfTest;
6051TForm	tfType;
6052TForm	tfTypeTuple;
6053TForm	tfCategory;
6054TForm	tfDomain;
6055TForm	tfBoolean;
6056TForm	tfTextWriter;
6057TForm	tfMachineInteger;

6059/* Is tf the type of a domain? */
6060Bool
6061tfIsDomainType(TForm tf)
6062{
if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
return abHasTag(tfGetExpr(tf), AB_With)((((tf)->__absyn))->abHdr.tag == (AB_With));

if (tfIsDefine(tf)(((tf)->tag) == TF_Define) && tfIsDeclare(tfDefineDecl(tf))(((tfFollowArg(tf, 0))->tag) == TF_Declare))
return tfIsWith(tfDeclareType(tfDefineDecl(tf)))(((tfFollowArg(tfFollowArg(tf, 0), 0))->tag) == TF_With);

if (tfIsJoin(tf)(((tf)->tag) == TF_Join))
return true1;

if (tfIsCategoryType(tfGetCategory(tf)))
return true1;
return false((int) 0);
6075}

6077/* Is tf the type of a domain constructor? */
6078Bool
6079tfIsDomainMap(TForm tf)
6080{
if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))
return tfIsDomainMap(tfMapRet(tf)tfFollowArg(tf, 1));
else
return tfIsDomainType(tf);
6085}

6087/* Is tf the type of a category? */
6088Bool
6089tfIsCategoryType(TForm tf)
6090{
AbSyn	ab = NULL((void*)0);

tf = tfFollowSubst(tf);

if (tfIsDefine(tf)(((tf)->tag) == TF_Define) && tfIsDeclare(tfDefineDecl(tf))(((tfFollowArg(tf, 0))->tag) == TF_Declare))
return tfIsCategoryType(tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0));

if (tfIsCategory(tf)(((tf)->tag) == TF_Category) || tfIsThird(tf)(((tf)->tag) == TF_Third))
return true1;

if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
ab = tfGetExpr(tf)((tf)->__absyn);

return ab && abIsTheId(ab, ssymCategory)(((ab)->abHdr.tag == (AB_Id)) && ((ab)->abId.sym
)==(ssymCategory));
6105}

6107/* Is tf the type of a category constructor? */
6108Bool
6109tfIsCategoryMap(TForm tf)
6110{
if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))
return tfIsCategoryMap(tfMapRet(tf)tfFollowArg(tf, 1));
else
return tfIsCategoryType(tf);
6115}

6117/*
* tfBoolean
*/

6121Bool
6122tfIsBooleanFn(TForm tf)
6123{
/*
* An unfixed compiler bug means that parts of Salli
* programs (and thus libAldor) are tinfered with
* (tfBoolean == tfUnknown). The correct fix is to
* ensure that tfBoolean has been imported into every
* scope that needs it before we get this far.
*/
AbSyn ab = tfGetExpr(tf)((tf)->__absyn);
if (tfBoolean == tfUnknown) comsgFatal(ab, ALDOR_F_BugNoBoolean367);
return tfSatisfies(tf, tfBoolean);
6134}

6136/*
* tfLibrary
*/

6140TForm
6141tfLibrary(Syme syme)
6142{
TForm	tf;
assert(symeIsLibrary(syme))do { if (!((((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->kind) == SYME_Library
))) _do_assert(("symeIsLibrary(syme)"),"tform.c",6144); } while
 (0);
tf = tfFrSyme(stabFile(), syme);
if (tfSymes(tf)((tf)->symes) == listNil(Syme)((SymeList) 0))
tfSetSymes(tf, listCons(Syme)(syme, listNil(Syme)))((tf)->symes = ((Syme_listPointer->Cons)(syme, ((SymeList
) 0))));
return tf;
6149}

6151TForm
6152tfGetLibrary(Syme syme)
6153{
Syme osyme = stabGetLibrary(symeId(syme)((syme)->id));
if (osyme && libEqual(symeLibrary(osyme)((Lib) (SYFI_Library < (8 * sizeof(int)) && !(((((
osyme)->kind == SYME_Trigger ? libGetAllSymes((osyme)->
lib) : ((void*)0)), (osyme))->hasmask) & (1 << (
SYFI_Library))) ? (symeFieldInfo[SYFI_Library].def) : (((((osyme
)->kind == SYME_Trigger ? libGetAllSymes((osyme)->lib) :
 ((void*)0)), (osyme))->locmask) & (1 << (SYFI_Library
))) ? ((((((osyme)->kind == SYME_Trigger ? libGetAllSymes(
(osyme)->lib) : ((void*)0)), (osyme))->locmask) & (
<< (SYFI_Library))) ? ((osyme)->fieldv)[symeIndex(
osyme,SYFI_Library)] : (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn
(osyme,SYFI_Library))), symeLibrary(syme)((Lib) (SYFI_Library < (8 * sizeof(int)) && !(((((
syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib
) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_Library
))) ? (symeFieldInfo[SYFI_Library].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_Library))) ?
 ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)
->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_Library))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Library
)] : (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn(syme
,SYFI_Library)))))
syme = osyme;
return tfLibrary(syme);
6158}

6160Bool
6161tfIsLibrary(TForm tf)
6162{
tfFollowSubst(tf);
return	(tfSymes(tf)((tf)->symes) != listNil(Syme)((SymeList) 0)) &&
(symeIsLibrary(car(tfSymes(tf)))(((((((((tf)->symes))->first))->kind == SYME_Trigger
 ? libGetAllSymes((((((tf)->symes))->first))->lib) :
 ((void*)0)), (((((tf)->symes))->first)))->kind) == SYME_Library
));
6166}

6168Bool
6169tfIsBasicLib(TForm tf)
6170{
if (tfIsLibrary(tf))
return libIsBasicLib(tfLibraryLib(tf));
else if (tfIsArchive(tf))
return arHasBasicLib(tfArchiveAr(tf));
else
return false((int) 0);
6177}

6179Syme
6180tfLibrarySyme(TForm tf)
6181{
tfFollow(tf)((tf) = tfFollowFn(tf));
return car(tfSymes(tf))((((tf)->symes))->first);
6184}

6186Lib
6187tfLibraryLib(TForm tf)
6188{
tfFollow(tf)((tf) = tfFollowFn(tf));
return symeLibrary(tfLibrarySyme(tf))((Lib) (SYFI_Library < (8 * sizeof(int)) && !(((((
tfLibrarySyme(tf))->kind == SYME_Trigger ? libGetAllSymes(
(tfLibrarySyme(tf))->lib) : ((void*)0)), (tfLibrarySyme(tf
)))->hasmask) & (1 << (SYFI_Library))) ? (symeFieldInfo
[SYFI_Library].def) : (((((tfLibrarySyme(tf))->kind == SYME_Trigger
 ? libGetAllSymes((tfLibrarySyme(tf))->lib) : ((void*)0)),
 (tfLibrarySyme(tf)))->locmask) & (1 << (SYFI_Library
))) ? ((((((tfLibrarySyme(tf))->kind == SYME_Trigger ? libGetAllSymes
((tfLibrarySyme(tf))->lib) : ((void*)0)), (tfLibrarySyme(tf
)))->locmask) & (1 << (SYFI_Library))) ? ((tfLibrarySyme
(tf))->fieldv)[symeIndex(tfLibrarySyme(tf),SYFI_Library)] :
 (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn(tfLibrarySyme
(tf),SYFI_Library)));
6191}

6193String
6194tfLibraryName(TForm tf)
6195{
tfFollow(tf)((tf) = tfFollowFn(tf));
return libGetFileId(tfLibraryLib(tf));
6198}

6200/*
* tfArchive
*/

6204TForm
6205tfArchive(Syme syme)
6206{
TForm	tf;
assert(symeIsArchive(syme))do { if (!((((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->kind) == SYME_Archive
))) _do_assert(("symeIsArchive(syme)"),"tform.c",6208); } while
 (0);
tf = tfFrSyme(stabFile(), syme);
if (tfSymes(tf)((tf)->symes) == listNil(Syme)((SymeList) 0))
tfSetSymes(tf, listCons(Syme)(syme, listNil(Syme)))((tf)->symes = ((Syme_listPointer->Cons)(syme, ((SymeList
) 0))));
return tf;
6213}

6215TForm
6216tfGetArchive(Syme syme)
6217{
Syme osyme = stabGetArchive(symeId(syme)((syme)->id));
if (osyme && arEqual(symeArchive(osyme)((Archive) (SYFI_Archive < (8 * sizeof(int)) && !(
((((osyme)->kind == SYME_Trigger ? libGetAllSymes((osyme)->
lib) : ((void*)0)), (osyme))->hasmask) & (1 << (
SYFI_Archive))) ? (symeFieldInfo[SYFI_Archive].def) : (((((osyme
)->kind == SYME_Trigger ? libGetAllSymes((osyme)->lib) :
 ((void*)0)), (osyme))->locmask) & (1 << (SYFI_Archive
))) ? ((((((osyme)->kind == SYME_Trigger ? libGetAllSymes(
(osyme)->lib) : ((void*)0)), (osyme))->locmask) & (
<< (SYFI_Archive))) ? ((osyme)->fieldv)[symeIndex(
osyme,SYFI_Archive)] : (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn
(osyme,SYFI_Archive))), symeArchive(syme)((Archive) (SYFI_Archive < (8 * sizeof(int)) && !(
((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_Archive
))) ? (symeFieldInfo[SYFI_Archive].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_Archive))) ?
 ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)
->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_Archive))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Archive
)] : (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn(syme
,SYFI_Archive)))))
syme = osyme;
return tfArchive(syme);
6222}

6224Bool
6225tfIsArchive(TForm tf)
6226{
tfFollowSubst(tf);
return	(tfSymes(tf)((tf)->symes) != listNil(Syme)((SymeList) 0)) &&
(symeIsArchive(car(tfSymes(tf)))(((((((((tf)->symes))->first))->kind == SYME_Trigger
 ? libGetAllSymes((((((tf)->symes))->first))->lib) :
 ((void*)0)), (((((tf)->symes))->first)))->kind) == SYME_Archive
));
6230}

6232Syme
6233tfArchiveSyme(TForm tf)
6234{
tfFollow(tf)((tf) = tfFollowFn(tf));
return car(tfSymes(tf))((((tf)->symes))->first);
6237}

6239Archive
6240tfArchiveAr(TForm tf)
6241{
tfFollow(tf)((tf) = tfFollowFn(tf));
return symeArchive(tfArchiveSyme(tf))((Archive) (SYFI_Archive < (8 * sizeof(int)) && !(
((((tfArchiveSyme(tf))->kind == SYME_Trigger ? libGetAllSymes
((tfArchiveSyme(tf))->lib) : ((void*)0)), (tfArchiveSyme(tf
)))->hasmask) & (1 << (SYFI_Archive))) ? (symeFieldInfo
[SYFI_Archive].def) : (((((tfArchiveSyme(tf))->kind == SYME_Trigger
 ? libGetAllSymes((tfArchiveSyme(tf))->lib) : ((void*)0)),
 (tfArchiveSyme(tf)))->locmask) & (1 << (SYFI_Archive
))) ? ((((((tfArchiveSyme(tf))->kind == SYME_Trigger ? libGetAllSymes
((tfArchiveSyme(tf))->lib) : ((void*)0)), (tfArchiveSyme(tf
)))->locmask) & (1 << (SYFI_Archive))) ? ((tfArchiveSyme
(tf))->fieldv)[symeIndex(tfArchiveSyme(tf),SYFI_Archive)] :
 (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn(tfArchiveSyme
(tf),SYFI_Archive)));
6244}

6246TForm
6247tfArchiveLib(TForm tf, Syme syme)
6248{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfLibrary(arLibrarySyme(tfArchiveAr(tf), syme));
6251}

6253/*
* tfDeclare
*/

6257TForm
6258tfDeclare(AbSyn id, TForm tf)
6259{
TForm	new;

tfFollow(tf)((tf) = tfFollowFn(tf));

new = tfNewNode(TF_Declare, 1, tf);
tfSetSymes(new, tfSymesFrDeclare(id))((new)->symes = (tfSymesFrDeclare(id)));
tfSetMeaningArgs(new);

return new;
6269}

6271Symbol
6272tfDeclareId(TForm tf)
6273{
Syme	syme;
tfFollow(tf)((tf) = tfFollowFn(tf));
syme = tfDeclareSyme(tf);
return syme ? symeId(syme)((syme)->id) : NULL((void*)0);
6278}

6280Syme
6281tfDeclareSyme(TForm tf)
6282{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfSymes(tf)((tf)->symes) ? car(tfSymes(tf))((((tf)->symes))->first) : NULL((void*)0);
6285}

6287/*
* tfDefine
*/

6291TForm
6292tfDefine(TForm tf, AbSyn val)
6293{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfNewNode(TF_Define, 2, tf, tfNewAbSyn(TF_General, val));
6296}

6298TForm
6299tfDefineOfType(TForm tf)
6300{
TForm	ntf;

ntf = tfNewNode(TF_Declare, 1, tfType);
tfSetMeaningArgs(ntf);

ntf = tfNewNode(TF_Define, 2, ntf, tf);
tfSetMeaningArgs(ntf);

return ntf;
6310}

6312Bool
6313tfIsDefineOfType(TForm tf)
6314{
Bool	result = false((int) 0);

if (tfIsDefine(tf)(((tf)->tag) == TF_Define) && tfIsDeclare(tfDefineDecl(tf))(((tfFollowArg(tf, 0))->tag) == TF_Declare)) {
tf = tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0);
result = tfIsType(tf)(((tf)->tag) == TF_Type) || tfIsUnknown(tf)(((tf)->tag) == TF_Unknown);
}

return result;
6323}

6325Bool
6326tfIsDefinedType(TForm tf)
6327{
TForm	cat;
TForm   tf2 = tfDefineeTypeSubst(tf);
/* !!Maybe a bit strong.
* What it should do is return true
* for uses of garbage types like Foo == zzz(x)(y);
* This function is performance critical because
* of the call from tformEqual0.  Consequently,
* it shouldn't call tfGetCategory or symeType
* if at all possible 
*/
if (!tfIsGeneral(tf2)(((tf2)->tag) == TF_General))
return false((int) 0);

if (tfIsSelf(tf)(((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id) && (((tf)->__absyn)->
abId.sym) == (ssymSelf)) && tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))
cat = symeType(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0));
else
cat = tfGetCategory(tf);

return tfIsDefineOfType(cat);
6347}

6349TForm
6350tfDefinedVal(TForm tf)
6351{
TForm	cat;

if (tfIsSelf(tf)(((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id) && (((tf)->__absyn)->
abId.sym) == (ssymSelf)) && tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0))
cat = symeType(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))->
abHdr.seman->syme : 0));
else
cat = tfGetCategory(tf);

return tfDefineVal(cat)tfFollowArg(cat, 1);
6360}

6362/*
* tfAssign
*/

6366TForm
6367tfAssign(TForm tf, AbSyn val)
6368{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfNewNode(TF_Assign, 2, tf, tfNewAbSyn(TF_General, val));
6371}


6374/*
* tfMap
*/

6378TForm
6379tfAnyMap(TForm arg, TForm ret, Bool packed)
6380{
if (packed)
return tfPackedMap(arg, ret);
else
return tfMap(arg, ret);
6385}

6387TForm
6388tfMap(TForm arg, TForm ret)
6389{
TForm	tf;
tfFollow(arg)((arg) = tfFollowFn(arg));
tfFollow(ret)((ret) = tfFollowFn(ret));
tf = tfNewNode(TF_Map, 2, arg, ret);
tfSetSymes(tf, tfSymesFrMap(tf))((tf)->symes = (tfSymesFrMap(tf)));
return tf;
6396}

6398TForm
6399tfPackedMap(TForm arg, TForm ret)
6400{
TForm	tf;
tfFollow(arg)((arg) = tfFollowFn(arg));
tfFollow(ret)((ret) = tfFollowFn(ret));
tf = tfNewNode(TF_PackedMap, 2, arg, ret);
tfSetSymes(tf, tfSymesFrMap(tf))((tf)->symes = (tfSymesFrMap(tf)));
return tf;
6407}

6409Bool
6410tfIsDependentMap(TForm tf)
6411{
Bool	result;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && !tfSymes(tf)((tf)->symes))
tfSetSymes(tf, tfSymesFrMap(tf))((tf)->symes = (tfSymesFrMap(tf)));

result = tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && tfSymes(tf)((tf)->symes) != listNil(Syme)((SymeList) 0);

if (DEBUG(tfMap)tfMapDebug) {
fprintf(dbOut, "tfIsDependentMap:  %s\n  tf:",
	boolToString(result)((result) ? "true" : "false"));
tfPrint(dbOut, tf);
fnewline(dbOut);
}

return result;
6429}

6431/* Return true if the map has default values for arguments.  */
6432Bool
6433tfMapHasDefaults(TForm tf)
6434{
Bool	result = false((int) 0);
Length	i;

tfFollow(tf)((tf) = tfFollowFn(tf));
assert(tfIsAnyMap(tf))do { if (!(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))) _do_assert(("tfIsAnyMap(tf)"),"tform.c",6439); } while (
0);

for (i = 0; i < tfMapArgc(tf); i++)
if (tfIsDefine(tfMapArgN(tf, i))(((tfMapArgN(tf, i))->tag) == TF_Define))
	result = true1;

return result;
6446}

6448Length
6449tfMapArgc(TForm tf)
6450{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiArgc(tfMapArg(tf)tfFollowArg(tf, 0));
6453}

6455/* Return the type of the nth argument value of a map of type tf. */
6456TForm
6457tfMapArgN(TForm tf, Length n)
6458{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiArgN(tfMapArg(tf)tfFollowArg(tf, 0), tfMapArgc(tf), n);
6461}

6463SymeList
6464tfMapArgSymes(TForm tf)
6465{
SymeList sl = listNil(Syme)((SymeList) 0);
int i;

tfFollow(tf)((tf) = tfFollowFn(tf));
assert(tfIsMap(tf))do { if (!((((tf)->tag) == TF_Map))) _do_assert(("tfIsMap(tf)"
),"tform.c",6470); } while (0);

for (i=0; i<tfMapArgc(tf); i++) {
TForm argTf = tfMapArgN(tf, i);
if (tfIsDeclare(argTf)(((argTf)->tag) == TF_Declare))
	sl = listCons(Syme)(Syme_listPointer->Cons)(tfDeclareSyme(argTf), sl);
else
	sl = listCons(Syme)(Syme_listPointer->Cons)(NULL((void*)0), sl);
}
return listNReverse(Syme)(Syme_listPointer->NReverse)(sl);
6480}


6483/* Return the type of the nth argument value of a map of type tf
* in an application with argc arguments.
*/
6486TForm
6487tfMapMultiArgN(TForm tf, Length argc, Length n)
6488{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiArgN(tfMapArg(tf)tfFollowArg(tf, 0), argc, n);
6491}

6493/* Return the embedding necessary to pass argc arguments
* to a map of type tf.
*/
6496AbEmbed
6497tfMapMultiArgEmbed(TForm tf, Length argc)
6498{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiEmbed(tfMapArg(tf)tfFollowArg(tf, 0), argc);
6501}

6503Length
6504tfMapRetc(TForm tf)
6505{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiArgc(tfIgnoreExceptions(tfMapRet(tf)tfFollowArg(tf, 1)));
6508}

6510/* Return the type of the nth return value of a map of type tf. */
6511TForm
6512tfMapRetN(TForm tf, Length n)
6513{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiArgN(tfMapRet(tf)tfFollowArg(tf, 1), tfMapRetc(tf), n);
6516}

6518/* Return the type of the nth return value of a map of type tf
* in an application with argc arguments.
*/
6521TForm
6522tfMapMultiRetN(TForm tf, Length argc, Length n)
6523{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiArgN(tfMapRet(tf)tfFollowArg(tf, 1), argc, n);
6526}

6528/* Return the embedding necessary to return argc arguments
* from a map of type tf.
*/
6531AbEmbed
6532tfMapMultiRetEmbed(TForm tf, Length argc)
6533{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfAsMultiEmbed(tfMapRet(tf)tfFollowArg(tf, 1), argc);
6536}

6538/*
* tfCross
*/

6542TForm
6543tfCross(Length argc, ...)
6544{
TForm	tf;
Length	i;
va_list argp;

tf = tfNewEmpty(TF_Cross, argc);

va_start(argp, argc)__builtin_va_start(argp, argc);
for (i = 0; i < argc; i += 1)
tfArgv(tf)((tf)->argv)[i] = va_arg(argp, TForm)__builtin_va_arg(argp, TForm);
va_end(argp)__builtin_va_end(argp);

tfSetSymes(tf, tfSymesFrCross(tf))((tf)->symes = (tfSymesFrCross(tf)));

return tf;
6559}

6561TForm
6562tfCrossFrList(TFormList tfl)
6563{
TForm	tf;
Length	i, argc = listLength(TForm)(TForm_listPointer->_Length)(tfl);

tf = tfNewEmpty(TF_Cross, argc);

for (i = 0; tfl; i += 1, tfl = cdr(tfl)((tfl)->rest))
tfArgv(tf)((tf)->argv)[i] = car(tfl)((tfl)->first);

tfSetSymes(tf, tfSymesFrCross(tf))((tf)->symes = (tfSymesFrCross(tf)));

return tf;
6575}

6577TForm
6578tfCrossFrMulti(TForm tfm)
6579{
TForm	tf;
Length	i, argc = tfMultiArgc(tfm);

tf = tfNewEmpty(TF_Cross, argc);

for (i = 0; i < argc; i++)
tfArgv(tf)((tf)->argv)[i] = tfArgv(tfm)((tfm)->argv)[i];

tfSetSymes(tf, tfSymesFrCross(tf))((tf)->symes = (tfSymesFrCross(tf)));

return tf;
6591}

6593Bool
6594tfIsDependentCross(TForm tf)
6595{
Bool	result;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfIsCross(tf)(((tf)->tag) == TF_Cross) && !tfSymes(tf)((tf)->symes))
tfSetSymes(tf, tfSymesFrCross(tf))((tf)->symes = (tfSymesFrCross(tf)));

result = tfIsCross(tf)(((tf)->tag) == TF_Cross) && tfSymes(tf)((tf)->symes) != listNil(Syme)((SymeList) 0);

if (DEBUG(tfCross)tfCrossDebug) {
fprintf(dbOut, "tfIsDependentCross:  %s\n  tf:",
	boolToString(result)((result) ? "true" : "false"));
tfPrint(dbOut, tf);
fnewline(dbOut);
}

return result;
6613}

6615Length
6616tfCrossArgc(TForm tf)
6617{
assert(tfIsCross(tf))do { if (!((((tf)->tag) == TF_Cross))) _do_assert(("tfIsCross(tf)"
),"tform.c",6618); } while (0);
return tfArgc(tf)((tf)->argc);
6620}

6622/*
* tfMultiple
*/

6626localstatic void
6627tfMultiAfter(TForm tf)
6628{
tfSetMeaningArgs(tf);
tfSetSymes(tf, tfSymesFrMulti(tf))((tf)->symes = (tfSymesFrMulti(tf)));
if (tfArgc(tf)((tf)->argc) == 0) tfToAbSyn(tf);
6632}

6634TForm
6635tfMulti(Length argc, ...)
6636{
TForm	tf;
Length	i;
va_list argp;

tf = tfNewEmpty(TF_Multiple, argc);

va_start(argp, argc)__builtin_va_start(argp, argc);
for (i = 0; i < argc; i += 1)
tfArgv(tf)((tf)->argv)[i] = va_arg(argp, TForm)__builtin_va_arg(argp, TForm);
va_end(argp)__builtin_va_end(argp);

tfMultiAfter(tf);
return tf;
6650}

6652Bool
6653tfIsDependentMulti(TForm tf)
6654{
Bool	result;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfIsMulti(tf)(((tf)->tag) == TF_Multiple) && !tfSymes(tf)((tf)->symes))
tfSetSymes(tf, tfSymesFrMulti(tf))((tf)->symes = (tfSymesFrMulti(tf)));

result = tfIsMulti(tf)(((tf)->tag) == TF_Multiple) && tfSymes(tf)((tf)->symes) != listNil(Syme)((SymeList) 0);

if (DEBUG(tfMulti)tfMultiDebug) {
fprintf(dbOut, "tfIsDependentMulti:  %s\n  tf:",
	boolToString(result)((result) ? "true" : "false"));
tfPrint(dbOut, tf);
fnewline(dbOut);
}

return result;
6672}

6674TForm
6675tfMultiFrList(TFormList tfl)
6676{
TForm	tf;
Length	i, argc = listLength(TForm)(TForm_listPointer->_Length)(tfl);

tf = tfNewEmpty(TF_Multiple, argc);

for (i = 0; tfl; i += 1, tfl = cdr(tfl)((tfl)->rest))
tfArgv(tf)((tf)->argv)[i] = car(tfl)((tfl)->first);

tfMultiAfter(tf);
return tf;
6687}

6689TForm
6690tfMultiFrTUnique(Sefo sefo)
6691{
TForm	tf;
Length	i, argc = abArgc(sefo)((sefo)->abHdr.argc);

tf = tfNewEmpty(TF_Multiple, argc);

for (i = 0; i < argc; i += 1)
tfArgv(tf)((tf)->argv)[i] = abTUnique(abArgv(sefo)[i])((((sefo)->abGen.data.argv)[i])->abHdr.type.unique);

tfMultiAfter(tf);
return tf;
6702}

6704Length
6705tfMultiArgc(TForm tf)
6706{
assert(tfIsMulti(tf))do { if (!((((tf)->tag) == TF_Multiple))) _do_assert(("tfIsMulti(tf)"
),"tform.c",6707); } while (0);
return tfArgc(tf)((tf)->argc);
6709}

6711Bool
6712tfMultiHasDefaults(TForm tf)
6713{
Bool	result = false((int) 0);
Length	i;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (!tfIsMulti(tf)(((tf)->tag) == TF_Multiple))
return tfIsDefine(tf)(((tf)->tag) == TF_Define);

for (i = 0; i < tfMultiArgc(tf); i++) {
TForm tfi = tfFollowSubst(tfMultiArgN(tf,i)tfFollowArg(tf, i));
if (tfIsDefine(tfi)(((tfi)->tag) == TF_Define))
	result = true1;
}
return result;
6728}

6730AbEmbed
6731tfAsMultiEmbed(TForm tf, Length argc)
6732{
AbEmbed		result = AB_Embed_Fail((AbEmbed) 0);
TForm		ntf;

ntf = tfDefineeType(tf);
tf  = tfFollowOnly(tf);

if (tfIsMulti(ntf)(((ntf)->tag) == TF_Multiple) &&
   (tfMultiArgc(ntf) == argc ||
    (tfMultiArgc(ntf) > argc && tfMultiHasDefaults(ntf))))
result = AB_Embed_Identity(((AbEmbed) 1) << 0);

else if (argc == 1)
result = AB_Embed_Identity(((AbEmbed) 1) << 0);

else if (tfIsTuple(ntf)(((ntf)->tag) == TF_Tuple))
result = AB_Embed_ApplyMultiToTuple(((AbEmbed) 1) << 12);

else if (tfIsCross(ntf)(((ntf)->tag) == TF_Cross) && tfCrossArgc(ntf) == argc)
result = AB_Embed_ApplyMultiToCross(((AbEmbed) 1) << 13);
else if (argc == 0 && tfIsDefine(tf)(((tf)->tag) == TF_Define))
return AB_Embed_Identity(((AbEmbed) 1) << 0);

return result;
6756}

6758Length
6759tfAsMultiArgc(TForm tf)
6760{
tfFollow(tf)((tf) = tfFollowFn(tf));
return (tfIsMulti(tf)(((tf)->tag) == TF_Multiple) ? tfMultiArgc(tf) : 1);
6763}

6765TForm
6766tfAsMultiArgN(TForm tf, Length argc, Length n)
6767{
TForm	result = 0;
TForm	ntf;

assert(n < argc)do { if (!(n < argc)) _do_assert(("n < argc"),"tform.c"
,6771); } while (0);
ntf = tfDefineeType(tf);

if (tfIsMulti(ntf)(((ntf)->tag) == TF_Multiple) && tfMultiArgc(ntf) == argc)
result = tfMultiArgN(ntf, n)tfFollowArg(ntf, n);

else if (argc == 1)
result = tf;

else if (tfIsTuple(ntf)(((ntf)->tag) == TF_Tuple))
result = tfTupleArg(ntf)tfFollowArg(ntf, 0);

else if (tfIsCross(ntf)(((ntf)->tag) == TF_Cross) && tfCrossArgc(ntf) == argc)
result = tfCrossArgN(ntf, n)tfFollowArg(ntf, n);

assert(result)do { if (!(result)) _do_assert(("result"),"tform.c",6786); } while
 (0);
return result;
6788}

6790#define		abIsDefineKeyword(ab)(((ab)->abHdr.tag == (AB_Define)) && ((((ab)->abDefine
.lhs))->abHdr.tag == (AB_Id)))	\
(abHasTag(ab, AB_Define)((ab)->abHdr.tag == (AB_Define)) && abHasTag(abDefineDecl(ab), AB_Id)((((ab)->abDefine.lhs))->abHdr.tag == (AB_Id)))

6793AbSyn
6794tfAsMultiSelectArg(AbSyn ab, Length argc, Length n, AbSynGetter argf,
   TForm tfi, Bool * def, Length * pos)
6796{
AbSyn	abpos, abkey, abi;
Symbol	name;
Length	i;

/* ?? tfFollowSubst */
tfFollow(tfi)((tfi) = tfFollowFn(tfi)); 
/* Find the keyword name. */
name = tfDefineeSymbol(tfi);

/* Find the positional argument. */
abpos = (n < argc) ? argf(ab, n) : NULL((void*)0);
*pos = n;

/* If abpos is a define, assume its a keyword, not positional.
* But if tfi doesn't have a keyword (if name == NULL),
* treat a define as positional so we can type check
* 'Record(x: Integer == 0)' correctly.
*/
if (name && abpos && abIsDefineKeyword(abpos)(((abpos)->abHdr.tag == (AB_Define)) && ((((abpos)
->abDefine.lhs))->abHdr.tag == (AB_Id))))
abpos = NULL((void*)0);

/* Find the keyword argument. */
abkey = NULL((void*)0);
for (i = 0; name && !abkey && i < argc; i += 1) {
AbSyn	ak = argf(ab, i);
if (abIsDefineKeyword(ak)(((ak)->abHdr.tag == (AB_Define)) && ((((ak)->abDefine
.lhs))->abHdr.tag == (AB_Id))) &&
    abIsTheId(abDefineeId(ak), name)(((abDefineeId(ak))->abHdr.tag == (AB_Id)) && ((abDefineeId
(ak))->abId.sym)==(name))) {
	abkey = ak;
	*pos = i;
}
}

/* Select the argument to use. */
*def = false((int) 0);
if (abpos && abkey)
abi = NULL((void*)0);

else if (abpos)
abi = abpos;

else if (abkey)
abi = abkey->abDefine.rhs;

else if (tfIsDefine(tfi)(((tfi)->tag) == TF_Define)) {
/*abi = tfGetExpr(tfDefineVal(tfi));*/
abi = tfExpr(tfDefineVal(tfi))tfToAbSyn(tfFollowArg(tfi, 1));
*def = true1;
}
else
abi = NULL((void*)0);

return abi;
6849}

6851/*
* Grab the ith argument from a flat absyn,
*/
6854AbSyn
6855tfMapSelectArg(TForm opTf, AbSyn ab, Length i)
6856{
Length  ai;
Bool 	def;
TForm tfi = tfMapArgN(opTf, i);
AbSyn abi = tfAsMultiSelectArg(ab, 
		       abApplyArgc(ab)(((ab)->abHdr.argc)-1), i, 
		       abApplyArgf, tfi, &def, &ai);

if (abTag(abi)((abi)->abHdr.tag) == AB_Define)
abi = abi->abDefine.rhs;

return abi;
6868}

6870/*
* tfTuple
*/

6874TForm
6875tfTuple(TForm arg)
6876{
TForm	tf = tfNewNode(TF_Tuple, 1, arg);
tfSetMeaningArgs(tf);
return tf;
6880}

6882/*
* tfEnumerate
*/

6886TForm
6887tfEnum(Stab stab, AbSyn id)
6888{
TForm   tf = tfNewNode(TF_Enumerate, 1, tfDeclare(id, tfType));
AbSyn	ab = tfExpr(tf)tfToAbSyn(tf);
TForm	ntf;

if ((ntf = stabGetTForm(stab, ab, NULL((void*)0))) != NULL((void*)0))
return ntf;

tfSetSymes(tf, tfSymesFrEnum(stab, tf, ab))((tf)->symes = (tfSymesFrEnum(stab, tf, ab)));
tfSetMeaningArgs(tf);

stabDefTForm(stab, tf);
return tf;
6901}

6903Length
6904tfEnumArgc(TForm tf)
6905{
assert(tfIsEnum(tf))do { if (!((((tf)->tag) == TF_Enumerate))) _do_assert(("tfIsEnum(tf)"
),"tform.c",6906); } while (0);
return tfArgc(tf)((tf)->argc);
6908}

6910Symbol
6911tfEnumId(TForm tf, Length n)
6912{
TForm	tfi;

assert(tfIsEnum(tf))do { if (!((((tf)->tag) == TF_Enumerate))) _do_assert(("tfIsEnum(tf)"
),"tform.c",6915); } while (0);
tfi = tfEnumArgN(tf, n)tfFollowArg(tf, n);

if (tfIsDeclare(tfi)(((tfi)->tag) == TF_Declare))
return tfDeclareId(tfi);
else if (tfIsId(tfi)((((tfi)->tag) == TF_General) && ((((tfi)->__absyn
))->abHdr.tag) == AB_Id))
return tfIdSym(tfi)(((tfi)->__absyn)->abId.sym);
else
return NULL((void*)0);
6924}

6926Symbol
6927tfCompoundId(TForm tf, Length n)
6928{
TForm	tfi = tfFollow(tfArgv(tf)[n])((((tf)->argv)[n]) = tfFollowFn(((tf)->argv)[n]));

if (tfIsDeclare(tfi)(((tfi)->tag) == TF_Declare))
return tfDeclareId(tfi);
else if (tfIsId(tfi)((((tfi)->tag) == TF_General) && ((((tfi)->__absyn
))->abHdr.tag) == AB_Id))
return tfIdSym(tfi)(((tfi)->__absyn)->abId.sym);
else
return NULL((void*)0);
6937}

6939/*
* tfRawRecord
*/
6942Length
6943tfRawRecordArgc(TForm tf)
6944{
assert(tfIsRawRecord(tf))do { if (!((((tf)->tag) == TF_RawRecord))) _do_assert(("tfIsRawRecord(tf)"
),"tform.c",6945); } while (0);
return tfArgc(tf)((tf)->argc);
6947}

6949/*
* tfRecord
*/

6953Length
6954tfRecordArgc(TForm tf)
6955{
assert(tfIsRecord(tf))do { if (!((((tf)->tag) == TF_Record))) _do_assert(("tfIsRecord(tf)"
),"tform.c",6956); } while (0);
return tfArgc(tf)((tf)->argc);
6958}

6960/*
* tfTrailingArray
*/

6964Length
6965tfTrailingArrayIArgc(TForm tf)
6966{
assert(tfIsTrailingArray(tf))do { if (!((((tf)->tag) == TF_TrailingArray))) _do_assert(
("tfIsTrailingArray(tf)"),"tform.c",6967); } while (0);
return tfArgc(tf)((tf)->argc);
6969}

6971Length
6972tfTrailingArrayAArgc(TForm tf)
6973{
assert(tfIsTrailingArray(tf))do { if (!((((tf)->tag) == TF_TrailingArray))) _do_assert(
("tfIsTrailingArray(tf)"),"tform.c",6974); } while (0);
return tfArgc(tf)((tf)->argc);
6976}

6978TForm
6979tfTrailingArrayIArgN(TForm tf, Length n)
6980{
assert(tfIsTrailingArray(tf))do { if (!((((tf)->tag) == TF_TrailingArray))) _do_assert(
("tfIsTrailingArray(tf)"),"tform.c",6981); } while (0);
bug("tfTrailingArrayIArgN: aargh");
return tfFollowArg(tf, n);
6984}

6986TForm
6987tfTrailingArrayAArgN(TForm tf, Length n)
6988{
assert(tfIsTrailingArray(tf))do { if (!((((tf)->tag) == TF_TrailingArray))) _do_assert(
("tfIsTrailingArray(tf)"),"tform.c",6989); } while (0);
bug("tfTrailingArrayAArgN: aargh");
return tfFollowArg(tf, n);
6992}

6994/*
* tfUnion
*/

6998Length
6999tfUnionArgc(TForm tf)
7000{
assert(tfIsUnion(tf))do { if (!((((tf)->tag) == TF_Union))) _do_assert(("tfIsUnion(tf)"
),"tform.c",7001); } while (0);
return tfArgc(tf)((tf)->argc);
7003}

7005/*
* tfWith
*/

7009TForm
7010tfWith(TForm base, TForm body)
7011{
TForm	tf = tfNewNode(TF_With, 2, base, body);
tfSetMeaningArgs(tf);
return tf;
7015}

7017TForm
7018tfWithFrSymes(SymeList symes)
7019{
TForm	tf;
tf = tfNewNode(TF_With, 2, tfNone()tfMulti(0), tfNone()tfMulti(0));
tfSetCatExports(tf, symes);
tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
return tf;
7025}

7027TForm
7028tfWithFrAbSyn(AbSyn absyn)
7029{
TForm	tf;
tf = tfWithFrSymes(listNReverse(Syme)(Syme_listPointer->NReverse)(tfSymesFrAdd(absyn)));
tfAddSelf(tf, tfGetSelfFrStab(abStab(absyn)((absyn)->abHdr.seman ? (absyn)->abHdr.seman->stab :
 0)));
return tf;
7034}

7036/*
* tfThird
*/

7040TForm
7041tfThirdFrTForm(TForm tfw)
7042{
TForm	tf;
tf = tfNewNode(TF_Third, 1, tfw);
return tf;
7046}

7048TForm
7049tfThird(SymeList symes)
7050{
TForm	tf;
tf = tfNewNode(TF_Third, 1, tfNone()tfMulti(0));
tfSetThdExports(tf, symes);
tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
return tf;
7056}

7058/*
* tfGenerator
*/

7062TForm
7063tfGenerator(TForm arg)
7064{
TForm	tf = tfNewNode(TF_Generator, 1, arg);
tfSetMeaningArgs(tf);
return tf;
7068}

7070Bool
7071tfIsGeneratorFn(TForm tf)
7072{
tf = tfFollowSubst(tf);
return tfIsGenerator(tf)(((tf)->tag) == TF_Generator);
7075}

7077Bool
7078tfIsXGeneratorFn(TForm tf)
7079{
tf = tfFollowSubst(tf);
return tfIsXGenerator(tf)(((tf)->tag) == TF_XGenerator);
7082}

7084/*
* tfReference
*/

7088TForm
7089tfReference(TForm arg)
7090{
TForm	tf = tfNewNode(TF_Reference, 1, arg);
tfSetMeaningArgs(tf);
return tf;
7094}

7096Bool
7097tfIsReferenceFn(TForm tf)
7098{
tf = tfFollowSubst(tf);
return tfIsReference(tf)(((tf)->tag) == TF_Reference);
7101}

7103/*
* tfSubst
*/

7107static int	TFSubstCount		= 0;

7109TForm
7110tfSubst(AbSub sigma, TForm arg)
7111{
TForm	tf = tfNewNode(TF_Subst, 1, arg);
tfSubstSigma(tf)((tf)->sigma) = absRefer(sigma);
tfSetMeaningArgs(tf);
TFSubstCount += 1;
return tf;
7117}

7119TForm
7120tfSubstPush(TForm tf)
7121{
AbSub	sigma;

assert(tfIsSubst(tf))do { if (!((((tf)->tag) == TF_Subst))) _do_assert(("tfIsSubst(tf)"
),"tform.c",7124); } while (0);
assert(tf->sigma)do { if (!(tf->sigma)) _do_assert(("tf->sigma"),"tform.c"
,7125); } while (0);

sigma = absRefer(tf->sigma);
absClrLazy(sigma)((sigma)->lazy = ((int) 0));

tf->argv[0] = tformSubst(sigma, tf->argv[0]);

absSetLazy(sigma)((sigma)->lazy = 1);
absFree(sigma);

if (tf->sigma) {
tf->sigma	= NULL((void*)0);
tf->tag		= TF_Forward;
absFree(sigma);
}
if (tfConditions(tf) != NULL((void*)0)) {
tfDEBUGif (!tfDebug) { } else afprintf(dbOut, "SubstPushCond: %pTForm %pAbSynList\n",
	tf->argv[0], tfConditionalAbSyn(tf));
tfSetConditions(tf->argv[0], tfConditions(tf))(tf->argv[0]->conditions = (tfConditions(tf)));
}

assert(tf->argv[0] != tf)do { if (!(tf->argv[0] != tf)) _do_assert(("tf->argv[0] != tf"
),"tform.c",7146); } while (0);
return tf->argv[0];
7148}

7150/*
* tfTrigger
*/

7154TForm
7155tfTrigger(Syme syme)
7156{
TForm	tf = tfNewEmpty(TF_Trigger, 1);
tfSetSymes(tf, listCons(Syme)(syme, listNil(Syme)))((tf)->symes = ((Syme_listPointer->Cons)(syme, ((SymeList
) 0))));
return tf;
7160}

7162Lib
7163tfTriggerLib(TForm tf)
7164{
assert(tfIsTrigger(tf))do { if (!((((tf)->tag) == TF_Trigger))) _do_assert(("tfIsTrigger(tf)"
),"tform.c",7165); } while (0);
assert(tfSymes(tf))do { if (!(((tf)->symes))) _do_assert(("tfSymes(tf)"),"tform.c"
,7166); } while (0);
return symeLib(car(tfSymes(tf)))((((((tf)->symes))->first))->lib);
7168}

7170TForm
7171tfForwardFrTrigger(TForm otf, TForm ntf)
7172{
assert(tfIsTrigger(otf))do { if (!((((otf)->tag) == TF_Trigger))) _do_assert(("tfIsTrigger(otf)"
),"tform.c",7173); } while (0);
assert(otf != ntf)do { if (!(otf != ntf)) _do_assert(("otf != ntf"),"tform.c",7174
); } while (0);

otf->tag	= TF_Forward;
otf->argc	= 1;
otf->argv[0]	= ntf;

return otf;
7181}

7183/*
* tfFollow
*/

7187#if 0
7188/* Debugging code for tfFollowFn. */

7190static int	TFFollowFrom		= TFF_Other;
7191static int	TFFollowCount[TFF_Limit];

7193void
7194tfFollowInit(void)
7195{
int	i;
for (i = 0; i < TFF_Limit; i += 1)
TFFollowCount[i] = 0;
7199}

7201void
7202tfFollowFini(void)
7203{
int	i;

fprintf(dbOut, "calls to tfSubst:  %d\n", TFSubstCount);
fprintf(dbOut, "calls to tfSubstPush from:");
fnewline(dbOut);

for (i = 0; i < TFF_Limit; i += 1)
fprintf(dbOut, "%d\t%d\n", i, TFFollowCount[i]);
7212}

7214void
7215tfFollowFrom(int loc)
7216{
TFFollowFrom = loc;
7218}
7219#endif

7221TForm
7222tfFollowOnly(TForm tf)
7223{
Bool	done = (tf == NULL((void*)0));

while (!done) {
if (tfIsForward(tf)(((tf)->tag) == TF_Forward))
	tf = tf->argv[0];
else if (tfIsTrigger(tf)(((tf)->tag) == TF_Trigger))
	libGetAllSymes(tfTriggerLib(tf));
else
	done = true1;
}
return tf;
7235}

7237TForm
7238tfFollowSubst(TForm tf)
7239{
Bool	done = (tf == NULL((void*)0));

while (!done) {
if (tfIsForward(tf)(((tf)->tag) == TF_Forward))
	tf = tf->argv[0];
else if (tfIsSubst(tf)(((tf)->tag) == TF_Subst))
	tf = tf->argv[0];
else if (tfIsTrigger(tf)(((tf)->tag) == TF_Trigger))
	libGetAllSymes(tfTriggerLib(tf));
else
	done = true1;
}
return tf;
7253}

7255TForm
7256tfFollowFn(TForm tf)
7257{
Bool	done = (tf == NULL((void*)0));

while (!done) {
if (tfIsForward(tf)(((tf)->tag) == TF_Forward))
	tf = tf->argv[0];
else if (tfIsSubst(tf)(((tf)->tag) == TF_Subst))
	tf = tfSubstPush(tf);
else if (tfIsTrigger(tf)(((tf)->tag) == TF_Trigger))
	libGetAllSymes(tfTriggerLib(tf));
else
	done = true1;
}
return tf;
7271}

7273TForm
7274tfFollowArg(TForm tf, Length i)
7275{
assert(!tfIsForward(tf))do { if (!(!(((tf)->tag) == TF_Forward))) _do_assert(("!tfIsForward(tf)"
),"tform.c",7276); } while (0);
if (i < tfArgc(tf)((tf)->argc)) {
tfArgv(tf)((tf)->argv)[i] = tfFollowOnly(tfArgv(tf)((tf)->argv)[i]);
return tfArgv(tf)((tf)->argv)[i];
}
else
return NULL((void*)0);
7283}

7285/*
* tfRaw
*/

7289localstatic Bool
7290tfIsRawMap(TForm tf)
7291{
return	tfIsMap(tf)(((tf)->tag) == TF_Map) && tfMapArgc(tf) == 1 &&
tfIsSelf(tfDefineeType(tfMapArgN(tf, int0)))(((((tfDefineeType(tfMapArgN(tf, ((int) 0))))->tag) == TF_General
) && ((((tfDefineeType(tfMapArgN(tf, ((int) 0))))->
__absyn))->abHdr.tag) == AB_Id) && (((tfDefineeType
(tfMapArgN(tf, ((int) 0))))->__absyn)->abId.sym) == (ssymSelf
));
7294}

7296TForm
7297tfRawType(TForm tf)
7298{
SymeList	sl;

for (sl = tfGetDomExports(tf); sl; sl = cdr(sl)((sl)->rest)) {
Syme	syme = car(sl)((sl)->first);
if (symeId(syme)((syme)->id) == symIntern("RawType")symProbe("RawType", 1 | 2) &&
    tfIsRawMap(symeType(syme)))
	return tfMapRet(symeType(syme))tfFollowArg(symeType(syme), 1);
}
return tf;
7308}

7310/*
* tfVariable
*/

7314TForm
7315tfSetVariable(TForm var, TForm val)
7316{
assert(tfIsVariable(var))do { if (!((((var)->tag) == TF_Variable))) _do_assert(("tfIsVariable(var)"
),"tform.c",7317); } while (0);
var->tag	= TF_Forward;
var->argv[0]	= val;
return var;
7321}

7323/*
* tfIf
*/

7327TForm
7328tfIf(TForm test, TForm thenAlt, TForm elseAlt)
7329{
TForm	tf;
tfFollow(test)((test) = tfFollowFn(test));
tfFollow(thenAlt)((thenAlt) = tfFollowFn(thenAlt));
tfFollow(elseAlt)((elseAlt) = tfFollowFn(elseAlt));
tf = tfNewNode(TF_If, 3, test, thenAlt, elseAlt);
return tf;
7336}

7338/*
* tfJoin
*/

7342TForm
7343tfJoin(Length argc, ...)
7344{
TForm	tf;
Length	i;
va_list argp;

tf = tfNewEmpty(TF_Join, argc);

va_start(argp, argc)__builtin_va_start(argp, argc);
for (i = 0; i < argc; i += 1)
tfArgv(tf)((tf)->argv)[i] = va_arg(argp, TForm)__builtin_va_arg(argp, TForm);
va_end(argp)__builtin_va_end(argp);

return tf;
7357}

7359TForm
7360tfJoinFrList(TFormList tl0)
7361{
Length		i, j, argc;
TFormList	tl;
TForm		tf;

for (tl = tl0, argc = 0; tl; tl = cdr(tl)((tl)->rest))
argc += tfIsJoin(car(tl))(((((tl)->first))->tag) == TF_Join) ? tfJoinArgc(car(tl))((((tl)->first))->argc) : 1;

tf = tfNewEmpty(TF_Join, argc);
for (tl = tl0, i = 0; tl; tl = cdr(tl)((tl)->rest))
if (tfIsJoin(car(tl))(((((tl)->first))->tag) == TF_Join))
	for (j = 0; j < tfJoinArgc(car(tl))((((tl)->first))->argc); j += 1)
		tfArgv(tf)((tf)->argv)[i++] = tfArgv(car(tl))((((tl)->first))->argv)[j];
else
	tfArgv(tf)((tf)->argv)[i++] = car(tl)((tl)->first);

tfSetMeaningArgs(tf);
assert(tfIsMeaning(tf))do { if (!((((tf)->state)>=TF_State_Meaning))) _do_assert
(("tfIsMeaning(tf)"),"tform.c",7378); } while (0);

return tf;
7381}

7383/*
* tfMeet
*/

7387TForm
7388tfMeet(Length argc, ...)
7389{
TForm	tf;
Length	i;
va_list argp;

tf = tfNewEmpty(TF_Meet, argc);

va_start(argp, argc)__builtin_va_start(argp, argc);
for (i = 0; i < argc; i += 1)
tfArgv(tf)((tf)->argv)[i] = va_arg(argp, TForm)__builtin_va_arg(argp, TForm);
va_end(argp)__builtin_va_end(argp);

return tf;
7402}

7404/*
* tfHas
*/

7408AbSyn
7409abHas(Syme syme, TForm tf)
7410{
return abNewHas(sposNone, abFrSyme(syme), tfExpr(tfDefineeType(tf)))abNew(AB_Has, sposNone,2, abFrSyme(syme),tfToAbSyn(tfDefineeType
(tf)));
7412}

7414TForm
7415tfHas(Syme syme, TForm tf)
7416{
return tfNewAbSyn(TF_General, abHas(syme, tf));
7418}

7420/*
* tfExcept
*/

7424TForm
7425tfExcept(TForm t, TForm e)
7426{
TForm tf;
tf = tfNewNode(TF_Except, 2, t, e);
tfSetMeaningArgs(tf);
return tf;
7431}

7433TForm
7434tfIgnoreExceptions(TForm tf)
7435{
tf = tfFollowOnly(tf);
if (tfIsExcept(tf)(((tf)->tag) == TF_Except))
return tfExceptType(tf)tfFollowArg(tf, 0);

return tf;
7441}

7443/*
* tfExtend
*/

7447localstatic TForm	tfJoinFlatten		       (TForm tf);

7449Bool
7450tfIsExtendTemplate(TForm tf)
7451{
if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare))
tf = tfDeclareType(tf)tfFollowArg(tf, 0);

return tfIsUnknown(tf)(((tf)->tag) == TF_Unknown) || tfIsUnknownMap(tf)(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && (((tfFollowArg(tf, 1))->tag) == TF_Unknown));
7456}

7458Bool
7459tfCanExtend(TForm tf, TForm tmpl)
7460{
Bool	result;

if (tfIsDeclare(tmpl)(((tmpl)->tag) == TF_Declare))
tmpl = tfDeclareType(tmpl)tfFollowArg(tmpl, 0);

if (tfIsAnyMap(tmpl)((((tmpl)->tag) == TF_Map) || (((tmpl)->tag) == TF_PackedMap
)))
result = tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && tfMapArgc(tf) == tfMapArgc(tmpl);

else
result = !tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
));

return result;
7473}

7475TForm
7476tfExtendEmpty(TForm tmpl, Length argc)
7477{
TForm	tf;

if (tfIsDeclare(tmpl)(((tmpl)->tag) == TF_Declare))
tmpl = tfDeclareType(tmpl)tfFollowArg(tmpl, 0);

if (tfIsAnyMap(tmpl)((((tmpl)->tag) == TF_Map) || (((tmpl)->tag) == TF_PackedMap
))) {
Length		i, targc = tfMapArgc(tmpl);
TForm		tfarg, tfret;

if (targc == 1)
	tfarg = tfNewEmpty(TF_Meet, argc);
else {
	tfarg = tfNewEmpty(TF_Multiple, targc);
	for (i = 0; i < targc; i += 1)
		tfArgv(tfarg)((tfarg)->argv)[i] = tfNewEmpty(TF_Meet, argc);
}
tfret = tfNewEmpty(TF_Join, argc);
tf = tfAnyMap(tfarg, tfret, tfIsPackedMap(tmpl)(((tmpl)->tag) == TF_PackedMap));
tfSetStab(tf, tfStab(tmpl))((tf)->stab = (((tmpl)->stab)));
}
else
tf = tfNewEmpty(TF_Join, argc);

return tf;
7502}

7504Length
7505tfExtendNext(TForm tf)
7506{
Length	i;

if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) tf = tfMapRet(tf)tfFollowArg(tf, 1);

for (i = 0; i < tfArgc(tf)((tf)->argc) && tfArgv(tf)((tf)->argv)[i]; i += 1) ;

return i;
7514}

7516#define			tfExtendCheck(tag,tf,i)(((tf)->tag) == (tag) && (i) < ((tf)->argc) &&
 ((tf)->argv)[i] == ((void*)0))	\
(tfTag(tf)((tf)->tag) == (tag) && (i) < tfArgc(tf)((tf)->argc) && tfArgv(tf)((tf)->argv)[i] == NULL((void*)0))

7519void
7520tfExtendFill(TForm tf, Length i, TForm ext)
7521{
if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) {
Length		j;

assert(tfIsAnyMap(ext))do { if (!(((((ext)->tag) == TF_Map) || (((ext)->tag) ==
 TF_PackedMap)))) _do_assert(("tfIsAnyMap(ext)"),"tform.c",7525
); } while (0);
assert(tfMapArgc(tf) == tfMapArgc(ext))do { if (!(tfMapArgc(tf) == tfMapArgc(ext))) _do_assert(("tfMapArgc(tf) == tfMapArgc(ext)"
),"tform.c",7526); } while (0);

/* Fill the arg types w/ the arg types from the extendees. */
for (j = 0; j < tfMapArgc(tf); j += 1) {
	TForm	tfj = tfMapArgN(tf, j);
	assert(tfExtendCheck(TF_Meet, tfj, i))do { if (!((((tfj)->tag) == (TF_Meet) && (i) < (
(tfj)->argc) && ((tfj)->argv)[i] == ((void*)0))
)) _do_assert(("tfExtendCheck(TF_Meet, tfj, i)"),"tform.c",7531
); } while (0);
	tfArgv(tfj)((tfj)->argv)[i] = tfMapArgN(ext, j);
}

/* Fill the ret types w/ the ret types from the extendees. */
assert(tfExtendCheck(TF_Join, tfMapRet(tf), i))do { if (!((((tfFollowArg(tf, 1))->tag) == (TF_Join) &&
 (i) < ((tfFollowArg(tf, 1))->argc) && ((tfFollowArg
(tf, 1))->argv)[i] == ((void*)0)))) _do_assert(("tfExtendCheck(TF_Join, tfMapRet(tf), i)"
),"tform.c",7536); } while (0);
tfArgv(tfMapRet(tf))((tfFollowArg(tf, 1))->argv)[i] = tfMapRet(ext)tfFollowArg(ext, 1);
}
else {
assert(tfExtendCheck(TF_Join, tf, i))do { if (!((((tf)->tag) == (TF_Join) && (i) < (
(tf)->argc) && ((tf)->argv)[i] == ((void*)0))))
 _do_assert(("tfExtendCheck(TF_Join, tf, i)"),"tform.c",7540)
; } while (0);
tfArgv(tf)((tf)->argv)[i] = ext;
}
7543}

7545TForm
7546tfExtendeeSubst(Stab stab, TForm tf, TForm tmpl)
7547{
Length		i;
AbSub		sigma;

if (tfIsDeclare(tmpl)(((tmpl)->tag) == TF_Declare))
tmpl = tfDeclareType(tmpl)tfFollowArg(tmpl, 0);
assert(tfIsAnyMap(tf) && tfIsAnyMap(tmpl) &&do { if (!(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && ((((tmpl)->tag) == TF_Map) || (((tmpl)->tag
) == TF_PackedMap)) && tfMapArgc(tf) == tfMapArgc(tmpl
))) _do_assert(("tfIsAnyMap(tf) && tfIsAnyMap(tmpl) && tfMapArgc(tf) == tfMapArgc(tmpl)"
),"tform.c",7554); } while (0)
      tfMapArgc(tf) == tfMapArgc(tmpl))do { if (!(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) && ((((tmpl)->tag) == TF_Map) || (((tmpl)->tag
) == TF_PackedMap)) && tfMapArgc(tf) == tfMapArgc(tmpl
))) _do_assert(("tfIsAnyMap(tf) && tfIsAnyMap(tmpl) && tfMapArgc(tf) == tfMapArgc(tmpl)"
),"tform.c",7554); } while (0);

/* Replace old parameter symes with new symes for the extendee. */
sigma = absNew(stab);
for (i = 0; i < tfMapArgc(tf); i += 1) {
Syme	osyme = tfDefineeSyme(tfMapArgN(tf, i));
Syme	nsyme = tfDefineeSyme(tfMapArgN(tmpl, i));

assert(osyme && nsyme)do { if (!(osyme && nsyme)) _do_assert(("osyme && nsyme"
),"tform.c",7562); } while (0);
sigma = absExtend(osyme, abFrSyme(nsyme), sigma);
}

tf = tformSubstSigma(sigma, tfMapRet(tf)tfFollowArg(tf, 1));
tmpl = tfMapRet(tmpl)tfFollowArg(tmpl, 1);
absFree(sigma);

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

return tf;
7574}

7576void
7577tfExtendSubst(Stab stab, TForm tf)
7578{
Length		i, j;
TForm		tfarg, tfret, ntf, ntfret;
AbSub		sigma;
SymeList	symes;

if (!tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))
return;

tfarg = tfMapArg(tf)tfFollowArg(tf, 0);
tfret = tfMapRet(tf)tfFollowArg(tf, 1);

assert(tfIsJoin(tfret) && tfJoinArgc(tfret) > 0)do { if (!((((tfret)->tag) == TF_Join) && ((tfret)
->argc) > 0)) _do_assert(("tfIsJoin(tfret) && tfJoinArgc(tfret) > 0"
),"tform.c",7590); } while (0);

/* Replace old parameter symes with new symes for the extension. */
assert(tfStab(tf))do { if (!(((tf)->stab))) _do_assert(("tfStab(tf)"),"tform.c"
,7593); } while (0);
sigma = absNew(tfStab(tf)((tf)->stab));
symes = listNil(Syme)((SymeList) 0);
for (j = 0; j < tfMapArgc(tf); j += 1) {
TForm	tfj = tfMapArgN(tf, j);
Syme	osyme = NULL((void*)0), nsyme;
AbSyn	ab;

assert(tfIsMeet(tfj) && tfMeetArgc(tfj) > 1)do { if (!((((tfj)->tag) == TF_Meet) && ((tfj)->
argc) > 1)) _do_assert(("tfIsMeet(tfj) && tfMeetArgc(tfj) > 1"
),"tform.c",7601); } while (0);

/* Create the new param syme from an extension param syme. */
for (i = 1; !osyme && i < tfMeetArgc(tfj)((tfj)->argc); i += 1)
	osyme = tfDefineeSyme(tfMeetArgv(tfj)((tfj)->argv)[i]);
assert(osyme)do { if (!(osyme)) _do_assert(("osyme"),"tform.c",7606); } while
 (0);
symeType(osyme);
nsyme = symeCopy(osyme);
symeSetLib(nsyme, NULL((void*)0));
symeSetHash(nsyme, (Hash) 0)(((nsyme)->hash) = ((Hash) 0));
ab = abFrSyme(nsyme);

for (i = 0; i < tfMeetArgc(tfj)((tfj)->argc); i += 1) {
	TForm	tfi = tfMeetArgv(tfj)((tfj)->argv)[i];
	Syme	syme = tfDefineeSyme(tfi);

	if (syme) {
		symeAddTwin(nsyme, syme);
		sigma = absExtend(syme, ab, sigma);
	}
}

symes = listCons(Syme)(Syme_listPointer->Cons)(nsyme, symes);
}
symes = listNReverse(Syme)(Syme_listPointer->NReverse)(symes);
tfSetSymes(tf, symes)((tf)->symes = (symes));

ntf = tformSubstSigma(sigma, tf);
absFree(sigma);

/* Replace old types with new types for the extension. */
tfFollow(ntf)((ntf) = tfFollowFn(ntf));
assert(tfIsAnyMap(ntf))do { if (!(((((ntf)->tag) == TF_Map) || (((ntf)->tag) ==
 TF_PackedMap)))) _do_assert(("tfIsAnyMap(ntf)"),"tform.c",7633
); } while (0);
for (j = 0; j < tfMapArgc(tf); j += 1) {
TForm	otfj = tfMapArgN(tf, j);
TForm	ntfj = tfMapArgN(ntf, j);

tfFollow(ntfj)((ntfj) = tfFollowFn(ntfj));
assert(tfIsMeet(ntfj) && tfMeetArgc(ntfj) == tfMeetArgc(otfj))do { if (!((((ntfj)->tag) == TF_Meet) && ((ntfj)->
argc) == ((otfj)->argc))) _do_assert(("tfIsMeet(ntfj) && tfMeetArgc(ntfj) == tfMeetArgc(otfj)"
),"tform.c",7639); } while (0);

for (i = 0; i < tfMeetArgc(otfj)((otfj)->argc); i += 1)
	tfMeetArgv(otfj)((otfj)->argv)[i] = tfMeetArgv(ntfj)((ntfj)->argv)[i];
tfSetFVars(otfj, NULL)(((otfj)->fv) = (((void*)0)));
}

ntfret = tfMapRet(ntf)tfFollowArg(ntf, 1);
tfFollow(ntfret)((ntfret) = tfFollowFn(ntfret));
assert(tfIsJoin(ntfret) && tfJoinArgc(ntfret) == tfJoinArgc(tfret))do { if (!((((ntfret)->tag) == TF_Join) && ((ntfret
)->argc) == ((tfret)->argc))) _do_assert(("tfIsJoin(ntfret) && tfJoinArgc(ntfret) == tfJoinArgc(tfret)"
),"tform.c",7648); } while (0);

for (i = 0; i < tfJoinArgc(tfret)((tfret)->argc); i += 1)
tfJoinArgv(tfret)((tfret)->argv)[i] = tfJoinArgv(ntfret)((ntfret)->argv)[i];
tfSetFVars(tfret, NULL)(((tfret)->fv) = (((void*)0)));
tfSetFVars(tf, NULL)(((tf)->fv) = (((void*)0)));
7654}

7656localstatic TForm
7657tfIsIdempotent(TForm tf)
7658{
TForm	tf0 = NULL((void*)0), tf1 = NULL((void*)0);
Length	i, argc;

assert(tfIsJoin(tf) || tfIsMeet(tf))do { if (!((((tf)->tag) == TF_Join) || (((tf)->tag) == TF_Meet
))) _do_assert(("tfIsJoin(tf) || tfIsMeet(tf)"),"tform.c",7662
); } while (0);

argc = tfArgc(tf)((tf)->argc);

for (i = 0; !tf1 && i < argc; i += 1) {
TForm	tfi = tfArgv(tf)((tf)->argv)[i];
if (tf0 == NULL((void*)0))
	tf0 = tfi;
else if (!tformEqual(tf0, tfi))
	tf1 = tfi;
}

if (tf0 == NULL((void*)0))
return tfArgv(tf)((tf)->argv)[0];
else if (tf1 == NULL((void*)0))
return tf0;
else
return NULL((void*)0);
7680}

7682localstatic void
7683tfForwardIdempotent(TForm tf, TForm ntf)
7684{
assert(tfIsJoin(tf) || tfIsMeet(tf))do { if (!((((tf)->tag) == TF_Join) || (((tf)->tag) == TF_Meet
))) _do_assert(("tfIsJoin(tf) || tfIsMeet(tf)"),"tform.c",7685
); } while (0);

tf->tag		= TF_Forward;
tf->argc	= 1;
tf->argv[0]	= ntf;
7690}

7692void
7693tfExtendFinish(TForm tf)
7694{
Length		i, j;
TForm		tfarg, tfret, ntfj;
SymeList	symes;

if (!tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) {
Stab	stab = NULL((void*)0);

assert(tfIsJoin(tf) && tfJoinArgc(tf) > 0)do { if (!((((tf)->tag) == TF_Join) && ((tf)->argc
) > 0)) _do_assert(("tfIsJoin(tf) && tfJoinArgc(tf) > 0"
),"tform.c",7702); } while (0);
for (j = tfJoinArgc(tf)((tf)->argc); !stab && j > 0; ) {
	TForm	tfj = tfJoinArgN(tf, --j)tfFollowArg(tf, --j);
	stab = tfGetStab(tfDefineeType(tfj));
	if (!stab && tfIsDefine(tfj)(((tfj)->tag) == TF_Define))
		stab = tfGetStab(tfDefineVal(tfj)tfFollowArg(tfj, 1));
}
if (!stab) stab = stabFile();

tf = tfJoinFlatten(tf);
tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);
for (symes = tfGetCatExports(tf); symes; symes = cdr(symes)((symes)->rest))
	tfExtendFinishTwins(stab, car(symes)((symes)->first));
return;
}

tfarg = tfMapArg(tf)tfFollowArg(tf, 0);
tfret = tfMapRet(tf)tfFollowArg(tf, 1);

assert(tfIsJoin(tfret) && tfJoinArgc(tfret) > 0)do { if (!((((tfret)->tag) == TF_Join) && ((tfret)
->argc) > 0)) _do_assert(("tfIsJoin(tfret) && tfJoinArgc(tfret) > 0"
),"tform.c",7721); } while (0);

for (j = tfMapArgc(tf); j > 0; ) {
TForm	tfj = tfMapArgN(tf, --j);
Syme	syme = NULL((void*)0);
Length	argc;

assert(tfIsMeet(tfj) && tfMeetArgc(tfj) > 0)do { if (!((((tfj)->tag) == TF_Meet) && ((tfj)->
argc) > 0)) _do_assert(("tfIsMeet(tfj) && tfMeetArgc(tfj) > 0"
),"tform.c",7728); } while (0);
argc = tfMeetArgc(tfj)((tfj)->argc);

/* If all args are the same, forward to the first. */
if ((ntfj = tfIsIdempotent(tfj)) != NULL((void*)0)) {
	tfForwardIdempotent(tfj, ntfj);
	tfSetMeaning(tfj)(((tfj)->state)=TF_State_Meaning);
	continue;
}

/* Otherwise conditionalize the ret types. */
for (i = 0; !syme && i < argc; i += 1)
	syme = tfDefineeSyme(tfMeetArgv(tfj)((tfj)->argv)[i]);
assert(syme)do { if (!(syme)) _do_assert(("syme"),"tform.c",7741); } while
 (0);
for (i = 0; i < tfJoinArgc(tfret)((tfret)->argc); i += 1) {
	TForm	tfi = tfJoinArgv(tfret)((tfret)->argv)[i];
	TForm	ifi = tfMeetArgv(tfj)((tfj)->argv)[i];
	ifi = tfDefineeType(ifi);
	if (tfIsType(ifi)(((ifi)->tag) == TF_Type))
		ifi = tfi;
	else
		ifi = tfIf(tfHas(syme, ifi), tfi, tfNone()tfMulti(0));
	tfJoinArgv(tfret)((tfret)->argv)[i] = ifi;
	tfSetMeaning(ifi)(((ifi)->state)=TF_State_Meaning);
}

/* ... and commute Meet v. Declare. */
ntfj = tfNewEmpty(TF_Meet, argc);
for (i = 0; i < argc; i += 1)
	tfArgv(ntfj)((ntfj)->argv)[i] = tfDefineeType(tfMeetArgv(tfj)((tfj)->argv)[i]);
tfSetMeaning(ntfj)(((ntfj)->state)=TF_State_Meaning);
symeSetUsedDeeply(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) |= (0x0004));
ntfj = tfDeclare(abFrSyme(syme), ntfj);
tfForwardIdempotent(tfj, ntfj);
tfSetMeaning(tfj)(((tfj)->state)=TF_State_Meaning);
}

tfret = tfJoinFlatten(tfret);

if ((ntfj = tfIsIdempotent(tfret)) != NULL((void*)0))
tfForwardIdempotent(tfret, ntfj);

tfSetMeaning(tfarg)(((tfarg)->state)=TF_State_Meaning);
tfSetMeaning(tfret)(((tfret)->state)=TF_State_Meaning);
tfSetMeaning(tf)(((tf)->state)=TF_State_Meaning);

assert(tfStab(tf))do { if (!(((tf)->stab))) _do_assert(("tfStab(tf)"),"tform.c"
,7774); } while (0);
for (symes = tfGetCatExports(tfret); symes; symes = cdr(symes)((symes)->rest))
tfExtendFinishTwins(tfStab(tf)((tf)->stab), car(symes)((symes)->first));
7777}

7779localstatic void
7780tfExtendFinishTwins(Stab stab, Syme syme)
7781{
SymeList	symes = symeTwins(syme);

if (syme == symeOriginal(syme)) return;
if (symeIsLazy(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0001))) symeType(syme);

if (!symeIsSelfSelf(syme)(((syme)->id) == ssymSelfSelf)) {
symeSetLib(syme, NULL((void*)0));
symeSetHash(syme, (Hash) 0)(((syme)->hash) = ((Hash) 0));
symeSetDefLevel(syme, car(stab)((stab)->first));
}
for (; symes; symes = cdr(symes)((symes)->rest)) {
Syme	twin = car(symes)((symes)->first);
if (twin != syme) tfExtendFinishTwins(stab, twin);
}
7796}

7798localstatic TForm
7799tfJoinFlatten(TForm tf)
7800{
TForm tf2;
int  argc, i, ii, j;

for (i=0, argc=0; i<tfJoinArgc(tf)((tf)->argc); i++) 
argc += tfIsJoin(tfJoinArgv(tf)[i])(((((tf)->argv)[i])->tag) == TF_Join) ? tfJoinArgc(tfJoinArgv(tf)[i])((((tf)->argv)[i])->argc) : 1;

if (argc == i) 
return tf;

tf2 = tfNewEmpty(TF_Join, argc);
for (i=0, j=0; i<tfJoinArgc(tf)((tf)->argc); i++) {
TForm tfi = tfJoinArgv(tf)((tf)->argv)[i];
if (!tfIsJoin(tfi)(((tfi)->tag) == TF_Join))
	tfJoinArgv(tf2)((tf2)->argv)[j++] = tfi;
else 
	for (ii=0; ii<tfJoinArgc(tfi)((tfi)->argc); ii++) 
		tfJoinArgv(tf2)((tf2)->argv)[j++] = tfJoinArgv(tfi)((tfi)->argv)[ii];
}
/* Forward tf to tf2 */
tfTag(tf)((tf)->tag) = TF_Forward;
tf->argc  = 1;
tf->argv[0] = tf2;
return tf2;
7824}


7827/*
* Given a symbol, return its unique tform or NULL if not possible.
* This is really only applicable for types where we can be certain
* of name uniqueness.
*/
7832TForm
7833tfFrSymbol(Symbol sym)
7834{
/* Get the meanings for this symbol */
SymeList symes  = stabGetMeanings(stabFile(), ablogFalse(), sym);


/* There can only be one ... */
if (symes && !cdr(symes)((symes)->rest))
return tiTopFns()->tiGetTopLevelTForm(ablogTrue(), abFrSyme(car(symes)((symes)->first)));
else
return (TForm)NULL((void*)0);
7844}


7847/*
* Return the tform for a functor symbol applied to an argument
* This is really only applicable for types where we can be certain
* of name uniqueness.
*/
7852TForm
7853tfFrSymbolPair(Symbol functor, Symbol argument)
7854{
/* Get the meanings for these symbols */
SymeList fsymes	= stabGetMeanings(stabFile(), ablogFalse(), functor);
SymeList asymes	= stabGetMeanings(stabFile(), ablogFalse(), argument);
AbSyn op	= abNewOfToken(AB_Id, tokId(sposNone, sposNone, functor)tokNew(sposNone, sposNone, TK_Id, functor));
AbSyn arg	= abNewOfToken(AB_Id, tokId(sposNone, sposNone, argument)tokNew(sposNone, sposNone, TK_Id, argument));
AbSyn ab	= abNewApply1(sposNone, op, arg)abNew(AB_Apply, sposNone,2, op,arg);


/*
* Construct a tform for the expression functor(arg).
* If we can't find meanings for either the functor or the
* argument symbols then they can't have been defined. We
* won't return tforms for this pair otherwise the type
* inference phase of tiGetTForm() below will scream. This
* is to allow libraries to be defined which don't necessarily
* have the requested value defined anywhere.
*/
if (!fsymes || !asymes)
return tfUnknown; /* Please don't return (TForm)NULL */
else
return tiTopFns()->tiGetTopLevelTForm(ablogTrue(), ab);
7876}

7878/*****************************************************************************
*
* :: Types of operations used in syntactic sugar
*
****************************************************************************/

7884/*
* LitOpType
*/

7888Bool
7889tfIsLitOpType(TForm tf)
7890{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) &&
      tfMapArgc(tf) == 1 &&
      tfEqual(tfMapArgN(tf, int0((int) 0)), tfLiteral);
7895}

7897TForm
7898tfLitOpTypeRet(TForm tf)
7899{
tfFollow(tf)((tf) = tfFollowFn(tf));
if (!tfIsLitOpType(tf))
bug("tfLitOpTypeRet:  !tfIsLitOpType(tf)");

return tfMapRet(tf)tfFollowArg(tf, 1);
7905}

7907/*
* TestOpType
*/

7911Bool
7912tfIsTestOpType(TForm tf)
7913{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) &&
      tfMapArgc(tf) == 1 &&
      tfEqual(tfMapRet(tf)tfFollowArg(tf, 1), tfTest);
7918}

7920TForm
7921tfTestOpTypeArg(TForm tf)
7922{
tfFollow(tf)((tf) = tfFollowFn(tf));
if (!tfIsTestOpType(tf))
bug("tfTestOpTypeArg:  !tfIsTestOpType(tf)");

return tfMapArg(tf)tfFollowArg(tf, 0);
7928}

7930/*
* GeneratorOpType
*/

7934Bool
7935tfIsGeneratorOpType(TForm tf)
7936{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) &&
tfIsGenerator(tfMapRet(tf))(((tfFollowArg(tf, 1))->tag) == TF_Generator);
7940}

7942Bool
7943tfIsXGeneratorOpType(TForm tf)
7944{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)) &&
tfIsXGenerator(tfMapRet(tf))(((tfFollowArg(tf, 1))->tag) == TF_XGenerator);
7948}

7950TForm
7951tfGeneratorOpTypeArg(TForm tf)
7952{
tfFollow(tf)((tf) = tfFollowFn(tf));
if (!tfIsGeneratorOpType(tf))
bug("tfGeneratorOpTypeArg:  !tfIsGeneratorOpType(tf)");

return tfMapArg(tf)tfFollowArg(tf, 0);
7958}

7960TForm
7961tfXGeneratorOpTypeArg(TForm tf)
7962{
tfFollow(tf)((tf) = tfFollowFn(tf));
if (!tfIsXGeneratorOpType(tf))
bug("tfXGeneratorOpTypeArg:  !tfIsXGeneratorOpType(tf)");

return tfMapArg(tf)tfFollowArg(tf, 0);
7968}

7970TForm
7971tfGeneratorOpTypeRet(TForm tf)
7972{
tfFollow(tf)((tf) = tfFollowFn(tf));
if (!tfIsGeneratorOpType(tf))
bug("tfGeneratorOpTypeRet:  !tfIsGeneratorOpType(tf)");

return tfGeneratorArg(tfMapRet(tf))tfFollowArg(tfFollowArg(tf, 1), 0);
7978}

7980TForm
7981tfXGeneratorOpTypeRet(TForm tf)
7982{
tfFollow(tf)((tf) = tfFollowFn(tf));
if (!tfIsXGeneratorOpType(tf))
bug("tfXGeneratorOpTypeRet:  !tfIsXGeneratorOpType(tf)");

return tfXGeneratorArg(tfMapRet(tf))tfFollowArg(tfFollowArg(tf, 1), 0);
7988}

7990TForm
7991tfXGenerator(TForm arg)
7992{
TForm	tf = tfNewNode(TF_XGenerator, 1, arg);
tfSetMeaningArgs(tf);
return tf;
7996}

7998TForm
7999tfAnyGenerator(TfGenType type, TForm tf)
8000{
switch (type) {
case TFG_Generator:
return tfGenerator(tf);
case TFG_XGenerator:
return tfXGenerator(tf);
default:
assert(false)do { if (!(((int) 0))) _do_assert(("false"),"tform.c",8007); }
 while (0);
}
return NULL((void*)0);
8010}

8012Bool
8013tfIsAnyGenerator(TForm tf)
8014{
return tfIsGenerator(tf)(((tf)->tag) == TF_Generator)
|| tfIsXGenerator(tf)(((tf)->tag) == TF_XGenerator);
8017}

8019TfGenType
8020tfAnyGeneratorType(TForm tf)
8021{
assert(tfIsAnyGenerator(tf))do { if (!(tfIsAnyGenerator(tf))) _do_assert(("tfIsAnyGenerator(tf)"
),"tform.c",8022); } while (0);
return tfIsGenerator(tf)(((tf)->tag) == TF_Generator) ? TFG_Generator : TFG_XGenerator;
8024}

8026TForm
8027tfAnyGeneratorArg(TForm tf)
8028{
if (tfIsGenerator(tf)(((tf)->tag) == TF_Generator))
return tfGeneratorArg(tf)tfFollowArg(tf, 0);
else if (tfIsXGenerator(tf)(((tf)->tag) == TF_XGenerator))
return tfXGeneratorArg(tf)tfFollowArg(tf, 0);
else
bug("tfIsGeneratorArg: Not reached");
8035}

8037/*
Usage
*/

8041Bool
8042abUseIsDContext(AbSyn ab)
8043{
return	abUse(ab)((ab)->abHdr.use) == AB_Use_NoValue ||
abUse(ab)((ab)->abHdr.use) == AB_Use_Type ||
abUse(ab)((ab)->abHdr.use) == AB_Use_Declaration;
8047}

8049Bool
8050tfIsTypeTuple(TForm tf)
8051{
return tfIsTuple(tf)(((tf)->tag) == TF_Tuple) && tfIsType(tfTupleArg(tf))(((tfFollowArg(tf, 0))->tag) == TF_Type);
8053}

8055Bool
8056tfIsCategoryContext(TForm tf, AbSyn ab)
8057{
if (tfIsUnknown(tf)(((tf)->tag) == TF_Unknown) || tfIsNone(tf)((((tf)->tag) == TF_Multiple) && tfMultiArgc(tf) ==
 0))
return false((int) 0);

if (tfIsCategory(tf)(((tf)->tag) == TF_Category) || tfIsTypeTuple(tf))
return true1;

if (abUseIsDContext(ab))
return tfSatCat(tf) || tfSatisfies(tf, tfTypeTuple);

return false((int) 0);
8068}

8070Bool
8071tfIsNoValueContext(TForm tf, AbSyn ab)
8072{
return	abUseIsDContext(ab) ||
tfIsNone(tf)((((tf)->tag) == TF_Multiple) && tfMultiArgc(tf) ==
 0) ||
tfIsUnknown(tf)(((tf)->tag) == TF_Unknown);
8076}

8078/******************************************************************************
*
* :: Implict category stuff
*
*****************************************************************************/

8084TForm tfImplPAOps = (TForm)NULL((void*)0); /* DenseStorageCategory */

8086void
8087tfInitImplicit(void)
8088{
static	Bool	isInit = false((int) 0);

if (isInit) return;


/* Start with the easy one */
tfImplPAOps = tfFrSymbol(ssymImplPAOps);
8096}


8099TForm
8100tfCatFrDom(TForm tf)
8101{
/* Walk past the declaration to get the type */
if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare))
 tf = tfDeclareType(tf)tfFollowArg(tf, 0);


/* Do we have the absyn for this domain? */
if (!tfHasExpr(tf)((tf)->__absyn != 0))
return (TForm)NULL((void*)0);


/* Return the category of this domain (if possible) */
return abGetCategory((AbSyn)tfGetExpr(tf)((tf)->__absyn));
8114}


8117Bool
8118tfDomHasImplicit(TForm tf)
8119{
TForm	tfcat = tfCatFrDom(tf);


/* Did we manage to get the category? */
if (!tfcat) return false((int) 0);


/* Ensure that we have the necessary tforms available */
tfInitImplicit();


/* Paranoia - do we have the required tform? */
if (!tfImplPAOps || tfIsUnknown(tfImplPAOps)(((tfImplPAOps)->tag) == TF_Unknown)) return false((int) 0);


/* Does this domain satisfy the category? */
return tfSatBit(tfSatHasMask(), tfcat, tfImplPAOps);
8137}


8140Bool
8141tfCatHasImplicit(TForm tf)
8142{
/* Walk past the declaration to get the type */
if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare))
tf = tfDeclareType(tf)tfFollowArg(tf, 0);


/* Ensure that we have the necessary tforms available */
tfInitImplicit();


/* Paranoia - do we have the required tform? */
if (!tfImplPAOps || tfIsUnknown(tfImplPAOps)(((tfImplPAOps)->tag) == TF_Unknown)) return false((int) 0);


/* Does this domain satisfy the category? */
return tfSatBit(tfSatHasMask(), tf, tfImplPAOps);
8158}


8161/*
* If this syme is one of the correct exports then return it
* otherwise return nothing.
*/
8165Syme
8166tfImplicitExport(Stab stab, SymeList mods, Syme syme)
8167{
Syme		nsyme = (Syme)NULL((void*)0);
SymeList	isymes;
Symbol		sym = symeId(syme)((syme)->id);
TForm		tf = symeType(syme);


/* Ensure that the necessary tforms are available */
tfInitImplicit();


/* Paranoia - do we have the required tform? */
if (!tfImplPAOps || tfIsUnknown(tfImplPAOps)(((tfImplPAOps)->tag) == TF_Unknown)) return nsyme;
1
Assuming 'tfImplPAOps' is non-null→
2
←
Assuming field 'tag' is not equal to TF_Unknown→
3
←
Taking false branch→


/* Extract the symes that we are looking for */
isymes = tfGetCatExports(tfImplPAOps);
4
←
Calling 'tfGetCatExports'→


/* Check to see if it is in the list */
for (; isymes; isymes = cdr(isymes)((isymes)->rest))
{
Syme xsyme = car(isymes)((isymes)->first);

if (symeId(xsyme)((xsyme)->id) != sym) continue;
if (!tformEqualMod(mods, symeType(xsyme), tf)) continue;

8194#if STAB_DEF_IMPLICIT
syme = stabDefExport(stab, sym, tf, (Doc)NULL((void*)0));
8196#endif
return syme; /* not xsyme ... */
}


/* Not one of the implicit packed array operations */
return nsyme;
8203}

8205/*********************************
* 
* :: Conditions
*
*********************************/
8210extern void   
8211tfMergeConditions(TForm tf, Stab stab, TfCondElt conditions)
8212{
if (DEBUG(tf)tfDebug) {
if (conditions != NULL((void*)0))
	afprintf(dbOut, "Merge condition %pAbSynList to %pTForm\n", 
		 conditions->list, tf);
}
tfSetConditions(tf, tfCondMerge(tfConditions(tf), stab, conditions))(tf->conditions = (tfCondMerge(tfConditions(tf), stab, conditions
)));
8219}

8221extern TfCond tfFloatConditions(Stab stab, TForm tf)
8222{
if (tfConditions(tf) != NULL((void*)0)) {
TfCond cond = tfCondFloat(stab, tfConditions(tf));
tfSetConditions(tf, cond)(tf->conditions = (cond));
}

return tfConditions(tf);
8229}

8231extern 
8232TfCond tfConditions(TForm tf)
8233{
tfFollow(tf)((tf) = tfFollowFn(tf));
return tf->conditions;
8236}


8239AbSynList
8240tfConditionalAbSyn(TForm tf)
8241{
if (tfConditions(tf) == NULL((void*)0))
return listNil(AbSyn)((AbSynList) 0);
if (tfConditions(tf)->containsEmpty) 
return listNil(AbSyn)((AbSynList) 0);
if (tfConditions(tf)->conditions == listNil(TfCondElt)((TfCondEltList) 0))
return listNil(AbSyn)((AbSynList) 0);

if (DEBUG(tf)tfDebug) {
TfCondEltList list;
list = tfConditions(tf)->conditions;
while (list != listNil(TfCondElt)((TfCondEltList) 0)) {
	afprintf(dbOut, "Condition: %pTForm %pAbSynList\n", tf, car(list)((list)->first)->list);
	list = cdr(list)((list)->rest);
};
}
return tfConditions(tf)->conditions->first->list;
8258}

8260Stab
8261tfConditionalStab(TForm tf)
8262{
if (tfConditions(tf) == NULL((void*)0))
return NULL((void*)0);
if (tfConditions(tf)->containsEmpty) 
return NULL((void*)0);

return tfConditions(tf)->conditions->first->stab;
8269}

8271/******************************************************************************
*
* :: Java
*
*****************************************************************************/
8276localstatic Bool tfCheckJavaImport(ErrorSet errors, TForm tf);
8277localstatic Bool tfJavaCheckArg(ErrorSet errors, Stab stab, TForm self, TForm arg);
8278localstatic Bool abCheckJavaImport(ErrorSet errors, AbSyn ab);
8279localstatic Bool abCheckJavaImportId(ErrorSet errors, AbSyn id);
8280localstatic Bool abIsJavaImportId(AbSyn id);
8281localstatic Bool abIsJavaImportId(AbSyn id);

8283Bool
8284tfIsJavaImport(TForm tf)
8285{
tfFollow(tf)((tf) = tfFollowFn(tf));

if (tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Id))
return abIsJavaImportId(tfExpr(tf)tfToAbSyn(tf));
else if (tfIsApply(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn
))->abHdr.tag) == AB_Apply) && abIsId(tfExpr(tf)->abApply.op)((tfToAbSyn(tf)->abApply.op)->abHdr.tag == (AB_Id))) {
return abIsJavaImportId(tfExpr(tf)tfToAbSyn(tf)->abApply.op);
}
return false((int) 0);
8294}

8296localstatic Bool
8297abIsJavaImportId(AbSyn id)
8298{
Syme syme = abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0);
if (syme == NULL((void*)0))
return false((int) 0);
return symeIsForeign(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Foreign) && symeForeign(syme)((ForeignOrigin) (SYFI_Foreign < (8 * sizeof(int)) &&
 !(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)
->lib) : ((void*)0)), (syme))->hasmask) & (1 <<
 (SYFI_Foreign))) ? (symeFieldInfo[SYFI_Foreign].def) : (((((
syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib
) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Foreign
))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((
syme)->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_Foreign))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Foreign
)] : (symeFieldInfo[SYFI_Foreign].def)) : symeGetFieldFn(syme
,SYFI_Foreign)))->protocol == FOAM_Proto_Java;
8303}

8305localstatic Bool
8306tfCheckJavaImport(ErrorSet errors, TForm tf)
8307{
Syme syme;
tfFollow(tf)((tf) = tfFollowFn(tf));

if (!tfIsGeneral(tf)(((tf)->tag) == TF_General))
return false((int) 0);

return abCheckJavaImport(errors, tfExpr(tf)tfToAbSyn(tf));
8315}

8317localstatic Bool
8318abCheckJavaImport(ErrorSet errors, AbSyn ab)
8319{
Bool ret = false((int) 0);

if (abIsId(ab)((ab)->abHdr.tag == (AB_Id))) {
ret = abCheckJavaImportId(errors, ab);
}
else if (abHasTag(ab, AB_Apply)((ab)->abHdr.tag == (AB_Apply))) {
AbSyn op = ab->abApply.op;
if (abCheckJavaImportId(errors, op)) {
	int i;
	ret = true1;
	for (i=0; ret && i<abApplyArgc(ab)(((ab)->abHdr.argc)-1); i++) {
		ret = abCheckJavaImport(errors, abApplyArg(ab, i)((ab)->abApply.argv[i]));
	}
}
}

return ret;
8337}

8339localstatic Bool
8340abCheckJavaImportId(ErrorSet errors, AbSyn id)
8341{
Syme syme = abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0);
Bool ret = true1;;
if (!errorSetPrintf(errors, abIsJavaImportId(id),
	    "%pAbSyn is not a valid java type\n", id)) {
ret = false((int) 0);
}
afprintf(dbOut, "CheckJavaImportId: %pAbSyn %d\n", id, ret);

return ret;
8351}

8353Bool
8354tfJavaCanExport(Stab stab, TForm self, TForm tf)
8355{
Bool result = true1;

tfFollow(tf)((tf) = tfFollowFn(tf));

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) {
return false((int) 0);
}
ErrorSet errorSink = errorSetNew();
tfJavaCheckArgs(errorSink, stab, self, tfMapArg(tf)tfFollowArg(tf, 0));
tfJavaCheckArgs(errorSink, stab, self, tfMapRet(tf)tfFollowArg(tf, 1));

if (errorSetHasErrors(errorSink)) {
result = false((int) 0);
}
errorSetFree(errorSink);

return result;
8373}


8376Bool
8377tfJavaCheckArgs(ErrorSet errors, Stab stab, TForm self, TForm tf)
8378{
Length argc;
Bool flg = true1;
int i;

tfFollow(tf)((tf) = tfFollowFn(tf));

tf = tfIgnoreExceptions(tf);
argc = tfAsMultiArgc(tf);
for (i=0; i<argc; i++) {
TForm arg = tfAsMultiArgN(tf, argc, i);
SymeList sl;

if (!errorSetPrintf(errors, !tfIsNotDomain(arg)((((arg)->tag) == TF_Type) || (((arg)->tag) == TF_With)
 || ((((arg)->tag) == TF_Syntax) && ((((arg)->__absyn
))->abHdr.tag == (AB_With))) || (((arg)->tag) == TF_Join
) || (((arg)->tag) == TF_If) || (((arg)->tag) == TF_Third
)), "Position %d must be a domain", i)) {
	flg = false((int) 0);
	continue;
}
flg = flg && tfJavaCheckArg(errors, stab, self, arg);
}

return flg;
8399}

8401localstatic Bool
8402tfJavaCheckArg(ErrorSet errors, Stab stab, TForm self, TForm arg)
8403{
Syme enc, dec;
Bool flg = true1;

arg = tfIgnoreExceptions(arg);

if (tfIsSelf(arg)(((((arg)->tag) == TF_General) && ((((arg)->__absyn
))->abHdr.tag) == AB_Id) && (((arg)->__absyn)->
abId.sym) == (ssymSelf)))
return true1;
if (tfIsJavaImport(arg))
return true1;
if (self && tfEqual(self, arg))
return true1;
if (stabIsForeignExport(stab, arg))
return true1;

if (tfHasSelf(arg)((arg)->hasSelf) && tfIsId(arg)((((arg)->tag) == TF_General) && ((((arg)->__absyn
))->abHdr.tag) == AB_Id) && symeExtension(tfIdSyme(arg)((((arg)->__absyn))->abHdr.seman ? (((arg)->__absyn)
)->abHdr.seman->syme : 0))) {
arg = tfFrSyme(stabFile(), symeExtensionFull(tfIdSyme(arg)((((arg)->__absyn))->abHdr.seman ? (((arg)->__absyn)
)->abHdr.seman->syme : 0)));
}

enc = tfGetDomExport(arg, symString(ssymTheToJava)((ssymTheToJava)->str), tfIsJavaEncoder);
dec = tfGetDomExport(arg, symString(ssymTheFromJava)((ssymTheFromJava)->str), tfIsJavaDecoder);
if (!errorSetPrintf(errors, dec != NULL((void*)0), "The domain %s must export toJava: %% -> ?",
	    abPretty(tfExpr(arg)tfToAbSyn(arg))))
flg = false((int) 0);
if (!errorSetPrintf(errors, enc != NULL((void*)0), "The domain %s must export fromJava: ? -> %%",
	    abPretty(tfExpr(arg)tfToAbSyn(arg))))
flg = false((int) 0);
return true1;
8431}


8434Bool
8435tfIsJavaEncoder(TForm tf)
8436{
tfFollow(tf)((tf) = tfFollowFn(tf));
/* Should be looking for % -> builtin */
if (!tfIsMap(tf)(((tf)->tag) == TF_Map))
return false((int) 0);
if (!tfIsSelf(tfMapArg(tf))(((((tfFollowArg(tf, 0))->tag) == TF_General) && (
(((tfFollowArg(tf, 0))->__absyn))->abHdr.tag) == AB_Id)
 && (((tfFollowArg(tf, 0))->__absyn)->abId.sym)
 == (ssymSelf)))
return false((int) 0);
return true1;
8444}

8446Bool
8447tfIsJavaDecoder(TForm tf)
8448{
tfFollow(tf)((tf) = tfFollowFn(tf));

if (!tfIsMap(tf)(((tf)->tag) == TF_Map))
return false((int) 0);
if (!tfIsSelf(tfMapRet(tf))(((((tfFollowArg(tf, 1))->tag) == TF_General) && (
(((tfFollowArg(tf, 1))->__absyn))->abHdr.tag) == AB_Id)
 && (((tfFollowArg(tf, 1))->__absyn)->abId.sym)
 == (ssymSelf)))
return false((int) 0);
if (tfMapRetc(tf) != 1)
return false((int) 0);
return true1;
8458}

8460/******************************************************************************
*
* :: Table of information about type form tags
*
*****************************************************************************/

8466#define	 TF_NARY(-1)	(-1)	/* Identifies tags with N-ary data argument. */

8468struct tform_info tformInfoTable[] = {

/* Special type form symbols */
{TF_Unknown,	"Unknown",      "Unknown",      0, 0},
{TF_Exit,	"Exit",         "Exit",         0, 0},
{TF_Literal,	"Literal",      "Literal",      0, 0},
{TF_Test,	"Test",         "Test",         0, 0},
{TF_Type,	"Type",         "Type",         0, 0},
{TF_Category,	"Category",     "Category",     0, 0},

/* Type forms described by abstract syntax */
{TF_Syntax,	"Syntax",       "Syntax",       0, 0},
{TF_General,	"General",      "General",      0, 0},

/* Type forms described by subordinate type forms */
{TF_Add,	"Add",          "Add",          0, 0},
{TF_Assign,	"Assign",       ":=",           0, 1},
{TF_Cross,	"Cross",        "Cross",        0, TF_NARY(-1)},
{TF_Declare,	"Declare",      ":",            0, 1},
{TF_Default,	"Default",      "==",           0, 2},
{TF_Define,	"Define",       "==",           0, 2},
{TF_Enumerate,	"Enumeration",  "Enumeration",  0, 1},
{TF_Forward,	"Forward",      "Forward",      0, 1},
{TF_Generator,	"Generator",    "Generator",    0, 1},
{TF_If,		"If",           "If",           0, 3},
{TF_Instance,	"Instance",     "Instance",     0, 2},
{TF_Join,	"Join",         "Join",         0, TF_NARY(-1)},
{TF_Map,	"Map",          "->",           0, 2},
{TF_Meet,	"Meet",         "Meet",         0, TF_NARY(-1)},
{TF_Multiple,	"Multiple",	"Multiple",     0, TF_NARY(-1)},
{TF_PackedMap,	"PackedMap",	"->*",          0, 2},
{TF_Raw,	"Raw",		"Raw",          0, 1},
{TF_RawRecord,	"RawRecord",    "RawRecord",    0, 0},
{TF_Record,	"Record",       "Record",       0, 0},
{TF_Reference,	"Reference",    "Ref",		0, 1},
{TF_Subst,	"Subst",        "Subst",        0, 1},
{TF_Third,	"Third",        "Third",        0, 2},
{TF_Trigger,	"Trigger",      "Trigger",      0, 1},
{TF_TrailingArray,"TrailingArray",    "TrailingArray",0, 1},
{TF_Tuple,	"Tuple",        "Tuple",        0, 1},
{TF_Union,	"Union",        "Union",        0, 0},
{TF_Variable,	"Variable",     "Variable",     0, 1},
{TF_With,	"With",         "With",         0, 2},
{TF_Except,	"Except",       "Except",       0, 2},
{TF_XGenerator,	"XGenerator",   "XGenerator",   0, 1},

{TF_LIMIT,	"LIMIT",        "LIMIT",        0, 0}
8515};