---

clabstract.c File Reference

#include "lclintMacros.nf"
#include "llbasic.h"
#include "cgrammar.h"
#include "usymtab_interface.h"
#include "structNames.h"
#include "nameChecks.h"
#include "cgrammar_tokens.h"

Go to the source code of this file.

Functions
void	setArgsUsed (void)
void	setSpecialFunction (qual qu)
void	storeLoc ()
void	setFunctionNoGlobals (void)
void	setFunctionStateSpecialClause (lltok stok, specialClauseKind kind, sRefSet s, lltok etok)
void	setFunctionSpecialClause (lltok stok, sRefSet s, lltok etok)
void	setFunctionModifies (sRefSet s)
void	globListAdd (sRef sr, qualList quals)
void	declareCIter (cstring name, uentryList params)
void	nextIterParam (void)
int	iterParamNo (void)
uentry	makeCurrentParam (idDecl t)
ctype	declareUnnamedEnum (enumNameList el)
ctype	declareEnum (cstring ename, enumNameList el)
void	setCurrentParams ( uentryList ue)
void	clearCurrentParams (void)
void	enterParamsTemp (void)
void	exitParamsTemp (void)
void	declareFunction (idDecl tid)
void	declareStaticFunction (idDecl tid)
uentryList	fixUentryList (idDeclList tl, qtype q)
uentryList	fixUnnamedDecl (qtype q)
void	setStorageClass (storageClassCode sc)
void	setProcessingIterVars (uentry iter)
void	setProcessingGlobalsList ()
void	setProcessingGlobMods ()
void	clearProcessingGlobMods ()
bool	isProcessingGlobMods ()
void	unsetProcessingGlobals ()
void	setProcessingVars ( qtype q)
void	setProcessingTypedef ( qtype q)
void	unsetProcessingVars ()
void	doneParams ()
void	checkDoneParams ()
void	unsetProcessingTypedef ()
void	checkConstant (qtype t, idDecl id)
void	checkValueConstant (qtype t, idDecl id, exprNode e)
void	processNamedDecl (idDecl t)
ctype	declareUnnamedStruct ( uentryList f)
ctype	declareUnnamedUnion ( uentryList f)
ctype	declareStruct (cstring id, uentryList f)
ctype	declareUnion (cstring id, uentryList f)
ctype	handleStruct ( cstring id)
ctype	handleUnion ( cstring id)
ctype	handleEnum (cstring id)
bool	processingIterVars (void)
uentry	getCurrentIter (void)
void	setFlipOldStyle ()
bool	isFlipOldStyle ()
bool	isNewStyle ()
void	setNewStyle ()
uentryList	handleParamIdList ( uentryList params)
uentryList	handleParamTypeList ( uentryList params)
void	doVaDcl ()
sRef	modListPointer (sRef s)
sRef	modListFieldAccess (sRef s, cstring f)
sRef	globListUnrecognized (cstring s)
sRef	modListArrowAccess (sRef s, cstring f)
sRef	checkSpecClausesId (uentry ue)
void	checkModifiesId (uentry ue)
sRef	fixModifiesId (cstring s)
sRef	fixSpecClausesId (cstring s)
sRef	modListArrayFetch (sRef s, sRef mexp)

---

Function Documentation

void checkConstant ( qtype t, idDecl id )

Definition at line 1278 of file clabstract.c. { uentry e; id = idDecl_fixBase (id, t); e = uentry_makeIdConstant (id); reflectStorageClass (e); resetStorageClass (); usymtab_supGlobalEntry (e); }

void checkDoneParams ( )

Definition at line 1246 of file clabstract.c. { if (uentry_isValid (saveFunction)) { /* ** old style declaration */ ctype ct = ctype_returnValue (uentry_getType (saveFunction)); ctype ct2; uentryList_elements (saveParamList, current) { uentry_setType (current, ctype_int); /* all params are ints */ } end_uentryList_elements; ct2 = ctype_makeParamsFunction (ct, uentryList_copy (saveParamList)); uentry_setType (saveFunction, ct2); ProcessingParams = FALSE; oldStyleDeclareFunction (saveFunction); saveFunction = uentry_undefined; } }

void checkModifiesId ( uentry ue )

Definition at line 2089 of file clabstract.c. { cstring s = uentry_rawName (ue); if (cstring_equalLit (s, "nothing") || cstring_equalLit (s, "internalState") || cstring_equalLit (s, "systemState") || (cstring_equalLit (s, "fileSystem"))) { if (optgenerror (FLG_SYNTAX, message ("Modifies list uses %s which is a variable and has special " "meaning in a modifies list. (Special meaning assumed.)", s), g_currentloc)) { uentry_showWhereDeclared (ue); } } }

sRef checkSpecClausesId ( uentry ue )

