---

sort.c File Reference

#include "lclintMacros.nf"
#include "llbasic.h"
#include "llgrammar.h"
#include "lclscan.h"

Go to the source code of this file.

Defines
#define	MAXBUFFLEN   1024
#define	DELTA   100
#define	NOSORTHANDLE   0
#define	HOFSORTHANDLE   1
#define	MAX_SORT_DEPTH   10
Functions
void	sort_destroyMod (void)
sort	sort_makeNoSort (void)
sort	sort_makeHOFSort (sort base)
sort	sort_makeSort ( ltoken t, lsymbol n)
sort	sort_makeSyn (ltoken t, sort s, lsymbol n)
sort	sort_makeFormal (sort insort)
sort	sort_makeGlobal (sort insort)
sort	sort_makeObj (sort sor)
sort	sort_makePtr (ltoken t, sort baseSort)
sort	sort_makePtrN (sort s, int pointers)
sort	sort_makeArr (ltoken t, sort baseSort)
sort	sort_makeVec (ltoken t, sort arraySort)
sort	sort_makeVal (sort sor)
sort	sort_makeImmutable (ltoken t, lsymbol name)
sort	sort_makeMutable (ltoken t, lsymbol name)
sort	sort_makeStr (ltoken opttagid)
bool	sort_updateStr (sort strSort, smemberInfo *info)
sort	sort_makeTuple (ltoken t, sort strSort)
sort	sort_makeUnion (ltoken opttagid)
bool	sort_updateUnion (sort unionSort, smemberInfo *info)
sort	sort_makeUnionVal (ltoken t, sort unionSort)
sort	sort_makeEnum (ltoken opttagid)
bool	sort_updateEnum (sort enumSort, smemberInfo *info)
void	sort_init (void)
sort	sort_lookupName (lsymbol name)
void	sort_printStats (void)
sortNode	sort_lookup (sort sor)
sortNode	sort_quietLookup (sort sor)
cstring	sort_unparse (sort s)
sort	sort_getUnderlying (sort s)
bool	sort_mutable (sort s)
bool	sort_setExporting (bool flag)
bool	sort_isValidSort (sort s)
void	sort_dump (FILE *f, bool lco)
void	sort_import (tsource *imported, ltoken tok, mapping * map)
bool	sort_equal (sort *s1, sort *s2)
bool	sort_compatible (sort s1, sort s2)
bool	sort_compatible_modulo_cstring (sort s1, sort s2)
lsymbol	sort_getLsymbol (sort sor)
char*	sort_getName (sort s)
cstring	sort_unparseName (sort s)
sort	sort_fromLsymbol (lsymbol sortid)
bool	sort_isHOFSortKind (sort s)
Variables
sort	sort_bool
sort	sort_capBool
sort	sort_int
sort	sort_char
sort	sort_float
sort	sort_double
sort	sort_cstring

---

Define Documentation

#define DELTA   100

Definition at line 53 of file sort.c.

#define HOFSORTHANDLE   1

Definition at line 59 of file sort.c.

#define MAXBUFFLEN   1024

Definition at line 50 of file sort.c.

#define MAX_SORT_DEPTH   10

Definition at line 2243 of file sort.c.

#define NOSORTHANDLE   0

Definition at line 56 of file sort.c.

---

Function Documentation

bool sort_compatible ( sort s1, sort s2 )

Definition at line 3017 of file sort.c. Referenced by checkLclPredicate(), and sort_compatible_modulo_cstring(). { sort syn1, syn2; /* later: might consider "char" and enum types the same as "int" */ if (s1 == s2) return TRUE; /* handle synonym sorts */ syn1 = sort_getUnderlying (s1); syn2 = sort_getUnderlying (s2); if (syn1 == syn2) return TRUE; /* makes bool and Bool equal */ return FALSE; }

bool sort_compatible_modulo_cstring ( sort s1, sort s2 )

Definition at line 3033 of file sort.c. { /* like sort_compatible but also handles special cstring inits, allows the following 2 cases: char c[] = "abc"; (LHS: char_Obj_Arr, RHS = char_Vec) (c as implicitly coerced into c^) char *d = "abc"; (LHS: char_Obj_Ptr, RHS = char_Vec) (d as implicitly coerced into d[]^) */ sort syn1, syn2; if (sort_compatible (s1, s2)) return TRUE; syn1 = sort_getUnderlying (s1); syn2 = sort_getUnderlying (s2); if (sort_cstring == syn2 && (syn1 == char_obj_ptrSort || syn1 == char_obj_ArrSort)) return TRUE; return FALSE; }

void sort_destroyMod ( void )

Definition at line 195 of file sort.c. { if (sortTable != NULL) { int i; for (i = 0; i < sortTableSize; i++) { sortNode_free (sortTable[i]); } nameNode_free (arrayRefNameNode); nameNode_free (ptr2arrayNameNode); nameNode_free (deRefNameNode); nameNode_free (nilNameNode); nameNode_free (plusNameNode); nameNode_free (minusNameNode); nameNode_free (condNameNode); nameNode_free (eqNameNode); nameNode_free (neqNameNode); sfree (sortTable); /*@-branchstate@*/ } }

void sort_dump ( FILE * f, bool lco )

