gf_add.c

Bug Summary

File:	src/gf_add.c
Warning:	line 331, column 7 Dereference of 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 gf_add.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 gf_add.c
1/*****************************************************************************
*
* gf_add.c: Foam code generation for "add", "with", and default packages.
*
* Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
*
****************************************************************************/

9#include "debug.h"
10#include "fluid.h"
11#include "genfoam.h"
12#include "gf_util.h"
13#include "gf_prog.h"
14#include "gf_add.h"
15#include "gf_imps.h"
16#include "gf_rtime.h"
17#include "gf_seq.h"
18#include "of_util.h"
19#include "optinfo.h"
20#include "spesym.h"
21#include "stab.h"
22#include "store.h"
23#include "util.h"
24#include "sefo.h"
25#include "lib.h"
26#include "tfsat.h"
27#include "ablogic.h"
28#include "abpretty.h"
29#include "comsg.h"
30#include "strops.h"
31#include "table.h"
32#include "ti_top.h"

34localstatic Foam         gen0AddBody1           (AbSyn, Stab, AbSyn);
35localstatic void         gen0AddImportedDomain  (TForm, Foam, AInt);
36localstatic Foam         gen0CombineHash        (Foam hash1, Foam hash2);
37localstatic AbSyn        gen0FindDefaults       (AbSyn with);
38localstatic Foam         gen0GetDomainDomain    (TForm);
39localstatic Foam	   gen0MakeDefaultHash	  (void);
40localstatic Foam	   gen0RtDomainHash	  	(Foam);
41localstatic void	   gen0MakeDomainSelf	  (void);
42localstatic void	   gen0TypeAddDefaultSelfSlot	(void);
43localstatic void	   gen0MakeDomainDefaults (Foam);
44localstatic void	   gen0MakeCategoryParents(AbSyn);
45localstatic int	   gen0MakeCatParents0	  (AbSyn, Foam, int);
46localstatic int	   gen0MakeCatParentsIf	  (AbSyn, Foam, int);
47localstatic void         gen0MakeDomainParents  (AbSyn);
48localstatic void         gen0MakeTypeParents	  (Length, AbSyn *, String, AbSyn);
49localstatic void	   gen0MakeTypeParent	  (AbSyn, Length, Foam, AbSyn);

51localstatic void	   gen0TypeInitDomain	  (AbSyn, AbSyn);
52localstatic void	   gen0TypeInitDefaults	  (void);
53localstatic ExportState  gen0TypeInit		  (void);
54localstatic void	   gen0TypeOpen		  (Foam, String);
55localstatic void	   gen0TypeFini 	  (void);
56localstatic Foam	   gen0MakeTypeExportMap  (SymeList);

58localstatic Foam 	   gen0BuildExporterName  (AbSyn exporter);
59localstatic Foam         gen0SeenImportedDomain (TForm, AInt);
60localstatic void         gen0SetInitUsage       (Foam, AInt);

62localstatic AbSynList    gen0CollectAux	  (AbSyn);
63localstatic AbSyn	   gen0CollectWithImports (AbSyn);

65localstatic Foam	   gen0Join			(AbSyn);
66localstatic Foam 	   gen0Map		     	(AbSyn);
67localstatic Foam 	   gen0Enum		     	(AbSyn);
68localstatic Foam	   gen0ApplySpecialOthers	(AbSyn);
69localstatic Bool	   gen0AllSymesAllocated	(AbSyn);

71localstatic Foam 	   gen0RtTypeHash		(TForm, TForm);
72localstatic Foam 	   gen0RtTypeHashWith		(TForm, TForm, String);
73localstatic Foam	   gen0RtSefoHashExporter 	(Sefo);
74localstatic Foam	   gen0RtSefoHash		(Sefo, Sefo);

76localstatic void 	   gen0InitExports	     (void);
77localstatic void 	   gen0InitConditionalExport (Syme);
78localstatic SymeList 	   gen0AddExportedSymes	     (void);
79localstatic Foam 	   gen0HasJoin		     (Foam, int, AbSyn *);
80localstatic Foam 	   gen0HasCat		     (Foam, AbSyn);
81localstatic Foam 	   gen0HasCatBit	     (Foam, AbSyn);
82localstatic Foam 	   gen0HasImports	     (Foam, SymeList, Foam);
83localstatic Foam 	   gen0HasImport	     (Foam, Syme);

85localstatic void	   gen0StrRegister	     (int, String);

87static ExportState 	gen0ExportState;
88static Foam		gen0HasSelf;

90Bool	genfExportDebug = false((int) 0);
91Bool	gfaddDebug	= false((int) 0);

93#define genfExportDEBUGif (!genfExportDebug) { } else afprintf		DEBUG_IF(genfExport)if (!genfExportDebug) { } else	afprintf
94#define gfaddDEBUGif (!gfaddDebug) { } else afprintf		DEBUG_IF(gfadd)if (!gfaddDebug) { } else		afprintf

96localstatic void
97gen0ClashCheck(AbSyn ab)
98{
Foam stmt, rhs;
Foam seentab, arg1, arg2, arg3, arg4;
TForm dom = abTForm(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->tform : 0);
/* Check ALL exports of this domain ... */
SymeList symes = dom ? tfGetDomExports(dom) : 0;
AbSyn exporter = gen0ProgGetExporter();
String exp = exporter ? abPretty(exporter) : "(unknown)";
long nelts = listLength(Syme)(Syme_listPointer->_Length)(symes);

/* seentab = fiNewExportTable() */
seentab = gen0TempLocal(FOAM_Word)gen0TempLocal0(FOAM_Word, 4);
rhs = foamNew(FOAM_BCall, 3, FOAM_BVal_NewExportTable,
	gen0CharArray(exp), foamNewSInt(nelts)foamNew(FOAM_SInt, 1, (AInt)(nelts)));
stmt = foamNewSet(seentab, rhs)foamNew(FOAM_Set, 2, seentab, rhs);
gen0AddStmt(stmt, ab);

/* Add each export to the table (may generate runtime warning) */
for (; symes; symes = cdr(symes)((symes)->rest)) {
Syme syme = car(symes)((symes)->first);
TForm tf = symeType(syme);
String str = symString(symeId(syme))((((syme)->id))->str);
String tfp = tfPretty(tf);

arg1 = foamNewSInt(gen0StrHash(str))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(str)));
arg2 = gen0TypeHash(tf, tf, str);
arg3 = gen0CharArray(str);
arg4 = gen0CharArray(tfp);
strFree(tfp);
stmt = foamNew(FOAM_BCall, 6, FOAM_BVal_AddToExportTable,
		foamCopy(seentab), arg1, arg2, arg3, arg4);
gen0AddStmt(stmt, ab);
}


/* fiFreeExportTable() */
stmt = foamNew(FOAM_BCall, 2, FOAM_BVal_FreeExportTable,
	foamCopy(seentab));
gen0AddStmt(stmt, ab);
137}


140/*
* Create a getter function for a package.
*/

144Foam
145genAdd(AbSyn absyn)
146{
      foamProgSetGetter(gen0State->program)((gen0State->program)->foamProg.infoBits |= (1 <<
 3));
      return gen0AddBody0(absyn, abStab(absyn)((absyn)->abHdr.seman ? (absyn)->abHdr.seman->stab :
 0), tfExpr(gen0AbType(absyn))tfToAbSyn(gen0AbType(absyn)));
149}

151/*
* This function generates code for add bodies.  
*
* A domain is represented by an Aldor record.  See axllib/runtime.as
* for the detail of domain representation.  When first created, domains
* contain only a single function, that, when called fills in the hash code
* for the domain, and another function.  When the second function is called,
* the domain get fully instantiated, and all the export slots are filled.
* This is all done in a lazy way, so that requestors of information from a
* domain need not worry about it.  Gen0AddBody0 creates this first function,
* and gen0AddBody1 creates the second.
*
* The arguments:
*      base: The left hand side of the add or with being processed, this
*              is the parent of the domain or category.
*      body: This is the code to be run when instantiating the type.
*      stab: The symbol table for the body.
*      defaultsAb: AbSyn for the defaults package.
*
*/

172Foam
173gen0AddBody0(AbSyn ab, Stab stab, AbSyn defaultsAb)
174{
AbSyn		body = ab->abAdd.capsule;
AInt		index;
      Foam            foam, clos;
Length		argc = 1;
String		argv[1];

argv[0] = "domain";

clos = gen0ProgClosEmpty();
foam = gen0ProgInitEmpty("addLevel0", NULL((void*)0));

index = gen0FormatNum;
      gen0ProgPushState(stab, GF_Add0);

if (genIsRuntime()(gen0IsRuntime))
gen0Vars(stab);
else
gen0ProgAddParams(argc, argv);

      gen0PushFormat(index);

      gen0State->program = foam;
      gen0State->program->foamProg.infoBits = IB_SIDE(1 << 0);

      if (genIsRuntime()(gen0IsRuntime)) {
              genFoamStmt(body);
              gen0AddStmt(foamNewReturn(foamNewNil())foamNew(FOAM_Return, 1, foamNew(FOAM_Nil, (int) 0)), NULL((void*)0));
      }
      else {
AbSyn	exporter = gen0ProgGetExporter();
Foam	rtHashCode = gen0SefoHashExporter(exporter);
Foam	stmt;

stmt = gen0BuiltinCCall(FOAM_Word, "domainAddNameFn!",
			"runtime",
		        2, foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))),
			gen0BuildExporterName(exporter));
gen0AddStmt(stmt, NULL((void*)0));
stmt = gen0BuiltinCCall(FOAM_Word, "domainAddHash!", "runtime",
			2, foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))), rtHashCode);
              gen0AddStmt(stmt, NULL((void*)0));
stmt = foamNewReturn(gen0AddBody1(ab,stab,defaultsAb))foamNew(FOAM_Return, 1, gen0AddBody1(ab,stab,defaultsAb));
              gen0AddStmt(stmt, NULL((void*)0));
      }

gen0IssueDCache();
gen0ProgAddStateFormat(index);
gen0ProgFiniEmpty(foam, FOAM_Clos, int0((int) 0));

      foamOptInfo(foam)((foam)->hdr.info.opt) = optInfoNew(gen0State->stab, foam, NULL((void*)0), false((int) 0));
      foamProgSetGetter(foam)((foam)->foamProg.infoBits |= (1 << 3));

gen0ProgPopState();

      if (!genIsRuntime()(gen0IsRuntime)) {
clos = gen0BuiltinCCall(FOAM_Word, "domainMake", "runtime",
			1, clos);
foamPure(clos)((clos)->hdr.info.pure) = true1;
}
      return clos;
235}

237Foam
238gen0AddBody1(AbSyn ab, Stab stab, AbSyn defaultsAb)
239{
Scope("gen0AddBody1")String scopeName = ("gen0AddBody1"); int fluidLevel0 = (scopeLevel
++, fluidLevel);
AbSyn		base = ab->abAdd.base;
AbSyn		body = ab->abAdd.capsule;
ExportState	fluid(gen0ExportState)fluidSave_gen0ExportState = ( fluidStack = (fluidLevel==fluidLimit
) ? fluidGrow() : fluidStack, fluidStack[fluidLevel].scopeName
 = scopeName, fluidStack[fluidLevel].scopeLevel = scopeLevel,
 fluidStack[fluidLevel].pglobal = (Pointer) &(gen0ExportState
), fluidStack[fluidLevel].pstack = (Pointer) &fluidSave_gen0ExportState
, fluidStack[fluidLevel].size = sizeof(gen0ExportState), fluidLevel
++, (gen0ExportState) );
SymeList	symes = listNil(Syme)((SymeList) 0);
Foam		clos, foam;
int		index;
Length		argc = 2;
String		argv[2];

argv[0] = "domain";
argv[1] = "hashcode";

clos = gen0ProgClosEmpty();
foam = gen0ProgInitEmpty("addLevel1", body);

      index = gen0FormatNum;
      gen0ProgPushState(stab, GF_Add1);

gen0ProgAddParams(argc, argv);

gen0Vars(stab);

      gen0PushFormat(index);

      gen0State->program = foam;
      gen0State->program->foamProg.infoBits = IB_SIDE(1 << 0);

gen0FindUncondSymes(body, symes);
/* Add parents and defaults */
gen0ExportState = gen0TypeInit();
gen0TypeInitDomain(base, defaultsAb);

      /* generate code for add body. */
      gen0DefTypeSequence(body, gen0ExportState->domExportList);

/* Generate code to check for export clashes */
if (genHashcheck()(gen0Hashcheck)) gen0ClashCheck(ab);

gen0TypeFini();

      gen0AddStmt(foamNewReturn(foamNewPar(int0))foamNew(FOAM_Return, 1, foamNew(FOAM_Par, 1, (AInt)(((int) 0)
))), NULL((void*)0));

      gen0State->hasTemps = true1;

gen0ProgAddStateFormat(index);
gen0ProgFiniEmpty(foam, FOAM_Word, int0((int) 0));

      foamOptInfo(foam)((foam)->hdr.info.opt) = optInfoNew(gen0State->stab, foam, NULL((void*)0), false((int) 0));
      foamProgSetGetter(foam)((foam)->foamProg.infoBits |= (1 << 3));

gen0ProgPopState();

      Return(clos){ fluidUnwind(fluidLevel0, ((int) 0)); return clos;; };
294}

296Foam
297gen0MakeDefaultPackage(AbSyn base, Stab stab, Bool inCatForm, Syme syme)
298{
Scope("gen0MakeDefaultPackage")String scopeName = ("gen0MakeDefaultPackage"); int fluidLevel0
 = (scopeLevel++, fluidLevel);
ExportState 	fluid(gen0ExportState)fluidSave_gen0ExportState = ( fluidStack = (fluidLevel==fluidLimit
) ? fluidGrow() : fluidStack, fluidStack[fluidLevel].scopeName
 = scopeName, fluidStack[fluidLevel].scopeLevel = scopeLevel,
 fluidStack[fluidLevel].pglobal = (Pointer) &(gen0ExportState
), fluidStack[fluidLevel].pstack = (Pointer) &fluidSave_gen0ExportState
, fluidStack[fluidLevel].size = sizeof(gen0ExportState), fluidLevel
++, (gen0ExportState) );
4
←
Assuming 'fluidLevel' is not equal to 'fluidLimit'→
5
←
'?' condition is false→
AbSyn		defs = NULL((void*)0);
Syme		self = stabGetSelf(stab);
SymeList	symes = listNil(Syme)((SymeList) 0);
Foam		foam, clos;
int		index, j;
Foam 		hasher;

Length		argc = 2;
String		argv[2];
argv[0] 	= "self";
argv[1] 	= "dom";

if (base5.1
'base' is non-null
 && abTag(base)((base)->abHdr.tag) == AB_With) {
6
←
Assuming field 'tag' is equal to AB_With→
7
←
Taking true branch→
defs = gen0FindDefaults(base->abWith.within);
base = gen0CollectWithImports(base);
8
←
Value assigned to 'base'→
}

if (base && abIsJoin(base)(((base)->abHdr.tag == (AB_Apply)) && (((((base)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((base)->
abApply.op))->abId.sym)==(ssymJoin)))) {
9
←
Assuming 'base' is null→
Length	jargc = abApplyArgc(base)(((base)->abHdr.argc)-1);
if (jargc == 0)
	base = abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
if (jargc == 1)
	base = abApplyArg(base, int0)((base)->abApply.argv[((int) 0)]);
}

if ((base9.1
'base' is equal to NULL
 == NULL((void*)0) || abIsNothing(base)((base)->abHdr.tag == (AB_Nothing))) &&
   (defs9.2
'defs' is not equal to NULL
 == NULL((void*)0) || abIsNothing(defs)((defs)->abHdr.tag == (AB_Nothing))) &&
   !inCatForm)
Return(foamNewNil()){ fluidUnwind(fluidLevel0, ((int) 0)); return foamNew(FOAM_Nil
, (int) 0);; };

if (!abIsJoin(base)(((base)->abHdr.tag == (AB_Apply)) && (((((base)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((base)->
abApply.op))->abId.sym)==(ssymJoin))) &&
10
←
Dereference of null pointer
   (defs == NULL((void*)0) || abIsNothing(defs)((defs)->abHdr.tag == (AB_Nothing))) &&
   (abIsId(base)((base)->abHdr.tag == (AB_Id)) || abIsApply(base)((base)->abHdr.tag == (AB_Apply))) &&
334#if 0
   (self == NULL((void*)0) || symeUnused(self)(((UShort) ((((((self)->kind == SYME_Trigger ? libGetAllSymes
((self)->lib) : ((void*)0)), (self))->locmask) & (1
 << (SYFI_UsedDepth))) ? ((self)->fieldv)[symeIndex(
self,SYFI_UsedDepth)] : (symeFieldInfo[SYFI_UsedDepth].def)))
 == (0x7FFF))) &&
336#endif
   !inCatForm)
Return(genFoamType(base)){ fluidUnwind(fluidLevel0, ((int) 0)); return genFoamType(base
);; };

hasher = gen0MakeDefaultHash();

      clos = gen0ProgClosEmpty();
foam = gen0ProgInitEmpty(gen0ProgName, base);

index = gen0FormatNum;
gen0ProgPushState(stab, inCatForm ? GF_DefaultCat : GF_Default);

gen0State->type = tfCategory;
gen0State->stab = stab;

gen0State->program	    = foam;
gen0State->program->foamProg.infoBits = IB_SIDE(1 << 0);

gen0ProgAddParams(argc, argv);
if (self) symeSetUsedDeeply(self)(((((self)->kind == SYME_Trigger ? libGetAllSymes((self)->
lib) : ((void*)0)), (self))->bits) |= (0x0004));
gen0Vars(stab);
gen0PushFormat(index);

if (defs) 
gen0FindUncondSymes(defs, symes);

gen0ExportState = gen0TypeInit();

if (self) {
gen0ExportState->self     = gen0Syme(self);
gen0ExportState->selfSyme = self;
}
else {
j = gen0AddLex(foamNewDecl(FOAM_Word, strCopy("self"),foamNew(FOAM_Decl,4,(AInt)(FOAM_Word),strCopy("self"), (AInt)
 (0x7FFF), 4)
			   emptyFormatSlot)foamNew(FOAM_Decl,4,(AInt)(FOAM_Word),strCopy("self"), (AInt)
 (0x7FFF), 4));
gen0ExportState->self = foamNewLex(int0, j)foamNew(FOAM_Lex, 2, (AInt)(((int) 0)), (AInt)(j));
}
gen0AddInit(foamNewDef(foamCopy(gen0ExportState->self),foamNew(FOAM_Def, 2, foamCopy(gen0ExportState->self), foamNew
(FOAM_Par, 1, (AInt)(1)))
	       foamNewPar(1))foamNew(FOAM_Def, 2, foamCopy(gen0ExportState->self), foamNew
(FOAM_Par, 1, (AInt)(1))));
gen0ExportState->selfHash = gen0TempLex(FOAM_SInt)gen0TempLex0(FOAM_SInt, 4);
gen0AddInit(foamNewSet(foamCopy(gen0ExportState->selfHash),foamNew(FOAM_Set, 2, foamCopy(gen0ExportState->selfHash), gen0RtDomainHash
(gen0ExportState->self))
	       gen0RtDomainHash(gen0ExportState->self))foamNew(FOAM_Set, 2, foamCopy(gen0ExportState->selfHash), gen0RtDomainHash
(gen0ExportState->self)));

gen0TypeInitDefaults();
gen0MakeCategoryParents(base);

if (defs) 
gen0DefTypeSequence(defs, gen0ExportState->domExportList);

gen0TypeFini();

gen0AddStmt(foamNewReturn(foamNew(FOAM_Values, int0))foamNew(FOAM_Return, 1, foamNew(FOAM_Values, ((int) 0))), NULL((void*)0));

gen0ProgAddStateFormat(index);
gen0ProgFiniEmpty(foam, FOAM_NOp, int0((int) 0));

foamOptInfo(foam)((foam)->hdr.info.opt) = optInfoNew(gen0State->stab, foam, syme, false((int) 0));
      foamProgSetGetter(foam)((foam)->foamProg.infoBits |= (1 << 3));
if (foam->foamProg.levels->foamDEnv.argv[0] != emptyFormatSlot4)
foamProgUnsetLeaf(foam)((foam)->foamProg.infoBits &= ~(1 << 1));
/*gen0ComputeSideEffects(foam);*/
gen0ProgPopState();


foam = gen0BuiltinCCall(FOAM_Word,
		"categoryMake", "runtime", 3, clos,
		hasher,
		gen0BuildExporterName(gen0ProgGetExporter()));
Return(foam){ fluidUnwind(fluidLevel0, ((int) 0)); return foam;; };
405}

407localstatic Foam
408gen0MakeDefaultHash()
409{
AbSyn exp = gen0ProgGetExporter();
Foam hashCode;

if (exp == NULL((void*)0) || abTag(exp)((exp)->abHdr.tag) == AB_Id) {
hashCode = gen0SefoHashExporter(exp);
return gen0BuiltinCCall(FOAM_Clos, "rtConstSIntFn", 
			"runtime", 1, hashCode);
}
else {
GenFoamState saved;
Foam 	     foam, clos;
GenFoamTag   oldTag = gen0State->tag;

clos = gen0ProgClosEmpty();
foam = gen0ProgInitEmpty("defhash0", NULL((void*)0));

saved = gen0ProgSaveState(PT_ExFn);
gen0State->tag = GF_Lambda;
hashCode = gen0SefoHashExporter(exp);

gen0AddStmt(foamNewReturn(hashCode)foamNew(FOAM_Return, 1, hashCode), NULL((void*)0));

gen0ProgPushFormat(emptyFormatSlot4);
gen0ProgFiniEmpty(foam, FOAM_SInt, int0((int) 0));
gen0AddLexLevels(foam, 1);
foamOptInfo(foam)((foam)->hdr.info.opt) = optInfoNew(NULL((void*)0), foam, NULL((void*)0), false((int) 0));

gen0ProgRestoreState(saved);
gen0State->tag = oldTag;

return clos;
}
442}



446localstatic void
447gen0TypeInitDomain(AbSyn base, AbSyn defaultsAb)
448{
Stab nstab;
Foam defaults;

gen0TypeOpen(foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))), "domainAddExports!");

