---

symtable.c File Reference

#include "lclintMacros.nf"
#include "llbasic.h"
#include "gram.h"
#include "lclscan.h"
#include "lclsyntable.h"
#include "lslparse.h"

Go to the source code of this file.

Compounds
struct	_idTable
struct	_symtableStruct
struct	idTableEntry
Defines
#define	MAXBUFFLEN   512
#define	DELTA   100
Typedefs
typedef struct _idTable	idTable
typedef fctInfo	o_fctInfo
Enumerations
enum	symKind { SYMK_FCN, SYMK_SCOPE, SYMK_TYPE, SYMK_VAR }
Functions
void	varInfo_free ( varInfo v)
void	symtable_free (symtable stable)
symtable	symtable_new (void)
void	symtable_enterOp (symtable st, nameNode n, sigNode oi)
bool	symtable_enterTag (symtable st, tagInfo ti)
bool	symtable_enterTagForce (symtable st, tagInfo ti)
opInfo	symtable_opInfo (symtable st, nameNode n)
tagInfo	symtable_tagInfo (symtable st, lsymbol i)
void	symtable_enterScope (symtable stable, scopeInfo si)
void	symtable_exitScope (symtable stable)
bool	symtable_enterFct (symtable stable, fctInfo fi)
void	symtable_enterType (symtable stable, typeInfo ti)
lsymbol	lsymbol_sortFromType (symtable s, lsymbol typename)
bool	symtable_enterVar (symtable stable, varInfo vi)
bool	symtable_exists (symtable stable, lsymbol i)
typeInfo	symtable_typeInfo (symtable stable, lsymbol i)
varInfo	symtable_varInfo (symtable stable, lsymbol i)
varInfo	symtable_varInfoInScope (symtable stable, lsymbol id)
void	symtable_export (symtable stable, bool yesNo)
void	symtable_dump (symtable stable, FILE * f, bool lco)
lsymbol	lsymbol_translateSort (mapping * m, lsymbol s)
void	symtable_import (tsource *imported, ltoken tok, mapping * map)
void	symtable_printStats (symtable s)
cstring	tagKind_unparse (tagKind k)
sigNodeSet	symtable_possibleOps (symtable tab, nameNode n)
bool	symtable_opExistsWithArity (symtable tab, nameNode n, int arity)
lslOpSet	symtable_opsWithLegalDomain (symtable tab, nameNode n, sortSetList argSorts, sort qual)

---

Define Documentation

#define DELTA   100

Definition at line 58 of file symtable.c.

#define MAXBUFFLEN   512

Definition at line 56 of file symtable.c.

---

Typedef Documentation

typedef struct _idTable idTable

typedef fctInfo o_fctInfo

Definition at line 958 of file symtable.c.

---

Enumeration Type Documentation

enum symKind

Enumeration values: SYMK_FCN   SYMK_SCOPE   SYMK_TYPE   SYMK_VAR   Definition at line 68 of file symtable.c. { SYMK_FCN, SYMK_SCOPE, SYMK_TYPE, SYMK_VAR }

---

Function Documentation

lsymbol lsymbol_sortFromType ( symtable s, lsymbol typename )

Definition at line 565 of file symtable.c. Referenced by processTraitSortId(). { lsymbol inter; lsymbol out; ltoken tok; /* check the synonym table first */ if (LCLIsSyn (typename)) { tok = LCLGetTokenForSyn (typename); inter = ltoken_getText (tok); /* printf ("In lsymbol_sortFromType: %s -> %s\n", lsymbol_toChars (typename), lsymbol_toChars (inter)); */ } else { inter = typename; } /* now map LCL type to sort */ out = mapping_find (s->type2sort, inter); if (out == lsymbol_undefined) { return inter; } return out; }

lsymbol lsymbol_translateSort ( mapping * m, lsymbol s )

Definition at line 825 of file symtable.c. { lsymbol res = mapping_find (m, s); if (res == lsymbol_undefined) return s; return res; }

void symtable_dump ( symtable stable, FILE * f, bool lco )

