sefo.c

Bug Summary

File:	src/sefo.c
Warning:	line 3916, column 2 Value stored to 'serial' is never read

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 sefo.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 sefo.c

1	/*****************************************************************************
2	*
3	* sefo.c: Semantic form maniuplation
4	*
5	* Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
6	*
7	****************************************************************************/
8
9	#include "axlobs.h"
10	#include "debug.h"
11	#include "format.h"
12	#include "genfoam.h"
13	#include "ostream.h"
14	#include "spesym.h"
15	#include "srcpos.h"
16	#include "stab.h"
17	#include "store.h"
18	#include "util.h"
19	#include "sefo.h"
20	#include "archive.h"
21	#include "lib.h"
22	#include "tqual.h"
23	#include "tfsat.h"
24	#include "freevar.h"
25	#include "absub.h"
26	#include "abpretty.h"
27	#include "strops.h"
28	#include "table.h"
29
30	Bool sstDebug = false((int) 0);
31	Bool sstMarkDebug = false((int) 0);
32
33	Bool sefoPrintDebug = false((int) 0);
34	Bool sefoEqualDebug = false((int) 0);
35	Bool sefoFreeDebug = false((int) 0);
36	Bool sefoSubstDebug = false((int) 0);
37	Bool sefoUnionDebug = false((int) 0);
38	Bool sefoInterDebug = false((int) 0);
39	Bool sefoCloseDebug = false((int) 0);
40
41	#define sstDEBUGif (!sstDebug) { } else afprintf DEBUG_IF(sst)if (!sstDebug) { } else afprintf
42	#define sstMarkDEBUGif (!sstMarkDebug) { } else afprintf DEBUG_IF(sstMark)if (!sstMarkDebug) { } else afprintf
43
44	#define sefoPrintDEBUGif (!sefoPrintDebug) { } else afprintf DEBUG_IF(sefoPrint)if (!sefoPrintDebug) { } else afprintf
45	#define sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf DEBUG_IF(sefoEqual)if (!sefoEqualDebug) { } else afprintf
46	#define sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf DEBUG_IF(sefoFree)if (!sefoFreeDebug) { } else afprintf
47	#define sefoSubstDEBUGif (!sefoSubstDebug) { } else afprintf DEBUG_IF(sefoSubst)if (!sefoSubstDebug) { } else afprintf
48	#define sefoUnionDEBUGif (!sefoUnionDebug) { } else afprintf DEBUG_IF(sefoUnion)if (!sefoUnionDebug) { } else afprintf
49	#define sefoInterDEBUGif (!sefoInterDebug) { } else afprintf DEBUG_IF(sefoInter)if (!sefoInterDebug) { } else afprintf
50	#define sefoCloseDEBUGif (!sefoCloseDebug) { } else afprintf DEBUG_IF(sefoClose)if (!sefoCloseDebug) { } else afprintf
51
52	#define SefoSubstTUnique
53	#undef SefoSubstShare
54	#define MarkScheme3
55
56	static ULong * SubstDebugTable = NULL((void*)0);
57
58	void
59	substDebugInit(void)
60	{
61	Length i;
62	SubstDebugTable = (ULong *) stoAlloc((unsigned) OB_Other0,
63	(TF_LIMIT + 1) * sizeof(ULong));
64	for (i = 0; i <= TF_LIMIT; i += 1)
65	SubstDebugTable[i] = 0;
66	}
67
68	void
69	substDebugReport(void)
70	{
71	Length i;
72	for (i = 0; i <= TF_LIMIT; i += 1)
73	fprintf(dbOut, "\t%12s:\t\t%12ld\n",
74	tformStr(i)tformInfoTable[(int)(i) - (int)TF_START].str, SubstDebugTable[i]);
75	}
76
77	/*****************************************************************************
78	*
79	* :: Local function declarations.
80	*
81	****************************************************************************/
82
83	extern void genGetConstNums (SymeList);
84	extern SymeList tfGetDomConstants (TForm);
85
86	localstatic int sstPrSefo (FILE *, int, Sefo);
87	localstatic int sstPrSyme (FILE *, int, Syme);
88	localstatic int sstPrTForm (FILE *, int, TForm);
89	localstatic int sstPrAbSub (FILE *, int, AbSub);
90	localstatic int sstPrSefoList (FILE *, int, SefoList);
91	localstatic int sstPrSymeList (FILE *, int, SymeList);
92	localstatic int sstPrTFormList (FILE *, int, TFormList);
93	localstatic int sstPrBool (FILE *, int, Bool);
94	localstatic int sstPrLib (FILE *, int, Lib);
95
96	localstatic int sefoOStreamPrint0 (OStream, Bool, Sefo);
97	localstatic int symeOStreamPrint0 (OStream, Bool, Syme);
98	localstatic int tformOStreamPrint0 (OStream, Bool, TForm);
99	localstatic int sefoListOStreamPrint0 (OStream, Bool, SefoList);
100	localstatic int symeListOStreamPrint0 (OStream, Bool, SymeList);
101	localstatic int tformListOStreamPrint0 (OStream, Bool, TFormList);
102
103	localstatic Bool sefoEqual0 (SymeList, Sefo, Sefo);
104	localstatic Bool symeEqual0 (SymeList, Syme, Syme);
105	localstatic Bool tformEqual0 (SymeList, TForm, TForm);
106	localstatic Bool sefoListEqual0 (SymeList, SefoList, SefoList);
107	localstatic Bool symeListEqual0 (SymeList, SymeList, SymeList);
108	localstatic Bool tformListEqual0 (SymeList,TFormList,TFormList);
109	localstatic Bool sefoIsDefinedType (Sefo);
110
111	localstatic Bool symeTypeEqual0 (SymeList, Syme, Syme);
112	localstatic Bool symeExtendEqual0 (SymeList, Syme, Syme);
113	localstatic Bool symeOriginEqual0 (SymeList, Syme, Syme);
114
115	localstatic Bool tformEqualCheckSymes (TForm);
116	localstatic Sefo sefoEqualMods (Sefo);
117	localstatic AbEqualValue sefoIdEqual (void *, Sefo, Sefo);
118
119	localstatic void sfvInitTable (void);
120	localstatic void sfvFiniTable (void);
121	localstatic void sfvPushTable (void);
122	localstatic void sfvConsTable (Syme);
123	localstatic FreeVar sfvPopTable (Bool);
124
125	localstatic void sfvAddSyme (Syme);
126	localstatic void sfvAddSymes (SymeList);
127	localstatic void sfvDelSyme (Syme);
128	localstatic void sfvDelSymes (SymeList);
129	localstatic void sfvDelStab (Stab);
130
131	localstatic Bool sfvIsAncestor (TForm, TForm);
132	localstatic TForm sfvCommonAncestor (TForm, TForm);
133
134	localstatic void sefoFreeVars0 (TForm *, TForm, Sefo);
135	localstatic void symeFreeVars0 (TForm *, TForm, Syme);
136	localstatic void tformFreeVars0 (TForm *, TForm, TForm);
137	localstatic void tqualFreeVars0 (TForm *, TForm, TQual);
138	localstatic void abSubFreeVars0 (TForm *, TForm, AbSub);
139	localstatic void sefoListFreeVars0 (TForm *, TForm, SefoList);
140	localstatic void symeListFreeVars0 (TForm *, TForm, SymeList);
141	localstatic void tformListFreeVars0 (TForm *, TForm, TFormList);
142	localstatic void tqualListFreeVars0 (TForm *, TForm, TQualList);
143
144	localstatic void sefoUnboundVars0 (TForm *, TForm, Sefo);
145	localstatic void symeUnboundVars0 (TForm *, TForm, Syme);
146	localstatic void tformUnboundVars0 (TForm *, TForm, TForm);
147	localstatic void tqualUnboundVars0 (TForm *, TForm, TQual);
148	localstatic void sefoListUnboundVars0 (TForm *, TForm, SefoList);
149	localstatic void symeListUnboundVars0 (TForm *, TForm, SymeList);
150	localstatic void tformListUnboundVars0 (TForm *, TForm, TFormList);
151	localstatic void tqualListUnboundVars0 (TForm *, TForm, TQualList);
152
153	localstatic TQualList tqualListSubst (AbSub, TQualList);
154
155	localstatic Sefo sefoSubst0 (AbSub, Sefo);
156	localstatic Syme symeSubst0 (AbSub, Syme);
157	localstatic TForm tformSubst0 (AbSub, TForm);
158	localstatic TQual tqualSubst0 (AbSub, TQual);
159	localstatic FreeVar freeVarSubst0 (AbSub, FreeVar);
160	localstatic SymeList parentListSubst0 (AbSub, SymeList);
161	localstatic SefoList condListSubst0 (AbSub, SefoList);
162	localstatic SymeList symeListSubst0 (AbSub, SymeList);
163	localstatic TFormList tformListSubst0 (AbSub, TFormList);
164	localstatic TQualList tqualListSubst0 (AbSub, TQualList);
165
166	localstatic void symeListMarkTwins (AbSub, Syme, Syme);
167	localstatic void symeListSubstUseConstants(AbSub, SymeList, SymeList,
168	SymeList);
169
170	localstatic Bool symeWillPush (Syme);
171	localstatic Bool symeWillSubst (AbSub, Syme);
172	localstatic Bool tformWillSubst (AbSub, TForm);
173
174	localstatic void slcAddSyme (Lib, Syme);
175	localstatic void slcAddType (Lib, TForm);
176
177	localstatic void sefoClosure0 (Lib, Sefo);
178	localstatic void symeClosure0 (Lib, Syme);
179	localstatic void symeClosure1 (Lib, Syme);
180	localstatic void tformClosure0 (Lib, TForm);
181	localstatic void tqualClosure0 (Lib, TQual);
182
183	localstatic void sefoListClosure0 (Lib, SefoList);
184	localstatic void symeListClosure0 (Lib, SymeList);
185	localstatic void tformListClosure0 (Lib, TFormList);
186	localstatic void tqualListClosure0 (Lib, TQualList);
187
188	localstatic int freeVarToBuffer (Lib, Buffer, FreeVar);
189
190	localstatic int tformToBuffer1 (Lib, Buffer, TForm);
191	localstatic TForm tformFrBuffer1 (Lib, Buffer);
192
193	localstatic void sefoFrBuffer0 (Buffer);
194	localstatic void symeFrBuffer0 (Buffer);
195	localstatic void tformFrBuffer0 (Buffer);
196	localstatic void tqualFrBuffer0 (Buffer);
197	localstatic void sefoListFrBuffer0 (Buffer);
198	localstatic void tformListFrBuffer0 (Buffer);
199	localstatic void tqualListFrBuffer0 (Buffer);
200
201	/*****************************************************************************
202	*
203	* :: Sefo/Syme/TForm traversal stack
204	*
205	****************************************************************************/
206
207	union sstArg {
208	Pointer ptr;
209	Bool * pbool;
210	Sefo sefo;
211	SefoList sefos;
212	Syme syme;
213	SymeList symes;
214	TForm tform;
215	TFormList tforms;
216	AbSub sigma;
217	Lib lib;
218	};
219
220	struct sstFrame {
221	String where;
222	union sstArg arg1;
223	union sstArg arg2;
224	struct sstFrame *prev;
225	};
226
227	static struct sstFrame *sstStack = 0;
228
229	void
230	sstStackPush(String where, Pointer arg1, Pointer arg2)
231	{
232	struct sstFrame *frame;
233
234	frame = (struct sstFrame ) stoAlloc(OB_Other0, sizeof(frame));
235	frame->where = where;
236	frame->arg1.ptr = arg1;
237	frame->arg2.ptr = arg2;
238	frame->prev = sstStack;
239	sstStack = frame;
240	}
241
242	void
243	sstStackPop(void)
244	{
245	struct sstFrame *frame;
246
247	if (!sstStack)
248	bug("sstStackPop: popping empty stack");
249
250	frame = sstStack->prev;
251	stoFree((Pointer) sstStack);
252	sstStack = frame;
253	}
254
255	int
256	sstStackPrint(FILE *fout)
257	{
258	int n, cc = 0;
259	struct sstFrame *frame;
260	String where;
261
262	cc += fputcTimes('v', 70, fout);
263	cc += fprintf(fout, "\n");
264
265	/* Compute stack depth. */
266	for (n = 0, frame = sstStack; frame; frame = frame->prev)
267	n++;
268
269	/* Display the stack. */
270	for (frame = sstStack; frame; frame = frame->prev, n--) {
271	where = frame->where;
272	cc += fprintf(fout, "Level %d. %s: \n", n, where);
273
274	/*
275	* Equal
276	*/
277	if (strEqual(where, "sefoEqual")) {
278	cc += sstPrSefo(fout, 1, frame->arg1.sefo);
279	cc += sstPrSefo(fout, 2, frame->arg2.sefo);
280	}
281	else if (strEqual(where, "symeIsTwin")) {
282	cc += sstPrSyme(fout, 1, frame->arg1.syme);
283	cc += sstPrSyme(fout, 2, frame->arg2.syme);
284	}
285	else if (strEqual(where, "symeEqual")) {
286	cc += sstPrSyme(fout, 1, frame->arg1.syme);
287	cc += sstPrSyme(fout, 2, frame->arg2.syme);
288	}
289	else if (strEqual(where, "tformEqual")) {
290	cc += sstPrTForm(fout, 1, frame->arg1.tform);
291	cc += sstPrTForm(fout, 2, frame->arg2.tform);
292	}
293	else if (strEqual(where, "sefoListEqual")) {
294	cc += sstPrSefoList(fout, 1, frame->arg1.sefos);
295	cc += sstPrSefoList(fout, 2, frame->arg2.sefos);
296	}
297	else if (strEqual(where, "symeListEqual")) {
298	cc += sstPrSymeList(fout, 1, frame->arg1.symes);
299	cc += sstPrSymeList(fout, 2, frame->arg2.symes);
300	}
301	else if (strEqual(where, "tformListEqual")) {
302	cc += sstPrTFormList(fout, 1, frame->arg1.tforms);
303	cc += sstPrTFormList(fout, 2, frame->arg2.tforms);
304	}
305
306	/*
307	* EqualMod
308	*/
309	else if (strEqual(where, "sefoEqualMod")) {
310	cc += sstPrSefo(fout, 1, frame->arg1.sefo);
311	cc += sstPrSefo(fout, 2, frame->arg2.sefo);
312	}
313	else if (strEqual(where, "symeEqualMod")) {
314	cc += sstPrSyme(fout, 1, frame->arg1.syme);
315	cc += sstPrSyme(fout, 2, frame->arg2.syme);
316	}
317	else if (strEqual(where, "tformEqualMod")) {
318	cc += sstPrTForm(fout, 1, frame->arg1.tform);
319	cc += sstPrTForm(fout, 2, frame->arg2.tform);
320	}
321	else if (strEqual(where, "sefoListEqualMod")) {
322	cc += sstPrSefoList(fout, 1, frame->arg1.sefos);
323	cc += sstPrSefoList(fout, 2, frame->arg2.sefos);
324	}
325	else if (strEqual(where, "symeListEqualMod")) {
326	cc += sstPrSymeList(fout, 1, frame->arg1.symes);
327	cc += sstPrSymeList(fout, 2, frame->arg2.symes);
328	}
329	else if (strEqual(where, "tformListEqualMod")) {
330	cc += sstPrTFormList(fout, 1, frame->arg1.tforms);
331	cc += sstPrTFormList(fout, 2, frame->arg2.tforms);
332	}
333
334	/*
335	* FreeVars
336	*/
337	else if (strEqual(where, "abSubFreeVars")) {
338	cc += sstPrBool (fout, 1, *(frame->arg1.pbool));
339	cc += sstPrAbSub(fout, 2, frame->arg2.sigma);
340	}
341	else if (strEqual(where, "tformFreeVars")) {
342	cc += sstPrBool (fout, 1, *(frame->arg1.pbool));
343	cc += sstPrTForm(fout, 2, frame->arg2.tform);
344	}
345
346	/*
347	* ListClosure
348	*/
349	else if (strEqual(where, "symeListClosure")) {
350	cc += sstPrLib (fout, 1, frame->arg1.lib);
351	cc += sstPrSymeList(fout, 2, frame->arg2.symes);
352	}
353
354	else {
355	cc += fprintf(fout, "\tArg1: ???\n");
356	}
357	}
358	cc += fputcTimes('^', 70, fout);
359	cc += fprintf(fout, "\n");
360
361	return cc;
362	}
363
364	localstatic int
365	sstPrSefo(FILE *fout, int n, Sefo sefo)
366	{
367	int cc = 0;
368
369	cc += fprintf(fout, "\tArg%d: ", n);
370	cc += sefoPrint(fout, sefo);
371	cc += fprintf(fout, "\n");
372
373	return cc;
374	}
375
376	localstatic int
377	sstPrSyme(FILE *fout, int n, Syme syme)
378	{
379	int cc = 0;
380	OStream ostream = ostreamNewFrFile(fout);
381	cc += fprintf(fout, "\tArg%d: ", n);
382	cc += symePrint(fout, syme);
383	cc += fprintf(fout, "\n");
384	ostreamClose(ostream);
385	ostreamFree(ostream);
386	return cc;
387	}
388
389	localstatic int
390	sstPrTForm(FILE *fout, int n, TForm tform)
391	{
392	int cc = 0;
393	cc += fprintf(fout, "\tArg%d: ", n);
394	cc += tformPrint(fout, tform);
395	cc += fprintf(fout, "\n");
396	return cc;
397	}
398
399	localstatic int
400	sstPrAbSub(FILE *fout, int n, AbSub sigma)
401	{
402	int cc = 0;
403	cc += fprintf (fout, "\tArg%d: ", n);
404	cc += absPrint(fout, sigma);
405	cc += fprintf (fout, "\n");
406	return cc;
407	}
408
409	localstatic int
410	sstPrSefoList(FILE *fout, int n, SefoList sefos)
411	{
412	int i, cc = 0;
413	cc += fprintf(fout, "\tArg%d:\n", n);
414	for (i = 0; sefos; sefos = cdr(sefos)((sefos)->rest), i++) {
415	cc += fprintf(fout, "%d. ", i);
416	cc += sefoPrint(fout, car(sefos)((sefos)->first));
417	cc += fprintf(fout, "\n");
418	}
419	return cc;
420	}
421
422	localstatic int
423	sstPrSymeList(FILE *fout, int n, SymeList symes)
424	{
425	int i, cc = 0;
426	cc += fprintf(fout, "\tArg%d:\n", n);
427
428	for (i = 0; symes; symes = cdr(symes)((symes)->rest), i++) {
429	cc += fprintf(fout, "%d. ", i);
430	cc += symePrint(fout, car(symes)((symes)->first));
431	cc += fprintf(fout, "\n");
432	}
433	return cc;
434	}
435
436	localstatic int
437	sstPrTFormList(FILE *fout, int n, TFormList tforms)
438	{
439	int i, cc = 0;
440	cc += fprintf(fout, "\tArg%d:\n", n);
441
442	for (i = 0; tforms; tforms = cdr(tforms)((tforms)->rest), i++) {
443	cc += fprintf(fout, "%d. ", i);
444	cc += tformPrint(fout, car(tforms)((tforms)->first));
445	cc += fprintf(fout, "\n");
446	}
447	return cc;
448	}
449
450	localstatic int
451	sstPrBool(FILE *fout, int n, Bool flag)
452	{
453	return fprintf(fout, "\tArg%d: %s\n", n, flag ? "true" : "false");
454	}
455
456	localstatic int
457	sstPrLib(FILE *fout, int n, Lib lib)
458	{
459	int cc = 0;
460	cc += fprintf(fout, "\tArg%d: ", n);
461	cc += fprintf(fout, "%s", fnameUnparseStatic(lib->name));
462	cc += fprintf(fout, "\n");
463	return cc;
464	}
465
466	/*****************************************************************************
467	*
468	* :: Sefo/Syme/TForm traversal control (General)
469	*
470	****************************************************************************/
471
472	static int sstSerialDebug = 0; /* debugging counter */
473
474	#define sstNext(wh,a1,a2){ if (sstDebug) { sstNextDB(wh, (Pointer)(a1), (Pointer)(a2)) ; } sstNext0(); } { \
475	if (DEBUG(sst)sstDebug) { \
476	sstNextDB(wh, (Pointer)(a1), (Pointer)(a2)); \
477	} \
478	sstNext0(); \
479	}
480	#define sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } } { \
481	sstDone0(); \
482	if (DEBUG(sst)sstDebug) { \
483	sstDoneDB(); \
484	} \
485	}
486
487	#define sstDoneSefo(sefo){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { sefoClear(sefo); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
488	#define sstDoneSyme(syme){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { symeClear(syme); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
489	#define sstDoneTForm(tform){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { tformClear(tform); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
490	#define sstDoneAbSub(sigma){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { abSubClear(sigma); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
491	#define sstDoneSefoList(sl){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { sefoListClear(sl); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
492	#define sstDoneSymeList(sl){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { symeListClear(sl); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
493	#define sstDoneTFormList(tl){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; } { tformListClear(tl); sstDone(){ sstDone0(); if (sstDebug) { sstDoneDB(); } }; }
494
495	/*****************************************************************************
496	*
497	* :: Sefo/Syme/TForm traversal control (Scheme 1)
498	*
499	****************************************************************************/
500
501	#if defined(MarkScheme1)
502	/* To handle simultaneous sst traversals, interpret the mark bits
503	* as two fields: the round number and the traversal number.
504	* Increment the round number only after the current traversals complete.
505	* Each round can handle up to eight simultaneous traversals.
506	* We can have a lot of rounds. (2^24 for 32 bit longs)
507	*/
508
509	/* A more complete implementation would use a stack of mark bits,
510	* but since we do so many traversals, it would be better to have
511	* a way that doesn't allocate memory.
512	*/
513	/* Where this scheme fails the fastest is when we have a need to
514	* do repeated instances of traversal "B" within a traversal "A".
515	* Being in traversal "A" fixes the round, and then the repeated
516	* instances of traversal "B" use up the bits.
517	*/
518
519	static ULong sstSerialRound = 1; /* sst round counter */
520	static ULong sstSerialTraversal = 0; /* sst traversal counter */
521	static ULong sstMarkMask = 0; /* active traversal mask */
522	static ULong sstSerialNext = 0; /* next available mask bit */
523
524	/* sstSerialTraversal always points to the high bit of sstMarkMask. */
525
526	#define SST_TR_NBITS (8)
527	#define SST_RD_NBITS (bitsizeof(SefoMark)(8 * sizeof(SefoMark)) - SST_TR_NBITS)
528
529	#define SST_TR_SHIFT (0)
530	#define SST_TR_MASK ((1 << SST_TR_NBITS) - 1)
531
532	#define SST_RD_SHIFT (SST_TR_SHIFT + SST_TR_NBITS)
533	#define SST_RD_MASK (((1 << SST_RD_NBITS) - 1) << SST_RD_SHIFT)
534
535	#define sstRound(m) (((m) & SST_RD_MASK) >> SST_RD_SHIFT)
536	#define sstSet(r, t) (((r) << SST_RD_SHIFT) \| (t) << SST_TR_SHIFT)
537	#define sstBit() (1 << sstSerialTraversal)
538
539	localstatic void
540	sstNext0(void)
541	{
542	/* If all the traversals for the current round are complete,
543	* go to the next round, otherwise, go to the next traversal.
544	*/
545	if (sstMarkMask == 0) {
546	sstSerialRound += 1;
547	sstSerialNext = 0;
548	}
549	else
550	sstSerialNext += 1;
551
552	if (sstSerialNext == SST_TR_NBITS)
553	bug("sstNext: too many simultaneous traversals");
554
555	sstSerialTraversal = sstSerialNext;
556	sstMarkMask \|= sstBit();
557	}
558
559	localstatic void
560	sstDone0(void)
561	{
562	ULong mask;
563
564	sstMarkMask &= ~sstBit();
565	sstSerialTraversal = 0;
566
567	for (mask = sstMarkMask >> 1; mask; mask >>= 1)
568	sstSerialTraversal += 1;
569
570	assert(sstMarkMask == 0 \|\| sstMarkMask >> sstSerialTraversal == 1)do { if (!(sstMarkMask == 0 \|\| sstMarkMask >> sstSerialTraversal == 1)) _do_assert(("sstMarkMask == 0 \|\| sstMarkMask >> sstSerialTraversal == 1" ),"sefo.c",570); } while (0);
571	}
572
573	localstatic ULong
574	sstSetMark(ULong mark)
575	{
576	if (sstRound(mark) == sstSerialRound)
577	return (mark \| sstBit());
578	else
579	return sstSet(sstSerialRound, sstBit());
580	}
581
582	localstatic Bool
583	sstIsMarked(ULong mark)
584	{
585	return (sstRound(mark) == sstSerialRound) && (mark & sstBit());
586	}
587
588	#define sstMarkSyme(syme) symeSetMark(syme, sstSetMark(symeMark(syme)))(symeSetFieldVal = ((AInt) (sstSetMark(((SefoMark) ((((((syme )->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Mark ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo [SYFI_Mark].def)))))), (((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? (((syme)->fieldv)[symeIndex(syme ,SYFI_Mark)] = (symeSetFieldVal)) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Mark].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Mark,symeSetFieldVal))
589	#define sstMarkTForm(tf) tformSetMark(tf, sstSetMark(tformMark(tf)))((tf)->__mark = (sstSetMark(((tf)->__mark))))
590
591	#define sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0))) sstIsMarked(symeMark(syme)((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv)[symeIndex(syme, SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def))))
592	#define sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0))) sstIsMarked(tformMark(tf)((tf)->__mark))
593
594	#endif /* defined(MarkScheme1) */
595
596
597	/*****************************************************************************
598	*
599	* :: Sefo/Syme/TForm traversal control (Scheme 2)
600	*
601	****************************************************************************/
602
603	#if defined(MarkScheme2)
604
605	/*
606	* This scheme uses each mark bit individually and relies on being able
607	* to clear all the bits which are set.
608	*/
609
610	#define SST_NMASK_BITS bitsizeof(SefoMark)(8 * sizeof(SefoMark))
611
612	static int sstMarkBitNo = -1;
613	static SefoMark sstMarkMask = 0;
614	static int sstMarkCount = 0;
615	static int sstMarkCountSave[SST_NMASK_BITS];
616
617	localstatic void
618	sstNext0(void)
619	{
620	/* Save state. */
621	if (sstMarkBitNo >= 0) {
622	sstMarkCountSave[sstMarkBitNo] = sstMarkCount;
623	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "sstNext: saving count %d\n",
624	sstMarkCount);
625	}
626
627	/* Increment level. */
628	sstMarkBitNo++;
629	if (sstMarkBitNo >= SST_NMASK_BITS) {
630	sstStackPrint(stderrstderr);
631	bug("sstNext: too many simultaneous traversals");
632	}
633
634	/* Initialize new state. */
635	sstMarkMask = 1L << sstMarkBitNo;
636	sstMarkCount = sstMarkCountSave[sstMarkBitNo] = 0;
637
638	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "sstNext: BitNo = %d\n", sstMarkBitNo);
639	}
640
641	localstatic void
642	sstDone0(void)
643	{
644	/* Verify current state. */
645	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "sstDone: BitNo = %d\n", sstMarkBitNo);
646	assert(sstMarkBitNo >= 0)do { if (!(sstMarkBitNo >= 0)) _do_assert(("sstMarkBitNo >= 0" ),"sefo.c",646); } while (0);
647	if (sstMarkCount != 0) {
648	sstStackPrint(stderrstderr);
649	bug("sstDone: lost %d marks.", sstMarkCount);
650	}
651
652	/* Decrement level. */
653	sstMarkBitNo--;
654
655	/* Restore previous state. */
656	if (sstMarkBitNo >= 0) {
657	sstMarkMask = 1L << sstMarkBitNo;
658	sstMarkCount = sstMarkCountSave[sstMarkBitNo];
659	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "sstDone: restoring count %d\n",
660	sstMarkCount);
661	}
662	}
663
664	#define sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0))) (symeMark(syme)((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv)[symeIndex(syme, SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def))) & sstMarkMask)
665	#define sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0))) (tformMark(tf)((tf)->__mark) & sstMarkMask)
666
667	#define sstMarkSyme(syme) \
668	{ if (!sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0)))) { \
669	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "++ marking %p\n", syme); \
670	sstMarkCount++; \
671	symeSetMark((syme), symeMark(syme) \| sstMarkMask)(symeSetFieldVal = ((AInt) (((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? ((syme )->fieldv)[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark ].def))) \| sstMarkMask)), ((((((syme))->kind == SYME_Trigger ? libGetAllSymes(((syme))->lib) : ((void)0)), ((syme)))-> locmask) & (1 << (SYFI_Mark))) ? ((((syme))->fieldv )[symeIndex((syme),SYFI_Mark)] = (symeSetFieldVal)) : !(((syme ))->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Mark ].def) ? symeSetFieldVal : symeSetFieldFn((syme),SYFI_Mark,symeSetFieldVal )); }}
672
673	#define sstMarkTForm(tf) \
674	{ if (!sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0)))) { \
675	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "++ marking %p\n", tf); \
676	sstMarkCount++; \
677	tformSetMark((tf), tformMark(tf) \| sstMarkMask)(((tf))->__mark = (((tf)->__mark) \| sstMarkMask)); }}
678
679	#define sstClearSyme(syme) \
680	{ if (sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0)))) { \
681	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "-- clearing %p\n", syme); \
682	sstMarkCount--; \
683	symeSetMark((syme), symeMark(syme) & ~sstMarkMask)(symeSetFieldVal = ((AInt) (((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? ((syme )->fieldv)[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark ].def))) & ~sstMarkMask)), ((((((syme))->kind == SYME_Trigger ? libGetAllSymes(((syme))->lib) : ((void)0)), ((syme)))-> locmask) & (1 << (SYFI_Mark))) ? ((((syme))->fieldv )[symeIndex((syme),SYFI_Mark)] = (symeSetFieldVal)) : !(((syme ))->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Mark ].def) ? symeSetFieldVal : symeSetFieldFn((syme),SYFI_Mark,symeSetFieldVal )); }}
684
685	#define sstClearTForm(tf) \
686	{ if (sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0)))) { \
687	sstMarkDEBUGif (!sstMarkDebug) { } else afprintf(dbOut, "-- clearing %p\n", tf); \
688	sstMarkCount--; \
689	tformSetMark((tf), tformMark(tf) & ~sstMarkMask)(((tf))->__mark = (((tf)->__mark) & ~sstMarkMask)); }}
690
691
692	#endif /* defined(MarkScheme2) */
693
694
695	/*****************************************************************************
696	*
697	* :: Sefo/Syme/TForm traversal control (Scheme 3)
698	*
699	****************************************************************************/
700
701	#if defined(MarkScheme3)
702
703	static ULong sstMarkMask = 0; /* For the generic debug fns. */
704
705	/*
706	* Not Traversing: sstMarkDepth=0; sstMarkTable=0; sstMarkStack=0;
707	* 1st Level(uses Round): sstMarkDepth=1; sstMarkTable=0; sstMarkStack=[0];
708	* 2nd Level(uses Table): sstMarkDepth=2; sstMarkTable=T; sstMarkStack=[0,0];
709	* 3rd Level(uses Table): sstMarkDepth=3; sstMarkTable=U; sstMarkStack=[T,0,0];
710	* ...
711	*/
712
713	static int sstMarkDepth = 0; /* current depth of marking. */
714	static long sstMarkRound = 0; /* round counter (level 1) */
715	static TableList sstMarkStack = 0; /* mark table stack (levels > 1) */
716	static Table sstMarkTable = 0; /* current markees (levels > 1) */
717
718	localstatic void
719	sstNext0(void)
720	{
721	sstMarkDepth++;
722
723	if (sstMarkDepth == 1)
724	sstMarkRound++;
725	else {
726	sstMarkStack = listCons(Table)(Table_listPointer->Cons)(sstMarkTable, sstMarkStack);
727	sstMarkTable = 0; /* Will be allocated on first use. */
728	}
729	}
730
731
732	localstatic void
733	sstDone0(void)
734	{
735
736	if (sstMarkDepth == 1)
737	; /* Nothing */
738	else {
739	if (sstMarkTable) tblFree(sstMarkTable);
740	sstMarkTable = car(sstMarkStack)((sstMarkStack)->first);
741	sstMarkStack = listFreeCons(Table)(Table_listPointer->FreeCons)(sstMarkStack);
742	}
743
744	sstMarkDepth--;
745	}
746
747	localstatic void
748	sstMarkSyme(Syme syme)
749	{
750	if (sstMarkDepth == 1)
751	symeSetMark(syme, sstMarkRound)(symeSetFieldVal = ((AInt) (sstMarkRound)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0 )), (syme))->locmask) & (1 << (SYFI_Mark))) ? (( (syme)->fieldv)[symeIndex(syme,SYFI_Mark)] = (symeSetFieldVal )) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_Mark].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Mark ,symeSetFieldVal));
752	else {
753	if (!sstMarkTable)
754	sstMarkTable = tblNew((TblHashFun) 0, (TblEqFun) 0);
755	tblSetElt(sstMarkTable, (Pointer) syme, (Pointer) syme);
756	}
757	}
758
759	localstatic void
760	sstMarkTForm(TForm tf)
761	{
762	if (sstMarkDepth == 1)
763	tformSetMark(tf, sstMarkRound)((tf)->__mark = (sstMarkRound));
764	else {
765	if (!sstMarkTable)
766	sstMarkTable = tblNew((TblHashFun) 0, (TblEqFun) 0);
767	tblSetElt(sstMarkTable, (Pointer) tf, (Pointer) tf);
768	}
769	}
770
771	#define sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0))) \
772	(sstMarkDepth == 1 ? symeMark(syme)((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv)[symeIndex(syme, SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def))) == sstMarkRound \
773	: sstMarkTable && tblElt(sstMarkTable, (Pointer) (syme), NULL((void*)0)))
774
775	#define sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0))) \
776	(sstMarkDepth == 1 ? tformMark(tf)((tf)->__mark) == sstMarkRound \
777	: sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), NULL((void*)0)))
778
779	#endif /* defined(MarkScheme3) */
780
781	/*****************************************************************************
782	*
783	* :: Sefo/Syme/TForm unmarking
784	*
785	****************************************************************************/
786
787	#if defined(MarkScheme1)
788
789	#define sefoClear(sefo) Nothing
790	#define symeClear(syme) Nothing
791	#define tformClear(tform) Nothing
792	#define abSubClear(sigma) Nothing
793	#define sefoListClear(sl) Nothing
794	#define symeListClear(sl) Nothing
795	#define tformListClear(tl) Nothing
796
797	#endif /* defined(MarkScheme1) */
798
799
800	#if defined(MarkScheme2)
801
802	localstatic void sefoClear (Sefo);
803	localstatic void symeClear (Syme);
804	localstatic void tformClear (TForm);
805	localstatic void tqualClear (TQual);
806	localstatic void abSubClear (AbSub);
807	localstatic void sefoListClear (SefoList);
808	localstatic void symeListClear (SymeList);
809	localstatic void tformListClear (TFormList);
810	localstatic void tqualListClear (TQualList);
811
812	localstatic void
813	sefoClear(Sefo sefo)
814	{
815	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
816	if (abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ))
817	symeClear(abSyme(sefo));
818	if (abImplicit(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->implicit : 0))
819	sefoClear(abImplicit(sefo));
820	}
821	else {
822	Length i;
823	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1)
824	sefoClear(abArgv(sefo)[i]);
825	}
826	}
827
828	localstatic void
829	symeClear(Syme syme)
830	{
831	if (!sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0))))
832	return;
833
834	sstClearSyme(syme);
835
836	if (!symeIsLazy(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) & (0x0001)))
837	tformClear(symeType(syme));
838
839	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import))
840	tformClear(symeExporter(syme));
841	if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Extend))
842	symeListClear(symeExtendee(syme));
843	if (symeExtension(syme))
844	symeClear(symeExtension(syme));
845	if (symeCondition(syme))
846	sefoListClear(symeCondition(syme));
847	}
848
849	localstatic void
850	tformClear(TForm tf)
851	{
852	assert (tf != 0)do { if (!(tf != 0)) _do_assert(("tf != 0"),"sefo.c",852); } while (0);
853	tf = tfFollowOnly(tf);
854
855	if (!sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0))))
856	return;
857
858	sstClearTForm(tf);
859
860	if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT))
861	;
862	else if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_ABSYN_LIMIT))
863	sefoClear(tfGetExpr(tf));
864	else if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_NODE_LIMIT)) {
865	Length i;
866	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
867	tformClear(tfFollowArg(tf, i));
868	}
869	else
870	bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag) , 870, "sefo.c");
871
872	if (tfSelf(tf)((tf)->self))
873	symeListClear(tfSelf(tf));
874	if (tfSelfSelf(tf)((tf)->selfself))
875	symeListClear(tfSelfSelf(tf));
876	if (tfParents(tf)((tf)->parents))
877	symeListClear(tfParents(tf));
878	if (tfSymes(tf)((tf)->symes))
879	symeListClear(tfSymes(tf));
880
881	/* Extra stuff */
882	if (tfDomExports(tf))
883	symeListClear(tfDomExports(tf));
884	if (tfCatExports(tf))
885	symeListClear(tfCatExports(tf));
886	if (tfThdExports(tf))
887	symeListClear(tfThdExports(tf));
888
889	if (tfDomImports(tf))
890	symeListClear(tfDomImports(tf));
891
892	if (tfQueries(tf)((tf)->queries))
893	tformListClear(tfQueries(tf));
894	if (tfCascades(tf)((tf)->cascades))
895	tqualListClear(tfCascades(tf)((tf)->cascades));
896	}
897
898	localstatic void
899	tqualClear(TQual tq)
900	{
901	assert(tq != 0)do { if (!(tq != 0)) _do_assert(("tq != 0"),"sefo.c",901); } while (0);
902
903	tformClear(tqBase(tq));
904	if (tqIsQualified(tq)((tq)->isQual == 1))
905	tformListClear(tqQual(tq));
906	}
907
908	localstatic void
909	abSubClear(AbSub sigma)
910	{
911	AbBindList l0;
912	for (l0 = sigma->l; l0; l0 = cdr(l0)((l0)->rest))
913	sefoClear(car(l0)->val);
914	}
915
916	localstatic void
917	sefoListClear(SefoList sefos)
918	{
919	for ( ; sefos; sefos = cdr(sefos)((sefos)->rest))
920	sefoClear(car(sefos));
921	}
922
923	localstatic void
924	symeListClear(SymeList symes)
925	{
926	for ( ; symes; symes = cdr(symes)((symes)->rest))
927	symeClear(car(symes));
928	}
929
930	localstatic void
931	tformListClear(TFormList tforms)
932	{
933	for ( ; tforms; tforms = cdr(tforms)((tforms)->rest))
934	tformClear(car(tforms));
935	}
936
937	localstatic void
938	tqualListClear(TQualList tquals)
939	{
940	for ( ; tquals; tquals = cdr(tquals)((tquals)->rest))
941	tqualClear(car(tquals)((tquals)->first));
942	}
943
944	#endif /* defined(MarkScheme2) */
945
946
947	#if defined(MarkScheme3)
948
949	#define sefoClear(sefo) Nothing
950	#define symeClear(syme) Nothing
951	#define tformClear(tform) Nothing
952	#define abSubClear(sigma) Nothing
953	#define sefoListClear(sl) Nothing
954	#define symeListClear(sl) Nothing
955	#define tformListClear(tl) Nothing
956
957	#endif /* defined(MarkScheme3) */
958
959
960	/*****************************************************************************
961	*
962	* :: Sefo/Syme/TForm traversal debugging
963	*
964	****************************************************************************/
965
966	void
967	sstNextDB(String where, Pointer arg1, Pointer arg2)
968	{
969	int i;
970
971	sstStackPush(where, arg1, arg2);
972
973	if (sstMarkMask <= 1) return;
974
975	fprintf(dbOut, "-> sstNext (%s) [%d]\n", where, sstSerialDebug);
976
977	fprintf(dbOut, "sstNext +");
978	for (i = 0; i < bitsizeof(SefoMark)(8 * sizeof(SefoMark)); i++)
979	fprintf(dbOut, (sstMarkMask & (1<<i)) ? "1" : "0");
980	fprintf(dbOut, "\n");
981
982	sstStackPrint(dbOut);
983	}
984
985	void
986	sstDoneDB(void)
987	{
988	int i;
989
990	sstStackPop();
991
992	if (sstMarkMask <= 1) return;
993
994	fprintf(dbOut, "<- sstDone\n");
995
996	fprintf(dbOut, "sstDone -");
997	for (i = 0; i < bitsizeof(SefoMark)(8 * sizeof(SefoMark)); i++)
998	fprintf(dbOut, (sstMarkMask & (1<<i)) ? "1" : "0");
999	fprintf(dbOut, "\n");
1000	}
1001
1002	/*****************************************************************************
1003	*
1004	* :: sstPrint
1005	*
1006	****************************************************************************/
1007
1008	/*
1009	* Within debugging code, we should avoid using the sst marking code
1010	* and avoid pushing any lazy symes.
1011	*/
1012
1013	/*
1014	* sstPrint external entry points.
1015	*/
1016
1017	int
1018	sefoPrint(FILE *fout, Sefo sefo)
1019	{
1020	struct ostream ostream;
1021	int n;
1022
1023	ostreamInitFrFile(&ostream, fout);
1024	n = sefoOStreamPrint0(&ostream, true1, sefo);
1025	ostreamClose(&ostream);
1026	return n;
1027	}
1028
1029	int
1030	symePrint(FILE *fout, Syme syme)
1031	{
1032	struct ostream ostream;
1033	int n;
1034	ostreamInitFrFile(&ostream, fout);
1035	n = symeOStreamPrint0(&ostream, true1, syme);
1036	ostreamClose(&ostream);
1037	return n;
1038	}
1039
1040	int
1041	symeOStreamWrite(OStream ostream, Syme syme)
1042	{
1043	int n = symeOStreamPrint0(ostream, false((int) 0), syme);
1044
1045	return n;
1046	}
1047
1048	int
1049	tformPrint(FILE *fout, TForm tf)
1050	{
1051	struct ostream ostream;
1052	int n;
1053	ostreamInitFrFile(&ostream, fout);
1054	n = tformOStreamPrint0(&ostream, true1, tf);
1055	ostreamClose(&ostream);
1056	return n;
1057	}
1058
1059	int
1060	sefoListPrint(FILE *fout, SefoList sefos)
1061	{
1062	struct ostream ostream;
1063	int n;
1064
1065	ostreamInitFrFile(&ostream, fout);
1066	n = sefoListOStreamPrint0(&ostream, true1, sefos);
1067	ostreamClose(&ostream);
1068	return n;
1069	}
1070
1071	int
1072	symeListPrint(FILE *fout, SymeList symes)
1073	{
1074	struct ostream ostream;
1075	int n;
1076
1077	ostreamInitFrFile(&ostream, fout);
1078	n = symeListOStreamPrint0(&ostream, true1, symes);
1079	ostreamClose(&ostream);
1080	return n;
1081	}
1082
1083	int
1084	tformListPrint(FILE *fout, TFormList tforms)
1085	{
1086	struct ostream ostream;
1087	int n;
1088
1089	ostreamInitFrFile(&ostream, fout);
1090	n = tformListOStreamPrint0(&ostream, true1, tforms);
1091	ostreamClose(&ostream);
1092	return n;
1093	}
1094
1095	/*
1096	* sstPrintDb external entry points.
1097	*/
1098
1099	int
1100	sefoPrintDb(Sefo sefo)
1101	{
1102	struct ostream ostream;
1103	int n;
1104	ostreamInitFrFile(&ostream, dbOut);
1105	n = sefoOStreamPrint0(&ostream, false((int) 0), sefo);
1106
1107	ostreamClose(&ostream);
1108	fnewline(dbOut);
1109	return n;
1110	}
1111
1112	int
1113	symePrintDb(Syme syme)
1114	{
1115	struct ostream ostream;
1116	int n;
1117	ostreamInitFrFile(&ostream, dbOut);
1118	n = symeOStreamPrint0(&ostream, false((int) 0), syme);
1119	ostreamClose(&ostream);
1120	fnewline(dbOut);
1121	return n;
1122	}
1123
1124	int
1125	symePrintDb2(Syme syme)
1126	{
1127	struct ostream ostream;
1128	int n;
1129	ostreamInitFrFile(&ostream, dbOut);
1130	n = symeOStreamPrint0(&ostream, false((int) 0), syme);
1131	ostreamClose(&ostream);
1132	return n;
1133	}
1134
1135	int
1136	tformOStreamWrite(OStream ostream, Bool deep, TForm tf)
1137	{
1138	int n = tformOStreamPrint0(ostream, deep, tf);
1139
1140	return n;
1141	}
1142
1143	int
1144	sefoOStreamWrite(OStream ostream, Sefo sefo)
1145	{
1146	int n = sefoOStreamPrint0(ostream, false((int) 0), sefo);
1147
1148	return n;
1149	}
1150
1151	int
1152	tformPrintDb(TForm tf)
1153	{
1154	struct ostream ostream;
1155	int n;
1156	ostreamInitFrFile(&ostream, dbOut);
1157	n = tformOStreamPrint0(&ostream, false((int) 0), tf);
1158	ostreamClose(&ostream);
1159	fnewline(dbOut);
1160	return n;
1161	}
1162
1163	int
1164	sefoListPrintDb(SefoList sefos)
1165	{
1166	struct ostream ostream;
1167	int n;
1168	ostreamInitFrFile(&ostream, dbOut);
1169	n = sefoListOStreamPrint0(&ostream, false((int) 0), sefos);
1170	ostreamClose(&ostream);
1171	fnewline(dbOut);
1172	return n;
1173	}
1174
1175	int
1176	symeListPrintDb(SymeList symes)
1177	{
1178	struct ostream ostream;
1179	int n;
1180	ostreamInitFrFile(&ostream, dbOut);
1181	n = symeListOStreamPrint0(&ostream, false((int) 0), symes);
1182	ostreamClose(&ostream);
1183	fnewline(dbOut);
1184	return n;
1185	}
1186
1187	int
1188	tformListPrintDb(TFormList tforms)
1189	{
1190	struct ostream ostream;
1191	int n;
1192	ostreamInitFrFile(&ostream, dbOut);
1193	n = tformListOStreamPrint0(&ostream, false((int) 0), tforms);
1194	ostreamClose(&ostream);
1195	fnewline(dbOut);
1196	return n;
1197	}
1198
1199	/*
1200	* Local functions.
1201	*/
1202
1203	localstatic int
1204	sefoOStreamPrint0(OStream ostream, Bool deep, Sefo sefo)
1205	{
1206	int cc = 0;
1207
1208	if (!sefo)
1209	return ostreamPrintf(ostream, "(* NULL *)");
1210
1211	cc += ostreamPrintf(ostream, "(*");
1212
1213	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
1214	cc += ostreamPrintf(ostream, " ");
1215	cc += abOStreamPrint(ostream, sefo);
1216	if (DEBUG(sefoPrint)sefoPrintDebug) {
1217	if (abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 )) {
1218	cc += ostreamPrintf(ostream, " ");
1219	cc += symeOStreamPrint0(ostream, false((int) 0), abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
1220	}
1221	}
1222	}
1223
1224	else {
1225	Length i;
1226	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1) {
1227	cc += ostreamPrintf(ostream, " ");
1228	cc += sefoOStreamPrint0(ostream, deep, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
1229	}
1230	}
1231
1232	cc += ostreamPrintf(ostream, " *)");
1233
1234	return cc;
1235	}
1236
1237	localstatic int
1238	symeOStreamPrint0(OStream ostream, Bool deep, Syme syme)
1239	{
1240	int cc = 0;
1241
1242	if (!syme)
1243	return ostreamPrintf(ostream, "{* NULL *}");
1244
1245	cc += ostreamPrintf(ostream, "{* (%s) ",
1246	symeInfo[symeKind(syme)((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind)].str + sizeof("SYME_") - 1);
1247
1248	cc += ostreamPrintf(ostream, "%s", symeString(syme)((((syme)->id))->str));
1249
1250	if (DEBUG(sefoPrint)sefoPrintDebug) {
1251	cc += ostreamPrintf(ostream, " [%s.%ld%s, dn:%d %ld],",
1252	symeConstLib(syme) != NULL((void*)0) ? libToStringShort(symeConstLib(syme))(((symeConstLib(syme))->name)->partv[1]) : "",
1253	symeConstNum(syme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_ConstInfo ))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0 )), (syme))->locmask) & (1 << (SYFI_ConstInfo))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme )->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_ConstInfo))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ConstInfo )] : (symeFieldInfo[SYFI_ConstInfo].def)) : symeGetFieldFn(syme ,SYFI_ConstInfo))) & 0xFFFF) == 32767 ? -1 : symeConstNum(syme)(((AInt) (SYFI_ConstInfo < (8 sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_ConstInfo ))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0 )), (syme))->locmask) & (1 << (SYFI_ConstInfo))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme )->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_ConstInfo))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ConstInfo )] : (symeFieldInfo[SYFI_ConstInfo].def)) : symeGetFieldFn(syme ,SYFI_ConstInfo))) & 0xFFFF),
1254	symeHasDefault(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) & (0x0080)) ? "D":"",
1255	symeDefnNum(syme)((int) (SYFI_DefnNum < (8 * sizeof(int)) && !((((( syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib ) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_DefnNum ))) ? (symeFieldInfo[SYFI_DefnNum].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0 )), (syme))->locmask) & (1 << (SYFI_DefnNum))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme) ->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_DefnNum))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_DefnNum )] : (symeFieldInfo[SYFI_DefnNum].def)) : symeGetFieldFn(syme ,SYFI_DefnNum))), symeMark(syme)((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv)[symeIndex(syme, SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def))));
1256	}
1257
1258	if (deep) {
1259	cc += ostreamPrintf(ostream, " : ");
1260	if (symeIsLazy(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) & (0x0001)))
1261	cc += ostreamPrintf(ostream, "[lazy] %ld", symeHash(syme)((syme)->hash));
1262	else
1263	cc += tformOStreamPrint0(ostream, deep, symeType(syme));
1264
1265	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import)) {
1266	cc += ostreamPrintf(ostream, " from ");
1267	cc += tformOStreamPrint0(ostream, deep, symeExporter(syme));
1268	}
1269	}
1270
1271	cc += ostreamPrintf(ostream, " *}");
1272
1273	return cc;
1274	}
1275
1276	localstatic int
1277	tformOStreamPrint0(OStream ostream, Bool deep, TForm tf)
1278	{
1279	int cc = 0;
1280
1281	if (!tf)
1282	return ostreamPrintf(ostream, "<* NULL *>");
1283
1284	cc += ostreamPrintf(ostream, "<* %s", tformStr(tfTag(tf))tformInfoTable[(int)(((tf)->tag)) - (int)TF_START].str);
1285
1286	if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT))
1287	;
1288	else if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_ABSYN_LIMIT)) {
1289	cc += ostreamPrintf(ostream, " ");
1290	cc += sefoOStreamPrint0(ostream, deep, tfGetExpr(tf)((tf)->__absyn));
1291	}
1292	else if (tfIsSubst(tf)(((tf)->tag) == TF_Subst) && deep) {
1293	cc += ostreamPrintf(ostream, "%pAbSub", tf->sigma);
1294	cc += ostreamPrintf(ostream, " ");
1295	cc += tformOStreamPrint0(ostream, deep, tfSubstArg(tf)tfFollowArg(tf, 0));
1296	}
1297	else if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_NODE_LIMIT)) {
1298	Length i;
1299	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1) {
1300	cc += ostreamPrintf(ostream, " ");
1301	cc += tformOStreamPrint0(ostream, deep, tfArgv(tf)((tf)->argv)[i]);
1302	}
1303	}
1304	else
1305	bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag) , 1305, "sefo.c");
1306
1307	if (tfSymes(tf)((tf)->symes))
1308	cc += symeListOStreamPrint0(ostream, deep, tfSymes(tf)((tf)->symes));
1309
1310	cc += ostreamPrintf(ostream, " *>");
1311
1312	return cc;
1313	}
1314
1315	/* The deep argument is currently unused. */
1316	localstatic int
1317	sefoListOStreamPrint0(OStream ostream, Bool deep, SefoList sefos)
1318	{
1319	int cc = 0;
1320
1321	cc += ostreamPrintf(ostream, " (");
1322	for (; sefos; sefos = cdr(sefos)((sefos)->rest)) {
1323	cc += ostreamPrintf(ostream, " ");
1324	cc += sefoOStreamPrint0(ostream, false((int) 0), car(sefos)((sefos)->first));
1325	}
1326	cc += ostreamPrintf(ostream, " )");
1327
1328	return cc;
1329	}
1330
1331	/* The deep argument is currently unused. */
1332	localstatic int
1333	symeListOStreamPrint0(OStream ostream, Bool deep, SymeList symes)
1334	{
1335	int cc = 0;
1336
1337	cc += ostreamPrintf(ostream, " (");
1338	for (; symes; symes = cdr(symes)((symes)->rest)) {
1339	cc += ostreamPrintf(ostream, " ");
1340	cc += symeOStreamPrint0(ostream, false((int) 0), car(symes)((symes)->first));
1341	}
1342	cc += ostreamPrintf(ostream, " )");
1343
1344	return cc;
1345	}
1346
1347	/* The deep argument is currently unused. */
1348	localstatic int
1349	tformListOStreamPrint0(OStream ostream, Bool deep, TFormList tforms)
1350	{
1351	int cc = 0;
1352
1353	cc += ostreamPrintf(ostream, " (");
1354	for (; tforms; tforms = cdr(tforms)((tforms)->rest)) {
1355	cc += ostreamPrintf(ostream, " ");
1356	cc += tformOStreamPrint0(ostream, false((int) 0), car(tforms)((tforms)->first));
1357	}
1358	cc += ostreamPrintf(ostream, " )");
1359
1360	return cc;
1361	}
1362
1363	/*****************************************************************************
1364	*
1365	* :: symeIsTwin
1366	*
1367	****************************************************************************/
1368
1369	localstatic void symeMarkTwins (Syme);
1370	localstatic Bool symeFindTwins (Syme);
1371	localstatic void symeClearTwins (Syme);
1372
1373	Bool
1374	symeIsTwin(Syme syme1, Syme syme2)
1375	{
1376	Bool eq;
1377
1378	if (syme1 == syme2) return false((int) 0);
1379
1380	symeMarkTwins(syme2);
1381	eq = symeFindTwins(syme1);
1382	symeClearTwins(syme2);
1383
1384	return eq;
1385	}
1386
1387	localstatic void
1388	symeMarkTwins(Syme syme)
1389	{
1390	SymeList symes = symeTwins(syme);
1391
1392	symeSetMarkBit(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) \|= (0x0100));
1393	for (; symes; symes = cdr(symes)((symes)->rest)) {
1394	Syme twin = car(symes)((symes)->first);
1395	if (twin != syme) symeMarkTwins(twin);
1396	}
1397	}
1398
1399	void
1400	symeShowTwins(Syme syme)
1401	{
1402	SymeList symes = symeTwins(syme);
1403
1404	afprintf(dbOut, "%p -> %pPtrList\n", syme, symes);
1405	for (; symes; symes = cdr(symes)((symes)->rest)) {
1406	Syme twin = car(symes)((symes)->first);
1407	if (twin != syme) symeShowTwins(twin);
1408	}
1409	}
1410
1411	localstatic Bool
1412	symeFindTwins(Syme syme)
1413	{
1414	SymeList symes = symeTwins(syme);
1415	Bool result = false((int) 0);
1416
1417	result = symeMarkBit(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) & (0x0100));
1418	for (; !result && symes; symes = cdr(symes)((symes)->rest)) {
1419	Syme twin = car(symes)((symes)->first);
1420	if (twin != syme) result = symeFindTwins(twin);
1421	}
1422
1423	return result;
1424	}
1425
1426	localstatic void
1427	symeClearTwins(Syme syme)
1428	{
1429	SymeList symes = symeTwins(syme);
1430
1431	symeClrMarkBit(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) &= ~(0x0100));
1432	for (; symes; symes = cdr(symes)((symes)->rest)) {
1433	Syme twin = car(symes)((symes)->first);
1434	if (twin != syme) symeClearTwins(twin);
1435	}
1436	}
1437
1438	/*****************************************************************************
1439	*
1440	* :: sstEqual
1441	*
1442	****************************************************************************/
1443
1444	/*
1445	* sstEqual external entry points.
1446	*/
1447
1448	Bool
1449	sefoEqual(Sefo sefo1, Sefo sefo2)
1450	{
1451	Bool eq;
1452
1453	sstNext("sefoEqual", sefo1, sefo2){ if (sstDebug) { sstNextDB("sefoEqual", (Pointer)(sefo1), (Pointer )(sefo2)); } sstNext0(); };
1454	eq = sefoEqual0(NULL((void*)0), sefo1, sefo2);
1455	sstDoneSefo(sefo1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1456
1457	if (eq && !sefoIsDefinedType(sefo1) && !sefoIsDefinedType(sefo2))
1458	assert(abHashSefo(sefo1) == abHashSefo(sefo2))do { if (!(abHashSefo(sefo1) == abHashSefo(sefo2))) _do_assert (("abHashSefo(sefo1) == abHashSefo(sefo2)"),"sefo.c",1458); } while (0);
1459
1460	return eq;
1461	}
1462
1463	Bool
1464	symeEqual(Syme syme1, Syme syme2)
1465	{
1466	Bool eq;
1467
1468	sstNext("symeEqual", syme1, syme2){ if (sstDebug) { sstNextDB("symeEqual", (Pointer)(syme1), (Pointer )(syme2)); } sstNext0(); };
1469	eq = symeEqual0(NULL((void*)0), syme1, syme2);
1470	sstDoneSyme(syme1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1471
1472	return eq;
1473	}
1474
1475	Bool
1476	tformEqual(TForm tf1, TForm tf2)
1477	{
1478	Bool eq;
1479
1480	sstNext("tformEqual", tf1, tf2){ if (sstDebug) { sstNextDB("tformEqual", (Pointer)(tf1), (Pointer )(tf2)); } sstNext0(); };
1481	eq = tformEqual0(NULL((void*)0), tf1, tf2);
1482	sstDoneTForm(tf1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1483
1484	return eq;
1485	}
1486
1487	Bool
1488	sefoListEqual(SefoList sefos1, SefoList sefos2)
1489	{
1490	Bool eq;
1491
1492	sstNext("sefoListEqual", sefos1, sefos2){ if (sstDebug) { sstNextDB("sefoListEqual", (Pointer)(sefos1 ), (Pointer)(sefos2)); } sstNext0(); };
1493	eq = sefoListEqual0(NULL((void*)0), sefos1, sefos2);
1494	sstDoneSefoList(sefos1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1495
1496	return eq;
1497	}
1498
1499	Bool
1500	symeListEqual(SymeList symes1, SymeList symes2)
1501	{
1502	Bool eq;
1503
1504	sstNext("symeListEqual", symes1, symes2){ if (sstDebug) { sstNextDB("symeListEqual", (Pointer)(symes1 ), (Pointer)(symes2)); } sstNext0(); };
1505	eq = symeListEqual0(NULL((void*)0), symes1, symes2);
1506	sstDoneSymeList(symes1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1507
1508	return eq;
1509	}
1510
1511	Bool
1512	tformListEqual(TFormList tforms1, TFormList tforms2)
1513	{
1514	Bool eq;
1515
1516	sstNext("tformListEqual", tforms1, tforms2){ if (sstDebug) { sstNextDB("tformListEqual", (Pointer)(tforms1 ), (Pointer)(tforms2)); } sstNext0(); };
1517	eq = tformListEqual0(NULL((void*)0), tforms1, tforms2);
1518	sstDoneTFormList(tforms1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1519
1520	return eq;
1521	}
1522
1523	/*
1524	* sstEqualMod external entry points.
1525	*/
1526
1527	Bool
1528	sefoEqualMod(SymeList mods, Sefo sefo1, Sefo sefo2)
1529	{
1530	Bool eq;
1531
1532	sstNext("sefoEqualMod", sefo1, sefo2){ if (sstDebug) { sstNextDB("sefoEqualMod", (Pointer)(sefo1), (Pointer)(sefo2)); } sstNext0(); };
1533	eq = sefoEqual0(mods, sefo1, sefo2);
1534	sstDoneSefo(sefo1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1535
1536	return eq;
1537	}
1538
1539	Bool
1540	symeEqualMod(SymeList mods, Syme syme1, Syme syme2)
1541	{
1542	Bool eq;
1543
1544	sstNext("symeEqualMod", syme1, syme2){ if (sstDebug) { sstNextDB("symeEqualMod", (Pointer)(syme1), (Pointer)(syme2)); } sstNext0(); };
1545	eq = symeEqual0(mods, syme1, syme2);
1546	sstDoneSyme(syme1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1547
1548	return eq;
1549	}
1550
1551	Bool
1552	tformEqualMod(SymeList mods, TForm tf1, TForm tf2)
1553	{
1554	Bool eq;
1555
1556	sstNext("tformEqualMod", tf1, tf2){ if (sstDebug) { sstNextDB("tformEqualMod", (Pointer)(tf1), ( Pointer)(tf2)); } sstNext0(); };
1557	eq = tformEqual0(mods, tf1, tf2);
1558	sstDoneTForm(tf1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1559
1560	return eq;
1561	}
1562
1563	Bool
1564	sefoListEqualMod(SymeList mods, SefoList sefos1, SefoList sefos2)
1565	{
1566	Bool eq;
1567
1568	sstNext("sefoListEqualMod", sefos1, sefos2){ if (sstDebug) { sstNextDB("sefoListEqualMod", (Pointer)(sefos1 ), (Pointer)(sefos2)); } sstNext0(); };
1569	eq = sefoListEqual0(mods, sefos1, sefos2);
1570	sstDoneSefoList(sefos1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1571
1572	return eq;
1573	}
1574
1575	Bool
1576	symeListEqualMod(SymeList mods, SymeList symes1, SymeList symes2)
1577	{
1578	Bool eq;
1579
1580	sstNext("symeListEqualMod", symes1, symes2){ if (sstDebug) { sstNextDB("symeListEqualMod", (Pointer)(symes1 ), (Pointer)(symes2)); } sstNext0(); };
1581	eq = symeListEqual0(mods, symes1, symes2);
1582	sstDoneSymeList(symes1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1583
1584	return eq;
1585	}
1586
1587	Bool
1588	tformListEqualMod(SymeList mods, TFormList tforms1, TFormList tforms2)
1589	{
1590	Bool eq;
1591
1592	sstNext("tformListEqualMod", tforms1, tforms2){ if (sstDebug) { sstNextDB("tformListEqualMod", (Pointer)(tforms1 ), (Pointer)(tforms2)); } sstNext0(); };
1593	eq = tformListEqual0(mods, tforms1, tforms2);
1594	sstDoneTFormList(tforms1){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
1595
1596	return eq;
1597	}
1598
1599	Bool
1600	symeEqualModConditions(SymeList mods, Syme syme1, Syme syme2)
1601	{
1602	Bool eq;
1603
1604	symeSetPopConds(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void*)0)), (syme1))->bits) \|= (0x0400));
1605	symeSetPopConds(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void*)0)), (syme2))->bits) \|= (0x0400));
1606	eq = symeEqualMod(mods, syme1, syme2);
1607	symeClrPopConds(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void*)0)), (syme2))->bits) &= ~(0x0400));
1608	symeClrPopConds(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void*)0)), (syme1))->bits) &= ~(0x0400));
1609
1610	return eq;
1611	}
1612
1613	/*
1614	* Local functions.
1615	*/
1616
1617	#define symeModsAllowAlpha(mods)((mods) && ((mods)->rest) && !(((((mods)-> first))->id) == ssymSelf) && ((((mods)->first)) ->id) != ((((((mods)->rest))->first))->id)) \
1618	((mods) && cdr(mods)((mods)->rest) && !symeIsSelf(car(mods))(((((mods)->first))->id) == ssymSelf) && \
1619	symeId(car(mods))((((mods)->first))->id) != symeId(car(cdr(mods)))((((((mods)->rest))->first))->id))
1620
1621	localstatic Bool
1622	sefoIsDefinedType(Sefo sefo)
1623	{
1624	TForm cat = abGetCategory(sefo);
1625	return tfIsDefineOfType(cat);
1626	}
1627
1628	localstatic Sefo
1629	sefoDefinedVal(Sefo sefo)
1630	{
1631	TForm cat = abGetCategory(sefo);
1632	return tfExpr(tfDefineVal(cat))tfToAbSyn(tfFollowArg(cat, 1));
1633	}
1634
1635	localstatic Bool
1636	sefoEqual0(SymeList mods, Sefo sefo1, Sefo sefo2)
1637	{
1638	Bool result = true1;
1639	Length serial = 0;
1640
1641	sstSerialDebug += 1;
1642	serial = sstSerialDebug;
1643
1644	sefo1 = sefoEqualMods(sefo1);
1645	sefo2 = sefoEqualMods(sefo2);
1646
1647	if (DEBUG(sefoEqual)sefoEqualDebug) {
1648	fprintf(dbOut, "-> sefoEqual[%d]:", (int) serial);
1649	fnewline(dbOut);
1650	sefoPrintDb(sefo1);
1651	sefoPrintDb(sefo2);
1652	}
1653
1654	if (sefo1 == sefo2)
1655	result = true1;
1656
1657	else if (!sefo1 \|\| !sefo2)
1658	result = false((int) 0);
1659
1660	else if (abTag(sefo1)((sefo1)->abHdr.tag) != abTag(sefo2)((sefo2)->abHdr.tag))
1661	result = false((int) 0);
1662
1663	else if (abArgc(sefo1)((sefo1)->abHdr.argc) != abArgc(sefo2)((sefo2)->abHdr.argc))
1664	result = false((int) 0);
1665
1666	else if (abIsId(sefo1)((sefo1)->abHdr.tag == (AB_Id)))
1667	result = symeEqual0(mods, abSyme(sefo1)((sefo1)->abHdr.seman ? (sefo1)->abHdr.seman->syme : 0), abSyme(sefo2)((sefo2)->abHdr.seman ? (sefo2)->abHdr.seman->syme : 0));
1668
1669	else if (abIsLeaf(sefo1)(((sefo1)->abHdr.tag) < AB_NODE_START))
1670	result = abEqual(sefo1, sefo2) &&
1671	symeEqual0(mods, abSyme(sefo1)((sefo1)->abHdr.seman ? (sefo1)->abHdr.seman->syme : 0), abSyme(sefo2)((sefo2)->abHdr.seman ? (sefo2)->abHdr.seman->syme : 0));
1672
1673	else {
1674	Length i;
1675	for (i = 0; result && i < abArgc(sefo1)((sefo1)->abHdr.argc); i += 1)
1676	result = sefoEqual0(mods, abArgv(sefo1)((sefo1)->abGen.data.argv)[i],
1677	abArgv(sefo2)((sefo2)->abGen.data.argv)[i]);
1678	}
1679
1680	if (!result) {
1681	if (sefoIsDefinedType(sefo1))
1682	result = sefoEqual0(mods, sefoDefinedVal(sefo1), sefo2);
1683
1684	else if (sefoIsDefinedType(sefo2))
1685	result = sefoEqual0(mods, sefo1, sefoDefinedVal(sefo2));
1686	}
1687
1688	if (DEBUG(sefoEqual)sefoEqualDebug) {
1689	fprintf(dbOut, "<- sefoEqual[%d] = %s",
1690	(int) serial, boolToString(result)((result) ? "true" : "false"));
1691	fnewline(dbOut);
1692	}
1693
1694	return result;
1695	}
1696
1697	localstatic AbEqualValue
1698	sefoIdEqual(void *ctxt, Sefo sefo1, Sefo sefo2)
1699	{
1700	int serial;
1701	Bool result;
1702	sstSerialDebug += 1;
1703	serial = sstSerialDebug;
1704	// This is for %% type comparison.. We can't use tfEqual as
1705	// that works via the parent exports.. Instead, compare ids
1706	// only if they are lexical variables
1707
1708	if (abTag(sefo1)((sefo1)->abHdr.tag) != abTag(sefo2)((sefo2)->abHdr.tag)) {
1709	return AbEqual_Struct;
1710	}
1711	else if (abTag(sefo1)((sefo1)->abHdr.tag) != AB_Id) {
1712	return AbEqual_Struct;
1713	}
1714	else {
1715	sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf(dbOut, "(weak[%d]: %pAbSyn %pAbSyn\n",
1716	(int) serial, sefo1, sefo2);
1717	if (symeIsSelf(abSyme(sefo1))(((((sefo1)->abHdr.seman ? (sefo1)->abHdr.seman->syme : 0))->id) == ssymSelf) && symeIsSelf(abSyme(sefo2))(((((sefo2)->abHdr.seman ? (sefo2)->abHdr.seman->syme : 0))->id) == ssymSelf)) {
1718	result = symeEqual0((SymeList) ctxt, abSyme(sefo1)((sefo1)->abHdr.seman ? (sefo1)->abHdr.seman->syme : 0), abSyme(sefo2)((sefo2)->abHdr.seman ? (sefo2)->abHdr.seman->syme : 0));
1719	}
1720	else {
1721	result = abEqual(sefo1, sefo2);
1722	}
1723
1724	sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf(dbOut, " weak[%d]: %pAbSyn %pAbSyn --> %d)\n",
1725	(int) serial, sefo1, sefo2, result);
1726	}
1727	return result ? AbEqual_True: AbEqual_False;
1728	}
1729
1730	localstatic Bool
1731	symeEqual0(SymeList mods, Syme syme1, Syme syme2)
1732	{
1733	Bool result = true1;
1734	Length serial = 0;
1735
1736	sstSerialDebug += 1;
1737	serial = sstSerialDebug;
1738
1739	if (syme1 == syme2)
1740	return true1;
1741
1742	else if (!syme1 \|\| !syme2)
1743	return false((int) 0);
1744
1745	sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf(dbOut, "(symeEqual[%d]: %pSyme %pSyme\n",
1746	(int) serial, syme1, syme2);
1747
1748	if (symeIsArchive(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void)0)), (syme1))->kind) == SYME_Archive) && symeIsLibrary(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void)0)), (syme2))->kind) == SYME_Library))
1749	result = arLibraryIsMember(symeArchive(syme1)((Archive) (SYFI_Archive < (8 * sizeof(int)) && !( ((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->hasmask) & (1 << ( SYFI_Archive))) ? (symeFieldInfo[SYFI_Archive].def) : (((((syme1 )->kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void)0)), (syme1))->locmask) & (1 << (SYFI_Archive ))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes( (syme1)->lib) : ((void*)0)), (syme1))->locmask) & ( 1 << (SYFI_Archive))) ? ((syme1)->fieldv)[symeIndex( syme1,SYFI_Archive)] : (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn (syme1,SYFI_Archive))),
1750	symeLibrary(syme2)((Lib) (SYFI_Library < (8 * sizeof(int)) && !((((( syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->hasmask) & (1 << ( SYFI_Library))) ? (symeFieldInfo[SYFI_Library].def) : (((((syme2 )->kind == SYME_Trigger ? libGetAllSymes((syme2)->lib) : ((void)0)), (syme2))->locmask) & (1 << (SYFI_Library ))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes( (syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Library))) ? ((syme2)->fieldv)[symeIndex( syme2,SYFI_Library)] : (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn (syme2,SYFI_Library))));
1751
1752	else if (symeIsArchive(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void)0)), (syme2))->kind) == SYME_Archive) && symeIsLibrary(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void)0)), (syme1))->kind) == SYME_Library))
1753	result = arLibraryIsMember(symeArchive(syme2)((Archive) (SYFI_Archive < (8 * sizeof(int)) && !( ((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->hasmask) & (1 << ( SYFI_Archive))) ? (symeFieldInfo[SYFI_Archive].def) : (((((syme2 )->kind == SYME_Trigger ? libGetAllSymes((syme2)->lib) : ((void)0)), (syme2))->locmask) & (1 << (SYFI_Archive ))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes( (syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Archive))) ? ((syme2)->fieldv)[symeIndex( syme2,SYFI_Archive)] : (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn (syme2,SYFI_Archive))),
1754	symeLibrary(syme1)((Lib) (SYFI_Library < (8 * sizeof(int)) && !((((( syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->hasmask) & (1 << ( SYFI_Library))) ? (symeFieldInfo[SYFI_Library].def) : (((((syme1 )->kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void)0)), (syme1))->locmask) & (1 << (SYFI_Library ))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes( (syme1)->lib) : ((void*)0)), (syme1))->locmask) & ( 1 << (SYFI_Library))) ? ((syme1)->fieldv)[symeIndex( syme1,SYFI_Library)] : (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn (syme1,SYFI_Library))));
1755
1756	else if (symeId(syme1)((syme1)->id) != symeId(syme2)((syme2)->id)) {
1757	if (symeModsAllowAlpha(mods)((mods) && ((mods)->rest) && !(((((mods)-> first))->id) == ssymSelf) && ((((mods)->first)) ->id) != ((((((mods)->rest))->first))->id)))
1758	result = listMember(Syme)(Syme_listPointer->Member)(mods, syme1, symeEq) &&
1759	listMember(Syme)(Syme_listPointer->Member)(mods, syme2, symeEq);
1760	else
1761	result = false((int) 0);
1762	}
1763
1764	else if (sstSymeIsMarked(syme1)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void)0)), (syme1))-> locmask) & (1 << (SYFI_Mark))) ? ((syme1)->fieldv )[symeIndex(syme1,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def ))) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme1), ((void)0))))
1765	result = true1;
1766
1767	else if (symeExtendEqual0(mods, syme1, syme2))
1768	result = true1;
1769
1770	else if (listMember(Syme)(Syme_listPointer->Member)(mods, syme1, symeEq) &&
1771	listMember(Syme)(Syme_listPointer->Member)(mods, syme2, symeEq))
1772	result = true1;
1773
1774	else if (symeIsSelf(syme1)(((syme1)->id) == ssymSelf))
1775	result = false((int) 0);
1776
1777	else if (symeIsSelfSelf(syme1)(((syme1)->id) == ssymSelfSelf)) {
1778	TForm tf1;
1779	TForm tf2;
1780
1781	if (symeHash(syme1)((syme1)->hash) && symeHash(syme2)((syme2)->hash) &&
1782	symeHash(syme1)((syme1)->hash) != symeHash(syme2)((syme2)->hash))
1783	result = false((int) 0);
1784	else {
1785	tf1 = symeType(syme1);
1786	tf2 = symeType(syme2);
1787
1788	tfFollow(tf1)((tf1) = tfFollowFn(tf1));
1789	tfFollow(tf2)((tf2) = tfFollowFn(tf2));
1790
1791	assert (tfIsGeneral(tf1) && tfIsGeneral(tf2))do { if (!((((tf1)->tag) == TF_General) && (((tf2) ->tag) == TF_General))) _do_assert(("tfIsGeneral(tf1) && tfIsGeneral(tf2)" ),"sefo.c",1791); } while (0);
1792	sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf(dbOut, " symeEqual[%d] - selfSelf case %pTForm %pTForm\n",
1793	(int) serial, tf1, tf2);
1794	result = (sefoListEqual0(mods, symeCondition(syme1),
1795	symeCondition(syme2)) &&
1796	abCompareModDeclares(sefoIdEqual, mods, tfGetExpr(tf1)((tf1)->__absyn), tfGetExpr(tf2)((tf2)->__absyn)));
1797	}
1798	}
1799
1800	else if (symeIsTwin(syme1, syme2)) {
1801	if (symeIsImport(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void)0)), (syme1))->kind) == SYME_Import) && symeIsImport(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void)0)), (syme2))->kind) == SYME_Import))
1802	result = symeOriginEqual0(mods, syme1, syme2);
1803	else
1804	result = true1;
1805	}
1806
1807	else {
1808	sstMarkSyme(syme1);
1809	result = (symeOriginEqual0(mods, syme1, syme2) &&
1810	sefoListEqual0(mods, symeCondition(syme1),
1811	symeCondition(syme2)) &&
1812	symeTypeEqual0(mods, syme1, syme2));
1813	}
1814
1815	sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf(dbOut, " symeEqual[%d] = %s)\n",
1816	(int) serial, boolToString(result)((result) ? "true" : "false"));
1817
1818	return result;
1819	}
1820
1821
1822	localstatic Bool tformStructSimilar(TForm tf1, TForm tf2);
1823
1824	localstatic Bool
1825	tformEqual0(SymeList mods, TForm tf1, TForm tf2)
1826	{
1827	Bool result = true1;
1828	Length serial = 0;
1829	#if CheckSimilar
1830	Bool similar = true1;
1831	#endif
1832	tf1 = tfFollowOnly(tf1);
1833	tf2 = tfFollowOnly(tf2);
1834
1835
1836	if (tf1 == tf2) return true1;
1837
1838	/* Only use tfFollow if exactly one of the types is lazy. */
1839	if (tfIsSubst(tf1)(((tf1)->tag) == TF_Subst) != tfIsSubst(tf2)(((tf2)->tag) == TF_Subst)) {
1840	if (!tformStructSimilar(tf1, tf2)) {
1841	#if CheckSimilar
1842	fprintf(dbOut, "(Similar test failed:\n");
1843	tfPrintDb(tf1);
1844	tfPrintDb(tf2);
1845	fprintf(dbOut, ")\n");
1846	similar = false((int) 0);
1847	#else
1848	return false((int) 0);
1849	#endif
1850	}
1851	tfFollow(tf1)((tf1) = tfFollowFn(tf1));
1852	tfFollow(tf2)((tf2) = tfFollowFn(tf2));
1853	}
1854
1855	/* If we can determine equality w/o using tfFollow, do so. */
1856	if (tfIsSubst(tf1)(((tf1)->tag) == TF_Subst) \|\| tfIsSubst(tf2)(((tf2)->tag) == TF_Subst)) {
1857	assert(tfIsSubst(tf1) && tfIsSubst(tf2))do { if (!((((tf1)->tag) == TF_Subst) && (((tf2)-> tag) == TF_Subst))) _do_assert(("tfIsSubst(tf1) && tfIsSubst(tf2)" ),"sefo.c",1857); } while (0);
1858	if (tfSubstSigma(tf1)((tf1)->sigma) == tfSubstSigma(tf2)((tf2)->sigma) &&
1859	tformEqual0(mods, tfSubstArg(tf1)tfFollowArg(tf1, 0), tfSubstArg(tf2)tfFollowArg(tf2, 0)))
1860	return true1;
1861	tfFollow(tf1)((tf1) = tfFollowFn(tf1));
1862	tfFollow(tf2)((tf2) = tfFollowFn(tf2));
1863	}
1864
1865	/* Only use tfDefineeType if both types are fully analyzed. */
1866	if (!tfIsSyntax(tf1)(((tf1)->tag) == TF_Syntax) && !tfIsSyntax(tf2)(((tf2)->tag) == TF_Syntax)) {
1867	tf1 = tfDefineeType(tf1);
1868	tf2 = tfDefineeType(tf2);
1869	}
1870
1871	/* The tfDefineeType of a type might also be a syntax type. */
1872	if (tfIsSyntax(tf1)(((tf1)->tag) == TF_Syntax) \|\| tfIsSyntax(tf2)(((tf2)->tag) == TF_Syntax))
1873	return abEqualModDeclares(tfExpr(tf1)tfToAbSyn(tf1), tfExpr(tf2)tfToAbSyn(tf2));
1874
1875	sstSerialDebug += 1;
1876	serial = sstSerialDebug;
1877
1878	if (DEBUG(sefoEqual)sefoEqualDebug) {
1879	fprintf(dbOut, "-> tformEqual[%d]:", (int) serial);
1880	fnewline(dbOut);
1881	tformPrintDb(tf1);
1882	tformPrintDb(tf2);
1883	}
1884
1885	if (tf1 == tf2)
1886	result = true1;
1887
1888	else if ((tfIsLibrary(tf1) \|\| tfIsArchive(tf1)) &&
1889	(tfIsLibrary(tf2) \|\| tfIsArchive(tf2)))
1890	result = true1;
1891
1892	else if ((tfTag(tf1)((tf1)->tag) != tfTag(tf2)((tf2)->tag)) \|\| (tfArgc(tf1)((tf1)->argc) != tfArgc(tf2)((tf2)->argc)))
1893	result = false((int) 0);
1894
1895	else if (tfIsSym(tf1)( (((tf1)->tag)) < TF_SYM_LIMIT))
1896	result = true1;
1897
1898	else if (tfTag(tf1)((tf1)->tag) == TF_General)
1899	result = sefoEqual0(mods, tfGetExpr(tf1)((tf1)->__absyn), tfGetExpr(tf2)((tf2)->__absyn));
1900
1901	else if (tfIsRecord(tf1)(((tf1)->tag) == TF_Record) \|\| tfIsRawRecord(tf1)(((tf1)->tag) == TF_RawRecord) \|\|
1902	tfIsUnion(tf1)(((tf1)->tag) == TF_Union) \|\| tfIsEnum(tf1)(((tf1)->tag) == TF_Enumerate)) {
1903	Length i;
1904	for (i = 0; result && i < tfArgc(tf1)((tf1)->argc); i += 1) {
1905	Symbol sym1 = tfCompoundId(tf1, i);
1906	Symbol sym2 = tfCompoundId(tf2, i);
1907	if (!sym1 \|\| !sym2 \|\| sym1 == sym2)
1908	result = tformEqual0(mods, tfArgv(tf1)((tf1)->argv)[i],
1909	tfArgv(tf2)((tf2)->argv)[i]);
1910	else
1911	result = false((int) 0);
1912	}
1913	}
1914	/* ??? Do we need to special-case TrailingArray */
1915	else if (tfIsNode(tf1)( TF_NODE_START <= (((tf1)->tag)) && (((tf1)-> tag)) < TF_NODE_LIMIT)) {
1916	Length i;
1917	for (i = 0; result && i < tfArgc(tf1)((tf1)->argc); i += 1)
1918	result = tformEqual0(mods, tfArgv(tf1)((tf1)->argv)[i],
1919	tfArgv(tf2)((tf2)->argv)[i]);
1920	}
1921	else
1922	bugBadCase(tfTag(tf1))bug("Bad case %d (line %d in file %s).", (int) ((tf1)->tag ), 1922, "sefo.c");
1923
1924	if (result && tfIsWith(tf1)(((tf1)->tag) == TF_With) &&
1925	(tfUseCatExports(tf1)(((((tfFollowArg(tf1, 0))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg(tf1, 0)) == 0) && ((((tfFollowArg (tf1, 1))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg (tf1, 1)) == 0)) \|\| tfUseCatExports(tf2)(((((tfFollowArg(tf2, 0))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg(tf2, 0)) == 0) && ((((tfFollowArg (tf2, 1))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg (tf2, 1)) == 0))))
1926	result = symeListEqual0(mods, tfParents(tf1)((tf1)->parents),
1927	tfParents(tf2)((tf2)->parents));
1928
1929	if (result && tfIsThird(tf1)(((tf1)->tag) == TF_Third) &&
1930	(tfUseThdExports(tf1)(((((tfFollowArg(tf1, 0))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg(tf1, 0)) == 0)) \|\| tfUseThdExports(tf2)(((((tfFollowArg(tf2, 0))->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg(tf2, 0)) == 0))))
1931	result = symeListEqual0(mods, tfGetThdExports(tf1),
1932	tfGetThdExports(tf2));
1933
1934	if (result && tformEqualCheckSymes(tf1) && tformEqualCheckSymes(tf2))
1935	result = symeListEqual0(mods, tfSymes(tf1)((tf1)->symes), tfSymes(tf2)((tf2)->symes));
1936
1937	if (!result) {
1938	if (tfIsDefinedType(tf1))
1939	result = tformEqual0(mods, tfDefinedVal(tf1), tf2);
1940
1941	else if (tfIsDefinedType(tf2))
1942	result = tformEqual0(mods, tf1, tfDefinedVal(tf2));
1943	}
1944
1945	if (DEBUG(sefoEqual)sefoEqualDebug) {
1946	fprintf(dbOut, "<- tformEqual[%d] = %s",
1947	(int) serial, boolToString(result)((result) ? "true" : "false"));
1948	fnewline(dbOut);
1949	}
1950	#if CheckSimilar
1951	if (result && !similar)
1952	bug("tformEqual, dissimilar, but the same!");
1953	#endif
1954	return result;
1955	}
1956
1957	localstatic Bool
1958	tformStructSimilar(TForm tf1, TForm tf2)
1959	{
1960	int i;
1961	/* We use the fact that only absyn can be replaced
1962	* by substitution
1963	*/
1964	tf1 = tfFollowSubst(tf1);
1965	tf2 = tfFollowSubst(tf2);
1966
1967	if (tfIsDeclare(tf1)(((tf1)->tag) == TF_Declare))
1968	tf1 = tfDeclareType(tf1)tfFollowArg(tf1, 0);
1969	if (tfIsDeclare(tf2)(((tf2)->tag) == TF_Declare))
1970	tf2 = tfDeclareType(tf2)tfFollowArg(tf2, 0);
1971
1972	/* These may change into something real */
1973	if (tfIsGeneral(tf1)(((tf1)->tag) == TF_General) \|\| tfIsGeneral(tf2)(((tf2)->tag) == TF_General))
1974	return true1;
1975
1976	if (tfIsSyntax(tf1)(((tf1)->tag) == TF_Syntax) \|\| tfIsSyntax(tf2)(((tf2)->tag) == TF_Syntax))
1977	return true1;
1978	/* TF_Define is downright bizzare, and can be whatever it
1979	* feels like.
1980	*/
1981	if (tfIsDefine(tf1)(((tf1)->tag) == TF_Define) \|\| tfIsDefine(tf2)(((tf2)->tag) == TF_Define))
1982	return true1;
1983
1984	if (tfTag(tf1)((tf1)->tag) != tfTag(tf2)((tf2)->tag))
1985	return false((int) 0);
1986	if (tfArgc(tf1)((tf1)->argc) != tfArgc(tf2)((tf2)->argc))
1987	return false((int) 0);
1988
1989	for (i=0; i<tfArgc(tf1)((tf1)->argc); i++)
1990	if (!tformStructSimilar(tfArgv(tf1)((tf1)->argv)[i], tfArgv(tf2)((tf2)->argv)[i]))
1991	return false((int) 0);
1992
1993	return true1;
1994	}
1995
1996	localstatic Bool
1997	sefoListEqual0(SymeList mods, SefoList sefos1, SefoList sefos2)
1998	{
1999	/* Quick check for empty and identical lists. */
2000	if (sefos1 == sefos2)
2001	return true1;
2002
2003	if (listLength(Sefo)(Sefo_listPointer->_Length)(sefos1) != listLength(Sefo)(Sefo_listPointer->_Length)(sefos2))
2004	return false((int) 0);
2005
2006	for (; sefos1 && sefos2; sefos1 = cdr(sefos1)((sefos1)->rest), sefos2 = cdr(sefos2)((sefos2)->rest))
2007	if (!sefoEqual0(mods, car(sefos1)((sefos1)->first), car(sefos2)((sefos2)->first)))
2008	return false((int) 0);
2009
2010	return true1;
2011	}
2012
2013	localstatic Bool
2014	symeListEqual0(SymeList mods, SymeList symes1, SymeList symes2)
2015	{
2016	/* Quick check for empty and identical lists. */
2017	if (symes1 == symes2)
2018	return true1;
2019
2020	if (listLength(Syme)(Syme_listPointer->_Length)(symes1) != listLength(Syme)(Syme_listPointer->_Length)(symes2))
2021	return false((int) 0);
2022
2023	for (; symes1 && symes2; symes1 = cdr(symes1)((symes1)->rest), symes2 = cdr(symes2)((symes2)->rest))
2024	if (!symeEqual0(mods, car(symes1)((symes1)->first), car(symes2)((symes2)->first)))
2025	return false((int) 0);
2026
2027	return true1;
2028	}
2029
2030	localstatic Bool
2031	tformListEqual0(SymeList mods, TFormList tl1, TFormList tl2)
2032	{
2033	/* Quick check for empty and identical lists. */
2034	if (tl1 == tl2)
2035	return true1;
2036
2037	if (listLength(TForm)(TForm_listPointer->_Length)(tl1) != listLength(TForm)(TForm_listPointer->_Length)(tl2))
2038	return false((int) 0);
2039
2040	for (; tl1 && tl2; tl1 = cdr(tl1)((tl1)->rest), tl2 = cdr(tl2)((tl2)->rest))
2041	if (!tformEqual0(mods, car(tl1)((tl1)->first), car(tl2)((tl2)->first)))
2042	return false((int) 0);
2043
2044	return true1;
2045	}
2046
2047	localstatic Bool
2048	symeTypeEqual0(SymeList mods, Syme syme1, Syme syme2)
2049	{
2050	if ((symeIsLazy(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void)0)), (syme1))->bits) & (0x0001)) && symeIsImport(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void)0)), (syme1))->kind) == SYME_Import)) \|\|
2051	(symeIsLazy(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void)0)), (syme2))->bits) & (0x0001)) && symeIsImport(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void)0)), (syme2))->kind) == SYME_Import)))
2052	return symeTypeCode(syme1) == symeTypeCode(syme2);
2053	else if (tfIsTrigger(syme1->type)(((syme1->type)->tag) == TF_Trigger) \|\| tfIsTrigger(syme2->type)(((syme2->type)->tag) == TF_Trigger))
2054	return symeTypeCode(syme1) == symeTypeCode(syme2);
2055	else
2056	return tformEqual0(mods, symeType(syme1), symeType(syme2));
2057	}
2058
2059	localstatic Bool
2060	symeExtendEqual0(SymeList mods, Syme syme1, Syme syme2)
2061	{
2062	Syme syme, ext, e1, e2;
2063	SymeList symes;
2064
2065	/* Check the extension, if any. */
2066
2067	e1 = symeExtensionFirst(syme1);
2068	e2 = symeExtensionFirst(syme2);
2069
2070	if (e1 \|\| e2) {
2071	Bool result;
2072	Syme s1, s2;
2073
2074	symeSetExtension(syme1, NULL)symeXSetExtension(syme1, (AInt) ((void*)0));
2075	symeSetExtension(syme2, NULL)symeXSetExtension(syme2, (AInt) ((void*)0));
2076
2077	s1 = e1 ? e1 : syme1;
2078	s2 = e2 ? e2 : syme2;
2079	result = symeEqual0(mods, s1, s2);
2080
2081	symeSetExtension(syme1, e1)symeXSetExtension(syme1, (AInt) e1);
2082	symeSetExtension(syme2, e2)symeXSetExtension(syme2, (AInt) e2);
2083
2084	return result;
2085	}
2086
2087	/* Check the extendees, if any. */
2088
2089	if (symeIsImport(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void)0)), (syme1))->kind) == SYME_Import) && symeIsImport(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void)0)), (syme2))->kind) == SYME_Import))
2090	return false((int) 0);
2091
2092	if (symeIsImportOfExtend(syme1)((((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1 )->lib) : ((void)0)), (syme1))->kind) == SYME_Import) && (((((symeOriginal(syme1))->kind == SYME_Trigger ? libGetAllSymes ((symeOriginal(syme1))->lib) : ((void)0)), (symeOriginal( syme1)))->kind) == SYME_Extend))) syme1 = symeOriginal(syme1);
2093	if (symeIsImportOfExtend(syme2)((((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2 )->lib) : ((void)0)), (syme2))->kind) == SYME_Import) && (((((symeOriginal(syme2))->kind == SYME_Trigger ? libGetAllSymes ((symeOriginal(syme2))->lib) : ((void)0)), (symeOriginal( syme2)))->kind) == SYME_Extend))) syme2 = symeOriginal(syme2);
2094
2095	if (symeIsExtend(syme1)(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1) ->lib) : ((void*)0)), (syme1))->kind) == SYME_Extend)) {
2096	ext = syme1;
2097	syme = syme2;
2098	}
2099	else if (symeIsExtend(syme2)(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2) ->lib) : ((void*)0)), (syme2))->kind) == SYME_Extend)) {
2100	ext = syme2;
2101	syme = syme1;
2102	}
2103	else
2104	return false((int) 0);
2105
2106	for (symes = symeExtendee(ext); symes; symes = cdr(symes)((symes)->rest))
2107	if (symeEqual0(mods, car(symes)((symes)->first), syme))
2108	return true1;
2109
2110	return false((int) 0);
2111	}
2112
2113	localstatic Bool
2114	symeOriginEqual0(SymeList mods, Syme syme1, Syme syme2)
2115	{
2116	Bool result = true1;
2117	Length serial = 0;
2118
2119	sstSerialDebug += 1;
2120	serial = sstSerialDebug;
2121
2122	if (DEBUG(sefoEqual)sefoEqualDebug) {
2123	fprintf(dbOut, "-> symeOriginEqual[%d]:", (int) serial);
2124	fnewline(dbOut);
2125	symePrintDb(syme1);
2126	symePrintDb(syme2);
2127	}
2128
2129	if (symeKind(syme1)((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->kind) != symeKind(syme2)((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->kind))
2130	result = false((int) 0);
2131
2132	else if (symeOrigin(syme1)((Pointer) (SYFI_Origin < (8 * sizeof(int)) && !(( (((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->hasmask) & (1 << ( SYFI_Origin))) ? (symeFieldInfo[SYFI_Origin].def) : (((((syme1 )->kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void)0)), (syme1))->locmask) & (1 << (SYFI_Origin ))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes( (syme1)->lib) : ((void)0)), (syme1))->locmask) & ( 1 << (SYFI_Origin))) ? ((syme1)->fieldv)[symeIndex(syme1 ,SYFI_Origin)] : (symeFieldInfo[SYFI_Origin].def)) : symeGetFieldFn (syme1,SYFI_Origin))) == symeOrigin(syme2)((Pointer) (SYFI_Origin < (8 sizeof(int)) && !(( (((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->hasmask) & (1 << ( SYFI_Origin))) ? (symeFieldInfo[SYFI_Origin].def) : (((((syme2 )->kind == SYME_Trigger ? libGetAllSymes((syme2)->lib) : ((void)0)), (syme2))->locmask) & (1 << (SYFI_Origin ))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes( (syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Origin))) ? ((syme2)->fieldv)[symeIndex(syme2 ,SYFI_Origin)] : (symeFieldInfo[SYFI_Origin].def)) : symeGetFieldFn (syme2,SYFI_Origin))))
2133	result = true1;
2134
2135	else switch (symeKind(syme1)((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void*)0)), (syme1))->kind)) {
2136	case SYME_Builtin:
2137	result = (symeBuiltin(syme1)((FoamBValTag) (SYFI_Builtin < (8 * sizeof(int)) && !(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1 )->lib) : ((void)0)), (syme1))->hasmask) & (1 << (SYFI_Builtin))) ? (symeFieldInfo[SYFI_Builtin].def) : ((((( syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->locmask) & (1 << ( SYFI_Builtin))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes ((syme1)->lib) : ((void)0)), (syme1))->locmask) & ( 1 << (SYFI_Builtin))) ? ((syme1)->fieldv)[symeIndex( syme1,SYFI_Builtin)] : (symeFieldInfo[SYFI_Builtin].def)) : symeGetFieldFn (syme1,SYFI_Builtin))) == symeBuiltin(syme2)((FoamBValTag) (SYFI_Builtin < (8 sizeof(int)) && !(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2 )->lib) : ((void)0)), (syme2))->hasmask) & (1 << (SYFI_Builtin))) ? (symeFieldInfo[SYFI_Builtin].def) : ((((( syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->locmask) & (1 << ( SYFI_Builtin))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes ((syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Builtin))) ? ((syme2)->fieldv)[symeIndex( syme2,SYFI_Builtin)] : (symeFieldInfo[SYFI_Builtin].def)) : symeGetFieldFn (syme2,SYFI_Builtin))));
2138	break;
2139	case SYME_Foreign:
2140	result = forgEqual(symeForeign(syme1)((ForeignOrigin) (SYFI_Foreign < (8 * sizeof(int)) && !(((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1 )->lib) : ((void)0)), (syme1))->hasmask) & (1 << (SYFI_Foreign))) ? (symeFieldInfo[SYFI_Foreign].def) : ((((( syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->locmask) & (1 << ( SYFI_Foreign))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes ((syme1)->lib) : ((void)0)), (syme1))->locmask) & ( 1 << (SYFI_Foreign))) ? ((syme1)->fieldv)[symeIndex( syme1,SYFI_Foreign)] : (symeFieldInfo[SYFI_Foreign].def)) : symeGetFieldFn (syme1,SYFI_Foreign))), symeForeign(syme2)((ForeignOrigin) (SYFI_Foreign < (8 sizeof(int)) && !(((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2 )->lib) : ((void)0)), (syme2))->hasmask) & (1 << (SYFI_Foreign))) ? (symeFieldInfo[SYFI_Foreign].def) : ((((( syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->locmask) & (1 << ( SYFI_Foreign))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes ((syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Foreign))) ? ((syme2)->fieldv)[symeIndex( syme2,SYFI_Foreign)] : (symeFieldInfo[SYFI_Foreign].def)) : symeGetFieldFn (syme2,SYFI_Foreign))));
2141	break;
2142	case SYME_Import:
2143	result = tformEqual0(mods, symeExporter(syme1),
2144	symeExporter(syme2));
2145	break;
2146	case SYME_Library:
2147	result = libEqual(symeLibrary(syme1)((Lib) (SYFI_Library < (8 * sizeof(int)) && !((((( syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->hasmask) & (1 << ( SYFI_Library))) ? (symeFieldInfo[SYFI_Library].def) : (((((syme1 )->kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void)0)), (syme1))->locmask) & (1 << (SYFI_Library ))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes( (syme1)->lib) : ((void)0)), (syme1))->locmask) & ( 1 << (SYFI_Library))) ? ((syme1)->fieldv)[symeIndex( syme1,SYFI_Library)] : (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn (syme1,SYFI_Library))), symeLibrary(syme2)((Lib) (SYFI_Library < (8 sizeof(int)) && !((((( syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->hasmask) & (1 << ( SYFI_Library))) ? (symeFieldInfo[SYFI_Library].def) : (((((syme2 )->kind == SYME_Trigger ? libGetAllSymes((syme2)->lib) : ((void)0)), (syme2))->locmask) & (1 << (SYFI_Library ))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes( (syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Library))) ? ((syme2)->fieldv)[symeIndex( syme2,SYFI_Library)] : (symeFieldInfo[SYFI_Library].def)) : symeGetFieldFn (syme2,SYFI_Library))));
2148	break;
2149	case SYME_Archive:
2150	result = arEqual(symeArchive(syme1)((Archive) (SYFI_Archive < (8 * sizeof(int)) && !( ((((syme1)->kind == SYME_Trigger ? libGetAllSymes((syme1)-> lib) : ((void)0)), (syme1))->hasmask) & (1 << ( SYFI_Archive))) ? (symeFieldInfo[SYFI_Archive].def) : (((((syme1 )->kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void)0)), (syme1))->locmask) & (1 << (SYFI_Archive ))) ? ((((((syme1)->kind == SYME_Trigger ? libGetAllSymes( (syme1)->lib) : ((void)0)), (syme1))->locmask) & ( 1 << (SYFI_Archive))) ? ((syme1)->fieldv)[symeIndex( syme1,SYFI_Archive)] : (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn (syme1,SYFI_Archive))), symeArchive(syme2)((Archive) (SYFI_Archive < (8 sizeof(int)) && !( ((((syme2)->kind == SYME_Trigger ? libGetAllSymes((syme2)-> lib) : ((void)0)), (syme2))->hasmask) & (1 << ( SYFI_Archive))) ? (symeFieldInfo[SYFI_Archive].def) : (((((syme2 )->kind == SYME_Trigger ? libGetAllSymes((syme2)->lib) : ((void)0)), (syme2))->locmask) & (1 << (SYFI_Archive ))) ? ((((((syme2)->kind == SYME_Trigger ? libGetAllSymes( (syme2)->lib) : ((void*)0)), (syme2))->locmask) & ( 1 << (SYFI_Archive))) ? ((syme2)->fieldv)[symeIndex( syme2,SYFI_Archive)] : (symeFieldInfo[SYFI_Archive].def)) : symeGetFieldFn (syme2,SYFI_Archive))));
2151	break;
2152	case SYME_Export:
2153	case SYME_Extend:
2154	result = true1;
2155	break;
2156	default:
2157	bugBadCase(symeKind(syme1))bug("Bad case %d (line %d in file %s).", (int) ((((syme1)-> kind == SYME_Trigger ? libGetAllSymes((syme1)->lib) : ((void *)0)), (syme1))->kind), 2157, "sefo.c");
2158	}
2159
2160	if (DEBUG(sefoEqual)sefoEqualDebug) {
2161	fprintf(dbOut, "<- symeOriginEqual[%d] = %s",
2162	(int) serial, boolToString(result)((result) ? "true" : "false"));
2163	fnewline(dbOut);
2164	}
2165
2166	return result;
2167	}
2168
2169	localstatic Bool
2170	tformEqualCheckSymes(TForm tf)
2171	{
2172	switch (tfTag(tf)((tf)->tag)) {
2173	case TF_Declare:
2174	case TF_Cross:
2175	case TF_Map:
2176	case TF_PackedMap:
2177	case TF_Multiple:
2178	case TF_Add:
2179	case TF_Third:
2180	return true1;
2181	default:
2182	if (tfIsLibrary(tf) \|\| tfIsArchive(tf))
2183	return true1;
2184	return false((int) 0);
2185	}
2186	}
2187
2188	/*
2189	* Equality preserving functions for sstEqual.
2190	*/
2191
2192	localstatic Sefo
2193	sefoEqualMods(Sefo sefo)
2194	{
2195	Bool changed = (sefo != NULL((void*)0));
2196
2197	while (changed)
2198	switch (abTag(sefo)((sefo)->abHdr.tag)) {
2199	case AB_PretendTo:
2200	sefo = sefo->abPretendTo.expr;
2201	break;
2202	case AB_RestrictTo:
2203	sefo = sefo->abRestrictTo.expr;
2204	break;
2205	case AB_Qualify:
2206	sefo = sefo->abQualify.what;
2207	break;
2208	case AB_Declare:
2209	sefo = sefo->abDeclare.type;
2210	break;
2211	case AB_Test: {
2212	if (tfEqual(abTUnique(sefo)((sefo)->abHdr.type.unique), tfBoolean))
2213	sefo = sefo->abTest.cond;
2214	else
2215	changed = false((int) 0);
2216	break;
2217	}
2218
2219	default:
2220	changed = false((int) 0);
2221	break;
2222	}
2223
2224	return sefo;
2225	}
2226
2227	/*****************************************************************************
2228	*
2229	* :: sefoCopy
2230	*
2231	****************************************************************************/
2232
2233	Sefo
2234	sefoCopy(Sefo sefo)
2235	{
2236	Sefo result = abCopy(sefo);
2237	abTransferSemantics(sefo, result);
2238	return result;
2239	}
2240
2241	/*****************************************************************************
2242	*
2243	* :: sefoAudit
2244	*
2245	****************************************************************************/
2246
2247	Bool
2248	sefoAudit(Bool verbose, Sefo sefo)
2249	{
2250	int i;
2251	Bool ok = true1;
2252
2253	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START) && !abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 )) {
2254	if (verbose) {
2255	String expr = abPretty(sefo);
2256	fprintf(dbOut, "No symbol meaning for leaf: %s", expr);
2257	fnewline(dbOut);
2258	strFree(expr);
2259	}
2260	ok = false((int) 0);
2261	}
2262	if (!abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START))
2263	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i++)
2264	ok &= sefoAudit(verbose, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
2265	return ok;
2266	}
2267
2268	/******************************************************************************
2269	*
2270	* :: sstFreeVars
2271	*
2272	*****************************************************************************/
2273
2274	/*
2275	* sstFreeVars entry points.
2276	*/
2277
2278	void
2279	sefoFreeVars(Sefo sefo)
2280	{
2281	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
2282	if (abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ))
2283	symeFreeVars(abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
2284	}
2285	else {
2286	Length i;
2287	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1)
2288	sefoFreeVars(abArgv(sefo)((sefo)->abGen.data.argv)[i]);
2289
2290	if (abState(sefo)((sefo)->abHdr.state) == AB_State_HasUnique)
2291	tformFreeVars(abTUnique(sefo)((sefo)->abHdr.type.unique));
2292	}
2293	}
2294
2295	void
2296	symeFreeVars(Syme syme)
2297	{
2298	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import))
2299	tformFreeVars(symeExporter(syme));
2300	else if (!symeIsSelf(syme)(((syme)->id) == ssymSelf))
2301	tformFreeVars(symeType(syme));
2302
2303	if (symeCondition(syme))
2304	sefoListFreeVars(symeCondition(syme));
2305	}
2306
2307	localstatic int sfvPrint(FILE *out);
2308
2309	void
2310	tformFreeVars(TForm tf)
2311	{
2312	TForm ancestor;
2313	FreeVar fv;
2314
2315	tf = tfFollowOnly(tf);
2316	if (tfIsPending(tf)(((tf)->state)==TF_State_Pending) && tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
2317	return;
2318
2319	if (tfFVars(tf)((tf)->fv))
2320	return;
2321
2322	sfvInitTable();
2323	sfvPushTable();
2324	ancestor = tf;
2325
2326	sstNext("tformFreeVars", &ancestor, tf){ if (sstDebug) { sstNextDB("tformFreeVars", (Pointer)(&ancestor ), (Pointer)(tf)); } sstNext0(); };
2327	tformFreeVars0(&ancestor, NULL((void*)0), tf);
2328	sstDoneTForm(tf){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
2329
2330	fv = sfvPopTable(true1);
2331	sfvFiniTable();
2332
2333	tfSetFVars(tf, fv)(((tf)->fv) = (fv));
2334	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, "FV(final) %pTForm = %pFreeVar\n", tf, tf->fv);
2335	if (DEBUG(sefoFree)sefoFreeDebug) {
2336	sfvPrint(dbOut);
2337	}
2338	}
2339
2340	void
2341	tqualFreeVars(TQual tqual)
2342	{
2343	tformFreeVars(tqBase(tqual)((tqual)->base));
2344	tformListFreeVars(tqQual(tqual)((tqual)->qual));
2345	}
2346
2347	void
2348	abSubFreeVars(AbSub sigma)
2349	{
2350	TForm ancestor = tfNone()tfMulti(0);
2351	FreeVar fv;
2352
2353	if (absFVars(sigma)((sigma)->fv))
2354	return;
2355
2356	sfvInitTable();
2357	sfvPushTable();
2358
2359	sstNext("abSubFreeVars", &ancestor, sigma){ if (sstDebug) { sstNextDB("abSubFreeVars", (Pointer)(&ancestor ), (Pointer)(sigma)); } sstNext0(); };
2360	abSubFreeVars0(&ancestor, ancestor, sigma);
2361	sstDoneAbSub(sigma){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
2362
2363	fv = sfvPopTable(true1);
2364	sfvFiniTable();
2365
2366	absSetFVars(sigma, fv)((sigma)->fv = (fv));
2367	}
2368
2369	void
2370	sefoListFreeVars(SefoList sefos)
2371	{
2372	for (; sefos; sefos = cdr(sefos)((sefos)->rest))
2373	sefoFreeVars(car(sefos)((sefos)->first));
2374	}
2375
2376	void
2377	symeListFreeVars(SymeList symes)
2378	{
2379	for (; symes; symes = cdr(symes)((symes)->rest))
2380	symeFreeVars(car(symes)((symes)->first));
2381	}
2382
2383	void
2384	tformListFreeVars(TFormList tforms)
2385	{
2386	for (; tforms; tforms = cdr(tforms)((tforms)->rest))
2387	tformFreeVars(car(tforms)((tforms)->first));
2388	}
2389
2390	void
2391	tqualListFreeVars(TQualList tquals)
2392	{
2393	for (; tquals; tquals = cdr(tquals)((tquals)->rest))
2394	tqualFreeVars(car(tquals)((tquals)->first));
2395	}
2396
2397	/*
2398	* sstFreeVars table stack functions.
2399	*/
2400
2401	static SymeListList sfvTableList = listNil(SymeList)((SymeListList) 0);
2402	static AIntList sfvBase = listNil(AInt)((AIntList) 0);
2403	static AInt sfvDepth = 0;
2404
2405	#define sfvHasDepth(l,n)((l) != ((AIntList) 0) && ((l)->first) == (n)) ((l) != listNil(AInt)((AIntList) 0) && car(l)((l)->first) == (n))
2406	#define sfvGetDepths(sy)((AIntList) (SYFI_Depths < (8 * sizeof(int)) && !( ((((sy)->kind == SYME_Trigger ? libGetAllSymes((sy)->lib ) : ((void)0)), (sy))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((sy)->kind == SYME_Trigger ? libGetAllSymes((sy)->lib) : ((void)0)), ( sy))->locmask) & (1 << (SYFI_Depths))) ? ((((((sy )->kind == SYME_Trigger ? libGetAllSymes((sy)->lib) : ( (void)0)), (sy))->locmask) & (1 << (SYFI_Depths ))) ? ((sy)->fieldv)[symeIndex(sy,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(sy,SYFI_Depths))) symeDepths(sy)((AIntList) (SYFI_Depths < (8 sizeof(int)) && !( ((((sy)->kind == SYME_Trigger ? libGetAllSymes((sy)->lib ) : ((void)0)), (sy))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((sy)->kind == SYME_Trigger ? libGetAllSymes((sy)->lib) : ((void)0)), ( sy))->locmask) & (1 << (SYFI_Depths))) ? ((((((sy )->kind == SYME_Trigger ? libGetAllSymes((sy)->lib) : ( (void*)0)), (sy))->locmask) & (1 << (SYFI_Depths ))) ? ((sy)->fieldv)[symeIndex(sy,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(sy,SYFI_Depths)))
2407	#define sfvSetDepths(sy,l)(symeSetFieldVal = ((AInt) (l)), (((((sy)->kind == SYME_Trigger ? libGetAllSymes((sy)->lib) : ((void)0)), (sy))->locmask ) & (1 << (SYFI_Depths))) ? (((sy)->fieldv)[symeIndex (sy,SYFI_Depths)] = (symeSetFieldVal)) : !((sy)->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Depths].def) ? symeSetFieldVal : symeSetFieldFn(sy,SYFI_Depths,symeSetFieldVal)) symeSetDepths(sy,l)(symeSetFieldVal = ((AInt) (l)), (((((sy)->kind == SYME_Trigger ? libGetAllSymes((sy)->lib) : ((void)0)), (sy))->locmask ) & (1 << (SYFI_Depths))) ? (((sy)->fieldv)[symeIndex (sy,SYFI_Depths)] = (symeSetFieldVal)) : !((sy)->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Depths].def) ? symeSetFieldVal : symeSetFieldFn(sy,SYFI_Depths,symeSetFieldVal))
2408	#define sfvIsBase(n)((n) == ((sfvBase)->first)) ((n) == car(sfvBase)((sfvBase)->first))
2409
2410	localstatic void
2411	sfvInitTable(void)
2412	{
2413	sfvBase = listCons(AInt)(AInt_listPointer->Cons)(sfvDepth, sfvBase);
2414	}
2415
2416	localstatic void
2417	sfvFiniTable(void)
2418	{
2419	sfvBase = listFreeCons(AInt)(AInt_listPointer->FreeCons)(sfvBase);
2420	}
2421
2422	localstatic int
2423	sfvPrint(FILE *out)
2424	{
2425	return afprintf(out,
2426	"(SFV: %d %pAIntList, %pSymeListList)\n",
2427	sfvDepth, sfvBase, sfvTableList);
2428	}
2429
2430	localstatic void
2431	sfvPushTable(void)
2432	{
2433	SymeList tbl = listNil(Syme)((SymeList) 0);
2434	sfvTableList = listCons(SymeList)(SymeList_listPointer->Cons)(tbl, sfvTableList);
2435	sfvDepth += 1;
2436	}
2437
2438	localstatic void
2439	sfvConsTable(Syme syme)
2440	{
2441	SymeList tbl = car(sfvTableList)((sfvTableList)->first);
2442	listPush(Syme, syme, tbl)(tbl = (Syme_listPointer->Cons)(syme, tbl));
2443	setcar(sfvTableList, tbl)((sfvTableList)->first = (tbl));
2444	}
2445
2446	localstatic FreeVar
2447	sfvPopTable(Bool save)
2448	{
2449	SymeList tbl = car(sfvTableList)((sfvTableList)->first);
2450	SymeList symes, fsymes;
2451	int odepth = sfvDepth;
2452
2453	sfvTableList = listFreeCons(SymeList)(SymeList_listPointer->FreeCons)(sfvTableList);
2454	sfvDepth -= 1;
2455
2456	fsymes = listNil(Syme)((SymeList) 0);
2457	for (symes = tbl; symes; symes = cdr(symes)((symes)->rest)) {
2458	Syme syme = car(symes)((symes)->first);
2459	List(AInt)AIntList elt = sfvGetDepths(syme)((AIntList) (SYFI_Depths < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Depths))) ? ((( (((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Depths ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(syme,SYFI_Depths)));
2460
2461	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, " popTable: %pSyme %d %d %pAIntList\n",
2462	syme, sfvHasDepth(elt, odepth)((elt) != ((AIntList) 0) && ((elt)->first) == (odepth )), odepth, elt);
2463
2464	if (!sfvHasDepth(elt, odepth)((elt) != ((AIntList) 0) && ((elt)->first) == (odepth ))) continue;
2465
2466	if (sfvIsBase(sfvDepth)((sfvDepth) == ((sfvBase)->first))) {
2467	elt = listFreeCons(AInt)(AInt_listPointer->FreeCons)(elt);
2468	sfvSetDepths(syme, elt)(symeSetFieldVal = ((AInt) (elt)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_Depths))) ? (((syme)->fieldv )[symeIndex(syme,SYFI_Depths)] = (symeSetFieldVal)) : !((syme )->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Depths ].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Depths,symeSetFieldVal ));
2469	}
2470	else if (sfvHasDepth(cdr(elt), sfvDepth)((((elt)->rest)) != ((AIntList) 0) && ((((elt)-> rest))->first) == (sfvDepth))) {
2471	elt = listFreeCons(AInt)(AInt_listPointer->FreeCons)(elt);
2472	sfvSetDepths(syme, elt)(symeSetFieldVal = ((AInt) (elt)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_Depths))) ? (((syme)->fieldv )[symeIndex(syme,SYFI_Depths)] = (symeSetFieldVal)) : !((syme )->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Depths ].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Depths,symeSetFieldVal ));
2473	}
2474	else {
2475	setcar(elt, sfvDepth)((elt)->first = (sfvDepth));
2476	sfvConsTable(syme);
2477	}
2478
2479	if (save) fsymes = listCons(Syme)(Syme_listPointer->Cons)(syme, fsymes);
2480	}
2481
2482	listFree(Syme)(Syme_listPointer->Free)(tbl);
2483
2484	return save ? fvFrSymes(fsymes) : fvEmpty();
2485	}
2486
2487	localstatic void
2488	sfvAddSyme(Syme syme)
2489	{
2490	List(AInt)AIntList elt = sfvGetDepths(syme)((AIntList) (SYFI_Depths < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Depths))) ? ((( (((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Depths ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(syme,SYFI_Depths)));
2491	if (!sfvHasDepth(elt, sfvDepth)((elt) != ((AIntList) 0) && ((elt)->first) == (sfvDepth ))) {
2492	elt = listCons(AInt)(AInt_listPointer->Cons)(sfvDepth, elt);
2493	sfvSetDepths(syme, elt)(symeSetFieldVal = ((AInt) (elt)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_Depths))) ? (((syme)->fieldv )[symeIndex(syme,SYFI_Depths)] = (symeSetFieldVal)) : !((syme )->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Depths ].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Depths,symeSetFieldVal ));
2494	sfvConsTable(syme);
2495	}
2496	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, " Adding syme: %pSyme %pAIntList\n",
2497	syme, sfvGetDepths(syme)((AIntList) (SYFI_Depths < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Depths))) ? ((( (((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Depths ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(syme,SYFI_Depths))));
2498	}
2499
2500	localstatic void
2501	sfvAddSymes(SymeList symes)
2502	{
2503	for (; symes; symes = cdr(symes)((symes)->rest))
2504	if (symeIsSubstable(car(symes))((((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void)0)), (((symes)-> first)))->kind) == SYME_Param) \|\| (((((((symes)->first) )->kind == SYME_Trigger ? libGetAllSymes((((symes)->first ))->lib) : ((void)0)), (((symes)->first)))->kind) == SYME_LexConst) \|\| (((((symes)->first))->id) == ssymSelf ) \|\| ((((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void*)0)), (((symes)-> first)))->kind) == SYME_Export) && !symeTop(((symes )->first)))))
2505	sfvAddSyme(car(symes)((symes)->first));
2506	}
2507
2508	localstatic void
2509	sfvDelSyme(Syme syme)
2510	{
2511	List(AInt)AIntList elt = sfvGetDepths(syme)((AIntList) (SYFI_Depths < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Depths))) ? ((( (((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Depths ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(syme,SYFI_Depths)));
2512	if (sfvHasDepth(elt, sfvDepth)((elt) != ((AIntList) 0) && ((elt)->first) == (sfvDepth ))) {
2513	elt = listFreeCons(AInt)(AInt_listPointer->FreeCons)(elt);
2514	sfvSetDepths(syme, elt)(symeSetFieldVal = ((AInt) (elt)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_Depths))) ? (((syme)->fieldv )[symeIndex(syme,SYFI_Depths)] = (symeSetFieldVal)) : !((syme )->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Depths ].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Depths,symeSetFieldVal ));
2515	}
2516	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, " Del syme: %pSyme %pAIntList\n",
2517	syme, sfvGetDepths(syme)((AIntList) (SYFI_Depths < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_Depths ))) ? (symeFieldInfo[SYFI_Depths].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_Depths))) ? ((( (((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Depths ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_Depths)] : (symeFieldInfo [SYFI_Depths].def)) : symeGetFieldFn(syme,SYFI_Depths))));
2518	}
2519
2520	localstatic void
2521	sfvDelSymes(SymeList symes)
2522	{
2523	for (; symes; symes = cdr(symes)((symes)->rest))
2524	if (symeIsSubstable(car(symes))((((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void)0)), (((symes)-> first)))->kind) == SYME_Param) \|\| (((((((symes)->first) )->kind == SYME_Trigger ? libGetAllSymes((((symes)->first ))->lib) : ((void)0)), (((symes)->first)))->kind) == SYME_LexConst) \|\| (((((symes)->first))->id) == ssymSelf ) \|\| ((((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void*)0)), (((symes)-> first)))->kind) == SYME_Export) && !symeTop(((symes )->first)))))
2525	sfvDelSyme(car(symes)((symes)->first));
2526	}
2527
2528	localstatic void
2529	sfvDelStab(Stab stab)
2530	{
2531	sfvDelSymes(stabGetBoundSymes(stab)(((stab)->first)->boundSymes));
2532	}
2533
2534	localstatic Bool
2535	sfvIsAncestor(TForm ancestor, TForm tf)
2536	{
2537	while (tf) {
2538	if (tf == ancestor) return true1;
2539	tf = tf->parent;
2540	}
2541	return false((int) 0);
2542	}
2543
2544	localstatic TForm
2545	sfvCommonAncestor(TForm tf1, TForm tf2)
2546	{
2547	while (tf1) {
2548	if (sfvIsAncestor(tf1, tf2)) return tf1;
2549	tf1 = tf1->parent;
2550	}
2551	assert(false)do { if (!(((int) 0))) _do_assert(("false"),"sefo.c",2551); } while (0);
2552	return NULL((void*)0);
2553	}
2554
2555	/*
2556	* sstFreeVars local functions.
2557	*/
2558
2559	localstatic void
2560	sefoFreeVars0(TForm *pa, TForm parent, Sefo sefo)
2561	{
2562	Length serial = 0;
2563
2564	sstSerialDebug += 1;
2565	serial = sstSerialDebug;
2566
2567	if (DEBUG(sefoFree)sefoFreeDebug) {
2568	afprintf(dbOut, "(sefoFree[%d]: %pAbSyn\n", (int) serial, sefo);
2569	sfvPrint(dbOut);
2570	}
2571
2572	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
2573	Syme syme = abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 );
2574
2575	/!! assert(syme); /
2576	if (!syme) return;
2577
2578	if (symeIsSubstable(syme)((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Param) \|\| ((((( syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib ) : ((void)0)), (syme))->kind) == SYME_LexConst) \|\| (((syme )->id) == ssymSelf) \|\| ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> kind) == SYME_Export) && !symeTop(syme))))
2579	sfvAddSyme(syme);
2580	symeUnboundVars0(pa, parent, syme);
2581	}
2582	else {
2583	Length i;
2584	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1)
2585	sefoUnboundVars0(pa, parent, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
2586
2587	if (abState(sefo)((sefo)->abHdr.state) == AB_State_HasUnique)
2588	tformUnboundVars0(pa, parent, abTUnique(sefo)((sefo)->abHdr.type.unique));
2589	}
2590
2591	if (DEBUG(sefoFree)sefoFreeDebug) {
2592	sfvPrint(dbOut);
2593	fprintf(dbOut, " sefoFree[%d]: %p)\n", (int) serial, (void) pa);
2594	}
2595	}
2596
2597	localstatic void
2598	symeFreeVars0(TForm *pa, TForm parent, Syme syme)
2599	{
2600	Length serial = 0;
2601
2602	sstSerialDebug += 1;
2603	serial = sstSerialDebug;
2604
2605	if (DEBUG(sefoFree)sefoFreeDebug) {
2606	afprintf(dbOut, "(symeFree[%d]: %pSyme\n", (int) serial, syme);
2607	sfvPrint(dbOut);
2608	}
2609
2610	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, " symeFree[%d]: Self: %d Substable: %d\n",
2611	(int) serial, symeIsSelf(syme)(((syme)->id) == ssymSelf),
2612	(int) symeDefLevelIsSubstable(syme)(symeDefLevel(syme)->isSubstable));
2613	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import))
2614	tformUnboundVars0(pa, parent, symeExporter(syme));
2615	else if (!symeIsSelf(syme)(((syme)->id) == ssymSelf) &&
2616	symeDefLevelIsSubstable(syme)(symeDefLevel(syme)->isSubstable))
2617	tformUnboundVars0(pa, parent, symeType(syme));
2618
2619	if (symeCondition(syme))
2620	sefoListUnboundVars0(pa, parent, symeCondition(syme));
2621
2622	if (DEBUG(sefoFree)sefoFreeDebug) {
2623	sfvPrint(dbOut);
2624	afprintf(dbOut, " symeFree[%d]: %pTForm)\n", (int) serial, *pa);
2625	}
2626	}
2627
2628	localstatic void
2629	tformFreeVars0(TForm *pa, TForm parent, TForm tf)
2630	{
2631	TForm ancestor;
2632	Length serial = 0;
2633	Bool cascade = false((int) 0);
2634	SymeList symes;
2635
2636	assert(tf)do { if (!(tf)) _do_assert(("tf"),"sefo.c",2636); } while (0);
2637	tf = tfFollowOnly(tf);
2638	if (tfIsDefine(tf)(((tf)->tag) == TF_Define) && tfIsWith(tfDefineVal(tf))(((tfFollowArg(tf, 1))->tag) == TF_With))
2639	tf = tfDefineeType(tf);
2640
2641	if (tfIsSubst(tf)(((tf)->tag) == TF_Subst) && tfFVars(tf)((tf)->fv) == NULL((void*)0)) {
2642	TForm arg = tfSubstArg(tf)tfFollowArg(tf, 0);
2643
2644	if (sstTFormIsMarked(arg)(sstMarkDepth == 1 ? ((arg)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (arg), ((void*)0)) )) {
2645	pa = sfvCommonAncestor(pa, arg);
2646	return;
2647	}
2648	tformFreeVars(arg);
2649	abSubFreeVars(tfSubstSigma(tf)((tf)->sigma));
2650	tfSetFVars(tf, freeVarSubst0(tfSubstSigma(tf), tfFVars(arg)))(((tf)->fv) = (freeVarSubst0(((tf)->sigma), ((arg)-> fv))));
2651	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, "FV(subst) %pTForm = %pFreeVar\n",
2652	tf, tf->fv);
2653	}
2654
2655	if (tfFVars(tf)((tf)->fv)) {
2656	sfvAddSymes(fvSymes(tfFVars(tf))((((tf)->fv))->symes));
2657	return;
2658	}
2659
2660	if (sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0)))) {
2661	pa = sfvCommonAncestor(pa, tf);
2662	return;
2663	}
2664	sstMarkTForm(tf);
2665
2666	sstSerialDebug += 1;
2667	serial = sstSerialDebug;
2668
2669	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, "(tformFree[%d]: %pTForm\n", (int) serial, tf);
2670
2671	sfvPushTable();
2672
2673	tf->parent = parent;
2674	ancestor = parent = tf;
2675
2676	if (tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
2677	;
2678	else if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT))
2679	;
2680	else if (tfIsLibrary(tf) \|\| tfIsArchive(tf))
2681	;
2682	else if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_ABSYN_LIMIT))
2683	sefoUnboundVars0(&ancestor, parent, tfGetExpr(tf)((tf)->__absyn));
2684	else if (tfIsWith(tf)(((tf)->tag) == TF_With) && (symes = tfGetCatParents(tf, true1)) != NULL((void*)0)) {
2685	tfGetCatSelf(tf);
2686	symeListUnboundVars0(&ancestor, parent, symes);
2687	tqualListFreeVars0(&ancestor, parent, tfGetCatCascades(tf));
2688	cascade = true1;
2689	}
2690	else if (tfIsThird(tf)(((tf)->tag) == TF_Third) && (symes = tfGetThdParents(tf)) != NULL((void*)0)) {
2691	tfGetThdSelf(tf);
2692	symeListUnboundVars0(&ancestor, parent, symes);
2693	tqualListFreeVars0(&ancestor, parent, tfGetThdCascades(tf));
2694	cascade = true1;
2695	}
2696	else if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_NODE_LIMIT)) {
2697	Length i;
2698	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
2699	tformUnboundVars0(&ancestor, parent, tfArgv(tf)((tf)->argv)[i]);
2700	}
2701	else
2702	bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag) , 2702, "sefo.c");
2703
2704	if (tfSymes(tf)((tf)->symes)) {
2705	if (!(tfIsLibrary(tf) \|\| tfIsArchive(tf)))
2706	symeListUnboundVars0(&ancestor, parent, tfSymes(tf)((tf)->symes));
2707	if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare))
2708	sfvAddSymes(tfSymes(tf)((tf)->symes));
2709	else
2710	sfvDelSymes(tfSymes(tf)((tf)->symes));
2711	}
2712	if (tfQueries(tf)((tf)->queries))
2713	tformListUnboundVars0(&ancestor, parent, tfQueries(tf)((tf)->queries));
2714	if (!cascade && tfCascades(tf)((tf)->cascades))
2715	tqualListUnboundVars0(&ancestor, parent, tfCascades(tf)((tf)->cascades));
2716
2717	if (tfStab(tf)((tf)->stab))
2718	sfvDelStab(tfStab(tf)((tf)->stab));
2719	if (tfSelf(tf)((tf)->self))
2720	sfvDelSymes(tfSelf(tf)((tf)->self));
2721	if (tfSelfSelf(tf)((tf)->selfself))
2722	sfvDelSymes(tfSelfSelf(tf)((tf)->selfself));
2723
2724	if (ancestor == tf && tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning)) {
2725	tfSetFVars(tf, sfvPopTable(true))(((tf)->fv) = (sfvPopTable(1)));
2726	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, "FV %pTForm = %pFreeVar\n", tf, tf->fv);
2727	}
2728	else {
2729	sfvPopTable(false((int) 0));
2730	*pa = ancestor;
2731	}
2732
2733	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, " tformFree[%d]: %d %pTForm)\n",
2734	(int) serial, tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning), *pa);
2735	}
2736
2737	localstatic void
2738	tqualFreeVars0(TForm *pa, TForm parent, TQual tq)
2739	{
2740	tformUnboundVars0(pa, parent, tqBase(tq)((tq)->base));
2741	if (tqIsQualified(tq)((tq)->isQual == 1))
2742	tformListUnboundVars0(pa, parent, tqQual(tq)((tq)->qual));
2743	}
2744
2745	localstatic void
2746	abSubFreeVars0(TForm *pa, TForm parent, AbSub sigma)
2747	{
2748	AbBindList l0;
2749	for (l0 = sigma->l; l0; l0 = cdr(l0)((l0)->rest))
2750	sefoUnboundVars0(pa, parent, car(l0)((l0)->first)->val);
2751	}
2752
2753	localstatic void
2754	sefoListFreeVars0(TForm *pa, TForm parent, SefoList sefos)
2755	{
2756	for (; sefos; sefos = cdr(sefos)((sefos)->rest))
2757	sefoUnboundVars0(pa, parent, car(sefos)((sefos)->first));
2758	}
2759
2760	localstatic void
2761	symeListFreeVars0(TForm *pa, TForm parent, SymeList symes)
2762	{
2763	for (; symes; symes = cdr(symes)((symes)->rest))
2764	symeUnboundVars0(pa, parent, car(symes)((symes)->first));
2765	}
2766
2767	localstatic void
2768	tformListFreeVars0(TForm *pa, TForm parent, TFormList tforms)
2769	{
2770	for (; tforms; tforms = cdr(tforms)((tforms)->rest))
2771	tformUnboundVars0(pa, parent, car(tforms)((tforms)->first));
2772	}
2773
2774	localstatic void
2775	tqualListFreeVars0(TForm *pa, TForm parent, TQualList tquals)
2776	{
2777	for (; tquals; tquals = cdr(tquals)((tquals)->rest))
2778	tqualUnboundVars0(pa, parent, car(tquals)((tquals)->first));
2779	}
2780
2781	localstatic void
2782	sefoUnboundVars0(TForm *pa, TForm parent, Sefo sefo)
2783	{
2784	sefoFreeVars0(pa, parent, sefo);
2785	if (abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0 ))
2786	sfvDelStab(abStab(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->stab : 0 ));
2787	}
2788
2789	localstatic void
2790	symeUnboundVars0(TForm *pa, TForm parent, Syme syme)
2791	{
2792	symeFreeVars0(pa, parent, syme);
2793	}
2794
2795	localstatic void
2796	tformUnboundVars0(TForm *pa, TForm parent, TForm tf)
2797	{
2798	tfGetStab(tf);
2799	tformFreeVars0(pa, parent, tf);
2800	}
2801
2802	localstatic void
2803	tqualUnboundVars0(TForm *pa, TForm parent, TQual tq)
2804	{
2805	tqualFreeVars0(pa, parent, tq);
2806	}
2807
2808	localstatic void
2809	sefoListUnboundVars0(TForm *pa, TForm parent, SefoList sefos)
2810	{
2811	sefoListFreeVars0(pa, parent, sefos);
2812	}
2813
2814	localstatic void
2815	symeListUnboundVars0(TForm *pa, TForm parent, SymeList symes)
2816	{
2817	symeListFreeVars0(pa, parent, symes);
2818	}
2819
2820	localstatic void
2821	tformListUnboundVars0(TForm *pa, TForm parent, TFormList tforms)
2822	{
2823	tformListFreeVars0(pa, parent, tforms);
2824	}
2825
2826	localstatic void
2827	tqualListUnboundVars0(TForm *pa, TForm parent, TQualList tquals)
2828	{
2829	tqualListFreeVars0(pa, parent, tquals);
2830	}
2831
2832	/*****************************************************************************
2833	*
2834	* :: sstSubst
2835	*
2836	****************************************************************************/
2837
2838	/*
2839	* symeListSubst external entry points.
2840	*/
2841
2842	AbSub
2843	absFrSymes(Stab stab, SymeList symes, Sefo sefo)
2844	{
2845	AbSub sigma = absNew(stab);
2846
2847	if (symes && symeIsSelf(car(symes))(((((symes)->first))->id) == ssymSelf)) absSetSelf(sigma)((sigma)->self = 1);
2848	for (; symes; symes = cdr(symes)((symes)->rest))
2849	sigma = absExtend(car(symes)((symes)->first), sefo, sigma);
2850
2851	return sigma;
2852	}
2853
2854	SymeList
2855	symeListSubstSelf(Stab stab, TForm tf, SymeList osymes)
2856	{
2857	AbSub sigma = absFrSymes(stab, tfGetDomSelf(tf), tfExpr(tf)tfToAbSyn(tf));
2858	SymeList nsymes, symes;
2859
2860	nsymes = symeListSubstSigma(sigma, osymes);
2861
2862	for (symes = osymes; symes; symes = cdr(symes)((symes)->rest)) {
2863	Syme syme = car(symes)((symes)->first);
2864	Syme nsyme = absGetSyme(sigma, syme);
2865	symeAddTwin(nsyme, syme);
2866
2867	/* Now mutate the syme kind. */
2868	symeSetKind(nsyme, SYME_Import)(((((nsyme)->kind == SYME_Trigger ? libGetAllSymes((nsyme) ->lib) : ((void*)0)), (nsyme))->kind) = (SYME_Import));
2869	symeSetExporter(nsyme, tf)(symeSetFieldVal = ((AInt) (tf)), (((((nsyme)->kind == SYME_Trigger ? libGetAllSymes((nsyme)->lib) : ((void*)0)), (nsyme))-> locmask) & (1 << (SYFI_Exporter))) ? (((nsyme)-> fieldv)[symeIndex(nsyme,SYFI_Exporter)] = (symeSetFieldVal)) : !((nsyme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_Exporter].def) ? symeSetFieldVal : symeSetFieldFn(nsyme ,SYFI_Exporter,symeSetFieldVal));
2870
2871	if (tfIsLazyExporter(tf)(tfIsLibrary(tf) \|\| tfIsArchive(tf) \|\| (((((tf)->tag) == TF_General ) && ((((tf)->__absyn))->abHdr.tag) == AB_Id) && (((tf)->__absyn)->abId.sym) == (ssymSelf)))) {
2872	symeSetLib(nsyme, symeLib(syme)((syme)->lib));
2873	symeSetHash(nsyme, symeHash(syme))(((nsyme)->hash) = (((syme)->hash)));
2874	}
2875	else if (!symeIsLazy(nsyme)(((((nsyme)->kind == SYME_Trigger ? libGetAllSymes((nsyme) ->lib) : ((void*)0)), (nsyme))->bits) & (0x0001)))
2876	symeSetHash(nsyme, (Hash) 0)(((nsyme)->hash) = ((Hash) 0));
2877	}
2878
2879	/* Modifies nsymes indirectly via sigma ... */
2880	symeListSubstUseConstants(sigma, tfGetDomSelf(tf), osymes,
2881	tfGetDomConstants(tf));
2882	absFree(sigma);
2883
2884	if (tfCascades(tf)((tf)->cascades)) {
2885	/* Use a fresh sigma to avoid getting stomped-on symes. */
2886	sigma = absFrSymes(stab, tfGetDomSelf(tf), tfExpr(tf)tfToAbSyn(tf));
2887	tfCascades(tf)((tf)->cascades) = tqualListSubst(sigma, tfCascades(tf)((tf)->cascades));
2888	absFree(sigma);
2889	}
2890
2891	return nsymes;
2892	}
2893
2894	SymeList
2895	symeListSubstCat(Stab stab, SymeList mods, TForm cat, SymeList osymes)
2896	{
2897	AbSub sigma;
2898	SymeList nsymes, symes;
2899
2900	if (!mods) return listCopy(Syme)(Syme_listPointer->Copy)(osymes);
2901
2902	sigma = absFrSymes(stab, cdr(mods)((mods)->rest), abFrSyme(car(mods)((mods)->first)));
2903
2904	nsymes = symeListSubstSigma(sigma, osymes);
2905
2906	for (symes = osymes; symes; symes = cdr(symes)((symes)->rest)) {
2907	Syme syme = car(symes)((symes)->first);
2908	Syme nsyme = absGetSyme(sigma, syme);
2909	symeAddTwin(nsyme, syme);
2910	}
2911
2912	symeListSubstUseConstants(sigma, mods, osymes, tfGetCatConstants(cat));
2913
2914	absFree(sigma);
2915	return nsymes;
2916	}
2917
2918	SymeList
2919	symeListSubstSigma(AbSub sigma, SymeList osymes)
2920	{
2921	SymeList symes;
2922
2923	if (absIsEmpty(sigma)) {
2924	for (symes = listNil(Syme)((SymeList) 0); osymes; osymes = cdr(osymes)((osymes)->rest)) {
2925	Syme syme = car(osymes)((osymes)->first);
2926	Syme nsyme = symeCopy(syme);
2927	symes = listCons(Syme)(Syme_listPointer->Cons)(nsyme, symes);
2928	absSetSyme(sigma, syme, nsyme);
2929	absSetStab(sigma, nsyme);
2930	}
2931	return listNReverse(Syme)(Syme_listPointer->NReverse)(symes);
2932	}
2933
2934	symeListFreeVars(osymes);
2935	abSubFreeVars(sigma);
2936
2937	/* Mark the symes so tformWillSubst can find them. */
2938	/* Mark the twins so that after the subst they become ==. */
2939	for (symes = osymes; symes; symes = cdr(symes)((symes)->rest)) {
2940	Syme syme = car(symes)((symes)->first);
2941	absMarkSyme(sigma, syme);
2942	symeListMarkTwins(sigma, syme, syme);
2943	}
2944
2945	/* Copy the symes that symeSubst doesn't need to. */
2946	for (symes = osymes; symes; symes = cdr(symes)((symes)->rest)) {
2947	Syme syme = car(symes)((symes)->first), nsyme;
2948
2949	if (!symeWillSubst(sigma, syme)) {
2950	nsyme = symeCopy(syme);
2951	absSetSyme(sigma, syme, nsyme);
2952	absSetStab(sigma, nsyme);
2953	}
2954	}
2955
2956	/* Now symeSubst0 will use the symes we copied, and copy the rest. */
2957	return symeListSubst0(sigma, osymes);
2958	}
2959
2960	TForm
2961	tformSubstSigma(AbSub sigma, TForm tf)
2962	{
2963	AbBindList l0;
2964
2965	if (absIsEmpty(sigma)) return tf;
2966
2967	tformFreeVars(tf);
2968	abSubFreeVars(sigma);
2969
2970	/* Mark the symes in sigma which have symes as substituands. */
2971	for (l0 = sigma->l; l0; l0 = cdr(l0)((l0)->rest)) {
2972	Syme syme = car(l0)((l0)->first)->key;
2973	AbSyn sefo = car(l0)((l0)->first)->val;
2974	if (abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ))
2975	absSetSyme(sigma, syme, abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
2976	}
2977
2978	/* Now tformSubst0 will use the symes we marked. */
2979	return tformSubst0(sigma, tf);
2980	}
2981
2982	localstatic void
2983	symeListMarkTwins(AbSub sigma, Syme final, Syme twin)
2984	{
2985	SymeList symes;
2986
2987	for (symes = symeTwins(twin); symes; symes = cdr(symes)((symes)->rest)) {
2988	Syme syme = car(symes)((symes)->first);
2989	absSetSyme(sigma, syme, final);
2990	symeListMarkTwins(sigma, final, syme);
2991	}
2992	}
2993
2994	localstatic void
2995	symeListSubstUseConstants(AbSub sigma, SymeList mods, SymeList osymes,
2996	SymeList rsymes)
2997	{
2998	/for (; osymes; osymes = cdr(osymes)) { /
2999	for (; rsymes && osymes; osymes = cdr(osymes)((osymes)->rest)) {
3000	Syme osyme = car(osymes)((osymes)->first);
3001	Syme nsyme = absGetSyme(sigma, osyme);
3002	SymeList symes;
3003
3004	for (symes = rsymes; symes; symes = cdr(symes)((symes)->rest)) {
3005	Syme rsyme = car(symes)((symes)->first);
3006	if (symeId(osyme)((osyme)->id) == symeId(rsyme)((rsyme)->id) &&
3007	tformEqualMod(mods, symeType(osyme),
3008	symeType(rsyme))) {
3009	symeTransferImplInfo(nsyme, rsyme);
3010	if (symeIsImport(nsyme)(((((nsyme)->kind == SYME_Trigger ? libGetAllSymes((nsyme) ->lib) : ((void*)0)), (nsyme))->kind) == SYME_Import))
3011	symeClrDefault(nsyme)(((((nsyme)->kind == SYME_Trigger ? libGetAllSymes((nsyme) ->lib) : ((void*)0)), (nsyme))->bits) &= ~(0x0080));
3012	}
3013	}
3014	}
3015	}
3016
3017	/*
3018	* sstSubst external entry points.
3019	*/
3020
3021	Sefo
3022	sefoSubst(AbSub sigma, Sefo sefo)
3023	{
3024	if (absIsEmpty(sigma)) return sefo;
3025	sefoFreeVars(sefo);
3026	abSubFreeVars(sigma);
3027
3028	return sefoSubst0(sigma, sefo);
3029	}
3030
3031	SefoList
3032	sefoListSubst(AbSub sigma, SefoList sefoList)
3033	{
3034	SefoList result = listNil(Sefo)((SefoList) 0);
3035	if (absIsEmpty(sigma)) return sefoList;
3036	listIter(Sefo, sefo, sefoList, sefoFreeVars(sefo)){ { SefoList _l0; Sefo sefo; for (_l0 = (sefoList); _l0; _l0 = ((_l0)->rest)) { sefo = ((_l0)->first); { sefoFreeVars (sefo); }; } }; };
3037	abSubFreeVars(sigma);
3038
3039	listIter(Sefo, sefo, sefoList, result = listCons(Sefo)(sefoSubst0(sigma, sefo), result)){ { SefoList _l0; Sefo sefo; for (_l0 = (sefoList); _l0; _l0 = ((_l0)->rest)) { sefo = ((_l0)->first); { result = (Sefo_listPointer ->Cons)(sefoSubst0(sigma, sefo), result); }; } }; };
3040
3041	return listNReverse(Sefo)(Sefo_listPointer->NReverse)(result);
3042	}
3043
3044	Syme
3045	symeSubst(AbSub sigma, Syme syme)
3046	{
3047	if (absIsEmpty(sigma)) return syme;
3048	symeFreeVars(syme);
3049	abSubFreeVars(sigma);
3050
3051	return symeSubst0(sigma, syme);
3052	}
3053
3054	TForm
3055	tformSubst(AbSub sigma, TForm tf)
3056	{
3057	if (absIsEmpty(sigma)) return tf;
3058	if (!tfIsPending(tf)(((tf)->state)==TF_State_Pending)) tformFreeVars(tf);
3059	abSubFreeVars(sigma);
3060
3061	return tformSubst0(sigma, tf);
3062	}
3063
3064	SymeList
3065	symeListSubst(AbSub sigma, SymeList symes)
3066	{
3067	if (absIsEmpty(sigma)) return symes;
3068	symeListFreeVars(symes);
3069	abSubFreeVars(sigma);
3070
3071	return symeListSubst0(sigma, symes);
3072	}
3073
3074	localstatic TQualList
3075	tqualListSubst(AbSub sigma, TQualList tquals)
3076	{
3077	if (absIsEmpty(sigma)) return tquals;
3078	tqualListFreeVars(tquals);
3079	abSubFreeVars(sigma);
3080
3081	return tqualListSubst0(sigma, tquals);
3082	}
3083
3084	/*
3085	* The result from sefoSubst0 does not share Sefo nodes with sefo.
3086	*/
3087	localstatic Sefo
3088	sefoSubst0(AbSub sigma, Sefo sefo)
3089	{
3090	Sefo final;
3091	extern Bool stabDumbImport(void);
3092
3093	assert(sefo)do { if (!(sefo)) _do_assert(("sefo"),"sefo.c",3093); } while (0);
3094
3095	if (DEBUG(sefoSubst)sefoSubstDebug) {
3096	fprintf(dbOut, "-> sefoSubst[%ld]:\n", absSerial(sigma)((sigma)->serialNo));
3097	sefoPrintDb(sefo);
3098	}
3099
3100	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
3101	Syme syme = abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 );
3102
3103	/!! assert(syme); /
3104	if (!syme)
3105	return sefoCopy(sefo);
3106
3107	final = absLookup(syme, sefo, sigma);
3108	/* If absLookup fails, walk the syme. */
3109	if (final == sefo) {
3110	final = sefoCopy(final);
3111	abSetSyme(final, symeSubst0(sigma, syme));
3112	}
3113	else
3114	final = sefoCopy(final);
3115	}
3116	else {
3117	Length i;
3118	final = abNewEmpty(abTag(sefo)((sefo)->abHdr.tag), abArgc(sefo)((sefo)->abHdr.argc));
3119	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i++)
3120	abArgv(final)((final)->abGen.data.argv)[i] = sefoSubst0(sigma, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
3121
3122	#ifdef SefoSubstTUnique
3123	/*!! This may have weaker semantics than we need.
3124	*!! Instead of creating the semantics on the resulting form,
3125	*!! which may yield more information, we are just
3126	*!! using the semantics on the unsubstituted form.
3127	*/
3128	if (abState(sefo)((sefo)->abHdr.state) == AB_State_HasUnique) {
3129	abState(final)((final)->abHdr.state) = abState(sefo)((sefo)->abHdr.state);
3130	abTUnique(final)((final)->abHdr.type.unique) = tformSubst0(sigma,abTUnique(sefo)((sefo)->abHdr.type.unique));
3131	}
3132
3133
3134	/* Copy semantics if they have some and we don't */
3135	if (abTForm(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0 ) && !abTForm(final)((final)->abHdr.seman ? (final)->abHdr.seman->tform : 0) && !stabDumbImport()) {
3136	/*
3137	* Really not sure about this: without it we
3138	* fail to process conditional imports
3139	* correctly after calling tfDefineeBaseType()
3140	* in stabImportFrom(). The final tform
3141	* should be the substituted version, which
3142	* hopefully won't cause too much recursion.
3143	*/
3144	abSetTForm(final, tformSubst0(sigma, abTForm(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0 )));
3145	}
3146	if (abSelf(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->self : 0 ))
3147	abSetSelf(final, abSelf(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->self : 0 ));
3148	#else
3149	if (abState(sefo)((sefo)->abHdr.state) == AB_State_HasUnique)
3150	abState(final)((final)->abHdr.state) = AB_State_AbSyn;
3151	#endif
3152	}
3153
3154	if (DEBUG(sefoSubst)sefoSubstDebug) {
3155	fprintf(dbOut, "<- sefoSubst[%ld]:\n", absSerial(sigma)((sigma)->serialNo));
3156	sefoPrintDb(final);
3157	}
3158
3159	return final;
3160	}
3161
3162	localstatic Bool
3163	tformSubstSkipCategory(TForm tf)
3164	{
3165	if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) \|\| (((tf)->tag) == TF_PackedMap ))) tf = tfMapRet(tf)tfFollowArg(tf, 1);
3166	tf = tfDefineeTypeSubst(tf);
3167
3168	/!! The first if clause is really not quite right. /
3169	if (tfIsType(tf)(((tf)->tag) == TF_Type) \|\| tfIsTypeSyntax(tf)((((tf)->tag) == TF_Syntax) && (((((tf)->__absyn ))->abHdr.tag == (AB_Id)) && ((((tf)->__absyn)) ->abId.sym)==(ssymType))) \|\| tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
3170	return true1;
3171
3172	if (tfIsCategory(tf)(((tf)->tag) == TF_Category) \|\| tfIsCategorySyntax(tf)((((tf)->tag) == TF_Syntax) && (((((tf)->__absyn ))->abHdr.tag == (AB_Id)) && ((((tf)->__absyn)) ->abId.sym)==(ssymCategory))) \|\| tfIsThird(tf)(((tf)->tag) == TF_Third))
3173	return true1;
3174
3175	return false((int) 0);
3176	}
3177
3178	localstatic Bool
3179	tformSubstSkipDomain(TForm tf)
3180	{
3181	if (tfIsAnyMap(tf)((((tf)->tag) == TF_Map) \|\| (((tf)->tag) == TF_PackedMap ))) tf = tfMapRet(tf)tfFollowArg(tf, 1);
3182	tf = tfDefineeTypeSubst(tf);
3183
3184	/!! The first if clause is really not quite right. /
3185	if (tfIsType(tf)(((tf)->tag) == TF_Type) \|\| tfIsTypeSyntax(tf)((((tf)->tag) == TF_Syntax) && (((((tf)->__absyn ))->abHdr.tag == (AB_Id)) && ((((tf)->__absyn)) ->abId.sym)==(ssymType))) \|\| tfIsSyntax(tf)(((tf)->tag) == TF_Syntax))
3186	return true1;
3187
3188	if (tfIsWith(tf)(((tf)->tag) == TF_With) \|\| tfIsWithSyntax(tf)((((tf)->tag) == TF_Syntax) && ((((tf)->__absyn ))->abHdr.tag == (AB_With))) \|\| tfIsIf(tf)(((tf)->tag) == TF_If) \|\|
3189	tfIsJoin(tf)(((tf)->tag) == TF_Join) \|\| tfIsMeet(tf)(((tf)->tag) == TF_Meet))
3190	return true1;
3191
3192	if (tfIsCategory(tf)(((tf)->tag) == TF_Category) \|\| tfIsCategorySyntax(tf)((((tf)->tag) == TF_Syntax) && (((((tf)->__absyn ))->abHdr.tag == (AB_Id)) && ((((tf)->__absyn)) ->abId.sym)==(ssymCategory))) \|\| tfIsThird(tf)(((tf)->tag) == TF_Third))
3193	return true1;
3194
3195	if (tfIsId(tf)((((tf)->tag) == TF_General) && ((((tf)->__absyn ))->abHdr.tag) == AB_Id) && tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))-> abHdr.seman->syme : 0) &&
3196	tformSubstSkipCategory(symeType(tfIdSyme(tf)((((tf)->__absyn))->abHdr.seman ? (((tf)->__absyn))-> abHdr.seman->syme : 0))))
3197	return true1;
3198
3199	return false((int) 0);
3200	}
3201
3202	localstatic Syme
3203	symeSubst0(AbSub sigma, Syme syme)
3204	{
3205	Syme final;
3206	Bool marked;
3207
3208	assert(syme)do { if (!(syme)) _do_assert(("syme"),"sefo.c",3208); } while (0);
3209
3210	final = absGetSyme(sigma, syme);
3211	marked = absSymeIsMarked(sigma, syme);
3212	if (final && !marked) {
3213	if (symeIsTwin(final, syme))
3214	return absSetSyme(sigma, syme,
3215	symeSubst0(sigma, final));
3216	return final;
3217	}
3218
3219	if (!symeWillSubst(sigma, syme))
3220	return absSetSyme(sigma, syme, syme);
3221
3222	if (symeWillPush(syme)) symeType(syme);
3223	final = absSetSyme(sigma, syme, symeCopy(syme));
3224	absSetStab(sigma, final);
3225
3226	if (DEBUG(sefoSubst)sefoSubstDebug) {
3227	fprintf(dbOut, "-> symeSubst[%ld]:\n", absSerial(sigma)((sigma)->serialNo));
3228	symePrintDb(syme);
3229	}
3230
3231	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import)) {
3232	symeSetExporter(final, tformSubst0(sigma, symeExporter(syme)))(symeSetFieldVal = ((AInt) (tformSubst0(sigma, symeExporter(syme )))), (((((final)->kind == SYME_Trigger ? libGetAllSymes(( final)->lib) : ((void*)0)), (final))->locmask) & (1 << (SYFI_Exporter))) ? (((final)->fieldv)[symeIndex (final,SYFI_Exporter)] = (symeSetFieldVal)) : !((final)->full ) && symeSetFieldVal == (symeFieldInfo[SYFI_Exporter] .def) ? symeSetFieldVal : symeSetFieldFn(final,SYFI_Exporter, symeSetFieldVal));
3233	#define SefoSubstImportType
3234	#ifdef SefoSubstImportType
3235	if (tformWillSubst(sigma, symeType(syme)))
3236	symeSetType(final, tformSubst0(sigma, symeType(syme)));
3237	#endif
3238	}
3239
3240	else if (absSelf(sigma)((sigma)->self) && !symeIsSelf(syme)(((syme)->id) == ssymSelf) && !marked &&
3241	tformSubstSkipDomain(symeType(syme)))
3242	;
3243
3244	else if (!symeIsSelf(syme)(((syme)->id) == ssymSelf) && symeDefLevelIsSubstable(syme)(symeDefLevel(syme)->isSubstable))
3245	symeSetType(final, tformSubst0(sigma, symeType(syme)));
3246
3247	if (symeCondition(syme))
3248	symeSetCondition(final,
3249	condListSubst0(sigma, symeCondition(syme)));
3250
3251	if (DEBUG(sefoSubst)sefoSubstDebug) {
3252	fprintf(dbOut, "<- symeSubst[%ld]: ", absSerial(sigma)((sigma)->serialNo));
3253	symePrintDb(final);
3254	}
3255
3256	return final;
3257	}
3258
3259	localstatic TForm
3260	tformSubst0(AbSub sigma, TForm tf)
3261	{
3262	TForm final;
3263	Bool lazy = absLazy(sigma)((sigma)->lazy);
3264	Bool fresh = true1;
3265	Bool cascade = false((int) 0);
3266	AbSyn abnew;
3267	Length i;
3268	SymeList symes;
3269
3270	assert(tf)do { if (!(tf)) _do_assert(("tf"),"sefo.c",3270); } while (0);
3271	absSetLazy(sigma)((sigma)->lazy = 1);
3272
3273	tf = tfFollowOnly(tf);
3274	if (tfIsDefine(tf)(((tf)->tag) == TF_Define) && tfIsWith(tfDefineVal(tf))(((tfFollowArg(tf, 1))->tag) == TF_With))
3275	tf = tfDefineeType(tf);
3276
3277	final = absGetTForm(sigma, tf);
3278	if (final && (!tfIsSubstOf(tf, final)((((final)->tag) == TF_Subst) && tfFollowArg(final , 0) == (tf)) \|\| lazy)) return final;
3279
3280	sefoSubstDEBUGif (!sefoSubstDebug) { } else afprintf(dbOut, "(-> tformSubst[%ld]: %pTForm\n",
3281	absSerial(sigma)((sigma)->serialNo), tf);
3282
3283	if (!lazy) tfFollow(tf)((tf) = tfFollowFn(tf));
3284
3285	if (tfFVars(tf)((tf)->fv) && !fvHasAbSub(tfFVars(tf)((tf)->fv), sigma)) {
3286	final = absSetTForm(sigma, tf, tf);
3287	fresh = false((int) 0);
3288	}
3289	else if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT)) {
3290	final = absSetTForm(sigma, tf, tf);
3291	fresh = false((int) 0);
3292	}
3293	else if (tfIsPending(tf)(((tf)->state)==TF_State_Pending)) {
3294	/!! May need to print an error message here. /
3295	final = absSetTForm(sigma, tf, tf);
3296	fresh = false((int) 0);
3297	}
3298	else if (tfIsLibrary(tf) \|\| tfIsArchive(tf)) {
3299	final = absSetTForm(sigma, tf, tf);
3300	fresh = false((int) 0);
3301	}
3302	else if (lazy) {
3303	final = tfSubst(sigma, tf);
3304	fresh = false((int) 0);
3305	}
3306	else if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_ABSYN_LIMIT)) {
3307	TForm tfnew;
3308
3309	final = absSetTForm(sigma, tf, tfNewEmpty(TF_Forward, 1));
3310	final->argv[0] = tf;
3311
3312	abnew = sefoSubst0(sigma, tfGetExpr(tf)((tf)->__absyn));
3313	#if SefoSubstShare
3314	tfnew = tfFullFrAbSyn(absStab(sigma)((sigma)->stab), abnew);
3315	#else
3316	tfnew = tfMeaning(absStab(sigma)((sigma)->stab), abnew,
3317	tfPending(absStab(sigma)((sigma)->stab), abnew));
3318	#endif
3319	fresh = (tfGetExpr(tfnew)((tfnew)->__absyn) == abnew);
3320
3321	if (fresh) tfOwnExpr(tfnew);
3322
3323	final->argv[0] = tfnew;
3324	final = tfFollowOnly(final);
3325	}
3326	else if (tfIsWith(tf)(((tf)->tag) == TF_With)) {
3327	final = tfNewEmpty(tfTag(tf)((tf)->tag), tfArgc(tf)((tf)->argc));
3328	final = absSetTForm(sigma, tf, final);
3329	tfArgv(final)((final)->argv)[0] = tfNone()tfMulti(0);
3330	tfArgv(final)((final)->argv)[1] = tfNone()tfMulti(0);
3331	symes = tfGetCatParents(tf, true1);
3332	if (symes) {
3333	tfGetCatSelf(tf);
3334	tfParents(final)((final)->parents) = parentListSubst0(sigma, symes);
3335	if (tfCatExports(tf))
3336	tfSetCatExports(final, listCopy(Syme)(Syme_listPointer->Copy)(tfParents(final)((final)->parents)));
3337	tfCascades(final)((final)->cascades) =
3338	tqualListSubst0(sigma, tfGetCatCascades(tf));
3339	tfHasCascades(final)((final)->hasCascades) = true1;
3340	cascade = true1;
3341	tfAuditExportList(tfParents(final)((final)->parents));
3342	}
3343	else {
3344	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
3345	tfArgv(final)((final)->argv)[i] =
3346	tformSubst0(sigma, tfArgv(tf)((tf)->argv)[i]);
3347	}
3348	tfSetMeaning(final)(((final)->state)=TF_State_Meaning);
3349	}
3350	else if (tfIsThird(tf)(((tf)->tag) == TF_Third)) {
3351	final = tfNewEmpty(tfTag(tf)((tf)->tag), tfArgc(tf)((tf)->argc));
3352	final = absSetTForm(sigma, tf, final);
3353	tfArgv(final)((final)->argv)[0] = tfNone()tfMulti(0);
3354	symes = tfGetThdParents(tf);
3355	if (symes) {
3356	tfGetThdSelf(tf);
3357	tfParents(final)((final)->parents) = parentListSubst0(sigma, symes);
3358	tfCascades(final)((final)->cascades) =
3359	tqualListSubst0(sigma, tfGetCatCascades(tf));
3360	tfHasCascades(final)((final)->hasCascades) = true1;
3361	cascade = true1;
3362	tfAuditExportList(tfParents(final)((final)->parents));
3363	}
3364	else {
3365	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
3366	tfArgv(final)((final)->argv)[i] =
3367	tformSubst0(sigma, tfArgv(tf)((tf)->argv)[i]);
3368	}
3369	tfSetMeaning(final)(((final)->state)=TF_State_Meaning);
3370	}
3371	else if (tfIsRecord(tf)(((tf)->tag) == TF_Record) && tfRecordArgc(tf) == 1) {
3372	TForm tf0, tfnew;
3373	Length argc;
3374
3375	final = absSetTForm(sigma, tf, tfNewEmpty(TF_Forward, 1));
3376	final->argv[0] = tf;
3377
3378	tf0 = tformSubst0(sigma, tfArgv(tf)((tf)->argv)[0]);
3379	argc = tfAsMultiArgc(tf0);
3380	tfnew = tfNewEmpty(tfTag(tf)((tf)->tag), argc);
3381	for (i = 0; i < argc; i += 1)
3382	tfArgv(tfnew)((tfnew)->argv)[i] = tfAsMultiArgN(tf0, argc, i);
3383	tfGetSymes(absStab(sigma)((sigma)->stab), tfnew, tfExpr(tfnew)tfToAbSyn(tfnew));
3384	tfSetMeaning(tfnew)(((tfnew)->state)=TF_State_Meaning);
3385
3386	final->argv[0] = tfnew;
3387	final = tfFollowOnly(final);
3388	}
3389	else if (tfIsRawRecord(tf)(((tf)->tag) == TF_RawRecord) && tfRawRecordArgc(tf) == 1) {
3390	/*
3391	* Don't know if we need this or not.
3392	* Don't know if having it will break things.
3393	*/
3394	TForm tf0, tfnew;
3395	Length argc;
3396
3397	final = absSetTForm(sigma, tf, tfNewEmpty(TF_Forward, 1));
3398	final->argv[0] = tf;
3399
3400	tf0 = tformSubst0(sigma, tfArgv(tf)((tf)->argv)[0]);
3401	argc = tfAsMultiArgc(tf0);
3402	tfnew = tfNewEmpty(tfTag(tf)((tf)->tag), argc);
3403	for (i = 0; i < argc; i += 1)
3404	tfArgv(tfnew)((tfnew)->argv)[i] = tfAsMultiArgN(tf0, argc, i);
3405	tfGetSymes(absStab(sigma)((sigma)->stab), tfnew, tfExpr(tfnew)tfToAbSyn(tfnew));
3406	tfSetMeaning(tfnew)(((tfnew)->state)=TF_State_Meaning);
3407
3408	final->argv[0] = tfnew;
3409	final = tfFollowOnly(final);
3410	}
3411	else if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_NODE_LIMIT)) {
3412	final = tfNewEmpty(tfTag(tf)((tf)->tag), tfArgc(tf)((tf)->argc));
3413	final = absSetTForm(sigma, tf, final);
3414	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1)
3415	tfArgv(final)((final)->argv)[i] =
3416	tformSubst0(sigma, tfArgv(tf)((tf)->argv)[i]);
3417	tfSetMeaning(final)(((final)->state)=TF_State_Meaning);
3418	}
3419	else {
3420	bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag) , 3420, "sefo.c");
3421	}
3422
3423	if (!fresh) {
3424	sefoSubstDEBUGif (!sefoSubstDebug) { } else afprintf(dbOut, " <- tformSubst[%ld]: %pTForm)\n",
3425	absSerial(sigma)((sigma)->serialNo), final);
3426	return final;
3427	}
3428
3429	if (tfSymes(tf)((tf)->symes) && !tfSymes(final)((final)->symes))
3430	tfSetSymes(final, symeListSubst0(sigma, tfSymes(tf)))((final)->symes = (symeListSubst0(sigma, ((tf)->symes)) ));
3431
3432	if (tfQueries(tf)((tf)->queries))
3433	tfSetQueries(final,(((final)->queries) = (tformListSubst0(sigma, ((tf)->queries ))))
3434	tformListSubst0(sigma, tfQueries(tf)))(((final)->queries) = (tformListSubst0(sigma, ((tf)->queries ))));
3435	if (!cascade && tfCascades(tf)((tf)->cascades)) {
3436	tfSetCascades(final,(((final)->cascades) = (tqualListSubst0(sigma, ((tf)->cascades ))))
3437	tqualListSubst0(sigma, tfCascades(tf)))(((final)->cascades) = (tqualListSubst0(sigma, ((tf)->cascades ))));
3438	tfHasCascades(final)((final)->hasCascades) = true1;
3439	}
3440
3441	if (tfGetStab(tf))
3442	tfSetStab(final, tfStab(tf))((final)->stab = (((tf)->stab)));
3443
3444	if (tfSelf(tf)((tf)->self)) {
3445	SymeList ssymes;
3446	ssymes = listCopy(Syme)(Syme_listPointer->Copy)(tfSelf(tf)((tf)->self));
3447	tfSetSelf(final, ssymes)((final)->self = (ssymes));
3448	tfHasSelf(final)((final)->hasSelf) = tfHasSelf(tf)((tf)->hasSelf);
3449	}
3450	if (tfFVars(tf)((tf)->fv)) {
3451	tfSetFVars(final, freeVarSubst0(sigma, tfFVars(tf)))(((final)->fv) = (freeVarSubst0(sigma, ((tf)->fv))));
3452	sefoFreeDEBUGif (!sefoFreeDebug) { } else afprintf(dbOut, "FV(subst) %pTForm = %pFreeVar\n",
3453	final, final->fv);
3454	}
3455	if (tfHasExpr(final)((final)->__absyn != 0)) tfSetNeedsSefo(final)((final)->state = (((final)->state)>=TF_State_Meaning ) ? TF_State_NeedsSefo : (final)->state);
3456
3457	sefoSubstDEBUGif (!sefoSubstDebug) { } else afprintf(dbOut, "<- tformSubst[%ld]: %pTForm)\n",
3458	absSerial(sigma)((sigma)->serialNo), final);
3459
3460	return final;
3461	}
3462
3463	localstatic TQual
3464	tqualSubst0(AbSub sigma, TQual tq)
3465	{
3466	return tqNewFrList(tformSubst0(sigma, tqBase(tq)((tq)->base)),
3467	tformListSubst0(sigma, tqQual(tq)((tq)->qual)));
3468	}
3469
3470	localstatic FreeVar
3471	freeVarSubst0(AbSub sigma, FreeVar fv)
3472	{
3473	FreeVar fv0 = absFVars(sigma)((sigma)->fv);
3474	SymeList symes, final;
3475
3476	if (fvSymes(fv)((fv)->symes) == listNil(Syme)((SymeList) 0))
3477	return fv0;
3478
3479	final = listReverse(Syme)(Syme_listPointer->Reverse)(fvSymes(fv0)((fv0)->symes));
3480	for (symes = fvSymes(fv)((fv)->symes); symes; symes = cdr(symes)((symes)->rest)) {
3481	Syme syme = car(symes)((symes)->first);
3482	if (absLookup(syme, NULL((void*)0), sigma))
3483	continue;
3484	syme = symeSubst0(sigma, syme);
3485	if (!fvHasSyme(fv0, syme))
3486	final = listCons(Syme)(Syme_listPointer->Cons)(syme, final);
3487	}
3488	final = listNReverse(Syme)(Syme_listPointer->NReverse)(final);
3489	return fvFrSymes(final);
3490	}
3491
3492	/* Make sure that the symes are not going to be stomped on. */
3493	localstatic SymeList
3494	parentListSubst0(AbSub sigma, SymeList symes)
3495	{
3496	if (absSelf(sigma)((sigma)->self))
3497	return listCopy(Syme)(Syme_listPointer->Copy)(symes);
3498	else
3499	return symeListSubst0(sigma, symes);
3500	}
3501
3502	localstatic SefoList
3503	condListSubst0(AbSub sigma, SefoList conds)
3504	{
3505	Bool self = absSelf(sigma)((sigma)->self);
3506	SefoList final = listNil(Sefo)((SefoList) 0);
3507
3508	for (; conds; conds = cdr(conds)((conds)->rest)) {
3509	Sefo cond = car(conds)((conds)->first);
3510	Sefo expr, prop;
3511
3512	if (abHasTag(cond, AB_Has)((cond)->abHdr.tag == (AB_Has))) {
3513	expr = car(conds)((conds)->first)->abHas.expr;
3514	prop = car(conds)((conds)->first)->abHas.property;
3515
3516	expr = sefoSubst0(sigma, expr);
3517	prop = self ? sefoCopy(prop) : sefoSubst(sigma, prop);
3518
3519	cond = abNewHas(sposNone, expr, prop)abNew(AB_Has, sposNone,2, expr,prop);
3520	}
3521	else
3522	cond = sefoSubst0(sigma, cond);
3523
3524	final = listCons(Sefo)(Sefo_listPointer->Cons)(cond, final);
3525	}
3526
3527	return listNReverse(Sefo)(Sefo_listPointer->NReverse)(final);
3528	}
3529
3530	localstatic SymeList
3531	symeListSubst0(AbSub sigma, SymeList symes)
3532	{
3533	SymeList final = listNil(Syme)((SymeList) 0);
3534
3535	for (; symes; symes = cdr(symes)((symes)->rest))
3536	final = listCons(Syme)(Syme_listPointer->Cons)(symeSubst0(sigma, car(symes)((symes)->first)),
3537	final);
3538
3539	return listNReverse(Syme)(Syme_listPointer->NReverse)(final);
3540	}
3541
3542	localstatic TFormList
3543	tformListSubst0(AbSub sigma, TFormList tforms)
3544	{
3545	TFormList final = listNil(TForm)((TFormList) 0);
3546
3547	for (; tforms; tforms = cdr(tforms)((tforms)->rest))
3548	final = listCons(TForm)(TForm_listPointer->Cons)(tformSubst0(sigma, car(tforms)((tforms)->first)),
3549	final);
3550
3551	return listNReverse(TForm)(TForm_listPointer->NReverse)(final);
3552	}
3553
3554	localstatic TQualList
3555	tqualListSubst0(AbSub sigma, TQualList tquals)
3556	{
3557	TQualList final = listNil(TQual)((TQualList) 0);
3558
3559	for (; tquals; tquals = cdr(tquals)((tquals)->rest))
3560	final = listCons(TQual)(TQual_listPointer->Cons)(tqualSubst0(sigma, car(tquals)((tquals)->first)),
3561	final);
3562
3563	return listNReverse(TQual)(TQual_listPointer->NReverse)(final);
3564	}
3565
3566	/* Return true if symeSubst0 must explicitly push a lazy syme. */
3567	localstatic Bool
3568	symeWillPush(Syme syme)
3569	{
3570	Bool result = false((int) 0);
3571
3572	if (symeIsLazy(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) & (0x0001))) {
3573	switch (symeKind(syme)((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind)) {
3574	case SYME_Export:
3575	case SYME_Param:
3576	if (symeDefLevelIsSubstable(syme)(symeDefLevel(syme)->isSubstable))
3577	result = true1;
3578	break;
3579	case SYME_Import: {
3580	TForm exporter = symeExporter(syme);
3581	if (!tfIsLazyExporter(exporter)(tfIsLibrary(exporter) \|\| tfIsArchive(exporter) \|\| (((((exporter )->tag) == TF_General) && ((((exporter)->__absyn ))->abHdr.tag) == AB_Id) && (((exporter)->__absyn )->abId.sym) == (ssymSelf))))
3582	result = true1;
3583	break;
3584	}
3585	default:
3586	break;
3587	}
3588	}
3589
3590	return result;
3591	}
3592
3593	/* Return true if symeSubst0 will create a new syme. */
3594	localstatic Bool
3595	symeWillSubst(AbSub sigma, Syme syme)
3596	{
3597	assert(syme)do { if (!(syme)) _do_assert(("syme"),"sefo.c",3597); } while (0);
3598
3599	if (symeCondition(syme))
3600	return true1;
3601	else if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import) &&
3602	tformWillSubst(sigma, symeExporter(syme)))
3603	return true1;
3604	else if (!symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import) &&
3605	absSelf(sigma)((sigma)->self) && !symeIsSelf(syme)(((syme)->id) == ssymSelf) &&
3606	!absSymeIsMarked(sigma, syme) &&
3607	tformSubstSkipDomain(symeType(syme)))
3608	return false((int) 0);
3609	else if (!symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import) &&
3610	!symeIsSelf(syme)(((syme)->id) == ssymSelf) &&
3611	symeDefLevelIsSubstable(syme)(symeDefLevel(syme)->isSubstable) &&
3612	tformWillSubst(sigma, symeType(syme)))
3613	return true1;
3614	else
3615	return false((int) 0);
3616	}
3617
3618	/* Return true if tformSubst0 will create a new tform. */
3619	localstatic Bool
3620	tformWillSubst(AbSub sigma, TForm tf)
3621	{
3622	TForm final;
3623
3624	assert(tf)do { if (!(tf)) _do_assert(("tf"),"sefo.c",3624); } while (0);
3625
3626	tf = tfFollowOnly(tf);
3627
3628	final = absGetTForm(sigma, tf);
3629	if (final && (!tfIsSubstOf(tf, final)((((final)->tag) == TF_Subst) && tfFollowArg(final , 0) == (tf)) \|\| absLazy(sigma)((sigma)->lazy)))
3630	return tf != final;
3631
3632	if (tfFVars(tf)((tf)->fv) && !fvHasAbSub(tfFVars(tf)((tf)->fv), sigma))
3633	return false((int) 0);
3634
3635	else if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT))
3636	return false((int) 0);
3637
3638	else if (tfIsLibrary(tf) \|\| tfIsArchive(tf))
3639	return false((int) 0);
3640
3641	else if (tfIsPending(tf)(((tf)->state)==TF_State_Pending))
3642	return false((int) 0);
3643
3644	else
3645	return true1;
3646	}
3647
3648	/*****************************************************************************
3649	*
3650	* :: symeListClosure
3651	*
3652	****************************************************************************/
3653
3654	localstatic void sefoClosureReleaseType (Sefo);
3655	/*
3656	* External entry points.
3657	*/
3658
3659	Bool
3660	symeCloseOverDetails(Syme syme)
3661	{
3662	if (symeIsLibrary(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Library) \|\| symeIsArchive(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Archive))
3663	return false((int) 0);
3664
3665	if (symeLib(syme)((syme)->lib) == NULL((void*)0))
3666	return true1;
3667
3668	if (symeConstLib(syme) == NULL((void*)0))
3669	return true1;
3670
3671	if (symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Export)
3672	&& symeConstLib(symeOriginal(syme)) != symeConstLib(syme)
3673	&& symeConstNum(syme)(((AInt) (SYFI_ConstInfo < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_ConstInfo ))) ? (symeFieldInfo[SYFI_ConstInfo].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0 )), (syme))->locmask) & (1 << (SYFI_ConstInfo))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme )->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_ConstInfo))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ConstInfo )] : (symeFieldInfo[SYFI_ConstInfo].def)) : symeGetFieldFn(syme ,SYFI_ConstInfo))) & 0xFFFF) != SYME_NUMBER_UNASSIGNED(0x7FFF))
3674	return true1;
3675
3676	if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Extend) && syme->lib != NULL((void)0))
3677	return false((int) 0);
3678
3679	if (symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Export) \|\| symeIsParam(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Param) \|\| symeIsSelf(syme)(((syme)->id) == ssymSelf))
3680	return false((int) 0);
3681
3682	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import)) {
3683	TForm exporter = symeExporter(syme);
3684	if (tfIsLazyExporter(exporter)(tfIsLibrary(exporter) \|\| tfIsArchive(exporter) \|\| (((((exporter )->tag) == TF_General) && ((((exporter)->__absyn ))->abHdr.tag) == AB_Id) && (((exporter)->__absyn )->abId.sym) == (ssymSelf))))
3685	return false((int) 0);
3686	}
3687
3688	return true1;
3689	}
3690
3691	void
3692	symeListClosure(Lib lib, SymeList symes)
3693	{
3694	SymeList sl0, sl;
3695
3696	if (DEBUG(sefoClose)sefoCloseDebug) {
3697	fprintf(dbOut, "symeListClosure: %d symes", (int) listLength(Syme)(Syme_listPointer->_Length)(symes));
3698	fnewline(dbOut);
3699	symeListPrintDb(symes);
3700	}
3701
3702	lib->topc = 0;
3703	lib->symec = 0;
3704	lib->symes = 0;
3705	lib->symev = 0;
3706
3707	lib->typec = 0;
3708	lib->types = 0;
3709	lib->typev = 0;
3710
3711	/* Collect the symes and types, putting the original list first. */
3712	sstNext("symeListClosure", lib, symes){ if (sstDebug) { sstNextDB("symeListClosure", (Pointer)(lib) , (Pointer)(symes)); } sstNext0(); };
3713	for (sl = symes; sl; sl = cdr(sl)((sl)->rest))
3714	slcAddSyme(lib, car(sl)((sl)->first));
3715	sl0 = lib->symes;
3716	for (sl = sl0; sl; sl = cdr(sl)((sl)->rest))
3717	symeClosure1(lib, car(sl)((sl)->first));
3718	sstDoneSymeList(sl0){ ; { sstDone0(); if (sstDebug) { sstDoneDB(); } }; };
3719
3720	/* Cache the symes/types in the lib. */
3721	lib->symes = listNReverse(Syme)(Syme_listPointer->NReverse)(lib->symes);
3722	lib->types = listNReverse(TForm)(TForm_listPointer->NReverse)(lib->types);
3723
3724	sefoCloseDEBUGif (!sefoCloseDebug) { } else afprintf(dbOut, " -> %d symes\n",
3725	(int) listLength(Syme)(Syme_listPointer->_Length)(lib->symes));
3726	}
3727
3728	/*
3729	* Local functions.
3730	*/
3731
3732	localstatic void
3733	slcAddSyme(Lib lib, Syme syme)
3734	{
3735	if (sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0))))
3736	return;
3737
3738	sstMarkSyme(syme);
3739	lib->symes = listCons(Syme)(Syme_listPointer->Cons)(syme, lib->symes);
3740	lib->symec += 1;
3741	if (libSymeIsTop(lib, syme)) lib->topc += 1;
3742
3743	sefoCloseDEBUGif (!sefoCloseDebug) { } else afprintf(dbOut, "+syme: [%d] %pSyme\n", symeHash(syme)((syme)->hash), syme);
3744	}
3745
3746	localstatic void
3747	slcAddType(Lib lib, TForm tf)
3748	{
3749	lib->types = listCons(TForm)(TForm_listPointer->Cons)(tf, lib->types);
3750	lib->typec += 1;
3751
3752	sefoCloseDEBUGif (!sefoCloseDebug) { } else afprintf(dbOut, "+type: %pTForm\n", tf);
3753	}
3754
3755	localstatic void
3756	sefoClosure0(Lib lib, Sefo sefo)
3757	{
3758	Length serial = 0;
3759
3760	assert(sefo)do { if (!(sefo)) _do_assert(("sefo"),"sefo.c",3760); } while (0);
3761
3762	sstSerialDebug += 1;
3763	serial = sstSerialDebug;
3764
3765	if (DEBUG(sefoClose)sefoCloseDebug) {
3766	fprintf(dbOut, "(S ");
3767	sefoPrintDb(sefo);
3768	}
3769
3770	if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
3771	if (abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ))
3772	symeClosure0(lib, abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
3773	if (abImplicit(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->implicit : 0))
3774	sefoClosure0(lib, abImplicit(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->implicit : 0));
3775	}
3776	else {
3777	Length i;
3778	for (i = 0; i < abArgc(sefo)((sefo)->abHdr.argc); i += 1)
3779	sefoClosure0(lib, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
3780	if (abState(sefo)((sefo)->abHdr.state) == AB_State_HasUnique) {
3781	#ifdef Bug1075
3782	abState(sefo)((sefo)->abHdr.state) = AB_State_AbSyn;
3783	#endif
3784	sefoClosureReleaseType(sefo);
3785	}
3786	}
3787
3788	if (abTag(sefo)((sefo)->abHdr.tag) == AB_With) {
3789	symeListClosure0(lib, tfSelf(abTForm(sefo))((((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0))->self));
3790	tformClosure0(lib, abTForm(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0 ));
3791	}
3792
3793	if (DEBUG(sefoClose)sefoCloseDebug) {
3794	fprintf(dbOut, " S)");
3795	sefoPrintDb(sefo);
3796	}
3797	}
3798
3799	localstatic void
3800	sefoClosureReleaseType(Sefo sefo)
3801	{
3802	abTUnique(sefo)((sefo)->abHdr.type.unique) = tfUnknown;
3803	}
3804
3805	/*
3806	* Close using the given syme as a root, adding it to the lib.
3807	*/
3808	localstatic void
3809	symeClosure0(Lib lib, Syme syme)
3810	{
3811	if (sstSymeIsMarked(syme)(sstMarkDepth == 1 ? ((SefoMark) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))-> locmask) & (1 << (SYFI_Mark))) ? ((syme)->fieldv )[symeIndex(syme,SYFI_Mark)] : (symeFieldInfo[SYFI_Mark].def) )) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable , (Pointer) (syme), ((void)0))))
3812	return;
3813
3814	slcAddSyme(lib, syme);
3815	symeClosure1(lib, syme);
3816	}
3817
3818	/*
3819	* Close using the given syme as a root, even though it is marked already.
3820	*/
3821	localstatic void
3822	symeClosure1(Lib lib, Syme syme)
3823	{
3824	Length serial = 0;
3825	Syme extension = NULL((void*)0);
3826	SymeList extendee = NULL((void*)0), symes;
3827	Bool details = symeCloseOverDetails(syme);
3828
3829	sstSerialDebug += 1;
3830	serial = sstSerialDebug;
3831
3832	if (DEBUG(sefoClose)sefoCloseDebug) {
3833	fprintf(dbOut, "([%d]:\t", (int) serial);
3834	symePrintDb(syme);
3835	if (sstSerialDebug % 25 == 0)
3836	fprintf(dbOut, "\n");
3837	}
3838
3839	assert(syme)do { if (!(syme)) _do_assert(("syme"),"sefo.c",3839); } while (0);
3840	if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Extend)) {
3841	if (symeExtension(syme))
3842	symeClosure0(lib, symeExtension(syme));
3843	extension = syme;
3844	extendee = symeExtendee(extension);
3845	}
3846	else if (symeExtension(syme)) {
3847	extension = symeExtension(syme);
3848	if (symeIsExtend(extension)(((((extension)->kind == SYME_Trigger ? libGetAllSymes((extension )->lib) : ((void*)0)), (extension))->kind) == SYME_Extend ))
3849	extendee = symeExtendee(extension);
3850	}
3851	for (symes = extendee; details && symes; symes = cdr(symes)((symes)->rest))
3852	slcAddSyme(lib, car(symes)((symes)->first));
3853	symeListSetExtension(extendee, NULL((void*)0));
3854	symeSetExtension(syme, NULL)symeXSetExtension(syme, (AInt) ((void*)0));
3855
3856	if (symeLib(syme)((syme)->lib))
3857	symeClosure0(lib, libLibrarySyme(symeLib(syme)((syme)->lib)));
3858	if (symeConstLib(syme))
3859	symeClosure0(lib, libLibrarySyme(symeConstLib(syme)));
3860
3861	if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import))
3862	tformClosure0(lib, symeExporter(syme));
3863	else if (details == false((int) 0))
3864	;
3865	else if (symeIsSelf(syme)(((syme)->id) == ssymSelf))
3866	tformClosure0(lib, tfType);
3867	else {
3868	TForm tf = symeType(syme);
3869	tformClosure0(lib, tf);
3870	if (symeTop(syme) && !tfIsAnyMap(tf)((((tf)->tag) == TF_Map) \|\| (((tf)->tag) == TF_PackedMap )) &&
3871	fvCount(tfFVars(tf))(Syme_listPointer->_Length)(((((tf)->fv))->symes)) > 1)
3872	fvSetSkipParam(tfFVars(tf))(((((tf)->fv))->skip) = 1);
3873	}
3874
3875	if (details) {
3876	sefoListClosure0(lib, symeCondition(syme));
3877	symeListClosure0(lib, symeTwins(syme));
3878
3879	if (!symeInlined(syme))
3880	symeSetInlined(syme, genGetSymeInlined(syme))(symeSetFieldVal = ((AInt) (genGetSymeInlined(syme))), (((((syme )->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_Inlined ))) ? (((syme)->fieldv)[symeIndex(syme,SYFI_Inlined)] = (symeSetFieldVal )) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_Inlined].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Inlined ,symeSetFieldVal));
3881
3882	if (symeInlined(syme))
3883	symeListClosure0(lib, symeInlined(syme));
3884
3885	if (extension)
3886	symeClosure0(lib, extension);
3887	for (symes = extendee; symes; symes = cdr(symes)((symes)->rest))
3888	symeClosure1(lib, car(symes)((symes)->first));
3889	}
3890
3891	symeListSetExtension(extendee, extension);
3892
3893	if (DEBUG(sefoClose)sefoCloseDebug) {
3894	fprintf(dbOut, " [%d])", (int) serial);
3895	symePrintDb(syme);
3896	}
3897
3898	return;
3899	}
3900
3901	localstatic void
3902	tformClosure0(Lib lib, TForm tf)
3903	{
3904	Length serial = 0;
3905	Bool cascade = false((int) 0);
3906
3907	assert(tf)do { if (!(tf)) _do_assert(("tf"),"sefo.c",3907); } while (0);
3908
3909	tfFollow(tf)((tf) = tfFollowFn(tf));
3910
3911	if (sstTFormIsMarked(tf)(sstMarkDepth == 1 ? ((tf)->__mark) == sstMarkRound : sstMarkTable && tblElt(sstMarkTable, (Pointer) (tf), ((void*)0))))
3912	return;
3913	sstMarkTForm(tf);
3914
3915	sstSerialDebug += 1;
3916	serial = sstSerialDebug;
	Value stored to 'serial' is never read
3917
3918	if (DEBUG(sefoClose)sefoCloseDebug) {
3919	fprintf(dbOut, "(T ");
3920	tformPrintDb(tf);
3921	}
3922
3923	if (tfFVars(tf)((tf)->fv) == NULL((void*)0))
3924	tformFreeVars(tf);
3925
3926	if (tfSatDom(tf)) {
3927	tfGetCatSelf(tf);
3928	tfGetCatSelfSelf(tf);
3929	}
3930
3931	if (tfIsWith(tf)(((tf)->tag) == TF_With) && tfUseCatExports(tf)(((((tfFollowArg(tf, 0))->tag) == TF_Multiple) && tfMultiArgc (tfFollowArg(tf, 0)) == 0) && ((((tfFollowArg(tf, 1)) ->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg( tf, 1)) == 0))) {
3932	SymeList catExports = tfGetCatExports(tf);
3933	symeListClosure0(lib, catExports);
3934	tqualListClosure0(lib, tfCascades(tf)((tf)->cascades));
3935	while (catExports != listNil(Syme)((SymeList) 0)) {
3936	sefoListClosure0(lib, symeCondition(car(catExports)((catExports)->first)));
3937	catExports = cdr(catExports)((catExports)->rest);
3938	}
3939	cascade = true1;
3940	}
3941	if (tfIsThird(tf)(((tf)->tag) == TF_Third) && tfUseThdExports(tf)(((((tfFollowArg(tf, 0))->tag) == TF_Multiple) && tfMultiArgc (tfFollowArg(tf, 0)) == 0))) {
3942	symeListClosure0(lib, tfGetThdExports(tf));
3943	tqualListClosure0(lib, tfCascades(tf)((tf)->cascades));
3944	cascade = true1;
3945	}
3946
3947	if (tfIsSym(tf)( (((tf)->tag)) < TF_SYM_LIMIT))
3948	;
3949	else if (tfIsAbSyn(tf)( TF_ABSYN_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_ABSYN_LIMIT)) {
3950	sefoClosure0(lib, tfGetExpr(tf)((tf)->__absyn));
3951	tfSetNeedsSefo(tf)((tf)->state = (((tf)->state)>=TF_State_Meaning) ? TF_State_NeedsSefo : (tf)->state);
3952	}
3953	else if (tfIsNode(tf)( TF_NODE_START <= (((tf)->tag)) && (((tf)-> tag)) < TF_NODE_LIMIT)) {
3954	Length i;
3955	for (i = 0; i < tfArgc(tf)((tf)->argc); i += 1) {
3956	tfFollow(tfArgv(tf)[i])((((tf)->argv)[i]) = tfFollowFn(((tf)->argv)[i]));
3957	tformClosure0(lib, tfArgv(tf)((tf)->argv)[i]);
3958	}
3959	}
3960	else
3961	bugBadCase(tfTag(tf))bug("Bad case %d (line %d in file %s).", (int) ((tf)->tag) , 3961, "sefo.c");
3962
3963	slcAddType(lib, tf);
3964
3965	if (tfSymes(tf)((tf)->symes))
3966	symeListClosure0(lib, tfSymes(tf)((tf)->symes));
3967	if (tfSelf(tf)((tf)->self))
3968	symeListClosure0(lib, tfSelf(tf)((tf)->self));
3969	if (tfSelfSelf(tf)((tf)->selfself))
3970	symeListClosure0(lib, tfSelfSelf(tf)((tf)->selfself));
3971	if (tfQueries(tf)((tf)->queries))
3972	tformListClosure0(lib, tfQueries(tf)((tf)->queries));
3973	if (!cascade && tfCascades(tf)((tf)->cascades))
3974	tqualListClosure0(lib, tfCascades(tf)((tf)->cascades));
3975
3976	if (DEBUG(sefoClose)sefoCloseDebug) {
3977	fprintf(dbOut, " T)");
3978	tformPrintDb(tf);
3979	}
3980	}
3981
3982	localstatic void
3983	tqualClosure0(Lib lib, TQual tqual)
3984	{
3985	tfFollow(tqBase(tqual))((((tqual)->base)) = tfFollowFn(((tqual)->base)));
3986	tformClosure0(lib, tqBase(tqual)((tqual)->base));
3987	if (tqIsQualified(tqual)((tqual)->isQual == 1))
3988	tformListClosure0(lib, tqQual(tqual)((tqual)->qual));
3989	}
3990
3991	localstatic void
3992	sefoListClosure0(Lib lib, SefoList sefos)
3993	{
3994	for ( ; sefos; sefos = cdr(sefos)((sefos)->rest))
3995	sefoClosure0(lib, car(sefos)((sefos)->first));
3996	}
3997
3998	localstatic void
3999	symeListClosure0(Lib lib, SymeList symes)
4000	{
4001	for ( ; symes; symes = cdr(symes)((symes)->rest))
4002	symeClosure0(lib, car(symes)((symes)->first));
4003	}
4004
4005	localstatic void
4006	tformListClosure0(Lib lib, TFormList tforms)
4007	{
4008	for ( ; tforms; tforms = cdr(tforms)((tforms)->rest)) {
4009	tfFollow(car(tforms))((((tforms)->first)) = tfFollowFn(((tforms)->first)));
4010	tformClosure0(lib, car(tforms)((tforms)->first));
4011	}
4012	}
4013
4014	localstatic void
4015	tqualListClosure0(Lib lib, TQualList tquals)
4016	{
4017	for ( ; tquals; tquals = cdr(tquals)((tquals)->rest))
4018	tqualClosure0(lib, car(tquals)((tquals)->first));
4019	}
4020
4021	/*****************************************************************************
4022	*
4023	* :: symeList set operations
4024	*
4025	****************************************************************************/
4026
4027	Bool
4028	symeListMember(Syme syme, SymeList symes, SymeEqFun eq)
4029	{
4030	SymeList symes0 = symes;
4031	for (; symes0; symes0 = cdr(symes0)((symes0)->rest)) {
4032	/* The extra '==' check saves a lot of funcalls on symeEq. */
4033	if (syme == car(symes0)((symes0)->first))
4034	return true1;
4035	}
4036
4037	if (eq != symeEq) {
4038	for (; symes; symes = cdr(symes)((symes)->rest)) {
4039	if (eq(syme, car(symes)((symes)->first)))
4040	return true1;
4041	}
4042	}
4043	return false((int) 0);
4044	}
4045
4046	/* Return true if each syme in symes1 is a member of symes2. */
4047	Bool
4048	symeListSubset(SymeList symes1, SymeList symes2, SymeEqFun eq)
4049	{
4050	for (; symes1; symes1 = cdr(symes1)((symes1)->rest))
4051	if (!symeListMember(car(symes1)((symes1)->first), symes2, eq))
4052	return false((int) 0);
4053	return true1;
4054	}
4055
4056	SymeList
4057	symeListUnion(SymeList symes1, SymeList symes2, SymeEqFun eq)
4058	{
4059	SymeList result = listNil(Syme)((SymeList) 0);
4060
4061	if (DEBUG(sefoUnion)sefoUnionDebug) {
4062	fprintf(dbOut, "symeListUnion: \n");
4063	fprintf(dbOut, " symes1: ");
4064	symeListPrintDb(symes1);
4065	fprintf(dbOut, " symes2: ");
4066	symeListPrintDb(symes2);
4067	}
4068
4069	for (; symes1; symes1 = cdr(symes1)((symes1)->rest))
4070	if (!symeListMember(car(symes1)((symes1)->first), symes2, eq))
4071	result = listCons(Syme)(Syme_listPointer->Cons)(car(symes1)((symes1)->first), result);
4072
4073	result = listNConcat(Syme)(Syme_listPointer->NConcat)(listNReverse(Syme)(Syme_listPointer->NReverse)(result),
4074	listCopy(Syme)(Syme_listPointer->Copy)(symes2));
4075
4076	if (DEBUG(sefoUnion)sefoUnionDebug) {
4077	fprintf(dbOut, "symeListUnion result: ");
4078	symeListPrintDb(result);
4079	}
4080
4081	return result;
4082	}
4083
4084	SymeList
4085	symeListIntersect(SymeList symes1, SymeList symes2, SymeEqFun eq)
4086	{
4087	SymeList result = listNil(Syme)((SymeList) 0);
4088
4089	if (DEBUG(sefoInter)sefoInterDebug) {
4090	fprintf(dbOut, "symeListIntersect: \n");
4091	fprintf(dbOut, " symes1: ");
4092	symeListPrintDb(symes1);
4093	fprintf(dbOut, " symes2: ");
4094	symeListPrintDb(symes2);
4095	}
4096
4097	for (; symes1; symes1 = cdr(symes1)((symes1)->rest))
4098	if (symeListMember(car(symes1)((symes1)->first), symes2, eq))
4099	result = listCons(Syme)(Syme_listPointer->Cons)(car(symes1)((symes1)->first), result);
4100
4101	result = listNReverse(Syme)(Syme_listPointer->NReverse)(result);
4102
4103	if (DEBUG(sefoInter)sefoInterDebug) {
4104	fprintf(dbOut, "symeListIntersect result: ");
4105	symeListPrintDb(result);
4106	}
4107
4108	return result;
4109	}
4110
4111	/*****************************************************************************
4112	*
4113	* :: sstToBuffer
4114	*
4115	****************************************************************************/
4116
4117	int
4118	sefoToBuffer(Lib lib, Buffer buf, Sefo sefo)
4119	{
4120	Length start = bufPosition(buf);
4121	AbSynTag tag = abTag(sefo)((sefo)->abHdr.tag);
4122	UShort i, argc;
4123
4124	bufPutByte(buf, tag);
4125
4126	switch (tag) {
4127	case AB_Nothing:
4128	case AB_Blank:
4129	break;
4130
4131	case AB_IdSy:
4132	bugUnimpl("sefoToBuffer: abIdSy")bug("Unimplemented %s (line %d in file %s).", "sefoToBuffer: abIdSy" , 4132, "sefo.c");
4133	break;
4134
4135	case AB_Id:
4136	assert(abSyme(sefo))do { if (!(((sefo)->abHdr.seman ? (sefo)->abHdr.seman-> syme : 0))) _do_assert(("abSyme(sefo)"),"sefo.c",4136); } while (0);
4137	symeToBuffer(lib, buf, abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
4138	break;
4139
4140	case AB_LitInteger:
4141	case AB_LitString:
4142	case AB_LitFloat:
4143	assert(abSyme(sefo))do { if (!(((sefo)->abHdr.seman ? (sefo)->abHdr.seman-> syme : 0))) _do_assert(("abSyme(sefo)"),"sefo.c",4143); } while (0);
4144	symeToBuffer(lib, buf, abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
4145	bufWrString(buf, abLeafStr(sefo)((sefo)->abGen.data.str));
4146	break;
4147
4148	case AB_Lambda: /* Lies, damn lies, and leaving out the body */
4149	sefoToBuffer(lib, buf, sefo->abLambda.param);
4150	sefoToBuffer(lib, buf, sefo->abLambda.rtype);
4151	break;
4152
4153	case AB_With:
4154	sefoToBuffer(lib, buf, sefo->abWith.base);
4155	sefoToBuffer(lib, buf, sefo->abWith.within);
4156	symeListToBuffer(lib, buf, tfGetCatSelf(abTForm(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->tform : 0 )));
4157	break;
4158	default:
4159	argc = abArgc(sefo)((sefo)->abHdr.argc);
4160	bufPutHInt(buf, argc);
4161	for (i = 0; i < argc; i += 1)
4162	sefoToBuffer(lib, buf, abArgv(sefo)((sefo)->abGen.data.argv)[i]);
4163	}
4164
4165	return bufPosition(buf) - start;
4166	}
4167
4168	int
4169	symeToBuffer(Lib lib, Buffer buf, Syme syme)
4170	{
4171	UShort n = symeLibNum(syme)((UShort) (SYFI_LibNum < (8 * sizeof(int)) && !((( ((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_LibNum ))) ? (symeFieldInfo[SYFI_LibNum].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_LibNum))) ? ((( (((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_LibNum ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_LibNum)] : (symeFieldInfo [SYFI_LibNum].def)) : symeGetFieldFn(syme,SYFI_LibNum)));
4172
4173	assert(libCheckSymeNumber(lib, syme, n))do { if (!(libCheckSymeNumber(lib, syme, n))) _do_assert(("libCheckSymeNumber(lib, syme, n)" ),"sefo.c",4173); } while (0);
4174	bufPutHInt(buf, n);
4175
4176	return HINT_BYTES2;
4177	}
4178
4179	localstatic int
4180	tformToBuffer1(Lib lib, Buffer buf, TForm tf)
4181	{
4182	ULong n = tf->libNum;
4183
4184	assert(libCheckTypeNumber(lib, tf, n))do { if (!(libCheckTypeNumber(lib, tf, n))) _do_assert(("libCheckTypeNumber(lib, tf, n)" ),"sefo.c",4184); } while (0);
4185	bufPutSInt(buf, n);
4186
4187	return SINT_BYTES4;
4188	}
4189
4190	int
4191	tformToBuffer(Lib lib, Buffer buf, TForm tf)
4192	{
4193	Length start = bufPosition(buf);
4194	TFormTag tag = tfTag(tf)((tf)->tag);
4195	UShort i, argc;
4196
4197	if (tfHasSelf(tf)((tf)->hasSelf)) tag \|= 0x80;
4198	if (tfHasCascades(tf)((tf)->hasCascades)) tag \|= 0x40;
4199	bufPutByte(buf, tag);
4200	tag &= 0x3f;
4201
4202	if (tfIsSymTag(tag)( (tag) < TF_SYM_LIMIT))
4203	;
4204
4205	else if (tfIsAbSynTag(tag)( TF_ABSYN_START <= (tag) && (tag) < TF_ABSYN_LIMIT ))
4206	sefoToBuffer(lib, buf, tfGetExpr(tf)((tf)->__absyn));
4207
4208	else if (tfIsNodeTag(tag)( TF_NODE_START <= (tag) && (tag) < TF_NODE_LIMIT )) {
4209	argc = tfArgc(tf)((tf)->argc);
4210	bufPutHInt(buf, argc);
4211	for (i = 0; i < argc; i += 1)
4212	tformToBuffer1(lib, buf, tfArgv(tf)((tf)->argv)[i]);
4213	}
4214
4215	else
4216	bugBadCase(tag)bug("Bad case %d (line %d in file %s).", (int) tag, 4216, "sefo.c" );
4217
4218	symeListToBuffer (lib, buf, tfSelf(tf)((tf)->self));
4219	symeListToBuffer (lib, buf, tfSelfSelf(tf)((tf)->selfself));
4220	tformListToBuffer(lib, buf, tfQueries(tf)((tf)->queries));
4221	tqualListToBuffer(lib, buf, tfCascades(tf)((tf)->cascades));
4222
4223	if (tfTagHasSymes(tfTag(tf)((tf)->tag)))
4224	symeListToBuffer(lib, buf, tfSymes(tf)((tf)->symes));
4225
4226	if (tfIsWith(tf)(((tf)->tag) == TF_With)) {
4227	if (tfUseCatExports(tf)(((((tfFollowArg(tf, 0))->tag) == TF_Multiple) && tfMultiArgc (tfFollowArg(tf, 0)) == 0) && ((((tfFollowArg(tf, 1)) ->tag) == TF_Multiple) && tfMultiArgc(tfFollowArg( tf, 1)) == 0))) {
4228	SymeList l;
4229	symeListToBuffer(lib, buf, tfGetCatExports(tf));
4230	l = tfGetCatExports(tf);
4231	bufPutHInt(buf, listLength(Syme)(Syme_listPointer->_Length)(l));
4232	while (l != listNil(Syme)((SymeList) 0)) {
4233	if (symeIsSelfSelf(car(l))(((((l)->first))->id) == ssymSelfSelf))
4234	sefoListToBuffer(lib, buf, listNil(Sefo)((SefoList) 0));
4235	else
4236	sefoListToBuffer(lib, buf, symeCondition(car(l)((l)->first)));
4237	l = cdr(l)((l)->rest);
4238	}
4239
4240	}
4241	else {
4242	bufPutHInt(buf, 0);
4243	symeListToBuffer(lib, buf, listNil(Syme)((SymeList) 0));
4244	}
4245	}
4246
4247	if (tfIsThird(tf)(((tf)->tag) == TF_Third)) {
4248	if (tfUseThdExports(tf)(((((tfFollowArg(tf, 0))->tag) == TF_Multiple) && tfMultiArgc (tfFollowArg(tf, 0)) == 0)))
4249	symeListToBuffer(lib, buf, tfGetThdExports(tf));
4250	else
4251	symeListToBuffer(lib, buf, listNil(Syme)((SymeList) 0));
4252	}
4253
4254	if (tfFVars(tf)((tf)->fv) == NULL((void*)0))
4255	tformFreeVars(tf);
4256
4257	assert(tfFVars(tf) != NULL)do { if (!(((tf)->fv) != ((void*)0))) _do_assert(("tfFVars(tf) != NULL" ),"sefo.c",4257); } while (0);
4258	/afprintf(dbOut, "TF: %pPtr %pTForm FreeVars: %pSymeList\n", tf, tf, tf->fv->symes);/
4259
4260	freeVarToBuffer(lib, buf, tfFVars(tf)((tf)->fv));
4261
4262	return bufPosition(buf) - start;
4263	}
4264
4265	int
4266	tqualToBuffer(Lib lib, Buffer buf, TQual tq)
4267	{
4268	Length start = bufPosition(buf);
4269
4270	tformToBuffer1(lib, buf, tqBase(tq)((tq)->base));
4271	tformListToBuffer(lib, buf, tqQual(tq)((tq)->qual));
4272
4273	return bufPosition(buf) - start;
4274	}
4275
4276	int
4277	sefoListToBuffer(Lib lib, Buffer buf, SefoList sefos)
4278	{
4279	Length start = bufPosition(buf);
4280	UShort sefoc = listLength(Sefo)(Sefo_listPointer->_Length)(sefos);
4281
4282	bufPutHInt(buf, sefoc);
4283
4284	for (; sefos; sefos = cdr(sefos)((sefos)->rest))
4285	sefoToBuffer(lib, buf, car(sefos)((sefos)->first));
4286
4287	return bufPosition(buf) - start;
4288	}
4289
4290	int
4291	symeListToBuffer(Lib lib, Buffer buf, SymeList symes)
4292	{
4293	Length start = bufPosition(buf);
4294	UShort symec = listLength(Syme)(Syme_listPointer->_Length)(symes);
4295
4296	bufPutHInt(buf, symec);
4297
4298	for (; symes; symes = cdr(symes)((symes)->rest))
4299	symeToBuffer(lib, buf, car(symes)((symes)->first));
4300
4301	return bufPosition(buf) - start;
4302	}
4303
4304	int
4305	tformListToBuffer(Lib lib, Buffer buf, TFormList tforms)
4306	{
4307	Length start = bufPosition(buf);
4308	UShort tformc = listLength(TForm)(TForm_listPointer->_Length)(tforms);
4309
4310	bufPutHInt(buf, tformc);
4311
4312	for (; tforms; tforms = cdr(tforms)((tforms)->rest))
4313	tformToBuffer1(lib, buf, car(tforms)((tforms)->first));
4314
4315	return bufPosition(buf) - start;
4316	}
4317
4318	int
4319	tqualListToBuffer(Lib lib, Buffer buf, TQualList tquals)
4320	{
4321	Length start = bufPosition(buf);
4322	UShort tqualc = listLength(TQual)(TQual_listPointer->_Length)(tquals);
4323
4324	bufPutHInt(buf, tqualc);
4325	for (; tquals; tquals = cdr(tquals)((tquals)->rest))
4326	tqualToBuffer(lib, buf, car(tquals)((tquals)->first));
4327
4328	return bufPosition(buf) - start;
4329	}
4330
4331	localstatic int
4332	freeVarToBuffer(Lib lib, Buffer buf, FreeVar fv)
4333	{
4334	Length start = bufPosition(buf);
4335	UShort symec;
4336	SymeList symes;
4337	Bool skipParams = fvSkipParam(fv)((fv)->skip);
4338
4339	/* Count the number of symes to put. */
4340	for (symec = 0, symes = fvSymes(fv)((fv)->symes); symes; symes = cdr(symes)((symes)->rest)) {
4341	if (skipParams && symeIsParam(car(symes))(((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void*)0)), (((symes)-> first)))->kind) == SYME_Param)) continue;
4342	if (libHasSyme(lib, car(symes)((symes)->first)))
4343	symec += 1;
4344	}
4345
4346	bufPutHInt(buf, symec);
4347
4348	for (symes = fvSymes(fv)((fv)->symes); symes; symes = cdr(symes)((symes)->rest)) {
4349	if (skipParams && symeIsParam(car(symes))(((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void*)0)), (((symes)-> first)))->kind) == SYME_Param)) continue;
4350	if (libHasSyme(lib, car(symes)((symes)->first)))
4351	symeToBuffer(lib, buf, car(symes)((symes)->first));
4352	}
4353
4354	return bufPosition(buf) - start;
4355	}
4356
4357	/*****************************************************************************
4358	*
4359	* :: sstFrBuffer
4360	*
4361	****************************************************************************/
4362
4363	Sefo
4364	sefoFrBuffer(Lib lib, Buffer buf)
4365	{
4366	Sefo sefo, sefo1;
4367	Syme syme;
4368	AbSynTag tag;
4369	UShort i, argc;
4370
4371	tag = bufGetByte(buf);
4372
4373	switch (tag) {
4374	case AB_Nothing:
4375	sefo = abNewNothing(sposNone)abNew(AB_Nothing, sposNone,0 );
4376	break;
4377	case AB_Blank:
4378	sefo = abNewBlank(sposNone, ssymVariable)abNew(AB_Blank, sposNone,1, ssymVariable);
4379	break;
4380	case AB_IdSy:
4381	bugUnimpl("sefoFrBuffer: abIdSy")bug("Unimplemented %s (line %d in file %s).", "sefoFrBuffer: abIdSy" , 4381, "sefo.c");
4382	NotReached(sefo = NULL){(void)bug("Not supposed to reach line %d in file: %s\n",4382 , "sefo.c");};
4383	break;
4384	case AB_Id:
4385	syme = symeFrBuffer(lib, buf);
4386	sefo = abNewId(sposNone, symeId(syme))abNew(AB_Id, sposNone,1, ((syme)->id));
4387	abSetSyme(sefo, syme);
4388	break;
4389	case AB_LitInteger:
4390	syme = symeFrBuffer(lib, buf);
4391	sefo = abNewLitInteger(sposNone, bufRdString(buf))abNew(AB_LitInteger, sposNone,1, bufRdString(buf));
4392	abSetSyme(sefo, syme);
4393	break;
4394	case AB_LitString:
4395	syme = symeFrBuffer(lib, buf);
4396	sefo = abNewLitString(sposNone, bufRdString(buf))abNew(AB_LitString, sposNone,1, bufRdString(buf));
4397	abSetSyme(sefo, syme);
4398	break;
4399	case AB_LitFloat:
4400	syme = symeFrBuffer(lib, buf);
4401	sefo = abNewLitFloat(sposNone, bufRdString(buf))abNew(AB_LitFloat, sposNone,1, bufRdString(buf));
4402	abSetSyme(sefo, syme);
4403	break;
4404	case AB_Lambda: {
4405	Sefo body;
4406	sefo1 = sefoFrBuffer(lib, buf);
4407	sefo = sefoFrBuffer(lib, buf);
4408	body = abNewNever(sposNone)abNew(AB_Never, sposNone,0 );
4409	abUse(body)((body)->abHdr.use) = AB_Use_Elided;
4410	sefo = abNewLambda(sposNone, sefo1, sefo, body)abNew(AB_Lambda, sposNone,3, sefo1,sefo,body);
4411	}
4412	break;
4413	case AB_With: {
4414	SymeList list;
4415	sefo1 = sefoFrBuffer(lib, buf);
4416	sefo = sefoFrBuffer(lib, buf);
4417	list = symeListFrBuffer(lib, buf);
4418	sefo = abNewWith(sposNone, sefo1, sefo)abNew(AB_With, sposNone,2, sefo1,sefo);
4419	abSetSelf(sefo, list);
4420	break;
4421	}
4422	default:
4423	argc = bufGetHInt(buf);
4424	sefo = abNewEmpty(tag, argc);
4425	for (i = 0; i < argc; i += 1)
4426	abArgv(sefo)((sefo)->abGen.data.argv)[i] = sefoFrBuffer(lib, buf);
4427	}
4428
4429	return sefo;
4430	}
4431
4432	Syme
4433	symeFrBuffer(Lib lib, Buffer buf)
4434	{
4435	UShort n;
4436
4437	n = bufGetHInt(buf);
4438	assert(libCheckSymeNumber(lib, NULL, n))do { if (!(libCheckSymeNumber(lib, ((void*)0), n))) _do_assert (("libCheckSymeNumber(lib, NULL, n)"),"sefo.c",4438); } while (0);
4439
4440	return lib->symev[n];
4441	}
4442
4443	localstatic TForm
4444	tformFrBuffer1(Lib lib, Buffer buf)
4445	{
4446	ULong n;
4447
4448	n = bufGetSInt(buf);
4449	assert(libCheckTypeNumber(lib, NULL, n))do { if (!(libCheckTypeNumber(lib, ((void*)0), n))) _do_assert (("libCheckTypeNumber(lib, NULL, n)"),"sefo.c",4449); } while (0);
4450
4451	/* The type forms are filled in later. */
4452	return (TForm) n;
4453	}
4454
4455	TForm
4456	tformFrBuffer(Lib lib, Buffer buf)
4457	{
4458	TForm tf;
4459	TFormTag tag;
4460	UShort i, argc;
4461	Bool hasSelf = false((int) 0), hasCascades = false((int) 0);
4462
4463	tag = bufGetByte(buf);
4464	if (tag & 0x80) hasSelf = true1;
4465	if (tag & 0x40) hasCascades = true1;
4466	tag &= 0x3f;
4467
4468	if (tfIsSymTag(tag)( (tag) < TF_SYM_LIMIT))
4469	switch (tag) {
4470	case TF_Unknown:
4471	tf = tfUnknown;
4472	break;
4473	case TF_Exit:
4474	tf = tfExit;
4475	break;
4476	case TF_Test:
4477	tf = tfTest;
4478	break;
4479	case TF_Literal:
4480	tf = tfLiteral;
4481	break;
4482	case TF_Type:
4483	tf = tfType;
4484	/* TTT */
4485	return tf;
4486	break;
4487	case TF_Category:
4488	tf = tfCategory;
4489	break;
4490	default:
4491	bugBadCase(tag)bug("Bad case %d (line %d in file %s).", (int) tag, 4491, "sefo.c" );
4492	NotReached(tf = NULL){(void)bug("Not supposed to reach line %d in file: %s\n",4492 , "sefo.c");};
4493	}
4494
4495	else if (tfIsAbSynTag(tag)( TF_ABSYN_START <= (tag) && (tag) < TF_ABSYN_LIMIT )) {
4496	Sefo sefo = sefoFrBuffer(lib, buf);
4497	Syme syme = abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 );
4498
4499	if (syme && syme->kind == SYME_Library)
4500	tf = tfGetLibrary(syme);
4501	else if (syme && syme->kind == SYME_Archive)
4502	tf = tfGetArchive(syme);
4503	else {
4504	tf = tfNewAbSyn(tag, sefo);
4505	tf->intStepNo = 0;
4506	tfOwnExpr(tf);
4507	}
4508	}
4509
4510	else if (tfIsNodeTag(tag)( TF_NODE_START <= (tag) && (tag) < TF_NODE_LIMIT )) {
4511	argc = bufGetHInt(buf);
4512	tf = tfNewEmpty(tag, argc);
4513	tf->intStepNo = 0;
4514	for (i = 0; i < argc; i += 1)
4515	tfArgv(tf)((tf)->argv)[i] = tformFrBuffer1(lib, buf);
4516	}
4517
4518	else {
4519	bugBadCase(tag)bug("Bad case %d (line %d in file %s).", (int) tag, 4519, "sefo.c" );
4520	NotReached(tf = NULL){(void)bug("Not supposed to reach line %d in file: %s\n",4520 , "sefo.c");};
4521	}
4522
4523	tfSetSelf(tf, symeListFrBuffer(lib, buf))((tf)->self = (symeListFrBuffer(lib, buf)));
4524	tfSetSelfSelf(tf, symeListFrBuffer(lib, buf))((tf)->selfself = (symeListFrBuffer(lib, buf)));
4525	tfSetQueries(tf, tformListFrBuffer(lib, buf))(((tf)->queries) = (tformListFrBuffer(lib, buf)));
4526	tfSetCascades(tf, tqualListFrBuffer(lib, buf))(((tf)->cascades) = (tqualListFrBuffer(lib, buf)));
4527
4528	tfHasSelf(tf)((tf)->hasSelf) = hasSelf;
4529	tfHasCascades(tf)((tf)->hasCascades) = hasCascades;
4530
4531	if (tfTagHasSymes(tfTag(tf)((tf)->tag)))
4532	tfSetSymes(tf, symeListFrBuffer(lib, buf))((tf)->symes = (symeListFrBuffer(lib, buf)));
4533
4534	if (tfIsWith(tf)(((tf)->tag) == TF_With)) {
4535	SymeList symes;
4536	int n;
4537	tfSetCatExports(tf, symeListFrBuffer(lib, buf));
4538	n = bufGetHInt(buf);
4539	symes = tfCatExports(tf);
4540	if (n != listLength(Syme)(Syme_listPointer->_Length)(symes)) {
4541	bug("incorrect number of exports");
4542	}
4543	while (symes != listNil(Syme)((SymeList) 0)) {
4544	SefoList condition = sefoListFrBuffer(lib, buf);
4545	symeSetCondition(car(symes)((symes)->first), condition);
4546	symes = cdr(symes)((symes)->rest);
4547	}
4548	}
4549	if (tfIsThird(tf)(((tf)->tag) == TF_Third))
4550	tfSetThdExports(tf, symeListFrBuffer(lib, buf));
4551
4552	tfSetFVars(tf, fvFrSymes(symeListFrBuffer(lib, buf)))(((tf)->fv) = (fvFrSymes(symeListFrBuffer(lib, buf))));
4553
4554	return tf;
4555	}
4556
4557	TQual
4558	tqualFrBuffer(Lib lib, Buffer buf)
4559	{
4560	TForm base = tformFrBuffer1(lib, buf);
4561	TFormList qual = tformListFrBuffer(lib, buf);
4562
4563	return tqNewFrList(base, qual);
4564	}
4565
4566	SefoList
4567	sefoListFrBuffer(Lib lib, Buffer buf)
4568	{
4569	SefoList sefos = listNil(Sefo)((SefoList) 0);
4570	UShort i, sefoc;
4571
4572	sefoc = bufGetHInt(buf);
4573
4574	for (i = 0; i < sefoc; i += 1) {
4575	Sefo sefo = sefoFrBuffer(lib, buf);
4576	sefos = listCons(Sefo)(Sefo_listPointer->Cons)(sefo, sefos);
4577	}
4578	return listNReverse(Sefo)(Sefo_listPointer->NReverse)(sefos);
4579	}
4580
4581	SymeList
4582	symeListFrBuffer(Lib lib, Buffer buf)
4583	{
4584	SymeList symes = listNil(Syme)((SymeList) 0);
4585	UShort i, symec;
4586
4587	symec = bufGetHInt(buf);
4588
4589	for (i = 0; i < symec; i += 1)
4590	symes = listCons(Syme)(Syme_listPointer->Cons)(symeFrBuffer(lib, buf), symes);
4591
4592	return listNReverse(Syme)(Syme_listPointer->NReverse)(symes);
4593	}
4594
4595	TFormList
4596	tformListFrBuffer(Lib lib, Buffer buf)
4597	{
4598	TFormList tforms = listNil(TForm)((TFormList) 0);
4599	UShort i, tformc;
4600
4601	tformc = bufGetHInt(buf);
4602
4603	for (i = 0; i < tformc; i += 1)
4604	tforms = listCons(TForm)(TForm_listPointer->Cons)(tformFrBuffer1(lib, buf), tforms);
4605
4606	return listNReverse(TForm)(TForm_listPointer->NReverse)(tforms);
4607
4608	}
4609
4610	TQualList
4611	tqualListFrBuffer(Lib lib, Buffer buf)
4612	{
4613	TQualList tquals = listNil(TQual)((TQualList) 0);
4614	UShort i, tqualc;
4615
4616	tqualc = bufGetHInt(buf);
4617
4618	for (i = 0; i < tqualc; i += 1)
4619	tquals = listCons(TQual)(TQual_listPointer->Cons)(tqualFrBuffer(lib, buf), tquals);
4620
4621	return listNReverse(TQual)(TQual_listPointer->NReverse)(tquals);
4622
4623	}
4624
4625	/*****************************************************************************
4626	*
4627	* :: sstFrBuffer0
4628	*
4629	****************************************************************************/
4630
4631	/*
4632	* Read the number of types from the type form section in a buffer.
4633	*/
4634	int
4635	tformTypecFrBuffer(Buffer buf)
4636	{
4637	ULong argc;
4638
4639	bufStart(buf);
4640	argc = bufGetSInt(buf);
4641
4642	return argc;
4643	}
4644
4645	/*
4646	* Compute the positions of the types from the type form section in a buffer.
4647	*/
4648	void
4649	tformTypepFrBuffer(Buffer buf, int posc, int *posv)
4650	{
4651	int i;
4652
4653	for (i = 0; i < posc; i += 1)
4654	posv[i] = 0;
4655
4656	/* Skip over the number of type forms. */
4657	tformTypecFrBuffer(buf);
4658
4659	for (i = 0; i < posc; i += 1) {
4660	posv[i] = bufPosition(buf);
4661	tformFrBuffer0(buf);
4662	}
4663	}
4664
4665	localstatic void
4666	sefoFrBuffer0(Buffer buf)
4667	{
4668	AbSynTag tag;
4669	UShort i, argc;
4670	ULong cc;
4671
4672	tag = bufGetByte(buf);
4673
4674	switch (tag) {
4675	case AB_Nothing:
4676	case AB_Blank:
4677	case AB_IdSy:
4678	break;
4679
4680	case AB_Id:
4681	symeFrBuffer0(buf);
4682	break;
4683
4684	case AB_LitInteger:
4685	case AB_LitString:
4686	case AB_LitFloat:
4687	symeFrBuffer0(buf);
4688	cc = bufGetSInt(buf);
4689	bufSkip(buf, cc);
4690	break;
4691
4692	case AB_Lambda:
4693	sefoFrBuffer0(buf);
4694	sefoFrBuffer0(buf);
4695	break;
4696	case AB_With:
4697	sefoFrBuffer0(buf);
4698	sefoFrBuffer0(buf);
4699	symeListFrBuffer0(buf);
4700	break;
4701	default:
4702	argc = bufGetHInt(buf);
4703	for (i = 0; i < argc; i += 1)
4704	sefoFrBuffer0(buf);
4705	break;
4706	}
4707	}
4708
4709	localstatic void
4710	symeFrBuffer0(Buffer buf)
4711	{
4712	bufSkip(buf, HINT_BYTES2);
4713	}
4714
4715	localstatic void
4716	tformFrBuffer0(Buffer buf)
4717	{
4718	TFormTag tag;
4719
4720	tag = bufGetByte(buf);
4721	tag &= 0x3f;
4722
4723	if (tfIsSymTag(tag)( (tag) < TF_SYM_LIMIT))
4724	;
4725
4726	else if (tfIsAbSynTag(tag)( TF_ABSYN_START <= (tag) && (tag) < TF_ABSYN_LIMIT ))
4727	sefoFrBuffer0(buf);
4728
4729	else if (tfIsNodeTag(tag)( TF_NODE_START <= (tag) && (tag) < TF_NODE_LIMIT ))
4730	tformListFrBuffer0(buf);
4731
4732	symeListFrBuffer0 (buf); /* tfSelf(tf) */
4733	symeListFrBuffer0 (buf); /* tfSelfSelf(tf) */
4734	tformListFrBuffer0(buf); /* tfQueries(tf) */
4735	tqualListFrBuffer0(buf); /* tfCascades(tf) */
4736
4737	if (tfTagHasSymes(tag))
4738	symeListFrBuffer0(buf); /* tfSymes(tf) */
4739
4740	if (tag == TF_With) {
4741	UShort n, i;
4742	symeListFrBuffer0(buf); /* tfCatExports(tf) */
4743	n = bufGetHInt(buf);
4744	for (i=0; i<n; i++) {
4745	sefoListFrBuffer0(buf);
4746	}
4747	}
4748	if (tag == TF_Third)
4749	symeListFrBuffer0(buf); /* tfThdExports(tf) */
4750
4751	symeListFrBuffer0(buf); /* fvSymes(tfFVars(tf)) */
4752	}
4753
4754	localstatic void
4755	tqualFrBuffer0(Buffer buf)
4756	{
4757	bufSkip(buf, SINT_BYTES4);
4758	tformListFrBuffer0(buf);
4759	}
4760
4761	localstatic void
4762	sefoListFrBuffer0(Buffer buf)
4763	{
4764	UShort i, sefoc;
4765
4766	sefoc = bufGetHInt(buf);
4767
4768	for (i = 0; i < sefoc; i += 1) {
4769	sefoFrBuffer0(buf);
4770	}
4771	}
4772
4773
4774	void
4775	symeListFrBuffer0(Buffer buf)
4776	{
4777	UShort symec;
4778
4779	symec = bufGetHInt(buf);
4780	bufSkip(buf, symec * HINT_BYTES2);
4781	}
4782
4783	localstatic void
4784	tformListFrBuffer0(Buffer buf)
4785	{
4786	UShort tformc;
4787
4788	tformc = bufGetHInt(buf);
4789	bufSkip(buf, tformc * SINT_BYTES4);
4790	}
4791
4792	localstatic void
4793	tqualListFrBuffer0(Buffer buf)
4794	{
4795	UShort i, tqualc;
4796
4797	tqualc = bufGetHInt(buf);
4798
4799	for (i = 0; i < tqualc; i += 1)
4800	tqualFrBuffer0(buf);
4801	}
4802
4803	/*
4804	* :: General stuff
4805	*/
4806
4807	SymeList
4808	sefoSymes(Sefo sefo)
4809	{
4810	SymeList sl = listNil(Syme)((SymeList) 0);
4811
4812	if (abIsId(sefo)((sefo)->abHdr.tag == (AB_Id)) && abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 )) {
4813	sl = listSingleton(Syme)(Syme_listPointer->Singleton)(abSyme(sefo)((sefo)->abHdr.seman ? (sefo)->abHdr.seman->syme : 0 ));
4814	}
4815	else if (abIsId(sefo)((sefo)->abHdr.tag == (AB_Id))) {
4816	// skip
4817	}
4818	else if (abIsLeaf(sefo)(((sefo)->abHdr.tag) < AB_NODE_START)) {
4819	// skip
4820	}
4821	else {
4822	for (int i=0; i<abArgc(sefo)((sefo)->abHdr.argc); i++) {
4823	sl = listConcat(Syme)(Syme_listPointer->Concat)(sefoSymes(abArgv(sefo)((sefo)->abGen.data.argv)[i]), sl);
4824	}
4825	}
4826	return sl;
4827	}