gen0MakeDomainSelf();

nstab = defaultsAb ? abStab(defaultsAb)((defaultsAb)->abHdr.seman ? (defaultsAb)->abHdr.seman->
stab : 0) : NULL((void*)0);
defaults = gen0MakeDefaultPackage(defaultsAb, nstab, false((int) 0), NULL((void*)0));

gen0MakeDomainDefaults(defaults);

gen0MakeDomainParents(base);
462}

464localstatic void
465gen0TypeInitDefaults()
466{
gen0TypeOpen(foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))), "categoryAddExports!");

if (gen0IsCatDefForm(gen0State))
gen0TypeAddDefaultSelfSlot();

472}

474/* COND-DEF */
475localstatic Hash
476gen0CondHash(GfCond cond)
477{
return (Hash)ptrCanon(cond->syme)((Pointer)(cond->syme));
479}

481localstatic Bool
482gen0CondEq(GfCond a, GfCond b)
483{
if ((a->syme) != (b->syme)) return false((int) 0);
return ablogEqual(a->condition, b->condition);
486}

488localstatic ExportState
489gen0TypeInit()
490{
ExportState exportState;
SymeList 	symes;
Foam 		szVar = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
Foam 		names, types, vals;
FoamList	place;	

      /* collect the exports. */
      if (gen0State->stab)
              symes = gen0AddExportedSymes();
      else
              symes = 0;
/* set for array sizes */
gen0AddInit(foamNewNOp()foamNew(FOAM_NOp, (int) 0));
place = gen0State->inits;

/* Create the foam arrays for the domain vectors. */
names = gen0TempLocal0(FOAM_Arr, FOAM_Word);
types = gen0TempLocal0(FOAM_Arr, FOAM_Word);
vals  = gen0TempLocal0(FOAM_Arr, FOAM_Word);

gen0AddInit(foamNewSet(names, foamNewANew(FOAM_Word,foamNew(FOAM_Set, 2, names, foamNew(FOAM_ANew, 2, FOAM_Word, foamCopy
(szVar))) 
				  foamCopy(szVar)))foamNew(FOAM_Set, 2, names, foamNew(FOAM_ANew, 2, FOAM_Word, foamCopy
(szVar))));
gen0AddInit(foamNewSet(types, foamNewANew(FOAM_Word,foamNew(FOAM_Set, 2, types, foamNew(FOAM_ANew, 2, FOAM_Word, foamCopy
(szVar))) 
				  foamCopy(szVar)))foamNew(FOAM_Set, 2, types, foamNew(FOAM_ANew, 2, FOAM_Word, foamCopy
(szVar))));
gen0AddInit(foamNewSet(vals,  foamNewANew(FOAM_Word,foamNew(FOAM_Set, 2, vals, foamNew(FOAM_ANew, 2, FOAM_Word, foamCopy
(szVar))) 
				  foamCopy(szVar)))foamNew(FOAM_Set, 2, vals, foamNew(FOAM_ANew, 2, FOAM_Word, foamCopy
(szVar))));

exportState = (ExportState) stoAlloc(OB_Other0, sizeof(*exportState));

exportState->foamLevel = gen0State->foamLevel;
exportState->domExportList = symes;
exportState->domInittedTbl = tblNew(NULL((void*)0), NULL((void*)0));
/* COND-DEF */
exportState->domCondTbl = tblNew((TblHashFun)gen0CondHash,
			(TblEqFun)gen0CondEq);
exportState->defMap   = gen0MakeTypeExportMap(symes);
exportState->setPlace = place;
exportState->szVar    = szVar;
exportState->size     = 0;
exportState->names    = names;
exportState->types    = types;
exportState->vals     = vals;
exportState->selfSyme = NULL((void*)0);
return exportState;
535}

537localstatic void
538gen0TypeOpen(Foam type, String exporterName)
539{
Foam size = gen0ExportState->szVar;
Foam names, types, vals;

/* Create the Aldor arrays for the domain vectors. */
names = gen0MakeArray(foamCopy(size), gen0ExportState->names, NULL((void*)0));
types = gen0MakeArray(foamCopy(size), gen0ExportState->types, NULL((void*)0));
vals  = gen0MakeArray(foamCopy(size), gen0ExportState->vals,  NULL((void*)0));

gen0AddStmt(gen0BuiltinCCall(FOAM_NOp, exporterName, "runtime", 4, 
		     type, names, types, vals), NULL((void*)0));
550}

552localstatic void
553gen0TypeFini()
554{
gen0InitExports();

gen0IssueDCache();

setcar(gen0ExportState->setPlace,((gen0ExportState->setPlace)->first = (foamNew(FOAM_Set
, 2, foamCopy(gen0ExportState->szVar), foamNew(FOAM_SInt, 1
, (AInt)(gen0ExportState->size)))))
      foamNewSet(foamCopy(gen0ExportState->szVar),((gen0ExportState->setPlace)->first = (foamNew(FOAM_Set
, 2, foamCopy(gen0ExportState->szVar), foamNew(FOAM_SInt, 1
, (AInt)(gen0ExportState->size))))) 
	  foamNewSInt(gen0ExportState->size)))((gen0ExportState->setPlace)->first = (foamNew(FOAM_Set
, 2, foamCopy(gen0ExportState->szVar), foamNew(FOAM_SInt, 1
, (AInt)(gen0ExportState->size)))));

listFree(Syme)(Syme_listPointer->Free)(gen0ExportState->domExportList);
tblFree(gen0ExportState->domInittedTbl);

stoFree(gen0ExportState);
567}

569void 
570gen0TypeAddExportSlot(Syme syme)
571{
TForm	tf = symeType(syme);
Foam 	name, type, val, lhs;
int 	posn;
String  str  = symString(symeId(syme))((((syme)->id))->str);

if (!gen0IsDomLevel(gen0State->tag)((gen0State->tag) >= GF_START_TYPE && (gen0State
->tag) <= GF_END_TYPE) || gen0State->tag == GF_File)
   return;

/* Get the location which holds the value of the export */
lhs = gen0SymeInit(syme);
if (!lhs)
{
AbSyn	ab = (AbSyn)NULL((void*)0);
String	etype = tfPretty(tf);
comsgFatal(ab, ALDOR_F_BugExportSymeNotInit368, str, etype);
}


/*
* Conditional exports get a flag so that runtime checks can be
* made to determine whether or not they have been initialised.
*/
if (!symeUnconditional(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0020))) {
gen0AddInit(foamNewSet(gen0ExpMapRef(syme),foamNew(FOAM_Set, 2, gen0ExpMapRef(syme), foamNew(FOAM_Bool, 1
, (AInt)(((int) 0)))) 
		       foamNewBool(false))foamNew(FOAM_Set, 2, gen0ExpMapRef(syme), foamNew(FOAM_Bool, 1
, (AInt)(((int) 0)))));
gen0AddStmt(foamNewSet(gen0ExpMapRef(syme),foamNew(FOAM_Set, 2, gen0ExpMapRef(syme), foamNew(FOAM_Bool, 1
, (AInt)(1))) 
		       foamNewBool(true))foamNew(FOAM_Set, 2, gen0ExpMapRef(syme), foamNew(FOAM_Bool, 1
, (AInt)(1))), NULL((void*)0));
}
posn = gen0ExportState->size++;
name = foamNewSInt(gen0StrHash(str))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(str)));
type = gen0TypeHash(tf, tf, str);


/* COND-DEF */
if (!symeUnconditional(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0020))) {
Foam def, rhs;


/* Get the local holding the export value */
rhs = gen0SymeCond(syme);


/* Safety check */
assert(rhs)do { if (!(rhs)) _do_assert(("rhs"),"gf_add.c",615); } while (
0);


/* Create definition for this export */
def = foamNewDef(foamCopy(lhs), foamCopy(rhs))foamNew(FOAM_Def, 2, foamCopy(lhs), foamCopy(rhs));


/* Retrieve the DefnId stashed by gen0Define */
def->foamDef.hdr.defnId = rhs->foamGen.hdr.defnId;


626#if 0
/* Debugging output */
(void)fprintf(dbOut, "--- [%d] ", def->foamDef.hdr.defnId);
foamPrintDb(rhs);
(void)fprintf(dbOut, "   ");
symePrintDb(syme);
(void)fprintf(dbOut, "   ");
ablogPrintDb(gfCondKnown);
634#endif


/* Define the export */
gen0AddStmt(def, NULL((void*)0));

}

      val  = foamCopy(lhs);


/* Wrap non-word exports */
      if (gen0Type(tf, NULL((void*)0)) != FOAM_Word)
              val = foamNewCast(FOAM_Word, val)foamNew(FOAM_Cast, 2, FOAM_Word, val);

      gen0AddStmt(gen0ASet(gen0ExportState->names,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(posn)),foamCopy(gen0ExportState->names
)), foamNew(FOAM_Cast, 2, FOAM_Word, name)) 
	     posn, FOAM_Word, foamNewCast(FOAM_Word, name))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(posn)),foamCopy(gen0ExportState->names
)), foamNew(FOAM_Cast, 2, FOAM_Word, name)),
    NULL((void*)0));
      gen0AddStmt(gen0ASet(gen0ExportState->types,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(posn)),foamCopy(gen0ExportState->types
)), foamNew(FOAM_Cast, 2, FOAM_Word, type)) 
	     posn, FOAM_Word, foamNewCast(FOAM_Word, type))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(posn)),foamCopy(gen0ExportState->types
)), foamNew(FOAM_Cast, 2, FOAM_Word, type)),
    NULL((void*)0));
      gen0AddStmt(gen0ASet(gen0ExportState->vals,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(posn)),foamCopy(gen0ExportState->vals
)), val)  
	     posn, FOAM_Word, val)foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(posn)),foamCopy(gen0ExportState->vals
)), val),  NULL((void*)0));

gen0StrRegister(name->foamSInt.SIntData, str);

return;
661}

663/*
* Walk the tree looking for symes at top level. We ought to
* do this in scobind and we ought to deal with implicit
* exports as well. For now we assume that implicit exports
* are unconditional and mark them in gen0DefTypeSequence().
*/
669void
670gen0FindUncondSymes(AbSyn absyn, SymeList symes)
671{
int i, argc;
AbSyn lhs, *argv;
Syme syme;

switch(abTag(absyn)((absyn)->abHdr.tag)) {
 case AB_Define:
lhs = absyn->abDefine.lhs;
if (abTag(lhs)((lhs)->abHdr.tag) == AB_Comma) {
	argc = abArgc(lhs)((lhs)->abHdr.argc);
	argv = lhs->abComma.argv;
} 
else {
	argc = 1;
	argv = &lhs;
}
for (i=0; i< argc; i++) {
	if (abTag(argv[i])((argv[i])->abHdr.tag)==AB_Declare)
		syme = abSyme(argv[i]->abDeclare.id)((argv[i]->abDeclare.id)->abHdr.seman ? (argv[i]->abDeclare
.id)->abHdr.seman->syme : 0);
	else {			
		assert(abTag(argv[i])==AB_Id)do { if (!(((argv[i])->abHdr.tag)==AB_Id)) _do_assert(("abTag(argv[i])==AB_Id"
),"gf_add.c",691); } while (0);
		syme = abSyme(argv[i])((argv[i])->abHdr.seman ? (argv[i])->abHdr.seman->syme
 : 0);
	}
	if (symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Export)||symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend))
		symeSetUnconditional(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) |= (0x0020));
}
break;
 case AB_Where:
gen0FindUncondSymes(absyn->abWhere.expr, symes);
break;
 case AB_Default:
 case AB_Sequence:
for (i=0; i<abArgc(absyn)((absyn)->abHdr.argc); i++) {
	if (abTag(abArgv(absyn)[i])((((absyn)->abGen.data.argv)[i])->abHdr.tag) == AB_Exit) break;
	gen0FindUncondSymes(abArgv(absyn)((absyn)->abGen.data.argv)[i], symes);
}
break;
 case AB_Local:
for (i=0; i<abArgc(absyn)((absyn)->abHdr.argc); i++) {
	gen0FindUncondSymes(abArgv(absyn)((absyn)->abGen.data.argv)[i], symes);
}
break;
 default:
break;
}
716}

718/*
* Create a local for self for a domain if needed.
*/
721localstatic void
722gen0MakeDomainSelf()
723{
SymeList sl;
Foam	result, set;

gen0ExportState->self = gen0TempLocal(FOAM_Word)gen0TempLocal0(FOAM_Word, 4);
result = gen0BuiltinCCall(FOAM_Word, "domainMakeDispatch",
			  "runtime", 1, foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))));
foamPure(result)((result)->hdr.info.pure) = true1;
gen0AddInit(foamNewSet(foamCopy(gen0ExportState->self), result)foamNew(FOAM_Set, 2, foamCopy(gen0ExportState->self), result
));
/* Tacky --- stabGetSelf gives an inner version, 
  so we go look for outer */
sl = gen0ExportState->domExportList;
while (sl && symeId(car(sl))((((sl)->first))->id) != ssymSelf)
sl = cdr(sl)((sl)->rest);

/* This was conditional on (sl && !symeUnused(car(sl))) 
* ie. used deeply.  The optimisations for self in tfFloat 
* break this.
*/
if (sl) {
set = gen0Syme(car(sl)((sl)->first));
gen0AddInit(foamNewSet(set,foamNew(FOAM_Set, 2, set, foamCopy(gen0ExportState->self))
		       foamCopy(gen0ExportState->self))foamNew(FOAM_Set, 2, set, foamCopy(gen0ExportState->self)));
gen0SymeSetInit(car(sl)((sl)->first), set);
symeSetUnconditional(car(sl))(((((((sl)->first))->kind == SYME_Trigger ? libGetAllSymes
((((sl)->first))->lib) : ((void*)0)), (((sl)->first)
))->bits) |= (0x0020));
}

gen0ExportState->selfSyme = sl ? car(sl)((sl)->first) : NULL((void*)0);
gen0ExportState->selfHash = gen0TempLex(FOAM_SInt)gen0TempLex0(FOAM_SInt, 4);
gen0AddInit(foamNewDef(gen0ExportState->selfHash, foamNewCast(FOAM_SInt,foamNew(FOAM_Def, 2, gen0ExportState->selfHash, foamNew(FOAM_Cast
, 2, FOAM_SInt, foamNew(FOAM_Par, 1, (AInt)(1))))
						      foamNewPar(1)))foamNew(FOAM_Def, 2, gen0ExportState->selfHash, foamNew(FOAM_Cast
, 2, FOAM_SInt, foamNew(FOAM_Par, 1, (AInt)(1)))));
754}

756Bool
757gen0HasDefaults(AbSyn absyn)
758{
int	i;
AbSyn	within = absyn->abWith.within;

for(i=0; i<abArgc(within)((within)->abHdr.argc); i++) {
if (abTag(abArgv(within)[i])((((within)->abGen.data.argv)[i])->abHdr.tag) == AB_Default)
	return true1;
/* Test should be improved.. */
if (abTag(abArgv(within)[i])((((within)->abGen.data.argv)[i])->abHdr.tag) == AB_If)
	return true1;
}
return false((int) 0);
770}

772localstatic void
773gen0TypeAddDefaultSelfSlot()
774{
AbSyn abType = gen0ProgGetExporter();
Foam  rtHash;
int i;

if (DEBUG(phase)phaseDebug) {
fprintf(dbOut, "Make slot: exporter is:\n");
abWrSExpr(dbOut, abType,int0((int) 0));
}

assert(gen0ExportState->self)do { if (!(gen0ExportState->self)) _do_assert(("gen0ExportState->self"
),"gf_add.c",784); } while (0);
rtHash = gen0SefoHashExporter(abType);

i = gen0ExportState->size++;
gen0AddStmt(gen0ASet(gen0ExportState->names, i, FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->names)
), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt
)(gen0StrHash("%%"))))) 
	     foamNewCast(FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->names)
), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt
)(gen0StrHash("%%"))))) 
			 foamNewSInt(gen0StrHash("%%"))))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->names)
), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt
)(gen0StrHash("%%"))))), 
    NULL((void*)0));
gen0AddStmt(gen0ASet(gen0ExportState->types, i, FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->types)
), foamNew(FOAM_Cast, 2, FOAM_Word, rtHash))
	     foamNewCast(FOAM_Word, rtHash))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->types)
), foamNew(FOAM_Cast, 2, FOAM_Word, rtHash)),
    NULL((void*)0));
gen0AddStmt(gen0ASet(gen0ExportState->vals, i, FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->vals))
, foamCopy(gen0ExportState->self)) 
	     foamCopy(gen0ExportState->self))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(gen0ExportState->vals))
, foamCopy(gen0ExportState->self)), 
    NULL((void*)0));
assert(foamTag(gen0ExportState->self) == FOAM_Lex)do { if (!(((gen0ExportState->self)->hdr.tag) == FOAM_Lex
)) _do_assert(("foamTag(gen0ExportState->self) == FOAM_Lex"
),"gf_add.c",798); } while (0);
gen0UseStackedFormat(gen0ExportState->self->foamLex.level);
800}

802/*
* Create the defaults for a domain.
*/
805localstatic void
806gen0MakeDomainDefaults(Foam defaults)
807{
Foam result;

if (!defaults || foamTag(defaults)((defaults)->hdr.tag) == FOAM_Nil) return;

result = gen0BuiltinCCall(FOAM_Word, "domainAddDefaults!",
		  "runtime", 3, foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))), defaults, 
		  foamCopy(gen0ExportState->self));
gen0AddStmt(result, NULL((void*)0));

gen0SetInitUsage(defaults, int0((int) 0));
818}

820/*
* Evaluate the parents of a domain.
*/
823localstatic void
824gen0MakeCategoryParents(AbSyn base)
825{
Foam 	 pars, result;
FoamList place;
int 	 sz;

assert(base)do { if (!(base)) _do_assert(("base"),"gf_add.c",830); } while
 (0);
if (abIsNothing(base)((base)->abHdr.tag == (AB_Nothing))) return;

pars = gen0TempLocal0(FOAM_Arr, FOAM_Word);
gen0AddInit(foamNewNOp()foamNew(FOAM_NOp, (int) 0));
place = gen0State->inits;
sz = gen0MakeCatParents0(base, pars, int0((int) 0));
/* fixup */
if (sz == 0)
return;
setcar(place,((place)->first = (foamNew(FOAM_Set, 2, foamCopy(pars), foamNew
(FOAM_ANew, 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt)(sz))))
)) 
      foamNewSet(foamCopy(pars),((place)->first = (foamNew(FOAM_Set, 2, foamCopy(pars), foamNew
(FOAM_ANew, 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt)(sz))))
))
	  foamNewANew(FOAM_Word, foamNewSInt(sz))))((place)->first = (foamNew(FOAM_Set, 2, foamCopy(pars), foamNew
(FOAM_ANew, 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt)(sz))))
));

/* Create the Aldor array for the parents. */
pars = gen0MakeArray(foamNewSInt(sz)foamNew(FOAM_SInt, 1, (AInt)(sz)), foamCopy(pars), base);

result = gen0BuiltinCCall(FOAM_Word, "categoryAddParents!", 
		  "runtime", 3,
		  foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))), pars, 
		  foamCopy(gen0ExportState->self));
gen0AddStmt(result, NULL((void*)0));
852}