Definition at line 2052 of file clabstract.c. { cstring s = uentry_rawName (ue); if (sRef_isGlobal (uentry_getSref (ue))) { voptgenerror (FLG_SYNTAX, message ("Global variable %s used special clause. (Global variables " "are not recognized in special clauses. If there is " "sufficient interest in support for this, it may be " "added to a future release. Send mail to " "lclint@cs.virginia.edu.)", s), g_currentloc); return sRef_undefined; } else { if (cstring_equalLit (s, "result")) { if (optgenerror (FLG_SYNTAX, message ("Special clause list uses %s which is a variable and has special " "meaning in a modifies list. (Special meaning assumed.)", s), g_currentloc)) { uentry_showWhereDeclared (ue); } } return uentry_getSref (ue); } }

void checkValueConstant ( qtype t, idDecl id, exprNode e )

Definition at line 1291 of file clabstract.c. { uentry ue; id = idDecl_fixBase (id, t); ue = uentry_makeIdConstant (id); reflectStorageClass (ue); resetStorageClass (); if (exprNode_isDefined (e)) { if (!exprNode_matchType (uentry_getType (ue), e)) { (void) gentypeerror (exprNode_getType (e), e, uentry_getType (ue), exprNode_undefined, message ("Constant %q initialized to type %t, expects %t: %s", uentry_getName (ue), exprNode_getType (e), uentry_getType (ue), exprNode_unparse (e)), exprNode_loc (e)); } else { if (exprNode_hasValue (e)) { uentry_mergeConstantValue (ue, multiVal_copy (exprNode_getValue (e))); } } } usymtab_supGlobalEntry (ue); }

void clearCurrentParams ( void )

Definition at line 582 of file clabstract.c. { currentParamList = uentryList_undefined; }

void clearProcessingGlobMods ( )

Definition at line 1148 of file clabstract.c. { ProcessingGlobMods = FALSE; }

void declareCIter ( cstring name, uentryList params )

Definition at line 363 of file clabstract.c. { uentry ue; ue = uentry_makeIter (name, ctype_makeFunction (ctype_void, params), fileloc_copy (g_currentloc)); usymtab_supEntry (uentry_makeEndIter (name, fileloc_copy (g_currentloc))); reflectModGlobs (ue); ue = usymtab_supGlobalEntryReturn (ue); }

ctype declareEnum ( cstring ename, enumNameList el )

Definition at line 441 of file clabstract.c. Referenced by handleEnum(). { ctype cet; uentry e; llassert (cstring_isDefined (ename)); cet = ctype_createEnum (ename, el); e = uentry_makeEnumTagLoc (ename, cet); reflectStorageClass (e); e = usymtab_supGlobalEntryReturn (e); cet = uentry_getType (e); declareEnumList (el, cet, uentry_whereLast (e)); return (uentry_getAbstractType (e)); }

void declareFunction ( idDecl tid )

Definition at line 720 of file clabstract.c. { uentry ue; DPRINTF (("Declare function: %s", idDecl_unparse (tid))); if (ProcessingParams) { ue = globalDeclareOldStyleFunction (tid); saveFunction = ue; } else { saveFunction = uentry_undefined; if (context_inRealFunction ()) { ue = uentry_makeVariableLoc (idDecl_observeId (tid), ctype_unknown); llparseerror (message ("Function declared inside function: %q", idDecl_unparse (tid))); context_quietExitFunction (); ue = usymtab_supEntryReturn (ue); } else { if (context_inInnerScope ()) { llparseerror (message ("Declaration in inner context: %q", idDecl_unparse (tid))); sRef_setGlobalScope (); ue = uentry_makeVariableLoc (idDecl_observeId (tid), ctype_unknown); ue = usymtab_supGlobalEntryReturn (ue); sRef_clearGlobalScope (); } else { ue = globalDeclareFunction (tid); } } resetGlobals (); } resetStorageClass (); idDecl_free (tid); }

void declareStaticFunction ( idDecl tid )