Definition at line 2329 of file sort.c. Referenced by outputLCSFile(). { int i; sortNode s; smemberInfo *mem; fprintf (f, "%s\n", BEGINSORTTABLE); llassert (sortTable != NULL); for (i = 2; i < sortTableSize; i++) { /* skips 0 and 1, noSort and HOFSort */ s = sortTable[i]; /* if (lco && !s.export) continue; */ /* Difficult to keep track of where each op and sort belong to which LCL type. Easiest to export them all (even private sorts and op's) but for checking imported modules, we only use LCL types and variables to check, i.e., we don't rely on sorts and op's for such checking. */ if (s.kind == SRT_NONE) continue; if (lco) { fprintf (f, "%%LCL"); } if (lsymbol_isDefined (s.name)) { fprintf (f, "sort %s ", lsymbol_toCharsSafe (s.name)); } else { llcontbug (message ("Invalid sort in sort_dump: sort %d; sortname: %s. This may result from using .lcs files produced by an old version of LCLint. Remove the .lcs files, and rerun LCLint.", i, lsymbol_toString (s.name))); fprintf (f, "sort _error_ "); } if (!lco && !s.export) fprintf (f, "private "); /*@-loopswitchbreak@*/ switch (s.kind) { case SRT_HOF: fprintf (f, "hof nil nil\n"); break; case SRT_PRIM: if (s.abstract) fprintf (f, "immutable nil nil\n"); else fprintf (f, "primitive nil nil\n"); break; case SRT_OBJ: if (s.abstract) fprintf (f, "mutable %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); else fprintf (f, "obj %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); break; case SRT_SYN: fprintf (f, "synonym %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); break; case SRT_PTR: fprintf (f, "ptr %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); break; case SRT_ARRAY: fprintf (f, "arr %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); break; case SRT_VECTOR: fprintf (f, "vec %s %s\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name), lsymbol_toCharsSafe (sortTable[s.objSort].name)); break; case SRT_STRUCT: if (s.tag == lsymbol_undefined) { /* we need to make up a tag to prevent excessive growth of .lcs files when tags are overloaded */ llbuglit ("Struct has no tag"); } else fprintf (f, "str %s nil\n", lsymbol_toCharsSafe (s.tag)); for (mem = s.members; mem != smemberInfo_undefined; mem = mem->next) { if (lco) fprintf (f, "%%LCL"); fprintf (f, "sort %s strMem %s nil\n", lsymbol_toCharsSafe (mem->name), lsymbol_toCharsSafe (sortTable[mem->sort].name)); } if (lco) fprintf (f, "%%LCL"); fprintf (f, "sort strEnd nil nil nil\n"); break; case SRT_UNION: if (s.tag == lsymbol_undefined) llbuglit ("Union has no tag"); else fprintf (f, "union %s nil\n", lsymbol_toCharsSafe (s.tag)); for (mem = s.members; mem != smemberInfo_undefined; mem = mem->next) { if (lco) fprintf (f, "%%LCL"); fprintf (f, "sort %s unionMem %s nil\n", lsymbol_toCharsSafe (mem->name), lsymbol_toCharsSafe (sortTable[mem->sort].name)); } if (lco) fprintf (f, "%%LCL"); fprintf (f, "sort unionEnd nil nil nil\n"); break; case SRT_ENUM: if (s.tag == lsymbol_undefined) { llbuglit ("Enum has no tag"); } fprintf (f, "enum %s nil\n", lsymbol_toCharsSafe (s.tag)); for (mem = s.members; mem != smemberInfo_undefined; mem = mem->next) { if (lco) fprintf (f, "%%LCL"); fprintf (f, "sort %s enumMem nil nil\n", lsymbol_toCharsSafe (mem->name)); } if (lco) fprintf (f, "%%LCL"); fprintf (f, "sort enumEnd nil nil nil\n"); break; case SRT_TUPLE: fprintf (f, "tup %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); break; case SRT_UNIONVAL: fprintf (f, "unionval %s nil\n", lsymbol_toCharsSafe (sortTable[s.baseSort].name)); break; default: fprintf (f, "sort_dump: unexpected sort: %d", (int)s.kind); } /* switch */ /*@=loopswitchbreak@*/ } fprintf (f, "%s\n", SORTTABLEEND); }

bool sort_equal ( sort * s1, sort * s2 )

Definition at line 2999 of file sort.c. Referenced by sortSet_member(), and symtable_opsWithLegalDomain(). { sort syn1, syn2; if ((s1 != 0) && (s2 != 0)) { if ((*s1) == (*s2)) return TRUE; /* handle synonym sorts */ syn1 = sort_getUnderlying (*s1); syn2 = sort_getUnderlying (*s2); if (syn1 == syn2) return TRUE; /* makes bool and Bool equal */ } return FALSE; }

sort sort_fromLsymbol ( lsymbol sortid )

Definition at line 3120 of file sort.c. Referenced by processTraitSortId(), and sigNode_rangeSort(). { /* like sort_lookupName but creates sort if not already present */ sort sort = sort_lookupName (sortid); if (sort == NOSORTHANDLE) sort = sort_makeSort (ltoken_undefined, sortid); return sort; }

lsymbol sort_getLsymbol ( sort sor )

Definition at line 3054 of file sort.c. Referenced by checkAndEnterTag(), and symtable_enterType(). { /* sortNode sn = sort_lookup (sor); */ sortNode sn = sort_quietLookup (sor); return sn.name; }

char * sort_getName ( sort s )

Definition at line 3063 of file sort.c. { return (lsymbol_toCharsSafe (sort_getLsymbol (s))); }

sort sort_getUnderlying ( sort s )

Definition at line 2265 of file sort.c. Referenced by makeTypeSpecifier(), sort_compatible(), sort_compatible_modulo_cstring(), sort_equal(), sort_makeFormal(), sort_makeGlobal(), and sort_makeObj(). { return sort_getUnderlyingAux (s, 0); }

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

Definition at line 2867 of file sort.c. Referenced by processImport(). { /* tok is only used for error message line number */ char *buf, *importfile; tsource *lclsource; sort bsort; lsymbolList slist = lsymbolList_new (); buf = tsource_nextLine (imported); llassert (buf != NULL); importfile = tsource_fileName (imported); if (!firstWord (buf, "%LCLSortTable")) { lclsource = LCLScanSource (); lclfatalerror (tok, message ("Expecting \"%%LCLSortTable\" line " "in import file %s:\n%s", cstring_fromChars (importfile), cstring_fromChars (buf))); } for (;;) { buf = tsource_nextLine (imported); llassert (buf != NULL); if (firstWord (buf, "%LCLSortTableEnd")) { break; } else { /* a good line, remove %LCL from line first */ if (firstWord (buf, "%LCL")) { parseSortLine (buf + 4, tok, imported, map, slist); } else { lclsource = LCLScanSource (); lclfatalerror (tok, message ("Expecting '%%LCL' prefix in import file %s:\n%s\n", cstring_fromChars (importfile), cstring_fromChars (buf))); } } } /* now process the smemberInfo in the sort List */ lsymbolList_elements (slist, s) { if (s != lsymbol_undefined) { sort sor; sortNode sn; sor = sort_lookupName (s); sn = sort_quietLookup (sor); switch (sn.kind) { case SRT_ENUM: { /* update the symbol table with members of enum */ varInfo vi; smemberInfo *mlist = sn.members; for (; mlist != NULL; mlist = mlist->next) { /* check that enumeration constants are unique */ vi = symtable_varInfo (g_symtab, mlist->name); if (!varInfo_exists (vi)) { /* put info into symbol table */ vi = (varInfo) dmalloc (sizeof (*vi)); vi->id = ltoken_create (NOTTOKEN, mlist->name); vi->kind = VRK_ENUM; vi->sort = sor; vi->export = TRUE; (void) symtable_enterVar (g_symtab, vi); varInfo_free (vi); } else { lclplainerror (message ("%s: enum member %s of %s has already been declared", cstring_fromChars (importfile), lsymbol_toString (mlist->name), lsymbol_toString (sn.name))); } } /*@switchbreak@*/ break; } case SRT_STRUCT: case SRT_UNION: { smemberInfo *mlist = sn.members; for (; mlist != NULL; mlist = mlist->next) { bsort = sort_lookupName (lsymbol_translateSort (map, mlist->sortname)); if (sort_isNoSort (bsort)) { lclbug (message ("%s: member %s of %s has unknown sort\n", cstring_fromChars (importfile), cstring_fromChars (lsymbol_toChars (mlist->name)), cstring_fromChars (lsymbol_toChars (sn.name)))); } else { mlist->sort = bsort; } } /*@switchbreak@*/ break; } default: lclbug (message ("%s: %s has unexpected sort kind %s", cstring_fromChars (importfile), cstring_fromChars (lsymbol_toChars (sn.name)), sort_unparseKind (sn.kind))); } } } end_lsymbolList_elements; /* list and sorts in it are not used anymore */ lsymbolList_free (slist); }

void sort_init ( void )

Definition at line 1786 of file sort.c. { /* on alpha, declaration does not allocate storage */ opFormNode opform; opFormUnion u; underscoreSymbol = lsymbol_fromChars ("_"); /* ** commonly used data for generating operators */ lsymbol_setbool (lsymbol_fromChars ("bool")); intToken = ltoken_createType (simpleId, SID_SORT, lsymbol_fromChars ("int")); /* ** __ \eq __: sort, sort -> bool */ u.anyop = ltoken_copy (ltoken_eq); opform = makeOpFormNode (ltoken_undefined, OPF_MANYOPM, u, ltoken_undefined); eqNameNode = makeNameNodeForm (opform); /* ** __ \neq __: sort, sort -> bool */ u.anyop = ltoken_copy (ltoken_neq); opform = makeOpFormNode (ltoken_undefined, OPF_MANYOPM, u, ltoken_undefined); neqNameNode = makeNameNodeForm (opform); /* **if __ then __ else __: bool, sort, sort -> sort */ opform = makeOpFormNode (ltoken_undefined, OPF_IF, opFormUnion_createMiddle (0), ltoken_undefined); condNameNode = makeNameNodeForm (opform); /* operator: __[__]: arraySort, int -> elementSort_Obj */ u.middle = 1; opform = makeOpFormNode (ltoken_copy (ltoken_lbracked), OPF_BMMIDDLE, u, ltoken_copy (ltoken_rbracket)); arrayRefNameNode = makeNameNodeForm (opform); /* operator: __[]: ptrSort -> arraySort */ u.middle = 0; opform = makeOpFormNode (ltoken_copy (ltoken_lbracked), OPF_BMMIDDLE, u, ltoken_copy (ltoken_rbracket)); ptr2arrayNameNode = makeNameNodeForm (opform); /* operator: *__ */ u.anyop = ltoken_create (LLT_MULOP, lsymbol_fromChars ("*")); opform = makeOpFormNode (ltoken_undefined, OPF_ANYOPM, u, ltoken_undefined); deRefNameNode = makeNameNodeForm (opform); /* operator: __ + __ */ u.anyop = ltoken_create (simpleOp, lsymbol_fromChars ("+")); opform = makeOpFormNode (ltoken_undefined, OPF_MANYOPM, u, ltoken_undefined); plusNameNode = makeNameNodeForm (opform); /* operator: __ - __ */ u.anyop = ltoken_create (simpleOp, lsymbol_fromChars ("-")); opform = makeOpFormNode (ltoken_undefined, OPF_MANYOPM, u, ltoken_undefined); minusNameNode = makeNameNodeForm (opform); /* operator: NIL */ nilNameNode = (nameNode) dmalloc (sizeof (*nilNameNode)); nilNameNode->isOpId = TRUE; nilNameNode->content.opid = ltoken_createType (simpleId, SID_OP, lsymbol_fromChars ("NIL")); noSort.kind = SRT_NONE; noSort.name = lsymbol_fromChars ("_unknown");; noSort.tag = lsymbol_undefined; noSort.baseSort = NOSORTHANDLE; noSort.objSort = NOSORTHANDLE; noSort.members = smemberInfo_undefined; noSort.export = FALSE; noSort.mutable = FALSE; noSort.abstract = FALSE; noSort.imported = FALSE; noSort.handle = NOSORTHANDLE; /* ** Store the null sort into table, and in the process initialize the sort table. ** Must be the first sort_enter so NOSORTHANDLE is truly = 0. Similarly, ** for HOFSORTHANDLE = 1. */ noSort.handle = sort_enterGlobal (noSort); (void) sort_enterGlobal (HOFSort); /* Other builtin sorts */ sort_bool = sort_makeImmutable (ltoken_undefined, lsymbol_fromChars ("bool")); sort_capBool = sort_makeSortNoOps (ltoken_undefined, lsymbol_fromChars ("Bool")); llassert (sortTable != NULL); /* make sort_Bool a synonym for sort_bool */ sortTable[sort_capBool].kind = SRT_SYN; sortTable[sort_capBool].baseSort = sort_bool; sortTable[sort_capBool].mutable = FALSE; sortTable[sort_capBool].abstract = TRUE; sort_int = sort_makeLiteralSort (ltoken_undefined, lsymbol_fromChars ("int")); sort_char = sort_makeLiteralSort (ltoken_undefined, lsymbol_fromChars ("char")); sort_void = sort_makeLiteralSort (ltoken_undefined, lsymbol_fromChars ("void")); /* sort_cstring is char__Vec, for C strings eg: "xyz" */ char_obj_ptrSort = sort_makePtr (ltoken_undefined, sort_char); char_obj_ArrSort = sort_makeArr (ltoken_undefined, sort_char); sort_cstring = sort_makeVal (char_obj_ArrSort); sort_float = sort_makeLiteralSort (ltoken_undefined, lsymbol_fromChars ("float")); sort_double = sort_makeLiteralSort (ltoken_undefined, lsymbol_fromChars ("double")); }

bool sort_isHOFSortKind ( sort s )

Definition at line 3130 of file sort.c. { sortNode sn = sort_quietLookup (s); if (sn.kind == SRT_HOF) return TRUE; return FALSE; }

bool sort_isValidSort ( sort s )

Definition at line 2318 of file sort.c. Referenced by makeModifyNodeRef(). { sortNode sn = sort_quietLookup (s); sortKind k = sn.kind; if (k != SRT_NONE && k > SRT_FIRST && k < SRT_LAST) return TRUE; else return FALSE; }

sortNode sort_lookup ( sort sor )

Definition at line 2034 of file sort.c. Referenced by sort_makeArr(), sort_makeFormal(), sort_makeGlobal(), sort_makePtr(), sort_makeTuple(), sort_makeUnionVal(), sort_makeVec(), sort_updateEnum(), sort_updateStr(), and sort_updateUnion(). { /* ymtan: can sor be 0 ? */ /* evs --- yup...0 should return noSort ? */ if (sor > 0U && sor < (unsigned) sortTableSize) { llassert (sortTable != NULL); return sortTable[sor]; } llassert (sor == 0); return noSort; }

sort sort_lookupName ( lsymbol name )

Definition at line 1920 of file sort.c. Referenced by o_fctInfo(), sort_fromLsymbol(), sort_import(), sort_makeArr(), sort_makeEnum(), sort_makeImmutable(), sort_makeMutable(), sort_makeObj(), sort_makePtr(), sort_makeSort(), sort_makeStr(), sort_makeSyn(), sort_makeTuple(), sort_makeUnion(), sort_makeUnionVal(), and sort_makeVec(). { long int i; if (name == lsymbol_undefined) { return NOSORTHANDLE; } llassert (sortTable != NULL); for (i = 0; i < sortTableSize; i++) { if (sortTable[i].name == name) { return i; } } return NOSORTHANDLE; }

sort sort_makeArr ( ltoken t, sort baseSort )

Definition at line 707 of file sort.c. Referenced by sort_init(), and sort_makePtr(). { sortNode s, outSort, old; sort handle, vecHandle; int dim; lsymbol name; s = sort_lookup (baseSort); if (s.kind == SRT_HOF) return baseSort; if (s.kind == SRT_NONE) return baseSort; if (s.kind != SRT_ARRAY && s.kind != SRT_STRUCT && s.kind != SRT_UNION && s.kind != SRT_OBJ) /* base is not an array, struct or obj. Need to insert a Obj. */ baseSort = sort_makeObj (baseSort); name = sp (sp (underscoreSymbol, sort_getLsymbol (baseSort)), lsymbol_fromChars ("_Arr")); handle = sort_lookupName (name); /* must not clash with any LSL sorts */ outSort.name = name; outSort.kind = SRT_ARRAY; outSort.baseSort = baseSort; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.mutable = TRUE; outSort.export = exporting; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); for (old = outSort, dim = 0; old.kind == SRT_ARRAY; dim++, old = sort_lookup (old.baseSort)) { ; } vecHandle = sort_makeVec (t, handle); genArrOps (baseSort, handle, dim, vecHandle); } else { outSort.handle = handle = sort_enterNew (outSort); } } else { llassert (sortTable != NULL); if (sortTable[handle].kind != SRT_ARRAY) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeEnum ( ltoken opttagid )

Definition at line 1467 of file sort.c. Referenced by checkAndEnterTag(), and makeEnumSpecNode(). { sortNode outSort; sort handle; bool isNew; lsymbol name; llassert (sortTable != NULL); if (ltoken_isUndefined (opttagid)) { opttagid = ltoken_create (simpleId, newEnumTag ()); outSort.realtag = FALSE; } else outSort.realtag = TRUE; /* must not clash with any LSL sorts, tag2sortname adds "_" prefix */ name = sortTag_toSymbol ("Enum", opttagid, &isNew); handle = sort_lookupName (name); outSort.name = name; outSort.kind = SRT_ENUM; outSort.tag = ltoken_getText (opttagid); outSort.baseSort = NOSORTHANDLE; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.mutable = FALSE; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); } else { outSort.handle = handle = sort_enterNewForce (outSort); } } else { if (sortTable[handle].kind != SRT_ENUM) { sortError (opttagid, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeFormal ( sort insort )

Definition at line 489 of file sort.c. Referenced by enteringClaimScope(), and enteringFcnScope(). { sortNode s; sort sor, handle; sor = sort_getUnderlying (insort); handle = sor; s = sort_lookup (sor); switch (s.kind) { case SRT_STRUCT: handle = sort_makeTuple (ltoken_undefined, sor); break; case SRT_UNION: handle = sort_makeUnionVal (ltoken_undefined, sor); break; default: break; } return handle; }

sort sort_makeGlobal ( sort insort )

Definition at line 514 of file sort.c. Referenced by makeVarDeclarationNode(), and makestrOrUnionNode(). { /* Make a Obj if not an array or a struct */ sortNode s; sort sor, handle; sor = sort_getUnderlying (insort); handle = sor; s = sort_lookup (sor); switch (s.kind) { case SRT_ARRAY: case SRT_STRUCT: case SRT_UNION: case SRT_HOF: case SRT_NONE: break; case SRT_VECTOR: case SRT_TUPLE: case SRT_UNIONVAL: llcontbuglit ("sort_makeGlobal: can't make vectors, tuples, or unionvals global"); break; default: handle = sort_makeObj (sor); break; } return handle; }

sort sort_makeHOFSort ( sort base )

Definition at line 233 of file sort.c. Referenced by typeExpr2ptrSort(). { sortNode outSort; sort handle; outSort.kind = SRT_HOF; outSort.name = cstring_toSymbol (message ("_HOF_sort_%d", sortTableSize)); outSort.tag = lsymbol_undefined; outSort.baseSort = base; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.imported = context_inImport (); outSort.mutable = FALSE; outSort.abstract = FALSE; llassert (sortTable != NULL); outSort.handle = handle = sortTableSize; sortTable[handle] = outSort; sortTableSize++; return handle; }

sort sort_makeImmutable ( ltoken t, lsymbol name )

Definition at line 910 of file sort.c. Referenced by makeAbstractNode(), sort_init(), and sort_makeMutable(). { sortNode outSort; sort handle; handle = sort_lookupName (name); outSort.kind = SRT_PRIM; outSort.name = name; outSort.baseSort = NOSORTHANDLE; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.mutable = FALSE; outSort.imported = context_inImport (); outSort.abstract = TRUE; outSort.handle = handle; if (handle == NOSORTHANDLE) { outSort.handle = handle = sort_enterNew (outSort); overloadSizeof (handle); } else { /* complain */ llassert (sortTable != NULL); if ((sortTable[handle].kind != SRT_PRIM) && (sortTable[handle].abstract) && (!sortTable[handle].mutable)) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeMutable ( ltoken t, lsymbol name )

Definition at line 951 of file sort.c. Referenced by makeAbstractNode(). { sort immutable_old, handle, baseSort; lsymbol objName; immutable_old = sort_lookupName (name); /* First generate the value sort */ baseSort = sort_makeImmutable (t, name); llassert (sortTable != NULL); /* to prevent duplicate error messages */ if (immutable_old != NOSORTHANDLE && (sortTable[baseSort].kind != SRT_PRIM) && (sortTable[baseSort].abstract) && (!sortTable[baseSort].mutable)) { /* already complained */ handle = NOSORTHANDLE; } else { /* sort_makeImmutable must have succeeded */ sortNode outSort; /* must not clash with any LSL sorts */ objName = sp (sp (underscoreSymbol, name), lsymbol_fromChars ("_Obj")); handle = sort_lookupName (objName); outSort.kind = SRT_OBJ; outSort.name = objName; outSort.tag = lsymbol_undefined; outSort.baseSort = baseSort; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.mutable = TRUE; outSort.export = exporting; outSort.imported = context_inImport (); outSort.abstract = TRUE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); } else { handle = sort_enterNew (outSort); } } else { llassert (sortTable != NULL); if ((sortTable[handle].kind != SRT_OBJ) && sortTable[handle].abstract && sortTable[handle].mutable) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } } return handle; }

sort sort_makeNoSort ( void )

Definition at line 227 of file sort.c. Referenced by checkAndEnterTag(), lclTypeSpecNode2sort(), makeArrayNode(), makeCTypesNode(), makeEnumSpecNode2(), makeForwardstrOrUnionNode(), makeFunctionNode(), makeIfTermNode(), makeInfixTermNode(), makeLetDeclNode(), makeLiteralTermNode(), makeMapTermNode(), makeMatchedNode(), makeOpCallTermNode(), makePointerNode(), makePostfixTermNode2(), makePrefixTermNode(), makeSelectTermNode(), makeSimpleTermNode(), makeSizeofTermNode(), makeSqBracketedNode(), makeTypeExpr(), makeTypeSpecifier(), makeUnchangedTermNode1(), makeUnchangedTermNode2(), makeVarNode(), o_fctInfo(), pushInfixOpPartNode(), and sigNode_rangeSort(). { return NOSORTHANDLE; }

sort sort_makeObj ( sort sor )

Definition at line 544 of file sort.c. Referenced by makeModifyNodeRef(), makeVarNode(), sort_makeArr(), sort_makeGlobal(), and sort_makePtr(). { sortNode baseSortNode, outSort; sort baseSort, handle; lsymbol name; /* skip the synonym sort */ baseSort = sort_getUnderlying (sor); baseSortNode = sort_quietLookup (baseSort); switch (baseSortNode.kind) { case SRT_HOF: case SRT_NONE: return baseSort; case SRT_VECTOR: if (baseSortNode.objSort != 0) return baseSortNode.objSort; else /* must have well-defined objSort field */ { llcontbuglit ("sort_makeObj: Inconsistent vector reps:invalid objSort field"); return baseSort; } case SRT_TUPLE: case SRT_UNIONVAL: /* need to map *_Struct_Tuple to *_Struct and *_Union_UnionVal to *_Union, according to sort naming conventions */ if (baseSortNode.baseSort != NOSORTHANDLE) /* for tuples and unionvals, baseSort field keeps the map from value sort to obj sort. */ return baseSortNode.baseSort; else /* valid tuples and unionvals must have baseSort fields */ { llcontbuglit ("sort_makeObj: Inconsistent tuples or unionvals reps: invalid baseSort field"); return baseSort; } default: name = sp (sp (underscoreSymbol, sort_getLsymbol (baseSort)), lsymbol_fromChars ("_Obj")); handle = sort_lookupName (name); outSort.kind = SRT_OBJ; /* must not clash with any LSL sorts */ outSort.name = name; outSort.tag = lsymbol_undefined; outSort.baseSort = baseSort; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.mutable = TRUE; outSort.export = exporting; outSort.abstract = FALSE; outSort.handle = handle; outSort.imported = TRUE; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); } else { outSort.handle = handle = sort_enterNew (outSort); } } else { llassert (sortTable != NULL); if (sortTable[handle].kind != SRT_OBJ) { sortError (ltoken_undefined, handle, outSort); } smemberInfo_free (outSort.members); } return handle; } }