854localstatic int
855gen0MakeCatParents0(AbSyn ab, Foam pars, int idx)
856{
int i;
      if (abIsJoin(ab)(((ab)->abHdr.tag == (AB_Apply)) && (((((ab)->abApply
.op))->abHdr.tag == (AB_Id)) && ((((ab)->abApply
.op))->abId.sym)==(ssymJoin)))) {
for (i=0; i<abApplyArgc(ab)(((ab)->abHdr.argc)-1) ; i++) {
	idx = gen0MakeCatParents0(abApplyArg(ab, i)((ab)->abApply.argv[i]), 
				  pars, idx);
}
}
else switch (abTag(ab)((ab)->abHdr.tag)) {
 case AB_Sequence:
for (i=0; i<abArgc(ab)((ab)->abHdr.argc) ; i++)
	idx = gen0MakeCatParents0(abArgv(ab)((ab)->abGen.data.argv)[i], 
				  pars, idx);
break;
 case AB_If:
idx = gen0MakeCatParentsIf(ab, pars, idx);
break;
 case AB_Default:
gen0DefTypeSequence(ab,
		    gen0ExportState->domExportList);
break;
 case AB_Declare:
 case AB_Export:
 case AB_Nothing:
break;
 case AB_Comma:
assert(abArgc(ab) == 0)do { if (!(((ab)->abHdr.argc) == 0)) _do_assert(("abArgc(ab) == 0"
),"gf_add.c",882); } while (0);
break;
 default:
gen0MakeTypeParent(ab, idx, foamCopy(pars), NULL((void*)0));
idx ++;
}
return idx;
889}


892localstatic int
893gen0MakeCatParentsIf(AbSyn ab, Foam pars, int idx)
894{
FoamList topLines;
Foam	 low;
int   l1 = gen0State->labelNo++, l2 = gen0State->labelNo++;
int   l3 = gen0State->labelNo++, l4 = gen0State->labelNo++;
int   idx1, idx2;
Bool  flag;

/* COND-DEF */
AbLogic	saveCond;
AbSyn	nTest;
Stab	stab = abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) ? abStab(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->stab : 0) : stabFile();
extern AbSyn abExpandDefs(Stab, AbSyn);

flag = gen0AddImportPlace(&topLines);

nTest = abExpandDefs(stab, (ab->abIf.test)); /* COND-DEF */

/* 
* Plan is:
*   (if cond L1)
*   idx1 := Fill <else> part from idx
*   low  := idx1
*   goto L2
* L1:
*   idx2 := Fill <then> part from idx
*   low := idx2
* L2:
*   high := max(idx1, idx2)
* L3:
*   if (high = low) L4;
*   arr.low := NIL;
*   low++;
* L4
*/
low  = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);

gen0AddStmt(foamNewIf(genFoamBit(ab->abIf.test), l1)foamNew(FOAM_If, 2, genFoamBit(ab->abIf.test), l1), ab);
ablogAndPush(&gfCondKnown, &saveCond, nTest, false((int) 0)); /* COND-DEF */
idx1 = gen0MakeCatParents0(ab->abIf.elseAlt, pars, idx);
ablogAndPop (&gfCondKnown, &saveCond); /* COND-DEF */
gen0AddStmt(foamNewSet(foamCopy(low), foamNewSInt(idx1))foamNew(FOAM_Set, 2, foamCopy(low), foamNew(FOAM_SInt, 1, (AInt
)(idx1))), ab);

gen0AddStmt(foamNewGoto(l2)foamNew(FOAM_Goto, 1, (AInt)(l2)), ab);
gen0AddStmt(foamNewLabel(l1)foamNew(FOAM_Label, 1, (AInt)(l1)), ab);

ablogAndPush(&gfCondKnown, &saveCond, nTest, true1); /* COND-DEF */
idx2 = gen0MakeCatParents0(ab->abIf.thenAlt, pars, idx);
ablogAndPop (&gfCondKnown, &saveCond); /* COND-DEF */
gen0AddStmt(foamNewSet(foamCopy(low), foamNewSInt(idx2))foamNew(FOAM_Set, 2, foamCopy(low), foamNew(FOAM_SInt, 1, (AInt
)(idx2))), ab);
gen0AddStmt(foamNewLabel(l2)foamNew(FOAM_Label, 1, (AInt)(l2)), ab);

idx = idx1>idx2 ? idx1 : idx2;

gen0AddStmt(foamNewLabel(l3)foamNew(FOAM_Label, 1, (AInt)(l3)), ab);
gen0AddStmt(foamNewIf(foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ,foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ, foamNew
(FOAM_SInt, 1, (AInt)(idx)), foamCopy(low)), l4)
		      foamNewSInt(idx),foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ, foamNew
(FOAM_SInt, 1, (AInt)(idx)), foamCopy(low)), l4)
		      foamCopy(low)),foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ, foamNew
(FOAM_SInt, 1, (AInt)(idx)), foamCopy(low)), l4)
	      l4)foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ, foamNew
(FOAM_SInt, 1, (AInt)(idx)), foamCopy(low)), l4), ab);
gen0AddStmt(foamNewSet(foamNewAElt(FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy
(low),foamCopy(pars)), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew
(FOAM_Nil, (int) 0))) 
			   foamCopy(low),foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy
(low),foamCopy(pars)), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew
(FOAM_Nil, (int) 0)))
			   foamCopy(pars)),foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy
(low),foamCopy(pars)), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew
(FOAM_Nil, (int) 0)))
	       foamNewCast(FOAM_Word, foamNewNil()))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy
(low),foamCopy(pars)), foamNew(FOAM_Cast, 2, FOAM_Word, foamNew
(FOAM_Nil, (int) 0))),
    ab);
gen0AddStmt(foamNewSet(foamCopy(low),foamNew(FOAM_Set, 2, foamCopy(low), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntNext
, foamCopy(low)))
	       foamNew(FOAM_BCall, 2,foamNew(FOAM_Set, 2, foamCopy(low), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntNext
, foamCopy(low)))
		       FOAM_BVal_SIntNext,foamNew(FOAM_Set, 2, foamCopy(low), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntNext
, foamCopy(low))) 
		       foamCopy(low)))foamNew(FOAM_Set, 2, foamCopy(low), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntNext
, foamCopy(low))),
    ab);
gen0AddStmt(foamNewGoto(l3)foamNew(FOAM_Goto, 1, (AInt)(l3)), ab);
gen0AddStmt(foamNewLabel(l4)foamNew(FOAM_Label, 1, (AInt)(l4)), ab);

foamFree(low);
if (flag) gen0ResetImportPlace(topLines);
	       
return idx;
970}

972localstatic void 
973gen0MakeDomainParents(AbSyn base)
974{
if (abIsNothing(base)((base)->abHdr.tag == (AB_Nothing))) return;

gen0MakeTypeParents(1, &base, "domainAddParents!", base);
978}


981localstatic void
982gen0MakeTypeParents(Length argc, AbSyn *argv, String adderName, AbSyn base)
983{
Foam	pars, result;
Length	i;

/* Create the foam array for the parent vector. */
pars = gen0TempLocal0(FOAM_Arr, FOAM_Word);
gen0AddStmt(gen0ANew(pars, FOAM_Word, argc)foamNew(FOAM_Set, 2, foamCopy(pars), foamNew(FOAM_ANew, 2, FOAM_Word
, foamNew(FOAM_SInt, 1, (AInt)(argc)))), base);

/* Fill the slots in the foam array. */
for (i = 0; i < argc; i += 1)
gen0MakeTypeParent(argv[i], i, pars, base);

/* Create the Aldor array for the domain parents. */
pars = gen0MakeArray(foamNewSInt(argc)foamNew(FOAM_SInt, 1, (AInt)(argc)), pars, base);

result = gen0BuiltinCCall(FOAM_Word, adderName, "runtime", 3,
		  foamNewPar(int0)foamNew(FOAM_Par, 1, (AInt)(((int) 0))), pars, 
		  foamCopy(gen0ExportState->self));
gen0AddStmt(result, NULL((void*)0));
1002}

1004/*
* Stuff the parent vector slot for a single parent in the add/with chain.
*/
1007localstatic void
1008gen0MakeTypeParent(AbSyn elt, Length i, Foam pars, AbSyn absyn)
1009{
FoamTag		type = gen0Type(gen0AbType(elt), NULL((void*)0));
Foam		par;

par = genFoamVal(elt);
if (type != FOAM_Word)
par = foamNewCast(FOAM_Word, par)foamNew(FOAM_Cast, 2, FOAM_Word, par);

gen0AddStmt(gen0ASet(pars, i, FOAM_Word, par)foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(pars)), par), absyn);
1018}

1020localstatic Foam
1021gen0MakeTypeExportMap(SymeList symes)
1022{
Foam mapVar;

mapVar = gen0Temp0(FOAM_Arr, FOAM_Bool);
gen0AddInit(gen0ANew(mapVar, FOAM_Bool, listLength(Syme)(symes))foamNew(FOAM_Set, 2, foamCopy(mapVar), foamNew(FOAM_ANew, 2, FOAM_Bool
, foamNew(FOAM_SInt, 1, (AInt)((Syme_listPointer->_Length)
(symes))))));
return mapVar;
1028}

1030int
1031gen0ExpMapPos(Syme syme)
1032{
return listPosq(Syme)(Syme_listPointer->Posq)(gen0ExportState->domExportList, syme);
1034}

1036Foam
1037gen0ExpMapRef(Syme syme)
1038{	/* !! Assumes syme came from gen0ExportState->domExports */
return foamNewAElt(FOAM_Bool, foamNewSInt(gen0ExpMapPos(syme)),foamNew(FOAM_AElt,3,(AInt)(FOAM_Bool),foamNew(FOAM_SInt, 1, (
AInt)(gen0ExpMapPos(syme))),foamCopy(gen0ExportState->defMap
))
	   foamCopy(gen0ExportState->defMap))foamNew(FOAM_AElt,3,(AInt)(FOAM_Bool),foamNew(FOAM_SInt, 1, (
AInt)(gen0ExpMapPos(syme))),foamCopy(gen0ExportState->defMap
));
1041}

1043localstatic void
1044gen0InitExports()
1045{
SymeList sl;

for (sl = gen0ExportState->domExportList; sl ; sl=cdr(sl)((sl)->rest)) {
Syme syme = car(sl)((sl)->first);
/* !! Eek */
if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend))
	continue;
/* 
 * The game we play with defaults is to assign them to
 * locals (see gen0Define), export them and then use
 * InitExports to pull in then binding.
 * !!Unfortunately, this fails if the export is
 * something that isn't lazy.
 */
if (symeHasDefault(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0080)) && gen0SymeInit(syme))
	gen0InitExport(syme);
else if (symeUsed(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0040)) && !symeUnconditional(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0020)) && 
	 gen0SymeInit(syme) != NULL((void*)0))
	gen0InitConditionalExport(syme);
else if (symeUsed(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->bits) & (0x0040)) && gen0SymeInit(syme) == NULL((void*)0))
	gen0InitExport(syme);
}
1068}

1070localstatic void
1071gen0InitConditionalExport(Syme syme)
1072{
int label;

if (!gen0IsDomLevel(gen0State->tag)((gen0State->tag) >= GF_START_TYPE && (gen0State
->tag) <= GF_END_TYPE) || gen0State->tag == GF_File)
return;

label = gen0State->labelNo++;

gen0AddStmt(foamNewIf(gen0ExpMapRef(syme), label)foamNew(FOAM_If, 2, gen0ExpMapRef(syme), label), NULL((void*)0));
gen0InitExport(syme);
gen0AddStmt(foamNewLabel(label)foamNew(FOAM_Label, 1, (AInt)(label)), NULL((void*)0));
1083}

1085/*
* This code generator tries to avoid domain lookup failures
* by testing for an export before attempting to forcing the
* lazy version. If the export is not found then no forcing
* is performed and (SInt 0) returned. Hopefully by the time
* that the export really is needed we will have initialised
* it by some other route.
*
* We want to generate the following code:
*
*     if (self has foo) L0;
*     tmpvar = (SInt 0);
*     goto L1;
* L0: tmpvar = lazyForceExport! val;
* L1: ...
*
* This trick helps to avoid bug #1221: while building % we
* try to initialise another domain parameterised by %. This
* domain is actually a domain-valued function and eagerly
* asks us a question. Unfortunately this causes us to force
* a simple (non-lambda) export that we haven't been able to
* create yet. Luckily the forced export isn't needed yet:
* if it was then we are in trouble.
*/
1109localstatic Foam
1110gen0TryForceLazy(Foam self, Syme syme, Foam lazy)
1111{
Bool		flag;
Foam		test, tmpvar, val;
FoamList	topLines;
int		l1, l2;
AbSyn		absyn = (AbSyn)NULL((void*)0);
FoamTag type = gen0Type(symeType(syme), NULL((void*)0));

/* Get some labels */
l1 = gen0State->labelNo++;
l2 = gen0State->labelNo++;


/* Standard guff */
flag = gen0AddImportPlace(&topLines);


/* Export values must fit into a word */
tmpvar = gen0TempLocal(FOAM_Word)gen0TempLocal0(FOAM_Word, 4);


/* Create the "has" test */
test = gen0HasImport(foamCopy(self), syme);
test = foamNewCast(FOAM_Bool, test)foamNew(FOAM_Cast, 2, FOAM_Bool, test);


/* Test for the export that we want to force */
gen0AddStmt(foamNewIf(test, l1)foamNew(FOAM_If, 2, test, l1), absyn);


/* Export not found: use a neutral value/bad pointer */
val = foamNewCast(FOAM_Word, foamNeutralValue(type))foamNew(FOAM_Cast, 2, FOAM_Word, foamNeutralValue(type));
gen0AddStmt(foamNewSet(foamCopy(tmpvar), val)foamNew(FOAM_Set, 2, foamCopy(tmpvar), val), absyn);


/* Jump to the place where we update the export */
gen0AddStmt(foamNewGoto(l2)foamNew(FOAM_Goto, 1, (AInt)(l2)), absyn);


/* Target for the successful if-test */
gen0AddStmt(foamNewLabel(l1)foamNew(FOAM_Label, 1, (AInt)(l1)), absyn);


/* Force the lazy export */
val = gen0LazyValue(lazy, syme);
gen0AddStmt(foamNewSet(foamCopy(tmpvar), val)foamNew(FOAM_Set, 2, foamCopy(tmpvar), val), absyn);


/* Target for the export update */
gen0AddStmt(foamNewLabel(l2)foamNew(FOAM_Label, 1, (AInt)(l2)), absyn);


/* Standard guff */
if (flag) gen0ResetImportPlace(topLines);


/* Return the value of the export */
return tmpvar;
1169}

1171void
1172gen0InitExport(Syme syme)
1173{
Foam	self, val;

assert(symeIsExport(syme)||symeIsExtend(syme))do { if (!((((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->kind) == SYME_Export
)||(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme
)->lib) : ((void*)0)), (syme))->kind) == SYME_Extend)))
 _do_assert(("symeIsExport(syme)||symeIsExtend(syme)"),"gf_add.c"
,1176); } while (0);
assert(gen0ExportState->self)do { if (!(gen0ExportState->self)) _do_assert(("gen0ExportState->self"
),"gf_add.c",1177); } while (0);

self = foamCopy(gen0ExportState->self);
val  = gen0GetDomImport(syme, self);

foamSyme(val)((val)->hdr.syme) = syme;

if (gen0IsLazyConst(symeType(syme)))
val = gen0TryForceLazy(self, syme, val);

gen0AddStmt(foamNewSet(gen0Syme(syme), val)foamNew(FOAM_Set, 2, gen0Syme(syme), val), NULL((void*)0));
if (foamTag(self)((self)->hdr.tag) == FOAM_Lex)
gen0UseStackedFormat(self->foamLex.level);
1190}

1192localstatic SymeList
1193gen0AddExportedSymes()
1194{
SymeList symes;

if (gen0State->parent &&
   gen0State->parent->parent &&
   gen0State->parent->parent->tag == GF_Lambda &&
   gen0State->parent->parent->stab) {
symes = stabGetExportedSymes(gen0State->parent->parent->stab);
symes = listConcat(Syme)(Syme_listPointer->Concat)(stabGetExportedSymes(gen0State->stab),
		         symes);
}
else symes = stabGetExportedSymes(gen0State->stab);

return symes;
1208}


1211void
1212gen0SymeSetInit(Syme syme, Foam foam)
1213{
tblSetElt(gen0ExportState->domInittedTbl, syme, foam);
1215}

1217Foam 
1218gen0SymeInit(Syme syme)
1219{
return (Foam) tblElt(gen0ExportState->domInittedTbl, syme, NULL((void*)0));
1221}


1224/* Conditional export */
1225/* COND-DEF */
1226Foam
1227gen0SymeCond(Syme syme)
1228{
Foam	result;
_GfCond	cond;

cond.syme = syme;
cond.condition = gfCondKnown;

result = (Foam) tblElt(gen0ExportState->domCondTbl, &cond, NULL((void*)0));
return result;
1237}

1239/* COND-DEF */
1240void
1241gen0SymeSetCond(Syme syme, Foam foam)
1242{
GfCond	cond = (GfCond)stoAlloc(OB_Other0, sizeof(*cond));

cond->syme = syme;
cond->condition = ablogCopy(gfCondKnown);

tblSetElt(gen0ExportState->domCondTbl, cond, foam);
1249}


1252/* Return a simpler sefo with the same type */

1254Sefo
1255gen0EqualMods(Sefo sefo)
1256{
Bool	changed = (sefo != NULL((void*)0));

while (changed)
switch (abTag(sefo)((sefo)->abHdr.tag)) {
case AB_PretendTo:
	sefo = sefo->abPretendTo.expr;
	break;
case AB_RestrictTo:
	sefo = sefo->abRestrictTo.expr;
	break;
case AB_Qualify:
	sefo = sefo->abQualify.what;
	break;
case AB_Assign:
	sefo = sefo->abAssign.lhs;
	break;
case AB_Define:
	sefo = sefo->abDefine.lhs;
	break;
case AB_Documented:
	sefo = sefo->abDocumented.expr;
	break;
case AB_Declare:
	sefo = sefo->abDeclare.id;
	break;
case AB_For:
	sefo = sefo->abFor.lhs;
	break;
case AB_Local:
case AB_Free:
case AB_Sequence:
case AB_Comma:
	if (abArgc(sefo)((sefo)->abHdr.argc) == 1)
		sefo = abArgv(sefo)((sefo)->abGen.data.argv)[0];
	else
		changed = false((int) 0);
	break;
default:
	changed = false((int) 0);
	break;
}

/*
* AB_Except is a bit of an oddity - in this case, the lhs won't be
* simplified, which may mean this function doesn't quite work.
*/
assert(sefo == NULL ||do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0)
      abTag(sefo) == AB_Id ||do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0)
      abTag(sefo) == AB_Apply ||do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0)
      abTag(sefo) == AB_Except ||do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0)
      abTag(sefo) == AB_Add ||do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0)
      abTag(sefo) == AB_With ||do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0)
      (abIsLeaf(sefo) && abSyme(sefo)))do { if (!(sefo == ((void*)0) || ((sefo)->abHdr.tag) == AB_Id
 || ((sefo)->abHdr.tag) == AB_Apply || ((sefo)->abHdr.tag
) == AB_Except || ((sefo)->abHdr.tag) == AB_Add || ((sefo)
->abHdr.tag) == AB_With || ((((sefo)->abHdr.tag) < AB_NODE_START
) && ((sefo)->abHdr.seman ? (sefo)->abHdr.seman
->syme : 0)))) _do_assert(("sefo == NULL || abTag(sefo) == AB_Id || abTag(sefo) == AB_Apply || abTag(sefo) == AB_Except || abTag(sefo) == AB_Add || abTag(sefo) == AB_With || (abIsLeaf(sefo) && abSyme(sefo))"
),"gf_add.c",1309); } while (0);
return sefo;
1311}


1314Foam 
1315gen0LocalSelf()
1316{
Foam foam = foamCopy(gen0ExportState->self);

if (gen0HasSelf)
return foamCopy(gen0HasSelf);

gen0AddLexLevels(foam,
	 gen0State->foamLevel
	 - gen0ExportState->foamLevel);
return foam;

1327}

1329Syme
1330gen0LocalSelfSyme()
1331{
if (gen0ExportState == NULL((void*)0))
return NULL((void*)0);
return gen0ExportState->selfSyme;
1335}

1337/*****************************************************************************
*
* :: Selection of an appropriate hashing scheme, and delayed 
*    export hashcode finding
*
****************************************************************************/

1344localstatic Bool 	gen0SefoListIsCachable	(SefoList);
1345localstatic Foam	gen0DCacheAddItem	(HashType, Pointer, Pointer);
1346localstatic Bool	gen0DCacheMatch		(DomainCache dc, 	
			 HashType type, 
			 Pointer arg0, Pointer arg1);
1349localstatic void	gen0IssueDCache1	(void);
1350static Bool gen0DCacheInIssue = false((int) 0);