Definition at line 771 of file clabstract.c. { uentry ue; DPRINTF (("Declare static funciton: %s", idDecl_unparse (tid))); if (ProcessingParams) { ue = globalDeclareOldStyleFunction (tid); saveFunction = ue; } else { saveFunction = uentry_undefined; if (context_inRealFunction ()) { ue = uentry_makeVariableLoc (idDecl_observeId (tid), ctype_unknown); llparseerror (message ("Function declared inside function: %q", idDecl_unparse (tid))); context_quietExitFunction (); ue = usymtab_supEntryReturn (ue); } else { if (context_inInnerScope ()) { llparseerror (message ("Declaration in inner context: %q", idDecl_unparse (tid))); sRef_setGlobalScope (); ue = uentry_makeVariableLoc (idDecl_observeId (tid), ctype_unknown); ue = usymtab_supGlobalEntryReturn (ue); sRef_clearGlobalScope (); } else { ctype deftype = idDecl_getCtype (tid); ctype rettype; if (ctype_isFunction (deftype)) { rettype = ctype_returnValue (deftype); } else { rettype = ctype_unknown; } /* ** check has been moved here... */ if (ctype_isFunction (idDecl_getCtype (tid))) { ue = uentry_makeIdFunction (tid); reflectSpecialCode (ue); reflectArgsUsed (ue); } else { llparseerror (message ("Inconsistent function declaration: %q", idDecl_unparse (tid))); tid = idDecl_replaceCtype (tid, ctype_makeFunction (ctype_unknown, uentryList_undefined)); ue = uentry_makeIdFunction (tid); } reflectStorageClass (ue); uentry_setStatic (ue); uentry_checkParams (ue); reflectModGlobs (ue); DPRINTF (("Sub global entry: %s", uentry_unparse (ue))); ue = usymtab_supGlobalEntryReturn (ue); context_enterFunction (ue); enterFunctionParams (uentry_getParams (ue)); resetStorageClass (); } } resetGlobals (); } resetStorageClass (); idDecl_free (tid); }

ctype declareStruct ( cstring id, uentryList f )

Definition at line 1656 of file clabstract.c. { ctype ct; uentry ue; int num = uentryList_size (f); ct = ctype_createStruct (cstring_copy (id), f); ue = uentry_makeStructTagLoc (id, ct); if (context_maybeSet (FLG_NUMSTRUCTFIELDS)) { int max = context_getValue (FLG_NUMSTRUCTFIELDS); if (num > max) { voptgenerror (FLG_NUMSTRUCTFIELDS, message ("Structure %q declared with %d fields " "(limit is set to %d)", uentry_getName (ue), num, max), uentry_whereLast (ue)); } } return (usymtab_supTypeEntry (ue)); }

ctype declareUnion ( cstring id, uentryList f )

Definition at line 1683 of file clabstract.c. { ctype ct; uentry ue; int num = uentryList_size (f); ct = ctype_createUnion (cstring_copy (id), f); ue = uentry_makeUnionTagLoc (id, ct); if (context_maybeSet (FLG_NUMSTRUCTFIELDS)) { int max = context_getValue (FLG_NUMSTRUCTFIELDS); if (num > max) { voptgenerror (FLG_NUMSTRUCTFIELDS, message ("Union %q declared with %d fields " "(limit is set to %d)", uentry_getName (ue), num, max), uentry_whereLast (ue)); } } return (usymtab_supTypeEntry (ue)); }

ctype declareUnnamedEnum ( enumNameList el )

Definition at line 408 of file clabstract.c. { ctype ret = usymtab_enumEnumNameListType (el); ctype rt; uentry e; if (ctype_isDefined (ret)) { rt = ret; e = uentry_makeEnumTagLoc (ctype_enumTag (rt), ret); reflectStorageClass (e); usymtab_supGlobalEntry (e); declareEnumList (el, ret, g_currentloc); enumNameList_free (el); } else { ctype ct = ctype_createEnum (fakeTag (), el); e = uentry_makeEnumTagLoc (ctype_enumTag (ctype_realType (ct)), ct); reflectStorageClass (e); e = usymtab_supGlobalEntryReturn (e); rt = uentry_getAbstractType (e); declareEnumList (el, ct, g_currentloc); } return (rt); }

ctype declareUnnamedStruct ( uentryList f )

Definition at line 1613 of file clabstract.c. { if (context_maybeSet (FLG_NUMSTRUCTFIELDS)) { int num = uentryList_size (f); int max = context_getValue (FLG_NUMSTRUCTFIELDS); if (num > max) { voptgenerror (FLG_NUMSTRUCTFIELDS, message ("Structure declared with %d fields " "(limit is set to %d)", num, max), g_currentloc); } } return (ctype_createUnnamedStruct (f)); }

ctype declareUnnamedUnion ( uentryList f )

Definition at line 1635 of file clabstract.c. { if (context_maybeSet (FLG_NUMSTRUCTFIELDS)) { int num = uentryList_size (f); int max = context_getValue (FLG_NUMSTRUCTFIELDS); if (num > max) { voptgenerror (FLG_NUMSTRUCTFIELDS, message ("Union declared with %d fields " "(limit is set to %d)", num, max), g_currentloc); } } return (ctype_createUnnamedUnion (f)); }

void doVaDcl ( )

Definition at line 1817 of file clabstract.c. { ctype c = ctype_unknown; cstring id = cstring_makeLiteral ("va_alist"); uentry e; if (ProcessingParams) { int i = uentryList_lookupRealName (saveParamList, id); if (i >= 0) { e = uentry_makeVariableSrefParam (id, c, sRef_makeParam (i, c)); } else { e = uentry_undefined; /* suppress gcc message */ llfatalerrorLoc (cstring_makeLiteral ("va_dcl used without va_alist")); } } else { llerror (FLG_SYNTAX, cstring_makeLiteral ("va_dcl used outside of function declaration")); e = uentry_makeVariableLoc (id, c); } cstring_free (id); uentry_setUsed (e, g_currentloc); usymtab_supEntrySref (e); }

