Bug Summary

File:src/sefo.c
Warning:line 1717, column 7
Access to field 'id' results in a dereference of a null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

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
30Bool sstDebug = false((int) 0);
31Bool sstMarkDebug = false((int) 0);
32
33Bool sefoPrintDebug = false((int) 0);
34Bool sefoEqualDebug = false((int) 0);
35Bool sefoFreeDebug = false((int) 0);
36Bool sefoSubstDebug = false((int) 0);
37Bool sefoUnionDebug = false((int) 0);
38Bool sefoInterDebug = false((int) 0);
39Bool 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
56static ULong * SubstDebugTable = NULL((void*)0);
57
58void
59substDebugInit(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
68void
69substDebugReport(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
83extern void genGetConstNums (SymeList);
84extern SymeList tfGetDomConstants (TForm);
85
86localstatic int sstPrSefo (FILE *, int, Sefo);
87localstatic int sstPrSyme (FILE *, int, Syme);
88localstatic int sstPrTForm (FILE *, int, TForm);
89localstatic int sstPrAbSub (FILE *, int, AbSub);
90localstatic int sstPrSefoList (FILE *, int, SefoList);
91localstatic int sstPrSymeList (FILE *, int, SymeList);
92localstatic int sstPrTFormList (FILE *, int, TFormList);
93localstatic int sstPrBool (FILE *, int, Bool);
94localstatic int sstPrLib (FILE *, int, Lib);
95
96localstatic int sefoOStreamPrint0 (OStream, Bool, Sefo);
97localstatic int symeOStreamPrint0 (OStream, Bool, Syme);
98localstatic int tformOStreamPrint0 (OStream, Bool, TForm);
99localstatic int sefoListOStreamPrint0 (OStream, Bool, SefoList);
100localstatic int symeListOStreamPrint0 (OStream, Bool, SymeList);
101localstatic int tformListOStreamPrint0 (OStream, Bool, TFormList);
102
103localstatic Bool sefoEqual0 (SymeList, Sefo, Sefo);
104localstatic Bool symeEqual0 (SymeList, Syme, Syme);
105localstatic Bool tformEqual0 (SymeList, TForm, TForm);
106localstatic Bool sefoListEqual0 (SymeList, SefoList, SefoList);
107localstatic Bool symeListEqual0 (SymeList, SymeList, SymeList);
108localstatic Bool tformListEqual0 (SymeList,TFormList,TFormList);
109localstatic Bool sefoIsDefinedType (Sefo);
110
111localstatic Bool symeTypeEqual0 (SymeList, Syme, Syme);
112localstatic Bool symeExtendEqual0 (SymeList, Syme, Syme);
113localstatic Bool symeOriginEqual0 (SymeList, Syme, Syme);
114
115localstatic Bool tformEqualCheckSymes (TForm);
116localstatic Sefo sefoEqualMods (Sefo);
117localstatic AbEqualValue sefoIdEqual (void *, Sefo, Sefo);
118
119localstatic void sfvInitTable (void);
120localstatic void sfvFiniTable (void);
121localstatic void sfvPushTable (void);
122localstatic void sfvConsTable (Syme);
123localstatic FreeVar sfvPopTable (Bool);
124
125localstatic void sfvAddSyme (Syme);
126localstatic void sfvAddSymes (SymeList);
127localstatic void sfvDelSyme (Syme);
128localstatic void sfvDelSymes (SymeList);
129localstatic void sfvDelStab (Stab);
130
131localstatic Bool sfvIsAncestor (TForm, TForm);
132localstatic TForm sfvCommonAncestor (TForm, TForm);
133
134localstatic void sefoFreeVars0 (TForm *, TForm, Sefo);
135localstatic void symeFreeVars0 (TForm *, TForm, Syme);
136localstatic void tformFreeVars0 (TForm *, TForm, TForm);
137localstatic void tqualFreeVars0 (TForm *, TForm, TQual);
138localstatic void abSubFreeVars0 (TForm *, TForm, AbSub);
139localstatic void sefoListFreeVars0 (TForm *, TForm, SefoList);
140localstatic void symeListFreeVars0 (TForm *, TForm, SymeList);
141localstatic void tformListFreeVars0 (TForm *, TForm, TFormList);
142localstatic void tqualListFreeVars0 (TForm *, TForm, TQualList);
143
144localstatic void sefoUnboundVars0 (TForm *, TForm, Sefo);
145localstatic void symeUnboundVars0 (TForm *, TForm, Syme);
146localstatic void tformUnboundVars0 (TForm *, TForm, TForm);
147localstatic void tqualUnboundVars0 (TForm *, TForm, TQual);
148localstatic void sefoListUnboundVars0 (TForm *, TForm, SefoList);
149localstatic void symeListUnboundVars0 (TForm *, TForm, SymeList);
150localstatic void tformListUnboundVars0 (TForm *, TForm, TFormList);
151localstatic void tqualListUnboundVars0 (TForm *, TForm, TQualList);
152
153localstatic TQualList tqualListSubst (AbSub, TQualList);
154
155localstatic Sefo sefoSubst0 (AbSub, Sefo);
156localstatic Syme symeSubst0 (AbSub, Syme);
157localstatic TForm tformSubst0 (AbSub, TForm);
158localstatic TQual tqualSubst0 (AbSub, TQual);
159localstatic FreeVar freeVarSubst0 (AbSub, FreeVar);
160localstatic SymeList parentListSubst0 (AbSub, SymeList);
161localstatic SefoList condListSubst0 (AbSub, SefoList);
162localstatic SymeList symeListSubst0 (AbSub, SymeList);
163localstatic TFormList tformListSubst0 (AbSub, TFormList);
164localstatic TQualList tqualListSubst0 (AbSub, TQualList);
165
166localstatic void symeListMarkTwins (AbSub, Syme, Syme);
167localstatic void symeListSubstUseConstants(AbSub, SymeList, SymeList,
168 SymeList);
169
170localstatic Bool symeWillPush (Syme);
171localstatic Bool symeWillSubst (AbSub, Syme);
172localstatic Bool tformWillSubst (AbSub, TForm);
173
174localstatic void slcAddSyme (Lib, Syme);
175localstatic void slcAddType (Lib, TForm);
176
177localstatic void sefoClosure0 (Lib, Sefo);
178localstatic void symeClosure0 (Lib, Syme);
179localstatic void symeClosure1 (Lib, Syme);
180localstatic void tformClosure0 (Lib, TForm);
181localstatic void tqualClosure0 (Lib, TQual);
182
183localstatic void sefoListClosure0 (Lib, SefoList);
184localstatic void symeListClosure0 (Lib, SymeList);
185localstatic void tformListClosure0 (Lib, TFormList);
186localstatic void tqualListClosure0 (Lib, TQualList);
187
188localstatic int freeVarToBuffer (Lib, Buffer, FreeVar);
189
190localstatic int tformToBuffer1 (Lib, Buffer, TForm);
191localstatic TForm tformFrBuffer1 (Lib, Buffer);
192
193localstatic void sefoFrBuffer0 (Buffer);
194localstatic void symeFrBuffer0 (Buffer);
195localstatic void tformFrBuffer0 (Buffer);
196localstatic void tqualFrBuffer0 (Buffer);
197localstatic void sefoListFrBuffer0 (Buffer);
198localstatic void tformListFrBuffer0 (Buffer);
199localstatic void tqualListFrBuffer0 (Buffer);
200
201/*****************************************************************************
202 *
203 * :: Sefo/Syme/TForm traversal stack
204 *
205 ****************************************************************************/
206
207union 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
220struct sstFrame {
221 String where;
222 union sstArg arg1;
223 union sstArg arg2;
224 struct sstFrame *prev;
225};
226
227static struct sstFrame *sstStack = 0;
228
229void
230sstStackPush(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
242void
243sstStackPop(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
255int
256sstStackPrint(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
364localstatic int
365sstPrSefo(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
376localstatic int
377sstPrSyme(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
389localstatic int
390sstPrTForm(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
399localstatic int
400sstPrAbSub(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
409localstatic int
410sstPrSefoList(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
422localstatic int
423sstPrSymeList(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
436localstatic int
437sstPrTFormList(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
450localstatic int
451sstPrBool(FILE *fout, int n, Bool flag)
452{
453 return fprintf(fout, "\tArg%d: %s\n", n, flag ? "true" : "false");
454}
455
456localstatic int
457sstPrLib(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
472static 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
519static ULong sstSerialRound = 1; /* sst round counter */
520static ULong sstSerialTraversal = 0; /* sst traversal counter */
521static ULong sstMarkMask = 0; /* active traversal mask */
522static 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
539localstatic void
540sstNext0(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
559localstatic void
560sstDone0(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
573localstatic ULong
574sstSetMark(ULong mark)
575{
576 if (sstRound(mark) == sstSerialRound)
577 return (mark | sstBit());
578 else
579 return sstSet(sstSerialRound, sstBit());
580}
581
582localstatic Bool
583sstIsMarked(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
612static int sstMarkBitNo = -1;
613static SefoMark sstMarkMask = 0;
614static int sstMarkCount = 0;
615static int sstMarkCountSave[SST_NMASK_BITS];
616
617localstatic void
618sstNext0(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
641localstatic void
642sstDone0(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
703static 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
713static int sstMarkDepth = 0; /* current depth of marking. */
714static long sstMarkRound = 0; /* round counter (level 1) */
715static TableList sstMarkStack = 0; /* mark table stack (levels > 1) */
716static Table sstMarkTable = 0; /* current markees (levels > 1) */
717
718localstatic void
719sstNext0(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
732localstatic void
733sstDone0(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
747localstatic void
748sstMarkSyme(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
759localstatic void
760sstMarkTForm(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
802localstatic void sefoClear (Sefo);
803localstatic void symeClear (Syme);
804localstatic void tformClear (TForm);
805localstatic void tqualClear (TQual);
806localstatic void abSubClear (AbSub);
807localstatic void sefoListClear (SefoList);
808localstatic void symeListClear (SymeList);
809localstatic void tformListClear (TFormList);
810localstatic void tqualListClear (TQualList);
811
812localstatic void
813sefoClear(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
828localstatic void
829symeClear(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
849localstatic void
850tformClear(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
898localstatic void
899tqualClear(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
908localstatic void
909abSubClear(AbSub sigma)
910{
911 AbBindList l0;
912 for (l0 = sigma->l; l0; l0 = cdr(l0)((l0)->rest))
913 sefoClear(car(l0)->val);
914}
915
916localstatic void
917sefoListClear(SefoList sefos)
918{
919 for ( ; sefos; sefos = cdr(sefos)((sefos)->rest))
920 sefoClear(car(sefos));
921}
922
923localstatic void
924symeListClear(SymeList symes)
925{
926 for ( ; symes; symes = cdr(symes)((symes)->rest))
927 symeClear(car(symes));
928}
929
930localstatic void
931tformListClear(TFormList tforms)
932{
933 for ( ; tforms; tforms = cdr(tforms)((tforms)->rest))
934 tformClear(car(tforms));
935}
936
937localstatic void
938tqualListClear(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
966void
967sstNextDB(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
985void
986sstDoneDB(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
1017int
1018sefoPrint(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
1029int
1030symePrint(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
1040int
1041symeOStreamWrite(OStream ostream, Syme syme)
1042{
1043 int n = symeOStreamPrint0(ostream, false((int) 0), syme);
1044
1045 return n;
1046}
1047
1048int
1049tformPrint(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
1059int
1060sefoListPrint(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
1071int
1072symeListPrint(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
1083int
1084tformListPrint(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
1099int
1100sefoPrintDb(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
1112int
1113symePrintDb(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
1124int
1125symePrintDb2(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
1135int
1136tformOStreamWrite(OStream ostream, Bool deep, TForm tf)
1137{
1138 int n = tformOStreamPrint0(ostream, deep, tf);
1139
1140 return n;
1141}
1142
1143int
1144sefoOStreamWrite(OStream ostream, Sefo sefo)
1145{
1146 int n = sefoOStreamPrint0(ostream, false((int) 0), sefo);
1147
1148 return n;
1149}
1150
1151int
1152tformPrintDb(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
1163int
1164sefoListPrintDb(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
1175int
1176symeListPrintDb(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
1187int
1188tformListPrintDb(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
1203localstatic int
1204sefoOStreamPrint0(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
1237localstatic int
1238symeOStreamPrint0(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
1276localstatic int
1277tformOStreamPrint0(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. */
1316localstatic int
1317sefoListOStreamPrint0(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. */
1332localstatic int
1333symeListOStreamPrint0(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. */
1348localstatic int
1349tformListOStreamPrint0(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
1369localstatic void symeMarkTwins (Syme);
1370localstatic Bool symeFindTwins (Syme);
1371localstatic void symeClearTwins (Syme);
1372
1373Bool
1374symeIsTwin(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
1387localstatic void
1388symeMarkTwins(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
1399void
1400symeShowTwins(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
1411localstatic Bool
1412symeFindTwins(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
1426localstatic void
1427symeClearTwins(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
1448Bool
1449sefoEqual(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
1463Bool
1464symeEqual(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
1475Bool
1476tformEqual(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
1487Bool
1488sefoListEqual(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
1499Bool
1500symeListEqual(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
1511Bool
1512tformListEqual(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
1527Bool
1528sefoEqualMod(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
1539Bool
1540symeEqualMod(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
1551Bool
1552tformEqualMod(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
1563Bool
1564sefoListEqualMod(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
1575Bool
1576symeListEqualMod(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
1587Bool
1588tformListEqualMod(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
1599Bool
1600symeEqualModConditions(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
1621localstatic Bool
1622sefoIsDefinedType(Sefo sefo)
1623{
1624 TForm cat = abGetCategory(sefo);
1625 return tfIsDefineOfType(cat);
1626}
1627
1628localstatic Sefo
1629sefoDefinedVal(Sefo sefo)
1630{
1631 TForm cat = abGetCategory(sefo);
1632 return tfExpr(tfDefineVal(cat))tfToAbSyn(tfFollowArg(cat, 1));
1633}
1634
1635localstatic Bool
1636sefoEqual0(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
1697localstatic AbEqualValue
1698sefoIdEqual(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)) {
1
Assuming '' is equal to ''
→
2
←
Taking false branch
→
1709 return AbEqual_Struct;
1710 }
1711 else if (abTag(sefo1)((sefo1)->abHdr.tag) != AB_Id) {
3
←
Assuming field 'tag' is equal to AB_Id
→
4
←
Taking false branch
→
1712 return AbEqual_Struct;
1713 }
1714 else {
1715 sefoEqualDEBUGif (!sefoEqualDebug) { } else afprintf(dbOut, "(weak[%d]: %pAbSyn %pAbSyn\n",
5
←
Assuming 'sefoEqualDebug' is 0
→
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)) {
6
←
Taking true branch
→
7
←
Assuming field 'seman' is null
→
8
←
'?' condition is false
→
9
←
Access to field 'id' results in a dereference of a null pointer
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
1730localstatic Bool
1731symeEqual0(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
1822localstatic Bool tformStructSimilar(TForm tf1, TForm tf2);
1823
1824localstatic Bool
1825tformEqual0(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
1957localstatic Bool
1958tformStructSimilar(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
1996localstatic Bool
1997sefoListEqual0(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
2013localstatic Bool
2014symeListEqual0(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
2030localstatic Bool
2031tformListEqual0(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
2047localstatic Bool
2048symeTypeEqual0(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
2059localstatic Bool
2060symeExtendEqual0(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
2113localstatic Bool
2114symeOriginEqual0(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
2169localstatic Bool
2170tformEqualCheckSymes(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
2192localstatic Sefo
2193sefoEqualMods(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
2233Sefo
2234sefoCopy(Sefo sefo)
2235{
2236 Sefo result = abCopy(sefo);
2237 abTransferSemantics(sefo, result);
2238 return result;
2239}
2240
2241/*****************************************************************************
2242 *
2243 * :: sefoAudit
2244 *
2245 ****************************************************************************/
2246
2247Bool
2248sefoAudit(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
2278void
2279sefoFreeVars(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
2295void
2296symeFreeVars(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
2307localstatic int sfvPrint(FILE *out);
2308
2309void
2310tformFreeVars(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
2340void
2341tqualFreeVars(TQual tqual)
2342{
2343 tformFreeVars(tqBase(tqual)((tqual)->base));
2344 tformListFreeVars(tqQual(tqual)((tqual)->qual));
2345}
2346
2347void
2348abSubFreeVars(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
2369void
2370sefoListFreeVars(SefoList sefos)
2371{
2372 for (; sefos; sefos = cdr(sefos)((sefos)->rest))
2373 sefoFreeVars(car(sefos)((sefos)->first));
2374}
2375
2376void
2377symeListFreeVars(SymeList symes)
2378{
2379 for (; symes; symes = cdr(symes)((symes)->rest))
2380 symeFreeVars(car(symes)((symes)->first));
2381}
2382
2383void
2384tformListFreeVars(TFormList tforms)
2385{
2386 for (; tforms; tforms = cdr(tforms)((tforms)->rest))
2387 tformFreeVars(car(tforms)((tforms)->first));
2388}
2389
2390void
2391tqualListFreeVars(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
2401static SymeListList sfvTableList = listNil(SymeList)((SymeListList) 0);
2402static AIntList sfvBase = listNil(AInt)((AIntList) 0);
2403static 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
2410localstatic void
2411sfvInitTable(void)
2412{
2413 sfvBase = listCons(AInt)(AInt_listPointer->Cons)(sfvDepth, sfvBase);
2414}
2415
2416localstatic void
2417sfvFiniTable(void)
2418{
2419 sfvBase = listFreeCons(AInt)(AInt_listPointer->FreeCons)(sfvBase);
2420}
2421
2422localstatic int
2423sfvPrint(FILE *out)
2424{
2425 return afprintf(out,
2426 "(SFV: %d %pAIntList, %pSymeListList)\n",
2427 sfvDepth, sfvBase, sfvTableList);
2428}
2429
2430localstatic void
2431sfvPushTable(void)
2432{
2433 SymeList tbl = listNil(Syme)((SymeList) 0);
2434 sfvTableList = listCons(SymeList)(SymeList_listPointer->Cons)(tbl, sfvTableList);
2435 sfvDepth += 1;
2436}
2437
2438localstatic void
2439sfvConsTable(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
2446localstatic FreeVar
2447sfvPopTable(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
2487localstatic void
2488sfvAddSyme(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
2500localstatic void
2501sfvAddSymes(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
2508localstatic void
2509sfvDelSyme(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
2520localstatic void
2521sfvDelSymes(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
2528localstatic void
2529sfvDelStab(Stab stab)
2530{
2531 sfvDelSymes(stabGetBoundSymes(stab)(((stab)->first)->boundSymes));
2532}
2533
2534localstatic Bool
2535sfvIsAncestor(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
2544localstatic TForm
2545sfvCommonAncestor(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
2559localstatic void
2560sefoFreeVars0(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
2597localstatic void
2598symeFreeVars0(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
2628localstatic void
2629tformFreeVars0(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
2737localstatic void
2738tqualFreeVars0(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
2745localstatic void
2746abSubFreeVars0(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
2753localstatic void
2754sefoListFreeVars0(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
2760localstatic void
2761symeListFreeVars0(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
2767localstatic void
2768tformListFreeVars0(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
2774localstatic void
2775tqualListFreeVars0(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
2781localstatic void
2782sefoUnboundVars0(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
2789localstatic void
2790symeUnboundVars0(TForm *pa, TForm parent, Syme syme)
2791{
2792 symeFreeVars0(pa, parent, syme);
2793}
2794
2795localstatic void
2796tformUnboundVars0(TForm *pa, TForm parent, TForm tf)
2797{
2798 tfGetStab(tf);
2799 tformFreeVars0(pa, parent, tf);
2800}
2801
2802localstatic void
2803tqualUnboundVars0(TForm *pa, TForm parent, TQual tq)
2804{
2805 tqualFreeVars0(pa, parent, tq);
2806}
2807
2808localstatic void
2809sefoListUnboundVars0(TForm *pa, TForm parent, SefoList sefos)
2810{
2811 sefoListFreeVars0(pa, parent, sefos);
2812}
2813
2814localstatic void
2815symeListUnboundVars0(TForm *pa, TForm parent, SymeList symes)
2816{
2817 symeListFreeVars0(pa, parent, symes);
2818}
2819
2820localstatic void
2821tformListUnboundVars0(TForm *pa, TForm parent, TFormList tforms)
2822{
2823 tformListFreeVars0(pa, parent, tforms);
2824}
2825
2826localstatic void
2827tqualListUnboundVars0(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
2842AbSub
2843absFrSymes(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
2854SymeList
2855symeListSubstSelf(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
2894SymeList
2895symeListSubstCat(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
2918SymeList
2919symeListSubstSigma(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
2960TForm
2961tformSubstSigma(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
2982localstatic void
2983symeListMarkTwins(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
2994localstatic void
2995symeListSubstUseConstants(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
3021Sefo
3022sefoSubst(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
3031SefoList
3032sefoListSubst(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
3044Syme
3045symeSubst(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
3054TForm
3055tformSubst(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
3064SymeList
3065symeListSubst(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
3074localstatic TQualList
3075tqualListSubst(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 */
3087localstatic Sefo
3088sefoSubst0(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
3162localstatic Bool
3163tformSubstSkipCategory(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
3178localstatic Bool
3179tformSubstSkipDomain(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
3202localstatic Syme
3203symeSubst0(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
3259localstatic TForm
3260tformSubst0(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
3463localstatic TQual
3464tqualSubst0(AbSub sigma, TQual tq)
3465{
3466 return tqNewFrList(tformSubst0(sigma, tqBase(tq)((tq)->base)),
3467 tformListSubst0(sigma, tqQual(tq)((tq)->qual)));
3468}
3469
3470localstatic FreeVar
3471freeVarSubst0(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. */
3493localstatic SymeList
3494parentListSubst0(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
3502localstatic SefoList
3503condListSubst0(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
3530localstatic SymeList
3531symeListSubst0(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
3542localstatic TFormList
3543tformListSubst0(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
3554localstatic TQualList
3555tqualListSubst0(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. */
3567localstatic Bool
3568symeWillPush(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. */
3594localstatic Bool
3595symeWillSubst(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. */
3619localstatic Bool
3620tformWillSubst(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
3654localstatic void sefoClosureReleaseType (Sefo);
3655/*
3656 * External entry points.
3657 */
3658
3659Bool
3660symeCloseOverDetails(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
3691void
3692symeListClosure(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
3732localstatic void
3733slcAddSyme(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
3746localstatic void
3747slcAddType(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
3755localstatic void
3756sefoClosure0(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
3799localstatic void
3800sefoClosureReleaseType(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 */
3808localstatic void
3809symeClosure0(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 */
3821localstatic void
3822symeClosure1(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
3901localstatic void
3902tformClosure0(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;
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
3982localstatic void
3983tqualClosure0(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
3991localstatic void
3992sefoListClosure0(Lib lib, SefoList sefos)
3993{
3994 for ( ; sefos; sefos = cdr(sefos)((sefos)->rest))
3995 sefoClosure0(lib, car(sefos)((sefos)->first));
3996}
3997
3998localstatic void
3999symeListClosure0(Lib lib, SymeList symes)
4000{
4001 for ( ; symes; symes = cdr(symes)((symes)->rest))
4002 symeClosure0(lib, car(symes)((symes)->first));
4003}
4004
4005localstatic void
4006tformListClosure0(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
4014localstatic void
4015tqualListClosure0(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
4027Bool
4028symeListMember(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. */
4047Bool
4048symeListSubset(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
4056SymeList
4057symeListUnion(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
4084SymeList
4085symeListIntersect(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
4117int
4118sefoToBuffer(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
4168int
4169symeToBuffer(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
4179localstatic int
4180tformToBuffer1(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
4190int
4191tformToBuffer(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
4265int
4266tqualToBuffer(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
4276int
4277sefoListToBuffer(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
4290int
4291symeListToBuffer(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
4304int
4305tformListToBuffer(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
4318int
4319tqualListToBuffer(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
4331localstatic int
4332freeVarToBuffer(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
4363Sefo
4364sefoFrBuffer(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
4432Syme
4433symeFrBuffer(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
4443localstatic TForm
4444tformFrBuffer1(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
4455TForm
4456tformFrBuffer(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
4557TQual
4558tqualFrBuffer(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
4566SefoList
4567sefoListFrBuffer(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
4581SymeList
4582symeListFrBuffer(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
4595TFormList
4596tformListFrBuffer(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
4610TQualList
4611tqualListFrBuffer(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 */
4634int
4635tformTypecFrBuffer(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 */
4648void
4649tformTypepFrBuffer(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
4665localstatic void
4666sefoFrBuffer0(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
4709localstatic void
4710symeFrBuffer0(Buffer buf)
4711{
4712 bufSkip(buf, HINT_BYTES2);
4713}
4714
4715localstatic void
4716tformFrBuffer0(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
4754localstatic void
4755tqualFrBuffer0(Buffer buf)
4756{
4757 bufSkip(buf, SINT_BYTES4);
4758 tformListFrBuffer0(buf);
4759}
4760
4761localstatic void
4762sefoListFrBuffer0(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
4774void
4775symeListFrBuffer0(Buffer buf)
4776{
4777 UShort symec;
4778
4779 symec = bufGetHInt(buf);
4780 bufSkip(buf, symec * HINT_BYTES2);
4781}
4782
4783localstatic void
4784tformListFrBuffer0(Buffer buf)
4785{
4786 UShort tformc;
4787
4788 tformc = bufGetHInt(buf);
4789 bufSkip(buf, tformc * SINT_BYTES4);
4790}
4791
4792localstatic void
4793tqualListFrBuffer0(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
4807SymeList
4808sefoSymes(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}