1352Foam
1353gen0TypeHash(TForm tf, TForm otf, String name)
1354{
SefoList sfl = gen0GetSefoInnerSefos(tfExpr(tf)tfToAbSyn(tf));

if (tfTag(otf)((otf)->tag) == TF_With)
gen0RtTypeHashWith(tf, otf, name);

if (!gen0DCacheInIssue && gen0SefoListIsCachable(sfl)) {
listFree(Sefo)(Sefo_listPointer->Free)(sfl);
return gen0DCacheAddItem(HT_TFormHash, tf, otf);
}
listFree(Sefo)(Sefo_listPointer->Free)(sfl);
return gen0RtTypeHash(tf, otf);
1366}

1368Foam 
1369gen0SefoHashExporter(Sefo sf)
1370{
return gen0RtSefoHashExporter(sf);
1372}

1374Foam 
1375gen0SefoHash(Sefo sf, Sefo osf)
1376{
SefoList sfl = gen0GetSefoInnerSefos(sf);

if (!gen0DCacheInIssue && gen0SefoListIsCachable(sfl)) {
listFree(Sefo)(Sefo_listPointer->Free)(sfl);
return gen0DCacheAddItem(HT_SefoHash, sf, osf);
}
listFree(Sefo)(Sefo_listPointer->Free)(sfl);
return gen0RtSefoHash(sf, osf);
1385}

1387/* Can we make a cache at the start of a function... */
1388localstatic Bool 
1389gen0SefoListIsCachable(SefoList sfl)
1390{
Sefo 	 sf;
Syme	 syme;

while (sfl != listNil(Sefo)((SefoList) 0)) {
sf = car(sfl)((sfl)->first);
if (abTag(sf)((sf)->abHdr.tag) != AB_Id)
	return false((int) 0);
syme = abSyme(sf)((sf)->abHdr.seman ? (sf)->abHdr.seman->syme : 0);
if (!syme)
	return false((int) 0);
if (!symeIsSelf(syme)(((syme)->id) == ssymSelf)
    && !symeIsParam(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Param))
	return false((int) 0);
/* In 'has' expression => Weird self */
if (symeIsSelf(syme)(((syme)->id) == ssymSelf) && gen0HasSelf) return false((int) 0);
sfl = cdr(sfl)((sfl)->rest);
}
return true1;
1409}

1411localstatic Foam
1412gen0DCacheAddItem(HashType type, Pointer arg0, Pointer arg1)
1413{
DomainCacheList dcl;
DomainCache 	cache, dc;
Foam 	    	tmp;

dcl = gen0State->domCache;

while (dcl != listNil(DomainCache)((DomainCacheList) 0)) {
dc = car(dcl)((dcl)->first);
if (gen0DCacheMatch(dc, type, arg0, arg1))
	return foamCopy(dc->hashVar);

dcl = cdr(dcl)((dcl)->rest);
}

tmp = gen0Temp(FOAM_SInt)gen0Temp0(FOAM_SInt, 4);

cache = (DomainCache) stoAlloc(OB_Other0, sizeof(*cache));
cache->hashVar  = tmp;
cache->type	= type;
cache->args[0]  = arg0;
cache->args[1]  = arg1;

if (type == HT_Id)
gen0State->domCache = 
	listNConcat(DomainCache)(DomainCache_listPointer->NConcat)
		(gen0State->domCache,
		 listCons(DomainCache)(DomainCache_listPointer->Cons)(cache, 
				       listNil(DomainCache)((DomainCacheList) 0)));
else
gen0State->domCache = 
	listCons(DomainCache)(DomainCache_listPointer->Cons)(cache, gen0State->domCache);

return foamCopy(tmp);
1447}

1449localstatic Bool
1450gen0DCacheMatch(DomainCache dc, HashType type, Pointer arg0, Pointer arg1)
1451{
if (dc->type != type)
return false((int) 0);

if (dc->args[0] == arg0 &&
   dc->args[1] == arg1) 
return true1;
if (type == HT_SefoHash)
return sefoEqual((Sefo)(dc->args[0]), (Sefo) arg0);
if (type == HT_TFormHash)
return tfEqual((TForm)(dc->args[0]), (TForm) arg0);

return false((int) 0);
1464}

1466/* Flushing the cache */
1467void
1468gen0IssueDCache()
1469{
gen0IssueDCache1();
/* HT_Id's may appear */
if (gen0State->domCache)
gen0IssueDCache1();

assert(gen0State->domCache == NULL)do { if (!(gen0State->domCache == ((void*)0))) _do_assert(
("gen0State->domCache == NULL"),"gf_add.c",1475); } while (
0);
1476}

1478localstatic void
1479gen0IssueDCache1()
1480{
DomainCacheList dcl = listNReverse(DomainCache)(DomainCache_listPointer->NReverse)(gen0State->domCache);
DomainCache     dc;
FoamList	stmts;
Foam 		set, rhs = NULL((void*)0);

gen0DCacheInIssue = true1;
stmts = gen0State->lines;
gen0State->lines = NULL((void*)0);
gen0State->domCache = listNil(DomainCache)((DomainCacheList) 0);

while (dcl != listNil(DomainCache)((DomainCacheList) 0)) {
dc = car(dcl)((dcl)->first);
switch (dc->type) {
  case HT_TFormHash:
	rhs = gen0RtTypeHash((TForm) (dc->args[0]), 
			     (TForm) (dc->args[1]));
	break;
  case HT_SefoHash:
	rhs = gen0RtSefoHash((Sefo) (dc->args[0]), 
			     (Sefo) (dc->args[1]));
	break;
  case HT_SefoHashExporter:
	rhs = gen0RtSefoHashExporter((Sefo) (dc->args[0]));
	break;
  case HT_Id:
	rhs = gen0RtDomainHash(gen0Syme((Syme)(dc->args[0])));
	break;
  default:
	bug("Unexpected hash-kind");
	break;
}
set = foamNewDef(dc->hashVar, rhs)foamNew(FOAM_Def, 2, dc->hashVar, rhs);
gen0AddStmt(set, NULL((void*)0));
dcl = cdr(dcl)((dcl)->rest);
}

gen0State->lines = listNConcat(Foam)(Foam_listPointer->NConcat)(stmts, gen0State->lines);
listFree(DomainCache)(DomainCache_listPointer->Free)(dcl);
gen0DCacheInIssue = false((int) 0);
1520}


1523/*****************************************************************************
*
* :: Foam code generation for (runtime) hash values
*
****************************************************************************/

1529#define foamNewProgInfo(x)foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg, 1, x))	foamNewPRef(0, foamNewCProg(x))foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg, 1, x))

1531localstatic Foam	gen0RtTypeHashAsGeneral		(TForm);
1532localstatic Foam      gen0RtTypeHashTuple             (Sefo, Foam);
1533localstatic Foam      gen0RtTypeHashMap		(TForm, TForm);
1534localstatic Bool	gen0RtSefoIsSpecialOp		(AbSyn);
1535localstatic Foam	gen0RtSefoHashSpecialExporter	(Sefo, Sefo);
1536localstatic Foam	gen0RtSefoHashId		(Sefo, Sefo);
1537localstatic Foam	gen0RtSefoHashApply		(Sefo, Sefo);
1538localstatic Foam	gen0RtSefoHashStdApply		(Sefo, Sefo);
1539localstatic Foam	gen0RtSefoHashSpecialApply	(Sefo);
1540localstatic Foam	gen0RtSefoHashEnum		(Sefo, SefoList);
1541localstatic Foam	gen0RtSefoHashList		(SefoList, SefoList, Foam);
1542localstatic SefoList	gen0RtSefoMakeArgList		(Sefo);
1543localstatic Foam	gen0RtTypeHashAsGeneral		(TForm);
1544localstatic Foam	gen0RtTypeHashAsGeneralMap	(TForm);
1545localstatic void	gen0RtUseDeclares		(SefoList);
1546localstatic SefoList  gen0RtSefoListUnComma		(SefoList);
1547localstatic Foam	gen0RtIsProgInfoNull		(Foam);
1548localstatic Foam      gen0RtSefoHashExpr		(Sefo, Sefo);

1550Foam 
1551gen0RtSetProgHash(Foam clos, AInt hash)
1552{
return foamNewSet(foamNewProgInfo(clos),foamNew(FOAM_Set, 2, foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg
, 1, clos)), foamNew(FOAM_SInt, 1, (AInt)(hash)))
	  foamNewSInt(hash))foamNew(FOAM_Set, 2, foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg
, 1, clos)), foamNew(FOAM_SInt, 1, (AInt)(hash)));
1555}

1557static unsigned long gen0RtArgHashSeed = 74755L;
1558static unsigned long *gen0RtArgHashMask = (unsigned long *)NULL((void*)0);

1560/*
* A trivial random number generator: it doesn't have to be good
* (it isn't), it just has to generate exactly the same sequence
* of pseudo-random numbers on every platform the compiler runs on.
* It returns a 15-bit unsigned number but must be able to perform
* unsigned arithmetic on 27-bit numbers without overflow.
*/
1567unsigned long gen0RtRand(void)
1568{
gen0RtArgHashSeed = (gen0RtArgHashSeed*1309L + 13849L) & 65535L;
return gen0RtArgHashSeed;
1571}

1573localstatic void
1574gen0RtInitRand(void)
1575{
gen0RtArgHashSeed = 74755L;
1577}


1580/* Allocate and populate gen0RtArgHashMask */
1581localstatic void
1582gen0RtInitHashMask(void)
1583{
int i;
unsigned long required;

/* Do nothing if already initialised */
if (gen0RtArgHashMask) return;

/* How many bytes of store are needed? */
required = ((int)TF_LIMIT)*sizeof(unsigned long);
gen0RtArgHashMask = (unsigned long *)stoAlloc(int0((int) 0), required);

/* Reset the random number generator */
gen0RtInitRand();

/* Generate a hash mask for each tform type */
for (i = 0; i < TF_LIMIT; i++) gen0RtArgHashMask[i] = gen0RtRand();
1599}

1601localstatic Foam
1602gen0RtTypeHash(TForm tf, TForm otf)
1603{
TFormList	tfl = 0, otfl = 0, l, ol;
Foam		hash = 0;
int		code, i;

if (genIsRuntime()(gen0IsRuntime))
return foamNewSInt(int0)foamNew(FOAM_SInt, 1, (AInt)(((int) 0)));
/* first fill tfl with the tforms we want to combine */
tf  = tfDefineeType(tf);
otf = tfDefineeType(otf);

code = gen0StrHash(tformSyntax(tfTag(tf))tformInfoTable[(int)(((tf)->tag)) - (int)TF_START].syntax);

if (tfTag(otf)((otf)->tag) == TF_General && tfTag(tf)((tf)->tag) != TF_General)
return gen0RtTypeHashAsGeneral(tf);

if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) {
return gen0RtTypeHashMap(tf, otf);
}

if (tfArgc(otf)((otf)->argc) != tfArgc(tf)((tf)->argc))
otf = tf;

switch (tfTag(otf)((otf)->tag)) {
case TF_Map:
case TF_PackedMap:
bug("Unreachable");
break;
case TF_RawRecord:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1632); } while (0);
for (i = 0; i < tfRawRecordArgc(tf); i++) {
	tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfRawRecordArgN(tf, i)tfFollowArg(tf, i), tfl);
	otfl = listCons(TForm)(TForm_listPointer->Cons)(tfRawRecordArgN(otf, i)tfFollowArg(otf, i), otfl);
}
break;
case TF_Record:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1639); } while (0);
for (i = 0; i < tfRecordArgc(tf); i++) {
	tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfRecordArgN(tf, i)tfFollowArg(tf, i), tfl);
	otfl = listCons(TForm)(TForm_listPointer->Cons)(tfRecordArgN(otf, i)tfFollowArg(otf, i), otfl);
}
break;
case TF_Union:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1646); } while (0);
for (i = 0; i < tfUnionArgc(tf); i++) {
	tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfUnionArgN(tf, i)tfFollowArg(tf, i), tfl);
	otfl = listCons(TForm)(TForm_listPointer->Cons)(tfUnionArgN(otf, i)tfFollowArg(otf, i), otfl);
}
break;
case TF_Cross:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1653); } while (0);
for (i = 0; i < tfCrossArgc(tf); i++) {
	tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfCrossArgN(tf, i)tfFollowArg(tf, i), tfl);
	otfl = listCons(TForm)(TForm_listPointer->Cons)(tfCrossArgN(otf, i)tfFollowArg(otf, i), otfl);
}
break;
case TF_Multiple:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1660); } while (0);
for (i = 0; i < tfMultiArgc(tf); i++) {
	tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfMultiArgN(tf, i)tfFollowArg(tf, i), tfl);
	otfl = listCons(TForm)(TForm_listPointer->Cons)(tfMultiArgN(otf, i)tfFollowArg(otf, i), otfl);
}
break;
case TF_Tuple:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1667); } while (0);
tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfTupleArg( tf)tfFollowArg(tf, 0), listNil(TForm)((TFormList) 0));
otfl = listCons(TForm)(TForm_listPointer->Cons)(tfTupleArg(otf)tfFollowArg(otf, 0), listNil(TForm)((TFormList) 0));
break;
case TF_Generator:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1672); } while (0);
tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfGeneratorArg( tf)tfFollowArg(tf, 0), listNil(TForm)((TFormList) 0));
otfl = listCons(TForm)(TForm_listPointer->Cons)(tfGeneratorArg(otf)tfFollowArg(otf, 0), listNil(TForm)((TFormList) 0));
break;
case TF_Reference:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1677); } while (0);
tfl  = listCons(TForm)(TForm_listPointer->Cons)(tfReferenceArg( tf)tfFollowArg(tf, 0), listNil(TForm)((TFormList) 0));
otfl = listCons(TForm)(TForm_listPointer->Cons)(tfReferenceArg(otf)tfFollowArg(otf, 0), listNil(TForm)((TFormList) 0));
break;
case TF_Enumerate:
assert(tfTag(tf) == tfTag(otf))do { if (!(((tf)->tag) == ((otf)->tag))) _do_assert(("tfTag(tf) == tfTag(otf)"
),"gf_add.c",1682); } while (0);
hash = foamNewSInt(code)foamNew(FOAM_SInt, 1, (AInt)(code));
for (i = 0; i < tfEnumArgc(tf); i++) {
	String  lit;
	AbSyn   tfi  = abDefineeId(tfExpr(tfEnumArgN(tf, i))tfToAbSyn(tfFollowArg(tf, i)));
	assert(abTag(tfi) == AB_Id)do { if (!(((tfi)->abHdr.tag) == AB_Id)) _do_assert(("abTag(tfi) == AB_Id"
),"gf_add.c",1687); } while (0);
	lit = tfi->abId.sym->str;
	hash = gen0CombineHash(foamNewSInt(gen0StrHash(lit))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(lit))),
			       hash);
}
break;
case TF_Literal:
break;

case TF_With:
code = 0;
break;
case TF_General:
hash = gen0RtSefoHash(tfExpr(tf)tfToAbSyn(tf), tfExpr(otf)tfToAbSyn(otf));
default:
break;
}
if (!hash)
hash = foamNewSInt(code)foamNew(FOAM_SInt, 1, (AInt)(code));
tfl  = listNReverse(TForm)(TForm_listPointer->NReverse)(tfl);
otfl = listNReverse(TForm)(TForm_listPointer->NReverse)(otfl);

for (i = 0, l = tfl, ol = otfl; l; i++, l = cdr(l)((l)->rest), ol = cdr(ol)((ol)->rest)) {
hash = gen0CombineHash(gen0RtTypeHash(car(l)((l)->first), car(ol)((ol)->first)), hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;
}

return hash;
1715}

1717localstatic Bool
1718tfMapArgIsTuple(TForm tf)
1719{
if (tfMapArgc(tf) != 1)
return false((int) 0);
if (abTUnique(tfExpr(tfMapArg(tf)))((tfToAbSyn(tfFollowArg(tf, 0)))->abHdr.type.unique) == NULL((void*)0))
return false((int) 0);
return tfIsTypeTuple(abTUnique(tfExpr(tfMapArg(tf)))((tfToAbSyn(tfFollowArg(tf, 0)))->abHdr.type.unique));
1725}

1727localstatic Bool
1728tfMapRetIsTuple(TForm tf)
1729{
if (tfMapRetc(tf) != 1)
return false((int) 0);
if (abTUnique(tfExpr(tfMapRet(tf)))((tfToAbSyn(tfFollowArg(tf, 1)))->abHdr.type.unique) == NULL((void*)0))
return false((int) 0);
return tfIsTypeTuple(abTUnique(tfExpr(tfMapRet(tf)))((tfToAbSyn(tfFollowArg(tf, 1)))->abHdr.type.unique));
1735}

1737localstatic Foam
1738gen0RtTypeHashMap(TForm tf, TForm otf)
1739{
int code = gen0StrHash(tformSyntax(tfTag(tf))tformInfoTable[(int)(((tf)->tag)) - (int)TF_START].syntax);
Foam hash, twist;
int i;
assert(tfIsAnyMap(tf))do { if (!(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))) _do_assert(("tfIsAnyMap(tf)"),"gf_add.c",1743); } while (
0);
assert(tfIsAnyMap(otf))do { if (!(((((otf)->tag) == TF_Map) || (((otf)->tag) ==
 TF_PackedMap)))) _do_assert(("tfIsAnyMap(otf)"),"gf_add.c",1744
); } while (0);

if (!gen0RtArgHashMask) gen0RtInitHashMask();

hash = foamNewSInt(code)foamNew(FOAM_SInt, 1, (AInt)(code));

if (tfMapArgIsTuple(tf)) {
hash = gen0RtTypeHashTuple(tfExpr(tfMapArg(tf))tfToAbSyn(tfFollowArg(tf, 0)), hash);
}
else {
TForm otfX = (tfMapArgIsTuple(otf)) ? tf : otf;
for(i=0; i<tfMapArgc(tf); i++) {
	TForm ptf = tfMapArgN(tf, i);
	TForm potf = tfMapArgN(otfX, i);
	Foam val = gen0RtTypeHash(ptf, potf);
	hash = gen0CombineHash(val, hash);
	foamPure(hash)((hash)->hdr.info.pure) = true1;
}
}
twist = foamNewSInt(gen0RtArgHashMask[tfTag(otf)])foamNew(FOAM_SInt, 1, (AInt)(gen0RtArgHashMask[((otf)->tag
)]));
foamPure(twist)((twist)->hdr.info.pure) = true1;

hash = gen0CombineHash(twist, hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;

if (tfMapRetIsTuple(tf)) {
hash = gen0RtTypeHashTuple(tfExpr(tfMapRet(tf))tfToAbSyn(tfFollowArg(tf, 1)), hash);
}
else {
TForm otfX = (tfMapArgIsTuple(otf)) ? tf : otf;
for(i=0; i<tfMapRetc(tf); i++) {
	TForm ptf = tfMapRetN(tf, i);
	TForm potf = tfMapRetN(otfX, i);
	Foam val = gen0RtTypeHash(ptf, potf);
	hash = gen0CombineHash(val, hash);
	foamPure(hash)((hash)->hdr.info.pure) = true1;
}
}
return hash;
1783}

1785localstatic Foam
1786gen0RtTypeHashAsGeneralMap(TForm tf)
1787{
int code = gen0StrHash(tformSyntax(tfTag(tf))tformInfoTable[(int)(((tf)->tag)) - (int)TF_START].syntax);
Foam hash, twist;
int i;
assert(tfIsAnyMap(tf))do { if (!(((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
)))) _do_assert(("tfIsAnyMap(tf)"),"gf_add.c",1791); } while (
0);

if (!gen0RtArgHashMask) gen0RtInitHashMask();

hash = foamNewSInt(code)foamNew(FOAM_SInt, 1, (AInt)(code));

if (tfMapArgIsTuple(tf)) {
hash = gen0RtTypeHashTuple(tfExpr(tfMapArg(tf))tfToAbSyn(tfFollowArg(tf, 0)), hash);
}
else {
for(i=0; i<tfMapArgc(tf); i++) {
	TForm ptf = tfMapArgN(tf, i);
	Foam val = gen0RtTypeHash(ptf, ptf);
	hash = gen0CombineHash(val, hash);
	foamPure(hash)((hash)->hdr.info.pure) = true1;
}
}
twist = foamNewSInt(gen0RtArgHashMask[tfTag(tf)])foamNew(FOAM_SInt, 1, (AInt)(gen0RtArgHashMask[((tf)->tag)
]));
foamPure(twist)((twist)->hdr.info.pure) = true1;

hash = gen0CombineHash(twist, hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;

if (tfMapRetIsTuple(tf)) {
hash = gen0RtTypeHashTuple(tfExpr(tfMapRet(tf))tfToAbSyn(tfFollowArg(tf, 1)), hash);
}
else {
for(i=0; i<tfMapRetc(tf); i++) {
	TForm ptf = tfMapRetN(tf, i);
	Foam val = gen0RtTypeHash(ptf, ptf);
	hash = gen0CombineHash(val, hash);
	foamPure(hash)((hash)->hdr.info.pure) = true1;
}
}
return hash;
1826}


1829/*
* Left as a function, as the hashcode for a TF_With is odd.
*/

1833localstatic Foam
1834gen0RtTypeHashWith(TForm tf, TForm otf, String name)
1835{
if (name)
return foamNewSInt(gen0StrHash(name))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(name)));
else
return foamNewSInt(int0)foamNew(FOAM_SInt, 1, (AInt)(((int) 0)));
1840}