void doneParams ( )

Definition at line 1206 of file clabstract.c. { if (ProcessingParams) { if (uentry_isInvalid (saveFunction)) { llbuglit ("unsetProcessingVars: no saved function\n"); if (sRefSet_isDefined (fcnModifies)) { sRefSet_free (fcnModifies); fcnModifies = sRefSet_undefined; } } else { ctype ct = ctype_returnValue (uentry_getType (saveFunction)); uentryList params = uentryList_copy (saveParamList); ctype ct2 = ctype_makeFunction (ct, params); uentry_setType (saveFunction, ct2); ProcessingParams = FALSE; reflectModGlobs (saveFunction); oldStyleDeclareFunction (saveFunction); saveFunction = uentry_undefined; resetGlobals (); } } else { /* ** If the paramlist used a type name, we could be here. */ llfatalerror (message ("%q: Old-style function parameter list uses a " "type name.", fileloc_unparse (g_currentloc))); } }

void enterParamsTemp ( void )

Definition at line 609 of file clabstract.c. { usymtab_enterScope (); enterFunctionParams (currentParamList); }

void exitParamsTemp ( void )

Definition at line 615 of file clabstract.c. { usymtab_quietPlainExitScope (); }

sRef fixModifiesId ( cstring s )

Definition at line 2109 of file clabstract.c. { sRef ret; cstring pname = makeParam (s); uentry ue = usymtab_lookupSafe (pname); cstring_free (pname); if (cstring_equalLit (s, "nothing")) { ret = sRef_makeNothing (); } else if (cstring_equalLit (s, "internalState")) { ret = sRef_makeInternalState (); } else if (cstring_equalLit (s, "fileSystem") || cstring_equalLit (s, "systemState")) { ret = sRef_makeSystemState (); } else { ret = sRef_undefined; } if (sRef_isValid (ret)) { if (uentry_isValid (ue)) { voptgenerror (FLG_SYNTAX, message ("Modifies list uses %s which is a parameter and has special " "meaning in a modifies list. (Special meaning assumed.)", s), g_currentloc); } } else { if (uentry_isValid (ue)) { ret = uentry_getSref (ue); } else { fileloc loc = fileloc_decColumn (g_currentloc, cstring_length (s)); ret = sRef_undefined; voptgenerror (FLG_UNRECOG, message ("Unrecognized identifier in modifies comment: %s", s), loc); fileloc_free (loc); } } return ret; }

sRef fixSpecClausesId ( cstring s )

Definition at line 2169 of file clabstract.c. { sRef ret; cstring pname = makeParam (s); uentry ue = usymtab_lookupSafe (pname); cstring_free (pname); if (cstring_equalLit (s, "result")) { ret = sRef_makeResult (); } else { ret = sRef_undefined; } if (sRef_isValid (ret)) { if (uentry_isValid (ue)) { voptgenerror (FLG_SYNTAX, message ("Special clause uses %s which is a parameter and has special " "meaning in a special clause. (Special meaning assumed.)", s), g_currentloc); } } else { if (uentry_isValid (ue)) { ret = uentry_getSref (ue); if (sRef_isGlobal (ret)) { voptgenerror (FLG_SYNTAX, message ("Global variable %s used special clause. (Global variables " "are not recognized in special clauses. If there is " "sufficient interest in support for this, it may be " "added to a future release. Send mail to " "lclint@cs.virginia.edu.)", s), g_currentloc); ret = sRef_undefined; } } else { fileloc loc = fileloc_decColumn (g_currentloc, cstring_length (s)); ret = sRef_undefined; voptgenerror (FLG_UNRECOG, message ("Unrecognized identifier in special clause: %s", s), loc); fileloc_free (loc); } } return ret; }

uentryList fixUentryList ( idDeclList tl, qtype q )

Definition at line 1025 of file clabstract.c. { uentryList f = uentryList_new (); idDeclList_elements (tl, i) { if (idDecl_isDefined (i)) { uentry ue; uentry old; ctype rt; (void) idDecl_fixBase (i, q); /* ** implicit annotations */ (void) fixStructDecl (i); ue = uentry_makeIdVariable (i); rt = ctype_realType (uentry_getType (ue)); /* ** where is this here??? if (ctype_isArray (rt) || ctype_isSU (rt)) { sRef_setAllocated (uentry_getSref (ue), uentry_whereDefined (ue)); } ** */ if (uentry_isValid (old = uentryList_lookupField (f, uentry_rawName (ue)))) { if (optgenerror (FLG_SYNTAX, message ("Field name reused: %s", uentry_rawName (ue)), uentry_whereDefined (ue))) { llgenmsg (message ("Previous use of %s", uentry_rawName (ue)), uentry_whereDefined (old)); } } f = uentryList_add (f, ue); } } end_idDeclList_elements; idDeclList_free (tl); return (f); }

