---

uentry.c File Reference

#include "lclintMacros.nf"
#include "basic.h"
#include "structNames.h"
#include "nameChecks.h"

Go to the source code of this file.

Functions
cstring	uentry_specOrDefName (uentry u)
cstring	uentry_specDeclName (uentry u)
uentry	uentry_makeEnumConstant (cstring n, ctype t)
uentry	uentry_makeEnumInitializedConstant (cstring n, ctype t, exprNode expr)
uentry	uentry_makeSpecEnumConstant (cstring n, ctype t, fileloc loc)
uentry	uentry_makeVariableLoc (cstring n, ctype t)
uentry	uentry_makeUnnamedVariable (ctype t)
uentry	uentry_makeIdDatatype (idDecl id)
void	uentry_checkParams (uentry ue)
uentry	uentry_makeIdFunction (idDecl id)
void	uentry_setRefCounted (uentry e)
void	uentry_setStatic (uentry c)
void	uentry_setExtern (uentry c)
void	uentry_setParamNo (uentry ue, int pno)
uentry	uentry_makeVariableSrefParam (cstring n, ctype t, sRef s)
void	uentry_fixupSref (uentry ue)
void	uentry_setSpecialClauses (uentry ue, specialClauses clauses)
void	uentry_setModifies (uentry ue, sRefSet sr)
void	uentry_setMutable (uentry e)
void	uentry_reflectQualifiers (uentry ue, qualList q)
bool	uentry_isOnly (uentry ue)
bool	uentry_isUnique (uentry ue)
bool	uentry_isFileStatic (uentry ue)
bool	uentry_isExported (uentry ue)
bool	uentry_isNonLocal (uentry ue)
bool	uentry_isGlobal (uentry ue)
bool	uentry_isPrintfLike (uentry ue)
bool	uentry_isScanfLike (uentry ue)
bool	uentry_isMessageLike (uentry ue)
void	uentry_setPrintfLike (uentry ue)
void	uentry_setScanfLike (uentry ue)
void	uentry_setMessageLike (uentry ue)
bool	uentry_isSpecialFunction (uentry ue)
uentry	uentry_makeParam (idDecl t, int i)
uentry	uentry_makeIdVariable (idDecl t)
uentry	uentry_makeVariableParam (cstring n, ctype t)
uentry	uentry_makeConstantAux (cstring n, ctype t, fileloc f, bool priv, multiVal m)
uentry	uentry_makeConstant (cstring n, ctype t, fileloc f)
uentry	uentry_makeIdConstant (idDecl t)
void	uentry_setDefState (uentry ue, sstate defstate)
bool	uentry_isCheckedUnknown (uentry ue)
bool	uentry_isCheckMod (uentry ue)
bool	uentry_isUnchecked (uentry ue)
bool	uentry_isChecked (uentry ue)
bool	uentry_isCheckedModify (uentry ue)
bool	uentry_isCheckedStrict (uentry ue)
void	uentry_setUnchecked (uentry ue)
void	uentry_setChecked (uentry ue)
void	uentry_setCheckMod (uentry ue)
void	uentry_setCheckedStrict (uentry ue)
bool	uentry_isYield (uentry ue)
uentry	uentry_makeVariable (cstring n, ctype t, fileloc f, bool isPriv)
void	uentry_makeVarFunction (uentry ue)
void	uentry_setGlobals (uentry ue, globSet globs)
void	uentry_addAccessType (uentry ue, typeId tid)
uentry	uentry_makeFunction (cstring n, ctype t, typeId access, globSet globs, sRefSet mods, fileloc f)
uentry	uentry_makePrivFunction2 (cstring n, ctype t, typeIdSet access, globSet globs, sRefSet mods, fileloc f)
uentry	uentry_makeSpecFunction (cstring n, ctype t, typeIdSet access, globSet globs, sRefSet mods, fileloc f)
uentry	uentry_makeExpandedMacro (cstring s, fileloc f)
uentry	uentry_makeForwardFunction (cstring n, typeId access, fileloc f)
bool	uentry_isForward (uentry e)
uentry	uentry_makeTypeListFunction (cstring n, typeIdSet access, fileloc f)
uentry	uentry_makeUnspecFunction (cstring n, ctype t, typeIdSet access, fileloc f)
uentry	uentry_makeDatatypeAux (cstring n, ctype t, ynm mut, ynm abs, fileloc f, bool priv)
uentry	uentry_makeDatatype (cstring n, ctype t, ynm mut, ynm abs, fileloc f)
uentry	uentry_makeBoolDatatype (ynm abs)
uentry	uentry_makeIter (cstring n, ctype ct, fileloc f)
uentry	uentry_makeEndIter (cstring n, fileloc f)
uentry	uentry_makeStructTagLoc (cstring n, ctype t)
uentry	uentry_makeStructTag (cstring n, ctype t, fileloc loc)
uentry	uentry_makeUnionTag (cstring n, ctype t, fileloc loc)
uentry	uentry_makeEnumTag (cstring n, ctype t, fileloc loc)
uentry	uentry_makeUnionTagLoc (cstring n, ctype t)
uentry	uentry_makeEnumTagLoc (cstring n, ctype t)
bool	uentry_isStructTag (uentry ue)
bool	uentry_isUnionTag (uentry ue)
bool	uentry_isEnumTag (uentry ue)
bool	uentry_isAnyTag (uentry ue)
void	uentry_destroyMod (void)
uentry	uentry_makeElipsisMarker (void)
bool	uentry_equiv (uentry p1, uentry p2)
int	uentry_xcomparealpha (uentry *p1, uentry *p2)
int	uentry_xcompareuses (uentry *p1, uentry *p2)
int	uentry_compareStrict (uentry v1, uentry v2)
int	uentry_compare (uentry u1, uentry u2)
bool	uentry_hasGlobs (uentry ue)
bool	uentry_hasSpecialClauses (uentry ue)
specialClauses	uentry_getSpecialClauses (uentry ue)
bool	uentry_hasMods (uentry ue)
void	uentry_markFree ( uentry u)
uentry	uentry_undump (ekind kind, fileloc loc, char **s)
cstring	uentry_dump (uentry v)
cstring	uentry_dumpParam (uentry v)
cstring	uentry_unparseAbbrev (uentry v)
cstring	uentry_unparse (uentry v)
cstring	uentry_unparseFull (uentry v)
bool	uentry_hasAccessType (uentry e)
typeIdSet	uentry_accessType (uentry e)
bool	uentry_isVariable (uentry e)
bool	uentry_isSpecified (uentry e)
bool	uentry_isVar (uentry e)
bool	uentry_isFakeTag (uentry e)
bool	uentry_isDatatype (uentry e)
void	uentry_setAbstract (uentry e)
void	uentry_setConcrete (uentry e)
bool	uentry_isAbstractDatatype (uentry e)
bool	uentry_isMaybeAbstract (uentry e)
bool	uentry_isMutableDatatype (uentry e)
bool	uentry_isRefCountedDatatype (uentry e)
bool	uentry_isParam (uentry u)
bool	uentry_isExpandedMacro (uentry u)
bool	uentry_isSefParam (uentry u)
bool	uentry_isRefParam (uentry u)
bool	uentry_isAnyParam (uentry u)
sstate	uentry_getDefState (uentry u)
bool	uentry_isOut (uentry u)
bool	uentry_isPartial (uentry u)
bool	uentry_isStateSpecial (uentry u)
exitkind	uentry_getExitCode (uentry ue)
qual	uentry_nullPred (uentry u)
bool	uentry_possiblyNull (uentry u)
alkind	uentry_getAliasKind (uentry u)
exkind	uentry_getExpKind (uentry u)
bool	uentry_isIter (uentry e)
bool	uentry_isEndIter (uentry e)
bool	uentry_isRealFunction (uentry e)
bool	uentry_hasName (uentry e)
bool	uentry_hasRealName (uentry e)
globSet	uentry_getGlobs (uentry l)
sRefSet	uentry_getMods (uentry l)
ekind	uentry_getKind (uentry e)
multiVal	uentry_getConstantValue (uentry e)
uentryList	uentry_getParams (uentry l)
cstring	uentry_rawName (uentry e)
cstring	uentry_getName (uentry e)
cstring	uentry_getRealName (uentry e)
ctype	uentry_getType (uentry e)
fileloc	uentry_whereLast (uentry e)
fileloc	uentry_whereEither (uentry e)
fileloc	uentry_whereSpecified (uentry e)
fileloc	uentry_whereDefined (uentry e)
fileloc	uentry_whereDeclared (uentry e)
fileloc	uentry_whereEarliest (uentry e)
void	uentry_setFunctionDefined (uentry e, fileloc loc)
void	uentry_setDeclaredForce (uentry e, fileloc f)
void	uentry_setDeclaredForceOnly (uentry e, fileloc f)
void	uentry_setDeclaredOnly (uentry e, fileloc f)
void	uentry_setDeclared (uentry e, fileloc f)
void	uentry_clearDefined (uentry e)
void	uentry_setDefined (uentry e, fileloc f)
bool	uentry_isCodeDefined (uentry e)
bool	uentry_isDeclared (uentry e)
sRef	uentry_getSref (uentry e)
sRef	uentry_getOrigSref (uentry e)
void	uentry_setName (uentry e, cstring n)
void	uentry_setType (uentry e, ctype t)
void	uentry_resetParams (uentry ue, uentryList pn)
void	uentry_setRefParam (uentry e)
void	uentry_setParam (uentry e)
void	uentry_setSref (uentry e, sRef s)
ctype	uentry_getAbstractType (uentry e)
ctype	uentry_getRealType (uentry e)
ctype	uentry_getForceRealType (uentry e)
uentry	uentry_nameCopy (cstring name, uentry e)
void	uentry_setDatatype (uentry e, usymId uid)
void	uentry_markOwned ( uentry u)
void	uentry_free ( uentry e)
void	uentry_freeComplete ( uentry e)
void	uentry_showWhereLast (uentry spec)
void	uentry_showDefSpecInfo (uentry ce, fileloc fwhere)
void	uentry_showWhereLastExtra (uentry spec, cstring extra)
void	uentry_showWhereDeclared (uentry spec)
void	uentry_showWhereAny (uentry spec)
void	uentry_showWhereDefined (uentry spec)
void	uentry_showWhereLastPlain (uentry spec)
void	uentry_showWhereSpecified (uentry spec)
void	uentry_showWhereSpecifiedExtra (uentry spec, cstring s)
cstring	uentry_checkedName (uentry ue)
void	uentry_checkMatchParam (uentry u1, uentry u2, int paramno, exprNode e)
void	uentry_mergeConstantValue (uentry ue, multiVal m)
void	uentry_mergeEntries (uentry spec, uentry def)
void	uentry_clearDecl (void)
void	uentry_checkDecl (void)
void	uentry_mergeDefinition (uentry old, uentry unew)
void	uentry_copyState (uentry res, uentry other)
bool	uentry_sameKind (uentry u1, uentry u2)
uentry	uentry_copy (uentry e)
void	uentry_setState (uentry res, uentry other)
void	uentry_mergeUses (uentry res, uentry other)
void	uentry_mergeState (uentry res, uentry other, fileloc loc, bool mustReturn, bool flip, bool opt, clause cl)
void	uentry_setUsed (uentry e, fileloc loc)
bool	uentry_isReturned (uentry u)
sRef	uentry_returnedRef (uentry u, exprNodeList args)
void	uentry_checkYieldParam (uentry old, uentry unew)
cstring	uentry_ekindName (uentry ue)
void	uentry_setHasNameError (uentry ue)
void	uentry_checkName (uentry ue)
uentry	uentry_makeUnrecognized (cstring c, fileloc loc)

---

Function Documentation

typeIdSet uentry_accessType ( uentry e )

Definition at line 4566 of file uentry.c. Referenced by uentry_compare(). { if (uentry_isValid (e)) { switch (e->ukind) { case KITER: return (e->info->iter->access); case KENDITER: return (e->info->enditer->access); case KFCN: return (e->info->fcn->access); case KENUMCONST: case KCONST: return (e->info->uconst->access); default: break; } } return typeIdSet_undefined; }

void uentry_addAccessType ( uentry ue, typeId tid )

Definition at line 2854 of file uentry.c. { if (uentry_isFunction (ue)) { ue->info->fcn->access = typeIdSet_insert (ue->info->fcn->access, tid); } else if (uentry_isEitherConstant (ue)) { ue->info->uconst->access = typeIdSet_insert (ue->info->uconst->access, tid); } else if (uentry_isIter (ue)) { ue->info->iter->access = typeIdSet_insert (ue->info->iter->access, tid); } else if (uentry_isEndIter (ue)) { ue->info->enditer->access = typeIdSet_insert (ue->info->enditer->access, tid); } else { llbug (message ("no access for: %q", uentry_unparse (ue))); } }

void uentry_checkDecl ( void )

Definition at line 8196 of file uentry.c. { if (uentry_isValid (posRedeclared)) { llassert (fileloc_isDefined (posLoc)); if (uentry_isCodeDefined (posRedeclared)) { if (optgenerror (FLG_REDECL, message ("%s %q declared after definition", ekind_capName (posRedeclared->ukind), uentry_getName (posRedeclared)), posLoc)) { llgenindentmsg (message ("Definition of %q", uentry_getName (posRedeclared)), posRedeclared->whereDeclared); } } else { if (optgenerror (FLG_REDECL, message ("%s %q declared more than once", ekind_capName (posRedeclared->ukind), uentry_getName (posRedeclared)), posLoc)) { llgenindentmsg (message ("Previous declaration of %q", uentry_getName (posRedeclared)), posRedeclared->whereDeclared); } } } fileloc_free (posLoc); posLoc = fileloc_undefined; posRedeclared = uentry_undefined; }

void uentry_checkMatchParam ( uentry u1, uentry u2, int paramno, exprNode e )