1842localstatic Foam
1843gen0RtTypeHashAsGeneral(TForm tf)
1844{
TFormList	tfl = listNil(TForm)((TFormList) 0);
Foam		hash = NULL((void*)0);
int		code, i;

code = gen0StrHash(tformSyntax(tfTag(tf))tformInfoTable[(int)(((tf)->tag)) - (int)TF_START].syntax);

if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT) || tfIsThird(tf)(((tf)->tag) == TF_Third))
return gen0RtSefoHash(tfExpr(tf)tfToAbSyn(tf), tfExpr(tf)tfToAbSyn(tf));

if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) || (((tf)->tag) == TF_PackedMap
))) {
return gen0RtTypeHashAsGeneralMap(tf);
}

switch(tfTag(tf)((tf)->tag)) {
case TF_Map:
case TF_PackedMap:
bug("unreachable");
break;
case TF_RawRecord:
for (i = 0; i < tfRawRecordArgc(tf); i += 1) {
	TForm	tfi = tfRawRecordArgN(tf, i)tfFollowArg(tf, i);
	tfl = listCons(TForm)(TForm_listPointer->Cons)(tfDefineeType(tfi), tfl);
}
break;
case TF_Record:
for (i = 0; i < tfRecordArgc(tf); i += 1) {
	TForm	tfi = tfRecordArgN(tf, i)tfFollowArg(tf, i);
	tfl = listCons(TForm)(TForm_listPointer->Cons)(tfDefineeType(tfi), tfl);
}
break;
case TF_Union:
for (i = 0; i < tfUnionArgc(tf); i += 1) {
	TForm	tfi = tfUnionArgN(tf, i)tfFollowArg(tf, i);
	tfl = listCons(TForm)(TForm_listPointer->Cons)(tfDefineeType(tfi), tfl);
}
break;
case TF_Cross:
for (i = 0; i < tfCrossArgc(tf); i += 1)
	tfl = listCons(TForm)(TForm_listPointer->Cons)(tfCrossArgN(tf, i)tfFollowArg(tf, i), tfl);
break;
case TF_Tuple:
tfl = listCons(TForm)(TForm_listPointer->Cons)(tfTupleArg(tf)tfFollowArg(tf, 0), listNil(TForm)((TFormList) 0));
break;
case TF_Reference:
tfl = listCons(TForm)(TForm_listPointer->Cons)(tfReferenceArg(tf)tfFollowArg(tf, 0), listNil(TForm)((TFormList) 0));
break;
case TF_Generator:
tfl = listCons(TForm)(TForm_listPointer->Cons)(tfGeneratorArg(tf)tfFollowArg(tf, 0), listNil(TForm)((TFormList) 0));
break;
case TF_Enumerate:
hash = foamNewSInt(code)foamNew(FOAM_SInt, 1, (AInt)(code));
for (i = 0; i < tfEnumArgc(tf); i++) {
	String lit;
	AbSyn  tfi = abDefineeId(tfExpr(tfEnumArgN(tf, i))tfToAbSyn(tfFollowArg(tf, i)));
	lit = tfi->abId.sym->str;
	hash = gen0CombineHash(foamNewSInt(gen0StrHash(lit))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(lit))),
			       hash);
}
break;
default:
tfPrintDb(tf);
bug("unhandled special type used in value context");
}

tfl = listNReverse(TForm)(TForm_listPointer->NReverse)(tfl);
if (hash == NULL((void*)0))
hash = foamNewSInt(code)foamNew(FOAM_SInt, 1, (AInt)(code));

for(i = 0; tfl; i++, tfl = cdr(tfl)((tfl)->rest)) {
hash = gen0CombineHash(gen0RtTypeHash(car(tfl)((tfl)->first),car(tfl)((tfl)->first)),hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;
}


return hash;
1920}

1922localstatic Foam
1923gen0RtSefoHashExporter(Sefo sf)
1924{
Foam	hash, hi;

if (genIsRuntime()(gen0IsRuntime) || sf == NULL((void*)0) || abHasTag(sf, AB_With)((sf)->abHdr.tag == (AB_With)))
return foamNewSInt(int0)foamNew(FOAM_SInt, 1, (AInt)(((int) 0)));

sf = gen0EqualMods(sf);

switch(abTag(sf)((sf)->abHdr.tag)) {
 case AB_Id:
hash = foamNewSInt(gen0StrHash(symString(abIdSym(sf))))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((((sf)->abId.sym
))->str))));
break;
 case AB_Apply:
if (gen0RtSefoIsSpecialOp(sf))
	hash = gen0RtSefoHashSpecialExporter(sf, NULL((void*)0));
else {
	Length	i;
	hash = gen0RtSefoHashExporter(abApplyOp(sf)((sf)->abApply.op));

	for (i = 0; i < abApplyArgc(sf)(((sf)->abHdr.argc)-1); i += 1) {
		hi = gen0RtSefoHash(abApplyArg(sf, i)((sf)->abApply.argv[i]), NULL((void*)0));
		hash = gen0CombineHash(hi, hash);
	}
}
break;
 case AB_LitInteger:
 case AB_LitFloat:
 case AB_LitString:
 default:
comsgFatal((AbSyn)sf, ALDOR_F_Bug365, "unexpected exporter");
NotReached(hash = 0){(void)bug("Not supposed to reach line %d in file: %s\n",1954
, "gf_add.c");};
}

return hash;
1958}

1960/*
* This nonsense is to get the definition of     Record(T:Tuple) == add
* to generate the same hash code as the use of  Record(A,B,C,D)
*/
1964localstatic Bool
1965gen0RtSefoIsSpecialOp(AbSyn ab)
1966{
AbSyn	op = abApplyOp(ab)((ab)->abApply.op);
Symbol	sym = abIsId(op)((op)->abHdr.tag == (AB_Id)) ? abIdSym(op)((op)->abId.sym) : NULL((void*)0);

return	sym == ssymArrow	||
sym == ssymPackedArrow	||
sym == ssymCross	||
sym == ssymRawRecord	||
sym == ssymRecord	||
sym == ssymUnion	||
sym == ssymEnum;
1977}

1979/* Convert special operation into a tform tag */
1980localstatic int
1981gen0RtSymSpecialTag(Symbol sym)
1982{
/* We aren't interested in every special */
if (sym == ssymArrow)		return (int)TF_Map;
if (sym == ssymPackedArrow)	return (int)TF_PackedMap;
if (sym == ssymCross)		return (int)TF_Cross;
if (sym == ssymRawRecord)	return (int)TF_RawRecord;
if (sym == ssymRecord)		return (int)TF_Record;
if (sym == ssymUnion)		return (int)TF_Union;
if (sym == ssymEnum)		return (int)TF_START;

/* All other specials are ignored */
return (int)TF_START;
1994}

1996/*
* Generate this code:
*
*     Th := hash(operatorString);
*  ** for each arg **
*     Tt := arg.i;
*     Tn := #Tt;
*     Ti := 0;
* TS: if (Ti = Tn) goto TE;
*     Th := gen0CombineHash(getDomainHash! tuple.i, Th);
*     Ti := Ti + 1;
*     goto TS
* TE: nop
*  ** end for each arg **
*  ** genFoamVal is Th **
*/       

2013#define GSTAT(x)gen0AddStmt(x, ((void*)0))	gen0AddStmt(x, NULL((void*)0))
2014#define GSET(l,r)foamNew(FOAM_Set, 2, foamCopy(l), r)	foamNewSet(foamCopy(l),r)foamNew(FOAM_Set, 2, foamCopy(l), r)

2016localstatic Foam
2017gen0RtSefoHashSpecialExporter(Sefo sf, Sefo osf)
2018{
Foam	Tt = gen0TempLocal0(FOAM_Rec, gen0MakeTupleFormat());
Foam 	Tn = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
Foam 	Ti = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
Foam 	Th = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
int	i;
AbSyn	op;
Bool	inEnum;

int	hashPoint = 0;
int	hashMask;
Symbol	opsym;
Foam	twist = (Foam)NULL((void*)0);

op = abApplyOp(sf)((sf)->abApply.op);
opsym = op->abId.sym;
inEnum = (opsym == ssymEnum);
hashMask = gen0RtSymSpecialTag(opsym);

assert(abTag(sf) == AB_Apply && abTag(abApplyOp(sf)) == AB_Id)do { if (!(((sf)->abHdr.tag) == AB_Apply && ((((sf
)->abApply.op))->abHdr.tag) == AB_Id)) _do_assert(("abTag(sf) == AB_Apply && abTag(abApplyOp(sf)) == AB_Id"
),"gf_add.c",2037); } while (0);
/* I don't think we ought to ever see this ... */
if ((opsym == ssymArrow) || (opsym == ssymPackedArrow))
hashPoint = 1; /* Only insert hash mask for maps */

/* Ensure that we have hash masks */
if (!gen0RtArgHashMask) gen0RtInitHashMask();

GSTAT(GSET(Th,foamNewSInt(gen0StrHash(symString(op->abId.sym)))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Th), foamNew(FOAM_SInt
, 1, (AInt)(gen0StrHash(((op->abId.sym)->str))))), ((void
*)0));

for (i = 0; i < abApplyArgc(sf)(((sf)->abHdr.argc)-1); i++) {
int	TS  = gen0State->labelNo++;	
int  	TE  = gen0State->labelNo++;
AbSyn	arg = abApplyArg(sf, i)((sf)->abApply.argv[i]);
Foam 	val;

assert(abTag(arg) == AB_Declare)do { if (!(((arg)->abHdr.tag) == AB_Declare)) _do_assert((
"abTag(arg) == AB_Declare"),"gf_add.c",2053); } while (0);
arg = arg->abDeclare.id;

GSTAT(GSET(Tt, foamNewCast(FOAM_Rec, genFoamVal(arg))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Tt), foamNew(FOAM_Cast
, 2, FOAM_Rec, genFoamVal(arg))), ((void*)0));
GSTAT(GSET(Tn, gen0NewTupleSizeRef(foamCopy(Tt))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Tn), foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(((int) 0)))), ((void*)0));
GSTAT(GSET(Ti, foamNewSInt(int0)))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Ti), foamNew(FOAM_SInt
, 1, (AInt)(((int) 0)))), ((void*)0));
GSTAT(foamNewLabel(TS))gen0AddStmt(foamNew(FOAM_Label, 1, (AInt)(TS)), ((void*)0));
GSTAT(foamNewIf(foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ,gen0AddStmt(foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ
, foamCopy(Ti), foamCopy(Tn)), TE), ((void*)0)) 
			foamCopy(Ti), foamCopy(Tn)), TE))gen0AddStmt(foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ
, foamCopy(Ti), foamCopy(Tn)), TE), ((void*)0));
/* Extra hash code merged in at the correct moment */
if (hashPoint && (i == hashPoint)) {
	twist = foamNewSInt(gen0RtArgHashMask[hashMask])foamNew(FOAM_SInt, 1, (AInt)(gen0RtArgHashMask[hashMask]));
	GSTAT(GSET(Th, gen0CombineHash(twist, foamCopy(Th))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Th), gen0CombineHash
(twist, foamCopy(Th))), ((void*)0));
}
val = foamNewAElt(FOAM_Word,foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(Ti),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(1)))
		  foamCopy(Ti),foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(Ti),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(1)))
		  gen0NewTupleValsRef(foamCopy(Tt)))foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(Ti),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(1)));
if (inEnum) 
	val = gen0BuiltinCCall(FOAM_SInt, "stringHash", "runtime", 1,
			       val);
else 
	val = gen0RtDomainHash(val);
GSTAT(GSET(Th, gen0CombineHash(val, foamCopy(Th))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Th), gen0CombineHash
(val, foamCopy(Th))), ((void*)0));
GSTAT(GSET(Ti, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntPlus,gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Ti), foamNew(FOAM_BCall
, 3, FOAM_BVal_SIntPlus, foamCopy(Ti), foamNew(FOAM_SInt, 1, (
AInt)(1)))), ((void*)0)) 
		       foamCopy(Ti), foamNewSInt(1))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Ti), foamNew(FOAM_BCall
, 3, FOAM_BVal_SIntPlus, foamCopy(Ti), foamNew(FOAM_SInt, 1, (
AInt)(1)))), ((void*)0));
GSTAT(foamNewGoto(TS))gen0AddStmt(foamNew(FOAM_Goto, 1, (AInt)(TS)), ((void*)0));
GSTAT(foamNewLabel(TE))gen0AddStmt(foamNew(FOAM_Label, 1, (AInt)(TE)), ((void*)0));
}

/* Add a dash of lime if not done so already */
if (!twist && hashPoint) {
twist = foamNewSInt(gen0RtArgHashMask[hashMask])foamNew(FOAM_SInt, 1, (AInt)(gen0RtArgHashMask[hashMask]));
GSTAT(GSET(Th, gen0CombineHash(twist, foamCopy(Th))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Th), gen0CombineHash
(twist, foamCopy(Th))), ((void*)0));
}

foamFree(Tt);
foamFree(Ti);
foamFree(Tn);

return Th;
2093}


2096localstatic Foam
2097gen0RtTypeHashTuple(Sefo sefo, Foam init)
2098{
Foam	Tt = gen0TempLocal0(FOAM_Rec, gen0MakeTupleFormat());
Foam 	Tn = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
Foam 	Ti = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
Foam 	Th = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
int	TS  = gen0State->labelNo++;
int  	TE  = gen0State->labelNo++;
Foam    val;

sefo = abDefineeTypeOrElse(sefo, sefo);

GSTAT(GSET(Th, init))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Th), init), ((void*
)0));

GSTAT(GSET(Tt, foamNewCast(FOAM_Rec, genFoamVal(sefo))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Tt), foamNew(FOAM_Cast
, 2, FOAM_Rec, genFoamVal(sefo))), ((void*)0));
GSTAT(GSET(Tn, gen0NewTupleSizeRef(foamCopy(Tt))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Tn), foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(((int) 0)))), ((void*)0));
GSTAT(GSET(Ti, foamNewSInt(int0)))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Ti), foamNew(FOAM_SInt
, 1, (AInt)(((int) 0)))), ((void*)0));
GSTAT(foamNewLabel(TS))gen0AddStmt(foamNew(FOAM_Label, 1, (AInt)(TS)), ((void*)0));
GSTAT(foamNewIf(foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ,gen0AddStmt(foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ
, foamCopy(Ti), foamCopy(Tn)), TE), ((void*)0))
		foamCopy(Ti), foamCopy(Tn)), TE))gen0AddStmt(foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntEQ
, foamCopy(Ti), foamCopy(Tn)), TE), ((void*)0));
val = foamNewAElt(FOAM_Word,foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(Ti),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(1)))
	  foamCopy(Ti),foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(Ti),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(1)))
	  gen0NewTupleValsRef(foamCopy(Tt)))foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(Ti),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(foamCopy(Tt)),(AInt
)(1)));

val = gen0RtDomainHash(val);

GSTAT(GSET(Th, gen0CombineHash(val, foamCopy(Th))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Th), gen0CombineHash
(val, foamCopy(Th))), ((void*)0));
GSTAT(GSET(Ti, foamNew(FOAM_BCall, 3, FOAM_BVal_SIntPlus,gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Ti), foamNew(FOAM_BCall
, 3, FOAM_BVal_SIntPlus, foamCopy(Ti), foamNew(FOAM_SInt, 1, (
AInt)(1)))), ((void*)0))
	       foamCopy(Ti), foamNewSInt(1))))gen0AddStmt(foamNew(FOAM_Set, 2, foamCopy(Ti), foamNew(FOAM_BCall
, 3, FOAM_BVal_SIntPlus, foamCopy(Ti), foamNew(FOAM_SInt, 1, (
AInt)(1)))), ((void*)0));
GSTAT(foamNewGoto(TS))gen0AddStmt(foamNew(FOAM_Goto, 1, (AInt)(TS)), ((void*)0));
GSTAT(foamNewLabel(TE))gen0AddStmt(foamNew(FOAM_Label, 1, (AInt)(TE)), ((void*)0));

return Th;
2130}
2131/* extract the hash code from a domain. */

2133localstatic Foam
2134gen0RtDomainHash(Foam dom)
2135{
Foam foam;

      foam = gen0BuiltinCCall(FOAM_SInt, "domainHash!", "runtime", 1, dom);
foamPure(foam)((foam)->hdr.info.pure) = true1;
return foam;
2141}

2143localstatic Foam
2144gen0RtSefoHash(Sefo sf, Sefo osf)
2145{
TForm	tf;

if (genIsRuntime()(gen0IsRuntime) || sf == NULL((void*)0) || abHasTag(sf, AB_With)((sf)->abHdr.tag == (AB_With)))
return foamNewSInt(int0)foamNew(FOAM_SInt, 1, (AInt)(((int) 0)));

sf  = gen0EqualMods(sf);
osf = gen0EqualMods(osf);

tiTopFns()->tiSefo(stabFile(), sf);
tf = gen0AbType(sf);

if (tf && !tfSatDom(tf) && !tfSatCat(tf))
return foamNewSInt(7)foamNew(FOAM_SInt, 1, (AInt)(7));

return gen0RtSefoHashExpr(sf, osf);
2161}

2163localstatic Foam
2164gen0RtSefoHashExpr(Sefo sf, Sefo osf)
2165{
Foam	hash;
String	msg;

switch(abTag(sf)((sf)->abHdr.tag)) {
 case AB_Id:
hash = gen0RtSefoHashId(sf, osf);
break;
 case AB_Apply:
hash = gen0RtSefoHashApply(sf, osf);
break;
 case AB_Lambda:
default:
msg = "gen0RtSefoHash got wierd type";
comsgFatal((AbSyn)sf, ALDOR_F_Bug365, msg);
NotReached(hash = 0){(void)bug("Not supposed to reach line %d in file: %s\n",2180
, "gf_add.c");};
}

return hash;
2184}

2186localstatic Foam
2187gen0RtSefoHashId(Sefo sf, Sefo osf)
2188{
Syme    syme = abSyme(sf)((sf)->abHdr.seman ? (sf)->abHdr.seman->syme : 0);
Foam    hash;
FoamTag kind = symeFoamKind(syme)((FoamTag) (SYFI_FoamKind < (8 * sizeof(int)) && !
(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->hasmask) & (1 << (SYFI_FoamKind
))) ? (symeFieldInfo[SYFI_FoamKind].def) : (((((syme)->kind
 == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0
)), (syme))->locmask) & (1 << (SYFI_FoamKind))) ?
 ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)
->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_FoamKind))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_FoamKind
)] : (symeFieldInfo[SYFI_FoamKind].def)) : symeGetFieldFn(syme
,SYFI_FoamKind)));

/* % --> my hashcode */
if (gen0HasSelf && symeIsSelf(syme)(((syme)->id) == ssymSelf)) 
hash = gen0RtDomainHash(foamCopy(gen0HasSelf));
else if (gen0ExportState && symeIsSelf(syme)(((syme)->id) == ssymSelf)) {
hash = foamCopy(gen0ExportState->selfHash);
gen0AddLexLevels(hash,
	gen0State->foamLevel - gen0ExportState->foamLevel);
}
else if (symeIsSelf(syme)(((syme)->id) == ssymSelf)) {
/*
 * This seems to only occur during -gloop. We
 * don't actually achieve anything by this since
 * gen0Syme will segfault anyway ... The problem
 * is that cascaded exports don't get added to
 * gen0ExportState properly leaving it NULL.
 */
hash = gen0RtDomainHash(foamCopy(gen0Syme(syme)));
if (DEBUG(genfHash)genfHashDebug) {
	(void)fprintf(dbOut, "!!! Warning: inventing hash for %%: ");
	symePrintDb(syme);
}
}


else if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Import)) {
if (kind == FOAM_LIMIT) gen0Syme(syme);
hash = gen0RtDomainHash(genFoamType(sf));
}