uentryList fixUnnamedDecl ( qtype q )

Definition at line 1088 of file clabstract.c. { ctype ct = ctype_realType (qtype_getType (q)); if (ctype_isStruct (ct) || ctype_isUnion (ct)) { uentryList res = ctype_getFields (ct); return (uentryList_copy (res)); } else { BADBRANCHCONT; } return uentryList_undefined; }

uentry getCurrentIter ( void )

Definition at line 1759 of file clabstract.c. { return currentIter; }

void globListAdd ( sRef sr, qualList quals )

Definition at line 352 of file clabstract.c. { if (sRef_isValid (sr)) { sRef sc = sRef_copy (sr); reflectGlobalQualifiers (sc, quals); currentGlobals = globSet_insert (currentGlobals, sc); } }

sRef globListUnrecognized ( cstring s )

Definition at line 1939 of file clabstract.c. { if (cstring_equalLit (s, "nothing")) { return sRef_makeNothing (); } else if (cstring_equalLit (s, "internalState")) { return sRef_makeInternalState (); } else if (cstring_equalLit (s, "fileSystem") || cstring_equalLit (s, "systemState")) { return sRef_makeSystemState (); } else { voptgenerror (FLG_UNRECOG, message ("Unrecognized identifier in globals list: %s", s), g_currentloc); return sRef_undefined; } }

ctype handleEnum ( cstring id )

Definition at line 1740 of file clabstract.c. { if (usymtab_existsEnumTag (id)) { ctype ret = uentry_getAbstractType (usymtab_lookupEnumTag (id)); cstring_free (id); return ret; } else { return (declareEnum (id, enumNameList_new ())); } }

uentryList handleParamIdList ( uentryList params )

Definition at line 1772 of file clabstract.c. { int paramno = 0; /* ** this is a really YUCKY hack to handle old style ** declarations. */ voptgenerror (FLG_OLDSTYLE, cstring_makeLiteral ("Old style function declaration"), g_currentloc); uentryList_elements (params, current) { uentry_setParam (current); uentry_setSref (current, sRef_makeParam (paramno, ctype_unknown)); paramno++; } end_uentryList_elements; setGenericParamList (params); g_expectingTypeName = TRUE; return params; }

uentryList handleParamTypeList ( uentryList params )

Definition at line 1798 of file clabstract.c. { if (flipOldStyle) { uentryList_fixMissingNames (params); voptgenerror (FLG_OLDSTYLE, cstring_makeLiteral ("Old style function declaration."), g_currentloc); setGenericParamList (params); flipOldStyle = FALSE; g_expectingTypeName = TRUE; } return (params); }

ctype handleStruct ( cstring id )

Definition at line 1710 of file clabstract.c. { if (usymtab_existsStructTag (id)) { ctype ct = uentry_getAbstractType (usymtab_lookupStructTag (id)); cstring_free (id); return ct; } else { return (ctype_createForwardStruct (id)); } }

ctype handleUnion ( cstring id )

Definition at line 1725 of file clabstract.c. { if (usymtab_existsUnionTag (id)) { ctype ret = uentry_getAbstractType (usymtab_lookupUnionTag (id)); cstring_free (id); return (ret); } else { return (ctype_createForwardUnion (id)); } }

bool isFlipOldStyle ( )

Definition at line 1768 of file clabstract.c. { return flipOldStyle; }

bool isNewStyle ( )

Definition at line 1769 of file clabstract.c. { return flipNewStyle; }

bool isProcessingGlobMods ( )

Definition at line 1154 of file clabstract.c. { return (ProcessingGlobMods); }

int iterParamNo ( void )

Definition at line 384 of file clabstract.c. Referenced by exprNode_iterExpr(), exprNode_iterId(), and exprNode_iterNewId(). { llassert (ProcessingIterVars); return saveIterParamNo; }

uentry makeCurrentParam ( idDecl t )

Definition at line 395 of file clabstract.c. { uentry ue; saveStoreLoc = fileloc_undefined; /* param number unknown */ ue = uentry_makeParam (t, 0); return ue; }

sRef modListArrayFetch ( sRef s, sRef mexp )

Definition at line 2235 of file clabstract.c. { ctype ct = sRef_getType (s); ctype rt = ctype_realType (ct); if (ctype_isAP (rt)) { if (context_inHeader () && ctype_isAbstract (ct)) { voptgenerror (FLG_ABSTRACT, message ("Modifies clause in header file indexes abstract " "type %s (interface modifies clause should not depend " "on or expose type representation): %q", ctype_unparse (ct), sRef_unparse (s)), g_currentloc); } return (sRef_makeAnyArrayFetch (s)); } else { voptgenerror (FLG_TYPE, message ("Implementation modifies clause uses array fetch on non-array (type %s): %q", ctype_unparse (ct), sRef_unparse (s)), g_currentloc); return s; } }