Definition at line 810 of file symtable.c. Referenced by outputLCSFile(). { symHashTable *ht = stable->hTable; fprintf (f, "%s\n", BEGINSYMTABLE); symHashTable_dump (ht, f, lco); symtable_dumpId (stable, f, lco); fprintf (f, "%s\n", SYMTABLEEND); }

bool symtable_enterFct ( symtable stable, fctInfo fi )

Definition at line 489 of file symtable.c. Referenced by enteringFcnScope(), and o_fctInfo(). { idTable *st = stable->idTable; idTableEntry *e; bool redecl = FALSE; if (!allowed_redeclaration && symtable_lookup (st, ltoken_getText (fi->id)) != (idTableEntry *) 0) { lclRedeclarationError (fi->id); redecl = TRUE; } e = nextFree (st); e->kind = SYMK_FCN; fi->export = st->exporting; /* && !fi->private; */ (e->info).fct = fi; return redecl; }

void symtable_enterOp ( symtable st, nameNode n, sigNode oi )

Definition at line 304 of file symtable.c. Referenced by abstract_init(), makeLiteralTermNode(), makelslOpNode(), and o_fctInfo(). { /* ** Operators are overloaded, we allow entering opInfo more than once, ** even if it's the same signature. ** ** Assumes all sorts are already entered into the symbol table */ symHashTable *ht = st->hTable; htData *d; lsymbol id; id = nameNode2key (n); d = symHashTable_get (ht, id, IK_OP, n); if (d == (htData *) 0) { /* first signature of this operator */ opInfo op = (opInfo) dmalloc (sizeof (*op)); htData *nd = (htData *) dmalloc (sizeof (*nd)); op->name = n; if (oi != (sigNode) 0) { op->signatures = sigNodeSet_singleton (oi); ht->count++; } else { op->signatures = sigNodeSet_new (); sigNode_markOwned (oi); } nd->kind = IK_OP; nd->content.op = op; (void) symHashTable_put (ht, nd); } else { nameNode_free (n); /*<<<??? */ if (htData_insertSignature (d, oi)) { ht->count++; } } }

void symtable_enterScope ( symtable stable, scopeInfo si )

Definition at line 456 of file symtable.c. Referenced by enteringClaimScope(), and enteringFcnScope(). { idTable *st = stable->idTable; idTableEntry *e = nextFree (st); if (si->kind == SPE_GLOBAL) llbuglit ("symtable_enterScope: SPE_GLOBAL"); e->kind = SYMK_SCOPE; (e->info).scope = si; }

bool symtable_enterTag ( symtable st, tagInfo ti )

Definition at line 359 of file symtable.c. Referenced by checkAndEnterTag(), and makeEnumSpecNode(). { /* put ti only if it is not already in symtable */ symHashTable *ht = st->hTable; htData *d; symbolKey key = ltoken_getText (ti->id); d = symHashTable_get (ht, key, IK_TAG, (nameNode) 0); if (d == (htData *) 0) { d = (htData *) dmalloc (sizeof (*d)); d->kind = IK_TAG; d->content.tag = ti; d->content.tag->imported = context_inImport (); (void) symHashTable_put (ht, d); return TRUE; } else { if (d->content.tag->imported) { d->content.tag = ti; d->content.tag->imported = context_inImport (); return TRUE; } else { tagInfo_free (ti); return FALSE; } } }

bool symtable_enterTagForce ( symtable st, tagInfo ti )

Definition at line 393 of file symtable.c. Referenced by makestrOrUnionNode(). { /* put ti, force-put if necessary */ symHashTable *ht = st->hTable; htData *d; symbolKey key = ltoken_getText (ti->id); d = symHashTable_get (ht, key, IK_TAG, (nameNode) 0); if (d == (htData *) 0) { d = (htData *) dmalloc (sizeof (*d)); d->kind = IK_TAG; d->content.tag = ti; d->content.tag->imported = context_inImport (); (void) symHashTable_put (ht, d); return TRUE; } else { d->kind = IK_TAG; d->content.tag = ti; d->content.tag->imported = context_inImport (); /* interpret return data later, htData * */ /*@i@*/ (void) symHashTable_forcePut (ht, d); return FALSE; } }