Definition at line 7000 of file uentry.c. { if (uentry_isElipsisMarker (u1) || uentry_isElipsisMarker (u2)) { return; } llassert (uentry_isVar (u1)); llassert (uentry_isVar (u2)); if (u1->info->var->kind != u2->info->var->kind) { if (u1->info->var->kind == VKSEFRETPARAM) { if (u2->info->var->kind == VKRETPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "sef parameter, but non-sef parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else if (u2->info->var->kind == VKSEFPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "returns parameter, but non-returns parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "sef returns parameter, but non-sef returns parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } } else if (u1->info->var->kind == VKRETPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "returns parameter, but non-returns parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else if (u1->info->var->kind == VKSEFPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "sef parameter, but non-sef parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else { if (u2->info->var->kind == VKSEFRETPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "normal parameter, but sef returns parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else if (u2->info->var->kind == VKSEFPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "normal parameter, but sef parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else if (u2->info->var->kind == VKRETPARAM) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "normal parameter, but returns parameter in " "assigned function: %s", paramno, exprNode_unparse (e)), exprNode_loc (e)); } else { BADBRANCH; } } } if (u1->info->var->defstate != u2->info->var->defstate) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "%s, but %s in assigned function: %s", paramno, sstate_unparse (u1->info->var->defstate), sstate_unparse (u2->info->var->defstate), exprNode_unparse (e)), exprNode_loc (e)); } if (u1->info->var->nullstate != u2->info->var->nullstate) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "%s, but %s in assigned function: %s", paramno, nstate_unparse (u1->info->var->nullstate), nstate_unparse (u2->info->var->nullstate), exprNode_unparse (e)), exprNode_loc (e)); } if (sRef_getAliasKind (u1->sref) != sRef_getAliasKind (u2->sref)) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "%s, but %s in assigned function: %s", paramno, alkind_unparse (sRef_getAliasKind (u1->sref)), alkind_unparse (sRef_getAliasKind (u2->sref)), exprNode_unparse (e)), exprNode_loc (e)); } if (sRef_getExKind (u1->sref) != sRef_getExKind (u2->sref)) { voptgenerror (FLG_TYPE, message ("Function types are inconsistent. Parameter %d is " "%s, but %s in assigned function: %s", paramno, exkind_unparse (sRef_getExKind (u1->sref)), exkind_unparse (sRef_getExKind (u2->sref)), exprNode_unparse (e)), exprNode_loc (e)); } }

void uentry_checkName ( uentry ue )

Definition at line 9290 of file uentry.c. Referenced by uentry_mergeDefinition(), and uentry_mergeEntries(). { if (uentry_isValid (ue) && !uentry_isElipsisMarker (ue) && context_getFlag (FLG_NAMECHECKS) && !ue->hasNameError && !uentry_isEndIter (ue) && !fileloc_isBuiltin (uentry_whereLast (ue)) && (uentry_isExpandedMacro (ue) || !uentry_isForward (ue))) { if (uentry_isPriv (ue)) { ; /* any checks here? */ } else if (fileloc_isExternal (uentry_whereDefined (ue))) { ; /* no errors for externals */ } else { int scope; if (uentry_isExpandedMacro (ue)) { scope = globScope; } else { if (uentry_isExpandedMacro (ue)) { scope = fileScope; } else if (uentry_isVariable (ue)) { sRef sr = uentry_getSref (ue); if (sRef_isValid (sr)) { scope = sRef_getScope (sr); } else { scope = fileScope; } } else if (uentry_isFunction (ue) || uentry_isIter (ue) || uentry_isEndIter (ue) || uentry_isConstant (ue)) { scope = uentry_isStatic (ue) ? fileScope : globScope; } else /* datatypes, etc. must be global */ { scope = globScope; } usymtab_checkDistinctName (ue, scope); } if (context_getFlag (FLG_CPPNAMES)) { if (checkCppName (uentry_rawName (ue), uentry_whereLast (ue))) { uentry_setHasNameError (ue); } } if (scope == globScope) { checkGlobalName (ue); if (context_getFlag (FLG_ANSIRESERVED)) { if (uentry_hasName (ue) && !uentry_isAnyTag (ue)) { if (checkAnsiName (uentry_rawName (ue), uentry_whereLast (ue))) { uentry_setHasNameError (ue); } } } } else { checkLocalName (ue); if (context_getFlag (FLG_ANSIRESERVEDLOCAL)) { if (uentry_hasName (ue) && !uentry_isAnyTag (ue)) { if (checkAnsiName (uentry_rawName (ue), uentry_whereLast (ue))) { uentry_setHasNameError (ue); } } } } DPRINTF (("Check prefix: %s", uentry_unparse (ue))); checkPrefix (ue); } } }

void uentry_checkParams ( uentry ue )

Definition at line 647 of file uentry.c. Referenced by declareStaticFunction(), and processNamedDecl(). { if (uentry_isValid (ue)) { bool isExt = uentry_isExtern (ue); if (uentry_isRealFunction (ue)) { uentryList params = uentry_getParams (ue); uentryList_elements (params, current) { if (uentry_isValid (current)) { ctype ct = current->utype; if (ctype_isFixedArray (ct)) { if (ctype_isArray (ctype_baseArrayPtr (ct)) && !ctype_isFixedArray (ctype_baseArrayPtr (ct))) { ; } else { voptgenerror (FLG_FIXEDFORMALARRAY, message ("Function parameter %q declared as " "manifest array (size constant is meaningless)", uentry_getName (current)), uentry_whereDeclared (current)); } } else { if (ctype_isArray (ct)) { voptgenerror (FLG_FORMALARRAY, message ("Function parameter %q declared as " "array (treated as pointer)", uentry_getName (current)), uentry_whereDeclared (current)); } } if (sRef_getNullState (uentry_getSref (current)) == NS_MNOTNULL) { if (ctype_isAbstract (ct) && (isExt || (ctype_isAbstract (ctype_realType (ct)) && !context_hasFileAccess (ctype_typeId (ct))))) { vgenhinterror (FLG_INCONDEFS, message ("Function %q declared with notnull parameter %q of abstract " "type %s", uentry_getName (ue), uentry_getName (current), ctype_unparse (ct)), message ("Since %s is an abstract type, notnull can only be " "used for parameters if the function is static to a " "module where %s is accessible.", ctype_unparse (ct), ctype_unparse (ct)), uentry_whereDeclared (current)); } } } } end_uentryList_elements; if (sRef_getNullState (uentry_getSref (ue)) == NS_MNOTNULL) { ctype ct = ue->utype; if (ctype_isAbstract (ct) && (isExt || (ctype_isAbstract (ctype_realType (ct)) && !context_hasFileAccess (ctype_typeId (ct))))) { vgenhinterror (FLG_INCONDEFS, message ("%s %q declared %s notnull storage of abstract type %s", ekind_capName (uentry_getKind (ue)), uentry_getName (ue), fcnErrName (ue), ctype_unparse (ct)), message ("Since %s is an abstract type, notnull can only be used " "if it is static to a module where %s is accessible.", ctype_unparse (ct), ctype_unparse (ct)), uentry_whereDeclared (ue)); } } } } }

void uentry_checkYieldParam ( uentry old, uentry unew )

Definition at line 9209 of file uentry.c. Referenced by processNamedDecl(). { cstring name; llassert (uentry_isVariable (old)); llassert (uentry_isVariable (unew)); unew->info->var->kind = VKYIELDPARAM; (void) checkTypeConformance (old, unew, TRUE); checkVarConformance (old, unew, TRUE, FALSE); /* get rid of param marker */ name = uentry_getName (unew); cstring_free (unew->uname); unew->uname = name; unew->info->var->kind = VKREFYIELDPARAM; uentry_setUsed (old, fileloc_undefined); uentry_setUsed (unew, fileloc_undefined); }

cstring uentry_checkedName ( uentry ue )

Definition at line 6447 of file uentry.c. { if (uentry_isVar (ue)) { return (checkedName (ue->info->var->checked)); } else { return (cstring_makeLiteralTemp ("<checked invalid>")); } }

void uentry_clearDecl ( void )

Definition at line 8188 of file uentry.c. { posRedeclared = uentry_undefined; fileloc_free (posLoc); posLoc = fileloc_undefined; }

void uentry_clearDefined ( uentry e )

Definition at line 5215 of file uentry.c. { if (uentry_isValid (e)) { e->whereDefined = fileloc_update (e->whereDefined, fileloc_undefined); } }

int uentry_compare ( uentry u1, uentry u2 )

Definition at line 3378 of file uentry.c. Referenced by uentryList_compareFields(), uentry_equiv(), and uentry_xcomparealpha(). { if (u1 == u2) return 0; if (uentry_isInvalid (u1)) return -1; if (uentry_isInvalid (u2)) return 1; INTCOMPARERETURN (u1->ukind, u2->ukind); COMPARERETURN (ctype_compare (u1->utype, u2->utype)); COMPARERETURN (bool_compare (uentry_isPriv (u1), uentry_isPriv (u2))); COMPARERETURN (sRef_compare (u1->sref, u2->sref)); switch (u1->ukind) { case KINVALID: case KELIPSMARKER: /* bug detected by lclint: ** uentry.c:753,14: Return value type bool does not match declared type int: TRUE */ return 0; case KENUMCONST: case KCONST: return (multiVal_compare (u1->info->uconst->val, u2->info->uconst->val)); case KSTRUCTTAG: case KUNIONTAG: case KENUMTAG: return (ctype_compare (u1->info->datatype->type, u2->info->datatype->type)); case KITER: COMPARERETURN (typeIdSet_compare (uentry_accessType (u1), uentry_accessType (u2))); return (uentryList_compareParams (uentry_getParams (u1), uentry_getParams (u2))); case KENDITER: return (typeIdSet_compare (uentry_accessType (u1), uentry_accessType (u2))); case KFCN: COMPARERETURN (typeIdSet_compare (uentry_accessType (u1), uentry_accessType (u2))); COMPARERETURN (globSet_compare (uentry_getGlobs (u1), uentry_getGlobs (u2))); COMPARERETURN (uentryList_compareParams (uentry_getParams (u1), uentry_getParams (u2))); COMPARERETURN (generic_compare (u1->info->fcn->specialCode, u2->info->fcn->specialCode)); COMPARERETURN (generic_compare (u1->info->fcn->nullPred, u2->info->fcn->nullPred)); return (sRefSet_compare (uentry_getMods (u1), uentry_getMods (u2))); case KVAR: COMPARERETURN (generic_compare (u1->info->var->kind, u2->info->var->kind)); COMPARERETURN (generic_compare (sRef_getOrigAliasKind (u1->sref), sRef_getOrigAliasKind (u2->sref))); COMPARERETURN (generic_compare (sRef_getOrigExKind (u1->sref), sRef_getOrigExKind (u2->sref))); COMPARERETURN (generic_compare (u1->info->var->checked, u2->info->var->checked)); COMPARERETURN (generic_compare (u1->info->var->defstate, u2->info->var->defstate)); return (generic_compare (u1->info->var->nullstate, u2->info->var->nullstate)); case KDATATYPE: COMPARERETURN (ctype_compare (u1->info->datatype->type, u2->info->datatype->type)); COMPARERETURN (ynm_compare (u1->info->datatype->mut, u2->info->datatype->mut)); return (ynm_compare (u1->info->datatype->abs, u2->info->datatype->abs)); } BADEXIT; }

int uentry_compareStrict ( uentry v1, uentry v2 )

Definition at line 3363 of file uentry.c. { COMPARERETURN (uentry_compare (v1, v2)); if (v1 != v2 && uentry_isValid (v1) && uentry_isValid (v2)) { COMPARERETURN (fileloc_compare (v1->whereDeclared, v2->whereDeclared)); COMPARERETURN (fileloc_compare (v1->whereDefined, v2->whereDefined)); COMPARERETURN (fileloc_compare (v1->whereSpecified, v2->whereSpecified)); } return 0; }

uentry uentry_copy ( uentry e )

Definition at line 8559 of file uentry.c. Referenced by uentryList_copy(). { if (uentry_isValid (e)) { uentry enew = uentry_alloc (); DPRINTF (("copy: %s", uentry_unparseFull (e))); uentry_copyInto (enew, e); DPRINTF (("Here we are...")); DPRINTF (("original: %s", uentry_unparseFull (e))); DPRINTF (("copy: %s", uentry_unparse (enew))); DPRINTF (("copy: %s", uentry_unparseFull (enew))); return enew; } else { return uentry_undefined; } }

void uentry_copyState ( uentry res, uentry other )

Definition at line 8491 of file uentry.c. { llassert (uentry_isValid (res)); llassert (uentry_isValid (other)); res->used = other->used; res->info->var->kind = other->info->var->kind; res->info->var->defstate = other->info->var->defstate; res->info->var->nullstate = other->info->var->nullstate; res->info->var->checked = other->info->var->checked; sRef_copyState (res->sref, other->sref); }

void uentry_destroyMod ( void )

Definition at line 3259 of file uentry.c. Referenced by llexit(). { static bool wasDestroyed = FALSE; llassert (!wasDestroyed); if (emarker != NULL) { uentry_reallyFree (emarker); } wasDestroyed = TRUE; }

cstring uentry_dump ( uentry v )

Definition at line 4202 of file uentry.c. Referenced by usymtab_dump(). { return (uentry_dumpAux (v, FALSE)); }

cstring uentry_dumpParam ( uentry v )

Definition at line 4208 of file uentry.c. { llassertprint (uentry_isVariable (v) || uentry_isElipsisMarker (v), ("dump: %s", uentry_unparseFull (v))); return (uentry_dumpAux (v, TRUE)); }

cstring uentry_ekindName ( uentry ue )

Definition at line 9232 of file uentry.c. Referenced by checkPrefix(). { if (uentry_isValid (ue)) { switch (ue->ukind) { case KINVALID: return cstring_makeLiteralTemp ("<Error: invalid uentry>"); case KDATATYPE: return cstring_makeLiteralTemp ("Datatype"); case KENUMCONST: return cstring_makeLiteralTemp ("Enum member"); case KCONST: return cstring_makeLiteralTemp ("Constant"); case KVAR: if (uentry_isParam (ue)) { return cstring_makeLiteralTemp ("Parameter"); } else if (uentry_isExpandedMacro (ue)) { return cstring_makeLiteralTemp ("Expanded macro"); } else { return cstring_makeLiteralTemp ("Variable"); } case KFCN: return cstring_makeLiteralTemp ("Function"); case KITER: return cstring_makeLiteralTemp ("Iterator"); case KENDITER: return cstring_makeLiteralTemp ("Iterator finalizer"); case KSTRUCTTAG: return cstring_makeLiteralTemp ("Struct tag"); case KUNIONTAG: return cstring_makeLiteralTemp ("Union tag"); case KENUMTAG: return cstring_makeLiteralTemp ("Enum tag"); case KELIPSMARKER: return cstring_makeLiteralTemp ("Optional parameters"); } } else { return cstring_makeLiteralTemp ("<Undefined>"); } BADEXIT; }

bool uentry_equiv ( uentry p1, uentry p2 )

Definition at line 3304 of file uentry.c. Referenced by usymtab_dump(). { if (uentry_compare (p1, p2) != 0) { return FALSE; } else { return TRUE; } }

void uentry_fixupSref ( uentry ue )

Definition at line 1117 of file uentry.c. Referenced by checkPassTransfer(), and usymtab_exitScope(). { sRef sr; if (uentry_isUndefined (ue) || uentry_isElipsisMarker (ue)) { return; } sr = uentry_getSref (ue); sRef_resetState (sr); sRef_clearDerived (sr); llassertprint (uentry_isVariable (ue), ("fixing: %s", uentry_unparseFull (ue))); llassert (sRef_isValid (sr)); if (uentry_isVariable (ue)) { sRef_setDefState (sr, ue->info->var->defstate, fileloc_undefined); sRef_setNullState (sr, ue->info->var->nullstate, fileloc_undefined); } }

void uentry_free ( uentry e )

Definition at line 5853 of file uentry.c. Referenced by exprNode_destroyMod(), uentryList_free(), uentryList_undump(), uentry_mergeDefinition(), uentry_mergeEntries(), and usymtab_popBranches(). { if (uentry_isValid (e) && !uentry_isElipsisMarker (e)) { uentry_reallyFree (e); } }

void uentry_freeComplete ( uentry e )

Definition at line 5866 of file uentry.c. { if (uentry_isValid (e) && !uentry_isElipsisMarker (e)) { /*@i@*/ sRef_free (e->sref); e->sref = sRef_undefined; uentry_reallyFree (e); } }

ctype uentry_getAbstractType ( uentry e )

Definition at line 5446 of file uentry.c. Referenced by declareEnum(), declareUnnamedEnum(), handleEnum(), handleStruct(), handleUnion(), uentry_getForceRealType(), uentry_getRealType(), usymtab_lookupAbstractType(), and usymtab_supForwardTypeEntry(). { llassert (uentry_isDatatype (e)); /* ** This assertion removed. ** Okay to have undefined type, for system types llassertprintret (!ctype_isUndefined (e->info->datatype->type), ("uentry_getAbstractType %q: undefined", uentry_unparseFull (e)), e->utype); */ if (ctype_isUndefined (e->info->datatype->type)) { return ctype_unknown; } /* ** Sadly, a kludge... */ if (ctype_isUserBool (e->info->datatype->type)) { return ctype_bool; } return e->info->datatype->type; }

alkind uentry_getAliasKind ( uentry u )

Definition at line 4793 of file uentry.c. { if (uentry_isValid (u)) { return (sRef_getAliasKind (uentry_getSref (u))); } else { return AK_UNKNOWN; } }

multiVal uentry_getConstantValue ( uentry e )

Definition at line 4911 of file uentry.c. { llassert (uentry_isEitherConstant (e)); return (e->info->uconst->val); }

sstate uentry_getDefState ( uentry u )

Definition at line 4724 of file uentry.c. Referenced by sRef_setStateFromUentry(). { if (uentry_isValid (u)) { return (sRef_getDefState (u->sref)); } else { return (SS_UNKNOWN); } }

exitkind uentry_getExitCode ( uentry ue )

Definition at line 4758 of file uentry.c. { if (uentry_isFunction (ue)) { return ue->info->fcn->exitCode; } else { return XK_UNKNOWN; } }

exkind uentry_getExpKind ( uentry u )

Definition at line 4806 of file uentry.c. { if (uentry_isValid (u)) { return (sRef_getExKind (uentry_getSref (u))); } else { return XO_UNKNOWN; } }

ctype uentry_getForceRealType ( uentry e )

Definition at line 5544 of file uentry.c. Referenced by ctype_forceRealType(). { ctype ct; typeId uid = USYMIDINVALID; if (uentry_isInvalid (e)) { return ctype_unknown; } llassertprint (uentry_isDatatype (e), ("not datatype: %s", uentry_unparse (e))); if (uentry_isAnyTag (e)) { return (e->utype); } if (uentry_isAbstractType (e)) { ct = uentry_getAbstractType (e); llassert (ctype_isUA (ct)); uid = ctype_typeId (ct); /* no check for access! */ } ct = uentry_getType (e); /* evs 2000-07-25 */ /* if (ctype_isUserBool (ct)) return ct; */ if (ctype_isManifestBool (ct)) { return ctype_bool; } if (ctype_isUA (ct)) { usymId iid = ctype_typeId (ct); if /*@access usymId@*/ (iid == uid) /*@noaccess usymId@*/ { llcontbug (message ("uentry_getRealType: recursive type! %s", ctype_unparse (ct))); return ct; } else { return uentry_getForceRealType (usymtab_getTypeEntry (iid)); } } else { return ct; } }

globSet uentry_getGlobs ( uentry l )

Definition at line 4859 of file uentry.c. Referenced by context_enterFunction(), and uentry_compare(). { if (uentry_isInvalid (l)) { return globSet_undefined; } if (l->ukind != KFCN) { if (l->ukind != KITER && l->ukind != KENDITER) { if (l->ukind == KVAR) { llbug (message ("Bad call to uentry_getGlobs (var): %q (%s)", uentry_unparse (l), ekind_unparse (l->ukind))); } else { llbug (message ("Bad call to uentry_getGlobs: %q (%s)", uentry_unparse (l), ekind_unparse (l->ukind))); } } return globSet_undefined; } return l->info->fcn->globs; }

ekind uentry_getKind ( uentry e )

Definition at line 4904 of file uentry.c. Referenced by usymtab_dump(). { llassert (uentry_isValid (e)); return (e->ukind); }

sRefSet uentry_getMods ( uentry l )

Definition at line 4890 of file uentry.c. Referenced by context_enterFunction(), and uentry_compare(). { llassert (uentry_isValid (l)); if (l->ukind != KFCN && l->ukind != KITER && l->ukind != KENDITER) { llcontbug (message ("Bad call to uentry_getMods: %q", uentry_unparse (l))); return sRefSet_undefined; } return l->info->fcn->mods; }

cstring uentry_getName ( uentry e )

Definition at line 4978 of file uentry.c. Referenced by checkParamNames(), checkPrefix(), exprChecks_checkEmptyMacroBody(), exprNode_checkMacroBody(), exprNode_iter(), exprNode_iterId(), sRef_sameName(), specialClauses_checkAll(), uentryList_lookupRealName(), uentry_checkDecl(), uentry_checkParams(), uentry_checkYieldParam(), uentry_mergeConstantValue(), uentry_mergeDefinition(), uentry_mergeEntries(), uentry_reflectQualifiers(), uentry_setDefined(), uentry_unparse(), uentry_unparseAbbrev(), uentry_unparseFull(), usymIdSet_unparse(), usymtab_allDefined(), usymtab_allUsed(), usymtab_checkFinalScope(), usymtab_exportHeader(), usymtab_exportLocal(), and usymtab_getTypeEntryName(). { cstring ret = cstring_undefined; if (uentry_isValid (e)) { if (uentry_isAnyTag (e)) { ret = fixTagName (e->uname); } else if (uentry_isAnyParam (e)) { ret = cstring_copy (fixParamName (e->uname)); } else { ret = cstring_copy (e->uname); } } return ret; }

sRef uentry_getOrigSref ( uentry e )

Definition at line 5294 of file uentry.c. { if (uentry_isValid (e)) { sRef sr = sRef_copy (uentry_getSref (e)); sRef_resetState (sr); sRef_clearDerived (sr); if (uentry_isVariable (e)) { sRef_setDefState (sr, e->info->var->defstate, fileloc_undefined); sRef_setNullState (sr, e->info->var->nullstate, fileloc_undefined); } return (sr); } else { return sRef_undefined; } }

uentryList uentry_getParams ( uentry l )

Definition at line 4919 of file uentry.c. Referenced by checkParamNames(), context_getParams(), exprNode_checkAllMods(), exprNode_iterStart(), uentry_checkParams(), uentry_compare(), and uentry_returnedRef(). { if (uentry_isInvalid (l)) return uentryList_undefined; switch (l->ukind) { case KFCN: case KITER: { ctype ct = l->utype; if (ctype_isFunction (ct)) { return (ctype_argsFunction (ct)); } else { return uentryList_undefined; } } case KVAR: { ctype ct = l->utype; llassert (ctype_isFunction (ct)); return (ctype_argsFunction (ct)); } BADDEFAULT; } BADEXIT; }

cstring uentry_getRealName ( uentry e )

Definition at line 5002 of file uentry.c. { if (uentry_isValid (e)) { if (uentry_isAnyTag (e)) { return (cstring_undefined); } else { return (e->uname); } } return cstring_undefined; }

ctype uentry_getRealType ( uentry e )

Definition at line 5476 of file uentry.c. Referenced by ctype_realType(), ctype_realishType(), usymtab_allUsed(), and usymtab_lookupType(). { ctype ct; typeId uid = USYMIDINVALID; if (uentry_isInvalid (e)) { return ctype_unknown; } llassertprint (uentry_isDatatype (e), ("not datatype: %s", uentry_unparse (e))); if (uentry_isAnyTag (e)) { return (e->utype); } if (uentry_isAbstractType (e)) { ct = uentry_getAbstractType (e); if (ctype_isManifestBool (ct)) { return ct; } llassert (ctype_isUA (ct)); uid = ctype_typeId (ct); if (!context_hasAccess (uid)) { return (ct); } } ct = uentry_getType (e); /* if (ctype_isUserBool (ct)) return ct; */ if (ctype_isManifestBool (ct)) { return ctype_bool; } if (ctype_isUA (ct)) { usymId iid = ctype_typeId (ct); if /*@access usymId@*/ (iid == uid) /*@noaccess usymId@*/ { llcontbug (message ("uentry_getRealType: recursive type! %s", ctype_unparse (ct))); return ct; } else { /* evs 2000-07-25: possible infinite recursion ? */ uentry ue2 = usymtab_getTypeEntry (iid); llassertprint (ue2 != e, ("Bad recursion: %s", uentry_unparseFull (e))); return uentry_getRealType (ue2); } } else { return ct; } }

specialClauses uentry_getSpecialClauses ( uentry ue )

Definition at line 3687 of file uentry.c. Referenced by checkReturnTransfer(), specialClauses_checkAll(), specialClauses_checkEqual(), uentry_returnedRef(), and usymtab_checkFinalScope(). { llassert (uentry_isFunction (ue)); return ue->info->fcn->specclauses; }

sRef uentry_getSref ( uentry e )

Definition at line 5284 of file uentry.c. Referenced by aliasTable_fixSrefs(), checkPassTransfer(), checkReturnTransfer(), checkSpecClausesId(), exprNode_checkMacroBody(), exprNode_createId(), exprNode_iterId(), exprNode_iterNewId(), fixModifiesId(), fixSpecClausesId(), processNamedDecl(), sRefSet_fixSrefs(), sRef_fixOuterRef(), sRef_updateSref(), specialClauses_checkAll(), uentryList_fixImpParams(), uentry_checkName(), uentry_directParamNo(), uentry_fixupSref(), usymtab_allUsed(), usymtab_checkFinalScope(), usymtab_popAndBranch(), and usymtab_supEntrySref(). { /* not true, used for functions too (but shouldn't be? */ /* llassertprint (e->ukind == KVAR, ("uentry_getSref: not variable!")); */ if (uentry_isInvalid (e)) return sRef_undefined; return (e->sref); }

ctype uentry_getType ( uentry e )

Definition at line 5018 of file uentry.c. Referenced by checkPassTransfer(), checkValueConstant(), context_currentFunctionType(), context_getRetType(), declareEnum(), exprNode_arrowAccess(), exprNode_checkMacroBody(), exprNode_createId(), exprNode_fieldAccess(), exprNode_iterId(), exprNode_iterNewId(), exprNode_offsetof(), sRef_deriveType(), uentryList_fixMissingNames(), uentryList_matchFields(), uentryList_matchParams(), uentryList_showFieldDifference(), uentry_getForceRealType(), uentry_getRealType(), uentry_isForward(), uentry_makeIdFunction(), uentry_reflectQualifiers(), uentry_showWhereLast(), usymtab_enterFunctionScope(), usymtab_enumEnumNameListType(), and usymtab_matchForwardStruct(). { if (uentry_isValid (e)) { return e->utype; } else { return ctype_unknown; } }

bool uentry_hasAccessType ( uentry e )

Definition at line 4543 of file uentry.c. Referenced by context_enterFunction(). { if (uentry_isValid (e)) { switch (e->ukind) { case KITER: return (!typeIdSet_isEmpty (e->info->iter->access)); case KENDITER: return (!typeIdSet_isEmpty (e->info->enditer->access)); case KFCN: return (!typeIdSet_isEmpty (e->info->fcn->access)); case KENUMCONST: case KCONST: return (!typeIdSet_isEmpty (e->info->uconst->access)); default: return FALSE; } } return FALSE; }

bool uentry_hasGlobs ( uentry ue )

Definition at line 3672 of file uentry.c. Referenced by context_exitFunction(). { if (uentry_isFunction (ue)) { return (ue->info->fcn->hasGlobs); } return FALSE; }

bool uentry_hasMods ( uentry ue )

Definition at line 3693 of file uentry.c. Referenced by context_exitFunction(), and context_hasMods(). { if (uentry_isFunction (ue)) { return (ue->info->fcn->hasMods); } return FALSE; }

bool uentry_hasName ( uentry e )

Definition at line 4838 of file uentry.c. Referenced by checkGlobalName(), checkParamNames(), sRef_hasName(), uentry_checkName(), uentry_makeParam(), uentry_showWhereAny(), uentry_showWhereDeclared(), uentry_showWhereLast(), uentry_showWhereSpecified(), uentry_showWhereSpecifiedExtra(), and usymtab_allUsed(). { if (uentry_isValid (e)) { cstring s = e->uname; return (!(cstring_isEmpty (s) || cstring_equalLit (s, "..."))); } else { return FALSE; } }

bool uentry_hasRealName ( uentry e )

Definition at line 4852 of file uentry.c. Referenced by exprNode_checkAllMods(), uentryList_fixMissingNames(), usymtab_allUsed(), and usymtab_dump(). { return (uentry_isValid (e) && cstring_isNonEmpty (e->uname)); }

bool uentry_hasSpecialClauses ( uentry ue )

Definition at line 3682 of file uentry.c. Referenced by checkPassTransfer(), and usymtab_checkFinalScope(). { return (uentry_isFunction (ue) && specialClauses_isDefined (ue->info->fcn->specclauses)); }

bool uentry_isAbstractDatatype ( uentry e )

Definition at line 4651 of file uentry.c. Referenced by usymtab_supReturnTypeEntry(), and usymtab_supTypeEntry(). { return (uentry_isDatatype (e) && (ynm_isOn (e->info->datatype->abs))); }

bool uentry_isAnyParam ( uentry u )

Definition at line 4713 of file uentry.c. Referenced by checkPrefix(), sRef_isRealLocalVar(), uentry_getName(), and usymtab_checkFinalScope(). { return (uentry_isVariable (u) && ((u->info->var->kind == VKPARAM) || (u->info->var->kind == VKSEFPARAM) || (u->info->var->kind == VKYIELDPARAM) || (u->info->var->kind == VKRETPARAM) || (u->info->var->kind == VKSEFRETPARAM))); }

bool uentry_isAnyTag ( uentry ue )

Definition at line 3250 of file uentry.c. Referenced by checkPrefix(), uentry_checkName(), uentry_getForceRealType(), uentry_getName(), uentry_getRealName(), uentry_getRealType(), usymtab_allDefined(), usymtab_allUsed(), usymtab_exportHeader(), usymtab_exportLocal(), and usymtab_matchForwardStruct(). { return (uentry_isStructTag (ue) || uentry_isUnionTag (ue) || uentry_isEnumTag (ue)); }

bool uentry_isCheckMod ( uentry ue )

Definition at line 2582 of file uentry.c. Referenced by context_checkAliasGlob(), and context_checkGlobUse(). { return (uentry_isVar (ue) && (ue->info->var->checked == CH_CHECKMOD)); }

bool uentry_isChecked ( uentry ue )

Definition at line 2594 of file uentry.c. Referenced by context_checkAliasGlob(), and context_checkGlobUse(). { return (uentry_isVar (ue) && (ue->info->var->checked == CH_CHECKED)); }

bool uentry_isCheckedModify ( uentry ue )

Definition at line 2600 of file uentry.c. Referenced by context_checkGlobMod(). { return (uentry_isVar (ue) && (ue->info->var->checked == CH_CHECKED || ue->info->var->checked == CH_CHECKMOD || ue->info->var->checked == CH_CHECKEDSTRICT)); }

bool uentry_isCheckedStrict ( uentry ue )

Definition at line 2608 of file uentry.c. Referenced by context_checkAliasGlob(), context_checkGlobMod(), and context_checkGlobUse(). { return (uentry_isVar (ue) && (ue->info->var->checked == CH_CHECKEDSTRICT)); }

bool uentry_isCheckedUnknown ( uentry ue )

Definition at line 2576 of file uentry.c. Referenced by context_checkAliasGlob(), context_checkGlobUse(), doDeclareVar(), and processNamedDecl(). { return (uentry_isVar (ue) && (ue->info->var->checked == CH_UNKNOWN)); }

bool uentry_isCodeDefined ( uentry e )

Definition at line 5268 of file uentry.c. Referenced by uentryList_showFieldDifference(), uentry_checkDecl(), uentry_makeDatatypeAux(), uentry_showWhereDefined(), and usymtab_allDefined(). { return (uentry_isValid (e) && fileloc_isDefined (e->whereDefined)); }

bool uentry_isDatatype ( uentry e )

Definition at line 4621 of file uentry.c. Referenced by checkPrefix(), context_checkExport(), exprChecks_checkExport(), exprNode_fromUIO(), uentry_isAbstractDatatype(), uentry_isMaybeAbstract(), uentry_isMutableDatatype(), uentry_isOut(), uentry_isPartial(), uentry_isRefCountedDatatype(), uentry_possiblyNull(), uentry_unparseFull(), usymtab_allUsed(), usymtab_existsType(), usymtab_existsTypeEither(), usymtab_exportHeader(), usymtab_exportLocal(), and usymtab_getTypeId(). { return (!uentry_isUndefined (e) && (e->ukind == KDATATYPE || e->ukind == KSTRUCTTAG || e->ukind == KUNIONTAG || e->ukind == KENUMTAG)); }

bool uentry_isDeclared ( uentry e )

Definition at line 5274 of file uentry.c. Referenced by specialClauses_checkEqual(), uentryList_showFieldDifference(), uentry_makeDatatypeAux(), uentry_showWhereAny(), uentry_showWhereDeclared(), uentry_showWhereLast(), uentry_showWhereLastExtra(), uentry_showWhereLastPlain(), uentry_showWhereSpecified(), uentry_showWhereSpecifiedExtra(), uentry_specDeclName(), and uentry_specOrDefName(). { if (uentry_isValid (e)) { return (fileloc_isDefined (e->whereDeclared)); } return FALSE; }

bool uentry_isEndIter ( uentry e )

Definition at line 4825 of file uentry.c. Referenced by context_checkExport(), exprChecks_checkExport(), uentry_addAccessType(), uentry_checkName(), usymtab_allUsed(), usymtab_exportHeader(), and usymtab_exportLocal(). { return (!uentry_isUndefined (e) && e->ukind == KENDITER); }

bool uentry_isEnumTag ( uentry ue )

Definition at line 3244 of file uentry.c. Referenced by uentry_isAnyTag(), and usymtab_enumEnumNameListType(). { return (uentry_isValid (ue) && ue->ukind == KENUMTAG); }

bool uentry_isExpandedMacro ( uentry u )

Definition at line 4687 of file uentry.c. Referenced by checkPrefix(), context_checkExport(), exprChecks_checkExport(), uentry_checkName(), uentry_ekindName(), uentry_mergeDefinition(), usymtab_allUsed(), usymtab_existsReal(), usymtab_exportHeader(), and usymtab_exportLocal(). { return (uentry_isVariable (u) && (u->info->var->kind == VKEXPMACRO)); }

bool uentry_isExported ( uentry ue )

Definition at line 2259 of file uentry.c. Referenced by checkPrefix(). { if (uentry_isValid (ue)) { if (uentry_isVariable (ue)) { return (sRef_isRealGlobal (uentry_getSref (ue))); } else { return !uentry_isStatic (ue); } } return FALSE; }

bool uentry_isFakeTag ( uentry e )

Definition at line 4615 of file uentry.c. Referenced by usymtab_allDefined(). { return (uentry_isValid (e) && strchr (cstring_toCharsSafe (e->uname), '!') != 0); }

bool uentry_isFileStatic ( uentry ue )

Definition at line 2251 of file uentry.c. Referenced by checkPrefix(). { return (uentry_isStatic (ue) && (!uentry_isVariable (ue) || sRef_isFileStatic (uentry_getSref (ue)))); }

bool uentry_isForward ( uentry e )

Definition at line 2943 of file uentry.c. Referenced by uentry_checkName(), uentry_mergeDefinition(), and usymtab_exportHeader(). { if (uentry_isValid (e)) { ctype ct = uentry_getType (e); return (ctype_isUnknown (ct) || (ctype_isFunction (ct) && ctype_isUnknown (ctype_returnValue (ct)))); } return FALSE; }

bool uentry_isGlobal ( uentry ue )

Definition at line 2284 of file uentry.c. Referenced by checkPrefix(). { return (uentry_isValid (ue) && uentry_isVariable (ue) && sRef_isGlobal (ue->sref)); }

bool uentry_isIter ( uentry e )

Definition at line 4819 of file uentry.c. Referenced by checkPrefix(), context_checkExport(), exprChecks_checkExport(), exprNode_iter(), exprNode_iterStart(), uentry_addAccessType(), uentry_checkName(), uentry_setGlobals(), uentry_setModifies(), uentry_unparseFull(), usymtab_allUsed(), usymtab_exportHeader(), and usymtab_exportLocal(). { return (!uentry_isUndefined (e) && e->ukind == KITER); }

bool uentry_isMaybeAbstract ( uentry e )

Definition at line 4658 of file uentry.c. Referenced by processNamedDecl(). { return (uentry_isDatatype (e) && (ynm_isMaybe (e->info->datatype->abs))); }

bool uentry_isMessageLike ( uentry ue )

Definition at line 2305 of file uentry.c. { return (uentry_isFunction (ue) && (ue->info->fcn->specialCode == SPC_MESSAGELIKE)); }

bool uentry_isMutableDatatype ( uentry e )

Definition at line 4665 of file uentry.c. { bool res = uentry_isDatatype (e) && (ynm_toBoolRelaxed (e->info->datatype->mut)); return res; }

bool uentry_isNonLocal ( uentry ue )

Definition at line 2277 of file uentry.c. Referenced by exprNode_createId(). { return (uentry_isValid (ue) && uentry_isVariable (ue) && (sRef_isGlobal (ue->sref) || uentry_isStatic (ue))); }

bool uentry_isOnly ( uentry ue )

Definition at line 2217 of file uentry.c. { return (!uentry_isUndefined (ue) && uentry_isVariable (ue) && alkind_isOnly (sRef_getOrigAliasKind (ue->sref))); }

bool uentry_isOut ( uentry u )

Definition at line 4737 of file uentry.c. Referenced by checkPassTransfer(), and usymtab_checkFinalScope(). { return ((uentry_isVariable (u) && (u->info->var->defstate == SS_ALLOCATED)) || (uentry_isDatatype (u) && (sRef_isAllocated (u->sref)))); }

bool uentry_isParam ( uentry u )

Definition at line 4680 of file uentry.c. Referenced by exprChecks_checkExport(), uentry_ekindName(), and usymtab_allUsed(). { return (uentry_isVariable (u) && (u->info->var->kind == VKPARAM || u->info->var->kind == VKYIELDPARAM)); }

bool uentry_isPartial ( uentry u )

Definition at line 4744 of file uentry.c. Referenced by checkPassTransfer(). { return ((uentry_isVariable (u) && (u->info->var->defstate == SS_PARTIAL)) || (uentry_isDatatype (u) && (sRef_isAllocated (u->sref)))); }

bool uentry_isPrintfLike ( uentry ue )

Definition at line 2291 of file uentry.c. { return (uentry_isFunction (ue) && (ue->info->fcn->specialCode == SPC_PRINTFLIKE)); }

bool uentry_isRealFunction ( uentry e )

Definition at line 4831 of file uentry.c. Referenced by uentry_checkParams(), and usymtab_checkFinalScope(). { return (uentry_isFunction (e) || (uentry_isVariable (e) && ctype_isFunction (uentry_getType (e)))); }

bool uentry_isRefCountedDatatype ( uentry e )

Definition at line 4674 of file uentry.c. { return (uentry_isDatatype (e) && (sRef_isRefCounted (uentry_getSref (e)))); }

bool uentry_isRefParam ( uentry u )

Definition at line 4703 of file uentry.c. Referenced by checkPrefix(), exprNode_sizeofExpr(), sRef_isRealLocalVar(), sRef_similarRelaxed(), usymtab_allUsed(), and usymtab_checkFinalScope(). { return (uentry_isVariable (u) && (u->info->var->kind == VKREFPARAM || u->info->var->kind == VKREFYIELDPARAM || u->info->var->kind == VKREFSEFPARAM || u->info->var->kind == VKREFSEFRETPARAM)); }

bool uentry_isReturned ( uentry u )

Definition at line 9015 of file uentry.c. Referenced by checkPassTransfer(), uentryList_hasReturned(), and uentry_returnedRef(). { return (uentry_isValid (u) && uentry_isVar (u) && (u->info->var->kind == VKRETPARAM || u->info->var->kind == VKSEFRETPARAM)); }

bool uentry_isScanfLike ( uentry ue )

Definition at line 2298 of file uentry.c. { return (uentry_isFunction (ue) && (ue->info->fcn->specialCode == SPC_SCANFLIKE)); }

bool uentry_isSefParam ( uentry u )

Definition at line 4693 of file uentry.c. Referenced by uentry_mergeState(), and uentry_setUsed(). { return (uentry_isVariable (u) && (u->info->var->kind == VKSEFPARAM || u->info->var->kind == VKREFSEFPARAM || u->info->var->kind == VKSEFRETPARAM || u->info->var->kind == VKREFSEFRETPARAM)); }

bool uentry_isSpecialFunction ( uentry ue )

Definition at line 2424 of file uentry.c. { return (uentry_isFunction (ue) && (ue->info->fcn->specialCode != SPC_NONE)); }

bool uentry_isSpecified ( uentry e )

Definition at line 4596 of file uentry.c. Referenced by exprNode_fromUIO(), uentry_showWhereAny(), uentry_showWhereDeclared(), uentry_showWhereLast(), uentry_showWhereLastExtra(), uentry_showWhereLastPlain(), uentry_showWhereSpecified(), and uentry_showWhereSpecifiedExtra(). { return (uentry_isValid (e) && !fileloc_isUndefined (e->whereSpecified)); }

bool uentry_isStateSpecial ( uentry u )

Definition at line 4751 of file uentry.c. Referenced by checkPassTransfer(). { return ((uentry_isVariable (u) && (u->info->var->defstate == SS_SPECIAL)) || (uentry_isValid (u) && sRef_isStateSpecial (u->sref))); }

bool uentry_isStructTag ( uentry ue )

Definition at line 3232 of file uentry.c. Referenced by uentry_isAnyTag(). { return (uentry_isValid (ue) && ue->ukind == KSTRUCTTAG); }

bool uentry_isUnchecked ( uentry ue )

Definition at line 2588 of file uentry.c. Referenced by context_checkGlobMod(). { return (uentry_isVar (ue) && (ue->info->var->checked == CH_UNCHECKED)); }

bool uentry_isUnionTag ( uentry ue )

Definition at line 3238 of file uentry.c. Referenced by uentry_isAnyTag(). { return (uentry_isValid (ue) && ue->ukind == KUNIONTAG); }

bool uentry_isUnique ( uentry ue )

Definition at line 2243 of file uentry.c. { return (!uentry_isUndefined (ue) && uentry_isVariable (ue) && alkind_isUnique (sRef_getOrigAliasKind (ue->sref))); }

bool uentry_isVar ( uentry e )

Definition at line 4609 of file uentry.c. Referenced by processNamedDecl(), uentry_checkedName(), uentry_directParamNo(), uentry_isCheckMod(), uentry_isChecked(), uentry_isCheckedModify(), uentry_isCheckedStrict(), uentry_isCheckedUnknown(), uentry_isReturned(), uentry_isUnchecked(), uentry_isVariable(), uentry_sameKind(), uentry_setParam(), uentry_setRefParam(), and usymtab_existsVar(). { return (!uentry_isUndefined (e) && e->ukind == KVAR); }

bool uentry_isVariable ( uentry e )

Definition at line 4590 of file uentry.c. Referenced by checkPrefix(), context_checkExport(), exprChecks_checkExport(), uentryList_dumpFields(), uentry_checkName(), uentry_fixupSref(), uentry_getOrigSref(), uentry_isAnyParam(), uentry_isExpandedMacro(), uentry_isExported(), uentry_isFileStatic(), uentry_isGlobal(), uentry_isNonLocal(), uentry_isOnly(), uentry_isOut(), uentry_isParam(), uentry_isPartial(), uentry_isRealFunction(), uentry_isRefParam(), uentry_isSefParam(), uentry_isStateSpecial(), uentry_isUnique(), uentry_isYield(), uentry_mergeDefinition(), uentry_possiblyNull(), uentry_reflectQualifiers(), uentry_resetParams(), uentry_setDefState(), uentry_setGlobals(), uentry_setMessageLike(), uentry_setModifies(), uentry_setPrintfLike(), uentry_setScanfLike(), uentry_setStatic(), uentry_unparseAbbrev(), uentry_unparseFull(), usymtab_allDefined(), usymtab_checkFinalScope(), usymtab_exitScope(), and usymtab_exportHeader(). { return (uentry_isVar (e)); }

bool uentry_isYield ( uentry ue )

Definition at line 2693 of file uentry.c. Referenced by checkPrefix(), exprNode_assign(), exprNode_iterExpr(), exprNode_iterId(), exprNode_iterNewId(), exprNode_iterStart(), processNamedDecl(), uentry_mergeDefinition(), uentry_setUsed(), and usymtab_allUsed(). { return (uentry_isVariable (ue) && (ue->info->var->kind == VKYIELDPARAM || ue->info->var->kind == VKREFYIELDPARAM)); }

uentry uentry_makeBoolDatatype ( ynm abs )

Definition at line 3039 of file uentry.c. Referenced by usymtab_initBool(). { uentry ret = uentry_makeDatatypeAux (context_getBoolName (), ctype_bool, NO, abs, fileloc_getBuiltin (), FALSE); ret->info->datatype->type = ctype_bool; return ret; }

uentry uentry_makeConstant ( cstring n, ctype t, fileloc f )

Definition at line 2540 of file uentry.c. Referenced by uentry_makeEnumConstant(), uentry_makeEnumInitializedConstant(), uentry_makeIdConstant(), and uentry_makeSpecEnumConstant(). { return (uentry_makeConstantAux (n, t, f, FALSE, multiVal_unknown ())); }

uentry uentry_makeConstantAux ( cstring n, ctype t, fileloc f, bool priv, multiVal m )

Definition at line 2505 of file uentry.c. Referenced by doDeclareConstant(), uentry_makeConstant(), and usymtab_initBool(). { uentry e = uentry_alloc (); e->ukind = KCONST; e->uname = cstring_copy (n); e->utype = t; e->storageclass = SCNONE; e->sref = sRef_makeConst (t); e->lset = FALSE; e->used = FALSE; e->uses = filelocList_new (); e->isPrivate = priv; e->hasNameError = FALSE; e->info = (uinfo) dmalloc (sizeof (*e->info)); e->info->uconst = (ucinfo) dmalloc (sizeof (*e->info->uconst)); e->info->uconst->val = m; e->info->uconst->access = typeIdSet_undefined; uentry_setSpecDef (e, f); if (multiVal_isInt (m) && (multiVal_forceInt (m) == 0)) { sRef_setDefNull (e->sref, uentry_whereDeclared (e)); } return (e); }

uentry uentry_makeDatatype ( cstring n, ctype t, ynm mut, ynm abs, fileloc f )

Definition at line 3033 of file uentry.c. Referenced by o_fctInfo(), and uentry_makeIdDatatype(). { return (uentry_makeDatatypeAux (n, t, mut, abs, f, FALSE)); }

uentry uentry_makeDatatypeAux ( cstring n, ctype t, ynm mut, ynm abs, fileloc f, bool priv )

Definition at line 2987 of file uentry.c. Referenced by uentry_makeBoolDatatype(), and uentry_makeDatatype(). { uentry e = uentry_alloc (); /* e->shallowCopy = FALSE; */ e->ukind = KDATATYPE; e->uname = cstring_copy (n); e->utype = t; e->storageclass = SCNONE; e->sref = sRef_makeUnknown (); if (ctype_isUA (t)) { sRef_setStateFromType (e->sref, t); } uentry_setSpecDef (e, f); e->uses = filelocList_new (); e->isPrivate = priv; e->hasNameError = FALSE; e->used = FALSE; e->lset = FALSE; e->info = (uinfo) dmalloc (sizeof (*e->info)); e->info->datatype = (udinfo) dmalloc (sizeof (*e->info->datatype)); e->info->datatype->abs = abs; e->info->datatype->mut = mut; e->info->datatype->type = ctype_undefined; if (uentry_isDeclared (e)) { uentry_setDefined (e, f); } if (ynm_isOn (abs) && !(uentry_isCodeDefined (e))) { sRef_setNullState (e->sref, NS_ABSNULL, uentry_whereDeclared (e)); } return (e); }

uentry uentry_makeElipsisMarker ( void )

Definition at line 3275 of file uentry.c. Referenced by uentry_undump(). { if (emarker == NULL) { emarker = uentry_alloc (); emarker->ukind = KELIPSMARKER; emarker->uname = cstring_makeLiteral ("..."); emarker->utype = ctype_elipsMarker; emarker->sref = sRef_undefined; emarker->storageclass = SCNONE; emarker->used = FALSE; emarker->lset = FALSE; emarker->info = NULL; uentry_setSpecDef (emarker, fileloc_undefined); emarker->uses = filelocList_new (); emarker->isPrivate = FALSE; emarker->hasNameError = FALSE; } /*@ignore@*/ return (emarker); /*@end@*/ }

uentry uentry_makeEndIter ( cstring n, fileloc f )

Definition at line 3118 of file uentry.c. Referenced by declareIter(). { return (uentry_makeEndIterAux (n, context_fileAccessTypes (), f)); }

uentry uentry_makeEnumConstant ( cstring n, ctype t )

Definition at line 572 of file uentry.c. { fileloc loc = setLocation (); uentry ue = uentry_makeConstant (n, t, loc); ue->ukind = KENUMCONST; uentry_setDefined (ue, loc); return ue; }

uentry uentry_makeEnumInitializedConstant ( cstring n, ctype t, exprNode expr )

Definition at line 582 of file uentry.c. { fileloc loc = setLocation (); uentry ue = uentry_makeConstant (n, t, loc); ctype etype = exprNode_getType (expr); if (!ctype_isRealInt (etype)) { voptgenerror (FLG_ENUMMEMBERS, message ("Value of enum member is not an integeral type (type %s): %s", ctype_unparse (etype), exprNode_unparse (expr)), exprNode_loc (expr)); } ue->ukind = KENUMCONST; uentry_setDefined (ue, loc); return ue; }

uentry uentry_makeEnumTag ( cstring n, ctype t, fileloc loc )

Definition at line 3201 of file uentry.c. { cstring ename = makeEnum (n); uentry ret = uentry_makeTagAux (ename, t, loc, FALSE, KENUMTAG); cstring_free (ename); return ret; }

uentry uentry_makeEnumTagLoc ( cstring n, ctype t )

Definition at line 3222 of file uentry.c. Referenced by declareEnum(), and declareUnnamedEnum(). { cstring ename = makeEnum (n); uentry ret = uentry_makeTagAux (ename, t, setLocation (), FALSE, KENUMTAG); cstring_free (ename); return ret; }

uentry uentry_makeExpandedMacro ( cstring s, fileloc f )

Definition at line 2921 of file uentry.c. { uentry ue = uentry_makeVariableAux (s, ctype_unknown, fileloc_undefined, sRef_undefined, FALSE, VKEXPMACRO); uentry_setDefined (ue, f); return ue; }

uentry uentry_makeForwardFunction ( cstring n, typeId access, fileloc f )

Definition at line 2931 of file uentry.c. { uentry ue = uentry_makeFunctionAux (n, ctype_unknown, typeIdSet_singleOpt (access), globSet_undefined, sRefSet_undefined, fileloc_undefined, FALSE, TRUE); ue->whereDeclared = fileloc_update (ue->whereDeclared, f); return ue; }

uentry uentry_makeFunction ( cstring n, ctype t, typeId access, globSet globs, sRefSet mods, fileloc f )

Definition at line 2879 of file uentry.c. Referenced by uentry_makeIdFunction(). { return (uentry_makeFunctionAux (n, t, ((typeId_isInvalid (access)) ? typeIdSet_emptySet () : typeIdSet_single (access)), globs, mods, f, FALSE, FALSE)); }

uentry uentry_makeIdConstant ( idDecl t )

Definition at line 2545 of file uentry.c. Referenced by checkConstant(), and checkValueConstant(). { uentry ue = uentry_makeConstant (idDecl_observeId (t), idDecl_getCtype (t), fileloc_undefined); llassert (fileloc_isUndefined (ue->whereDeclared)); ue->whereDeclared = setLocation (); uentry_reflectQualifiers (ue, idDecl_getQuals (t)); return ue; }

uentry uentry_makeIdDatatype ( idDecl id )

Definition at line 624 of file uentry.c. Referenced by processNamedDecl(). { ctype ct = idDecl_getCtype (id); uentry ue = uentry_makeDatatype (idDecl_observeId (id), ct, MAYBE, MAYBE, setLocation ()); uentry_reflectQualifiers (ue, idDecl_getQuals (id)); if (!ynm_isOn (ue->info->datatype->abs)) { if (ctype_isUnknown (ct)) { ue->info->datatype->mut = MAYBE; } else { ue->info->datatype->mut = ynm_fromBool (ctype_isMutable (ct)); } } return ue; }

uentry uentry_makeIdFunction ( idDecl id )

Definition at line 868 of file uentry.c. Referenced by declareStaticFunction(), processNamedDecl(), and uentry_makeIdVariable(). { uentry ue = uentry_makeFunction (idDecl_observeId (id), idDecl_getCtype (id), typeId_invalid, globSet_undefined, sRefSet_undefined, setLocation ()); uentry_reflectQualifiers (ue, idDecl_getQuals (id)); reflectImplicitFunctionQualifiers (ue, FALSE); if (!uentry_isStatic (ue) && cstring_equalLit (ue->uname, "main")) { ctype typ = ue->utype; ctype retval; uentryList args; llassert (ctype_isFunction (typ)); retval = ctype_returnValue (typ); if (!ctype_isInt (retval)) { voptgenerror (FLG_MAINTYPE, message ("Function main declared to return %s, should return int", ctype_unparse (retval)), uentry_whereDeclared (ue)); } args = ctype_argsFunction (typ); if (uentryList_isMissingParams (args) || uentryList_size (args) == 0) { ; } else { if (uentryList_size (args) != 2) { voptgenerror (FLG_MAINTYPE, message ("Function main declared with %d arg%p, " "should have 2 (int argc, char *argv[])", uentryList_size (args)), uentry_whereLast (ue)); } else { uentry arg = uentryList_getN (args, 0); ctype ct = uentry_getType (arg); if (!ctype_isInt (ct)) { voptgenerror (FLG_MAINTYPE, message ("Parameter 1, %q, of function main declared " "with type %t, should have type int", uentry_getName (arg), ct), uentry_whereDeclared (arg)); } arg = uentryList_getN (args, 1); ct = uentry_getType (arg); if (ctype_isArrayPtr (ct) && ctype_isArrayPtr (ctype_baseArrayPtr (ct)) && ctype_isChar (ctype_baseArrayPtr (ctype_baseArrayPtr (ct)))) { ; } else { voptgenerror (FLG_MAINTYPE, message ("Parameter 2, %q, of function main declared " "with type %t, should have type char **", uentry_getName (arg), ct), uentry_whereDeclared (arg)); } } } } return ue; }

uentry uentry_makeIdVariable ( idDecl t )

Definition at line 2469 of file uentry.c. Referenced by fixUentryList(), and processNamedDecl(). { ctype ct = idDecl_getCtype (t); if (ctype_isFunction (ct)) { return (uentry_makeIdFunction (t)); } else { fileloc loc = setLocation (); uentry ue = uentry_makeVariable (idDecl_observeId (t), ct, loc, FALSE); uentry_reflectQualifiers (ue, idDecl_getQuals (t)); if (!uentry_isExtern (ue)) { uentry_setDefined (ue, loc); } return ue; } }

uentry uentry_makeIter ( cstring n, ctype ct, fileloc f )

Definition at line 3084 of file uentry.c. Referenced by declareCIter(), and declareIter(). { return (uentry_makeIterAux (n, context_fileAccessTypes (), ct, f)); }

uentry uentry_makeParam ( idDecl t, int i )

Definition at line 2430 of file uentry.c. Referenced by exprNode_initMod(), makeCurrentParam(), and processNamedDecl(). { ctype ct = idDecl_getCtype (t); ctype base = ct; sRef pref = sRef_makeParam (i, ct); uentry ue = uentry_makeVariableSrefParam (idDecl_observeId (t), ct, pref); uentry_reflectQualifiers (ue, idDecl_getQuals (t)); uentry_implicitParamAnnots (ue); /* Parameter type [][] or [x][] is invalid */ while (ctype_isFixedArray (base)) { base = ctype_baseArrayPtr (base); } if (ctype_isIncompleteArray (base)) { base = ctype_baseArrayPtr (base); if (ctype_isArray (base)) { if (!uentry_hasName (ue)) { (void) optgenerror (FLG_INCOMPLETETYPE, message ("Unnamed function parameter %d is incomplete type (inner array must have bounds): %s", i + 1, ctype_unparse (ct)), uentry_whereLast (ue)); } else { (void) optgenerror (FLG_INCOMPLETETYPE, message ("Function parameter %q is incomplete type (inner array must have bounds): %s", uentry_getName (ue), ctype_unparse (ct)), uentry_whereLast (ue)); } } } return ue; }

uentry uentry_makePrivFunction2 ( cstring n, ctype t, typeIdSet access, globSet globs, sRefSet mods, fileloc f )

Definition at line 2893 of file uentry.c. { return (uentry_makeFunctionAux (n, t, access, globs, mods, f, TRUE, FALSE)); }

uentry uentry_makeSpecEnumConstant ( cstring n, ctype t, fileloc loc )

Definition at line 603 of file uentry.c. { uentry ue = uentry_makeConstant (n, t, loc); ue->ukind = KENUMCONST; return ue; }

uentry uentry_makeSpecFunction ( cstring n, ctype t, typeIdSet access, globSet globs, sRefSet mods, fileloc f )

Definition at line 2903 of file uentry.c. { uentry ue = uentry_makeFunctionAux (n, t, access, globs, mods, f, FALSE, FALSE); uentry_setHasGlobs (ue); uentry_setHasMods (ue); reflectImplicitFunctionQualifiers (ue, TRUE); return (ue); }

uentry uentry_makeStructTag ( cstring n, ctype t, fileloc loc )

Definition at line 3180 of file uentry.c. Referenced by ctype_createForwardStruct(). { cstring sname = makeStruct (n); uentry ret = uentry_makeTagAux (sname, t, loc, FALSE, KSTRUCTTAG); cstring_free (sname); return ret; }

uentry uentry_makeStructTagLoc ( cstring n, ctype t )

Definition at line 3170 of file uentry.c. Referenced by ctype_createUnnamedStruct(), and declareStruct(). { cstring sname = makeStruct (n); uentry ret = uentry_makeTagAux (sname, t, setLocation (), FALSE, KSTRUCTTAG); cstring_free (sname); return (ret); }

uentry uentry_makeTypeListFunction ( cstring n, typeIdSet access, fileloc f )

Definition at line 2959 of file uentry.c. { return (uentry_makeFunctionAux (n, ctype_unknown, access, globSet_new (), sRefSet_new (), f, FALSE, TRUE)); }

uentry uentry_makeUnionTag ( cstring n, ctype t, fileloc loc )

Definition at line 3190 of file uentry.c. Referenced by ctype_createForwardUnion(). { cstring uname = makeUnion (n); uentry ret = uentry_makeTagAux (uname, t, loc, FALSE, KUNIONTAG); cstring_free (uname); return (ret); }

uentry uentry_makeUnionTagLoc ( cstring n, ctype t )

Definition at line 3212 of file uentry.c. Referenced by ctype_createUnnamedUnion(), and declareUnion(). { cstring uname = makeUnion (n); uentry ret = uentry_makeTagAux (uname, t, setLocation (), FALSE, KUNIONTAG); cstring_free (uname); return ret; }

uentry uentry_makeUnnamedVariable ( ctype t )

Definition at line 618 of file uentry.c. { return uentry_makeVariable (cstring_undefined, t, setLocation (), FALSE); }

uentry uentry_makeUnrecognized ( cstring c, fileloc loc )

Definition at line 9400 of file uentry.c. Referenced by coerceId(). { uentry ue; fileloc tloc; /* ** Can't but unrecognized ids in macros in global scope, because srefs will break! */ if (!context_inMacro ()) { sRef_setGlobalScopeSafe (); } ue = uentry_makeVariable (c, ctype_unknown, loc, FALSE); uentry_setUsed (ue, loc); tloc = fileloc_createExternal (); uentry_setDefined (ue, tloc); fileloc_free (tloc); uentry_setHasNameError (ue); if (context_getFlag (FLG_REPEATUNRECOG)) { uentry_markOwned (ue); } else { ue = usymtab_supReturnFileEntry (ue); } if (!context_inMacro ()) { sRef_clearGlobalScopeSafe (); } return ue; }

uentry uentry_makeUnspecFunction ( cstring n, ctype t, typeIdSet access, fileloc f )

Definition at line 2968 of file uentry.c. { uentry ue = uentry_makeFunctionAux (n, t, access, globSet_new (), sRefSet_new (), f, FALSE, TRUE); reflectImplicitFunctionQualifiers (ue, TRUE); return ue; }

void uentry_makeVarFunction ( uentry ue )

Definition at line 2717 of file uentry.c. Referenced by uentry_resetParams(), uentry_setGlobals(), uentry_setMessageLike(), uentry_setModifies(), uentry_setPrintfLike(), and uentry_setScanfLike(). { alkind ak; exkind ek; uvinfo oldInfo; fileloc loc; llassert (uentry_isValid (ue)); llassert (!sRef_modInFunction ()); ak = sRef_getOrigAliasKind (ue->sref); ek = sRef_getOrigExKind (ue->sref); oldInfo = ue->info->var; llassert (ctype_isUnknown (ue->utype) || ctype_isFunction (ue->utype)); /* ** expanded macro is marked used (until I write a pre-processor) */ ue->used |= (oldInfo->kind == VKEXPMACRO); ue->ukind = KFCN; ue->info->fcn = (ufinfo) dmalloc (sizeof (*ue->info->fcn)); ue->info->fcn->exitCode = XK_UNKNOWN; ue->info->fcn->nullPred = QU_UNKNOWN; ue->info->fcn->specialCode = SPC_NONE; ue->info->fcn->access = typeIdSet_undefined; ue->info->fcn->hasGlobs = FALSE; ue->info->fcn->globs = globSet_undefined; ue->info->fcn->hasMods = FALSE; ue->info->fcn->mods = sRefSet_undefined; ue->info->fcn->specclauses = NULL; ue->info->fcn->defparams = uentryList_undefined; if (ctype_isFunction (ue->utype)) { ue->sref = sRef_makeType (ctype_returnValue (ue->utype)); } else { ue->sref = sRef_makeType (ctype_unknown); } if (sRef_isRefCounted (ue->sref)) { ak = AK_NEWREF; } else { if (alkind_isUnknown (ak)) { if (exkind_isKnown (ek)) { ak = AK_IMPDEPENDENT; } else { if (context_getFlag (FLG_RETIMPONLY)) { if (ctype_isFunction (ue->utype) && ctype_isVisiblySharable (ctype_realType (ctype_returnValue (ue->utype)))) { if (uentryList_hasReturned (uentry_getParams (ue))) { ; } else { ak = AK_IMPONLY; } } } } } } loc = ue->whereDeclared; sRef_setAliasKind (ue->sref, ak, loc); sRef_setNullState (ue->sref, oldInfo->nullstate, loc); sRef_setDefState (ue->sref, oldInfo->defstate, loc); sRef_setExKind (ue->sref, ek, loc); if (oldInfo->kind == VKEXPMACRO) { fileloc_free (loc); ue->whereDeclared = fileloc_undefined; } else { fileloc_free (ue->whereDefined); ue->whereDefined = fileloc_undefined; } uvinfo_free (oldInfo); }

uentry uentry_makeVariable ( cstring n, ctype t, fileloc f, bool isPriv )

Definition at line 2707 of file uentry.c. Referenced by doDeclareVar(), exprNode_initMod(), exprNode_iterId(), exprNode_iterNewId(), o_fctInfo(), uentry_makeIdVariable(), uentry_makeUnnamedVariable(), uentry_makeUnrecognized(), and uentry_makeVariableLoc(). { return (uentry_makeVariableAux (n, t, f, sRef_makeType (t), isPriv, fileloc_isSpec (f) ? VKSPEC : VKNORMAL)); }

uentry uentry_makeVariableLoc ( cstring n, ctype t )

Definition at line 612 of file uentry.c. Referenced by declareFunction(), declareStaticFunction(), doVaDcl(), exprNode_iterNewId(), and usymtab_getParam(). { return uentry_makeVariable (n, t, setLocation (), FALSE); }

uentry uentry_makeVariableParam ( cstring n, ctype t )

Definition at line 2494 of file uentry.c. { return (uentry_makeVariableParamAux (n, t, sRef_makeType (t), SS_DEFINED)); }

uentry uentry_makeVariableSrefParam ( cstring n, ctype t, sRef s )

Definition at line 1111 of file uentry.c. Referenced by doVaDcl(), and uentry_makeParam(). { return (uentry_makeVariableParamAux (n, t, s, SS_UNKNOWN)); }

void uentry_markFree ( uentry u )

Definition at line 3919 of file uentry.c. { /* should save u */ /*@-mustfree@*/ }

void uentry_markOwned ( uentry u )

Definition at line 5847 of file uentry.c. Referenced by exprNode_iterNewId(), uentry_makeUnrecognized(), and usymtab_getParam(). { sfreeEventually (u); }

void uentry_mergeConstantValue ( uentry ue, multiVal m )

Definition at line 7489 of file uentry.c. Referenced by checkValueConstant(), and exprNode_checkMacroBody(). { multiVal uval; llassert (uentry_isValid (ue)); llassert (uentry_isEitherConstant (ue)); uval = ue->info->uconst->val; if (multiVal_isDefined (uval)) { if (multiVal_isDefined (m)) { if (!multiVal_equiv (uval, m)) { if (optgenerror (FLG_INCONDEFS, message ("%s %q defined with inconsistent value: %q", ekind_capName (ue->ukind), uentry_getName (ue), multiVal_unparse (m)), g_currentloc)) { uentry_showWhereLastExtra (ue, multiVal_unparse (uval)); } } } multiVal_free (m); } else { ue->info->uconst->val = m; multiVal_free (uval); } }

void uentry_mergeDefinition ( uentry old, uentry unew )

Definition at line 8241 of file uentry.c. { fileloc olddef = uentry_whereDeclared (old); fileloc unewdef = uentry_whereDeclared (unew); bool mustConform; bool wasForward; if (uentry_isExtern (unew)) { uentry_setUsed (old, unewdef); } wasForward = fileloc_isUndefined (olddef) && fileloc_isDefined (uentry_whereDefined (old)) && !uentry_isExpandedMacro (old); if (!context_getFlag (FLG_INCONDEFSLIB) && (fileloc_isLib (olddef) || fileloc_isImport (olddef))) { mustConform = FALSE; } else { mustConform = TRUE; } llassert (uentry_isValid (old)); llassert (uentry_isValid (unew)); llassert (cstring_equal (old->uname, unew->uname)); /* ** should check old one was extern! */ if (uentry_isStatic (old)) { if (!(uentry_isStatic (unew))) { if (optgenerror (FLG_SHADOW, message ("%s %q shadows static declaration", ekind_capName (unew->ukind), uentry_getName (unew)), unewdef)) { uentry_showWhereLast (old); } } else { uentry_setDeclDef (old, unewdef); } } else if (uentry_isStatic (unew)) { uentry_setDeclDef (old, unewdef); } else if (uentry_isExtern (old)) { uentry_setDeclared (old, unewdef); } else { if (!uentry_isExtern (unew) && !uentry_isForward (old) && !fileloc_equal (olddef, unewdef) && !fileloc_isUndefined (olddef) && !fileloc_isUndefined (unewdef) && !fileloc_isBuiltin (olddef) && !fileloc_isBuiltin (unewdef) && !uentry_isYield (old) && !(fileloc_isLib (olddef) || fileloc_isImport (olddef))) { if (uentry_isVariable (old) || uentry_isVariable (unew)) { ; /* will report redeclaration error later */ } else { if (fileloc_isDefined (uentry_whereDefined (old))) { if (optgenerror (FLG_REDEF, message ("%s %q defined more than once", ekind_capName (unew->ukind), uentry_getName (unew)), uentry_whereLast (unew))) { llgenindentmsg (message ("Previous definition of %q", uentry_getName (old)), uentry_whereLast (old)); } /* if (uentry_isDatatype (old) || uentry_isAnyTag (old)) { uentry_copyInto (old, unew); old->sref = sRef_saveCopy (old->sref); } */ } } } else { if (fileloc_isLib (olddef) || fileloc_isUndefined (olddef) || fileloc_isImport (olddef)) { if (uentry_isExtern (unew)) { if (uentry_isExtern (old) || (fileloc_isDefined (uentry_whereDeclared (old)) && (!fileloc_equal (uentry_whereDeclared (old), uentry_whereDefined (old))))) { if (optgenerror (FLG_REDECL, message ("%s %q declared more than once", ekind_capName (unew->ukind), uentry_getName (unew)), unew->whereDeclared)) { llgenindentmsg (message ("Previous declaration of %q", uentry_getName (old)), old->whereDeclared); } } uentry_setExtern (old); } else { uentry_setDefined (old, unewdef); } } } } uentry_checkConformance (old, unew, mustConform, FALSE); old->used = old->used || unew->used; old->uses = filelocList_append (old->uses, unew->uses); unew->uses = filelocList_undefined; sRef_storeState (old->sref); sRef_storeState (unew->sref); if (wasForward) { old->whereDefined = fileloc_update (old->whereDefined, fileloc_undefined); } /* ** No redeclaration errors for functions here, since we ** don't know if this is the definition of the function. */ if (fileloc_isUser (old->whereDeclared) && fileloc_isUser (unew->whereDeclared) && !fileloc_equal (old->whereDeclared, unew->whereDeclared) && !fileloc_isDefined (unew->whereDefined)) { if (uentry_isFunction (old)) { /*@-temptrans@*/ posRedeclared = old; /*@=temptrans@*/ posLoc = fileloc_update (posLoc, unew->whereDeclared); } else { if (optgenerror (FLG_REDECL, message ("%s %q declared more than once", ekind_capName (unew->ukind), uentry_getName (unew)), unew->whereDeclared)) { llgenindentmsg (message ("Previous declaration of %q", uentry_getName (old)), old->whereDeclared); } } } if (fileloc_isUndefined (old->whereDefined)) { old->whereDefined = fileloc_update (old->whereDefined, unew->whereDefined); } else { if (!context_processingMacros () && fileloc_isUser (old->whereDefined) && fileloc_isUser (unew->whereDefined) && !fileloc_equal (old->whereDefined, unew->whereDefined)) { if (uentry_isVariable (unew) || uentry_isFunction (unew)) { if (uentry_isVariable (unew) && uentry_isExtern (unew)) { if (optgenerror (FLG_REDECL, message ("%s %q declared after definition", ekind_capName (unew->ukind), uentry_getName (unew)), unew->whereDeclared)) { llgenindentmsg (message ("Definition of %q", uentry_getName (old)), old->whereDefined); } } else { if (optgenerror (FLG_REDEF, message ("%s %q redefined", ekind_capName (unew->ukind), uentry_getName (unew)), unew->whereDefined)) { llgenindentmsg (message ("Previous definition of %q", uentry_getName (old)), old->whereDefined); } } } } } if (uentry_isExternal (unew)) { old->whereDefined = fileloc_createExternal (); } if (unew->hasNameError) { old->hasNameError = TRUE; } uentry_free (unew); if (!old->hasNameError) { uentry_checkName (old); } llassert (!ctype_isUndefined (old->utype)); }

void uentry_mergeEntries ( uentry spec, uentry def )

Definition at line 8129 of file uentry.c. { llassert (uentry_isValid (spec)); llassert (uentry_isValid (def)); llassert (cstring_equal (spec->uname, def->uname)); uentry_checkConformance (spec, def, TRUE, context_getFlag (FLG_NEEDSPEC)); /* was: !(fileloc_isImport (uentry_whereSpecified (spec)))); */ /* ** okay, declarations conform. Propagate extra information. */ uentry_setDefined (spec, uentry_whereDefined (def)); uentry_setDeclared (spec, uentry_whereDeclared (def)); if (uentry_isStatic (def)) { if (optgenerror (FLG_INCONDEFS, message ("%s %q specified, but declared as static", ekind_capName (def->ukind), uentry_getName (def)), uentry_whereDeclared (def))) { uentry_showWhereSpecified (spec); } } else { spec->storageclass = def->storageclass; } sRef_storeState (spec->sref); spec->used = def->used || spec->used; spec->hasNameError |= def->hasNameError; uentry_free (def); if (!spec->hasNameError) { uentry_checkName (spec); } else { ; } }

void uentry_mergeState ( uentry res, uentry other, fileloc loc, bool mustReturn, bool flip, bool opt, clause cl )

Definition at line 8717 of file uentry.c. Referenced by usymtab_exitSwitch(), usymtab_newCase(), usymtab_popAndBranch(), usymtab_popBranches(), usymtab_popOrBranch(), and usymtab_quietExitScope(). { llassert (uentry_isValid (res)); llassert (uentry_isValid (other)); llassert (res->ukind == other->ukind); llassert (res->ukind == KVAR); DPRINTF (("Merge state: %s / %s", uentry_unparse (res), uentry_unparse (other))); if (sRef_isValid (res->sref)) { if (!mustReturn) { if (incompatibleStates (res->sref, other->sref)) { if (sRef_isThroughArrayFetch (res->sref) && !context_getFlag (FLG_STRICTBRANCHSTATE)) { if (sRef_isKept (res->sref) || sRef_isKept (other->sref)) { sRef_maybeKill (res->sref, loc); } else if (sRef_isPossiblyDead (other->sref)) { sRef_maybeKill (res->sref, loc); } else { ; } } else { if (notNull (other->sref, flip)) { if (sRef_isLocalParamVar (res->sref) && (sRef_isLocalState (other->sref) || sRef_isDependent (other->sref))) { if (sRef_isDependent (res->sref)) { sRef_setDependent (other->sref, loc); } else { sRef_setDefState (res->sref, SS_UNUSEABLE, loc); } } else { branchStateError (res, other, flip, cl, loc); } } } if (sRef_isKept (res->sref)) { sRef_setKept (other->sref, loc); } } else { if (incompatibleStates (other->sref, res->sref)) { if (notNull (res->sref, !flip)) { if (sRef_isLocalParamVar (res->sref) && (sRef_isDependent (res->sref) || sRef_isLocalState (res->sref))) { if (sRef_isDependent (other->sref)) { sRef_setDependent (res->sref, loc); } else { sRef_setDefState (res->sref, SS_UNUSEABLE, loc); } } else { if (sRef_isParam (other->sref)) { /* ** If the local variable associated ** with the param has the correct state, ** its okay. ** (e.g., free (s); s = new(); ... */ uentry uvar = usymtab_lookupSafe (other->uname); if (uentry_isValid (uvar) && ((sRef_isDead (other->sref) && sRef_isOnly (uvar->sref)) || (sRef_isDependent (other->sref) && sRef_isOwned (uvar->sref)))) { /* no error */ } else { branchStateAltError (res, other, flip, cl, loc); } } else { branchStateAltError (res, other, flip, cl, loc); } } } } if (sRef_isKept (other->sref)) { sRef_setKept (res->sref, loc); } } if (opt) { DPRINTF (("Merge opt...")); sRef_mergeOptState (res->sref, other->sref, cl, loc); DPRINTF (("Done!")); } else { sRef_mergeState (res->sref, other->sref, cl, loc); } } else { if (sRef_isModified (other->sref)) { sRef_setModified (res->sref); } } if (cl == DOWHILECLAUSE) { res->used = other->used || res->used; res->lset = other->lset || res->lset; res->uses = filelocList_append (res->uses, other->uses); other->uses = filelocList_undefined; } else { if (sRef_isMacroParamRef (res->sref) && !uentry_isSefParam (other) && !uentry_isSefParam (res)) { bool hasError = FALSE; if (bool_equal (res->used, other->used)) { res->used = other->used; } else { if (other->used && !flip) { hasError = optgenerror (FLG_MACROPARAMS, message ("Macro parameter %q used in true clause, " "but not in false clause", uentry_getName (res)), uentry_whereDeclared (res)); } else { hasError = optgenerror (FLG_MACROPARAMS, message ("Macro parameter %q used in false clause, " "but not in true clause", uentry_getName (res)), uentry_whereDeclared (res)); } res->used = TRUE; if (hasError) { /* make it sef now, prevent more errors */ res->info->var->kind = VKREFSEFPARAM; } } } else { res->used = other->used || res->used; res->lset = other->lset || res->lset; res->uses = filelocList_append (res->uses, other->uses); other->uses = filelocList_undefined; } } } }

void uentry_mergeUses ( uentry res, uentry other )

Definition at line 8596 of file uentry.c. Referenced by usymtab_exitSwitch(), and usymtab_popBranches(). { llassert (uentry_isValid (res)); llassert (uentry_isValid (other)); res->used = other->used || res->used; res->lset = other->lset || res->lset; res->uses = filelocList_append (res->uses, other->uses); other->uses = filelocList_undefined; }

uentry uentry_nameCopy ( cstring name, uentry e )

Definition at line 5600 of file uentry.c. Referenced by usymtab_load(). { uentry enew = uentry_alloc (); llassert (uentry_isValid (e)); /* enew->shallowCopy = FALSE; */ enew->ukind = e->ukind; enew->uname = name; enew->utype = e->utype; enew->whereSpecified = fileloc_copy (e->whereSpecified); enew->whereDefined = fileloc_copy (e->whereDefined); enew->whereDeclared = fileloc_copy (e->whereDeclared); enew->sref = sRef_copy (e->sref); enew->used = e->used; enew->lset = FALSE; enew->isPrivate = e->isPrivate; enew->hasNameError = FALSE; enew->uses = filelocList_new (); enew->storageclass = e->storageclass; enew->info = uinfo_copy (e->info, e->ukind); return enew; }

qual uentry_nullPred ( uentry u )

Definition at line 4771 of file uentry.c. { llassert (uentry_isRealFunction (u)); if (uentry_isFunction (u)) { return (u->info->fcn->nullPred); } else { return QU_UNKNOWN; } }

bool uentry_possiblyNull ( uentry u )

Definition at line 4786 of file uentry.c. { return ((uentry_isVariable (u) && (nstate_possiblyNull (u->info->var->nullstate))) || (uentry_isDatatype (u) && (sRef_possiblyNull (u->sref)))); }

cstring uentry_rawName ( uentry e )

Definition at line 4952 of file uentry.c. Referenced by checkModifiesId(), checkSpecClausesId(), context_inFunctionName(), exprNode_checkAllMods(), uentryList_compareFields(), uentryList_matchFields(), uentryList_showFieldDifference(), usymtab_convertId(), usymtab_dump(), and usymtab_popBranches(). { if (uentry_isValid (e)) { return (e->uname); } else { return cstring_undefined; } }

void uentry_reflectQualifiers ( uentry ue, qualList q )

Definition at line 1970 of file uentry.c. Referenced by doDeclareConstant(), doDeclareVar(), processNamedDecl(), uentry_makeIdConstant(), uentry_makeIdDatatype(), uentry_makeIdFunction(), uentry_makeIdVariable(), and uentry_makeParam(). { llassert (uentry_isValid (ue)); qualList_elements (q, qel) { if (qual_isStatic (qel)) { uentry_setStatic (ue); } else if (qual_isUnused (qel)) { uentry_setUsed (ue, fileloc_undefined); } else if (qual_isExternal (qel)) { fileloc_free (ue->whereDefined); ue->whereDefined = fileloc_createExternal (); } else if (qual_isSef (qel)) { if (uentry_isVariable (ue)) { vkind vk = ue->info->var->kind; llassert (vk != VKREFPARAM); if (vk == VKYIELDPARAM) { llerror (FLG_SYNTAX, message ("Qualifier sef cannot be used with %s: %q", cstring_makeLiteralTemp (vk == VKYIELDPARAM ? "yield" : "returned"), uentry_unparse (ue))); } else if (vk == VKRETPARAM) { ue->info->var->kind = VKSEFRETPARAM; } else { ue->info->var->kind = VKSEFPARAM; } } else { llerror (FLG_SYNTAX, message ("Qualifier sef is meaningful only on parameters: %q", uentry_unparse (ue))); } } else if (qual_isExtern (qel)) { ue->storageclass = SCEXTERN; } else if (qual_isGlobalQual (qel)) /* undef, killed */ { if (uentry_isVariable (ue)) { sstate oldstate = ue->info->var->defstate; sstate defstate = sstate_fromQual (qel); if ((oldstate == SS_UNDEFGLOB && defstate == SS_KILLED) || (oldstate == SS_KILLED && defstate == SS_UNDEFGLOB)) { defstate = SS_UNDEFKILLED; } else { ; /* any errors? */ } sRef_setDefState (ue->sref, defstate, fileloc_undefined); ue->info->var->defstate = defstate; } else { llerror (FLG_SYNTAX, message ("Qualifier %s used on non-variable: %q", qual_unparse (qel), uentry_unparse (ue))); } } else if (qual_isAllocQual (qel)) /* out, partial, reldef, special, etc. */ { ctype realType = ctype_realType (ue->utype); sstate defstate = sstate_fromQual (qel); if (ctype_isFunction (realType)) { realType = ctype_realType (ctype_returnValue (realType)); } if (qual_isRelDef (qel)) { ; /* okay anywhere */ } else { if (!ctype_isAP (realType) && !ctype_isSU (realType) && !ctype_isUnknown (realType) && !ctype_isAbstract (ue->utype)) { llerror (FLG_SYNTAX, message ("Qualifier %s used on non-pointer or struct: %q", qual_unparse (qel), uentry_unparse (ue))); } } uentry_setDefState (ue, defstate); if (sRef_isStateSpecial (ue->sref) && alkind_isImplicit (sRef_getAliasKind (ue->sref))) { sRef_setAliasKind (ue->sref, AK_ERROR, fileloc_undefined); } } else if (qual_isYield (qel)) { if (uentry_isVariable (ue)) { ue->info->var->kind = VKYIELDPARAM; } else { llerror (FLG_SYNTAX, message ("Qualifier %s used on non-iterator parameter: %q", qual_unparse (qel), uentry_unparse (ue))); } } else if (qual_isExQual (qel)) { exkind ek = exkind_fromQual (qel); ctype ut = uentry_getType (ue); if (ctype_isFunction (ut)) { ut = ctype_returnValue (ut); } if (!(ctype_isVisiblySharable (ut)) && !(ctype_isArray (ut)) /* can apply to arrays also! */ && !(ctype_isStruct (ctype_realType (ut)))) /* applies to structure fields! */ { if (!qual_isImplied (qel)) { llerror (FLG_SYNTAX, message ("Qualifier %s used on unsharable storage type %t: %q", exkind_unparse (ek), ut, uentry_getName (ue))); } } else { alkind ak = sRef_getAliasKind (ue->sref); sRef_setExKind (ue->sref, ek, uentry_whereDeclared (ue)); if (alkind_isUnknown (ak) || alkind_isImplicit (ak) || alkind_isStatic (ak)) { if (!alkind_isTemp (ak)) { uentry_setAliasKind (ue, AK_IMPDEPENDENT); } } else if (alkind_isDependent (ak) || alkind_isTemp (ak) || alkind_isOwned (ak)) { ; /* okay */ } else { llerror (FLG_SYNTAX, message ("Exposure qualifier %s used on %s storage (should " "be dependent): %q", qual_unparse (qel), alkind_unparse (ak), uentry_unparse (ue))); } } } else if (qual_isGlobCheck (qel)) { if (uentry_isVariable (ue)) { chkind ch = chkind_fromQual (qel); if (ue->info->var->checked != CH_UNKNOWN) { if (ch == ue->info->var->checked) { llerror (FLG_SYNTAX, message ("Redundant %s qualifier on %q", qual_unparse (qel), uentry_getName (ue))); } else { llerror (FLG_SYNTAX, message ("Contradictory %s and %s qualifiers on %q", qual_unparse (qel), checkedName (ue->info->var->checked), uentry_getName (ue))); } } ue->info->var->checked = ch; } else { llerror (FLG_SYNTAX, message ("Qualifier %s used with non-variable", qual_unparse (qel))); } } else if (qual_isReturned (qel)) { if (uentry_isVariable (ue)) { ue->info->var->kind = VKRETPARAM; } else { llerror (FLG_SYNTAX, message ("Qualifier %s used with non-variable", qual_unparse (qel))); } } else { uentry_reflectOtherQualifier (ue, qel); } sRef_storeState (ue->sref); } end_qualList_elements; qualList_clear (q); }

void uentry_resetParams ( uentry ue, uentryList pn )

Definition at line 5341 of file uentry.c. { ctype rct; ctype rettype = ctype_unknown; llassert (uentry_isValid (ue)); rct = ctype_realType (ue->utype); if (uentry_isVariable (ue) && (ctype_isFunction (rct) || ctype_isUnknown (rct))) { uentry_makeVarFunction (ue); } llassert (uentry_isFunction (ue)); if (ctype_isFunction (rct)) { rettype = ctype_returnValue (rct); } ue->utype = ctype_makeNFParamsFunction (rettype, pn); }

sRef uentry_returnedRef ( uentry u, exprNodeList args )

Definition at line 9022 of file uentry.c. { llassert (uentry_isRealFunction (u)); if (ctype_isFunction (u->utype) && sRef_isStateSpecial (uentry_getSref (u))) { specialClauses clauses = uentry_getSpecialClauses (u); sRef res = sRef_makeNew (ctype_returnValue (u->utype), u->sref, u->uname); sRef_setAllocated (res, g_currentloc); specialClauses_postElements (clauses, cl) { sRefSet refs = specialClause_getRefs (cl); sRefMod modf = specialClause_getEffectFunction (cl); sRefSet_elements (refs, el) { sRef base = sRef_getRootBase (el); if (sRef_isResult (base)) { if (modf != NULL) { sRef sr = sRef_fixBase (el, res); modf (sr, g_currentloc); } } else { ; } } end_sRefSet_elements ; } end_specialClauses_postElements ; return res; } else { uentryList params; alkind ak; sRefSet prefs = sRefSet_new (); sRef res = sRef_undefined; int paramno = 0; params = uentry_getParams (u); uentryList_elements (params, current) { if (uentry_isReturned (current)) { if (exprNodeList_size (args) >= paramno) { exprNode ecur = exprNodeList_nth (args, paramno); sRef tref = exprNode_getSref (ecur); if (sRef_isValid (tref)) { sRef tcref = sRef_copy (tref); if (sRef_isDead (tcref)) { sRef_setDefined (tcref, g_currentloc); sRef_setOnly (tcref, g_currentloc); } if (sRef_isRefCounted (tcref)) { /* could be a new ref now (but only if its returned) */ sRef_setAliasKindComplete (tcref, AK_ERROR, g_currentloc); } sRef_makeSafe (tcref); prefs = sRefSet_insert (prefs, tcref); } } } paramno++; } end_uentryList_elements ; if (sRefSet_size (prefs) > 0) { nstate n = sRef_getNullState (u->sref); if (sRefSet_size (prefs) == 1) { res = sRefSet_choose (prefs); } else { res = sRefSet_mergeIntoOne (prefs); } if (nstate_isKnown (n)) { sRef_setNullState (res, n, g_currentloc); } } else { if (ctype_isFunction (u->utype)) { res = sRef_makeNew (ctype_returnValue (u->utype), u->sref, u->uname); } else { res = sRef_makeNew (ctype_unknown, u->sref, u->uname); } if (sRef_isRefCounted (res)) { sRef_setAliasKind (res, AK_NEWREF, g_currentloc); } } if (sRef_getNullState (res) == NS_ABSNULL) { ctype ct = ctype_realType (u->utype); if (ctype_isAbstract (ct)) { sRef_setNotNull (res, g_currentloc); } else { if (ctype_isUser (ct)) { sRef_setStateFromUentry (res, usymtab_getTypeEntry (ctype_typeId (ct))); } else { sRef_setNotNull (res, g_currentloc); } } } if (sRef_isRefCounted (res)) { sRef_setAliasKind (res, AK_NEWREF, g_currentloc); } else if (sRef_isKillRef (res)) { sRef_setAliasKind (res, AK_REFCOUNTED, g_currentloc); } else { ; } ak = sRef_getAliasKind (res); if (alkind_isImplicit (ak)) { sRef_setAliasKind (res, alkind_fixImplicit (ak), g_currentloc); } sRefSet_free (prefs); return res; } }

bool uentry_sameKind ( uentry u1, uentry u2 )

Definition at line 8507 of file uentry.c. { if (uentry_isValid (u1) && uentry_isValid (u2)) { if (uentry_isVar (u1) && uentry_isVar (u2)) { ctype c1 = u1->utype; ctype c2 = u2->utype; if (ctype_isUnknown (c1) || ctype_isUnknown (c2)) return FALSE; /* ** both functions, or both not functions */ return (bool_equal (ctype_isFunction (c1), ctype_isFunction (c2))); } else { return ((u1->ukind == u2->ukind)); } } return FALSE; }

void uentry_setAbstract ( uentry e )

Definition at line 4629 of file uentry.c. Referenced by processNamedDecl(). { typeId oldid; llassert (uentry_isDatatype (e) && (ynm_isMaybe (e->info->datatype->abs))); oldid = ctype_typeId (e->info->datatype->type); e->info->datatype->abs = YES; e->info->datatype->type = ctype_createAbstract (oldid); }

void uentry_setCheckMod ( uentry ue )

Definition at line 2628 of file uentry.c. Referenced by doDeclareVar(), and processNamedDecl(). { llassert (uentry_isVar (ue)); ue->info->var->checked = CH_CHECKMOD; }

void uentry_setChecked ( uentry ue )

Definition at line 2621 of file uentry.c. Referenced by doDeclareVar(), and processNamedDecl(). { llassert (uentry_isVar (ue)); ue->info->var->checked = CH_CHECKED; }

void uentry_setCheckedStrict ( uentry ue )

Definition at line 2635 of file uentry.c. Referenced by doDeclareVar(), and processNamedDecl(). { llassert (uentry_isVar (ue)); ue->info->var->checked = CH_CHECKEDSTRICT; }

void uentry_setConcrete ( uentry e )

Definition at line 4642 of file uentry.c. Referenced by processNamedDecl(). { llassert (uentry_isDatatype (e) && (ynm_isMaybe (e->info->datatype->abs))); e->info->datatype->abs = NO; }

void uentry_setDatatype ( uentry e, usymId uid )

Definition at line 5628 of file uentry.c. Referenced by usymtab_supAbstractTypeEntry(), usymtab_supExposedTypeEntry(), and usymtab_supForwardTypeEntry(). { llassert (uentry_isDatatype (e)); if (uentry_isAbstractType (e)) { e->info->datatype->type = ctype_createAbstract (uid); } else { e->info->datatype->type = ctype_createUser (uid); } }

void uentry_setDeclared ( uentry e, fileloc f )

Definition at line 5190 of file uentry.c. Referenced by uentry_mergeDefinition(), and uentry_mergeEntries(). { fileloc oldloc; llassert (uentry_isValid (e)); oldloc = e->whereDeclared; if (fileloc_isDefined (oldloc)) { if (fileloc_isLib (oldloc) || fileloc_isImport (oldloc)) { e->whereDeclared = fileloc_update (e->whereDeclared, f); } else { ; } } else { e->whereDeclared = fileloc_update (e->whereDeclared, f); } }

void uentry_setDeclaredForce ( uentry e, fileloc f )

Definition at line 5148 of file uentry.c. { llassert (uentry_isValid (e)); e->whereDeclared = fileloc_update (e->whereDeclared, f); }

void uentry_setDeclaredForceOnly ( uentry e, fileloc f )

Definition at line 5155 of file uentry.c. { llassert (uentry_isValid (e)); fileloc_free (e->whereDeclared); e->whereDeclared = f; }

void uentry_setDeclaredOnly ( uentry e, fileloc f )

Definition at line 5163 of file uentry.c. Referenced by processNamedDecl(). { fileloc oldloc; llassert (uentry_isValid (e)); oldloc = e->whereDeclared; if (fileloc_isDefined (oldloc)) { if (fileloc_isLib (oldloc) || fileloc_isImport (oldloc)) { e->whereDeclared = f; fileloc_free (oldloc); } else { fileloc_free (f); } } else { e->whereDeclared = f; fileloc_free (oldloc); } }

void uentry_setDefState ( uentry ue, sstate defstate )

Definition at line 2563 of file uentry.c. Referenced by uentry_reflectQualifiers(). { if (uentry_isValid (ue)) { sRef_setDefState (ue->sref, defstate, fileloc_undefined); if (uentry_isVariable (ue)) { ue->info->var->defstate = defstate; /* evs 2000-05-17: fixed bug, was SS_DEFINED! */ } } }

void uentry_setDefined ( uentry e, fileloc f )

Definition at line 5224 of file uentry.c. Referenced by doDeclareConstant(), doDeclareVar(), exprNode_checkMacroBody(), processNamedDecl(), uentry_makeDatatypeAux(), uentry_makeEnumConstant(), uentry_makeEnumInitializedConstant(), uentry_makeExpandedMacro(), uentry_makeIdVariable(), uentry_makeUnrecognized(), uentry_mergeDefinition(), and uentry_mergeEntries(). { fileloc oldloc; llassert (uentry_isValid (e)); oldloc = e->whereDefined; if (fileloc_isDefined (oldloc)) { if (fileloc_isLib (oldloc) || fileloc_isImport (oldloc) || fileloc_isBuiltin (oldloc) || fileloc_isPreproc (oldloc)) { e->whereDefined = fileloc_update (e->whereDefined, f); } else { if (fileloc_equal (oldloc, f) || context_processingMacros ()) { ; /* okay */ } else { if (optgenerror (FLG_REDEF, message ("%s %q redefined", ekind_capName (e->ukind), uentry_getName (e)), f)) { llgenindentmsg (message ("Previous definition of %q", uentry_getName (e)), e->whereDefined); } } } } else { e->whereDefined = fileloc_update (e->whereDefined, f); } }

void uentry_setExtern ( uentry c )

Definition at line 1058 of file uentry.c. Referenced by uentry_mergeDefinition(). { if (uentry_isValid (c)) c->storageclass = SCEXTERN; }

void uentry_setFunctionDefined ( uentry e, fileloc loc )

Definition at line 5117 of file uentry.c. Referenced by context_setFunctionDefined(). { if (uentry_isValid (e)) { llassert (uentry_isFunction (e)); if (fileloc_isUndefined (e->whereDeclared)) { e->whereDeclared = fileloc_update (e->whereDeclared, loc); } if (!fileloc_isDefined (e->whereDefined)) { e->whereDefined = fileloc_update (e->whereDefined, loc); } } }

void uentry_setGlobals ( uentry ue, globSet globs )

Definition at line 2818 of file uentry.c. { llassert (uentry_isValid (ue)); if (uentry_isIter (ue)) { llassert (globSet_isUndefined (ue->info->iter->globs)); ue->info->iter->globs = globs; } else { if (uentry_isVariable (ue) && ctype_isFunction (uentry_getType (ue))) { uentry_makeVarFunction (ue); } llassert (uentry_isFunction (ue)); llassert (!ue->info->fcn->hasGlobs && globSet_isUndefined (ue->info->fcn->globs)); ue->info->fcn->hasGlobs = TRUE; /*@-mustfree@*/ ue->info->fcn->globs = globs; /*@=mustfree@*/ } if (globSet_hasStatic (globs)) { context_recordFileGlobals (globs); } if (context_getFlag (FLG_GLOBALSIMPMODIFIESNOTHING)) { ue->info->fcn->hasMods = TRUE; } }

void uentry_setHasNameError ( uentry ue )

Definition at line 9283 of file uentry.c. Referenced by checkParamNames(), checkPrefix(), exprNode_initMod(), exprNode_iterId(), exprNode_iterNewId(), uentry_checkName(), uentry_makeUnrecognized(), and usymtab_checkDistinctName(). { llassert (uentry_isValid (ue)); ue->hasNameError = TRUE; }

void uentry_setMessageLike ( uentry ue )

Definition at line 2411 of file uentry.c. { if (uentry_isVariable (ue) && ctype_isFunction (uentry_getType (ue))) { uentry_makeVarFunction (ue); } llassertfatal (uentry_isFunction (ue)); ue->info->fcn->specialCode = SPC_MESSAGELIKE; checkSpecialFunction (ue); }

void uentry_setModifies ( uentry ue, sRefSet sr )

Definition at line 1165 of file uentry.c. { if (sRef_modInFunction ()) { llparseerror (message ("Modifies list not in function context. " "A modifies list can only appear following the parameter list " "in a function declaration or header.")); /*@-mustfree@*/ return; /*@=mustfree@*/ } if (sRefSet_hasStatic (sr)) { context_recordFileModifies (sr); } if (uentry_isValid (ue)) { if (uentry_isIter (ue)) { llassert (sRefSet_isUndefined (ue->info->iter->mods)); ue->info->iter->mods = sr; } else { if (uentry_isVariable (ue) && ctype_isFunction (uentry_getType (ue))) { uentry_makeVarFunction (ue); } llassertfatal (uentry_isFunction (ue)); llassert (sRefSet_isUndefined (ue->info->fcn->mods)); ue->info->fcn->mods = sr; ue->info->fcn->hasMods = TRUE; checkGlobalsModifies (ue, sr); } if (context_getFlag (FLG_MODIFIESIMPNOGLOBALS)) { ue->info->fcn->hasGlobs = TRUE; } } else { sRefSet_free (sr); } }

void uentry_setMutable ( uentry e )

Definition at line 1549 of file uentry.c. { llassert (uentry_isDatatype (e)); e->info->datatype->mut = YES; }

void uentry_setName ( uentry e, cstring n )

Definition at line 5322 of file uentry.c. Referenced by uentryList_fixMissingNames(). { llassert (uentry_isValid (e)); cstring_free (e->uname); e->uname = n; }

void uentry_setParam ( uentry e )

Definition at line 5395 of file uentry.c. Referenced by handleParamIdList(). { if (!uentry_isVar (e)) { if (uentry_isElipsisMarker (e)) { } else { llbug (message ("uentry_setParam: not variable: %q", uentry_unparse (e))); } } else { cstring oldname; if (e->info->var->kind == VKYIELDPARAM || e->info->var->kind == VKSEFPARAM || e->info->var->kind == VKSEFRETPARAM) { ; } else { e->info->var->kind = VKPARAM; } oldname = e->uname; e->uname = makeParam (e->uname); cstring_free (oldname); } }

void uentry_setParamNo ( uentry ue, int pno )

Definition at line 1065 of file uentry.c. { llassert (uentry_isAnyParam (ue) && sRef_isParam (ue->sref)); sRef_setParamNo (ue->sref, pno); }

void uentry_setPrintfLike ( uentry ue )

Definition at line 2385 of file uentry.c. { if (uentry_isVariable (ue) && ctype_isFunction (uentry_getType (ue))) { uentry_makeVarFunction (ue); } llassertfatal (uentry_isFunction (ue)); ue->info->fcn->specialCode = SPC_PRINTFLIKE; checkSpecialFunction (ue); }

void uentry_setRefCounted ( uentry e )

Definition at line 999 of file uentry.c. { if (uentry_isValid (e)) { uentry_setAliasKind (e, AK_REFCOUNTED); sRef_storeState (e->sref); } }

void uentry_setRefParam ( uentry e )

Definition at line 5366 of file uentry.c. { if (!uentry_isVar (e)) { llbug (message ("uentry_setParam: not variable: %q", uentry_unparse (e))); } else { if (e->info->var->kind == VKSEFPARAM) { e->info->var->kind = VKREFSEFPARAM; } else if (e->info->var->kind == VKSEFRETPARAM) { e->info->var->kind = VKREFSEFRETPARAM; } else if (e->info->var->kind == VKYIELDPARAM) { e->info->var->kind = VKREFYIELDPARAM; } else { e->info->var->kind = VKREFPARAM; } } }

void uentry_setScanfLike ( uentry ue )

Definition at line 2398 of file uentry.c. { if (uentry_isVariable (ue) && ctype_isFunction (uentry_getType (ue))) { uentry_makeVarFunction (ue); } llassertfatal (uentry_isFunction (ue)); ue->info->fcn->specialCode = SPC_SCANFLIKE; checkSpecialFunction (ue); }

void uentry_setSpecialClauses ( uentry ue, specialClauses clauses )

Definition at line 1141 of file uentry.c. { llassert (uentry_isFunction (ue)); llassert (!specialClauses_isDefined (ue->info->fcn->specclauses)); ue->info->fcn->specclauses = clauses; specialClauses_checkAll (ue); }

void uentry_setSref ( uentry e, sRef s )

Definition at line 5430 of file uentry.c. Referenced by handleParamIdList(). { if (uentry_isValid (e)) { if (sRef_isValid (e->sref)) { sRef_mergeStateQuietReverse (e->sref, s); } else { e->sref = sRef_saveCopy (s); } } }

void uentry_setState ( uentry res, uentry other )

Definition at line 8579 of file uentry.c. Referenced by usymtab_exitSwitch(), and usymtab_popBranches(). { llassert (uentry_isValid (res)); llassert (uentry_isValid (other)); llassert (res->ukind == other->ukind); llassert (res->ukind == KVAR); res->sref = sRef_saveCopy (other->sref); res->used = other->used; filelocList_free (res->uses); res->uses = other->uses; other->uses = filelocList_undefined; res->lset = other->lset; }

void uentry_setStatic ( uentry c )

Definition at line 1010 of file uentry.c. Referenced by declareStaticFunction(), and uentry_reflectQualifiers(). { if (uentry_isValid (c)) { alkind ak = sRef_getAliasKind (c->sref); c->storageclass = SCSTATIC; if (uentry_isVariable (c) && !ctype_isFunction (uentry_getType (c))) { if (!alkind_isUnknown (ak) && !alkind_isStatic (ak)) { if (!(ctype_isRealPointer (uentry_getType (c))) && !(ctype_isAbstract (ctype_realType (uentry_getType (c)))) && !alkind_isRefCounted (ak)) { if (alkind_isImplicit (ak) && alkind_isDependent (ak) && ctype_isArray (uentry_getType (c))) { ; /* no error for observer arrays */ } else { voptgenerror (FLG_INCONDEFS, message ("Static storage %q declared as %s", uentry_getName (c), alkind_unparse (ak)), uentry_whereDeclared (c)); } } } else { if (alkind_isUnknown (ak) || (alkind_isImplicit (sRef_getAliasKind (c->sref)) && !alkind_isDependent (sRef_getAliasKind (c->sref)))) { sRef_setAliasKind (c->sref, AK_STATIC, fileloc_undefined); sRef_setOrigAliasKind (c->sref, AK_STATIC); } } } } }

void uentry_setType ( uentry e, ctype t )

Definition at line 5331 of file uentry.c. Referenced by checkDoneParams(), doneParams(), processNamedDecl(), and uentryList_fixMissingNames(). { if (uentry_isValid (e)) { e->utype = t; sRef_setType (e->sref, t); } }

void uentry_setUnchecked ( uentry ue )

Definition at line 2614 of file uentry.c. Referenced by processNamedDecl(). { llassert (uentry_isVar (ue)); ue->info->var->checked = CH_UNCHECKED; }

void uentry_setUsed ( uentry e, fileloc loc )

Definition at line 8923 of file uentry.c. Referenced by doVaDcl(), exprNode_arrowAccess(), exprNode_fieldAccess(), exprNode_iter(), exprNode_iterId(), exprNode_iterNewId(), exprNode_makeInitialization(), main(), uentry_checkYieldParam(), uentry_makeUnrecognized(), uentry_mergeDefinition(), uentry_reflectQualifiers(), and usymtab_allUsed(). { static bool firstTime = TRUE; static bool showUses = FALSE; static bool exportLocal = FALSE; if (firstTime) { /* need to track uses is FLG_SHOWUSES or FLG_EXPORTLOCAL is true */ showUses = context_getFlag (FLG_SHOWUSES); exportLocal = context_maybeSet (FLG_EXPORTLOCAL); firstTime = FALSE; } if (uentry_isValid (e)) { int dp; if (sRef_isMacroParamRef (e->sref)) { if (uentry_isYield (e) || uentry_isSefParam (e)) { ; } else { if (context_inConditional ()) { if (optgenerror (FLG_MACROPARAMS, message ("Macro parameter %q used in conditionally " "executed code (may or may not be " "evaluated exactly once)", uentry_getName (e)), loc)) { e->info->var->kind = VKREFSEFPARAM; } } else { if ((e)->used) { if (optgenerror (FLG_MACROPARAMS, message ("Macro parameter %q used more than once", uentry_getName (e)), uentry_whereDeclared (e))) { e->info->var->kind = VKREFSEFPARAM; } } } } } if ((dp = uentry_directParamNo (e)) >= 0) { uentry_setUsed (usymtab_getParam (dp), loc); } e->used = TRUE; if (!sRef_isLocalVar (e->sref)) { if (showUses) { e->uses = filelocList_add (e->uses, fileloc_copy (loc)); } else { if (exportLocal) { if (context_inMacro ()) { e->uses = filelocList_addUndefined (e->uses); } else { e->uses = filelocList_addDifferentFile (e->uses, uentry_whereDeclared (e), loc); } } } } } }

void uentry_showDefSpecInfo ( uentry ce, fileloc fwhere )

Definition at line 6012 of file uentry.c. Referenced by usymtab_allUsed(), usymtab_exportHeader(), and usymtab_exportLocal(). { fileloc loc = uentry_whereDefined (ce); if (fileloc_isUser (loc) && !fileloc_equal (loc, fwhere)) { llgenindentmsg (message ("Definition of %q", uentry_getName (ce)), loc); } loc = uentry_whereSpecified (ce); if (fileloc_isUser (loc) && !fileloc_equal (loc, fwhere)) { llgenindentmsg (message ("Specification of %q", uentry_getName (ce)), loc); } }

void uentry_showWhereAny ( uentry spec )

Definition at line 6086 of file uentry.c. { if (uentry_isDeclared (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Declaration of %q", uentry_getName (spec)), uentry_whereDeclared (spec)); } else { llgenindentmsg (cstring_makeLiteral ("Declaration"), uentry_whereDeclared (spec)); } } else if (uentry_isSpecified (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Specification of %q", uentry_getName (spec)), uentry_whereSpecified (spec)); } else { llgenindentmsg (cstring_makeLiteral ("Specification"), uentry_whereSpecified (spec)); } } else if (fileloc_isDefined (uentry_whereDefined (spec))) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Definition of %q", uentry_getName (spec)), uentry_whereDefined (spec)); } else { llgenindentmsg (cstring_makeLiteral ("Definition"), uentry_whereDefined (spec)); } } else { /* nothing to show */ } }

void uentry_showWhereDeclared ( uentry spec )

Definition at line 6052 of file uentry.c. Referenced by checkModifiesId(), checkSpecClausesId(), and exprNode_iterId(). { if (uentry_isDeclared (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Declaration of %q", uentry_getName (spec)), uentry_whereDeclared (spec)); } else { llgenindentmsg (cstring_makeLiteral ("Declaration"), uentry_whereDeclared (spec)); } } else if (uentry_isSpecified (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Specification of %q", uentry_getName (spec)), uentry_whereSpecified (spec)); } else { llgenindentmsg (cstring_makeLiteral ("Specification"), uentry_whereSpecified (spec)); } } else { /* nothing to show */ } }

void uentry_showWhereDefined ( uentry spec )

Definition at line 6133 of file uentry.c. { if (uentry_isCodeDefined (spec)) { llgenindentmsg (message ("Previous definition of %q", uentry_getName (spec)), uentry_whereDefined (spec)); } }

void uentry_showWhereLast ( uentry spec )

Definition at line 5969 of file uentry.c. Referenced by uentry_mergeDefinition(). { if (uentry_isValid (spec)) { if (fileloc_isDefined (spec->whereDefined) && !fileloc_isLib (spec->whereDefined) && !fileloc_isPreproc (spec->whereDefined)) { llgenindentmsg (message ("Previous definition of %q: %t", uentry_getName (spec), uentry_getType (spec)), uentry_whereDefined (spec)); } else if (uentry_isDeclared (spec)) { llgenindentmsg (message ("Previous declaration of %q: %t", uentry_getName (spec), uentry_getType (spec)), uentry_whereDeclared (spec)); } else if (uentry_isSpecified (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Specification of %q: %t", uentry_getName (spec), uentry_getType (spec)), uentry_whereSpecified (spec)); } else { llgenindentmsg (message ("Specification: %t", uentry_getType (spec)), uentry_whereSpecified (spec)); } } else { /* nothing to show */ } } }

void uentry_showWhereLastExtra ( uentry spec, cstring extra )

Definition at line 6031 of file uentry.c. Referenced by specialClauses_checkEqual(), and uentry_mergeConstantValue(). { if (uentry_isDeclared (spec)) { llgenindentmsg (message ("Previous declaration of %q: %q", uentry_getName (spec), extra), uentry_whereDeclared (spec)); } else if (uentry_isSpecified (spec)) { llgenindentmsg (message ("Specification of %q: %q", uentry_getName (spec), extra), uentry_whereSpecified (spec)); } else { cstring_free (extra); } }

void uentry_showWhereLastPlain ( uentry spec )

Definition at line 6143 of file uentry.c. Referenced by uentryList_showFieldDifference(). { if (uentry_isDeclared (spec)) { llgenindentmsg (message ("Previous declaration of %q", uentry_getName (spec)), uentry_whereDeclared (spec)); } else if (uentry_isSpecified (spec)) { llgenindentmsg (message ("Specification of %q", uentry_getName (spec)), uentry_whereSpecified (spec)); } else { } }

void uentry_showWhereSpecified ( uentry spec )

Definition at line 6181 of file uentry.c. Referenced by exprNode_checkAllMods(), exprNode_checkMacroBody(), uentry_mergeEntries(), and usymtab_allUsed(). { if (uentry_isSpecified (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Specification of %q", uentry_getName (spec)), uentry_whereSpecified (spec)); } else { llgenindentmsg (cstring_makeLiteral ("Specification"), uentry_whereSpecified (spec)); } } else if (uentry_isDeclared (spec)) { llgenindentmsg (message ("Declaration of %q", uentry_getName (spec)), uentry_whereDeclared (spec)); } else { /* nothing to show */ } }

void uentry_showWhereSpecifiedExtra ( uentry spec, cstring s )

Definition at line 6208 of file uentry.c. { if (uentry_isSpecified (spec)) { if (uentry_hasName (spec)) { llgenindentmsg (message ("Specification of %q: %q", uentry_getName (spec), s), uentry_whereSpecified (spec)); } else { llgenindentmsg (message ("Specification: %q", s), uentry_whereSpecified (spec)); } } else if (uentry_isDeclared (spec)) { llgenindentmsg (message ("Declaration of %q: %q", uentry_getName (spec), s), uentry_whereDeclared (spec)); } else { llgenindentmsg (message ("Previous: %q", s), uentry_whereLast (spec)); } }

cstring uentry_specDeclName ( uentry u )

Definition at line 526 of file uentry.c. { if (uentry_isDeclared (u)) { return cstring_makeLiteralTemp ("previous declaration"); } else { return cstring_makeLiteralTemp ("specification"); } }

cstring uentry_specOrDefName ( uentry u )

Definition at line 514 of file uentry.c. Referenced by uentryList_showFieldDifference(). { if (uentry_isDeclared (u)) { return cstring_makeLiteralTemp ("previously declared"); } else { return cstring_makeLiteralTemp ("specified"); } }

uentry uentry_undump ( ekind kind, fileloc loc, char ** s )

Definition at line 3927 of file uentry.c. Referenced by uentryList_undump(), and usymtab_load(). { uentry ue; if (**s == '!') { checkChar (s, '!'); checkChar (s, '.'); ue = uentry_makeElipsisMarker (); } else { ctype ct = ctype_undump (s); cstring name; switch (kind) { case KVAR: { vkind tkind; sstate defstate; nstate isnull; alkind aliased; exkind exp; chkind checked; checkChar (s, '|'); if (optCheckChar (s, '@')) { tkind = vkind_fromInt (getInt (s)); checkChar (s, '|'); } else { tkind = VKPARAM; } if (optCheckChar (s, '$')) { defstate = SS_UNKNOWN; isnull = NS_UNKNOWN; aliased = AK_IMPTEMP; exp = XO_UNKNOWN; checked = CH_UNKNOWN; } else if (optCheckChar (s, '&')) { defstate = SS_DEFINED; isnull = NS_UNKNOWN; aliased = AK_IMPTEMP; exp = XO_UNKNOWN; checked = CH_UNKNOWN; } else if (optCheckChar (s, '^')) { defstate = SS_UNKNOWN; isnull = NS_UNKNOWN; aliased = AK_IMPTEMP; exp = XO_UNKNOWN; checked = CH_UNKNOWN; } else { defstate = sstate_fromInt (getInt (s)); advanceField (s); isnull = nstate_fromInt (getInt (s)); advanceField (s); aliased = alkind_fromInt (getInt (s)); if (optCheckChar (s, '&')) { exp = XO_UNKNOWN; checked = CH_UNKNOWN; } else { advanceField (s); exp = exkind_fromInt (getInt (s)); advanceField (s); checked = (chkind) (getInt (s)); } } advanceName (s); name = getStringWord (s); ue = uentry_makeVariableBase (name, ct, tkind, defstate, isnull, aliased, exp, checked, fileloc_copy (loc)); } break; case KDATATYPE: { ynm abs; ynm mut; ctype rtype; sstate defstate; nstate isnull; alkind aliased; exkind exp; advanceField (s); abs = ynm_fromCodeChar (loadChar (s)); advanceField (s); mut = ynm_fromCodeChar (loadChar (s)); advanceField (s); defstate = sstate_fromInt (getInt (s)); advanceField (s); isnull = nstate_fromInt (getInt (s)); advanceField (s); aliased = alkind_fromInt (getInt (s)); advanceField (s); exp = exkind_fromInt (getInt (s)); advanceField (s); rtype = ctype_undump (s); advanceName (s); name = getStringWord (s); ue = uentry_makeDatatypeBase (name, ct, abs, mut, rtype, aliased, exp, defstate, isnull, fileloc_copy (loc)); } break; case KFCN: { alkind ak; exkind exp; sstate defstate; nstate isnull; exitkind exitCode; specCode specc; qual nullPred; typeIdSet access; bool hasGlobs; globSet globs; bool hasMods; sRefSet mods; specialClauses specclauses; if (optCheckChar (s, '$')) { defstate = SS_DEFINED; isnull = NS_UNKNOWN; exitCode = XK_UNKNOWN; specc = SPC_NONE; nullPred = QU_UNKNOWN; } else { advanceField (s); defstate = sstate_fromInt (getInt (s)); advanceField (s); isnull = nstate_fromInt (getInt (s)); advanceField (s); exitCode = exitkind_fromInt (getInt (s)); advanceField (s); specc = specCode_fromInt (getInt (s)); advanceField (s); nullPred = qual_fromInt (getInt (s)); } if (optCheckChar (s, '$')) { hasGlobs = FALSE; globs = globSet_undefined; hasMods = FALSE; mods = sRefSet_undefined; } else if (optCheckChar (s, '^')) { hasGlobs = TRUE; globs = globSet_undefined; hasMods = TRUE; mods = sRefSet_undefined; } else { advanceField (s); hasGlobs = bool_fromInt (getInt (s)); advanceField (s); globs = globSet_undump (s); advanceField (s); hasMods = bool_fromInt (getInt (s)); advanceField (s); mods = sRefSet_undump (s); } if (optCheckChar (s, '$')) { ak = AK_UNKNOWN; exp = XO_UNKNOWN; } else { advanceField (s); ak = alkind_fromInt (getInt (s)); advanceField (s); exp = exkind_fromInt (getInt (s)); } advanceField (s); access = typeIdSet_undump (s); if (optCheckChar (s, '@')) { specclauses = specialClauses_undump (s); } else { specclauses = specialClauses_undefined; } advanceName (s); name = getStringWord (s); ue = uentry_makeFunctionBase (name, ct, access, hasGlobs, globs, hasMods, mods, ak, exp, defstate, isnull, exitCode, specc, nullPred, specclauses, fileloc_copy (loc)); DPRINTF (("Undump: %s", uentry_unparse (ue))); } break; case KITER: { typeIdSet access; advanceField (s); access = typeIdSet_undump (s); advanceName (s); name = getStringWord (s); ue = uentry_makeIterBase (name, access, ct, fileloc_copy (loc)); } break; case KENDITER: { typeIdSet access; advanceField (s); access = typeIdSet_undump (s); advanceName (s); name = getStringWord (s); ue = uentry_makeEndIterBase (name, access, fileloc_copy (loc)); } break; case KENUMCONST: case KCONST: { typeIdSet access; multiVal val; nstate nullstate; if (optCheckChar (s, '$')) { val = multiVal_undefined; access = typeIdSet_undefined; nullstate = NS_UNKNOWN; } else { advanceField (s); val = multiVal_undump (s); advanceField (s); access = typeIdSet_undump (s); advanceField (s); nullstate = nstate_fromInt (getInt (s)); } advanceName (s); name = getStringWord (s); ue = uentry_makeConstantBase (name, ct, access, nullstate, fileloc_copy (loc), val); break; } case KSTRUCTTAG: case KUNIONTAG: case KENUMTAG: { ctype rtype; advanceField (s); rtype = ctype_undump (s); advanceName (s); name = getStringWord (s); ue = uentry_makeTagBase (name, kind, ct, rtype, fileloc_copy (loc)); } break; case KINVALID: llcontbuglit ("uentry_undump: invalid"); ue = uentry_undefined; break; case KELIPSMARKER: llcontbuglit ("uentry_undump: elips marker"); ue = uentry_undefined; break; } } return (ue); }

cstring uentry_unparse ( uentry v )

Definition at line 4444 of file uentry.c. Referenced by uentryList_showFieldDifference(), uentry_getForceRealType(), uentry_getRealType(), uentry_mergeState(), uentry_reflectQualifiers(), uentry_unparseAbbrev(), and usymtab_addEntry(). { cstring st; if (uentry_isUndefined (v)) return (cstring_makeLiteral ("<undefined>")); if (uentry_isElipsisMarker (v)) return (cstring_makeLiteral ("...")); st = uentry_getName (v); if (cstring_isDefined (st)) { return (ctype_unparseDeclaration (v->utype, st)); } else { cstring_free (st); return (cstring_copy (ctype_unparse (v->utype))); } }

cstring uentry_unparseAbbrev ( uentry v )

Definition at line 4432 of file uentry.c. { if (!uentry_isVariable (v)) { llcontbuglit ("uentry_unparseAbbrev: not variable"); return uentry_unparse (v); } return (message ("%s %q", ctype_unparseDeep (v->utype), uentry_getName (v))); }

cstring uentry_unparseFull ( uentry v )

Definition at line 4465 of file uentry.c. Referenced by uentry_dumpParam(), uentry_fixupSref(), usymtab_allUsed(), and usymtab_printOut(). { if (uentry_isUndefined (v)) { return (cstring_makeLiteral ("<undefined>")); } else if (uentry_isDatatype (v)) { return (message ("[%d] [%s] %s %q : %t [%t] %s %s // %q [s: %q; d: %q]", (int) v, ekind_unparse (v->ukind), v->uname, uentry_getName (v), v->utype, ctype_isDefined (v->info->datatype->type) ? v->info->datatype->type : ctype_unknown, ynm_unparse (v->info->datatype->mut), ynm_unparse (v->info->datatype->abs), sRef_unparseState (v->sref), fileloc_unparse (v->whereSpecified), fileloc_unparse (v->whereDefined))); } else if (uentry_isFunction (v)) { return (message ("[%w] = [%s] %q : %t / sref: %q / mods: %q / " "globs: %q / [s: %q; decl: %q; def: %q]", (long unsigned) v, ekind_unparse (v->ukind), uentry_getName (v), v->utype, sRef_unparseFull (v->sref), sRefSet_unparse (v->info->fcn->mods), globSet_unparse (v->info->fcn->globs), fileloc_unparse (v->whereSpecified), fileloc_unparse (v->whereDeclared), fileloc_unparse (v->whereDefined))); } else if (uentry_isIter (v)) { return (message ("[%s] %q: %t / %q [s: %q; d: %q]", ekind_unparse (v->ukind), uentry_getName (v), v->utype, sRef_unparseFull (v->sref), fileloc_unparse (v->whereSpecified), fileloc_unparse (v->whereDefined))); } else if (uentry_isVariable (v)) { return (message ("[check: %s] / [%w] = [%s] %s : %t %q [s: %q; def: %q; dec: %q] " "kind <%d> isout <%d> used <%d>", checkedName (v->info->var->checked), (long unsigned) v, ekind_unparse (v->ukind), v->uname, v->utype, sRef_unparseDeep (v->sref), fileloc_unparse (v->whereSpecified), fileloc_unparse (v->whereDefined), fileloc_unparse (v->whereDeclared), (int) v->info->var->kind, (int) v->info->var->defstate, (int) v->used)); } else { return (message ("[%s] %s : %t %q at [s: %q; d: %q]", ekind_unparse (v->ukind), v->uname, v->utype, sRef_unparseFull (v->sref), fileloc_unparse (v->whereSpecified), fileloc_unparse (v->whereDefined))); } }

fileloc uentry_whereDeclared ( uentry e )

Definition at line 5090 of file uentry.c. Referenced by exprChecks_checkExport(), exprChecks_checkUsedGlobs(), processNamedDecl(), uentry_checkParams(), uentry_makeIdFunction(), uentry_mergeDefinition(), uentry_mergeEntries(), uentry_mergeState(), uentry_setStatic(), uentry_setUsed(), uentry_showWhereAny(), uentry_showWhereDeclared(), uentry_showWhereLast(), uentry_showWhereLastExtra(), uentry_showWhereLastPlain(), uentry_showWhereSpecified(), uentry_showWhereSpecifiedExtra(), uentry_whereLast(), usymtab_allDefined(), usymtab_allUsed(), usymtab_exportHeader(), and usymtab_exportLocal(). { if (uentry_isInvalid (e)) return fileloc_undefined; return (e->whereDeclared); }

fileloc uentry_whereDefined ( uentry e )

Definition at line 5083 of file uentry.c. Referenced by fixUentryList(), uentryList_mergeFields(), uentryList_showFieldDifference(), uentry_mergeDefinition(), uentry_showDefSpecInfo(), uentry_showWhereAny(), uentry_showWhereDefined(), uentry_showWhereLast(), usymtab_allUsed(), usymtab_exportHeader(), and usymtab_exportLocal(). { if (uentry_isInvalid (e)) return fileloc_undefined; return (e->whereDefined); }

fileloc uentry_whereEarliest ( uentry e )

Definition at line 5098 of file uentry.c. Referenced by usymtab_allUsed(), and usymtab_enterFunctionScope(). { if (uentry_isInvalid (e)) return fileloc_undefined; if (fileloc_isDefined (e->whereSpecified)) { return (e->whereSpecified); } else if (fileloc_isDefined (e->whereDeclared)) { return (e->whereDeclared); } else { return e->whereDefined; } }

fileloc uentry_whereEither ( uentry e )

Definition at line 5057 of file uentry.c. Referenced by uentryList_showFieldDifference(). { if (uentry_isInvalid (e)) return fileloc_undefined; if (fileloc_isDefined (e->whereDefined) && !fileloc_isExternal (e->whereDefined)) { return e->whereDefined; } else if (fileloc_isDefined (e->whereDeclared)) { return e->whereDeclared; } else { return e->whereSpecified; } }

fileloc uentry_whereLast ( uentry e )

Definition at line 5030 of file uentry.c. Referenced by checkParamNames(), checkPrefix(), declareStruct(), declareUnion(), exprNode_checkAllMods(), processNamedDecl(), sRef_fixResultType(), specialClauses_checkAll(), uentry_checkName(), uentry_makeIdFunction(), uentry_makeParam(), uentry_mergeDefinition(), uentry_showWhereSpecifiedExtra(), and usymtab_checkDistinctName(). { fileloc loc; if (uentry_isInvalid (e)) { return fileloc_undefined; } loc = e->whereDefined; if (fileloc_isValid (loc) && !fileloc_isExternal (loc)) { return loc; } loc = uentry_whereDeclared (e); if (fileloc_isValid (loc) && !fileloc_isExternal (loc)) { return loc; } loc = uentry_whereSpecified (e); return loc; }

fileloc uentry_whereSpecified ( uentry e )

Definition at line 5076 of file uentry.c. Referenced by exprChecks_checkUsedGlobs(), exprNode_checkAllMods(), lclRedeclarationError(), uentry_showDefSpecInfo(), uentry_showWhereAny(), uentry_showWhereDeclared(), uentry_showWhereLast(), uentry_showWhereLastExtra(), uentry_showWhereLastPlain(), uentry_showWhereSpecified(), uentry_showWhereSpecifiedExtra(), uentry_whereLast(), and usymtab_allDefined(). { if (uentry_isInvalid (e)) return fileloc_undefined; return (e->whereSpecified); }

int uentry_xcomparealpha ( uentry * p1, uentry * p2 )

Definition at line 3317 of file uentry.c. { int res; if ((res = uentry_compare (*p1, *p2)) == 0) { if ((*p1 != NULL) && (*p2 != NULL)) { res = cstring_compare ((*p1)->uname, (*p2)->uname); } } return res; }

int uentry_xcompareuses ( uentry * p1, uentry * p2 )

Definition at line 3332 of file uentry.c. { uentry u1 = *p1; uentry u2 = *p2; if (uentry_isValid (u1)) { if (uentry_isValid (u2)) { return (-1 * int_compare (filelocList_size (u1->uses), filelocList_size (u2->uses))); } else { return 1; } } else { if (uentry_isValid (u2)) { return -1; } else { return 0; } } }

---