sRef modListArrowAccess ( sRef s, cstring f )

Definition at line 1965 of file clabstract.c. { ctype ct = sRef_getType (s); ctype rt = ctype_realType (ct); if (ctype_isRealPointer (rt)) { ctype b = ctype_baseArrayPtr (rt); ctype rb = ctype_realType (b); if (ctype_isStructorUnion (rb)) { uentry tf = uentryList_lookupField (ctype_getFields (rb), f); if (uentry_isUndefined (tf)) { voptgenerror (FLG_TYPE, message ("Modifies list arrow accesses non-existent " "field %s of %t: %q", f, b, sRef_unparse (s)), g_currentloc); cstring_free (f); return sRef_undefined; } else { if (context_inHeader ()) { if (ctype_isAbstract (b)) { voptgenerror (FLG_ABSTRACT, message ("Modifies clause in header file arrow accesses abstract " "type %s (interface modifies clause should not depend " "on or expose type representation): %q", ctype_unparse (b), sRef_unparse (s)), g_currentloc); } } else { if (ctype_isAbstract (ct)) { voptgenerror (FLG_ABSTRACT, message ("Modifies clause in header file arrow accesses abstract " "type %s (interface modifies clause should not depend " "on or expose type representation): %q", ctype_unparse (ct), sRef_unparse (s)), g_currentloc); } } } cstring_markOwned (f); return (sRef_makeArrow (s, f)); } else { voptgenerror (FLG_TYPE, message ("Modifies clause arrow accesses pointer to " "non-structure (type %s): %q", ctype_unparse (rt), sRef_unparse (s)), g_currentloc); } } else { voptgenerror (FLG_TYPE, message ("Modifies clause arrow accesses non-pointer (type %s): %q", ctype_unparse (rt), sRef_unparse (s)), g_currentloc); } cstring_free (f); return s; }

sRef modListFieldAccess ( sRef s, cstring f )

Definition at line 1886 of file clabstract.c. { ctype ct = sRef_getType (s); ctype rt = ctype_realType (ct); if (ctype_isStructorUnion (rt)) { uentry tf = uentryList_lookupField (ctype_getFields (rt), f); if (uentry_isUndefined (tf)) { voptgenerror (FLG_TYPE, message ("Modifies list accesses non-existent " "field %s of %t: %q", f, ct, sRef_unparse (s)), g_currentloc); cstring_free (f); return sRef_undefined; } else { if (ctype_isAbstract (ct) && context_inHeader ()) { voptgenerror (FLG_ABSTRACT, message ("Modifies clause in header file accesses abstract " "type %s (interface modifies clause should not depend " "on or expose type representation): %q", ctype_unparse (ct), sRef_unparse (s)), g_currentloc); } } cstring_markOwned (f); return (sRef_makeField (s, f)); } else { voptgenerror (FLG_TYPE, message ("Modifies clause dereferences non-pointer (type %s): %q", ctype_unparse (rt), sRef_unparse (s)), g_currentloc); cstring_free (f); return s; } }

sRef modListPointer ( sRef s )

Definition at line 1848 of file clabstract.c. { ctype ct = sRef_getType (s); ctype rt = ctype_realType (ct); if (ctype_isAP (rt)) { if (context_inHeader () && ctype_isAbstract (ct)) { voptgenerror (FLG_ABSTRACT, message ("Modifies clause in header file dereferences abstract " "type %s (interface modifies clause should not depend " "on or expose type representation): %q", ctype_unparse (ct), sRef_unparse (s)), g_currentloc); } return (sRef_constructPointer (s)); } else { if (ctype_isKnown (rt)) { voptgenerror (FLG_TYPE, message ("Implementation modifies clause dereferences non-pointer (type %s): %q", ctype_unparse (rt), sRef_unparse (s)), g_currentloc); } return s; } }

void nextIterParam ( void )

Definition at line 378 of file clabstract.c. { llassert (ProcessingIterVars); saveIterParamNo++; }

void processNamedDecl ( idDecl t )