else if (symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Export) || symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend)) {
if (kind == FOAM_LIMIT && !symeLib(syme)((syme)->lib)) {
	if (DEBUG(genfHash)genfHashDebug) {
		fprintf(dbOut, "Ugh: Found unhackable syme: ");
		symePrintDb(syme);
	}
	return foamNewSInt(gen0StrHash(symeString(syme)))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((((syme)->id))->
str))));
}
hash = gen0RtDomainHash(genFoamType(sf));
}
else if (abTForm(sf)((sf)->abHdr.seman ? (sf)->abHdr.seman->tform : 0) && tfIsJavaImport(abTForm(sf)((sf)->abHdr.seman ? (sf)->abHdr.seman->tform : 0))) {
hash = foamNewSInt(gen0StrHash(symeString(syme)))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((((syme)->id))->
str))));
}
else if (kind == FOAM_LIMIT) {
if (DEBUG(genfHash)genfHashDebug) {
	fprintf(dbOut, "Ugh: Found weird syme: ");
	symePrintDb(syme);
}
hash = foamNewSInt(int0)foamNew(FOAM_SInt, 1, (AInt)(((int) 0)));
}

else if (symeIsParam(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Param) &&
 !stabHasMeaning(gen0State->stab, symeOriginal(syme)))
hash = foamNewSInt(int0)foamNew(FOAM_SInt, 1, (AInt)(((int) 0)));
/* We can cache non-local parameters and lexicals used in types,
  providing we are in an add or with clause */
else if (symeIsParam(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Param) &&
 gen0State->tag >= GF_START_TYPE &&
 gen0State->tag <= GF_END_TYPE)
hash = gen0DCacheAddItem(HT_Id, syme, NULL((void*)0));
else
hash = gen0RtDomainHash(genFoamType(sf));

return hash;
2256}

2258localstatic Foam
2259gen0RtSefoHashApply(Sefo sf, Sefo osf)
2260{
if (gen0RtSefoIsSpecialOp(sf))
return gen0RtSefoHashSpecialApply(sf);
else if (abTForm(sf)((sf)->abHdr.seman ? (sf)->abHdr.seman->tform : 0) && tfIsJavaImport(abTForm(sf)((sf)->abHdr.seman ? (sf)->abHdr.seman->tform : 0))) {
return foamNewSInt(999)foamNew(FOAM_SInt, 1, (AInt)(999));
}
else
return gen0RtSefoHashStdApply(sf, osf);
2268}

2270localstatic Foam
2271gen0RtSefoHashStdApply(Sefo sf, Sefo osf)
2272{
SefoList sfl = listNil(Sefo)((SefoList) 0), osfl = listNil(Sefo)((SefoList) 0);
AbSyn 	 op   = abApplyOp(sf)((sf)->abApply.op);
FoamList topLines;
Foam	 opFoam, dom, hash;
Foam	 result = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);
int	 askLabel = gen0State->labelNo++;
int	 outLabel = gen0State->labelNo++;
Bool	 flag, buildable;

sfl = gen0RtSefoMakeArgList(sf);

if (osf && abIsApply(osf)((osf)->abHdr.tag == (AB_Apply)))
osfl = gen0RtSefoMakeArgList(osf);

flag = gen0AddImportPlace(&topLines);

/*
* Check to see if all the symes have been classified (their
* kind is believable. Unfortunately this isn't a good test
* of whether a domain can be constructed. Some domains can
* be constructed without having all their symes allocated
* while others can't.
*/
buildable = gen0AllSymesAllocated(sf);

opFoam = genFoamType(op);
if (abTag(op)((op)->abHdr.tag) != AB_Id) {
Foam	loc = gen0TempLocal(FOAM_Word)gen0TempLocal0(FOAM_Word, 4);
gen0AddStmt(foamNewSet(foamCopy(loc), opFoam)foamNew(FOAM_Set, 2, foamCopy(loc), opFoam), NULL((void*)0));
opFoam = loc;
}

/*
* Force the type to be unlazied: We have to do this
* to avoid creating at least one domain per imported
* constructor. See gen0MakeLazyGlo{Dom,Cat}
*/
gen0AddStmt(foamNewEEnsure(foamNewCEnv(foamCopy(opFoam)))foamNew(FOAM_EEnsure, 1, foamNew(FOAM_CEnv, 1, foamCopy(opFoam
))),
    NULL((void*)0));


2314#if AXL_EDIT_1_1_12p6_14  /* DO NOT ENABLE THIS (see editlevels.h) */
/*
* Always ask unless we can't build: this is because a bug in
* this code means that we peek the hash code from the wrong
* object when given a curried domain. Until this bug is fixed
* we MUST create the domain and ask for its hash code.
*/
if (!buildable) {
gen0AddStmt(foamNewIf(gen0RtIsProgInfoNull(opFoam), askLabel)foamNew(FOAM_If, 2, gen0RtIsProgInfoNull(opFoam), askLabel),
    NULL((void*)0));
hash = foamNewProgInfo(foamCopy(opFoam))foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg, 1, foamCopy(opFoam
)));
hash = gen0RtSefoHashList(sfl, osfl, hash);
gen0AddStmt(foamNewSet(foamCopy(result), hash)foamNew(FOAM_Set, 2, foamCopy(result), hash), NULL((void*)0));
gen0AddStmt(foamNewGoto(outLabel)foamNew(FOAM_Goto, 1, (AInt)(outLabel)), NULL((void*)0));

/* When all else fails, try asking... */
gen0AddStmt(foamNewLabel(askLabel)foamNew(FOAM_Label, 1, (AInt)(askLabel)), NULL((void*)0));
}
2332#else
/*
* If we can read a pre-computed hash code then do so. If we
* cannot then we build the domain and ask it for the hash.
*/
gen0AddStmt(foamNewIf(gen0RtIsProgInfoNull(opFoam), askLabel)foamNew(FOAM_If, 2, gen0RtIsProgInfoNull(opFoam), askLabel),
    NULL((void*)0));
hash = foamNewProgInfo(foamCopy(opFoam))foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg, 1, foamCopy(opFoam
)));
hash = gen0RtSefoHashList(sfl, osfl, hash);
gen0AddStmt(foamNewSet(foamCopy(result), hash)foamNew(FOAM_Set, 2, foamCopy(result), hash), NULL((void*)0));
gen0AddStmt(foamNewGoto(outLabel)foamNew(FOAM_Goto, 1, (AInt)(outLabel)), NULL((void*)0));


/* When all else fails, try asking... */
gen0AddStmt(foamNewLabel(askLabel)foamNew(FOAM_Label, 1, (AInt)(askLabel)), NULL((void*)0));
2347#endif

if (buildable) {
/*
 * We assume that this will give us the hash code. Luckily
 * if we don't get the hash code then we didn't actually need
 * it! This begs the question, why did we ask for it in the
 * first place?
 */
dom = gen0RtDomainHash(genFoamType(sf));
gen0AddStmt(foamNewSet(foamCopy(result), dom)foamNew(FOAM_Set, 2, foamCopy(result), dom), NULL((void*)0));
}
else {
2360/*
* We ought to generate this compiler warning but it happens
* too often in situations where it may not actually cause
* any problems.
*/
2365#if 0
/*
 * Issue a compiler warning if we are able to link
 * this bit of sefo with some source code.
 */
if (abPos((AbSyn)sf)(spstackFirst(((AbSyn)sf)->abHdr.pos)))
	comsgWarning((AbSyn)sf, ALDOR_W_ChkBadDependent84);
2372#endif

gen0AddStmt(foamNew(FOAM_BCall, 2,
		    FOAM_BVal_Halt,
		    foamNewSInt(FOAM_Halt_BadDependentType)foamNew(FOAM_SInt, 1, (AInt)(FOAM_Halt_BadDependentType))), NULL((void*)0));
gen0AddStmt(foamNewSet(foamCopy(result),foamNew(FOAM_Set, 2, foamCopy(result), foamNew(FOAM_SInt, 1, (
AInt)(((int) 0)))) 
		       foamNewSInt(int0))foamNew(FOAM_Set, 2, foamCopy(result), foamNew(FOAM_SInt, 1, (
AInt)(((int) 0)))), NULL((void*)0));
}

gen0AddStmt(foamNewLabel(outLabel)foamNew(FOAM_Label, 1, (AInt)(outLabel)), NULL((void*)0));
if (flag) gen0ResetImportPlace(topLines);
hash = result;

listFree(Sefo)(Sefo_listPointer->Free)(sfl);
listFree(Sefo)(Sefo_listPointer->Free)(osfl);
return hash;
2388}

2390localstatic Foam
2391gen0RtSefoHashSpecialMap(Sefo sf)
2392{
Sefo	 arg;
Sefo	*argv;
AbSyn	 op  = abApplyOp(sf)((sf)->abApply.op);
Symbol	 sym = abIdSym(op)((op)->abId.sym);
Foam	 hash, twist, hi;
int 	 argc;
int 	 i;
int	hashMask = gen0RtSymSpecialTag(sym);

/* Ensure that we have hash masks */
if (!gen0RtArgHashMask) gen0RtInitHashMask();

/* Hash the operator ... */
hash = foamNewSInt(gen0StrHash(symString(sym)))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((sym)->str))));

arg  = abApplyArg(sf, int0)((sf)->abApply.argv[((int) 0)]);
argv = abArgvAs(AB_Comma, arg)(((arg)->abHdr.tag == (AB_Comma)) ? ((arg)->abGen.data.
argv) : &(arg));
argc = abArgcAs(AB_Comma, arg)(((arg)->abHdr.tag == (AB_Comma)) ? ((arg)->abHdr.argc)
 : 1);
for (i = 0; i < argc; i++) {
Sefo argi = argv[i];

if (abTag(argi)((argi)->abHdr.tag) != AB_Id)
	argi = abDefineeTypeOrElse(argi, argi);
hi = gen0RtSefoHash(argi, (Sefo)NULL((void*)0));
foamPure(hi)((hi)->hdr.info.pure) = true1;
hash = gen0CombineHash(hi, hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;
}
/* Fold in the map hash mask */
twist = foamNewSInt(gen0RtArgHashMask[hashMask])foamNew(FOAM_SInt, 1, (AInt)(gen0RtArgHashMask[hashMask]));
foamPure(twist)((twist)->hdr.info.pure) = true1;
hash = gen0CombineHash(twist, hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;

/* Process the map return types */
arg  = abApplyArg(sf, 1)((sf)->abApply.argv[1]);
argv = abArgvAs(AB_Comma, arg)(((arg)->abHdr.tag == (AB_Comma)) ? ((arg)->abGen.data.
argv) : &(arg));
argc = abArgcAs(AB_Comma, arg)(((arg)->abHdr.tag == (AB_Comma)) ? ((arg)->abHdr.argc)
 : 1);
for (i = 0; i < argc; i++) {
Sefo argi = argv[i];

if (abTag(argi)((argi)->abHdr.tag) != AB_Id)
	argi = abDefineeTypeOrElse(argi, argi);
hi = gen0RtSefoHash(argi, (Sefo)NULL((void*)0));
foamPure(hi)((hi)->hdr.info.pure) = true1;
hash = gen0CombineHash(hi, hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;
}

return hash;
2443}

2445localstatic Foam
2446gen0RtSefoHashSpecialApply(Sefo sf)
2447{
SefoList sfl = listNil(Sefo)((SefoList) 0);
AbSyn	 op  = abApplyOp(sf)((sf)->abApply.op);
Symbol	 sym = abIdSym(op)((op)->abId.sym);
Foam	 hash;
int 	 argc = abApplyArgc(sf)(((sf)->abHdr.argc)-1);
int 	 i;

if (abIsAnyMap(sf)(((((sf)->abHdr.tag == (AB_Apply)) && (((((sf)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((sf)->
abApply.op))->abId.sym)==(ssymArrow))) && (((sf)->
abHdr.argc)-1) == 2) || ((((sf)->abHdr.tag == (AB_Apply)) &&
 (((((sf)->abApply.op))->abHdr.tag == (AB_Id)) &&
 ((((sf)->abApply.op))->abId.sym)==(ssymPackedArrow))) &&
 (((sf)->abHdr.argc)-1) == 2)))
return gen0RtSefoHashSpecialMap(sf);

for (i = 0; i < argc; i += 1)
sfl = listCons(Sefo)(Sefo_listPointer->Cons)(abApplyArg(sf, i)((sf)->abApply.argv[i]), sfl);
sfl = listNReverse(Sefo)(Sefo_listPointer->NReverse)(sfl);

if (sym == ssymEnum)
return gen0RtSefoHashEnum(sf, sfl);

gen0RtUseDeclares(sfl);

hash = foamNewSInt(gen0StrHash(symString(sym)))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((sym)->str))));
hash = gen0RtSefoHashList(sfl, listNil(Sefo)((SefoList) 0), hash);
listFree(Sefo)(Sefo_listPointer->Free)(sfl);
return hash;
2471}

2473localstatic Foam
2474gen0RtSefoHashEnum(Sefo sf, SefoList sfl)
2475{
AbSyn	op = abApplyOp(sf)((sf)->abApply.op);
Symbol	sym = abIdSym(op)((op)->abId.sym);
Foam	hash, hi;

hash = foamNewSInt(gen0StrHash(symString(sym)))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((sym)->str))));
for (; sfl; sfl = cdr(sfl)((sfl)->rest)) {
sym = abIdSym(abDefineeId(car(sfl)))((abDefineeId(((sfl)->first)))->abId.sym);
hi = foamNewSInt(gen0StrHash(symString(sym)))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(((sym)->str))));
hash = gen0CombineHash(hi, hash);
}

return hash;
2488}

2490localstatic Foam
2491gen0RtSefoHashList(SefoList sfl, SefoList osfl, Foam hash)
2492{
Sefo	sf, osf;

assert(!osfl || listLength(Sefo)(sfl) == listLength(Sefo)(osfl))do { if (!(!osfl || (Sefo_listPointer->_Length)(sfl) == (Sefo_listPointer
->_Length)(osfl))) _do_assert(("!osfl || listLength(Sefo)(sfl) == listLength(Sefo)(osfl)"
),"gf_add.c",2495); } while (0);
while (sfl) {
sf = car(sfl)((sfl)->first);
osf = osfl ? car(osfl)((osfl)->first) : NULL((void*)0);

hash = gen0CombineHash(gen0RtSefoHash(sf, osf), hash);
foamPure(hash)((hash)->hdr.info.pure) = true1;

sfl = cdr(sfl)((sfl)->rest);
osfl = osfl ? cdr(osfl)((osfl)->rest) : NULL((void*)0);
}
return hash;
2507}

2509localstatic SefoList
2510gen0RtSefoListUnComma(SefoList sfl)
2511{
SefoList lst = listNil(Sefo)((SefoList) 0);

while (sfl) {
Sefo	sf = car(sfl)((sfl)->first);
Sefo	*argv = abArgvAs(AB_Comma, sf)(((sf)->abHdr.tag == (AB_Comma)) ? ((sf)->abGen.data.argv
) : &(sf));
Length	i, argc = abArgcAs(AB_Comma, sf)(((sf)->abHdr.tag == (AB_Comma)) ? ((sf)->abHdr.argc) :
 1);

for (i = 0; i < argc; i += 1)
	lst = listCons(Sefo)(Sefo_listPointer->Cons)(argv[i], lst);
sfl = cdr(sfl)((sfl)->rest);
}
return listNReverse(Sefo)(Sefo_listPointer->NReverse)(lst);
2524}

2526localstatic SefoList
2527gen0RtSefoMakeArgList(Sefo sf)
2528{
SefoList sfl = listNil(Sefo)((SefoList) 0);
TForm    opTf = gen0AbType(abApplyOp(sf)((sf)->abApply.op));
int      argc = tfMapArgc(opTf);
int      i;

for (i = 0; i < argc; i += 1) {
AbSyn sfi = tfMapSelectArg(opTf, sf, i);
sfl = listCons(Sefo)(Sefo_listPointer->Cons)(sfi, sfl);
}
sfl = listNReverse(Sefo)(Sefo_listPointer->NReverse)(sfl);

return sfl;
2541}

2543localstatic void
2544gen0RtUseDeclares(SefoList sfl)
2545{
while (sfl) {
Sefo sf = car(sfl)((sfl)->first);
if (abTag(sf)((sf)->abHdr.tag) != AB_Id)
	car(sfl)((sfl)->first) = abDefineeTypeOrElse(sf, sf);
sfl = cdr(sfl)((sfl)->rest);
}
2552}

2554localstatic Foam
2555gen0RtIsProgInfoNull(Foam foam)
2556{
return foamNew(FOAM_BCall, 2, FOAM_BVal_SIntIsZero, 
       foamNewProgInfo(foam)foamNew(FOAM_PRef, 2, 0, foamNew(FOAM_CProg, 1, foam)));
2559}


2562/* A 28 or 30 bit prime */

2564#define HashModulus(gen0SmallHashCodes ? 0x07FFFFD9 : 0x3FFFFFDD) (gen0SmallHashCodes ? 0x07FFFFD9 : 0x3FFFFFDD)
2565#define ShiftMask0x00FFFFFF   0x00FFFFFF

2567localstatic Foam
2568gen0CombineHash(Foam hash1, Foam hash0)
2569{
      Foam    bcall;
2571#if 0
2572/*!! use when inlining from callbacks works */
      return gen0BuiltinCCall(FOAM_SInt, "combineHash", "runtime",
                             hash1, hash0);
2575#endif
      bcall = foamNew(FOAM_BCall, 3, FOAM_BVal_SIntHashCombine, hash1, hash0);

      return bcall;
2579}

2581int
2582gen0StrHash(String s)
2583{
      return strHash(s) % HashModulus(gen0SmallHashCodes ? 0x07FFFFD9 : 0x3FFFFFDD);
2585}

2587Foam
2588genWith(AbSyn absyn)
2589{
return gen0MakeDefaultPackage(absyn, abStab(absyn)((absyn)->abHdr.seman ? (absyn)->abHdr.seman->stab :
 0), false((int) 0), NULL((void*)0));
1
Assuming field 'seman' is null→
2
←
'?' condition is false→
3
←
Calling 'gen0MakeDefaultPackage'→
2591}

2593/*
* Construct calls to Join/Map/Enumeration/Cross/Record/Union.
*/
2596Bool
2597gen0IsSpecialType(AbSyn ab)
2598{
AbSyn	op = abApplyOp(ab)((ab)->abApply.op);
Symbol	sym = abIsId(op)((op)->abHdr.tag == (AB_Id)) ? abIdSym(op)((op)->abId.sym) : NULL((void*)0);

return	sym == ssymJoin		||
	sym == ssymArrow	||
sym == ssymPackedArrow	||
sym == ssymCross	||
sym == ssymRawRecord	||
sym == ssymRecord	||
sym == ssymUnion	||
sym == ssymEnum;
2610}

2612Foam
2613gen0ApplySpecialType(AbSyn absyn)
2614{
if (abIsJoin(absyn)(((absyn)->abHdr.tag == (AB_Apply)) && (((((absyn)
->abApply.op))->abHdr.tag == (AB_Id)) && ((((absyn
)->abApply.op))->abId.sym)==(ssymJoin))))
return gen0Join(absyn);
else if (abIsAnyMap(absyn)(((((absyn)->abHdr.tag == (AB_Apply)) && (((((absyn
)->abApply.op))->abHdr.tag == (AB_Id)) && ((((absyn
)->abApply.op))->abId.sym)==(ssymArrow))) && ((
(absyn)->abHdr.argc)-1) == 2) || ((((absyn)->abHdr.tag ==
 (AB_Apply)) && (((((absyn)->abApply.op))->abHdr
.tag == (AB_Id)) && ((((absyn)->abApply.op))->abId
.sym)==(ssymPackedArrow))) && (((absyn)->abHdr.argc
)-1) == 2)))
return gen0Map(absyn);
else if (abIsApplyOf(absyn, ssymEnum)(((absyn)->abHdr.tag == (AB_Apply)) && (((((absyn)
->abApply.op))->abHdr.tag == (AB_Id)) && ((((absyn
)->abApply.op))->abId.sym)==(ssymEnum))))
return gen0Enum(absyn);
else 	
return gen0ApplySpecialOthers(absyn);
2623}

2625localstatic Foam
2626gen0Join(AbSyn absyn)
2627{
return gen0MakeDefaultPackage(absyn, abStab(absyn)((absyn)->abHdr.seman ? (absyn)->abHdr.seman->stab :
 0), false((int) 0), NULL((void*)0));
2629}

2631localstatic Foam 
2632gen0Map(AbSyn absyn)
2633{
Foam	opFoam, argFoam, retFoam, foam;
AbSyn	arg = abMapArg(absyn)((absyn)->abApply.argv[0]);
AbSyn	ret = abMapRet(absyn)((absyn)->abApply.argv[1]);
AbSyn	*argv;
Length	argc;

argv = abArgvAs(AB_Comma, arg)(((arg)->abHdr.tag == (AB_Comma)) ? ((arg)->abGen.data.
argv) : &(arg));
argc = abArgcAs(AB_Comma, arg)(((arg)->abHdr.tag == (AB_Comma)) ? ((arg)->abHdr.argc)
 : 1);
argFoam = gen0MakeTuple(argc, argv, arg);

argv = abArgvAs(AB_Comma, ret)(((ret)->abHdr.tag == (AB_Comma)) ? ((ret)->abGen.data.
argv) : &(ret));
argc = abArgcAs(AB_Comma, ret)(((ret)->abHdr.tag == (AB_Comma)) ? ((ret)->abHdr.argc)
 : 1);
retFoam = gen0MakeTuple(argc, argv, ret);

opFoam = genFoamVal(abApplyOp(absyn)((absyn)->abApply.op));

foam = foamNew(FOAM_CCall, 4, FOAM_Word, opFoam, argFoam, retFoam);
foamPure(foam)((foam)->hdr.info.pure) = true1;
return foam;
2653}