void symtable_enterType ( symtable stable, typeInfo ti )

Definition at line 511 of file symtable.c. Referenced by LCLBuiltins(), abstract_init(), declareForwardType(), makeAbstractNode(), and o_fctInfo(). { idTable *st = stable->idTable; idTableEntry *e; bool insertp = TRUE; scopeKind k = (symtable_scopeInfo (stable))->kind; /* symtable_disp (stable); */ if (k != SPE_GLOBAL && k != SPE_INVALID) /* fixed for LCLint */ { llbug (message ("%q: symtable_enterType: expect global scope. (type: %s)", ltoken_unparseLoc (ti->id), ltoken_getRawString (ti->id))); } if (!allowed_redeclaration && symtable_lookup (st, ltoken_getText (ti->id)) != (idTableEntry *) 0) { /* ignore if Bool is re-entered */ if (ltoken_getText (ti->id) == lsymbol_getBool () || ltoken_getText (ti->id) == lsymbol_getbool ()) { insertp = FALSE; } else { lclRedeclarationError (ti->id); } } if (insertp) { /* make sure it is a type TYPEDEF_NAME; */ if (ltoken_getCode (ti->id) != LLT_TYPEDEF_NAME) { lclbug (message ("symtable_enterType: gets a simpleId, expect a type: %s", ltoken_getRawString (ti->id))); } e = nextFree (st); e->kind = SYMK_TYPE; ti->export = st->exporting;/* && !ti->private; */ (e->info).type = ti; mapping_bind (stable->type2sort, ltoken_getText (ti->id), sort_getLsymbol (sort_makeVal (sort_getUnderlying (ti->basedOn)))); } else { typeInfo_free (ti); } }

bool symtable_enterVar ( symtable stable, varInfo vi )

Definition at line 601 of file symtable.c. Referenced by LCLBuiltins(), enteringClaimScope(), enteringFcnScope(), makeConstDeclarationNode(), makeEnumSpecNode(), makeLetDeclNode(), makeVarDeclarationNode(), makeVarNode(), o_fctInfo(), and sort_import(). { idTable *st = stable->idTable; bool insertp = TRUE; bool redecl = FALSE; /* symtable_disp (symtab); */ if (!allowed_redeclaration && (symtable_lookupInScope (st, ltoken_getText (vi->id)) != (idTableEntry *) 0)) { if (ltoken_getText (vi->id) == lsymbol_getTRUE () || ltoken_getText (vi->id) == lsymbol_getFALSE ()) { insertp = FALSE; } else { if (usymtab_existsEither (ltoken_getRawString (vi->id))) { lclRedeclarationError (vi->id); redecl = TRUE; } else { llbuglit ("redeclared somethingerother?!"); } } } if (insertp) { idTableEntry *e = nextFree (st); e->kind = SYMK_VAR; vi->export = st->exporting && /* !vi.private && */ (vi->kind == VRK_VAR || vi->kind == VRK_CONST || vi->kind == VRK_ENUM); (e->info).var = varInfo_copy (vi); } return (redecl); }

bool symtable_exists ( symtable stable, lsymbol i )

Definition at line 646 of file symtable.c. Referenced by yllex(). { idTable *st = stable->idTable; return symtable_lookup (st, i) != (idTableEntry *) 0; }

void symtable_exitScope ( symtable stable )

Definition at line 467 of file symtable.c. { idTable *st = stable->idTable; int n; if (st->entries != NULL) { for (n = st->size - 1; (st->entries[n]).kind != SYMK_SCOPE; n--) { ; } } else { llcontbuglit ("symtable_exitScope: no scope to exit"); n = 0; } st->size = n; }

void symtable_export ( symtable stable, bool yesNo )

Definition at line 734 of file symtable.c. { idTable *st = stable->idTable; st->exporting = yesNo; (void) sort_setExporting (yesNo); }

void symtable_free ( symtable stable )