sort sort_makePtr ( ltoken t, sort baseSort )

Definition at line 625 of file sort.c. Referenced by sort_init(). { sortNode s, outSort; sort handle, arrayHandle; lsymbol name; s = sort_lookup (baseSort); if (s.kind == SRT_HOF) { return baseSort; } if (s.kind == SRT_NONE) { return baseSort; } if (s.kind != SRT_ARRAY && s.kind != SRT_STRUCT && s.kind != SRT_UNION) /* && s.kind != SRT_OBJ) */ /* base is not an SRT_ARRAY, struct or union. Need to insert a obj. */ baseSort = sort_makeObj (baseSort); name = sp (sp (underscoreSymbol, sort_getLsymbol (baseSort)), lsymbol_fromChars ("_Ptr")); handle = sort_lookupName (name); outSort.kind = SRT_PTR; outSort.name = name; outSort.tag = lsymbol_undefined; outSort.baseSort = baseSort; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.mutable = FALSE; outSort.export = exporting; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); arrayHandle = sort_makeArr (t, baseSort); genPtrOps (baseSort, handle, arrayHandle); } else { outSort.handle = handle = sort_enterNew (outSort); } } else { llassert (sortTable != NULL); if (sortTable[handle].kind != SRT_PTR) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makePtrN ( sort s, int pointers )

Definition at line 691 of file sort.c. Referenced by lclTypeSpecNode2sort(). { llassert (pointers >= 0); if (pointers == 0) { return s; } else { return sort_makePtrN (sort_makePtr (ltoken_undefined, s), pointers - 1); } }

sort sort_makeSort ( ltoken t, lsymbol n )

Definition at line 356 of file sort.c. Referenced by sort_fromLsymbol(). { /* ** Expects n to be a new sort. ** Generate a sort with the given name. Useful for LSL sorts. */ sort handle = sort_lookupName (n); if (handle == NOSORTHANDLE) { sortNode outSort; outSort.handle = handle; outSort.kind = SRT_PRIM; outSort.name = n; outSort.tag = lsymbol_undefined; outSort.baseSort = NOSORTHANDLE; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.mutable = FALSE; outSort.imported = context_inImport (); outSort.abstract = FALSE; /* Put into sort table, sort_enter checks for duplicates. */ outSort.handle = handle = sort_enterNew (outSort); } else { /* don't override old info */ ; } return handle; }

sort sort_makeStr ( ltoken opttagid )

Definition at line 1022 of file sort.c. Referenced by checkAndEnterTag(), makeForwardstrOrUnionNode(), and makestrOrUnionNode(). { sortNode outSort; sort handle; bool isNewTag; lsymbol name; /* must not clash with any LSL sorts, tag2sortname adds "_" prefix */ /* isNewTag true means that the name generated is new */ if (ltoken_isUndefined (opttagid)) { opttagid = ltoken_create (simpleId, newStructTag ()); outSort.realtag = FALSE; } else { outSort.realtag = TRUE; } name = sortTag_toSymbol ("Struct", opttagid, &isNewTag); llassert (sortTable != NULL); handle = sort_lookupName (name); outSort.name = name; outSort.kind = SRT_STRUCT; outSort.tag = ltoken_getText (opttagid); outSort.baseSort = NOSORTHANDLE; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.mutable = TRUE; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); } else { outSort.handle = handle = sort_enterNewForce (outSort); } } else { if (sortTable[handle].kind != SRT_STRUCT) { sortError (opttagid, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeSyn ( ltoken t, sort s, lsymbol n )

Definition at line 439 of file sort.c. Referenced by declareForwardType(). { /* make a synonym sort with name n that is == to sort s */ /* expect n to be a new sort name */ sortNode outSort; sort handle; /* must not clash with any LSL sorts */ lsymbol newname = sp (underscoreSymbol, n); if (n == lsymbol_undefined) { llbuglit ("sort_makeSyn: synonym must have name"); } handle = sort_lookupName (newname); outSort.kind = SRT_SYN; outSort.name = newname; outSort.baseSort = s; outSort.objSort = NOSORTHANDLE; /* info is not duplicated */ outSort.tag = lsymbol_undefined; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.mutable = FALSE; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { outSort.handle = handle = sort_enterNew (outSort); /* No operators to generate for synonyms */ } else { llassert (sortTable != NULL); if (sortTable[handle].kind != SRT_SYN) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeTuple ( ltoken t, sort strSort )

Definition at line 1109 of file sort.c. Referenced by sort_makeFormal(), sort_makeVal(), and sort_updateStr(). { sort handle; sortNode outSort, s = sort_lookup (strSort); lsymbol name; if (s.kind != SRT_STRUCT) { llfatalbug (message ("sort_makeTuple: Only structs can become tuples: given sort is %s", sort_unparseKind (s.kind))); } name = sp (s.name, lsymbol_fromChars ("_Tuple")); llassert (sortTable != NULL); handle = sort_lookupName (name); outSort.kind = SRT_TUPLE; outSort.name = name; outSort.tag = s.tag; outSort.realtag = s.realtag; outSort.baseSort = strSort; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.abstract = FALSE; outSort.imported = context_inImport (); outSort.mutable = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); sort_addTupleMembers (handle, strSort); genTupleOps (handle); } else { outSort.handle = handle = sort_enterNew (outSort); } } else { if (sortTable[handle].kind != SRT_TUPLE) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeUnion ( ltoken opttagid )

Definition at line 1297 of file sort.c. Referenced by checkAndEnterTag(), makeForwardstrOrUnionNode(), and makestrOrUnionNode(). { sortNode outSort; sort handle; bool isNewTag; lsymbol name; /* must not clash with any LSL sorts, tag2sortname adds "_" prefix */ /* isNewTag true means that the name generated is new */ if (ltoken_isUndefined (opttagid)) { opttagid = ltoken_create (simpleId, newUnionTag ()); outSort.realtag = FALSE; } else outSort.realtag = TRUE; llassert (sortTable != NULL); name = sortTag_toSymbol ("Union", opttagid, &isNewTag); handle = sort_lookupName (name); outSort.name = name; outSort.kind = SRT_UNION; outSort.tag = ltoken_getText (opttagid); outSort.baseSort = NOSORTHANDLE; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.mutable = TRUE; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); } else { outSort.handle = handle = sort_enterNewForce (outSort); } } else { if (sortTable[handle].kind != SRT_UNION) { sortError (opttagid, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeUnionVal ( ltoken t, sort unionSort )

Definition at line 1382 of file sort.c. Referenced by sort_makeFormal(), sort_makeVal(), and sort_updateUnion(). { sort handle; sortNode outSort, s = sort_lookup (unionSort); lsymbol name; if (s.kind != SRT_UNION) { llfatalbug (message ("sort_makeUnion: only unions can become unionVals: given sort is: %s", sort_unparseKind (s.kind))); } llassert (sortTable != NULL); name = sp (s.name, lsymbol_fromChars ("_UnionVal")); handle = sort_lookupName (name); outSort.kind = SRT_UNIONVAL; outSort.name = name; outSort.tag = s.tag; outSort.realtag = s.realtag; outSort.baseSort = unionSort; outSort.objSort = NOSORTHANDLE; outSort.members = smemberInfo_undefined; outSort.export = exporting; outSort.abstract = FALSE; outSort.imported = context_inImport (); outSort.mutable = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); /* Add members to the unionVal's. */ /* same as structs and tuples */ sort_addTupleMembers (handle, unionSort); genUnionOps (handle); } else { outSort.handle = handle = sort_enterNew (outSort); } } else { if (sortTable[handle].kind != SRT_UNIONVAL) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

sort sort_makeVal ( sort sor )

Definition at line 858 of file sort.c. Referenced by makeVarNode(), sort_init(), and sort_makeVec(). { sort retSort = sor; sortNode rsn, s; llassert (sortTable != NULL); s = sort_quietLookup (sor); switch (s.kind) { case SRT_PRIM: case SRT_ENUM: case SRT_PTR: case SRT_TUPLE: case SRT_UNIONVAL: case SRT_VECTOR: case SRT_HOF: case SRT_NONE: /* Do nothing for basic types and pointers. */ retSort = sor; break; case SRT_SYN: return sort_makeVal (sortTable[sor].baseSort); case SRT_OBJ: /* Strip out the last Obj's */ if (s.baseSort == NOSORTHANDLE) { llbuglit ("sort_makeVal: expecting a base sort for Obj"); } retSort = s.baseSort; break; case SRT_ARRAY: retSort = sort_makeVec (ltoken_undefined, sor); break; case SRT_STRUCT: retSort = sort_makeTuple (ltoken_undefined, sor); break; case SRT_UNION: retSort = sort_makeUnionVal (ltoken_undefined, sor); break; default: llbuglit ("sort_makeVal: invalid sort kind"); } rsn = sort_quietLookup (retSort); if (rsn.kind == SRT_NONE) { llfatalbug (message ("sort_makeVal: invalid return sort kind: %d", (int)rsn.kind)); } return retSort; }

sort sort_makeVec ( ltoken t, sort arraySort )

Definition at line 779 of file sort.c. Referenced by sort_makeArr(), and sort_makeVal(). { sortNode s, outSort, old; sort baseSort, handle, elementSort; int dim; /* array dimension count. */ lsymbol name; s = sort_lookup (arraySort); if (s.kind == SRT_HOF) return arraySort; if (s.kind == SRT_NONE) return arraySort; if (s.kind != SRT_ARRAY) { llbug (message ("sort_makeVec: only arrays can become vectors: given sort is %s", sort_unparseKind (s.kind))); } if (s.baseSort == NOSORTHANDLE) llbuglit ("sort_makeVec: arrays must have base (element) sort"); /* Vectors return "values", so make array elements values. */ baseSort = s.baseSort; elementSort = sort_makeVal (baseSort); name = sp (sp (underscoreSymbol, sort_getLsymbol (elementSort)), lsymbol_fromChars ("_Vec")); handle = sort_lookupName (name); outSort.baseSort = elementSort; outSort.name = name; outSort.objSort = arraySort; outSort.kind = SRT_VECTOR; outSort.members = smemberInfo_undefined; outSort.mutable = FALSE; outSort.export = exporting; outSort.imported = context_inImport (); outSort.abstract = FALSE; outSort.handle = handle; if (handle == NOSORTHANDLE) { if (sort_isNewEntry (outSort)) { outSort.handle = handle = sort_enterNew (outSort); for (old = outSort, dim = 0; old.kind == SRT_VECTOR; dim++, old = sort_lookup (old.baseSort)) { ; } genVecOps (elementSort, handle, dim); } else { outSort.handle = handle = sort_enterNew (outSort); } } else { llassert (sortTable != NULL); if (sortTable[handle].kind != SRT_VECTOR) { sortError (t, handle, outSort); } smemberInfo_free (outSort.members); } return handle; }

bool sort_mutable ( sort s )

Definition at line 2290 of file sort.c. Referenced by makeModifyNodeRef(), and makeUnchangedTermNode2(). { /* if s is not a valid sort, then returns false */ sortNode sn = sort_quietLookup (s); if (sn.mutable) return TRUE; return FALSE; }

void sort_printStats ( void )

Definition at line 2026 of file sort.c. { /* only for debugging */ printf ("sortTableSize = %d; sortTableAlloc = %d\n", sortTableSize, sortTableAlloc); }

sortNode sort_quietLookup ( sort sor )

Definition at line 2050 of file sort.c. Referenced by MAX_SORT_DEPTH(), sort_getLsymbol(), sort_import(), sort_isHOFSortKind(), sort_isValidSort(), sort_makeObj(), sort_makeVal(), sort_mutable(), and sort_unparse(). { /* ymtan: can sor be 0 ? */ if (sor > 0U && sor < (unsigned) sortTableSize) { llassert (sortTable != NULL); return (sortTable[sor]); } else { return noSort; } }

bool sort_setExporting ( bool flag )

Definition at line 2300 of file sort.c. Referenced by processImport(), and symtable_export(). { bool old; old = exporting; exporting = flag; return old; }

cstring sort_unparse ( sort s )

Definition at line 2099 of file sort.c. Referenced by makeConstDeclarationNode(), and makeVarDeclarationNode(). { /* printing routine for sorts */ sortNode sn; lsymbol name; sn = sort_quietLookup (s); name = sn.name; switch (sn.kind) { case SRT_NONE: if (name == lsymbol_undefined) { return cstring_makeLiteral ("_unknown"); } return (cstring_fromCharsNew (lsymbol_toChars (name))); case SRT_HOF: return cstring_makeLiteral ("procedural"); case SRT_PRIM: return (cstring_fromCharsNew (lsymbol_toChars (name))); case SRT_SYN: return (cstring_fromCharsNew (lsymbol_toChars (name))); case SRT_PTR: return (message ("%q *", sort_unparse (sort_makeVal (sn.baseSort)))); case SRT_OBJ: return (message ("obj %q", sort_unparse (sn.baseSort))); case SRT_ARRAY: return (message ("array of %q", sort_unparse (sort_makeVal (sn.baseSort)))); case SRT_VECTOR: return (message ("vector of %q", sort_unparse (sn.baseSort))); case SRT_TUPLE: if (sn.tag != lsymbol_undefined && sn.realtag) { return (message ("struct %s", cstring_fromChars (lsymbol_toChars (sn.tag)))); } else { return (message ("struct {%q}", printStructMembers (sn.members))); } case SRT_UNIONVAL: if (sn.tag != lsymbol_undefined && sn.realtag) { return (message ("union %s", cstring_fromChars (lsymbol_toChars (sn.tag)))); } else { return (message ("union {%q}", printStructMembers (sn.members))); } case SRT_ENUM: if (sn.tag != lsymbol_undefined && sn.realtag) { return (message ("enum %s", cstring_fromChars (lsymbol_toChars (sn.tag)))); } else { return (message ("enum {%q}", printEnumMembers (sn.members))); } case SRT_STRUCT: if (sn.tag != lsymbol_undefined && sn.realtag) { return (message ("obj struct %s", cstring_fromChars (lsymbol_toChars (sn.tag)))); } else { return (message ("obj struct {%q}", printStructMembers (sn.members))); } case SRT_UNION: if (sn.tag != lsymbol_undefined && sn.realtag) { return (message ("obj union %s", cstring_fromChars (lsymbol_toChars (sn.tag)))); } else { return (message ("obj union {%q}", printStructMembers (sn.members))); } default: return (cstring_makeLiteral ("illegal")); } }

cstring sort_unparseName ( sort s )

Definition at line 3069 of file sort.c. Referenced by signNode_unparse(). { return (cstring_fromChars (sort_getName (s))); }

bool sort_updateEnum ( sort enumSort, smemberInfo * info )

Definition at line 1525 of file sort.c. Referenced by makeEnumSpecNode(). { /* ** Expect enumSort to be in sort table but not yet filled in. ** Return TRUE if it is "new" */ sortNode sn; llassert (sortTable != NULL); sn = sort_lookup (enumSort); if (sn.members == (smemberInfo *) 0) { sortTable[enumSort].members = info; genEnumOps (enumSort); return TRUE; } else { smemberInfo_free (info); return FALSE; } }

bool sort_updateStr ( sort strSort, smemberInfo * info )

Definition at line 1084 of file sort.c. Referenced by makestrOrUnionNode(). { /* expect strSort to be in sort table but not yet filled in */ /* return TRUE if it is "new" */ sort tupleSort; sortNode sn; llassert (sortTable != NULL); sn = sort_lookup (strSort); if (sn.members == (smemberInfo *) 0) { sortTable[strSort].members = info; tupleSort = sort_makeTuple (ltoken_undefined, strSort); genStrOps (strSort, tupleSort); return TRUE; } else { smemberInfo_free (info); return FALSE; } }

bool sort_updateUnion ( sort unionSort, smemberInfo * info )

Definition at line 1355 of file sort.c. Referenced by makestrOrUnionNode(). { /* expect unionSort to be in sort table but not yet filled in */ /* return TRUE if it is "new" */ sort uValSort; sortNode sn; llassert (sortTable != NULL); sn = sort_lookup (unionSort); if (sn.members == (smemberInfo *) 0) { sortTable[unionSort].members = info; uValSort = sort_makeUnionVal (ltoken_undefined, unionSort); /* same as struct operations */ genStrOps (unionSort, uValSort); return TRUE; } else { smemberInfo_free (info); return FALSE; } }

---

Variable Documentation

sort sort_bool

Definition at line 118 of file sort.c.

sort sort_capBool

Definition at line 119 of file sort.c.

sort sort_char

Definition at line 121 of file sort.c.

sort sort_cstring

Definition at line 124 of file sort.c.

sort sort_double

Definition at line 123 of file sort.c.

sort sort_float

Definition at line 122 of file sort.c.

sort sort_int

Definition at line 120 of file sort.c.

---