2655localstatic Foam
2656gen0Enum(AbSyn absyn)
2657{
Foam	vars[2], tupl, elts, elt, opFoam, foam;
Length	i, argc = abApplyArgc(absyn)(((absyn)->abHdr.argc)-1);
AbSyn	*argv = abApplyArgv(absyn)((absyn)->abApply.argv);

gen0MakeEmptyTuple(foamNewSInt(argc)foamNew(FOAM_SInt, 1, (AInt)(argc)), vars, absyn);
tupl = vars[0];
elts = vars[1];

for (i = 0; i < argc; i += 1) {
AbSyn	arg = abDefineeId(argv[i]);
elt = foamNewCast(FOAM_Word, gen0CharArray(arg->abId.sym->str))foamNew(FOAM_Cast, 2, FOAM_Word, gen0CharArray(arg->abId.sym
->str));
gen0AddStmt(gen0ASet(elts, (AInt) i, FOAM_Word, elt)foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)((AInt) i)),foamCopy(elts)), elt), absyn);
}

opFoam = genFoamVal(abApplyOp(absyn)((absyn)->abApply.op));
foam = foamNew(FOAM_CCall, 3, FOAM_Word, opFoam, tupl);
foamPure(foam)((foam)->hdr.info.pure) = true1;
return foam;
2676}

2678/*
* This function is only called when Record() etc are used as values,
* eg on the RHS of a definition. When used as a type constructor the
* functor never actually gets applied.
*/
2683localstatic Foam
2684gen0ApplySpecialOthers(AbSyn absyn)
2685{
Foam	vars[2], tupl, elts, elt, foam;
Length	i, argc = abApplyArgc(absyn)(((absyn)->abHdr.argc)-1);
AbSyn	*argv = abApplyArgv(absyn)((absyn)->abApply.argv);
AbSyn	op = abApplyOp(absyn)((absyn)->abApply.op);

assert(abIdSym(op) == ssymCross ||do { if (!(((op)->abId.sym) == ssymCross || ((op)->abId
.sym) == ssymRawRecord || ((op)->abId.sym) == ssymRecord ||
 ((op)->abId.sym) == ssymUnion)) _do_assert(("abIdSym(op) == ssymCross || abIdSym(op) == ssymRawRecord || abIdSym(op) == ssymRecord || abIdSym(op) == ssymUnion"
),"gf_add.c",2694); } while (0)
      abIdSym(op) == ssymRawRecord ||do { if (!(((op)->abId.sym) == ssymCross || ((op)->abId
.sym) == ssymRawRecord || ((op)->abId.sym) == ssymRecord ||
 ((op)->abId.sym) == ssymUnion)) _do_assert(("abIdSym(op) == ssymCross || abIdSym(op) == ssymRawRecord || abIdSym(op) == ssymRecord || abIdSym(op) == ssymUnion"
),"gf_add.c",2694); } while (0)
      abIdSym(op) == ssymRecord ||do { if (!(((op)->abId.sym) == ssymCross || ((op)->abId
.sym) == ssymRawRecord || ((op)->abId.sym) == ssymRecord ||
 ((op)->abId.sym) == ssymUnion)) _do_assert(("abIdSym(op) == ssymCross || abIdSym(op) == ssymRawRecord || abIdSym(op) == ssymRecord || abIdSym(op) == ssymUnion"
),"gf_add.c",2694); } while (0)
      abIdSym(op) == ssymUnion)do { if (!(((op)->abId.sym) == ssymCross || ((op)->abId
.sym) == ssymRawRecord || ((op)->abId.sym) == ssymRecord ||
 ((op)->abId.sym) == ssymUnion)) _do_assert(("abIdSym(op) == ssymCross || abIdSym(op) == ssymRawRecord || abIdSym(op) == ssymRecord || abIdSym(op) == ssymUnion"
),"gf_add.c",2694); } while (0);

gen0MakeEmptyTuple(foamNewSInt(argc)foamNew(FOAM_SInt, 1, (AInt)(argc)), vars, absyn);
tupl = vars[0];
elts = vars[1];

for (i = 0; i < argc; i += 1) {
AbSyn	arg = abDefineeTypeOrElse(argv[i], argv[i]);

if (gen0AllSymesAllocated(arg))
	elt = genFoamType(arg);
else
	elt = foamNewNil()foamNew(FOAM_Nil, (int) 0);

gen0AddStmt(gen0ASet(elts, (AInt) i, FOAM_Word, elt)foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)((AInt) i)),foamCopy(elts)), elt), absyn);
}

foam = foamNew(FOAM_CCall, 3, FOAM_Word, genFoamVal(op), tupl);
foamPure(foam)((foam)->hdr.info.pure) = true1;
return foam;
2714}

2716/* Return true if we can generate complete foam for 'ab'. 
* This should check for formal arguments, symes from 
* dependant types, and so on.
* As lazy symbol meanings are handled later (see gen0SymeGeneric),
* we test for and and ignore them here.
*/
2722localstatic Bool
2723gen0AllSymesAllocated(AbSyn ab)
2724{
Bool	result = true1;

if (abTag(ab)((ab)->abHdr.tag) == AB_Declare)
result = gen0AllSymesAllocated(ab->abDeclare.type);
else if (abIsLeaf(ab)(((ab)->abHdr.tag) < AB_NODE_START)) {
Syme	syme = abSyme(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->syme : 0);

/* Unallocated symes normally cause false return value. */
result = !(syme && gen0FoamKind(syme)((((FoamTag) (SYFI_FoamKind < (8 * sizeof(int)) &&
 !(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)
->lib) : ((void*)0)), (syme))->hasmask) & (1 <<
 (SYFI_FoamKind))) ? (symeFieldInfo[SYFI_FoamKind].def) : (((
((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_FoamKind
))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((
syme)->lib) : ((void*)0)), (syme))->locmask) & (1 <<
 (SYFI_FoamKind))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_FoamKind
)] : (symeFieldInfo[SYFI_FoamKind].def)) : symeGetFieldFn(syme
,SYFI_FoamKind))) != FOAM_LIMIT) ? ((FoamTag) (SYFI_FoamKind <
 (8 * sizeof(int)) && !(((((syme)->kind == SYME_Trigger
 ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->
hasmask) & (1 << (SYFI_FoamKind))) ? (symeFieldInfo
[SYFI_FoamKind].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes
((syme)->lib) : ((void*)0)), (syme))->locmask) & (1
 << (SYFI_FoamKind))) ? ((((((syme)->kind == SYME_Trigger
 ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->
locmask) & (1 << (SYFI_FoamKind))) ? ((syme)->fieldv
)[symeIndex(syme,SYFI_FoamKind)] : (symeFieldInfo[SYFI_FoamKind
].def)) : symeGetFieldFn(syme,SYFI_FoamKind))) : ((FoamTag) (
SYFI_FoamKind < (8 * sizeof(int)) && !(((((symeOriginal
(syme))->kind == SYME_Trigger ? libGetAllSymes((symeOriginal
(syme))->lib) : ((void*)0)), (symeOriginal(syme)))->hasmask
) & (1 << (SYFI_FoamKind))) ? (symeFieldInfo[SYFI_FoamKind
].def) : (((((symeOriginal(syme))->kind == SYME_Trigger ? libGetAllSymes
((symeOriginal(syme))->lib) : ((void*)0)), (symeOriginal(syme
)))->locmask) & (1 << (SYFI_FoamKind))) ? ((((((
symeOriginal(syme))->kind == SYME_Trigger ? libGetAllSymes
((symeOriginal(syme))->lib) : ((void*)0)), (symeOriginal(syme
)))->locmask) & (1 << (SYFI_FoamKind))) ? ((symeOriginal
(syme))->fieldv)[symeIndex(symeOriginal(syme),SYFI_FoamKind
)] : (symeFieldInfo[SYFI_FoamKind].def)) : symeGetFieldFn(symeOriginal
(syme),SYFI_FoamKind)))) == FOAM_LIMIT);

if (DEBUG(gfadd)gfaddDebug) {
	fprintf(dbOut, "syme [%c]: ", result ? ' ' :
		symeLib(syme)((syme)->lib) &&
		(symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Export) || symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend)) ?
		'-' : '?');
	symePrintDb(syme);
}

if (syme && symeLib(syme)((syme)->lib) &&
    (symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Export) || symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->
lib) : ((void*)0)), (syme))->kind) == SYME_Extend)))
    result = true1;
}
else {
Length	i;
for (i = 0; result && i < abArgc(ab)((ab)->abHdr.argc); i += 1)
	result = gen0AllSymesAllocated(abArgv(ab)((ab)->abGen.data.argv)[i]);
}
return result;
2753}

2755/*
* Collect the defaults from the body of a with.
*/
2758localstatic AbSyn
2759gen0FindDefaults(AbSyn with)
2760{
Length	i;
Length	defc = 0;
AbSyn	defs = NULL((void*)0), *argv;

if (abTag(with)((with)->abHdr.tag) == AB_Default)
return with;
if (abTag(with)((with)->abHdr.tag) != AB_Sequence)
return abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );

argv = with->abSequence.argv;
for (i = 0; i < abArgc(with)((with)->abHdr.argc); i += 1)
if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default) {
	defs = argv[i];
	defc += 1;
}

if (defc == 0)
return abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
if (defc == 1)
return defs;

      defs = abNewEmpty(AB_Sequence, defc);
      for (i = 0, defc = 0; i < abArgc(with)((with)->abHdr.argc); i += 1)
              if (abTag(argv[i])((argv[i])->abHdr.tag) == AB_Default)
	abArgv(defs)((defs)->abGen.data.argv)[defc++] = abArgv(argv[i])((argv[i])->abGen.data.argv)[0];

      return defs;
2788}

2790/*
* Return the code for the getter function from a domain.
*/

2794Foam
2795gen0GetDomain(TForm exporter, int levOffset)
2796{
      int             i;
      String          name;
      Foam            getter, var, decl, ini;

      /* if already imported return variable where stored. */
      var = gen0SeenImportedDomain(exporter, int0((int) 0));
      if (var)
              return var;

      name   = strPrintf("dom");
      getter = gen0GetDomainDomain(exporter);

      decl = foamNewDecl(FOAM_Word, name, emptyFormatSlot)foamNew(FOAM_Decl,4,(AInt)(FOAM_Word),name, (AInt) (0x7FFF), 4
);
      i = gen0AddLexNth(decl, int0((int) 0), levOffset);

var = gen0NewLex(levOffset, i);

/* if offsets are the same, then we should not be importing twice */
      gen0AddImportedDomain(exporter, foamCopy(var), int0((int) 0));
      ini = foamNewDef(foamCopy(var), getter)foamNew(FOAM_Def, 2, foamCopy(var), getter);
      gen0SetInitUsage(ini, int0((int) 0));
      gen0AddStmt(ini, NULL((void*)0));
      return foamCopy(var);
2820}

2822localstatic void
2823gen0AddImportedDomain(TForm exporter, Foam var, AInt level)
2824{
      GenFoamState    s = gen0NthState(level);
      s->domImportList = listCons(TForm)(TForm_listPointer->Cons)(exporter, s->domImportList);
      s->domList = listCons(Foam)(Foam_listPointer->Cons)(var, s->domList);
2828}

2830localstatic Foam
2831gen0SeenImportedDomain(TForm dom, AInt level)
2832{
      GenFoamState    s = gen0NthState(level);
      TFormList       dl = s->domImportList;
      FoamList        vl = s->domList;

      for(; dl; dl = cdr(dl)((dl)->rest), vl = cdr(vl)((vl)->rest))
              if (tfEqual(dom, car(dl)((dl)->first)))
                      return foamCopy(car(vl)((vl)->first));
      return 0;
2841}

2843localstatic Foam
2844gen0GetDomainDomain(TForm exporter)
2845{
      return genFoamType(tfExpr(exporter)tfToAbSyn(exporter));
2847}

2849localstatic void
2850gen0SetInitUsage(Foam getter, AInt level)
2851{
      SlotUsageList    lu;
      AIntList         ls;

      lu = gen0NthState(level)->formatUsage;
      ls = gen0NthState(level)->formatStack;
      gen0SetUsage(getter, lu, ls);
2858}

2860void
2861gen0SetUsage(Foam foam, SlotUsageList lu, AIntList ls)
2862{
      foamIter(foam, arg, gen0SetUsage(*arg, lu, ls)){ { String argf = (foamInfoTable [(int)(((foam)->hdr.tag))
-(int)FOAM_START]).argf; Length _i; for (_i = 0; _i < ((foam
)->hdr.argc); _i++, argf++) { if (*argf == '*') argf--; if
 (*argf == 'C') { Foam *arg = (Foam *) ((foam)->foamGen.argv
)+_i; { gen0SetUsage(*arg, lu, ls); }; } } }; };
      if (foamTag(foam)((foam)->hdr.tag) == FOAM_Lex) {
              AInt level = foam->foamLex.level;
              while(level > 0) {
                      assert(ls != 0)do { if (!(ls != 0)) _do_assert(("ls != 0"),"gf_add.c",2867);
 } while (0);
                      assert(lu != 0)do { if (!(lu != 0)) _do_assert(("lu != 0"),"gf_add.c",2868);
 } while (0);
                      ls = cdr(ls)((ls)->rest);
                      lu = cdr(lu)((lu)->rest);
                      level -= 1;
              }
              assert(ls != 0)do { if (!(ls != 0)) _do_assert(("ls != 0"),"gf_add.c",2873);
 } while (0);
              assert(lu != 0)do { if (!(lu != 0)) _do_assert(("lu != 0"),"gf_add.c",2874);
 } while (0);
              car(lu)((lu)->first) = suFrFormat(car(ls))(((((ls)->first)) << 2) | 2);
      }
      else if (foamTag(foam)((foam)->hdr.tag) == FOAM_Env) {
              AInt level = foam->foamEnv.level;
              while(level > 0) {
                      assert(lu != 0)do { if (!(lu != 0)) _do_assert(("lu != 0"),"gf_add.c",2880);
 } while (0);
                      lu = cdr(lu)((lu)->rest);
                      level -= 1;
              }
              assert(lu != 0)do { if (!(lu != 0)) _do_assert(("lu != 0"),"gf_add.c",2884);
 } while (0);
              if (car(lu)((lu)->first) == emptyFormatSlot4)
	car(lu)((lu)->first) = suFrFormat(envUsedSlot)(((0) << 2) | 2);
      }
2888}

2890localstatic AbSyn
2891gen0CollectWithImports(AbSyn with)
2892{
AbSynList lst;
AbSyn base = with->abWith.base;
int i;

lst = gen0CollectAux(with->abWith.within);

if (!lst)
return with->abWith.base;

      if (abIsJoin(base)(((base)->abHdr.tag == (AB_Apply)) && (((((base)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((base)->
abApply.op))->abId.sym)==(ssymJoin)))) {
for (i=abApplyArgc(base)(((base)->abHdr.argc)-1)-1; i >= 0; i--)
	lst = listCons(AbSyn)(AbSyn_listPointer->Cons)(abApplyArg(base,i)((base)->abApply.argv[i]), lst);
}
else if (!abIsNothing(base)((base)->abHdr.tag == (AB_Nothing)))
lst = listCons(AbSyn)(AbSyn_listPointer->Cons)(base, lst);

return abNewApplyL(abPos(with), abNewId(sposNone, ssymJoin), lst)abNewOfOpAndList(AB_Apply,(spstackFirst((with)->abHdr.pos)
),abNew(AB_Id, sposNone,1, ssymJoin),lst);
2910}

2912localstatic AbSynList
2913gen0CollectAux(AbSyn absyn)
2914{
AbSynList lst = listNil(AbSyn)((AbSynList) 0);
int i;

switch (abTag(absyn)((absyn)->abHdr.tag)) {
 case AB_Sequence:
for (i=0; i<abArgc(absyn)((absyn)->abHdr.argc); i++)
	lst = listNConcat(AbSyn)(AbSyn_listPointer->NConcat)
			 (gen0CollectAux(abArgv(absyn)((absyn)->abGen.data.argv)[i]),
			  lst);
return lst;
 case AB_Default:
 case AB_Declare:
return listNil(AbSyn)((AbSynList) 0);
 case AB_Export:
 case AB_Nothing:
 case AB_Comma:
return listNil(AbSyn)((AbSynList) 0);
 default:
return listCons(AbSyn)(AbSyn_listPointer->Cons)(absyn, lst);
}
2935}

2937/* Has questions */

2939Foam
2940genHas(AbSyn absyn)
2941{
AbSyn dom, cat, lhs, *argv;
SymeList symes = listNil(Syme)((SymeList) 0);
Foam foam, self;
int argc;

assert(abTag(absyn) == AB_Has)do { if (!(((absyn)->abHdr.tag) == AB_Has)) _do_assert(("abTag(absyn) == AB_Has"
),"gf_add.c",2947); } while (0);

dom = absyn->abHas.expr;
cat = absyn->abHas.property;

/* should replace with tfSubstHasSelf */
self  = gen0Temp(FOAM_Word)gen0Temp0(FOAM_Word, 4);
gen0HasSelf = self;

gen0AddStmt(foamNewSet(self, genFoamVal(dom))foamNew(FOAM_Set, 2, self, genFoamVal(dom)), absyn);

if (abTag(cat)((cat)->abHdr.tag) == AB_With) {
symes = stabGetExportedSymes(abStab(cat)((cat)->abHdr.seman ? (cat)->abHdr.seman->stab : 0));
lhs = gen0CollectWithImports(cat);
}
else 
lhs = cat;

if (abIsJoin(lhs)(((lhs)->abHdr.tag == (AB_Apply)) && (((((lhs)->
abApply.op))->abHdr.tag == (AB_Id)) && ((((lhs)->
abApply.op))->abId.sym)==(ssymJoin)))) {
argc = abApplyArgc(lhs)(((lhs)->abHdr.argc)-1);
argv = abApplyArgv(lhs)((lhs)->abApply.argv);
}
else if (abIsNothing(lhs)((lhs)->abHdr.tag == (AB_Nothing))) {
argc = 0;
argv = NULL((void*)0);
}
else {
argc = 1;
argv = &lhs;
}
if (argc == 0)
foam = foamNewBool(true)foamNew(FOAM_Bool, 1, (AInt)(1));
else if (argc == 1) 
foam = gen0HasCat(self, argv[0]);
else 
foam = gen0HasJoin(self, argc, argv);

if (symes) {
foam = gen0HasImports(self, symes, foam);
}

gen0HasSelf = NULL((void*)0);
return(foam);
2990}

2992localstatic Foam 
2993gen0HasJoin(Foam dom, int argc, AbSyn *argv)
2994{
Foam resultVar = gen0Temp(FOAM_Bool)gen0Temp0(FOAM_Bool, 4);
int falseLabel = gen0State->labelNo++;
int endLabel = gen0State->labelNo++;
int i;

for (i = 0; i < argc ; i++) {
int nextLabel = gen0State->labelNo++;
gen0AddStmt(foamNewIf(gen0HasCatBit(dom, argv[i]), nextLabel)foamNew(FOAM_If, 2, gen0HasCatBit(dom, argv[i]), nextLabel), NULL((void*)0));
gen0AddStmt(foamNewGoto(falseLabel)foamNew(FOAM_Goto, 1, (AInt)(falseLabel)), NULL((void*)0));
gen0AddStmt(foamNewLabel(nextLabel)foamNew(FOAM_Label, 1, (AInt)(nextLabel)), NULL((void*)0));
}
gen0AddStmt(foamNewSet(foamCopy(resultVar), foamNewBool(true))foamNew(FOAM_Set, 2, foamCopy(resultVar), foamNew(FOAM_Bool, 1
, (AInt)(1))), NULL((void*)0));
gen0AddStmt(foamNewGoto(endLabel)foamNew(FOAM_Goto, 1, (AInt)(endLabel)), NULL((void*)0));
gen0AddStmt(foamNewLabel(falseLabel)foamNew(FOAM_Label, 1, (AInt)(falseLabel)), NULL((void*)0));
gen0AddStmt(foamNewSet(foamCopy(resultVar), foamNewBool(false))foamNew(FOAM_Set, 2, foamCopy(resultVar), foamNew(FOAM_Bool, 1
, (AInt)(((int) 0)))), NULL((void*)0));
gen0AddStmt(foamNewLabel(endLabel)foamNew(FOAM_Label, 1, (AInt)(endLabel)), NULL((void*)0));
return resultVar;
3012}

3014localstatic Foam 
3015gen0HasCat(Foam dom, AbSyn cat)
3016{
return foamNewCast(FOAM_Word, gen0HasCatBit(dom, cat))foamNew(FOAM_Cast, 2, FOAM_Word, gen0HasCatBit(dom, cat));
3018}

3020localstatic Foam
3021gen0HasCatBit(Foam dom, AbSyn cat)
3022{
Foam foam;
if (DEBUG(genf)genfDebug) {
fprintf(dbOut, "Hash:\n");
sefoPrintDb(cat);
tfPrintDb(abTForm(cat)((cat)->abHdr.seman ? (cat)->abHdr.seman->tform : 0));
}
foam = gen0BuiltinCCall(FOAM_Bool,"domainTestExport!",
		"runtime", 3,
		foamCopy(dom),
		 foamNewSInt(gen0StrHash("%%"))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash("%%"))), 
		 gen0SefoHash(cat, cat));