Definition at line 142 of file symtable.c. { /* symtable_printStats (stable); */ idTable_free (stable->idTable); symHashTable_free (stable->hTable); mapping_free (stable->type2sort); sfree (stable); }

void symtable_import ( tsource * imported, ltoken tok, mapping * map )

Definition at line 1375 of file symtable.c. Referenced by processImport(). { char *buf, *importfile; tsource *lclsource; int old_lsldebug; bool old_inImport = inImport; buf = tsource_nextLine (imported); importfile = tsource_fileName (imported); llassert (buf != NULL); if (!firstWord (buf, "%LCLSymbolTable")) { lclsource = LCLScanSource (); lclfatalerror (tok, message ("Expecting '%%LCLSymbolTable' line in import file %s:\n%s\n", cstring_fromChars (importfile), cstring_fromChars (buf))); } old_lsldebug = lsldebug; lsldebug = 0; allowed_redeclaration = TRUE; inImport = TRUE; for (;;) { buf = tsource_nextLine (imported); llassert (buf != NULL); if (firstWord (buf, "%LCLSymbolTableEnd")) { break; } else { /* a good line, remove %LCL from line first */ if (firstWord (buf, "%LCL")) { parseLine (buf + 4, imported, map); } else { lclsource = LCLScanSource (); lclfatalerror (tok, message ("Expecting '%%LCL' prefix in import file %s:\n%s\n", cstring_fromChars (importfile), cstring_fromChars (buf))); } } } /* restore old value */ inImport = old_inImport; lsldebug = old_lsldebug; allowed_redeclaration = FALSE; }

symtable symtable_new ( void )

Definition at line 220 of file symtable.c. { symtable stable = (symtable) dmalloc (sizeof (*stable)); idTableEntry *e; stable->idTable = symtable_newIdTable (); stable->hTable = symHashTable_create (HT_MAXINDEX); stable->type2sort = mapping_create (); /* add builtin synonym: Bool -> bool */ mapping_bind (stable->type2sort, lsymbol_getBool (), lsymbol_getbool ()); /* ** done by symtable_newIdTable ** st->allocated = 0; ** st->entries = (idTableEntry *) 0; ** st->exporting = TRUE; */ /* this is global scope */ e = nextFree (stable->idTable); e->kind = SYMK_SCOPE; (e->info).scope = (scopeInfo) dmalloc (sizeof (*((e->info).scope))); (e->info).scope->kind = SPE_GLOBAL; return stable; }

bool symtable_opExistsWithArity ( symtable tab, nameNode n, int arity )

Definition at line 2039 of file symtable.c. Referenced by computePossibleSorts(). { opInfo oi = symtable_opInfo (tab, n); if (opInfo_exists (oi)) { sigNodeSet sigs = oi->signatures; sigNodeSet_elements (sigs, sig) { if (ltokenList_size (sig->domain) == arity) return TRUE; } end_sigNodeSet_elements; } return FALSE; }

opInfo symtable_opInfo ( symtable st, nameNode n )

Definition at line 425 of file symtable.c. Referenced by makeLiteralTermNode(), makeSimpleTermNode(), symtable_opExistsWithArity(), symtable_opsWithLegalDomain(), and symtable_possibleOps(). { symHashTable *ht = st->hTable; lsymbol i = nameNode2key (n); htData *d; d = symHashTable_get (ht, i, IK_OP, n); if (d == (htData *) 0) { return (opInfo)NULL; } return (d->content.op); }

lslOpSet symtable_opsWithLegalDomain ( symtable tab, nameNode n, sortSetList argSorts, sort qual )

Definition at line 2082 of file symtable.c. Referenced by computePossibleSorts(). { /* handles nil qual */ lslOpSet ops = lslOpSet_new (); lslOp op; sort rangeSort; opInfo oi; llassert (n != NULL); oi = symtable_opInfo (tab, n); if (opInfo_exists (oi)) { sigNodeSet sigs = oi->signatures; sigNodeSet_elements (sigs, sig) { if (ltokenList_size (sig->domain) == sortSetList_size (argSorts)) { rangeSort = sigNode_rangeSort (sig); if ((qual == 0) || (sort_equal (&rangeSort, &qual))) { if (domainMatches (sig->domain, argSorts)) { op = (lslOp) dmalloc (sizeof (*op)); /* each domain sort in op must be an element of the corresponding set in argSorts. */ op->signature = sig; op->name = nameNode_copy (n); (void) lslOpSet_insert (ops, op); } } } } end_sigNodeSet_elements; } return ops; }

