stab.c

Bug Summary

File:	src/stab.c
Warning:	line 2072, column 3 Value stored to 'tfu' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name stab.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 stab.c

1	/*****************************************************************************
2	*
3	* stab.c: Symbol table definitions.
4	*
5	* Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
6	*
7	****************************************************************************/
8
9	#include "ablogic.h"
10	#include "abpretty.h"
11	#include "axlobs.h"
12	#include "comsg.h"
13	#include "debug.h"
14	#include "doc.h"
15	#include "fint.h"
16	#include "format.h"
17	#include "lib.h"
18	#include "sefo.h"
19	#include "simpl.h"
20	#include "spesym.h"
21	#include "stab.h"
22	#include "store.h"
23	#include "strops.h"
24	#include "table.h"
25	#include "tfsat.h"
26	#include "tposs.h"
27	#include "tqual.h"
28
29	Bool stabDebug = false((int) 0);
30	Bool stabImportDebug = false((int) 0);
31	Bool stabConstDebug = false((int) 0);
32
33	#define stabDEBUGif (!stabDebug) { } else afprintf DEBUG_IF(stab)if (!stabDebug) { } else afprintf
34	#define stabImportDEBUGif (!stabImportDebug) { } else afprintf DEBUG_IF(stabImport)if (!stabImportDebug) { } else afprintf
35	#define stabConstDEBUGif (!stabConstDebug) { } else afprintf DEBUG_IF(stabConst)if (!stabConstDebug) { } else afprintf
36
37	/****************************************************************************
38	*
39	* :: Local function declarations.
40	*
41	****************************************************************************/
42
43	localstatic StabEntry stabEntryNew (void);
44	localstatic StabEntry stabEntryCopy (StabEntry);
45
46	localstatic void stabEntryClearCache (StabEntry);
47	localstatic void stabEntryAddCache (StabEntry, AbLogic, SymeList);
48
49	localstatic void stabEntryPutSyme (StabEntry, Length, Syme);
50	localstatic void stabEntryAddSyme (StabEntry, Syme);
51
52	localstatic Bool stabEntryIsGeneric (StabEntry);
53
54	localstatic SymeList stabEntryAllSymes (StabEntry);
55	localstatic SymeList stabEntryGetSymes (StabEntry, AbLogic);
56	localstatic SymeList stabEntryCacheSymes (StabEntry, AbLogic);
57
58	localstatic TPoss stabEntryAllTypes (StabEntry);
59	localstatic TPoss stabEntryGetTypes (StabEntry, AbLogic);
60	localstatic TPoss stabEntryCacheTypes (StabEntry, Length);
61
62	CREATE_LIST(TFormUses)struct TFormUses_listOpsStruct const TFormUses_listPointer = (struct TFormUses_listOpsStruct const ) &ptrlistOps;
63
64	typedef TFormUses(*UpdateTfuFun)(TFormUses);
65
66	localstatic StabLevel stabNewLevel (int, int, SrcPos, Bool, Bool);
67	localstatic StabEntry stabGetEntry (Stab, Symbol, Bool);
68	localstatic int stabPrEntry (FILE *, TblKey);
69
70	localstatic Bool stabImportIsCovered (SymeList, Syme, Stab);
71	localstatic Bool stabExtendIsCovered (SymeList, Syme);
72
73	localstatic void stabPropagateDecl (Stab, Syme);
74
75	localstatic Bool symeHasExtendee (Syme, Syme);
76	localstatic Syme symeListHasImportee (SymeList, Syme);
77	localstatic void symeRefreshExtendees (Syme);
78
79	localstatic Syme stabGetSymeOfKind (Stab, Symbol, SymeTag);
80	localstatic Syme stabLevelGetSymeOfKind (Stab, Symbol, SymeTag);
81
82	localstatic void stabImportRemark (Stab, TFormList, TForm);
83
84	localstatic TFormUses tfuNew (TForm);
85	localstatic TFormUses tfuSetFlag (Stab, TForm, UpdateTfuFun);
86	localstatic TFormUses tformDoNothing (TFormUses);
87	localstatic TFormUses tformIsImported (TFormUses);
88	localstatic TFormUses tformExportAll (TFormUses);
89	localstatic TFormUses tformImportAll (TFormUses);
90	localstatic TFormUses tformInlineAll (TFormUses);
91	localstatic TFormUses tformExplicitlyImportAll(TFormUses);
92	localstatic TFormUses tformCategoricallyImport(TFormUses);
93	localstatic TFormUses tformParameterImport (TFormUses);
94
95	localstatic TForm addTFormUnused (Stab stab, TForm tf);
96	localstatic TForm findTFormUnused (Stab stab, AbSyn ab);
97	localstatic void removeTFormUnused (Stab stab, TForm tf);
98
99	#define stabUseList(stab,ab)!(((stab)->first)->tformsUsed.table) !stabLevelIsLarge(stab)(((stab)->first)->tformsUsed.table)
100	#define stabUseTable(stab,ab)(((stab)->first)->tformsUsed.table) stabLevelIsLarge(stab)(((stab)->first)->tformsUsed.table)
101
102	#define tfuSetUnqualified(f,tf)((f) = (f) ? tqSetUnqualified(f) : tqNewUnqualified(tf)) \
103	((f) = (f) ? tqSetUnqualified(f) : tqNewUnqualified(tf))
104	#define tfuSetQualified(f,tf,q)((f) = (f) ? (((f)->isQual == 1) ? tqAddQual(f,q) : (f)) : tqNewQualified(tf,q)) \
105	((f) = (f) ? (tqIsQualified(f)((f)->isQual == 1) ? tqAddQual(f,q) : (f)) \
106	: tqNewQualified(tf,q))
107
108	#define tfuCreateIfNeeded(f,tf)((f)=(f)?(f):tqNewEmpty(tf)) ((f)=(f)?(f):tqNewEmpty(tf))
109
110	/****************************************************************************
111	*
112	* :: -Wdumb-import options
113	*
114	****************************************************************************/
115
116	static Bool stabDumbImportFlag = false((int) 0);
117
118	Bool
119	stabDumbImport(void)
120	{
121	return stabDumbImportFlag;
122	}
123
124
125	void
126	stabSetDumbImport(Bool flag)
127	{
128	stabDumbImportFlag = flag;
129	}
130
131	/****************************************************************************
132	*
133	* :: stabMaxSerialNo/stabMaxDefnNum
134	*
135	****************************************************************************/
136
137	static ULong stabSerialNoCounter = 0; /* unique index per stab lvl */
138	static ULong stabDefinitionCounter = 0; /* unique index per defn */
139
140	ULong
141	stabMaxSerialNo(void)
142	{
143	return stabSerialNoCounter;
144	}
145
146	UShort
147	stabMaxDefnNum(void)
148	{
149	return stabDefinitionCounter;
150	}
151
152	/****************************************************************************
153	*
154	* :: StabGlobal/StabFile
155	*
156	****************************************************************************/
157
158	static Stab StabGlobal = 0; /* Persists across all files. */
159	static Stab StabFile = 0; /* Persists across one file. */
160
161	void
162	stabInitGlobal(void)
163	{
164	StabGlobal = stabNewGlobal();
165	return;
166	}
167
168	void
169	stabInitFile(void)
170	{
171	StabFile = stabNewFile(StabGlobal);
172	stabDefinitionCounter = 0;
173	return;
174	}
175
176	Stab
177	stabNewGlobal(void)
178	{
179	StabLevel slev = stabNewLevel(int0((int) 0), int0((int) 0), sposNone, false((int) 0), false((int) 0)); /* small */
180
181	Stab stab = listCons(StabLevel)(StabLevel_listPointer->Cons) (slev, listNil(StabLevel)((StabLevelList) 0));
182	stabClrSubstable(stab)(((stab)->first)->isSubstable=((int) 0));
183
184	return stab;
185	}
186
187	Stab
188	stabNewFile(Stab globalStab)
189	{
190	StabLevel slev = stabNewLevel(1, 1, sposNone, true1, false((int) 0)); /* large level */
191
192	Stab fileStab = listCons(StabLevel)(StabLevel_listPointer->Cons) (slev, globalStab);
193	assert(listLength(StabLevel)(globalStab) == 1)do { if (!((StabLevel_listPointer->_Length)(globalStab) == 1)) _do_assert(("listLength(StabLevel)(globalStab) == 1"),"stab.c" ,193); } while (0);
194
195	stabClrSubstable(fileStab)(((fileStab)->first)->isSubstable=((int) 0));
196
197	return fileStab;
198	}
199
200	void
201	stabFiniGlobal(void)
202	{
203	/* stabFree(StabGlobal); */
204	StabGlobal = 0;
205	return;
206	}
207
208	void
209	stabFiniFile(void)
210	{
211	/* stabFree(StabFile); */
212	StabFile = 0;
213	return;
214	}
215
216	Stab
217	stabGlobal(void)
218	{
219	return StabGlobal;
220	}
221
222	Stab
223	stabFile(void)
224	{
225	return StabFile ? StabFile : StabGlobal;
226	}
227
228	/****************************************************************************
229	*
230	* :: Symbol table entries.
231	*
232	****************************************************************************/
233
234	/*
235	* Each stab entry has an array of syme lists, keyed by condition,
236	* which represents the cached result of stabGetSymes under various
237	* conditions.
238	*
239	* The cache is set up to make common accesses quickly:
240	* index 0 - condv == ablogTrue()
241	* The list of unconditional symes are always found here.
242	* index 1 - condv == ablogFalse()
243	* The list of all symes are found here, when conditional
244	* meanings exist for this symbol in this stab.
245	*
246	* So if no conditional symes are present, we go right to the list.
247	* If we ask for the symes present when no conditions are assumed, ditto.
248	* If we repeatedly ask for symes under the same condition, ditto.
249	* Otherwise we filter through the list of all symes (at index 1).
250	*/
251
252	#define StabEntryCacheSize4 4
253	localstatic void stabEntryCheckConditions(StabEntry stent);
254
255	localstatic StabEntry
256	stabEntryNew(void)
257	{
258	StabEntry stent;
259	Length argc, cc, i;
260
261	argc = StabEntryCacheSize4;
262	cc = sizeof(AbLogic ) + sizeof(SymeList ) + sizeof(TPoss *);
263	cc = sizeof(stent) + argc cc;
264
265	stent = (StabEntry) stoAlloc((unsigned) OB_Other0, cc);
266
267	stent->argc = 0;
268	stent->condv = (AbLogic *) (stent + 1);
269	stent->symev = (SymeList *) (stent->condv + argc);
270	stent->possv = (TPoss *) (stent->symev + argc);
271	stent->pending = listNil(Syme)((SymeList) 0);
272
273	for (i = 0; i < argc; i += 1) {
274	stent->condv[i] = NULL((void*)0);
275	stent->symev[i] = listNil(Syme)((SymeList) 0);
276	stent->possv[i] = NULL((void*)0);
277	}
278
279	stabEntryAddCache(stent, ablogTrue(), listNil(Syme)((SymeList) 0));
280
281	return stent;
282	}
283
284	localstatic StabEntry
285	stabEntryCopy(StabEntry stent)
286	{
287	StabEntry nstent = stabEntryNew();
288	Length i;
289
290	nstent->argc = stent->argc;
291	if (nstent->argc > 2) nstent->argc = 2;
292
293	for (i = 0; i < nstent->argc; i += 1) {
294	nstent->condv[i] = ablogCopy(stent->condv[i]);
295	nstent->symev[i] = listCopy(Syme)(Syme_listPointer->Copy)(stent->symev[i]);
296	nstent->possv[i] = tpossCopy(stent->possv[i]);
297	}
298	nstent->pending = listCopy(Syme)(Syme_listPointer->Copy)(stent->pending);
299
300	return nstent;
301	}
302
303	localstatic void
304	stabEntryClearCache(StabEntry stent)
305	{
306	Length i;
307
308	tpossFree(stent->possv[0]);
309	stent->possv[0] = NULL((void*)0);
310
311	if (stabEntryIsGeneric(stent))
312	return;
313
314	tpossFree(stent->possv[1]);
315	stent->possv[1] = NULL((void*)0);
316
317	for (i = 2; i < stent->argc; i += 1) {
318	ablogFree(stent->condv[i]);
319	listFree(Syme)(Syme_listPointer->Free)(stent->symev[i]);
320	tpossFree(stent->possv[i]);
321
322	stent->condv[i] = NULL((void*)0);
323	stent->symev[i] = listNil(Syme)((SymeList) 0);
324	stent->possv[i] = NULL((void*)0);
325	}
326	stent->argc = 2;
327	}
328
329	localstatic void
330	stabEntryAddCache(StabEntry stent, AbLogic abl, SymeList symes)
331	{
332	assert(stent->argc < StabEntryCacheSize)do { if (!(stent->argc < 4)) _do_assert(("stent->argc < StabEntryCacheSize" ),"stab.c",332); } while (0);
333	stent->condv[stent->argc] = abl;
334	stent->symev[stent->argc] = symes;
335	stent->possv[stent->argc] = NULL((void*)0);
336	stent->argc += 1;
337	}
338
339	localstatic void
340	stabEntryPutSyme(StabEntry stent, Length i, Syme syme)
341	{
342	stent->symev[i] = listCons(Syme)(Syme_listPointer->Cons)(syme, stent->symev[i]);
343	}
344
345	localstatic void
346	stabEntryAddSyme(StabEntry stent, Syme syme)
347	{
348	stabEntryClearCache(stent);
349
350	if (symeIsCheckCondIncomplete(syme)(((AInt) (SYFI_ExtraBits < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_ExtraBits ))) ? (symeFieldInfo[SYFI_ExtraBits].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0 )), (syme))->locmask) & (1 << (SYFI_ExtraBits))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme )->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_ExtraBits))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ExtraBits )] : (symeFieldInfo[SYFI_ExtraBits].def)) : symeGetFieldFn(syme ,SYFI_ExtraBits))) & (0x0004))) {
351	stent->pending = listCons(Syme)(Syme_listPointer->Cons)(syme, stent->pending);
352	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, "Pending condition: %pSyme %pAbSynList\n",
353	syme, symeCondition(syme));
354	}
355	if (!symeIsCondChecked(syme)(((AInt) (SYFI_ExtraBits < (8 * sizeof(int)) && !( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_ExtraBits ))) ? (symeFieldInfo[SYFI_ExtraBits].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0 )), (syme))->locmask) & (1 << (SYFI_ExtraBits))) ? ((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme )->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_ExtraBits))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_ExtraBits )] : (symeFieldInfo[SYFI_ExtraBits].def)) : symeGetFieldFn(syme ,SYFI_ExtraBits))) & (0x0008)) && symeCondition(syme)) {
356	stent->pending = listCons(Syme)(Syme_listPointer->Cons)(syme, stent->pending);
357	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, "Pending condition [unchecked]: %pSyme %pAbSynList\n",
358	syme, symeCondition(syme));
359	}
360	if (symeCondIsLazy(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->bits) & (0x8000))) {
361	stabEntryPutSyme(stent, int0((int) 0), syme);
362	if (!stabEntryIsGeneric(stent))
363	stabEntryPutSyme(stent, 1, syme);
364	}
365	else if (symeCondition(syme)) {
366	if (stabEntryIsGeneric(stent)) {
367	SymeList osymes = stent->symev[0];
368	stabEntryAddCache(stent, ablogFalse(), osymes);
369	}
370	stabEntryPutSyme(stent, 1, syme);
371	}
372	else {
373	stabEntryPutSyme(stent, int0((int) 0), syme);
374	if (!stabEntryIsGeneric(stent))
375	stabEntryPutSyme(stent, 1, syme);
376	}
377	}
378
379	localstatic Bool
380	stabEntryIsGeneric(StabEntry stent)
381	{
382	/* Return true if all symes in stent are unconditional. */
383	return stent->argc == 1;
384	}
385
386	localstatic SymeList
387	stabEntryAllSymes(StabEntry stent)
388	{
389	return stabEntryGetSymes(stent, ablogFalse());
390	}
391
392	localstatic SymeList
393	stabEntryGetSymes(StabEntry stent, AbLogic abl)
394	{
395	Length i;
396	SymeList symes;
397
398	if (abl != NULL((void*)0) && ablogEqual(abl, ablogFalse())) {
399	if (stent->argc == 1) {
400	return stent->symev[0];
401	}
402	else {
403	assert(ablogEqual(stent->condv[1], ablogFalse()))do { if (!(ablogEqual(stent->condv[1], ablogFalse()))) _do_assert (("ablogEqual(stent->condv[1], ablogFalse())"),"stab.c",403 ); } while (0);
404	return stent->symev[1];
405	}
406	}
407
408	stabEntryCheckConditions(stent);
409
410	/* Generic entry: no conditional symes, return them all. */
411	if (stent->argc == 1)
412	return stent->symev[0];
413
414	/* Generic query: return the unconditional symes. */
415	if (abl == NULL((void*)0) \|\| ablogIsTrue(abl))
416	return stent->symev[0];
417
418	/* Check the cache. */
419	for (i = 1; i < stent->argc; i += 1)
420	if (ablogEqual(abl, stent->condv[i]))
421	return stent->symev[i];
422
423	/* Filter the symes. */
424	symes = stabEntryCacheSymes(stent, abl);
425
426	/* Cache the result. */
427	if (stent->argc < StabEntryCacheSize4)
428	stabEntryAddCache(stent, ablogCopy(abl), listCopy(Syme)(Syme_listPointer->Copy)(symes));
429
430	return symes;
431	}
432
433	localstatic void
434	stabEntryCheckConditions(StabEntry stent)
435	{
436	SymeList psymes, npsymes;
437
438	psymes = stent->pending;
439	npsymes = listNil(Syme)((SymeList) 0);
440	while (psymes != listNil(Syme)((SymeList) 0)) {
441	Syme psyme = car(psymes)((psymes)->first);
442	psymes = cdr(psymes)((psymes)->rest);
443
444	if (!symeCheckCondition(psyme)) {
445	continue;
446	}
447
448	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, "Checked: %pSyme - complete: %d condition: %pAbSynList\n",
449	psyme, symeIsCheckCondIncomplete(psyme)(((AInt) (SYFI_ExtraBits < (8 * sizeof(int)) && !( ((((psyme)->kind == SYME_Trigger ? libGetAllSymes((psyme)-> lib) : ((void)0)), (psyme))->hasmask) & (1 << ( SYFI_ExtraBits))) ? (symeFieldInfo[SYFI_ExtraBits].def) : ((( ((psyme)->kind == SYME_Trigger ? libGetAllSymes((psyme)-> lib) : ((void)0)), (psyme))->locmask) & (1 << ( SYFI_ExtraBits))) ? ((((((psyme)->kind == SYME_Trigger ? libGetAllSymes ((psyme)->lib) : ((void*)0)), (psyme))->locmask) & ( 1 << (SYFI_ExtraBits))) ? ((psyme)->fieldv)[symeIndex (psyme,SYFI_ExtraBits)] : (symeFieldInfo[SYFI_ExtraBits].def) ) : symeGetFieldFn(psyme,SYFI_ExtraBits))) & (0x0004)),
450	symeCondition(psyme));
451
452	if (symeCondition(psyme) == listNil(Sefo)((SefoList) 0)) {
453	stabEntryPutSyme(stent, int0((int) 0), psyme);
454	}
455	if (symeIsCheckCondIncomplete(psyme)(((AInt) (SYFI_ExtraBits < (8 * sizeof(int)) && !( ((((psyme)->kind == SYME_Trigger ? libGetAllSymes((psyme)-> lib) : ((void)0)), (psyme))->hasmask) & (1 << ( SYFI_ExtraBits))) ? (symeFieldInfo[SYFI_ExtraBits].def) : ((( ((psyme)->kind == SYME_Trigger ? libGetAllSymes((psyme)-> lib) : ((void)0)), (psyme))->locmask) & (1 << ( SYFI_ExtraBits))) ? ((((((psyme)->kind == SYME_Trigger ? libGetAllSymes ((psyme)->lib) : ((void*)0)), (psyme))->locmask) & ( 1 << (SYFI_ExtraBits))) ? ((psyme)->fieldv)[symeIndex (psyme,SYFI_ExtraBits)] : (symeFieldInfo[SYFI_ExtraBits].def) ) : symeGetFieldFn(psyme,SYFI_ExtraBits))) & (0x0004))) {
456	npsymes = listCons(Syme)(Syme_listPointer->Cons)(psyme, npsymes);
457	}
458	}
459	listFree(Syme)(Syme_listPointer->Free)(stent->pending);
460	stent->pending = npsymes;
461	}
462
463
464	localstatic SymeList
465	stabEntryCacheSymes(StabEntry stent, AbLogic abl)
466	{
467	SymeList symes, nsymes;
468
469	/* When conditional symes are present, all symes are at index 1. */
470	nsymes = listNil(Syme)((SymeList) 0);
471	for (symes = stent->symev[1]; symes; symes = cdr(symes)((symes)->rest)) {
472	Syme syme = car(symes)((symes)->first);
473	if (ablogIsListImplied(abl, symeCondition(syme)))
474	nsymes = listCons(Syme)(Syme_listPointer->Cons)(syme, nsymes);
475	}
476
477	nsymes = listNReverse(Syme)(Syme_listPointer->NReverse)(nsymes);
478	return nsymes;
479	}
480
481	localstatic TPoss
482	stabEntryAllTypes(StabEntry stent)
483	{
484	return stabEntryGetTypes(stent, ablogFalse());
485	}
486
487	localstatic TPoss
488	stabEntryGetTypes(StabEntry stent, AbLogic abl)
489	{
490	Length i;
491	SymeList symes;
492	TPoss tposs;
493
494	stabEntryCheckConditions(stent);
495
496	/* Generic query: return the unconditional types. */
497	if (abl == NULL((void*)0) \|\| ablogIsTrue(abl))
498	return stabEntryCacheTypes(stent, int0((int) 0));
499
500	/* Check the cache. */
501	for (i = 1; i < stent->argc; i += 1)
502	if (ablogEqual(abl, stent->condv[i]))
503	return stabEntryCacheTypes(stent, i);
504
505	/* Filter the symes. */
506	symes = stabEntryCacheSymes(stent, abl);
507	tposs = tpossFrSymes(symes);
508
509	/* Cache the result. */
510	if (stent->argc < StabEntryCacheSize4) {
511	stabEntryAddCache(stent, ablogCopy(abl), symes);
512	stent->possv[i] = tpossRefer(tposs);
513	}
514
515	return tposs;
516	}
517
518	localstatic TPoss
519	stabEntryCacheTypes(StabEntry stent, Length i)
520	{
521	assert(i < stent->argc)do { if (!(i < stent->argc)) _do_assert(("i < stent->argc" ),"stab.c",521); } while (0);
522	if (stent->possv[i] == NULL((void*)0))
523	stent->possv[i] = tpossFrSymes(stent->symev[i]);
524	return tpossRefer(stent->possv[i]);
525	}
526
527	/****************************************************************************
528	*
529	* Local structure manipulation.
530	*
531	****************************************************************************/
532
533	localstatic StabLevel
534	stabNewLevel(int levno, int lamno, SrcPos spos, Bool isLargeLevel, Bool isGenerator)
535	{
536	StabLevel slev;
537
538	slev = (StabLevel) stoAlloc((unsigned) OB_Stab(14 + 6), sizeof(*slev));
539
540	slev->lexicalLevel = levno;
541	slev->lambdaLevel = lamno;
542	slev->serialNo = stabSerialNoCounter++;
543	slev->hash = slev->serialNo;
544	slev->isLocked = false((int) 0);
545	slev->isChecked = false((int) 0);
546	slev->isSubstable = true1;
547	slev->isGenerator = isGenerator;
548	slev->intStepNo = intStepNo;
549	slev->tbl = tblNew((TblHashFun) 0, (TblEqFun) 0);
550	slev->children = listNil(Stab)((StabList) 0);
551	slev->spos = spos;
552	slev->idsInScope = 0;
553	slev->labelsInScope = listNil(AbSyn)((AbSynList) 0);
554
555	slev->tformsUsed.list = listNil(TFormUses)((TFormUsesList) 0);
556	slev->tformsUnused = listNil(TForm)((TFormList) 0);
557
558	/*
559	* large levels have a non-0 hash table for faster lookup of tforms.
560	*/
561	slev->tformsUsed.table = isLargeLevel ?
562	tblNew((TblHashFun) abHash, (TblEqFun) abEqual) : NULL((void*)0);
563
564	slev->boundSymes = listNil(Syme)((SymeList) 0);
565	slev->extendSymes = listNil(Syme)((SymeList) 0);
566	slev->exportedTypes = NULL((void*)0);
567
568	return slev;
569	}
570
571	/****************************************************************************
572	*
573	* Exported operations.
574	*
575	****************************************************************************/
576
577	Stab
578	stabPushLevel(Stab stab, SrcPos spos, ULong flags)
579	{
580	StabLevel slev;
581	Stab oldStab = stab;
582	int levno, lamno;
583
584	Bool isLargeLevel = (flags & STAB_LEVEL_LARGE(1<<1)) ? 1 : 0;
585	Bool isLoopLevel = (flags & STAB_LEVEL_LOOP(1<<2)) ? 1 : 0;
586	Bool isCollectLevel= (flags & STAB_LEVEL_COLLECT(1<<5)) ? 1 : 0;
587	Bool isWhereLevel = (flags & STAB_LEVEL_WHERE(1<<3)) ? 1 : 0;
588	Bool isGenLevel = (flags & STAB_LEVEL_XGENERATE(1<<4)) ? 1 : 0;
589	Bool isLoopLike = isLoopLevel \|\| isCollectLevel;
590	Bool isProgLevel = !isLoopLike && !isWhereLevel;
591
592	assert(stab != 0)do { if (!(stab != 0)) _do_assert(("stab != 0"),"stab.c",592) ; } while (0);
593
594	levno = car(stab)((stab)->first)->lexicalLevel + (isLoopLike ? 0 : 1);
595	lamno = car(stab)((stab)->first)->lambdaLevel + (isProgLevel ? 1 : 0);
596
597	slev = stabNewLevel(levno, lamno, spos, isLargeLevel, isGenLevel);
598	stab = listCons(StabLevel)(StabLevel_listPointer->Cons) (slev, stab);
599	car(oldStab)((oldStab)->first)->children =
600	listCons(Stab)(Stab_listPointer->Cons) (stab, car(oldStab)((oldStab)->first)->children);
601
602	return stab;
603	}
604
605	Stab
606	stabPopLevel(Stab stab)
607	{
608	return cdr(stab)((stab)->rest);
609	}
610
611	void
612	stabFree(Stab stab)
613	{
614	/!!/
615	}
616
617	/******************************************************************************
618	*
619	* :: Symbol lookup
620	*
621	*****************************************************************************/
622
623	/*
624	* Get entry for "id" in "stab". If "id" has never been searched at this
625	* level, then the meanings from the outer level are added at this level.
626	*/
627
628	localstatic StabEntry
629	stabGetEntry(Stab stab0, Symbol id, Bool recurse)
630	{
631	Stab stab;
632	StabEntry stent;
633	Bool first = true1;
634
635	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, "Searching for symbol %s", symString(id)((id)->str));
636
637	stab = stab0;
638	stent = 0;
639	while (stab && !stent) {
640	stabDEBUGif (!stabDebug) { } else afprintf(dbOut,
641	(first ? " looking in level %lu" : ", %lu"),
642	stabLevelNo(stab)(((stab)->first)->lexicalLevel));
643	first = false((int) 0);
644	stent = (StabEntry) tblElt(car(stab)((stab)->first)->tbl, id, NULL((void*)0));
645	if (! recurse)
646	break;
647	if (! stent)
648	stab = cdr(stab)((stab)->rest);
649	}
650
651	if (!stent) {
652	stent = stabEntryNew();
653	tblSetElt(car(stab0)((stab0)->first)->tbl, id, stent);
654	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, " ... manufacturing");
655	}
656	else if (stab != stab0) {
657	stent = stabEntryCopy(stent);
658	tblSetElt(car(stab0)((stab0)->first)->tbl, id, stent);
659	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, " ... copying");
660	}
661
662
663	if (DEBUG(stab)stabDebug) {
664	fnewline(dbOut);
665	}
666	stabEntryGetTypes(stent, ablogFalse());
667
668	if (DEBUG(stab)stabDebug) {
669	SymeList sl = stabEntryAllSymes(stent);
670	TPoss tp = stabEntryAllTypes(stent);
671	int i;
672
673	if (sl) {
674	findent += 2;
675	fnewline(dbOut);
676	fprintf(dbOut, "Meanings found: ");
677	findent++;
678	fnewline(dbOut);
679	for (i = 1; sl; i++, sl = cdr(sl)((sl)->rest)) {
680	fprintf(dbOut,"%2d. ",i);
681	symePrint(dbOut, car(sl)((sl)->first));
682	if (cdr(sl)((sl)->rest))
683	fnewline(dbOut);
684	}
685	findent -= 3;
686	}
687
688	if (tp && tpossCount(tp)) {
689	TPossIterator tit;
690
691	findent += 2;
692	fnewline(dbOut);
693	fprintf(dbOut, "Types found:");
694	findent++;
695	fnewline(dbOut);
696
697	for (i = 1, tpossITER(tit, tp)((tit).possl = (tp ? (tp)->possl : ((void*)0)));
698	tpossMORE(tit)((tit).possl);
699	i++, tpossSTEP(tit)((tit).possl = (((tit).possl)->rest)))
700	{
701	fprintf(dbOut,"%2d. ",i);
702	tfPrint(dbOut, tpossELT(tit)tpossELT_(&tit));
703	if (tpossMORE(tit)((tit).possl))
704	fnewline(dbOut);
705	}
706	findent -= 3;
707	}
708	fnewline(dbOut);
709	}
710
711	return stent;
712	}
713
714	/*
715	* For each constant symbol here, add meanings from outer levels.
716	*/
717
718	void
719	stabSeeOuterImports(Stab stab0)
720	{
721	TableIterator it;
722
723	for (tblITER(it, car(stab0)->tbl)_tblITER(&(it), ((stab0)->first)->tbl); tblMORE(it)((it).curr <= (it).last); tblSTEP(it)((((it).link=(it).link->next))==0 ? _tblSTEP(&(it)) : 1 )) {
724	Symbol symb = (Symbol) tblKEY(it)((it).link->key);
725	StabEntry stent0 = (StabEntry) tblELT(it)((it).link->elt);
726	SymeList symes0 = stabEntryAllSymes(stent0);
727	Stab stab;
728	StabEntry stent = NULL((void*)0);
729	SymeList symes;
730
731	/* Consider only symbols with constant meanings. */
732	if (symes0 == NULL((void*)0))
733	continue;
734
735	if (symeIsParam(car(symes0))(((((((symes0)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes0)->first))->lib) : ((void*)0)), (((symes0)-> first)))->kind) == SYME_Param) \|\|
736	symeIsLexVar(car(symes0))(((((((symes0)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes0)->first))->lib) : ((void*)0)), (((symes0)-> first)))->kind) == SYME_LexVar) \|\|
737	symeIsExtend(car(symes0))(((((((symes0)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes0)->first))->lib) : ((void*)0)), (((symes0)-> first)))->kind) == SYME_Extend))
738	continue;
739
740	/* Establish there is something to add. */
741	for (stab = cdr(stab0)((stab0)->rest); !stent && stab; stab = cdr(stab)((stab)->rest))
742	stent = (StabEntry) tblElt(car(stab)((stab)->first)->tbl, symb, NULL((void*)0));
743	if (stent == NULL((void*)0))
744	continue;
745
746	/* Get outer meanings that are not covered. */
747	/* Outer imports are covered by local exports. */
748	for (symes = stabEntryAllSymes(stent); symes; symes = cdr(symes)((symes)->rest)) {
749	Syme syme = car(symes)((symes)->first);
750	Bool covered;
751
752	if (listMemq(Syme)(Syme_listPointer->Memq)(symes0, syme))
753	covered = true1;
754	else if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Extend))
755	covered = stabExtendIsCovered(symes0, syme);
756	else if (symeIsImport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Import))
757	covered = stabImportIsCovered(symes0, syme,
758	stab0);
759	else
760	covered = false((int) 0);
761
762	if (!covered)
763	stabEntryAddSyme(stent0, syme);
764	}
765	}
766	}
767
768	localstatic Bool
769	stabImportIsCovered(SymeList symes, Syme syme, Stab stab)
770	{
771	Syme syme0;
772	TForm tf0;
773	SymeList aself;
774	Syme asyme;
775	TForm tfd;
776
777	if (symeListHasImportee(symes, syme))
778	return true1;
779
780	for (; symes; symes = cdr(symes)((symes)->rest)) {
781	syme0 = car(symes)((symes)->first);
782	if (!symeIsExport(syme0)(((((syme0)->kind == SYME_Trigger ? libGetAllSymes((syme0) ->lib) : ((void*)0)), (syme0))->kind) == SYME_Export)) continue;
783
784	tf0 = symeType(syme0);
785	if (tfEqual(symeType(syme), tf0))
786	return true1;
787
788	if (!tfEqual(symeType(symeOriginal(syme)), tf0))
789	continue;
790
791	aself = tfGetSelfFrStab(stab);
792	asyme = (aself ? car(aself)((aself)->first) : NULL((void*)0));
793	tfd = (asyme ? symeType(asyme) : NULL((void*)0));
794	if (tfd && tfIsDefineOfType(tfd) &&
795	tfEqual(tfDefineVal(tfd)tfFollowArg(tfd, 1), symeExporter(syme)))
796	return true1;
797	}
798	return false((int) 0);
799	}
800
801	localstatic Bool
802	stabExtendIsCovered(SymeList symes, Syme syme)
803	{
804	for (; symes; symes = cdr(symes)((symes)->rest))
805	if (symeExtension(car(symes)((symes)->first)) == syme)
806	return true1;
807	return false((int) 0);
808	}
809
810	void
811	stabGetSubstable(Stab stab)
812	{
813	SymeList symes;
814
815	if (stab == stabGlobal()) return;
816
817	stabLevelIsSubstable(stab)(((stab)->first)->isSubstable) = stabLevelIsSubstable(cdr(stab))(((((stab)->rest))->first)->isSubstable);
818	symes = stabGetBoundSymes(stab)(((stab)->first)->boundSymes);
819	for (; !stabLevelIsSubstable(stab)(((stab)->first)->isSubstable) && symes; symes = cdr(symes)((symes)->rest))
820	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)))))
821	stabSetSubstable(stab)(((stab)->first)->isSubstable=1);
822	}
823
824	void
825	stabExtendMeanings(Stab stab, Syme syme)
826	{
827	StabEntry stent = stabGetEntry(stab, symeId(syme)((syme)->id), true1);
828	Length i;
829
830	if (stent) {
831	stabEntryClearCache(stent);
832	for (i = 0; i < stent->argc; i += 1) {
833	stent->symev[i] = symeListExtend(stent->symev[i], syme);
834
835	}
836	}
837
838	car(stab)((stab)->first)->boundSymes = symeListExtend(car(stab)((stab)->first)->boundSymes, syme);
839	}
840
841	SymeList
842	symeListExtend(SymeList symes, Syme syme)
843	{
844	SymeList result;
845	Syme xsyme;
846
847	if (symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Extend))
848	xsyme = syme;
849	else if (symeIsImportOfExtend(syme)((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Import) && (((((symeOriginal(syme))->kind == SYME_Trigger ? libGetAllSymes ((symeOriginal(syme))->lib) : ((void)0)), (symeOriginal(syme )))->kind) == SYME_Extend)))
850	xsyme = symeOriginal(syme);
851	else
852	return symes;
853
854	result = listNil(Syme)((SymeList) 0);
855
856	#if 0
857	{
858	SymeList tmp = symes;
859
860	printf("(Adding: %p %p %s\nCurrent: %s\nOrigin: %s\n",
861	syme, xsyme,
862	syme->id->str,
863	syme->lib && syme->lib->name ? syme->lib->name->partv[1]: "Local",
864	xsyme->lib->name->partv[1]);
865
866
867	while (tmp) {
868	printf("%p %s %s\n", car(tmp)((tmp)->first),
869	car(tmp)((tmp)->first)->lib && car(tmp)((tmp)->first)->lib->name
870	? car(tmp)((tmp)->first)->lib->name->partv[1] : "Local",
871	car(tmp)((tmp)->first)->id->str);
872	tmp = cdr(tmp)((tmp)->rest);
873	}
874	printf("\n");
875	}
876	#endif
877	for (; symes; symes = listFreeCons(Syme)(Syme_listPointer->FreeCons)(symes)) {
878	/*if (symeOriginal(car(symes)) == xsyme)
879	stabExtendPair(symeOriginal(car(symes)), xsyme);
880	else*/ if (car(symes)((symes)->first) != syme && symeExtension(car(symes)((symes)->first)) != syme)
881	result = listCons(Syme)(Syme_listPointer->Cons)(car(symes)((symes)->first), result);
882	else {
883	#if 0
884	printf("Deleted: %p %s %s\n",
885	car(symes)((symes)->first),
886	car(symes)((symes)->first)->lib && car(symes)((symes)->first)->lib->name
887	? car(symes)((symes)->first)->lib->name->partv[1] : "Local",
888	car(symes)((symes)->first)->id->str);
889	#endif
890	}
891	}
892	result = listCons(Syme)(Syme_listPointer->Cons)(syme, listNReverse(Syme)(Syme_listPointer->NReverse)(result));
893
894	return result;
895	}
896
897	/* Is syme1 an extendee of syme2? */
898	localstatic Bool
899	symeHasExtendee(Syme syme1, Syme syme2)
900	{
901	SymeList symes;
902	Bool result = false((int) 0);
903
904	assert(symeIsExtend(syme2))do { if (!((((((syme2)->kind == SYME_Trigger ? libGetAllSymes ((syme2)->lib) : ((void*)0)), (syme2))->kind) == SYME_Extend ))) _do_assert(("symeIsExtend(syme2)"),"stab.c",904); } while (0);
905
906	symes = symeExtendee(syme2);
907	for (; !result && symes; symes = cdr(symes)((symes)->rest)) {
908	Syme ext0 = car(symes)((symes)->first);
909	Syme ext1 = symeExtension(ext0);
910	symeSetExtension(ext0, NULL)symeXSetExtension(ext0, (AInt) ((void*)0));
911	result = symeEqual(symeOriginal(syme1), ext0);
912	symeSetExtension(ext0, ext1)symeXSetExtension(ext0, (AInt) ext1);
913	}
914
915	return result;
916	}
917
918	/* Is there an import for syme2 in symes? */
919	localstatic Syme
920	symeListHasImportee(SymeList symes, Syme syme2)
921	{
922	Syme result = NULL((void*)0);
923
924	for (; !result && symes; symes = cdr(symes)((symes)->rest)) {
925	Syme syme1 = car(symes)((symes)->first);
926	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) &&
927	symeOriginal(syme1) == symeOriginal(syme2) &&
928	tformEqual(symeExporter(syme1), symeExporter(syme2)) &&
929	tformEqual(symeType(syme1), symeType(syme2)) &&
930	sefoListEqualMod(NULL((void*)0), symeCondition(syme1),
931	symeCondition(syme2)))
932	result = syme1;
933	}
934	return result;
935	}
936
937	/* Is there an extension of syme1 in symes? */
938	Syme
939	symeListHasExtension(SymeList symes, Syme syme1)
940	{
941	Syme result = NULL((void*)0);
942
943	for (; !result && symes; symes = cdr(symes)((symes)->rest)) {
944	Syme syme2 = car(symes)((symes)->first);
945	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)) &&
946	symeHasExtendee(syme1, symeOriginal(syme2)))
947	result = syme2;
948	}
949	return result;
950	}
951
952	/* Is there an extendee of syme2 in symes? */
953	Syme
954	symeListHasExtendee(SymeList symes, Syme syme2)
955	{
956	Syme result = NULL((void*)0);
957
958	for (; !result && symes; symes = cdr(symes)((symes)->rest)) {
959	Syme syme1 = car(symes)((symes)->first);
960	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)) &&
961	symeHasExtendee(syme1, symeOriginal(syme2)))
962	result = syme1;
963	}
964
965	return result;
966	}
967
968	localstatic void
969	symeRefreshExtendees(Syme syme)
970	{
971	SymeList symes;
972
973	assert(symeIsImportOfExtend(syme))do { if (!(((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void)0)), (syme))->kind) == SYME_Import ) && (((((symeOriginal(syme))->kind == SYME_Trigger ? libGetAllSymes((symeOriginal(syme))->lib) : ((void)0)) , (symeOriginal(syme)))->kind) == SYME_Extend)))) _do_assert (("symeIsImportOfExtend(syme)"),"stab.c",973); } while (0);
974	syme = symeOriginal(syme);
975
976	symes = symeExtendee(syme);
977	for (; symes; symes = cdr(symes)((symes)->rest)) {
978	Syme ext = car(symes)((symes)->first);
979	if (symeExtension(ext) == NULL((void*)0))
980	symeSetExtension(ext, syme)symeXSetExtension(ext, (AInt) syme);
981	}
982	}
983
984	SymeList
985	stabGetMeanings(Stab stab, AbLogic abl, Symbol sym)
986	{
987	StabEntry stent = stabGetEntry(stab, sym, true1);
988	return stent ? stabEntryGetSymes(stent, abl) : listNil(Syme)((SymeList) 0);
989	}
990
991	TPoss
992	stabGetTypes(Stab stab, AbLogic abl, Symbol sym)
993	{
994	StabEntry stent = stabGetEntry(stab, sym, true1);
995	return stent ? stabEntryGetTypes(stent, abl) : tpossEmpty();
996	}
997
998	/*
999	* Get the symbol meaning for %, or return NULL for failure.
1000	*/
1001	Syme
1002	stabGetSelf(Stab stab)
1003	{
1004	StabEntry stent;
1005	SymeList symes;
1006
1007	if (stab == NULL((void)0)) return NULL((void)0);
1008
1009	stent = stabGetEntry(stab, ssymSelf, false((int) 0));
1010	if (stent == NULL((void)0)) return NULL((void)0);
1011
1012	for (symes = stabEntryAllSymes(stent); symes; symes = cdr(symes)((symes)->rest)) {
1013	Syme syme = car(symes)((symes)->first);
1014	if ((symeIsLexVar(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_LexVar) \|\| symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Extend)) &&
1015	symeDefLevel(syme) == car(stab)((stab)->first))
1016	return syme;
1017	}
1018
1019	return NULL((void*)0);
1020	}
1021
1022	/*
1023	* Get an export symbol meaning for id whose type is equal to tf modulo mods.
1024	*/
1025	Syme
1026	stabGetExportMod(Stab stab, SymeList mods, Symbol id, TForm tf)
1027	{
1028	StabEntry stent;
1029	SymeList symes;
1030
1031	if (stab == NULL((void)0)) return NULL((void)0);
1032
1033	stent = stabGetEntry(stab, id, true1);
1034	if (stent == NULL((void)0)) return NULL((void)0);
1035
1036	for (symes = stabEntryAllSymes(stent); symes; symes = cdr(symes)((symes)->rest)) {
1037	Syme syme = car(symes)((symes)->first);
1038
1039	if (!symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Export)) continue;
1040
1041	/*!! This should eventually be replaced by something which
1042	*!! knows how to compare the public parts of the types.
1043	*/
1044	if (tfIsCategory(tf)(((tf)->tag) == TF_Category) && tfSatCat(symeType(syme)))
1045	return syme;
1046
1047	if (tformEqualMod(mods, tf, symeType(syme)))
1048	return syme;
1049	}
1050
1051	return NULL((void*)0);
1052	}
1053
1054
1055	/*
1056	* This function is a bit of a hack; it replaces stabGetExportMod,
1057	* iterating over only symbols in the local stab instead of doing
1058	* a recursive search.
1059	*
1060	* stabGetExportMod's remaining use is in tiWithSymes, and in those
1061	* contexts a recursive search seems to be necessary.
1062	*
1063	* Ideally, we'd replace both with a single function, but better to
1064	* commit this and gather test cases.
1065	*/
1066
1067	Syme
1068	stabGetDomainExportMod(Stab astab, SymeList mods, Symbol sym, TForm tf)
1069	{
1070	SymeList exports = stabGetExportedSymes(astab);
1071	while (exports != listNil(Syme)((SymeList) 0)) {
1072	Syme syme = car(exports)((exports)->first);
1073	exports = cdr(exports)((exports)->rest);
1074	if (symeId(syme)((syme)->id) != sym)
1075	continue;
1076	if (!symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind) == SYME_Export)) continue;
1077	if (tfIsCategory(tf)(((tf)->tag) == TF_Category) && tfSatCat(symeType(syme)))
1078	return syme;
1079	if (tformEqualMod(mods, tf, symeType(syme)))
1080	return syme;
1081	}
1082	return NULL((void*)0);
1083	}
1084
1085
1086
1087	/*
1088	*
1089	*/
1090	Bool
1091	stabGetLex(Stab stab, Symbol sym)
1092	{
1093	return stabGetSymeOfKind(stab, sym, SYME_LexVar) != NULL((void*)0) \|\|
1094	stabGetSymeOfKind(stab, sym, SYME_LexConst) != NULL((void*)0);
1095	}
1096
1097	/*
1098	* Get the library symbol meaning for the given identifier.
1099	*/
1100	Syme
1101	stabGetLibrary(Symbol sym)
1102	{
1103	return stabGetSymeOfKind(stabFile(), sym, SYME_Library);
1104	}
1105
1106	/*
1107	* Get the archive symbol meaning for the given identifier.
1108	*/
1109	Syme
1110	stabGetArchive(Symbol sym)
1111	{
1112	return stabGetSymeOfKind(stabFile(), sym, SYME_Archive);
1113	}
1114
1115	/*
1116	* Get the first syme we find for the sym that has one of the given tags.
1117	*/
1118	localstatic Syme
1119	stabGetSymeOfKind(Stab stab, Symbol sym, SymeTag tag)
1120	{
1121	Syme syme = NULL((void*)0);
1122
1123	for (; !syme && stab; stab = cdr(stab)((stab)->rest))
1124	syme = stabLevelGetSymeOfKind(stab, sym, tag);
1125
1126	return syme;
1127	}
1128
1129	localstatic Syme
1130	stabLevelGetSymeOfKind(Stab stab, Symbol sym, SymeTag tag)
1131	{
1132	StabEntry stent = (StabEntry) tblElt(car(stab)((stab)->first)->tbl, sym, NULL((void*)0));
1133	SymeList symes = stent ? stabEntryAllSymes(stent) : listNil(Syme)((SymeList) 0);
1134
1135	for (; symes; symes = cdr(symes)((symes)->rest))
1136	if (symeKind(car(symes))((((((symes)->first))->kind == SYME_Trigger ? libGetAllSymes ((((symes)->first))->lib) : ((void*)0)), (((symes)-> first)))->kind) == tag)
1137	return car(symes)((symes)->first);
1138	return NULL((void*)0);
1139	}
1140
1141	/******************************************************************************
1142	*
1143	* :: Symbol meaning creation
1144	*
1145	*****************************************************************************/
1146
1147	void
1148	stabUseMeaning(Stab stab, Syme syme)
1149	{
1150	UShort d = stabLevelNo(stab)(((stab)->first)->lexicalLevel) - symeDefLevelNo(syme)(symeDefLevel(syme)->lexicalLevel);
1151
1152	if (DEBUG(stab)stabDebug) {
1153	fprintf(dbOut, "Using %s (.%ld) of depth %d at %d",
1154	symeString(syme)((((syme)->id))->str), 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),
1155	symeUsedDepth(syme)((UShort) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_UsedDepth))) ? ((syme)->fieldv)[symeIndex( syme,SYFI_UsedDepth)] : (symeFieldInfo[SYFI_UsedDepth].def))), d);
1156	fnewline(dbOut);
1157	}
1158
1159	if (symeUnused(syme)(((UShort) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_UsedDepth))) ? ((syme)->fieldv)[symeIndex( syme,SYFI_UsedDepth)] : (symeFieldInfo[SYFI_UsedDepth].def))) == (0x7FFF)) \|\| symeUsedDepth(syme)((UShort) ((((((syme)->kind == SYME_Trigger ? libGetAllSymes ((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_UsedDepth))) ? ((syme)->fieldv)[symeIndex( syme,SYFI_UsedDepth)] : (symeFieldInfo[SYFI_UsedDepth].def))) < d)
1160	symeSetUsedDepth(syme, d)(symeSetFieldVal = ((AInt) (d)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_UsedDepth))) ? (((syme)-> fieldv)[symeIndex(syme,SYFI_UsedDepth)] = (symeSetFieldVal)) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_UsedDepth].def) ? symeSetFieldVal : symeSetFieldFn(syme ,SYFI_UsedDepth,symeSetFieldVal));
1161	}
1162
1163	Bool
1164	stabHasMeaning(Stab stab, Syme syme)
1165	{
1166	StabEntry stent;
1167	SymeList symes;
1168	Bool result = false((int) 0);
1169
1170	for (; !result && stab; stab = cdr(stab)((stab)->rest)) {
1171	stent = (StabEntry) tblElt(car(stab)((stab)->first)->tbl, symeId(syme)((syme)->id), NULL((void*)0));
1172	symes = stent ? stabEntryAllSymes(stent) : listNil(Syme)((SymeList) 0);
1173	result = listMemq(Syme)(Syme_listPointer->Memq)(symes, syme);
1174	}
1175
1176	return result;
1177	}
1178
1179	Syme
1180	stabAddMeaning(Stab stab, Syme syme)
1181	{
1182	Symbol id;
1183	StabEntry stent;
1184
1185	assert(stab != 0)do { if (!(stab != 0)) _do_assert(("stab != 0"),"stab.c",1185 ); } while (0);
1186
1187	if (stabLevelIsLocked(stab)(((stab)->first)->isLocked))
1188	return stabAddMeaning(cdr(stab)((stab)->rest), syme);
1189
1190	if (stabHasMeaning(stab, syme))
1191	return syme;
1192
1193	id = symeId(syme)((syme)->id);
1194
1195	switch (symeKind(syme)((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->kind)) {
1196	case SYME_LexVar:
1197	case SYME_Param:
1198	case SYME_Extend:
1199	stent = stabGetEntry(stab, id, false((int) 0));
1200	break;
1201	default:
1202	stent = stabGetEntry(stab, id, true1);
1203	break;
1204	}
1205
1206	if (symeIsImportOfExtend(syme)((((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Import) && (((((symeOriginal(syme))->kind == SYME_Trigger ? libGetAllSymes ((symeOriginal(syme))->lib) : ((void)0)), (symeOriginal(syme )))->kind) == SYME_Extend)))
1207	symeRefreshExtendees(syme);
1208
1209	if (stent) {
1210	SymeList osymes = stabEntryAllSymes(stent);
1211	Syme osyme;
1212
1213	osyme = symeListHasImportee(osymes, syme);
1214	if (osyme)
1215	return osyme;
1216
1217	osyme = symeListHasExtendee(osymes, syme);
1218	if (osyme) {
1219	symeSetExtension(osyme, syme)symeXSetExtension(osyme, (AInt) syme);
1220	stabExtendMeanings(stab, syme);
1221	return syme;
1222	}
1223
1224	osyme = symeListHasExtension(osymes, syme);
1225	if (osyme)
1226	return osyme;
1227	}
1228
1229	car(stab)((stab)->first)->boundSymes = listCons(Syme)(Syme_listPointer->Cons)(syme, car(stab)((stab)->first)->boundSymes);
1230	stabDEBUGif (!stabDebug) { } else afprintf(dbOut, "Adding stab entry %d %pSyme %pAbSynList\n", car(stab)((stab)->first)->lexicalLevel,
1231	syme, symeCondition(syme));
1232	stabEntryAddSyme(stent, syme);
1233
1234	return syme;
1235	}
1236
1237	void
1238	stabPutMeaningSet(Stab stab, SymeSet symeSet)
1239	{
1240	stabPutMeanings(stab, symeSetList(symeSet));
1241	}
1242
1243	void
1244	stabPutMeanings(Stab stab, SymeList symes)
1245	{
1246	SymeList l;
1247
1248	for (l = symes; l; l = cdr(l)((l)->rest)) {
1249	Syme syme = car(l)((l)->first);
1250
1251	stabAddMeaning(stab, syme);
1252	symeSetDefLevel(syme, car(stab)((stab)->first));
1253	}
1254	}
1255
1256	Syme
1257	stabDefParam(Stab stab, Symbol id, TForm tform)
1258	{
1259	Syme syme = symeNewParam(id, tform, car(stab)((stab)->first));
1260
1261	syme = stabAddMeaning(stab, syme);
1262	return syme;
1263	}
1264
1265	Syme
1266	stabDefLexConst(Stab stab, Symbol id, TForm tform)
1267	{
1268	Syme syme = symeNewLexConst(id, tform, car(stab)((stab)->first));
1269	symeSetDefnNum(syme, (int) ++stabDefinitionCounter)(symeSetFieldVal = ((AInt) ((int) ++stabDefinitionCounter)), ( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_DefnNum ))) ? (((syme)->fieldv)[symeIndex(syme,SYFI_DefnNum)] = (symeSetFieldVal )) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_DefnNum].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_DefnNum ,symeSetFieldVal));
1270
1271	if (DEBUG(stabConst)stabConstDebug) {
1272	fprintf(dbOut, "defnNum[%d]: ", 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))));
1273	symePrint(dbOut, syme);
1274	fnewline(dbOut);
1275	}
1276
1277	syme = stabAddMeaning(stab, syme);
1278	return syme;
1279	}
1280
1281	Syme
1282	stabDefLexVar(Stab stab, Symbol id, TForm tform)
1283	{
1284	Syme syme = symeNewLexVar(id, tform, car(stab)((stab)->first));
1285
1286	syme = stabAddMeaning(stab, syme);
1287	symeSetDefnNum(syme, (int) ++stabDefinitionCounter)(symeSetFieldVal = ((AInt) ((int) ++stabDefinitionCounter)), ( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_DefnNum ))) ? (((syme)->fieldv)[symeIndex(syme,SYFI_DefnNum)] = (symeSetFieldVal )) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_DefnNum].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_DefnNum ,symeSetFieldVal));
1288
1289	if (DEBUG(stabConst)stabConstDebug) {
1290	fprintf(dbOut, "defnNum[%d]: ", 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))));
1291	symePrint(dbOut, syme);
1292	fnewline(dbOut);
1293	}
1294
1295	return syme;
1296	}
1297
1298	Syme
1299	stabDefFluid(Stab stab, Symbol id, TForm tform)
1300	{
1301	Syme syme = symeNewFluid(id, tform, car(stab)((stab)->first));
1302
1303	syme = stabAddMeaning(stab, syme);
1304
1305	return syme;
1306	}
1307
1308	Syme
1309	stabDefImport(Stab stab, Symbol id, TForm tform, TForm exporter)
1310	{
1311	Syme syme = symeNewImport(id, tform, car(stab)((stab)->first), exporter);
1312
1313	return stabAddMeaning(stab, syme);
1314	}
1315
1316	Syme
1317	stabDefExport(Stab stab, Symbol id, TForm tform, Doc doc)
1318	{
1319	Syme syme = symeNewExport(id, tform, car(stab)((stab)->first));
1320
1321	if (DEBUG(stab)stabDebug) {
1322	fprintf(dbOut, "Defining export %s with comment ",
1323	symString(id)((id)->str));
1324	docPrint(dbOut, doc);
1325	fnewline(dbOut);
1326	}
1327
1328	symeSetComment(syme, doc)(symeSetFieldVal = ((AInt) (doc)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_Comment))) ? (((syme)->fieldv )[symeIndex(syme,SYFI_Comment)] = (symeSetFieldVal)) : !((syme )->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Comment ].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Comment,symeSetFieldVal ));
1329	syme = stabAddMeaning(stab, syme);
1330	symeSetDefnNum(syme, (int) ++stabDefinitionCounter)(symeSetFieldVal = ((AInt) ((int) ++stabDefinitionCounter)), ( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_DefnNum ))) ? (((syme)->fieldv)[symeIndex(syme,SYFI_DefnNum)] = (symeSetFieldVal )) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_DefnNum].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_DefnNum ,symeSetFieldVal));
1331
1332	if (DEBUG(stabConst)stabConstDebug) {
1333	fprintf(dbOut, "defnNum[%d]: ", 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))));
1334	symePrint(dbOut, syme);
1335	fnewline(dbOut);
1336	}
1337
1338	return syme;
1339	}
1340
1341	Syme
1342	stabDefExtendee(Stab stab, Symbol id, TForm tform, Doc doc)
1343	{
1344	Syme syme = symeNewExport(id, tform, car(stab)((stab)->first));
1345
1346	symeSetComment(syme, doc)(symeSetFieldVal = ((AInt) (doc)), (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void*)0)), (syme))-> locmask) & (1 << (SYFI_Comment))) ? (((syme)->fieldv )[symeIndex(syme,SYFI_Comment)] = (symeSetFieldVal)) : !((syme )->full) && symeSetFieldVal == (symeFieldInfo[SYFI_Comment ].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_Comment,symeSetFieldVal ));
1347	symeSetDefnNum(syme, (int) ++stabDefinitionCounter)(symeSetFieldVal = ((AInt) ((int) ++stabDefinitionCounter)), ( ((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_DefnNum ))) ? (((syme)->fieldv)[symeIndex(syme,SYFI_DefnNum)] = (symeSetFieldVal )) : !((syme)->full) && symeSetFieldVal == (symeFieldInfo [SYFI_DefnNum].def) ? symeSetFieldVal : symeSetFieldFn(syme,SYFI_DefnNum ,symeSetFieldVal));
1348
1349	return syme;
1350	}
1351
1352	Syme
1353	stabDefExtend(Stab stab, Symbol id, TForm tform)
1354	{
1355	Syme syme = symeNewExtend(id, tform, car(stab)((stab)->first));
1356
1357	return stabAddMeaning(stab, syme);
1358	}
1359
1360	Syme
1361	stabDefLibrary(Stab stab, Symbol id, TForm tform, Lib lib)
1362	{
1363	SymeList symes;
1364	Syme syme;
1365
1366	/* Check for symbol meanings that already exist. */
1367	symes = stabGetMeanings(stab, NULL((void*)0), id);
1368	if (symes) {
1369	comsgWarning(NULL((void*)0), ALDOR_W_LibRedefined153, symString(id)((id)->str));
1370	return car(symes)((symes)->first);
1371	}
1372
1373	syme = symeNewLibrary(id, tform, car(stab)((stab)->first), lib);
1374	tfFrSyme(stab, syme);
1375
1376	return stabAddMeaning(stab, syme);
1377	}
1378
1379	Syme
1380	stabDefArchive(Stab stab, Symbol id, TForm tform, Archive ar)
1381	{
1382	SymeList symes;
1383	Syme syme;
1384
1385	/* Check for symbol meanings that already exist. */
1386	symes = stabGetMeanings(stab, NULL((void*)0), id);
1387	if (symes) {
1388	comsgWarning(NULL((void*)0), ALDOR_W_LibRedefined153, symString(id)((id)->str));
1389	return car(symes)((symes)->first);
1390	}
1391
1392	syme = symeNewArchive(id, tform, car(stab)((stab)->first), ar);
1393	tfFrSyme(stab, syme);
1394
1395	return stabAddMeaning(stab, syme);
1396	}
1397
1398	Syme
1399	stabDefForeign(Stab stab, Symbol id, TForm tform, ForeignOrigin forg)
1400	{
1401	Syme syme = symeNewForeign(id, tform, car(stab)((stab)->first), forg);
1402
1403	return stabAddMeaning(stab, syme);
1404	}
1405
1406	Syme
1407	stabDefBuiltin(Stab stab, Symbol id, TForm tform, FoamBValTag builtin)
1408	{
1409	Syme syme = symeNewBuiltin(id, tform, car(stab)((stab)->first), builtin);
1410
1411	return stabAddMeaning(stab, syme);
1412	}
1413
1414	/******************************************************************************
1415	*
1416	* :: Shadow Stuff
1417	*
1418	*****************************************************************************/
1419
1420	static AbSyn StabUseMeaningShadow = 0;
1421
1422	void
1423	stabUseMeaningShadow(AbSyn ab)
1424	{
1425	StabUseMeaningShadow = ab;
1426	}
1427
1428	void
1429	stabUseMeaningUnshadow(void)
1430	{
1431	StabUseMeaningShadow = 0;
1432	}
1433
1434	void
1435	stabSetSyme(Stab stab, AbSyn ab, Syme syme, AbLogic cond)
1436	{
1437	SImpl impl;
1438	/*!! if (abUse(ab) != AB_Use_Declaration &&
1439	abUse(ab) != AB_Use_Define) */
1440	if (ab != StabUseMeaningShadow)
1441	stabUseMeaning(stab, syme);
1442	abSetSyme(ab, syme);
1443
1444	if (abDefineIdx(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->defnIdx : -1 ) != -1)
1445	symeImplAddConst(syme, cond, abDefineIdx(ab)((ab)->abHdr.seman ? (ab)->abHdr.seman->defnIdx : -1 ));
1446
1447	/* NB: We assume that the impl information is correct.
1448	* It ought to be, at least for add bodies, 'cos it is
1449	* set in tiAddSymes.
1450	*/
1451	impl = implEvaluate(symeImpl(syme)((SImpl) (SYFI_SImpl < (8 * sizeof(int)) && !((((( syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib ) : ((void)0)), (syme))->hasmask) & (1 << (SYFI_SImpl ))) ? (symeFieldInfo[SYFI_SImpl].def) : (((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)->lib) : ((void)0)), (syme))->locmask) & (1 << (SYFI_SImpl))) ? (((( ((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void*)0)), (syme))->locmask) & (1 << (SYFI_SImpl ))) ? ((syme)->fieldv)[symeIndex(syme,SYFI_SImpl)] : (symeFieldInfo [SYFI_SImpl].def)) : symeGetFieldFn(syme,SYFI_SImpl))), abCondKnown);
1452	abSetImpl(ab, impl);
1453	}
1454
1455	Bool
1456	stabIsUndeclaredId(Stab stab, Symbol sym)
1457	{
1458	Length symec = 0;
1459	SymeList symes;
1460
1461	for (symes = stabGetMeanings(stab, NULL((void*)0), sym); symes; symes = cdr(symes)((symes)->rest))
1462	if (tfIsUnknown(symeType(car(symes)))(((symeType(((symes)->first)))->tag) == TF_Unknown))
1463	symec += 1;
1464
1465	return symec == 1;
1466	}
1467
1468	void
1469	stabDeclareId(Stab stab, Symbol sym, TForm tform)
1470	{
1471	Syme syme = NULL((void*)0);
1472	SymeList symes;
1473
1474	for (symes = stabGetMeanings(stab, NULL((void*)0), sym); symes; symes = cdr(symes)((symes)->rest))
1475	if (tfIsUnknown(symeType(car(symes)))(((symeType(((symes)->first)))->tag) == TF_Unknown))
1476	syme = car(symes)((symes)->first);
1477
1478	assert(syme)do { if (!(syme)) _do_assert(("syme"),"stab.c",1478); } while (0);
1479	symeSetType(syme, tform);
1480	stabPropagateDecl(stab, syme);
1481	}
1482
1483	/* Once the type of syme has been inferred,
1484	* clear the stab entry caches for each level in which syme is visible.
1485	* Ex: for x in 1..10
1486	* j := 1 -- declared here
1487	* j := 2 -- update this stent
1488	*/
1489	localstatic void
1490	stabPropagateDecl(Stab stab, Syme syme)
1491	{
1492	StabEntry stent;
1493	Symbol sym = symeId(syme)((syme)->id);
1494
1495	for (; stab; stab = cdr(stab)((stab)->rest)) {
1496	stent = (StabEntry) tblElt(car(stab)((stab)->first)->tbl, sym, NULL((void*)0));
1497
1498	if (stent && listMemq(Syme)(Syme_listPointer->Memq)(stabEntryAllSymes(stent), syme))
1499	stabEntryClearCache(stent);
1500
1501	/* Stop when the definition level has been reached. */
1502	if (car(stab)((stab)->first) == symeDefLevel(syme)) break;
1503	}
1504	}
1505	/******************************************************************************
1506	*
1507	* :: Symbol table printing.
1508	*
1509	*****************************************************************************/
1510
1511	int
1512	stabPrint(FILE * fout, Stab stab)
1513	{
1514	return stabPrintTo(fout, stab, (int) 0);
1515	}
1516
1517	/*
1518	* Print "stab" level by level until "minlev" is reached. If "minlev" is
1519	* negative, then the count is made from the top of the stack instead of the
1520	* bottom.
1521	*/
1522
1523	int
1524	stabPrintTo(FILE * fout, Stab stab, int minlev)
1525	{
1526	int cc, ts;
1527	StabLevel slev;
1528
1529	if (stab && minlev < 0)
1530	minlev = car(stab)((stab)->first)->lexicalLevel + minlev + 1;
1531
1532	for (cc = 0; stab; stab = cdr(stab)((stab)->rest)) {
1533	slev = car(stab)((stab)->first);
1534	if (slev->lexicalLevel < minlev)
1535	break;
1536	cc += fnewline(fout);
1537	cc += fprintf(fout, "SymbolTable Level %ld, %s, (serial %ld),",
1538	slev->lexicalLevel,
1539	stabLevelIsLarge(stab)(((stab)->first)->tformsUsed.table) ? "LARGE" : "SMALL",
1540	slev->serialNo);
1541	cc += fprintf(fout, " %d symbols.", ts = tblSize(slev->tbl));
1542	findent += 2;
1543	cc += fnewline(fout);
1544	if (ts)
1545	cc += tblColumnPrint(fout, slev->tbl,
1546	(TblPrKeyFun) 0, stabPrEntry);
1547	findent -= 2;
1548	cc += fnewline(fout);
1549
1550	if (slev->tformsUnused) {
1551	TFormList tfl;
1552
1553	cc += fprintf(fout,
1554	"Type forms registered but not used: ");
1555	findent += 2;
1556	cc += fnewline(fout);
1557	for (tfl = slev->tformsUnused; tfl; tfl = cdr(tfl)((tfl)->rest)) {
1558	cc += tfPrint(fout, car(tfl)((tfl)->first));
1559	cc += fnewline(fout);
1560	}
1561	findent -= 2;
1562	cc += fnewline(fout);
1563	}
1564
1565	cc += fprintf(fout, "All type forms used: ");
1566	findent += 2;
1567	cc += fnewline(fout);
1568
1569	if (!slev->tformsUsed.list)
1570	cc += fprintf(fout, "NONE");
1571	else
1572	cc += tfulPrint(fout, slev->tformsUsed.list);
1573
1574	findent -= 2;
1575	cc += fnewline(fout);
1576
1577	if (slev->labelsInScope) {
1578	AbSynList asl = slev->labelsInScope;
1579	cc += fprintf(fout, "Labels in this scope: ");
1580	while (asl) {
1581	cc += abPrettyPrint(fout, car(asl)((asl)->first));
1582	asl = cdr(asl)((asl)->rest);
1583	cc += asl ? fprintf(fout, ", ") : fnewline(fout);
1584	}
1585	cc += fnewline(fout);
1586	}
1587
1588	if (slev->boundSymes) {
1589	SymeList sl = slev->boundSymes;
1590	cc += fprintf(fout, "Bound symbol meanings: ");
1591	findent += 2;
1592	cc += fnewline(fout);
1593	while (sl) {
1594	cc += symePrint(fout, car(sl)((sl)->first));
1595	sl = cdr(sl)((sl)->rest);
1596	if (sl)
1597	cc += fnewline(fout);
1598	}
1599	findent -= 2;
1600	}
1601
1602	cc += fnewline(fout);
1603	}
1604	return cc;
1605	}
1606
1607	localstatic int
1608	stabPrEntry(FILE * fout, TblElt e)
1609	{
1610	StabEntry stent = (StabEntry) e;
1611	SymeList symes = stabEntryAllSymes(stent);
1612	int cc = 0;
1613
1614	for (; symes; symes = cdr(symes)((symes)->rest)) {
1615	cc += symePrint(fout, car(symes)((symes)->first));
1616	if (cdr(symes)((symes)->rest))
1617	cc += fnewline(fout);
1618	}
1619	return cc;
1620	}
1621
1622	int
1623	tfulPrint(FILE *fout, TFormUsesList tful)
1624	{
1625	int cc = 0;
1626	while (tful) {
1627	TFormUses tfu = car(tful)((tful)->first);
1628	tful = cdr(tful)((tful)->rest);
1629	cc += tfuPrint(fout, tfu);
1630	}
1631	return cc;
1632	}
1633
1634	int
1635	tfuPrint(FILE *fout, TFormUses tfu)
1636	{
1637	int cc = 0;
1638
1639	cc += tfPrint(fout, tfu->tf);
1640	findent += 2;
1641	cc += fnewline(fout);
1642
1643	if (tfu->isExplicitImport) {
1644	cc += fprintf(fout, "Explicitly imported.");
1645	cc += fnewline(fout);
1646	}
1647	if (tfu->isCategoryImport) {
1648	cc += fprintf(fout, "Categorically imported.");
1649	cc += fnewline(fout);
1650	}
1651	if (tfu->isParamImport) {
1652	cc += fprintf(fout, "Parameter import.");
1653	cc += fnewline(fout);
1654	}
1655
1656	if (tfu->exports) {
1657	cc += fprintf(fout, "exports: ");
1658	cc += tqPrint(fout, tfu->exports);
1659	cc += fnewline(fout);
1660	}
1661	if (tfu->imports) {
1662	cc += fprintf(fout, "imports: ");
1663	cc += tqPrint(fout, tfu->imports);
1664	cc += fnewline(fout);
1665	}
1666	if (tfu->inlines) {
1667	cc += fprintf(fout, "inlines: ");
1668	cc += tqPrint(fout, tfu->inlines);
1669	cc += fnewline(fout);
1670	}
1671
1672	if (tfQueries(tfu->tf)((tfu->tf)->queries)) {
1673	TFormList cl;
1674	int i;
1675
1676	cc += fnewline(fout);
1677	cc += fprintf(fout, "Conditional categories:");
1678	cl = tfQueries(tfu->tf)((tfu->tf)->queries);
1679	findent += 2;
1680	cc += fnewline(fout);
1681	for (i = 1; cl; cl = cdr(cl)((cl)->rest), i++) {
1682	cc += fprintf(fout, "%d: ", i);
1683	cc += tformPrint(fout, car(cl)((cl)->first));
1684	cc += fnewline(fout);
1685	}
1686	findent -= 2;
1687	}
1688
1689	if (tfu->declarees) {
1690	cc += fnewline(fout);
1691	cc += fprintf(fout, "Declarees: ");
1692	listPrint(Symbol)(Symbol_listPointer->Print)(fout,tfu->declarees,symPrint);
1693	}
1694
1695	findent -= 2;
1696	cc += fnewline(fout);
1697
1698	return cc;
1699	}
1700
1701	/******************************************************************************
1702	*
1703	* :: Imports
1704	*
1705	*****************************************************************************/
1706
1707	SymeList
1708	stabGetExportedSymes(Stab stab)
1709	{
1710	SymeList symes, exports = listNil(Syme)((SymeList) 0);
1711
1712	for (symes = stabGetBoundSymes(stab)(((stab)->first)->boundSymes); symes; symes = cdr(symes)((symes)->rest)) {
1713	Syme syme = car(symes)((symes)->first);
1714	if (symeIsExport(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Export) \|\| symeIsExtend(syme)(((((syme)->kind == SYME_Trigger ? libGetAllSymes((syme)-> lib) : ((void)0)), (syme))->kind) == SYME_Extend))
1715	exports = listCons(Syme)(Syme_listPointer->Cons)(car(symes)((symes)->first), exports);
1716	}
1717
1718	return exports;
1719	}
1720
1721	TQualList
1722	stabImportFrom(Stab stab, TQual tq)
1723	{
1724	SymeSet dsymes;
1725	TForm origin = tqBase(tq)((tq)->base);
1726
1727
1728	/* Carefully follow this tform */
1729	tfFollow(origin)((origin) = tfFollowFn(origin));
1730
1731
1732	/*
1733	* We can significantly improve inlining if we replace
1734	* the domain with its normal form. Users can turn this
1735	* off by compiling with -Wdumb-import.
1736	*/
1737	if (!stabDumbImport())
1738	{
1739	TForm base = tfDefineeBaseType(origin);
1740
1741	if (tfQueries(origin)((origin)->queries) != listNil(TForm)((TFormList) 0))
1742	(void)tfCopyQueries(base, origin);
1743	origin = base;
1744	}
1745
1746
1747	/* Don't import a tform if has already been imported */
1748	if (stabIsImportedTForm(stab, origin))
1749	return listNil(TQual)((TQualList) 0);
1750
1751	if (DEBUG(stabImport)stabImportDebug) {
1752	fprintf(dbOut, "Importing %s from ",
1753	tqIsForeign(tq)(((tq)->status) == TQUAL_Foreign) ? " foreign exports" :
1754	tqIsBuiltin(tq)(((tq)->status) == TQUAL_Builtin) ? " builtin exports" :
1755	tqIsQualified(tq)((tq)->isQual == 1) ? " explicit exports" : "");
1756	tfPrint(dbOut, origin);
1757	fnewline(dbOut);
1758	}
1759
1760	stabImportRemark(stab, tqQual(tq)((tq)->qual), origin);
1761
1762	if (tqIsForeign(tq)(((tq)->status) == TQUAL_Foreign))
1763	dsymes = symeSetFrSymes(tqGetForeignImports(stab, tq));
1764	else if (tqIsBuiltin(tq)(((tq)->status) == TQUAL_Builtin))
1765	dsymes = symeSetFrSymes(tqGetBuiltinImports(stab, tq));
1766	else if (tqIsQualified(tq)((tq)->isQual == 1))
1767	dsymes = symeSetFrSymes(tqGetQualImports(tq));
1768	else {
1769	Stab nstab = stab;
1770
1771	/*
1772	* We want to avoid using stabFile() otherwise some
1773	* tforms will seep into the top level and cause us
1774	* grief later on (e.g. bug1192). However, there are
1775	* times when we really do want to use stabFile(). If
1776	* we have sefo that isn't associated with any source
1777	* code then stabFile() ought to be okay.
1778	*
1779	* An alternative to using the local stab passed down
1780	* to us, we be to use tfStab() if it was present. That
1781	* may be more reliable if it corresponds to a higher
1782	* lexical level.
1783	*/
1784	if (!tfGetExpr(origin)((origin)->__absyn) \|\| !abPos(tfGetExpr(origin))(spstackFirst((((origin)->__absyn))->abHdr.pos)))
1785	nstab = stabFile();
1786
1787
1788	/* Get the domain imports of origin */
1789	dsymes = tfStabGetDomImportSet(nstab, origin);
1790
1791
1792	/*
1793	* It doesn't matter which stab we chose to get domain
1794	* imports from, we are importing into the local one.
1795	*/
1796	if (!symeSetIsEmpty(dsymes)) stabMakeImportedTForm(stab, origin);
1797	}
1798
1799	stabPutMeaningSet(stab, dsymes);
1800
1801	stabImportDEBUGif (!stabImportDebug) { } else afprintf(dbOut, "... imported: %pSymeSet\n", dsymes);
1802
1803	if (!tqIsQualified(tq)((tq)->isQual == 1))
1804	return tfGetDomCascades(origin);
1805	else
1806	return listNil(TQual)((TQualList) 0);
1807	}
1808
1809	localstatic void
1810	stabImportRemark(Stab stab, TFormList what, TForm origin)
1811	{
1812	if (comsgOkRemark(ALDOR_R_StabImporting140)) {
1813	String s = tfPretty(origin);
1814	comsgRemark(abNewNothing(car(stab)->spos)abNew(AB_Nothing, ((stab)->first)->spos,0 ), ALDOR_R_StabImporting140, s);
1815	strFree(s);
1816	}
1817
1818	if (what && comsgOkRemark(ALDOR_R_StabImportingQual141)) {
1819	Buffer buf = bufNew();
1820	String explicits;
1821	TFormList tmpList;
1822
1823	for (tmpList = what; tmpList; tmpList = cdr(tmpList)((tmpList)->rest)) {
1824	String pp = abPretty(tfExpr(car(tmpList))tfToAbSyn(((tmpList)->first)));
1825	bufAdd1(buf, '\n');
1826	bufAdd1(buf, '\t');
1827	bufPuts(buf, pp);
1828	strFree(pp);
1829	}
1830
1831	explicits = bufLiberate(buf);
1832	comsgRemark(abNewNothing(car(stab)->spos)abNew(AB_Nothing, ((stab)->first)->spos,0 ),
1833	ALDOR_R_StabImportingQual141, explicits);
1834
1835	strFree(explicits);
1836	}
1837	}
1838
1839	/******************************************************************************
1840	*
1841	* :: Foreign exports
1842	*
1843	*****************************************************************************/
1844
1845	void
1846	stabAddForeignExport(Stab stab, TForm tf, ForeignOrigin forg)
1847	{
1848	if (car(stab)((stab)->first)->exportedTypes == NULL((void*)0))
1849	car(stab)((stab)->first)->exportedTypes = tblNew((TblHashFun) tfHash, (TblEqFun) tfEqual);
1850	tblSetElt(car(stab)((stab)->first)->exportedTypes, tf, forg);
1851	}
1852
1853	ForeignOrigin
1854	stabForeignExportLocation(Stab stab, TForm tf)
1855	{
1856	while (stab != listNil(StabLevel)((StabLevelList) 0)) {
1857	if (car(stab)((stab)->first)->exportedTypes == NULL((void*)0)) {
1858	stab = cdr(stab)((stab)->rest);
1859	continue;
1860	}
1861	ForeignOrigin forg = tblElt(car(stab)((stab)->first)->exportedTypes, tf, NULL((void*)0));
1862	if (forg != NULL((void*)0))
1863	return forg;
1864	stab = cdr(stab)((stab)->rest);
1865	}
1866	return NULL((void*)0);
1867	}
1868
1869	Bool
1870	stabIsForeignExport(Stab stab, TForm tf)
1871	{
1872	return stabForeignExportLocation(stab, tf) != NULL((void*)0);
1873	}
1874
1875	/****************************************************************************
1876	*
1877	* TForm and TFormUses code.
1878	*
1879	****************************************************************************/
1880
1881	/*
1882	* General scheme is this: TFormUses holds TForms and their usage
1883	* information. If a TForm is "registered" via stabDefTForm but not
1884	* used explicitly yet for importing or inlining, say, then it is stored on
1885	* the list tformsUnused. A TForm is taken off that list when it is
1886	* added to tformsUsed.
1887	*/
1888
1889	localstatic TFormUses
1890	tformDoNothing(TFormUses tfu)
1891	{
1892	/*
1893	* Used to return an old or newly created TFormUses object.
1894	*/
1895	return tfu;
1896	}
1897
1898	localstatic TFormUses
1899	tformIsImported(TFormUses tfu)
1900	{
1901	tfu->isImported = true1;
1902	return tfu;
1903	}
1904
1905	localstatic TFormUses
1906	tformExportAll(TFormUses tfu)
1907	{
1908	tfuSetUnqualified(tfu->exports, tfu->tf)((tfu->exports) = (tfu->exports) ? tqSetUnqualified(tfu ->exports) : tqNewUnqualified(tfu->tf));
1909	return tfu;
1910	}
1911
1912	localstatic TFormUses
1913	tformImportAll(TFormUses tfu)
1914	{
1915	tfuSetUnqualified(tfu->imports, tfu->tf)((tfu->imports) = (tfu->imports) ? tqSetUnqualified(tfu ->imports) : tqNewUnqualified(tfu->tf));
1916	return tfu;
1917	}
1918
1919	localstatic TFormUses
1920	tformInlineAll(TFormUses tfu)
1921	{
1922	tfuSetUnqualified(tfu->inlines, tfu->tf)((tfu->inlines) = (tfu->inlines) ? tqSetUnqualified(tfu ->inlines) : tqNewUnqualified(tfu->tf));
1923	return tfu;
1924	}
1925
1926	localstatic TFormUses
1927	tformExplicitlyImportAll(TFormUses tfu)
1928	{
1929	tfu->isExplicitImport = true1;
1930	return tformImportAll(tfu);
1931	}
1932
1933	localstatic TFormUses
1934	tformCategoricallyImport(TFormUses tfu)
1935	{
1936	tfu->isCategoryImport = true1;
1937	return tfu;
1938	}
1939
1940	localstatic TFormUses
1941	tformCatConditionImport(TFormUses tfu)
1942	{
1943	tfu->isCatConditionImport = true1;
1944	return tfu;
1945	}
1946
1947	localstatic TFormUses
1948	tformParameterImport(TFormUses tfu)
1949	{
1950	tfu->isParamImport = true1;
1951	return tfu;
1952	}
1953
1954	localstatic TFormUses
1955	tfuNew(TForm tf)
1956	{
1957	TFormUses tu = (TFormUses) stoAlloc(OB_Other0, sizeof(*tu));
1958
1959	tu->isImported = false((int) 0);
1960	tu->isExplicitImport = false((int) 0);
1961	tu->isCategoryImport = false((int) 0);
1962	tu->isCatConditionImport= false((int) 0);
1963	tu->isParamImport = false((int) 0);
1964	tu->tf = tf;
1965	tu->exports = NULL((void*)0);
1966	tu->imports = NULL((void*)0);
1967	tu->inlines = NULL((void*)0);
1968	tu->cascades = listNil(TQual)((TQualList) 0);
1969	tu->extension = listNil(AbSyn)((AbSynList) 0);
1970	tu->extendees = listNil(AbSyn)((AbSynList) 0);
1971	tu->declarees = listNil(Symbol)((SymbolList) 0);
1972	tu->dependents = listNil(TFormUses)((TFormUsesList) 0);
1973	tu->dependees = listNil(TFormUses)((TFormUsesList) 0);
1974	tu->nbefore = 0;
1975	tu->nafter = 0;
1976	tu->cdependents = listNil(TFormUses)((TFormUsesList) 0);
1977	tu->cdependees = listNil(TFormUses)((TFormUsesList) 0);
1978	tu->ncbefore = 0;
1979	tu->ncafter = 0;
1980	tu->sortMark = false((int) 0);
1981	tu->outEdges = listNil(TFormUses)((TFormUsesList) 0);
1982	tu->inDegree = 0;
1983	tu->cmarked = false((int) 0);
1984	tu->crep = NULL((void*)0);
1985
1986	return tu;
1987	}
1988
1989	TFormUses
1990	stabFindTFormUses(Stab stab, AbSyn ab)
1991	{
1992	TFormUses tfu = NULL((void*)0);
1993	TFormUsesList tful;
1994
1995	assert(stab != 0)do { if (!(stab != 0)) _do_assert(("stab != 0"),"stab.c",1995 ); } while (0);
1996	assert(ab != 0)do { if (!(ab != 0)) _do_assert(("ab != 0"),"stab.c",1996); } while (0);
1997
1998	if (stabUseList(stab, ab)!(((stab)->first)->tformsUsed.table)) {
1999	tful = car(stab)((stab)->first)->tformsUsed.list;
2000	for (; tful && !tfu; tful = cdr(tful)((tful)->rest))
2001	if (abEqual(ab, tfGetExpr(car(tful)->tf)((((tful)->first)->tf)->__absyn)))
2002	tfu = car(tful)((tful)->first);
2003	}
2004	else if (stabUseTable(stab, ab)(((stab)->first)->tformsUsed.table))
2005	tfu = (TFormUses) tblElt(car(stab)((stab)->first)->tformsUsed.table,
2006	(TblKey) ab, (TblElt) NULL((void*)0));
2007
2008	return tfu;
2009	}
2010
2011	/*
2012	* Find or create a TFormUses and then call fun on it
2013	*/
2014	localstatic TFormUses
2015	tfuSetFlag(Stab stab, TForm tf, UpdateTfuFun fun)
2016	{
2017	AbSyn ab = tfExpr(tf)tfToAbSyn(tf);
2018	TFormUses tfu = stabFindTFormUses(stab, ab);
2019
2020	if (!tfu) {
2021	/* first remove tf from tformsUnused, if present */
2022	removeTFormUnused(stab, tf);
2023
2024	/* now make a new one */
2025	tfu = tfuNew(tf);
2026
2027	if (stabUseTable(stab, ab)(((stab)->first)->tformsUsed.table))
2028	tblSetElt(car(stab)((stab)->first)->tformsUsed.table,
2029	(TblKey) ab, (TblElt) tfu);
2030	listPush(TFormUses, tfu, car(stab)->tformsUsed.list)(((stab)->first)->tformsUsed.list = (TFormUses_listPointer ->Cons)(tfu, ((stab)->first)->tformsUsed.list));
2031	}
2032
2033	return fun(tfu);
2034	}
2035
2036	localstatic TForm
2037	findTFormUnused(Stab stab, AbSyn ab)
2038	{
2039	TFormList tfl;
2040
2041	for (tfl = car(stab)((stab)->first)->tformsUnused; tfl; tfl = cdr(tfl)((tfl)->rest))
2042	if (abEqual(ab, tfGetExpr(car(tfl))((((tfl)->first))->__absyn)))
2043	return car(tfl)((tfl)->first);
2044
2045	return 0;
2046	}
2047
2048	localstatic TForm
2049	addTFormUnused(Stab stab, TForm tf)
2050	{
2051	car(stab)((stab)->first)->tformsUnused =
2052	listCons(TForm)(TForm_listPointer->Cons) (tf, car(stab)((stab)->first)->tformsUnused);
2053	return tf;
2054	}
2055
2056	localstatic void
2057	removeTFormUnused(Stab stab, TForm tf)
2058	{
2059	car(stab)((stab)->first)->tformsUnused =
2060	listNRemove(TForm)(TForm_listPointer->NRemove) (car(stab)((stab)->first)->tformsUnused, tf, tfEqual);
2061	}
2062
2063	TForm
2064	stabMakeUsedTForm(Stab stab, AbSyn ab, TfCondElt conditions)
2065	{
2066	TFormUses tfu;
2067	TForm tf;
2068
2069	tfu = stabFindTFormUses(stab, ab);
2070	if (tfu == NULL((void*)0)) {
2071	tf = tfSyntaxFrAbSyn(stab, ab);
2072	tfu = tfuSetFlag(stab, tf, tformDoNothing);
	Value stored to 'tfu' is never read
2073	}
2074	else {
2075	tf = tfu->tf;
2076	}
2077
2078	tfSyntaxConditions(stab, tf, conditions);
2079	abSetTForm(ab, tf);
2080	return tf;
2081	}
2082
2083	TForm
2084	stabMakeImportedTForm(Stab stab, TForm tf)
2085	{
2086	return tfuSetFlag(stab, tf, tformIsImported)->tf;
2087	}
2088
2089	TForm
2090	stabExportTForm(Stab stab, TForm tf)
2091	{
2092	return tfuSetFlag(stab, tf, tformExportAll)->tf;
2093	}
2094
2095	TForm
2096	stabImportTForm(Stab stab, TForm tf)
2097	{
2098	return tfuSetFlag(stab, tf, tformImportAll)->tf;
2099	}
2100
2101	TForm
2102	stabInlineTForm(Stab stab, TForm tf)
2103	{
2104	return tfuSetFlag(stab, tf, tformInlineAll)->tf;
2105	}
2106
2107	TForm
2108	stabExplicitlyImportTForm(Stab stab, TForm tf)
2109	{
2110	return tfuSetFlag(stab, tf, tformExplicitlyImportAll)->tf;
2111	}
2112
2113	TForm
2114	stabCategoricallyImportTForm(Stab stab, TForm tf)
2115	{
2116	return tfuSetFlag(stab, tf, tformCategoricallyImport)->tf;
2117	}
2118
2119	TForm
2120	stabParameterImportTForm(Stab stab, TForm tf)
2121	{
2122	return tfuSetFlag(stab, tf, tformParameterImport)->tf;
2123	}
2124
2125	TForm
2126	stabQualifiedExportTForm(Stab stab, AbSyn ab, TForm tf)
2127	{
2128	TFormUses tfu = tfuSetFlag(stab, tf, tformDoNothing);
2129
2130	tfuSetQualified(tfu->exports, tfu->tf, tfSyntaxFrAbSyn(stab, ab))((tfu->exports) = (tfu->exports) ? (((tfu->exports)-> isQual == 1) ? tqAddQual(tfu->exports,tfSyntaxFrAbSyn(stab , ab)) : (tfu->exports)) : tqNewQualified(tfu->tf,tfSyntaxFrAbSyn (stab, ab)));
2131
2132	return tf;
2133	}
2134
2135	TForm
2136	stabQualifiedImportTForm(Stab stab, AbSyn ab, TForm tf)
2137	{
2138	TFormUses tfu = tfuSetFlag(stab, tf, tformDoNothing);
2139
2140	tfuSetQualified(tfu->imports, tfu->tf, tfSyntaxFrAbSyn(stab, ab))((tfu->imports) = (tfu->imports) ? (((tfu->imports)-> isQual == 1) ? tqAddQual(tfu->imports,tfSyntaxFrAbSyn(stab , ab)) : (tfu->imports)) : tqNewQualified(tfu->tf,tfSyntaxFrAbSyn (stab, ab)));
2141	tfu->isExplicitImport = true1;
2142
2143	return tf;
2144	}
2145
2146	TForm
2147	stabQualifiedInlineTForm(Stab stab, AbSyn ab, TForm tf)
2148	{
2149	TFormUses tfu = tfuSetFlag(stab, tf, tformDoNothing);
2150
2151	tfuSetQualified(tfu->inlines, tfu->tf, tfSyntaxFrAbSyn(stab, ab))((tfu->inlines) = (tfu->inlines) ? (((tfu->inlines)-> isQual == 1) ? tqAddQual(tfu->inlines,tfSyntaxFrAbSyn(stab , ab)) : (tfu->inlines)) : tqNewQualified(tfu->tf,tfSyntaxFrAbSyn (stab, ab)));
2152
2153	return tf;
2154	}
2155
2156	/*
2157	* Add an id declared to be an extension with the type tf.
2158	*/
2159	TForm
2160	stabAddTFormExtension(Stab stab, TForm tf, AbSyn extension)
2161	{
2162	TFormUses tfu;
2163	int i, declc = 0;
2164	AbSyn *declv;
2165
2166	tfu = tfuSetFlag(stab, tf, tformDoNothing);
2167
2168	switch (abTag(extension)((extension)->abHdr.tag)) {
2169	case AB_Nothing:
2170	declc = 0;
2171	declv = 0;
2172	break;
2173	case AB_Sequence:
2174	case AB_Comma:
2175	declc = abArgc(extension)((extension)->abHdr.argc);
2176	declv = abArgv(extension)((extension)->abGen.data.argv);
2177	break;
2178	default:
2179	declc = 1;
2180	declv = &extension;
2181	break;
2182	}
2183
2184	for (i = 0; i < declc; i += 1)
2185	tfu->extension = listCons(AbSyn)(AbSyn_listPointer->Cons)(declv[i], tfu->extension);
2186
2187	return tf;
2188	}
2189
2190	/*
2191	* Add an id declared to be an extendee with the type tf.
2192	*/
2193	TForm
2194	stabAddTFormExtendees(Stab stab, TForm tf, AbSyn extendees)
2195	{
2196	TFormUses tfu;
2197	int i, declc = 0;
2198	AbSyn *declv;
2199
2200	tfu = tfuSetFlag(stab, tf, tformDoNothing);
2201
2202	switch (abTag(extendees)((extendees)->abHdr.tag)) {
2203	case AB_Nothing:
2204	declc = 0;
2205	declv = 0;
2206	break;
2207	case AB_Sequence:
2208	case AB_Comma:
2209	declc = abArgc(extendees)((extendees)->abHdr.argc);
2210	declv = abArgv(extendees)((extendees)->abGen.data.argv);
2211	break;
2212	default:
2213	declc = 1;
2214	declv = &extendees;
2215	break;
2216	}
2217
2218	for (i = 0; i < declc; i += 1)
2219	tfu->extendees = listCons(AbSyn)(AbSyn_listPointer->Cons)(declv[i], tfu->extendees);
2220
2221	return tf;
2222	}
2223
2224	/*
2225	* Record the fact that the question "dom has cat" has been asked.
2226	*/
2227	TForm
2228	stabAddTFormQuery(Stab stab, TForm dom, TForm cat)
2229	{
2230	tfFollow(dom)((dom) = tfFollowFn(dom));
2231	tfAddQuery(dom, cat);
2232	if (tfIsSyntax(dom)(((dom)->tag) == TF_Syntax) && abIsTheId(tfGetExpr(dom), ssymSelf)(((((dom)->__absyn))->abHdr.tag == (AB_Id)) && ( (((dom)->__absyn))->abId.sym)==(ssymSelf))) {
2233	TFormUses tfu = stabFindTFormUses(stab, tfExpr(cat)tfToAbSyn(cat));
2234	tformCatConditionImport(tfu);
2235	}
2236	return dom;
2237	}
2238
2239	/*
2240	* Add an id declared to have type tf if not already in the list.
2241	* Handles sequences or commas of ids.
2242	*/
2243	TForm
2244	stabAddTFormDeclaree(Stab stab, TForm tf, AbSyn declarees)
2245	{
2246	TFormUses tfu;
2247	int i, declc = 0;
2248	AbSyn *declv;
2249	Bool wasEmpty;
2250
2251	tfu = tfuSetFlag(stab, tf, tformDoNothing);
2252
2253	switch (abTag(declarees)((declarees)->abHdr.tag)) {
2254	case AB_Nothing:
2255	declc = 0;
2256	declv = 0;
2257	break;
2258	case AB_Sequence:
2259	case AB_Comma:
2260	declc = abArgc(declarees)((declarees)->abHdr.argc);
2261	declv = abArgv(declarees)((declarees)->abGen.data.argv);
2262	break;
2263	default:
2264	declc = 1;
2265	declv = &declarees;
2266	break;
2267	}
2268
2269	wasEmpty = tfu->declarees ? false((int) 0) : true1;
2270
2271	for (i = 0; i < declc; i += 1) {
2272	Symbol s = declv[i]->abId.sym;
2273	if (wasEmpty \|\| ! listMemq(Symbol)(Symbol_listPointer->Memq)(tfu->declarees, s))
2274	tfu->declarees = listCons(Symbol)(Symbol_listPointer->Cons)(s, tfu->declarees);
2275	}
2276
2277	return tfu->tf;
2278	}
2279
2280
2281	TForm
2282	stabGetTForm(Stab stab, AbSyn ab, TForm failed)
2283	{
2284	TFormUses tfu;
2285	TForm tf;
2286
2287	assert(stab != 0)do { if (!(stab != 0)) _do_assert(("stab != 0"),"stab.c",2287 ); } while (0);
2288
2289	if (stabLevelIsLocked(stab)(((stab)->first)->isLocked))
2290	return stabGetTForm(cdr(stab)((stab)->rest), ab, failed);
2291
2292	tf = findTFormUnused(stab, ab);
2293	if (tf)
2294	return tf;
2295
2296	tfu = stabFindTFormUses(stab, ab);
2297	if (tfu)
2298	return tfu->tf;
2299
2300	return failed;
2301	}
2302
2303	TForm
2304	stabDefTForm(Stab stab, TForm tf)
2305	{
2306	/* !! presume NOT already present */
2307	/* !! (this is presumptious) */
2308	if (stabLevelIsLocked(stab)(((stab)->first)->isLocked))
2309	stabDefTForm(cdr(stab)((stab)->rest), tf);
2310
2311	#if 0
2312	/* Someone turn this into a proper -Wd debug hook ... */
2313	if (tfGetExpr(tf)((tf)->__absyn) && abIsTheId(tfGetExpr(tf), ssymSelf)(((((tf)->__absyn))->abHdr.tag == (AB_Id)) && ( (((tf)->__absyn))->abId.sym)==(ssymSelf)))
2314	{
2315	Stab fil = stabFile();
2316	SrcPosStack sposStk = tfGetExpr(tf)((tf)->__absyn)->abHdr.pos;
2317
2318	(void)fprintf(dbOut, "defTForm: <%3d: %d/%d> (%3d: %d/%d)\n",
2319	stabSerialNo(stab)(((stab)->first)->serialNo),
2320	stabLevelNo(stab)(((stab)->first)->lexicalLevel),
2321	stabLambdaLevelNo(stab)(((stab)->first)->lambdaLevel),
2322	stabSerialNo(fil)(((fil)->first)->serialNo),
2323	stabLevelNo(fil)(((fil)->first)->lexicalLevel),
2324	stabLambdaLevelNo(fil)(((fil)->first)->lambdaLevel));
2325	if (sposStk.stack != NULL((void*)0))
2326	{
2327	SrcPos pos = spstackFirst(sposStk);
2328	spstackPrintLine(dbOut, pos);
2329	}
2330	fnewline(dbOut);
2331	}
2332	#endif
2333
2334	return addTFormUnused(stab, tf);
2335	}
2336
2337	Bool
2338	stabIsImportedTForm(Stab stab, TForm tf)
2339	{
2340	/*
2341	* This function walks up the stab stack to see if tf has already been
2342	* imported.
2343	*/
2344
2345	/* Sanity check/hack */
2346	if (!tfHasSelf(tf)((tf)->hasSelf))
2347	{
2348	/*
2349	* Something bad has happened to the tf but we re-import
2350	* it anyway. See tfCopyQueries for one example of "Bad".
2351	* Currently, we don't reset it anywhere else.
2352	*/
2353	/* (void)fprintf(dbOut, "(((ooops)))\n"); */
2354	return false((int) 0);
2355	}
2356
2357	for (; stab; stab = cdr(stab)((stab)->rest)) {
2358	TFormUses tfu = stabFindTFormUses(stab, tfExpr(tf)tfToAbSyn(tf));
2359
2360	if (tfu && tfu->isImported) {
2361	if (tfIsMeaning(tfu->tf)(((tfu->tf)->state)>=TF_State_Meaning) && tfIsMeaning(tf)(((tf)->state)>=TF_State_Meaning) &&
2362	!tformEqual(tfu->tf, tf))
2363	continue;
2364	return true1;
2365	}
2366	}
2367	return false((int) 0);
2368	}
2369
2370	TForm
2371	stabFindOuterTForm(Stab stab, AbSyn ab)
2372	{
2373	assert(stab)do { if (!(stab)) _do_assert(("stab"),"stab.c",2373); } while (0);
2374
2375	for (; stab; stab = cdr(stab)((stab)->rest)) {
2376	TForm tf = findTFormUnused(stab, ab);
2377
2378	if (! tf) {
2379	TFormUses tfu = stabFindTFormUses(stab, ab);
2380	if (tfu)
2381	tf = tfu->tf;
2382	}
2383	if (tf) {
2384	tfFollow(tf)((tf) = tfFollowFn(tf));
2385	return tf;
2386	}
2387	}
2388	return NULL((void*)0);
2389	}
2390
2391
2392	/*
2393	* getAllTypesUsed recurses from sl down and gets all types imported,
2394	* inlined, or otherwise used. The first two list may overlap but the
2395	* third will not overlap either of the other two.
2396	*/
2397
2398	localstatic void getAllTypesUsed0(StabLevel sl, struct typesUsed *tu);
2399
2400	struct typesUsed *
2401	getAllTypesUsed(StabLevel sl)
2402	{
2403	struct typesUsed tu = (struct typesUsed )
2404	stoAlloc((unsigned) OB_Other0, sizeof(struct typesUsed));
2405
2406	tu->typesImported = tu->typesInlined = tu->typesOther = 0;
2407
2408	getAllTypesUsed0(sl, tu);
2409
2410	/*
2411	* do a final check to make sure 'other' types are not imported
2412	* or inlined.
2413	*/
2414
2415	if (tu->typesOther) {
2416	AbSynList al = tu->typesOther, reallyUnused = 0;
2417
2418	while (al) {
2419	int pos;
2420	AbSyn ab = car(al)((al)->first);
2421
2422	al = cdr(al)((al)->rest);
2423	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesImported,ab,abEqual,&pos);
2424	if (pos != -1)
2425	continue;
2426	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesInlined,ab,abEqual,&pos);
2427	if (pos == -1)
2428	reallyUnused = listCons(AbSyn)(AbSyn_listPointer->Cons)(ab,reallyUnused);
2429	}
2430
2431	if (reallyUnused) {
2432	listFree(AbSyn)(AbSyn_listPointer->Free)(tu->typesOther);
2433	tu->typesOther = reallyUnused;
2434	}
2435	}
2436
2437
2438	return tu;
2439	}
2440
2441	localstatic void
2442	getAllTypesUsed0(StabLevel sl, struct typesUsed *tu)
2443	{
2444	StabList children = sl->children;
2445	TFormUsesList tfuses = sl->tformsUsed.list;
2446	TFormList tfunused = sl->tformsUnused;
2447
2448	/* first do children and then me */
2449
2450	while (children) {
2451	getAllTypesUsed0(car(car(children))((((children)->first))->first), tu);
2452	children = cdr(children)((children)->rest);
2453	}
2454
2455	/* iterate across the used tforms */
2456
2457	while (tfuses) {
2458	Bool used = false((int) 0);
2459	TFormUses tfu = car(tfuses)((tfuses)->first);
2460	AbSyn ab;
2461	int pos;
2462
2463	tfuses = cdr(tfuses)((tfuses)->rest);
2464	if (tfIsWith(tfu->tf)(((tfu->tf)->tag) == TF_With))
2465	continue;
2466	ab = tfGetExpr(tfu->tf)((tfu->tf)->__absyn);
2467	if (abHasTag(ab, AB_Apply)((ab)->abHdr.tag == (AB_Apply)))
2468	ab = ab->abApply.op;
2469	if (abHasTag(ab, AB_With)((ab)->abHdr.tag == (AB_With)))
2470	continue;
2471
2472	if (tfu->imports) {
2473	used = true1;
2474	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesImported,ab,abEqual,&pos);
2475	if (pos == -1)
2476	tu->typesImported =
2477	listCons(AbSyn)(AbSyn_listPointer->Cons)(ab,tu->typesImported);
2478	}
2479
2480	if (tfu->inlines) {
2481	used = true1;
2482	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesInlined,ab,abEqual,&pos);
2483	if (pos == -1)
2484	tu->typesInlined =
2485	listCons(AbSyn)(AbSyn_listPointer->Cons)(ab,tu->typesInlined);
2486	}
2487
2488	if (used == false((int) 0)) {
2489	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesOther,ab,abEqual,&pos);
2490	if (pos == -1)
2491	tu->typesOther =
2492	listCons(AbSyn)(AbSyn_listPointer->Cons)(ab,tu->typesOther);
2493	}
2494	}
2495
2496	/* iterate across the unused tforms */
2497
2498	while (tfunused) {
2499	TForm tf = car(tfunused)((tfunused)->first);
2500	AbSyn ab;
2501	int pos;
2502
2503	tfunused = cdr(tfunused)((tfunused)->rest);
2504
2505	if (tfIsWith(tf)(((tf)->tag) == TF_With))
2506	continue;
2507	ab = tfGetExpr(tf)((tf)->__absyn);
2508	if (abHasTag(ab, AB_Apply)((ab)->abHdr.tag == (AB_Apply)))
2509	ab = ab->abApply.op;
2510	if (abHasTag(ab, AB_With)((ab)->abHdr.tag == (AB_With)))
2511	continue;
2512
2513	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesImported,ab,abEqual,&pos);
2514	if (pos != -1)
2515	continue;
2516
2517	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesInlined,ab,abEqual,&pos);
2518	if (pos != -1)
2519	continue;
2520
2521	listFind(AbSyn)(AbSyn_listPointer->Find)(tu->typesOther,ab,abEqual,&pos);
2522	if (pos == -1)
2523	tu->typesOther = listCons(AbSyn)(AbSyn_listPointer->Cons)(ab,tu->typesOther);
2524	}
2525	}
2526
2527
2528	/*
2529	* stabAddLabel(stab, label): Add label to the list of labels in this scope.
2530	* It is an error if the label is already present.
2531	*/
2532	void
2533	stabAddLabel(Stab stab, AbSyn label)
2534	{
2535	Symbol labsym = label->abId.sym;
2536	if (stabLabelExistsInThisStab(stab, labsym)) {
2537	AbSyn abLab = stabGetLabelInThisStab(stab, labsym);
2538	comsgNError(label, ALDOR_E_StabDupLabels139, symString(labsym)((labsym)->str));
2539	comsgNote(abLab, ALDOR_N_Here3);
2540	}
2541	else {
2542	Syme syme = symeNewLabel(labsym, tfNone()tfMulti(0), car(stab)((stab)->first));
2543	abSetSyme(label, syme);
2544	car(stab)((stab)->first)->labelsInScope =
2545	listCons(AbSyn)(AbSyn_listPointer->Cons)(label, car(stab)((stab)->first)->labelsInScope);
2546	}
2547	}
2548
2549	/*
2550	* stabGetAllLabels(stab): return a list of all labels in this or outer scopes.
2551	*/
2552	AbSynList
2553	stabGetAllLabels(Stab stab)
2554	{
2555	Stab stab0;
2556	AbSynList allLabels = listNil(AbSyn)((AbSynList) 0);
2557	for (stab0 = stab; stab0; stab0 = cdr(stab0)((stab0)->rest))
2558	allLabels = listConcat(AbSyn)(AbSyn_listPointer->Concat)(car(stab)((stab)->first)->labelsInScope,
2559	allLabels);
2560	return allLabels;
2561	}
2562
2563	/*
2564	* stabLabelExists(stab, label): returns true if the label is present in
2565	* this or any outer scope, false otherwise.
2566	*/
2567	Bool
2568	stabLabelExists(Stab stab, Symbol label)
2569	{
2570	Stab stab0;
2571	for (stab0 = stab; stab0; stab0 = cdr(stab0)((stab0)->rest))
2572	if (stabLabelExistsInThisStab(stab0, label))
2573	return true1;
2574	return false((int) 0);
2575	}
2576
2577	/*
2578	* stabLabelExistsInThisStab(stab, label): returns true if the label is
2579	* present in this symbol table level, false otherwise.
2580	*/
2581	Bool
2582	stabLabelExistsInThisStab(Stab stab, Symbol label)
2583	{
2584	AbSynList asl = car(stab)((stab)->first)->labelsInScope;
2585	while (asl) {
2586	if (label == car(asl)((asl)->first)->abId.sym)
2587	return true1;
2588	asl = cdr(asl)((asl)->rest);
2589	}
2590	return false((int) 0);
2591	}
2592
2593	/*
2594	* stabGetLabels(stab, label): returns all labels (absyns) with the given
2595	* name in this or any outer symbol table level.
2596	*/
2597	AbSynList
2598	stabGetLabels(Stab stab, Symbol label)
2599	{
2600	AbSynList labels = listNil(AbSyn)((AbSynList) 0);
2601	Stab stab0;
2602
2603	for (stab0 = stab; stab0; stab0 = cdr(stab0)((stab0)->rest)) {
2604	AbSyn foundLabel = stabGetLabelInThisStab(stab0, label);
2605	if (foundLabel)
2606	labels = listCons(AbSyn)(AbSyn_listPointer->Cons)(foundLabel, labels);
2607	}
2608	return listNReverse(AbSyn)(AbSyn_listPointer->NReverse)(labels);
2609	}
2610
2611	/*
2612	* stabGetLabelInThisStab(stab, label): returns the unique label in this
2613	* symbol table level with the given name, if it exists. If it is
2614	* note present, 0 is returned.
2615	*/
2616	AbSyn
2617	stabGetLabelInThisStab(Stab stab, Symbol label)
2618	{
2619	AbSynList asl = car(stab)((stab)->first)->labelsInScope;
2620	while (asl) {
2621	if (label == car(asl)((asl)->first)->abId.sym)
2622	return car(asl)((asl)->first);
2623	asl = cdr(asl)((asl)->rest);
2624	}
2625	return 0;
2626	}
2627
2628	/* If an inner stab level can be found which binds syme, return it. */
2629	Stab
2630	stabFindLevel(Stab stab, Syme syme)
2631	{
2632	StabList sl;
2633
2634	if (stabLevelNo(stab)(((stab)->first)->lexicalLevel) >= symeDefLevelNo(syme)(symeDefLevel(syme)->lexicalLevel))
2635	return stab;
2636
2637	for (sl = car(stab)((stab)->first)->children; sl; sl = cdr(sl)((sl)->rest)) {
2638	Stab istab = car(sl)((sl)->first), nstab;
2639
2640	if (car(istab)((istab)->first) == symeDefLevel(syme))
2641	return istab;
2642
2643	nstab = stabFindLevel(istab, syme);
2644	if (nstab != istab)
2645	return nstab;
2646	}
2647
2648	return stab;
2649	}
2650
2651
2652	Bool stabIsChild(Stab parent, Stab child)
2653	{
2654	Bool isChild = false((int) 0);
2655
2656	while (child != listNil(StabLevel)((StabLevelList) 0)) {
2657	if (child == parent)
2658	return true1;
2659	child = cdr(child)((child)->rest);
2660	}
2661
2662	return isChild;
2663	}