Definition at line 1327 of file clabstract.c. { if (qtype_isUndefined (processingType)) { llparseerror (message ("No type before declaration name: %q", idDecl_unparse (t))); processingType = qtype_create (ctype_unknown); } t = idDecl_fixBase (t, processingType); DPRINTF (("Declare: %s", idDecl_unparse (t))); if (ProcessingGlobals) { cstring id = idDecl_getName (t); uentry ue = usymtab_lookupSafe (id); if (!uentry_isValid (ue)) { llerror (FLG_UNRECOG, message ("Variable used in globals list is undeclared: %s", id)); } else { if (!ctype_match (uentry_getType (ue), idDecl_getCtype (t))) { voptgenerror (FLG_INCONDEFS, message ("Variable %s used in globals list declared %s, " "but listed as %s", id, ctype_unparse (uentry_getType (ue)), ctype_unparse (idDecl_getCtype (t))), g_currentloc); } else { sRef sr = sRef_copy (uentry_getSref (ue)); reflectGlobalQualifiers (sr, idDecl_getQuals (t)); currentGlobals = globSet_insert (currentGlobals, sr); } } } else if (ProcessingVars) { uentry e; ctype ct; ct = ctype_realType (idDecl_getCtype (t)); if (ProcessingParams) { cstring id = idDecl_getName (t); int paramno = uentryList_lookupRealName (saveParamList, id); if (paramno >= 0) { uentry cparam = uentryList_getN (saveParamList, paramno); uentry_setType (cparam, idDecl_getCtype (t)); uentry_reflectQualifiers (cparam, idDecl_getQuals (t)); uentry_setDeclaredOnly (cparam, context_getSaveLocation ()); } else { llfatalerrorLoc (message ("Old style declaration uses unlisted parameter: %s", id)); } } else { fileloc loc; if (context_inIterDef ()) { cstring pname = makeParam (idDecl_observeId (t)); uentry p = usymtab_lookupSafe (pname); cstring_free (pname); if (uentry_isYield (p)) { e = uentry_makeParam (t, sRef_getParam (uentry_getSref (p))); uentry_checkYieldParam (p, e); usymtab_supEntrySref (e); return; } } if ((hasSpecialCode () || argsUsed) && ctype_isFunction (idDecl_getCtype (t))) { e = uentry_makeIdFunction (t); reflectSpecialCode (e); reflectArgsUsed (e); } else { e = uentry_makeIdVariable (t); } loc = uentry_whereDeclared (e); /* if (context_inGlobalScope ()) { uentry_checkParams was here! } */ if (ctype_isFunction (uentry_getType (e))) { reflectModGlobs (e); } else { llassert (!globSet_isDefined (currentGlobals) && !sRefSet_isDefined (fcnModifies)); } e = usymtab_supEntrySrefReturn (e); if (uentry_isExtern (e) && !context_inGlobalScope ()) { voptgenerror (FLG_NESTEDEXTERN, message ("Declaration using extern inside function scope: %q", uentry_unparse (e)), g_currentloc); uentry_setDefined (e, fileloc_getExternal ()); sRef_setDefined (uentry_getSref (e), fileloc_getExternal ()); } if (uentry_isFunction (e)) { uentry_checkParams (e); checkParamNames (e); } if (uentry_isVar (e) && uentry_isCheckedUnknown (e)) { sRef sr = uentry_getSref (e); if (sRef_isLocalVar (sr)) { if (context_getFlag (FLG_IMPCHECKMODINTERNALS)) { uentry_setCheckMod (e); } else { uentry_setUnchecked (e); } } else if (sRef_isFileStatic (sr)) { if (context_getFlag (FLG_IMPCHECKEDSTRICTSTATICS)) { uentry_setCheckedStrict (e); } else if (context_getFlag (FLG_IMPCHECKEDSTATICS)) { uentry_setChecked (e); } else if (context_getFlag (FLG_IMPCHECKMODSTATICS)) { uentry_setCheckMod (e); } else { ; } } else /* real global */ { llassert (sRef_isRealGlobal (sr)); if (context_getFlag (FLG_IMPCHECKEDSTRICTGLOBALS)) { uentry_setCheckedStrict (e); } else if (context_getFlag (FLG_IMPCHECKEDGLOBALS)) { uentry_setChecked (e); } else if (context_getFlag (FLG_IMPCHECKMODGLOBALS)) { uentry_setCheckMod (e); } else { ; } } } } } else if (ProcessingTypedef) { ctype ct = idDecl_getCtype (t); uentry e; DPRINTF (("Processing typedef: %s", ctype_unparse (ct))); e = uentry_makeIdDatatype (t); if (cstring_equal (idDecl_getName (t), context_getBoolName ())) { ctype rt = ctype_realType (ct); if (ctype_isEnum (rt)) { ; } else { if (!(ctype_isInt (rt) || ctype_isUnknown (rt) || ctype_isChar (rt))) { (void) llgenerror (FLG_BOOLTYPE, message ("Boolean type %s defined using non-standard type %s (integral, char or enum type expected)", context_getBoolName (), ctype_unparse (ct)), uentry_whereLast (e)); } ct = ctype_bool; uentry_setType (e, ct); } } reflectStorageClass (e); checkTypeDecl (e, ct); e = usymtab_supReturnTypeEntry (e); if (uentry_isMaybeAbstract (e)) { if (context_getFlag (FLG_IMPABSTRACT)) { uentry_setAbstract (e); } else { uentry_setConcrete (e); } } } else { llparseerror (message ("Suspect missing struct or union keyword: %q", idDecl_unparse (t))); } }