foamPure(foam)((foam)->hdr.info.pure) = true1;
return foam;
3036}

3038localstatic Foam
3039gen0HasImports(Foam dom, SymeList symes, Foam startTest)
3040{
Foam resultVar = gen0Temp(FOAM_Bool)gen0Temp0(FOAM_Bool, 4);
int falseLabel = gen0State->labelNo++;
int startLabel = gen0State->labelNo++;
int endLabel = gen0State->labelNo++;

gen0AddStmt(foamNewIf(startTest, startLabel)foamNew(FOAM_If, 2, startTest, startLabel), NULL((void*)0));
gen0AddStmt(foamNewGoto(falseLabel)foamNew(FOAM_Goto, 1, (AInt)(falseLabel)), NULL((void*)0));
gen0AddStmt(foamNewLabel(startLabel)foamNew(FOAM_Label, 1, (AInt)(startLabel)), NULL((void*)0));

for ( ; symes ; symes = cdr(symes)((symes)->rest)) {
int	nextLabel;
assert(symeIsExport(car(symes)))do { if (!((((((((symes)->first))->kind == SYME_Trigger
 ? libGetAllSymes((((symes)->first))->lib) : ((void*)0)
), (((symes)->first)))->kind) == SYME_Export))) _do_assert
(("symeIsExport(car(symes))"),"gf_add.c",3052); } while (0);

nextLabel = gen0State->labelNo++;
gen0AddStmt(foamNewIf(foamNewCast(FOAM_Bool, gen0HasImport(dom, car(symes))),foamNew(FOAM_If, 2, foamNew(FOAM_Cast, 2, FOAM_Bool, gen0HasImport
(dom, ((symes)->first))), nextLabel)
		      nextLabel)foamNew(FOAM_If, 2, foamNew(FOAM_Cast, 2, FOAM_Bool, gen0HasImport
(dom, ((symes)->first))), nextLabel), NULL((void*)0));
gen0AddStmt(foamNewGoto(falseLabel)foamNew(FOAM_Goto, 1, (AInt)(falseLabel)), NULL((void*)0));
gen0AddStmt(foamNewLabel(nextLabel)foamNew(FOAM_Label, 1, (AInt)(nextLabel)), NULL((void*)0));
}
gen0AddStmt(foamNewSet(foamCopy(resultVar), foamNewBool(true))foamNew(FOAM_Set, 2, foamCopy(resultVar), foamNew(FOAM_Bool, 1
, (AInt)(1))), NULL((void*)0));
gen0AddStmt(foamNewGoto(endLabel)foamNew(FOAM_Goto, 1, (AInt)(endLabel)), NULL((void*)0));
gen0AddStmt(foamNewLabel(falseLabel)foamNew(FOAM_Label, 1, (AInt)(falseLabel)), NULL((void*)0));
gen0AddStmt(foamNewSet(foamCopy(resultVar), foamNewBool(false))foamNew(FOAM_Set, 2, foamCopy(resultVar), foamNew(FOAM_Bool, 1
, (AInt)(((int) 0)))), NULL((void*)0));
gen0AddStmt(foamNewLabel(endLabel)foamNew(FOAM_Label, 1, (AInt)(endLabel)), NULL((void*)0));
return resultVar;
3066}

3068localstatic Foam 
3069gen0HasImport(Foam dom, Syme syme) 
3070{
Foam 	foam;
TForm 	tf;
String str = symeString(syme)((((syme)->id))->str);

tf = symeType(syme);

foam = gen0BuiltinCCall(FOAM_Bool, "domainTestExport!",
		"runtime", 3,
		foamCopy(dom),
		foamNewSInt(gen0StrHash(str))foamNew(FOAM_SInt, 1, (AInt)(gen0StrHash(str))),
		gen0TypeHash(tf, tf, str));
foamPure(foam)((foam)->hdr.info.pure) = true1;

return foamNewCast(FOAM_Word, foam)foamNew(FOAM_Cast, 2, FOAM_Word, foam);
3085}	

3087/*****************************************************************************
*
* :: gen0NameType: Given an exporter, return a name-constuctor
*
****************************************************************************/

3093localstatic Foam 	gen0BuildExporterNameFn	(AbSyn);

3095localstatic Foam	gen0NameType	(AbSyn, Bool, Bool);
3096localstatic Foam	gen0NameApply   (AbSyn, Bool);
3097localstatic Foam	gen0NameId	(AbSyn, Bool, Bool);
3098localstatic Foam	gen0NameTuple	(Syme,  TForm, Bool);

3100localstatic Foam	gen0NameConst		(String);
3101localstatic Bool	gen0NameIsSingleParam	(AbSyn);
3102localstatic Foam 	gen0NameSingleParam	(String, Foam);
3103localstatic Foam	gen0NameCombineParts	(int argc, Foam *argv);
3104localstatic Foam	gen0NamePartFrString	(String s);


3107localstatic Foam
3108gen0BuildExporterName(AbSyn exporter)
3109{
if (!exporter)
return gen0NameConst("Anonymous");

else if (abTag(exporter)((exporter)->abHdr.tag) == AB_Id)
return gen0NameConst(symString(exporter->abId.sym)((exporter->abId.sym)->str));

else if (gen0NameIsSingleParam(exporter)) {
AbSyn	op  = abApplyOp(exporter)((exporter)->abApply.op);
AbSyn	arg = abApplyArg(exporter, int0)((exporter)->abApply.argv[((int) 0)]);
return gen0NameSingleParam(symString(op->abId.sym)((op->abId.sym)->str),
			   genFoamVal(arg));
}
else
return gen0BuildExporterNameFn(exporter);
3124}

3126localstatic Bool
3127gen0NameIsSingleParam(AbSyn exporter)
3128{
TForm	tf;

if (!(abIsApply(exporter)((exporter)->abHdr.tag == (AB_Apply)) && abApplyArgc(exporter)(((exporter)->abHdr.argc)-1) == 1))
return false((int) 0);
if (gen0RtSefoIsSpecialOp(exporter))
return false((int) 0);

if (!abIsId(abApplyOp(exporter))((((exporter)->abApply.op))->abHdr.tag == (AB_Id)))
return false((int) 0);

tf = gen0AbType(gen0EqualMods(abApplyArg(exporter, int0)((exporter)->abApply.argv[((int) 0)])));
return tfSatCat(tf) || tfSatDom(tf);
3141}

3143localstatic Foam 
3144gen0BuildExporterNameFn(AbSyn exporter)
3145{
GenFoamState	saved;
Foam		foam, clos;

clos = foamNewClos(foamNewEnv(int0), foamNewConst(gen0NumProgs))foamNew(FOAM_Clos,2, foamNew(FOAM_Env, 1, (AInt)(((int) 0))),
 foamNew(FOAM_Const, 1, (AInt)(gen0NumProgs)));
foam = gen0ProgInitEmpty(strCopy("addNameFn"), NULL((void*)0));

saved = gen0ProgSaveState(PT_Gener);

gen0AddStmt(foamNewReturn(gen0NameType(exporter, true, false))foamNew(FOAM_Return, 1, gen0NameType(exporter, 1, ((int) 0))), NULL((void*)0));

gen0ProgPushFormat(emptyFormatSlot4);
gen0ProgFiniEmpty(foam, FOAM_Word, int0((int) 0));

gen0AddLexLevels(foam, 1);

      foamOptInfo(foam)((foam)->hdr.info.opt) = optInfoNew(NULL((void*)0), foam, NULL((void*)0), false((int) 0));

gen0ProgRestoreState(saved);

return clos;
3166}


3169localstatic Foam
3170gen0NameType(AbSyn ab, Bool atExporter, Bool isEnum)
3171{
Foam	foam;
String	msg;

ab = gen0EqualMods(ab);

switch(abTag(ab)((ab)->abHdr.tag)) {
 case AB_Apply:
foam = gen0NameApply(ab, atExporter);
break;
 case AB_Id:
foam = gen0NameId(ab, atExporter, isEnum);
break;
 default:
msg = "gen0NameType found unhandled exporter type";
comsgFatal(ab, ALDOR_F_Bug365, msg);
NotReached(foam = 0){(void)bug("Not supposed to reach line %d in file: %s\n",3187
, "gf_add.c");};
3188#if 0
printf("unhandled exporter type");
abWrSExpr(dbOut, ab,int0((int) 0));
bug("unhandled exporter type");
foam = gen0NamePartFrString(abPretty(ab));
3193#endif
}
return foam;
3196}

3198localstatic Foam
3199gen0NameApply(AbSyn app, Bool atExporter)
3200{
AbSyn op = app->abApply.op;
Foam foam;
Foam *fmArgv;
Bool isEnum;
int argc = abApplyArgc(app)(((app)->abHdr.argc)-1);
int i;

isEnum = abTag(op)((op)->abHdr.tag) == AB_Id && op->abId.sym == ssymEnum;

fmArgv = (Foam *) stoAlloc(OB_Other0, (1 + argc)*sizeof(Foam));

fmArgv[0] = gen0NameType(op, atExporter, false((int) 0));

for (i=0; i<argc; i++) {
fmArgv[i+1] = gen0NameType(abApplyArg(app, i)((app)->abApply.argv[i]), false((int) 0), isEnum);
}

foam = gen0NameCombineParts(1 + argc, fmArgv);
stoFree(fmArgv);
return foam;
3221}

3223localstatic Foam
3224gen0NameId(AbSyn id, Bool atExporter, Bool isEnum)
3225{	
Syme   syme;
TForm  tf;

Foam foam;
if (atExporter)
return gen0NamePartFrString(symString(id->abId.sym)((id->abId.sym)->str));

syme = abSyme(id)((id)->abHdr.seman ? (id)->abHdr.seman->syme : 0);
tf = symeType(syme);
if (tfSatDom(tf)) 
foam = gen0BuiltinCCall(FOAM_Word, "domainName", "runtime",
			1, genFoamVal(id));
else if (tfIsTuple(tf)(((tf)->tag) == TF_Tuple)) 
foam = gen0NameTuple(syme, tfTupleArg(tf)tfFollowArg(tf, 0), isEnum);
else if (tfSatCat(tf)) 
foam = gen0BuiltinCCall(FOAM_Word, "categoryName", "runtime", 
			1, genFoamVal(id));
else
foam = gen0BuiltinCCall(FOAM_Word, "namePartFrOther",
			"runtime", 1, genFoamVal(id));
return foam;
3247}

3249localstatic Foam
3250gen0NameTuple(Syme id, TForm tf, Bool isEnum)
3251{
Foam tuple, n, newarr, foam, refexpr;
Foam t2[2];
int l1 = gen0State->labelNo++;
int l2 = gen0State->labelNo++;

tuple = foamNewCast(FOAM_Rec, gen0Syme(id))foamNew(FOAM_Cast, 2, FOAM_Rec, gen0Syme(id));
n     = gen0TempLocal(FOAM_SInt)gen0TempLocal0(FOAM_SInt, 4);

/*
* Generate:
*   n := size(tuple);
*   t2 := Tuple(n);
* l1:
*   n := n - 1;
*   if negative? n goto l2;
*   t2.n := domainName tuple.n;
*   goto l1;
* l2:
*   buildName(t2);
*/
gen0AddStmt(foamNewSet(foamCopy(n),foamNew(FOAM_Set, 2, foamCopy(n), foamNew(FOAM_RElt,3,(AInt)(
gen0MakeTupleFormat()),foamCopy(tuple),(AInt)(((int) 0)))) 
	       gen0NewTupleSizeRef(tuple))foamNew(FOAM_Set, 2, foamCopy(n), foamNew(FOAM_RElt,3,(AInt)(
gen0MakeTupleFormat()),foamCopy(tuple),(AInt)(((int) 0)))), NULL((void*)0));
gen0MakeEmptyTuple(foamCopy(n), t2, NULL((void*)0));
newarr = t2[1];
gen0AddStmt(foamNewLabel(l1)foamNew(FOAM_Label, 1, (AInt)(l1)), NULL((void*)0));
gen0AddStmt(foamNewSet(foamCopy(n),foamNew(FOAM_Set, 2, foamCopy(n), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntPrev
, foamCopy(n))) 
	       foamNew(FOAM_BCall, 2,foamNew(FOAM_Set, 2, foamCopy(n), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntPrev
, foamCopy(n))) 
		       FOAM_BVal_SIntPrev,foamNew(FOAM_Set, 2, foamCopy(n), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntPrev
, foamCopy(n)))
		       foamCopy(n)))foamNew(FOAM_Set, 2, foamCopy(n), foamNew(FOAM_BCall, 2, FOAM_BVal_SIntPrev
, foamCopy(n))), 
    NULL((void*)0));
gen0AddStmt(foamNewIf(foamNew(FOAM_BCall, 2, FOAM_BVal_SIntIsNeg,foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 2, FOAM_BVal_SIntIsNeg
, foamCopy(n)), l2) 
		      foamCopy(n)), l2)foamNew(FOAM_If, 2, foamNew(FOAM_BCall, 2, FOAM_BVal_SIntIsNeg
, foamCopy(n)), l2), NULL((void*)0));

refexpr = foamNewAElt(FOAM_Word, foamCopy(n),foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(n),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(tuple),(AInt)(1)))
	      gen0NewTupleValsRef(tuple))foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy(n),foamNew(FOAM_RElt
,3,(AInt)(gen0MakeTupleFormat()),foamCopy(tuple),(AInt)(1)));

if (isEnum) 
refexpr = gen0BuiltinCCall(FOAM_Word, "namePartFrString",
			   "runtime",
			   1, refexpr);
else if (tfSatDom(tf) || tfSatCat(tf))
refexpr = gen0BuiltinCCall(FOAM_Word, "domainName", "runtime",
			1, refexpr);
else
refexpr = gen0BuiltinCCall(FOAM_Word, "namePartFrOther",
			   "runtime", 1, refexpr);

gen0AddStmt(foamNewSet(foamNewAElt(FOAM_Word, foamCopy(n),foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy
(n),foamCopy(newarr)), refexpr)
			   foamCopy(newarr)), refexpr)foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamCopy
(n),foamCopy(newarr)), refexpr),
    NULL((void*)0));
gen0AddStmt(foamNewGoto(l1)foamNew(FOAM_Goto, 1, (AInt)(l1)), NULL((void*)0));
gen0AddStmt(foamNewLabel(l2)foamNew(FOAM_Label, 1, (AInt)(l2)), NULL((void*)0));

foam = gen0BuiltinCCall(FOAM_Word, "namePartConcat", "runtime", 2,
		foamNewBool(1)foamNew(FOAM_Bool, 1, (AInt)(1)), foamCopy(t2[0]));
foamFree(n);

return foam;
3310}

3312localstatic Foam
3313gen0NameConst(String s)
3314{
return gen0BuiltinCCall(FOAM_Word, "rtConstNameFn", "runtime", 1,
		gen0CharArray(s));
3317}

3319localstatic Foam
3320gen0NameSingleParam(String s, Foam foam)
3321{
return gen0BuiltinCCall(FOAM_Word, 
		"rtSingleParamNameFn", "runtime", 2,
		gen0CharArray(s),
		foam);
3326}

3328localstatic Foam
3329gen0NameCombineParts(int argc, Foam *argv)
3330{
return gen0BuiltinCCall(FOAM_Word, "namePartConcat", "runtime", 2,
		foamNewBool(false)foamNew(FOAM_Bool, 1, (AInt)(((int) 0))),
		gen0MakeTupleFromFoam(argc, argv));
3334}

3336localstatic Foam
3337gen0NamePartFrString(String s)
3338{
return gen0BuiltinCCall(FOAM_Word, "namePartFrString",
		"runtime", 1, gen0CharArray(s));
3341}

3343/*****************************************************************************
*
* :: Hash<->String value management
*
****************************************************************************/

3349/* hash values are placed in a table, and it is assumed that collisions never occur 
* [get assumes this too]
*/
3352static Table gen0StringTable;

3354void
3355gen0StringsInit()
3356{
gen0StringTable = tblNew((TblHashFun) NULL((void*)0), (TblEqFun) NULL((void*)0));
3358}

3360void
3361gen0StringsFini()
3362{
FoamList body;
Foam 	 str1, str2;
Foam	 int1, int2;
TableIterator iter;
int size = tblSize(gen0StringTable);
int	i=0;

if (size == 0) {
tblFree(gen0StringTable);
return;
}
body = gen0State->lines;
gen0State->lines = listNil(Foam)((FoamList) 0);

int1 = gen0TempLocal0(FOAM_Arr, FOAM_Word);
str1 = gen0TempLocal0(FOAM_Arr, FOAM_Word);

gen0AddStmt(gen0ANew(int1, FOAM_Word, size)foamNew(FOAM_Set, 2, foamCopy(int1), foamNew(FOAM_ANew, 2, FOAM_Word
, foamNew(FOAM_SInt, 1, (AInt)(size)))), NULL((void*)0));
gen0AddStmt(gen0ANew(str1, FOAM_Word, size)foamNew(FOAM_Set, 2, foamCopy(str1), foamNew(FOAM_ANew, 2, FOAM_Word
, foamNew(FOAM_SInt, 1, (AInt)(size)))), NULL((void*)0));

for (tblITER(iter, gen0StringTable)_tblITER(&(iter), gen0StringTable); tblMORE(iter)((iter).curr <= (iter).last); tblSTEP(iter)((((iter).link=(iter).link->next))==0 ? _tblSTEP(&(iter
)) : 1)) {
gen0AddStmt(gen0ASet(int1, i, FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(int1)), foamNew(FOAM_Cast,
 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt)((AInt) ((iter).link
->key)))))
		     foamNewCast(FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(int1)), foamNew(FOAM_Cast,
 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt)((AInt) ((iter).link
->key)))))
				 foamNewSInt((AInt) tblKEY(iter))))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(int1)), foamNew(FOAM_Cast,
 2, FOAM_Word, foamNew(FOAM_SInt, 1, (AInt)((AInt) ((iter).link
->key))))), NULL((void*)0));
gen0AddStmt(gen0ASet(str1, i, FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(str1)), foamNew(FOAM_Cast,
 2, FOAM_Word, gen0CharArray((String) ((iter).link->elt)))
) 
		     foamNewCast(FOAM_Word,foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(str1)), foamNew(FOAM_Cast,
 2, FOAM_Word, gen0CharArray((String) ((iter).link->elt)))
)
				 gen0CharArray((String) tblELT(iter))))foamNew(FOAM_Set, 2, foamNew(FOAM_AElt,3,(AInt)(FOAM_Word),foamNew
(FOAM_SInt, 1, (AInt)(i)),foamCopy(str1)), foamNew(FOAM_Cast,
 2, FOAM_Word, gen0CharArray((String) ((iter).link->elt)))
), 
	    NULL((void*)0));
i++;
}
int2 = gen0MakeArray(foamNewSInt(size)foamNew(FOAM_SInt, 1, (AInt)(size)), int1, NULL((void*)0));
str2 = gen0MakeArray(foamNewSInt(size)foamNew(FOAM_SInt, 1, (AInt)(size)), str1, NULL((void*)0));

gen0AddStmt(gen0BuiltinCCall(FOAM_NOp, "rtAddStrings", "runtime",
		     2, 
		     foamNewCast(FOAM_Word, int2)foamNew(FOAM_Cast, 2, FOAM_Word, int2), 
		     foamNewCast(FOAM_Word, str2)foamNew(FOAM_Cast, 2, FOAM_Word, str2)), NULL((void*)0));

gen0State->lines = listNConcat(Foam)(Foam_listPointer->NConcat)(body, gen0State->lines);

tblFree(gen0StringTable);
3404}

3406localstatic void
3407gen0StrRegister(int hash, String s)
3408{
tblSetElt(gen0StringTable, (TblKey) (long) hash, (TblElt) s);
3410}