sigNodeSet symtable_possibleOps ( symtable tab, nameNode n )

Definition at line 2026 of file symtable.c. Referenced by computePossibleSorts(). { opInfo oi = symtable_opInfo (tab, n); if (opInfo_exists (oi)) { return (oi->signatures); } return sigNodeSet_undefined; }

void symtable_printStats ( symtable s )

Definition at line 1995 of file symtable.c. { symHashTable_printStats (s->hTable); /* for debugging only */ printf ("idTable size = %d; allocated = %d\n", s->idTable->size, s->idTable->allocated); }

tagInfo symtable_tagInfo ( symtable st, lsymbol i )

Definition at line 441 of file symtable.c. Referenced by checkAndEnterTag(), makeEnumSpecNode(), makeEnumSpecNode2(), makeForwardstrOrUnionNode(), and makestrOrUnionNode(). { symHashTable *ht = st->hTable; htData *d; d = symHashTable_get (ht, i, IK_TAG, 0); if (d == (htData *) 0) { return (tagInfo) NULL; } return (d->content.tag); }

typeInfo symtable_typeInfo ( symtable stable, lsymbol i )

Definition at line 653 of file symtable.c. Referenced by makeTypeSpecifier(). { idTable *st; idTableEntry *e; st = stable->idTable; e = symtable_lookup (st, i); if (e == (idTableEntry *) 0 || e->kind != SYMK_TYPE) { return (typeInfo) NULL; } return (e->info).type; }

varInfo symtable_varInfo ( symtable stable, lsymbol i )

Definition at line 670 of file symtable.c. Referenced by makeSimpleTermNode(), makeVarDeclarationNode(), and sort_import(). { idTable *st = stable->idTable; idTableEntry *e; e = symtable_lookup (st, i); if (e == (idTableEntry *) 0 || e->kind != SYMK_VAR) { return (varInfo) NULL; } return (e->info).var; }

varInfo symtable_varInfoInScope ( symtable stable, lsymbol id )

Definition at line 686 of file symtable.c. Referenced by makeSimpleTermNode(). { /* if current scope is a SPE_QUANT, can go beyond current scope */ idTable *st = stable->idTable; idTableEntry *e2 = (idTableEntry *) 0; int n; for (n = st->size - 1; n >= 0; n--) { ltoken tok; e2 = &(st->entries[n]); if (e2->kind == SYMK_SCOPE && e2->info.scope->kind != SPE_QUANT) { return (varInfo) NULL; } tok = idTableEntry_getId (e2); if (e2->kind == SYMK_VAR && ltoken_getText (tok) == id) { return (e2->info).var; } } return (varInfo) NULL; }

cstring tagKind_unparse ( tagKind k )

Definition at line 2004 of file symtable.c. Referenced by makeEnumSpecNode(), makeEnumSpecNode2(), makeForwardstrOrUnionNode(), and makestrOrUnionNode(). { switch (k) { case TAG_STRUCT: case TAG_FWDSTRUCT: return cstring_makeLiteral ("struct"); case TAG_UNION: case TAG_FWDUNION: return cstring_makeLiteral ("union"); case TAG_ENUM: return cstring_makeLiteral ("enum"); } BADEXIT; }

void varInfo_free ( varInfo v )

Definition at line 125 of file symtable.c. Referenced by LCLBuiltins(), enteringClaimScope(), enteringFcnScope(), makeConstDeclarationNode(), makeEnumSpecNode(), makeLetDeclNode(), makeVarDeclarationNode(), makeVarNode(), o_fctInfo(), and sort_import(). { sfree (v); }

---