bool processingIterVars ( void )

Definition at line 1754 of file clabstract.c. Referenced by exprNode_iterExpr(). { return ProcessingIterVars; }

void setArgsUsed ( void )

Definition at line 82 of file clabstract.c. { if (argsUsed) { voptgenerror (FLG_SYNTAX, cstring_makeLiteral ("Multiple ARGSUSED comments for one function"), g_currentloc); } argsUsed = TRUE; }

void setCurrentParams ( uentryList ue )

Definition at line 577 of file clabstract.c. { currentParamList = ue; }

void setFlipOldStyle ( )

Definition at line 1767 of file clabstract.c. { flipOldStyle = TRUE; }

void setFunctionModifies ( sRefSet s )

Definition at line 271 of file clabstract.c. { sRefSet_free (fcnModifies); fcnModifies = s; }

void setFunctionNoGlobals ( void )

Definition at line 210 of file clabstract.c. { llassert (globSet_isUndefined (currentGlobals)); fcnNoGlobals = TRUE; }

void setFunctionSpecialClause ( lltok stok, sRefSet s, lltok etok )

Definition at line 241 of file clabstract.c. { int tok = lltok_getTok (stok); switch (tok) { case QUSES: specClauses = specialClauses_add (specClauses, specialClause_createUses (s)); break; case QDEFINES: specClauses = specialClauses_add (specClauses, specialClause_createDefines (s)); break; case QALLOCATES: specClauses = specialClauses_add (specClauses, specialClause_createAllocates (s)); break; case QSETS: specClauses = specialClauses_add (specClauses, specialClause_createSets (s)); break; case QRELEASES: specClauses = specialClauses_add (specClauses, specialClause_createReleases (s)); break; default: sRefSet_free (s); BADBRANCH; } DPRINTF (("Added to specclauses: %s", specialClauses_unparse (specClauses))); }

void setFunctionStateSpecialClause ( lltok stok, specialClauseKind kind, sRefSet s, lltok etok )

Definition at line 217 of file clabstract.c. { int tok = lltok_getTok (stok); switch (tok) { case QPRECLAUSE: specClauses = specialClauses_add (specClauses, specialClause_create (TK_BEFORE, kind, s)); break; case QPOSTCLAUSE: specClauses = specialClauses_add (specClauses, specialClause_create (TK_AFTER, kind, s)); break; default: sRefSet_free (s); BADBRANCH; } DPRINTF (("Added to specclauses: %s", specialClauses_unparse (specClauses))); }

void setNewStyle ( )

Definition at line 1770 of file clabstract.c. { flipNewStyle = TRUE; }

void setProcessingGlobMods ( )

Definition at line 1142 of file clabstract.c. { ProcessingGlobMods = TRUE; }

void setProcessingGlobalsList ( )

Definition at line 1120 of file clabstract.c. { ProcessingGlobals = TRUE; llassert (globSet_isUndefined (currentGlobals)); currentGlobals = globSet_undefined; llassert (sRefSet_isUndefined (fcnModifies)); fcnModifies = sRefSet_undefined; /* ** No, special clauses might have been processed first! llassert (specialClauses_isUndefined (specClauses)); specClauses = specialClauses_undefined; */ fcnNoGlobals = FALSE; }

void setProcessingIterVars ( uentry iter )

Definition at line 1112 of file clabstract.c. { ProcessingIterVars = TRUE; currentIter = iter; saveIterParamNo = 0; }

void setProcessingTypedef ( qtype q )

Definition at line 1190 of file clabstract.c. { ProcessingTypedef = TRUE; qtype_free (processingType); processingType = q; }

void setProcessingVars ( qtype q )

Definition at line 1175 of file clabstract.c. { ProcessingVars = TRUE; qtype_free (processingType); processingType = q; }

void setSpecialFunction ( qual qu )

Definition at line 113 of file clabstract.c. { if (specialFunctionCode != QU_UNKNOWN) { voptgenerror (FLG_SYNTAX, message ("Multiple special function codes: %s, %s " "(first code is ignored)", qual_unparse (specialFunctionCode), qual_unparse (qu)), g_currentloc); } specialFunctionCode = qu; }

void setStorageClass ( storageClassCode sc )

Definition at line 1106 of file clabstract.c. { storageClass = sc; }

void storeLoc ( )

Definition at line 205 of file clabstract.c. { saveStoreLoc = g_currentloc; }

void unsetProcessingGlobals ( )

Definition at line 1169 of file clabstract.c. { ProcessingGlobals = FALSE; }

void unsetProcessingTypedef ( )

Definition at line 1273 of file clabstract.c. { ProcessingTypedef = FALSE; }

void unsetProcessingVars ( )

Definition at line 1199 of file clabstract.c. { resetStorageClass (); ProcessingVars = FALSE; }

---