---

exprNode.c File Reference

#include <ctype.h>
#include "lclintMacros.nf"
#include "basic.h"
#include "cgrammar.h"
#include "cgrammar_tokens.h"
#include "exprChecks.h"
#include "aliasChecks.h"
#include "exprNodeSList.h"
#include "exprData.i"

Go to the source code of this file.

Functions
void	exprNode_initMod (void)
void	exprNode_destroyMod (void)
void	exprNode_freeShallow ( exprNode e)
void	exprNode_free (exprNode e)
exprNode	exprNode_makeError ()
exprNode	exprNode_makeMustExit (void)
bool	exprNode_isNullValue (exprNode e)
exprNode	exprNode_numLiteral (ctype c, cstring t, fileloc loc, long val)
exprNode	exprNode_charLiteral (char c, cstring text, fileloc loc)
exprNode	exprNode_floatLiteral (double d, ctype ct, cstring text, fileloc loc)
multiVal	exprNode_getValue (exprNode e)
exprNode	exprNode_stringLiteral ( cstring t, fileloc loc)
exprNode	exprNode_fromUIO (cstring c)
exprNode	exprNode_createId ( uentry c)
exprNode	exprNode_fromIdentifier ( uentry c)
exprNode	exprNode_arrayFetch ( exprNode e1, exprNode e2)
uentry	exprNode_getUentry (exprNode e)
exprNode	exprNode_makeInitBlock (lltok brace, exprNodeList inits)
exprNode	exprNode_functionCall ( exprNode f, exprNodeList args)
exprNode	exprNode_fieldAccess ( exprNode s, cstring f)
exprNode	exprNode_addParens ( lltok lpar, exprNode e)
exprNode	exprNode_arrowAccess ( exprNode s, cstring f)
exprNode	exprNode_postOp ( exprNode e, lltok op)
exprNode	exprNode_preOp ( exprNode e, lltok op)
exprNode	exprNode_sizeofType ( qtype qt)
exprNode	exprNode_alignofType ( qtype qt)
exprNode	exprNode_offsetof (qtype qt, cstringList s)
exprNode	exprNode_sizeofExpr ( exprNode e)
exprNode	exprNode_alignofExpr ( exprNode e)
exprNode	exprNode_cast ( lltok tok, exprNode e, qtype q)
exprNode	exprNode_op ( exprNode e1, exprNode e2, lltok op)
exprNode	exprNode_assign ( exprNode e1, exprNode e2, lltok op)
exprNode	exprNode_cond ( exprNode pred, exprNode ifclause, exprNode elseclause)
exprNode	exprNode_vaArg ( lltok tok, exprNode arg, qtype qt)
exprNode	exprNode_labelMarker ( cstring label)
exprNode	exprNode_notReached ( exprNode stmt)
bool	exprNode_isDefaultMarker (exprNode e)
bool	exprNode_isCaseMarker (exprNode e)
bool	exprNode_isLabelMarker (exprNode e)
exprNode	exprNode_caseMarker ( exprNode test, bool fallThrough)
exprNode	exprNode_defaultMarker ( lltok def, bool fallThrough)
bool	exprNode_mayEscape (exprNode e)
bool	exprNode_mustEscape (exprNode e)
bool	exprNode_errorEscape (exprNode e)
exprNode	exprNode_concat ( exprNode e1, exprNode e2)
exprNode	exprNode_createTok ( lltok t)
exprNode	exprNode_statement ( exprNode e)
exprNode	exprNode_checkExpr ( exprNode e)
void	exprNode_produceGuards (exprNode pred)
exprNode	exprNode_makeBlock ( exprNode e)
bool	exprNode_isAssign (exprNode e)
exprNode	exprNode_if ( exprNode pred, exprNode tclause)
exprNode	exprNode_ifelse ( exprNode pred, exprNode tclause, exprNode eclause)
exprNode	exprNode_switch ( exprNode e, exprNode s)
exprNode	exprNode_while ( exprNode t, exprNode b)
exprNode	exprNode_doWhile ( exprNode b, exprNode t)
exprNode	exprNode_for ( exprNode inc, exprNode body)
guardSet	exprNode_getForGuards (exprNode pred)
exprNode	exprNode_whilePred ( exprNode test)
exprNode	exprNode_forPred ( exprNode init, exprNode test, exprNode inc)
exprNode	exprNode_goto ( cstring label)
exprNode	exprNode_continue ( lltok l, int qcontinue)
exprNode	exprNode_break ( lltok l, int bqual)
exprNode	exprNode_nullReturn ( lltok t)
exprNode	exprNode_return ( exprNode e)
exprNode	exprNode_comma ( exprNode e1, exprNode e2)
exprNode	exprNode_makeInitialization ( idDecl t, exprNode e)
exprNode	exprNode_iter ( uentry name, exprNodeList alist, exprNode body, uentry end)
exprNode	exprNode_iterNewId ( cstring s)
exprNode	exprNode_iterExpr ( exprNode e)
exprNode	exprNode_iterId ( uentry c)
exprNode	exprNode_iterStart ( uentry name, exprNodeList alist)
sRef	exprNode_getSref (exprNode e)
cstring	exprNode_unparseFirst (exprNode e)
cstring	exprNode_unparse (exprNode e)
fileloc	exprNode_loc (exprNode e)
bool	exprNode_isCharLit (exprNode e)
bool	exprNode_isNumLit (exprNode e)
bool	exprNode_matchLiteral (ctype expected, exprNode e)
bool	exprNode_matchType (ctype expected, exprNode e)
void	exprNode_checkSet (exprNode e, sRef s)
void	exprNode_checkMSet (exprNode e, sRef s)
void	exprNode_checkUseParam (exprNode current)
exprNode	exprNode_updateLocation ( exprNode e, fileloc loc)
long	exprNode_getLongValue (exprNode e)

---

Function Documentation

exprNode exprNode_addParens ( lltok lpar, exprNode e )

Definition at line 3343 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (e); ret->loc = fileloc_update (ret->loc, lltok_getLoc (lpar)); ret->kind = XPR_PARENS; ret->edata = exprData_makeUop (e, lpar); if (!exprNode_isError (e)) { ret->exitCode = e->exitCode; ret->canBreak = e->canBreak; ret->mustBreak = e->mustBreak; ret->isJumpPoint = e->isJumpPoint; ret->sref = e->sref; } return ret; }

exprNode exprNode_alignofExpr ( exprNode e )

Definition at line 4042 of file exprNode.c. { exprNode ret; if (exprNode_isUndefined (e)) { ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc)); } else { ret = exprNode_createPartialCopy (e); } ret->edata = exprData_makeSingle (e); ret->typ = sizeof_resultType (); ret->kind = XPR_ALIGNOF; /* ** sizeof (x) doesn't "really" use x */ return (ret); }

exprNode exprNode_alignofType ( qtype qt )

Definition at line 3905 of file exprNode.c. { exprNode ret = exprNode_create (sizeof_resultType ()); ctype ct = qtype_getType (qt); ret->kind = XPR_ALIGNOFT; ret->edata = exprData_makeSizeofType (qt); voptgenerror (FLG_SIZEOFTYPE, message ("Parameter to alignof is type %s: %s", ctype_unparse (ct), exprNode_unparse (ret)), ret->loc); return (ret); }

exprNode exprNode_arrayFetch ( exprNode e1, exprNode e2 )

Definition at line 976 of file exprNode.c. { /* ** error in arr, error propagates (no new messages) ** error in ind, assume valid and continue */ if (exprNode_isError (e1)) { exprNode_free (e2); return (exprNode_makeError ()); } else { exprNode arr; exprNode ind; ctype carr = exprNode_getType (e1); ctype crarr = ctype_realType (carr); /* ** this sets up funny aliasing, that leads to spurious ** lclint errors. Hence, the i2 comments. */ if (!ctype_isRealArray (crarr) && ctype_isRealNumeric (crarr) && !exprNode_isError (e2) && ctype_isRealAP (exprNode_getType (e2))) /* fetch like 3[a] */ { arr = e2; ind = e1; carr = exprNode_getType (arr); crarr = ctype_realType (carr); } else { arr = e1; ind = e2; } if (sRef_possiblyNull (arr->sref)) { if (!usymtab_isGuarded (arr->sref)) { if (optgenerror (FLG_NULLDEREF, message ("Index of %s pointer %q: %s", sRef_nullMessage (arr->sref), sRef_unparse (arr->sref), exprNode_unparse (arr)), arr->loc)) { sRef_showNullInfo (arr->sref); /* suppress future messages */ sRef_setNullError (arr->sref); } } } if (exprNode_isError (ind)) { if ((ctype_isArrayPtr (crarr) && !ctype_isFunction (crarr)) || ctype_isUnknown (carr)) { exprNode ret = exprNode_createPartialCopy (arr); if (ctype_isKnown (carr)) { ret->typ = ctype_baseArrayPtr (crarr); } else { ret->typ = ctype_unknown; } ret->sref = sRef_makeArrayFetch (arr->sref); ret->kind = XPR_FETCH; /* ** Because of funny aliasing (when arr and ind are ** flipped) spurious errors would be reported here. */ /*@i2@*/ ret->edata = exprData_makePair (arr, ind); checkSafeUse (ret, arr->sref); return (ret); } else { voptgenerror (FLG_TYPE, message ("Array fetch from non-array (%t): %s[%s]", carr, exprNode_unparse (e1), exprNode_unparse (e2)), arr->loc); exprNode_free (arr); return (exprNode_makeError ()); } } else { if (!ctype_isForceRealInt (&(ind->typ))) { ctype rt = ctype_realType (ind->typ); if (ctype_isChar (rt)) { vnoptgenerror (FLG_CHARINDEX, message ("Array fetch using non-integer, %t: %s[%s]", ind->typ, exprNode_unparse (e1), exprNode_unparse (e2)), arr->loc); } else if (ctype_isEnum (rt)) { vnoptgenerror (FLG_ENUMINDEX, message ("Array fetch using non-integer, %t: %s[%s]", ind->typ, exprNode_unparse (e1), exprNode_unparse (e2)), arr->loc); } else { voptgenerror (FLG_TYPE, message ("Array fetch using non-integer, %t: %s[%s]", ind->typ, exprNode_unparse (e1), exprNode_unparse (e2)), arr->loc); } multiVal_free (ind->val); ind->val = multiVal_unknown (); } if (ctype_isArrayPtr (crarr) && !ctype_isFunction (crarr)) { exprNode ret = exprNode_createSemiCopy (arr); multiVal m = exprNode_getValue (ind); ret->typ = ctype_baseArrayPtr (crarr); ret->kind = XPR_FETCH; if (multiVal_isInt (m)) { int i = (int) multiVal_forceInt (m); if (sRef_isValid (arr->sref)) { ret->sref = sRef_makeArrayFetchKnown (arr->sref, i); } else { ret->sref = sRef_undefined; } } else { ret->sref = sRef_makeArrayFetch (arr->sref); } ret->sets = sRefSet_realNewUnion (arr->sets, ind->sets); ret->msets = sRefSet_realNewUnion (arr->msets, ind->msets); ret->uses = sRefSet_realNewUnion (arr->uses, ind->uses); /* (see comment on spurious errors above) */ /*@i2@*/ ret->edata = exprData_makePair (arr, ind); exprNode_checkUse (ret, ind->sref, ind->loc); exprNode_checkUse (ret, arr->sref, arr->loc); return (ret); } else { if (ctype_isUnknown (carr)) { exprNode ret = exprNode_createPartialCopy (arr); ret->kind = XPR_FETCH; ret->typ = ctype_unknown; ret->sets = sRefSet_union (ret->sets, ind->sets); ret->msets = sRefSet_union (ret->msets, ind->msets); ret->uses = sRefSet_union (ret->uses, ind->uses); /* (see comment on spurious errors above) */ /*@i2@*/ ret->edata = exprData_makePair (arr, ind); exprNode_checkUse (ret, ind->sref, ind->loc); exprNode_checkUse (ret, arr->sref, arr->loc); return (ret); } else { voptgenerror (FLG_TYPE, message ("Array fetch from non-array (%t): %s[%s]", carr, exprNode_unparse (e1), exprNode_unparse (e2)), arr->loc); exprNode_free (arr); exprNode_free (ind); return (exprNode_makeError ()); } } } } BADEXIT; }

exprNode exprNode_arrowAccess ( exprNode s, cstring f )

Definition at line 3364 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (s); ret->edata = exprData_makeField (s, f); ret->kind = XPR_ARROW; if (exprNode_isError (s)) { return (ret); } else { ctype t = exprNode_getType (s); ctype tr = ctype_realType (t); checkMacroParen (s); (void) ctype_fixArrayPtr (tr); /* REWRITE THIS */ if (ctype_isRealPointer (tr)) { ctype b = ctype_realType (ctype_baseArrayPtr (tr)); if (ctype_isStructorUnion (b)) { uentry fentry = uentryList_lookupField (ctype_getFields (b), f); if (sRef_isKnown (s->sref) && sRef_possiblyNull (s->sref)) { if (!usymtab_isGuarded (s->sref) && !context_inProtectVars ()) { if (optgenerror (FLG_NULLDEREF, message ("Arrow access from %s pointer%q: %s", sRef_nullMessage (s->sref), sRef_unparsePreOpt (s->sref), exprNode_unparse (ret)), s->loc)) { sRef_showNullInfo (s->sref); sRef_setNullError (s->sref); } } } if (uentry_isUndefined (fentry)) { voptgenerror (FLG_TYPE, message ("Access non-existent field %s of %t: %s", f, t, exprNode_unparse (ret)), s->loc); ret->typ = ctype_unknown; return (ret); } else { /* ** was safeUse: shouldn't be safe! ** ** to do rec->field ** rec must be defined, ** *rec must be allocated ** rec->field need only be defined it if is an rvalue */ uentry_setUsed (fentry, exprNode_loc (ret)); ret->typ = uentry_getType (fentry); exprNode_checkUse (ret, s->sref, s->loc); /* exprNode_checkUse (ret, sRef_makePointer (s->sref), s->loc); */ ret->sref = sRef_makeArrow (s->sref, uentry_rawName (fentry)); return (ret); } } else /* Pointer to something that is not a struct or union*/ { if (ctype_isRealAbstract (tr)) { ctype xrt = ctype_forceRealType (tr); voptgenerror (FLG_ABSTRACT, message ("Arrow access field of abstract type (%t): %s->%s", t, exprNode_unparse (s), f), s->loc); /* ** Set the state correctly, as if the abstraction is broken. */ if (ctype_isRealPointer (xrt) && (b = ctype_realType (ctype_baseArrayPtr (xrt)), ctype_isStructorUnion (b))) { uentry fentry = uentryList_lookupField (ctype_getFields (b), f); ret->typ = uentry_getType (fentry); ret->sref = sRef_makeArrow (s->sref, uentry_rawName (fentry)); } else { ret->typ = ctype_unknown; ret->sref = sRef_undefined; } } else /* not a struct, union or abstract */ { if (ctype_isUnknown (tr)) { cstring sn = cstring_copy (f); DPRINTF (("Here: %s", exprNode_unparse (s))); exprNode_checkUse (ret, s->sref, s->loc); exprNode_checkUse (ret, sRef_makePointer (s->sref), s->loc); cstring_markOwned (sn); ret->sref = sRef_makeArrow (s->sref, sn); ret->kind = XPR_ARROW; return (ret); } else { voptgenerror (FLG_TYPE, message ("Arrow access field of non-struct or union " "pointer (%t): %s->%s", t, exprNode_unparse (s), f), s->loc); ret->typ = ctype_unknown; ret->sref = sRef_undefined; } } } } else /* its not a pointer */ { if (!ctype_isUnknown (tr)) { voptgenerror (FLG_TYPE, message ("Arrow access of non-pointer (%t): %s->%s", t, exprNode_unparse (s), f), s->loc); ret->typ = ctype_unknown; ret->sref = sRef_undefined; } else { cstring sn = cstring_copy (f); DPRINTF (("Here: %s", exprNode_unparse (s))); exprNode_checkUse (ret, s->sref, s->loc); exprNode_checkUse (ret, sRef_makePointer (s->sref), s->loc); cstring_markOwned (sn); ret->sref = sRef_makeArrow (s->sref, sn); ret->kind = XPR_ARROW; return (ret); } } return (ret); } BADEXIT; }

exprNode exprNode_assign ( exprNode e1, exprNode e2, lltok op )

Definition at line 4932 of file exprNode.c. { bool isalloc = FALSE; bool isjustalloc = FALSE; exprNode ret; DPRINTF (("%s [%s] <- %s [%s]", exprNode_unparse (e1), ctype_unparse (e1->typ), exprNode_unparse (e2), ctype_unparse (e2->typ))); if (lltok_getTok (op) != TASSIGN) { ret = exprNode_makeOp (e1, e2, op); } else { ret = exprNode_createPartialCopy (e1); ret->kind = XPR_ASSIGN; ret->edata = exprData_makeOp (e1, e2, op); if (!exprNode_isError (e2)) { ret->sets = sRefSet_union (ret->sets, e2->sets); ret->msets = sRefSet_union (ret->msets, e2->msets); ret->uses = sRefSet_union (ret->uses, e2->uses); } } checkExpressionDefined (e1, e2, op); if (exprNode_isError (e1)) { if (!exprNode_isError (e2)) { ret->loc = fileloc_update (ret->loc, e2->loc); } else { ret->loc = fileloc_update (ret->loc, g_currentloc); } } if (!exprNode_isError (e2)) { checkMacroParen (e2); } if (exprNode_isDefined (e1)) { if (sRef_isMacroParamRef (e1->sref)) { if (context_inIterDef ()) { uentry ue = sRef_getUentry (e1->sref); if (uentry_isYield (ue)) { ; } else { if (fileloc_isDefined (e1->loc)) { voptgenerror (FLG_MACROPARAMS, message ("Assignment to non-yield iter parameter: %q", sRef_unparse (e1->sref)), e1->loc); } else { voptgenerror (FLG_MACROPARAMS, message ("Assignment to non-yield iter parameter: %q", sRef_unparse (e1->sref)), g_currentloc); } } } else { if (fileloc_isDefined (e1->loc)) { voptgenerror (FLG_MACROASSIGN, message ("Assignment to macro parameter: %q", sRef_unparse (e1->sref)), e1->loc); } else { voptgenerror (FLG_MACROASSIGN, message ("Assignment to macro parameter: %q", sRef_unparse (e1->sref)), g_currentloc); } } } else { exprNode_checkAssignMod (e1, ret); } if (exprNode_isDefined (e2)) { if (lltok_getTok (op) == TASSIGN) { ctype te1 = exprNode_getType (e1); ctype te2 = exprNode_getType (e2); if (!ctype_forceMatch (te1, te2)) { if (exprNode_matchLiteral (te1, e2)) { ; } else { (void) gentypeerror (te2, e2, te1, e1, message ("Assignment of %t to %t: %s %s %s", te2, te1, exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)), e1->loc); } } } exprNode_mergeUSs (ret, e2); exprNode_checkUse (ret, e2->sref, e2->loc); doAssign (e1, e2, FALSE); ret->sref = e1->sref; } else { if (exprNode_isDefined (e2)) { exprNode_mergeUSs (ret, e2); exprNode_checkUse (ret, e2->sref, e2->loc); } } if (sRef_isPointer (e1->sref) && !sRef_isMacroParamRef (e1->sref)) { exprNode_checkUse (ret, sRef_getBase (e1->sref), e1->loc); } isjustalloc = sRef_isJustAllocated (e1->sref); isalloc = sRef_isAllocated (e1->sref); if (sRef_isField (e1->sref)) { sRef root = sRef_getRootBase (sRef_getBase (e1->sref)); if (!sRef_isAllocated (root) && !sRef_isMacroParamRef (root)) { exprNode_checkUse (ret, root, e1->loc); } } /* ** be careful! this defines e1->sref. */ if (!sRef_isMacroParamRef (e1->sref)) { exprNode_checkSet (ret, e1->sref); } if (isjustalloc) { sRef_setAllocatedComplete (e1->sref, exprNode_isDefined (e2) ? e2->loc : e1->loc); } else { if (isalloc) { sRef_setAllocatedShallowComplete (e1->sref, exprNode_loc (e2)); } } } return ret; }

exprNode exprNode_break ( lltok l, int bqual )

Definition at line 6670 of file exprNode.c. { exprNode ret = exprNode_createLoc (ctype_unknown, fileloc_copy (lltok_getLoc (l))); clause breakClause = context_breakClause (); ret->kind = XPR_BREAK; ret->edata = exprData_makeTok (l); ret->canBreak = TRUE; ret->mustBreak = TRUE; if (breakClause == NOCLAUSE) { voptgenerror (FLG_SYNTAX, cstring_makeLiteral ("Break not inside while, for or switch statement"), exprNode_loc (ret)); } else { if (bqual != BADTOK) { switch (bqual) { case QSAFEBREAK: break; case QINNERBREAK: if (breakClause == SWITCHCLAUSE) { if (!context_inDeepSwitch ()) { voptgenerror (FLG_SYNTAX, cstring_makeLiteral ("Break preceded by innerbreak is not in a deep switch"), exprNode_loc (ret)); } } else { if (!context_inDeepLoop ()) { voptgenerror (FLG_SYNTAX, cstring_makeLiteral ("Break preceded by innerbreak is not in a deep loop"), exprNode_loc (ret)); } } break; case QLOOPBREAK: if (breakClause == SWITCHCLAUSE) { voptgenerror (FLG_SYNTAX, cstring_makeLiteral ("Break preceded by loopbreak is breaking a switch"), exprNode_loc (ret)); } break; case QSWITCHBREAK: if (breakClause != SWITCHCLAUSE) { voptgenerror (FLG_SYNTAX, message ("Break preceded by switchbreak is breaking %s", cstring_makeLiteralTemp ((breakClause == WHILECLAUSE || breakClause == DOWHILECLAUSE) ? "a while loop" : (breakClause == FORCLAUSE) ? "a for loop" : (breakClause == ITERCLAUSE) ? "an iterator" : "<error loop>")), exprNode_loc (ret)); } break; BADDEFAULT; } } else { if (breakClause == SWITCHCLAUSE) { clause nextBreakClause = context_nextBreakClause (); switch (nextBreakClause) { case NOCLAUSE: break; case WHILECLAUSE: case DOWHILECLAUSE: case FORCLAUSE: case ITERCLAUSE: voptgenerror (FLG_LOOPSWITCHBREAK, cstring_makeLiteral ("Break statement in switch inside loop"), exprNode_loc (ret)); break; case SWITCHCLAUSE: voptgenerror (FLG_SWITCHSWITCHBREAK, cstring_makeLiteral ("Break statement in switch inside switch"), exprNode_loc (ret)); break; BADDEFAULT; } } else { if (context_inDeepLoop ()) { voptgenerror (FLG_LOOPLOOPBREAK, cstring_makeLiteral ("Break statement in nested loop"), exprNode_loc (ret)); } else { if (context_inDeepLoopSwitch ()) { voptgenerror (FLG_SWITCHLOOPBREAK, cstring_makeLiteral ("Break statement in loop inside switch"), exprNode_loc (ret)); } } } } } return ret; }

exprNode exprNode_caseMarker ( exprNode test, bool fallThrough )

Definition at line 5373 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (test); ret->kind = fallThrough ? XPR_FTCASE : XPR_CASE; if (exprNode_isError (test)) { return ret; } exprNode_checkUse (ret, test->sref, test->loc); usymtab_setExitCode (ret->exitCode); if (ret->mustBreak) { usymtab_setMustBreak (); } ret->edata = exprData_makeSingle (test); ret->isJumpPoint = TRUE; return ret; }

exprNode exprNode_cast ( lltok tok, exprNode e, qtype q )

Definition at line 4067 of file exprNode.c. { ctype c; ctype t; exprNode ret; if (exprNode_isError (e)) { qtype_free (q); lltok_release (tok); return exprNode_undefined; } checkMacroParen (e); c = qtype_getType (q); t = exprNode_getType (e); ret = exprNode_createPartialCopy (e); ret->loc = fileloc_update (ret->loc, lltok_getLoc (tok)); ret->typ = c; ret->kind = XPR_CAST; ret->edata = exprData_makeCast (tok, e, q); if (ctype_isRealSU (ctype_getBaseType (sRef_getType (e->sref)))) { /* ** This is a bit of a hack to avoid a problem ** when the code does, ** (some other struct) x ** ... ** x->field */ ret->sref = sRef_copy (e->sref); usymtab_addForceMustAlias (ret->sref, e->sref); sRef_setTypeFull (ret->sref, c); DPRINTF (("Cast: %s -> %s", sRef_unparseFull (e->sref), sRef_unparseFull (ret->sref))); } else { ret->sref = e->sref; sRef_setTypeFull (ret->sref, c); DPRINTF (("Cast 2: -> %s", sRef_unparseFull (ret->sref))); } /* ** we allow ** abstract -> void ** 0 <-> abstract * ** void * <-> abstract * (if FLG_ABSTVOIDP) ** abstract * <-> void * (if FLG_ABSTVOIDP) */ if (ctype_isVoid (c)) /* cast to void is always okay --- discard value */ { ; } else if (ctype_isRealAP (c)) /* casting to array or pointer */ { ctype bc = ctype_getBaseType (c); ctype bt = ctype_getBaseType (t); ctype rt = ctype_realType (t); if (ctype_isFunction (ctype_baseArrayPtr (ctype_realType (c))) && (ctype_isArrayPtr (rt) && !ctype_isFunction (ctype_realType (ctype_baseArrayPtr (rt))))) { voptgenerror (FLG_CASTFCNPTR, message ("Cast from function pointer type (%t) to " "non-function pointer (%t): %s", c, t, exprNode_unparse (ret)), e->loc); } if (!ctype_isFunction (ctype_baseArrayPtr (c)) && (ctype_isArrayPtr (rt) && ctype_isFunction (ctype_realType (ctype_baseArrayPtr (rt))))) { voptgenerror (FLG_CASTFCNPTR, message ("Cast from non-function pointer type (%t) to " "function pointer (%t): %s", c, t, exprNode_unparse (ret)), e->loc); } if (exprNode_isZero (e) && context_getFlag (FLG_ZEROPTR) && !(ctype_isRealAbstract (bc) && context_hasAccess (ctype_typeId (bc)))) { ; /* okay to cast zero */ } else { if (ctype_isRealAbstract (bc) && !context_hasAccess (ctype_typeId (bc))) { if (ctype_isVoidPointer (t) || ctype_isUnknown (t)) { vnoptgenerror (FLG_ABSTVOIDP, message ("Cast to underlying abstract type %t: %s", c, exprNode_unparse (ret)), e->loc); } else { voptgenerror (FLG_ABSTRACT, message ("Cast to underlying abstract type %t: %s", c, exprNode_unparse (ret)), e->loc); } } if (ctype_isRealAbstract (bt) && !context_hasAccess (ctype_typeId (bt))) { if (ctype_isUnknown (c) || ctype_isVoidPointer (c)) { vnoptgenerror (FLG_ABSTVOIDP, message ("Cast from underlying abstract type %t: %s", t, exprNode_unparse (ret)), e->loc); } else { voptgenerror (FLG_ABSTRACT, message ("Cast from underlying abstract type %t: %s", t, exprNode_unparse (ret)), e->loc); } } } } else { ctype bt = ctype_realType (ctype_getBaseType (t)); ctype bc = ctype_realType (ctype_getBaseType (c)); if (ctype_isAbstract (bt) && !context_hasAccess (ctype_typeId (bt))) { if (ctype_match (c, t)) { if (ctype_equal (c, t)) { voptgenerror (FLG_TYPE, message ("Redundant cast involving abstract type %t: %s", bt, exprNode_unparse (ret)), e->loc); } } else { voptgenerror (FLG_ABSTRACT, message ("Cast from abstract type %t: %s", bt, exprNode_unparse (ret)), e->loc); } } if (ctype_isAbstract (bc) && !context_hasAccess (ctype_typeId (bc))) { if (ctype_match (c, t)) { ; } else { voptgenerror (FLG_ABSTRACT, message ("Cast to abstract type %t: %s", bc, exprNode_unparse (ret)), e->loc); } } } if (ctype_isAbstract (c)) { if (sRef_isExposed (e->sref) || sRef_isOnly (e->sref)) { /* okay, cast exposed to abstract */ sRef_clearExKindComplete (ret->sref, fileloc_undefined); } else { if (ctype_isVisiblySharable (t) && sRef_isExternallyVisible (e->sref) && !(ctype_isAbstract (t) && context_hasAccess (ctype_typeId (t)))) { voptgenerror (FLG_CASTEXPOSE, message ("Cast to abstract type from externally visible " "mutable storage exposes rep of %s: %s", ctype_unparse (c), exprNode_unparse (e)), e->loc); } } } return (ret); }

exprNode exprNode_charLiteral ( char c, cstring text, fileloc loc )

Definition at line 665 of file exprNode.c. { exprNode e = exprNode_createLoc (ctype_char, loc); if (context_getFlag (FLG_CHARINTLITERAL)) { e->typ = ctype_makeConj (ctype_char, ctype_int); } e->kind = XPR_NUMLIT; e->val = multiVal_makeChar (c); e->edata = exprData_makeLiteral (cstring_copy (text)); return (e); }

exprNode exprNode_checkExpr ( exprNode e )

Definition at line 5642 of file exprNode.c. { if (!exprNode_isError (e)) { if (e->kind != XPR_ASSIGN) { exprNode_checkUse (e, e->sref, e->loc); } } return e; }

void exprNode_checkMSet ( exprNode e, sRef s )

Definition at line 8804 of file exprNode.c. Referenced by checkPassTransfer(). { if (sRef_isValid (s) && !sRef_isNothing (s)) { uentry ue = sRef_getBaseUentry (s); if (uentry_isValid (ue)) { uentry_setLset (ue); } if (!ynm_toBoolStrict (sRef_isWriteable (s))) { voptgenerror (FLG_USEDEF, message ("Attempt to set unuseable storage: %q", sRef_unparse (s)), exprNode_loc (e)); } if (sRef_isMeaningful (s)) { sRef_setDefinedComplete (s, exprNode_loc (e)); } if (exprNode_isDefined (e)) { e->msets = sRefSet_insert (e->msets, s); } } }

void exprNode_checkSet ( exprNode e, sRef s )

Definition at line 8701 of file exprNode.c. Referenced by checkPassTransfer(), exprNode_assign(), exprNode_postOp(), exprNode_preOp(), and exprNode_vaArg(). { sRef defines = sRef_undefined; if (sRef_isValid (s) && !sRef_isNothing (s)) { uentry ue = sRef_getBaseUentry (s); if (uentry_isValid (ue)) { uentry_setLset (ue); } if (!ynm_toBoolStrict (sRef_isWriteable (s))) { voptgenerror (FLG_USEDEF, message ("Attempt to set unuseable storage: %q", sRef_unparse (s)), exprNode_loc (e)); } if (sRef_isMeaningful (s)) { if (sRef_isDead (s)) { sRef base = sRef_getBaseSafe (s); if (sRef_isValid (base) && sRef_isDead (base)) { sRef_setPartial (s, exprNode_loc (e)); } defines = s; /* okay - modifies for only param */ } else if (sRef_isPartial (s)) { sRef eref = exprNode_getSref (e); if (!sRef_isPartial (eref)) { /* ** should do something different here??? */ sRef_setDefinedComplete (eref, exprNode_loc (e)); } else { sRef_setPartialDefinedComplete (eref, exprNode_loc (e)); } if (sRef_isMeaningful (eref)) { defines = eref; } else { defines = s; } } else if (sRef_isAllocated (s)) { sRef eref = exprNode_getSref (e); if (!sRef_isAllocated (eref)) { sRef_setDefinedComplete (eref, exprNode_loc (e)); } else { sRef base = sRef_getBaseSafe (eref); if (sRef_isValid (base)) { sRef_setPdefined (base, exprNode_loc (e)); } } defines = s; } else { sRef_setDefinedNCComplete (s, exprNode_loc (e)); defines = s; } } else /* not meaningful...but still need to insert it */ { defines = s; } } if (exprNode_isDefined (e) && sRef_isValid (defines)) { e->sets = sRefSet_insert (e->sets, defines); } }

void exprNode_checkUseParam ( exprNode current )

Definition at line 9066 of file exprNode.c. Referenced by checkPassTransfer(). { if (exprNode_isDefined (current)) { exprNode_checkUse (current, current->sref, current->loc); } }

exprNode exprNode_comma ( exprNode e1, exprNode e2 )

Definition at line 6835 of file exprNode.c. { exprNode ret; if (exprNode_isError (e1)) { if (exprNode_isError (e2)) { ret = exprNode_createLoc (ctype_unknown, g_currentloc); } else { ret = exprNode_createPartialCopy (e2); exprNode_checkUse (ret, e2->sref, e2->loc); ret->sref = e2->sref; } } else { ret = exprNode_createPartialCopy (e1); exprNode_checkUse (ret, e1->sref, e1->loc); if (!exprNode_isError (e2)) { exprNode_mergeUSs (ret, e2); exprNode_checkUse (ret, e2->sref, e2->loc); ret->sref = e2->sref; } } ret->kind = XPR_COMMA; ret->edata = exprData_makePair (e1, e2); if (exprNode_isDefined (e1)) { if (exprNode_isDefined (e2)) { ret->typ = e2->typ; if (exprNode_mustEscape (e1) || e1->mustBreak) { voptgenerror (FLG_UNREACHABLE, message ("Second clause of comma expression is unreachable: %s", exprNode_unparse (e2)), exprNode_loc (e2)); } ret->exitCode = exitkind_combine (e1->exitCode, e2->exitCode); ret->mustBreak = e1->mustBreak || e2->mustBreak; ret->canBreak = e1->canBreak || e2->canBreak; } else { if (exprNode_mustEscape (e1) || e1->mustBreak) { voptgenerror (FLG_UNREACHABLE, message ("Second clause of comma expression is unreachable: %s", exprNode_unparse (e2)), exprNode_loc (e2)); } ret->exitCode = e1->exitCode; ret->canBreak = e1->canBreak; } } else { if (exprNode_isDefined (e2)) { ret->exitCode = e2->exitCode; ret->mustBreak = e2->mustBreak; ret->canBreak = e2->canBreak; } } return (ret); }

exprNode exprNode_concat ( exprNode e1, exprNode e2 )

Definition at line 5488 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (e1); ret->edata = exprData_makePair (e1, e2); ret->kind = XPR_STMTLIST; if (exprNode_isDefined (e1)) { ret->isJumpPoint = e1->isJumpPoint; ret->canBreak = e1->canBreak; } else { if (exprNode_isDefined (e2)) { ret->loc = fileloc_update (ret->loc, e2->loc); } } if (exprNode_isDefined (e2)) { ret->exitCode = e2->exitCode; ret->mustBreak = e2->mustBreak; if (e2->canBreak) ret->canBreak = TRUE; } /* ** if e1 must return, then e2 is unreachable! */ if (exprNode_isDefined (e1) && exprNode_isDefined (e2)) { if ((exprNode_mustEscape (e1) || exprNode_mustBreak (e1)) && !(e2->isJumpPoint)) { if (context_getFlag (FLG_UNREACHABLE)) { exprNode nr = e2; if (e2->kind == XPR_STMT) { nr = exprData_getSingle (e2->edata); } if ((nr->kind == XPR_TOK && lltok_isSemi (exprData_getTok (nr->edata)))) { /* okay to have unreachable ";" */ ret->exitCode = XK_MUSTEXIT; ret->canBreak = TRUE; } else { if (optgenerror (FLG_UNREACHABLE, message ("Unreachable code: %s", exprNode_unparseFirst (nr)), exprNode_loc (nr))) { ret->isJumpPoint = TRUE; ret->mustBreak = FALSE; ret->exitCode = XK_ERROR; DPRINTF (("Jump point: %s", exprNode_unparse (ret))); } else { ret->exitCode = XK_MUSTEXIT; ret->canBreak = TRUE; } } } } else { if ((e2->kind == XPR_CASE || e2->kind == XPR_DEFAULT)) { /* ** We want a warning anytime we have: ** case xxx: ... ** yyy; <<<- no break or return ** case zzz: ... */ exprNode lastStmt = exprNode_lastStatement (e1); if (exprNode_isDefined (lastStmt) && !exprNode_mustEscape (lastStmt) && !exprNode_mustBreak (lastStmt) && !exprNode_isCaseMarker (lastStmt) && !exprNode_isDefaultMarker (lastStmt) && !exprNode_isLabelMarker (lastStmt)) { voptgenerror (FLG_CASEBREAK, cstring_makeLiteral ("Fall through case (no preceeding break)"), e2->loc); } } } } exprNode_mergeUSs (ret, e2); usymtab_setExitCode (ret->exitCode); if (ret->mustBreak) { usymtab_setMustBreak (); } return ret; }

exprNode exprNode_cond ( exprNode pred, exprNode ifclause, exprNode elseclause )

Definition at line 5126 of file exprNode.c. { exprNode ret; if (!exprNode_isError (pred)) { ret = exprNode_createPartialCopy (pred); checkMacroParen (pred); exprNode_checkPred (cstring_makeLiteralTemp ("conditional"), pred); if (!exprNode_isError (ifclause)) { checkMacroParen (ifclause); /* update macro counts! */ if (!exprNode_isError (elseclause)) { checkMacroParen (elseclause); if (!exprNode_matchTypes (ifclause, elseclause)) { if (gentypeerror (exprNode_getType (ifclause), ifclause, exprNode_getType (elseclause), elseclause, message ("Conditional clauses are not of same type: " "%s (%t), %s (%t)", exprNode_unparse (ifclause), exprNode_getType (ifclause), exprNode_unparse (elseclause), exprNode_getType (elseclause)), ifclause->loc)) { ret->sref = sRef_undefined; ret->typ = ctype_unknown; } } else { /* for now...should merge the states */ ret->sref = ifclause->sref; ret->typ = ifclause->typ; if (exprNode_isNullValue (ifclause)) { ret->typ = elseclause->typ; } } exprNode_checkUse (ret, pred->sref, pred->loc); exprNode_checkUse (ifclause, ifclause->sref, ifclause->loc); exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc); exprNode_mergeCondUSs (ret, ifclause, elseclause); } else { ret->typ = ifclause->typ; exprNode_checkUse (pred, pred->sref, pred->loc); exprNode_checkUse (ifclause, ifclause->sref, ifclause->loc); exprNode_mergeCondUSs (ret, ifclause, exprNode_undefined); } } else { if (!exprNode_isError (elseclause)) { ret->typ = elseclause->typ; exprNode_checkUse (pred, pred->sref, pred->loc); exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc); exprNode_mergeCondUSs (ret, exprNode_undefined, elseclause); } } } else /* pred is error */ { if (!exprNode_isError (ifclause)) { ret = exprNode_createSemiCopy (ifclause); checkMacroParen (ifclause); /* update macro counts! */ if (!exprNode_isError (elseclause)) { checkMacroParen (elseclause); ret->typ = ifclause->typ; if (!ctype_forceMatch (ifclause->typ, elseclause->typ)) { if (gentypeerror (exprNode_getType (ifclause), ifclause, exprNode_getType (elseclause), elseclause, message ("Conditional clauses are not of same type: " "%s (%t), %s (%t)", exprNode_unparse (ifclause), exprNode_getType (ifclause), exprNode_unparse (elseclause), exprNode_getType (elseclause)), ifclause->loc)) { ret->typ = ctype_unknown; } } exprNode_checkUse (ifclause, ifclause->sref, ifclause->loc); exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc); exprNode_mergeCondUSs (ret, ifclause, elseclause); } } else if (!exprNode_isError (elseclause)) /* pred, if errors */ { ret = exprNode_createSemiCopy (ifclause); ret->typ = elseclause->typ; checkMacroParen (elseclause); exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc); exprNode_mergeCondUSs (ret, exprNode_undefined, elseclause); } else /* all errors! */ { ret = exprNode_createLoc (ctype_unknown, g_currentloc); } } ret->kind = XPR_COND; ret->edata = exprData_makeCond (pred, ifclause, elseclause); if (exprNode_isDefined (ifclause) && exprNode_isDefined (elseclause)) { exprNode_combineControl (ret, ifclause, elseclause); } return (ret); }

exprNode exprNode_continue ( lltok l, int qcontinue )

Definition at line 6628 of file exprNode.c. { exprNode ret = exprNode_createLoc (ctype_unknown, fileloc_copy (lltok_getLoc (l))); ret->kind = XPR_CONTINUE; ret->edata = exprData_makeTok (l); ret->canBreak = TRUE; ret->mustBreak = TRUE; if (qcontinue == QSAFEBREAK) { ; /* no checking */ } else if (qcontinue == QINNERCONTINUE) { if (!context_inDeepLoop ()) { voptgenerror (FLG_LOOPLOOPCONTINUE, cstring_makeLiteral ("Continue statement marked with innercontinue " "is not inside a nested loop"), exprNode_loc (ret)); } } else if (qcontinue == BADTOK) { if (context_inDeepLoop ()) { voptgenerror (FLG_LOOPLOOPCONTINUE, cstring_makeLiteral ("Continue statement in nested loop"), exprNode_loc (ret)); } } else { llbuglit ("exprNode_continue: bad qcontinue"); } return ret; }

exprNode exprNode_createId ( uentry c )

Definition at line 824 of file exprNode.c. Referenced by exprNode_makeInitialization(). { if (uentry_isValid (c)) { exprNode e = exprNode_new (); e->typ = uentry_getType (c); if (uentry_isFunction (c) && !sRef_isLocalVar (uentry_getSref (c))) { e->sref = sRef_undefined; } else { e->sref = uentry_getSref (c); } if (sRef_isStateUnknown (e->sref) && uentry_isNonLocal (c)) { sRef_setDefined (e->sref, fileloc_undefined); } /* ** yoikes! leaving this out was a heinous bug...that would have been ** caught if i had lclint working first. gag! */ e->etext = cstring_undefined; if (uentry_isEitherConstant (c)) { e->kind = XPR_CONST; e->val = multiVal_copy (uentry_getConstantValue (c)); } else { e->kind = XPR_VAR; e->val = multiVal_unknown (); } e->edata = exprData_makeId (c); e->loc = context_getSaveLocation (); if (fileloc_isUndefined (e->loc)) { fileloc_free (e->loc); e->loc = fileloc_copy (g_currentloc); } e->guards = guardSet_new (); e->sets = sRefSet_new (); e->msets = sRefSet_new (); e->uses = sRefSet_new (); /*> missing fields, detected by lclint <*/ e->exitCode = XK_NEVERESCAPE; e->isJumpPoint = FALSE; e->canBreak = FALSE; e->mustBreak = FALSE; return e; } else { return exprNode_createUnknown (); } }

exprNode exprNode_createTok ( lltok t )

Definition at line 5602 of file exprNode.c. Referenced by exprNode_defaultMarker(). { exprNode ret = exprNode_create (ctype_unknown); ret->kind = XPR_TOK; ret->edata = exprData_makeTok (t); return ret; }

exprNode exprNode_defaultMarker ( lltok def, bool fallThrough )

Definition at line 5437 of file exprNode.c. { exprNode ret = exprNode_createTok (def); ret->isJumpPoint = TRUE; ret->kind = fallThrough ? XPR_FTDEFAULT : XPR_DEFAULT; return (ret); }

void exprNode_destroyMod ( void )

Definition at line 203 of file exprNode.c. Referenced by llexit(). { if (initMod) { uentry_free (regArg); uentry_free (outArg); uentry_free (outStringArg); exprNode_free (mustExitNode); initMod = FALSE; /*@-branchstate@*/ } /*@=branchstate@*/ }

exprNode exprNode_doWhile ( exprNode b, exprNode t )

Definition at line 6355 of file exprNode.c. { exprNode ret; if (exprNode_isError (t)) { if (exprNode_isError (b)) { ret = exprNode_createLoc (ctype_unknown, g_currentloc); } else { ret = exprNode_createPartialCopy (b); ret->exitCode = exitkind_makeConditional (b->exitCode); exprNode_checkUse (ret, b->sref, b->loc); ret->exitCode = b->exitCode; ret->canBreak = b->canBreak; ret->mustBreak = b->mustBreak; } } else { ret = exprNode_createPartialCopy (t); exprNode_checkPred (cstring_makeLiteralTemp ("while"), t); if (!exprNode_isError (b)) { /* ** forgot the copy's --- why wasn't this detected?? */ ret->sets = sRefSet_copy (ret->sets, b->sets); ret->msets = sRefSet_copy (ret->msets, b->msets); ret->uses = sRefSet_copy (ret->uses, b->uses); /* left this out --- causes and aliasing bug (infinite loop) should be detected?? */ exprNode_checkUse (ret, b->sref, b->loc); exprNode_mergeUSs (ret, t); exprNode_checkUse (ret, t->sref, t->loc); ret->exitCode = b->exitCode; ret->canBreak = b->canBreak; ret->mustBreak = b->mustBreak; } } context_exitDoWhileClause (t); ret->kind = XPR_DOWHILE; ret->edata = exprData_makePair (t, b); return ret; }

bool exprNode_errorEscape ( exprNode e )

Definition at line 5478 of file exprNode.c. Referenced by exprNode_checkFunctionBody(). { if (exprNode_isDefined (e)) { return exitkind_isError (e->exitCode); } return FALSE; }

exprNode exprNode_fieldAccess ( exprNode s, cstring f )

Definition at line 3257 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (s); ret->kind = XPR_FACCESS; if (exprNode_isError (s)) { ret->edata = exprData_makeField (s, f); return ret; } else { ctype t = exprNode_getType (s); ctype tr = ctype_realType (t); checkMacroParen (s); ret->edata = exprData_makeField (s, f); if (ctype_isStructorUnion (tr)) { uentry tf = uentryList_lookupField (ctype_getFields (tr), f); if (uentry_isUndefined (tf)) { voptgenerror (FLG_TYPE, message ("Access non-existent field %s of %t: %s", f, t, exprNode_unparse (ret)), s->loc); return (ret); } else { uentry_setUsed (tf, exprNode_loc (ret)); ret->typ = uentry_getType (tf); checkSafeUse (ret, s->sref); ret->sref = sRef_makeField (s->sref, uentry_rawName (tf)); return (ret); } } else /* isStructorUnion */ { if (ctype_isRealAbstract (tr)) { voptgenerror (FLG_ABSTRACT, message ("Access field of abstract type (%t): %s.%s", t, exprNode_unparse (s), f), s->loc); ret->typ = ctype_unknown; } else { if (ctype_isKnown (tr)) { voptgenerror (FLG_TYPE, message ("Access field of non-struct or union (%t): %s.%s", t, exprNode_unparse (s), f), s->loc); ret->typ = ctype_unknown; } else { cstring sn = cstring_copy (f); checkSafeUse (ret, s->sref); cstring_markOwned (sn); ret->sref = sRef_makeField (s->sref, sn); return (ret); } } return (ret); } } BADEXIT; }

exprNode exprNode_floatLiteral ( double d, ctype ct, cstring text, fileloc loc )

Definition at line 682 of file exprNode.c. { exprNode e = exprNode_createLoc (ct, loc); e->kind = XPR_NUMLIT; e->val = multiVal_makeDouble (d); e->edata = exprData_makeLiteral (cstring_copy (text)); return (e); }

exprNode exprNode_for ( exprNode inc, exprNode body )

Definition at line 6411 of file exprNode.c. { exprNode ret; bool emptyErr = FALSE; if (context_maybeSet (FLG_FOREMPTY)) { if (exprNode_isEmptyStatement (body)) { emptyErr = optgenerror (FLG_FOREMPTY, cstring_makeLiteral ("Body of for statement is empty"), exprNode_loc (body)); } } if (!emptyErr && context_maybeSet (FLG_FORBLOCK)) { if (exprNode_isDefined (body) && !exprNode_isBlock (body)) { if (context_inIterDef () && (body->kind == XPR_STMTLIST || body->kind == XPR_TOK)) { ; /* no error */ } else { voptgenerror (FLG_FORBLOCK, message ("Body of for statement is not a block: %s", exprNode_unparse (body)), exprNode_loc (body)); } } } /* ** for ud purposes: (alreadly) init -> test -> (now) LOOP: body + inc + test */ if (exprNode_isError (body)) { ret = exprNode_createPartialCopy (inc); } else { ret = exprNode_createPartialCopy (body); ret->exitCode = exitkind_makeConditional (body->exitCode); exprNode_mergeUSs (inc, body); if (exprNode_isDefined (inc)) { exprNode tmp; context_setMessageAnnote (cstring_makeLiteral ("in post loop increment")); tmp = exprNode_effect (exprData_getTripleInc (inc->edata)); exprNode_freeShallow (tmp); context_clearMessageAnnote (); context_setMessageAnnote (cstring_makeLiteral ("in post loop test")); tmp = exprNode_effect (exprData_getTripleTest (inc->edata)); exprNode_freeShallow (tmp); context_clearMessageAnnote (); ret->uses = sRefSet_copy (ret->uses, inc->uses); ret->sets = sRefSet_copy (ret->sets, inc->sets); ret->msets = sRefSet_copy (ret->msets, inc->msets); } } ret->kind = XPR_FOR; ret->edata = exprData_makePair (inc, body); if (exprNode_isDefined (inc)) { exprNode test = exprData_getTripleTest (inc->edata); if (exprNode_isUndefined (test)) { if (exprNode_isDefined (body)) { if (!body->canBreak) { /* Really, it means never reached. */ ret->exitCode = XK_MUSTEXIT; } } } } return (ret); }

exprNode exprNode_forPred ( exprNode init, exprNode test, exprNode inc )

Definition at line 6558 of file exprNode.c. { exprNode ret; /* ** for ud purposes: init -> test -> LOOP: [ body, inc ] */ exprNode_checkPred (cstring_makeLiteralTemp ("for"), test); if (!exprNode_isError (inc)) { ret = exprNode_createPartialCopy (inc); } else { if (!exprNode_isError (init)) { ret = exprNode_createPartialCopy (init); } else if (!exprNode_isError (test)) { ret = exprNode_createPartialCopy (test); } else { ret = exprNode_createUnknown (); } } exprNode_mergeUSs (ret, init); if (exprNode_isDefined (init)) { exprNode_checkUse (ret, init->sref, init->loc); } exprNode_mergeUSs (ret, test); if (exprNode_isDefined (test)) { exprNode_checkUse (ret, test->sref, test->loc); } ret->kind = XPR_FORPRED; ret->edata = exprData_makeFor (init, test, inc); return (ret); }

void exprNode_free ( exprNode e )

Definition at line 341 of file exprNode.c. Referenced by exprNodeList_free(), exprNode_arrayFetch(), exprNode_checkFunction(), exprNode_checkIterBody(), exprNode_checkIterEnd(), exprNode_checkMacroBody(), exprNode_destroyMod(), exprNode_functionCall(), and exprNode_makeInitialization(). { if (!exprNode_isError (e)) { if (!inEffect) { multiVal_free (e->val); cstring_free (e->etext); fileloc_free (e->loc); sRefSet_free (e->uses); sRefSet_free (e->sets); sRefSet_free (e->msets); guardSet_free (e->guards); exprData_free (e->edata, e->kind); nowalloc--; sfree (e); /*@-branchstate@*/ } /*@=branchstate@*/ } }

void exprNode_freeShallow ( exprNode e )

Definition at line 297 of file exprNode.c. Referenced by exprNodeList_freeShallow(), and exprNode_for(). { if (!exprNode_isError (e)) { if (shallowKind (e->kind)) { } else { if (!inEffect) { if (e->kind == XPR_EMPTY || e->kind == XPR_BODY || e->kind == XPR_STRINGLITERAL || e->kind == XPR_NUMLIT || e->kind == XPR_NODE || e->kind == XPR_OFFSETOF || e->kind == XPR_ALIGNOFT || e->kind == XPR_ALIGNOF || e->kind == XPR_SIZEOFT || e->kind == XPR_SIZEOF) { /* don't free anything */ } else { /* multiVal_free (e->val); */ cstring_free (e->etext); fileloc_free (e->loc); sRefSet_free (e->uses); sRefSet_free (e->sets); sRefSet_free (e->msets); guardSet_free (e->guards); exprData_freeShallow (e->edata, e->kind); nowalloc--; /*@-compdestroy@*/ sfree (e); /*@=compdestroy@*/ /*@-branchstate@*/ } } } /*@=branchstate@*/ } }

exprNode exprNode_fromIdentifier ( uentry c )

Definition at line 894 of file exprNode.c. { exprNode ret; if (context_justPopped ()) /* watch out! c could be dead */ { uentry ce = usymtab_lookupSafe (LastIdentifier ()); if (uentry_isValid (ce)) { c = ce; } else { llbuglit ("Looks like Aunt Millie forgot to walk to dog again."); } } ret = exprNode_fromIdentifierAux (c); return ret; }

exprNode exprNode_fromUIO ( cstring c )

Definition at line 754 of file exprNode.c. { fileloc loc = context_getSaveLocation (); exprNode e = exprNode_createPlain (ctype_unknown); e->kind = XPR_VAR; if (fileloc_isUndefined (loc)) { loc = fileloc_copy (g_currentloc); } e->loc = loc; /* save loc was mangled */ e->sref = defref; if (usymtab_exists (c)) { uentry ue = usymtab_lookupEither (c); if (uentry_isDatatype (ue) && uentry_isSpecified (ue)) { llfatalerror (message ("%q: Specified datatype %s used in code, but not defined. " "(Cannot continue reasonably from this error.)", fileloc_unparse (e->loc), c)); } else { BADBRANCH; } } llassertprint (!usymtab_exists (c), ("Entry exists: %s", c)); /* ** was supercedeGlobalEntry...is this better? */ if (!context_inIterEnd ()) { if (context_inMacro ()) { if (context_getFlag (FLG_UNRECOG)) { voptgenerror (FLG_MACROUNDEF, message ("Unrecognized identifier in macro definition: %s", c), e->loc); } else { flagcode_recordSuppressed (FLG_UNRECOG); } } else { voptgenerror (FLG_UNRECOG, message ("Unrecognized identifier: %s", c), e->loc); } } e->edata = exprData_makeId (uentry_makeUnrecognized (c, fileloc_copy (loc))); /* No alias errors for unrecognized identifiers */ sRef_setAliasKind (e->sref, AK_ERROR, loc); return (e); }

exprNode exprNode_functionCall ( exprNode f, exprNodeList args )

Definition at line 3166 of file exprNode.c. { ctype t; setCodePoint (); if (exprNode_isUndefined (f)) { exprNode_free (f); exprNodeList_free (args); return exprNode_undefined; } t = exprNode_getType (f); if (sRef_isLocalVar (f->sref)) { exprNode_checkUse (f, f->sref, f->loc); if (sRef_possiblyNull (f->sref)) { if (!usymtab_isGuarded (f->sref)) { if (optgenerror (FLG_NULLDEREF, message ("Function call using %s pointer %q", sRef_nullMessage (f->sref), sRef_unparse (f->sref)), f->loc)) { sRef_showNullInfo (f->sref); sRef_setNullError (f->sref); } } } } setCodePoint (); if (ctype_isRealFunction (t)) { exprNode ret = functionCallSafe (f, t, args); setCodePoint (); return ret; } else if (ctype_isUnknown (t)) { exprNode ret = exprNode_createPartialCopy (f); cstring tstring; setCodePoint (); ret->typ = t; exprNodeList_elements (args, current) { if (exprNode_isDefined (current)) { exprNode_checkUse (ret, current->sref, ret->loc); /* ** also, anything derivable from current->sref may be used */ exprNode_addUse (ret, sRef_makeDerived (current->sref)); exprNode_mergeUSs (ret, current); } } end_exprNodeList_elements; ret->edata = exprData_makeCall (f, args); ret->kind = XPR_CALL; tstring = cstring_copy (exprNode_unparse (f)); cstring_markOwned (tstring); exprNode_checkSetAny (ret, tstring); return (ret); } else { voptgenerror (FLG_TYPE, message ("Call to non-function (type %t): %s", t, exprNode_unparse (f)), f->loc); exprNode_free (f); exprNodeList_free (args); return (exprNode_makeError ()); } }

guardSet exprNode_getForGuards ( exprNode pred )

Definition at line 6520 of file exprNode.c. { exprNode test; if (exprNode_isError (pred)) return guardSet_undefined; llassert (pred->kind == XPR_FORPRED); test = exprData_getTripleTest (pred->edata); if (!exprNode_isError (test)) { return (test->guards); } return guardSet_undefined; }

long exprNode_getLongValue ( exprNode e )

Definition at line 9752 of file exprNode.c. { long value; if (exprNode_hasValue (e) && multiVal_isInt (exprNode_getValue (e))) { value = multiVal_forceInt (exprNode_getValue (e)); } else { value = 0; } return value; }

sRef exprNode_getSref ( exprNode e )

Definition at line 7474 of file exprNode.c. Referenced by checkAssignTransfer(), checkInitTransfer(), checkPassTransfer(), checkReturnTransfer(), exprNode_checkSet(), sRef_fixBaseParam(), and uentry_returnedRef(). { if (exprNode_isDefined (e)) { /*@access sRef@*/ if (e->sref == defref) /*@noaccess sRef@*/ { /*@-mods@*/ e->sref = sRef_makeUnknown (); sRef_setAliasKind (e->sref, AK_ERROR, fileloc_undefined); /*@=mods@*/ return e->sref; } else { return e->sref; } } else { return sRef_undefined; } }

uentry exprNode_getUentry ( exprNode e )

Definition at line 3138 of file exprNode.c. Referenced by checkPassTransfer(), exprNode_checkMacroBody(), exprNode_iterStart(), and exprNode_sizeofExpr(). { if (exprNode_isError (e)) { return uentry_undefined; } else { cstring s = exprNode_rootVarName (e); uentry ue = usymtab_lookupSafe (s); return ue; } }

multiVal exprNode_getValue ( exprNode e )

Definition at line 692 of file exprNode.c. Referenced by exprNode_arrayFetch(), exprNode_isNullValue(), and exprNode_matchLiteral(). { while (exprNode_isInParens (e)) { if (e->edata != NULL) { e = exprData_getUopNode (e->edata); } else { break; } } if (exprNode_isDefined (e)) { return e->val; } else { return multiVal_undefined; } }

exprNode exprNode_goto ( cstring label )

Definition at line 6608 of file exprNode.c. { exprNode ret = exprNode_createUnknown (); if (context_inMacro ()) { voptgenerror (FLG_MACROSTMT, message ("Macro %s uses goto (not functional)", context_inFunctionName ()), g_currentloc); } ret->kind = XPR_GOTO; ret->edata = exprData_makeLiteral (label); ret->mustBreak = TRUE; ret->exitCode = XK_GOTO; ret->canBreak = TRUE; return ret; }

exprNode exprNode_if ( exprNode pred, exprNode tclause )

Definition at line 5708 of file exprNode.c. { exprNode ret; bool emptyErr = FALSE; if (context_maybeSet (FLG_IFEMPTY)) { if (exprNode_isEmptyStatement (tclause)) { emptyErr = optgenerror (FLG_IFEMPTY, cstring_makeLiteral ("Body of if statement is empty"), exprNode_loc (tclause)); } } if (!emptyErr && context_maybeSet (FLG_IFBLOCK)) { if (exprNode_isDefined (tclause) && !exprNode_isBlock (tclause)) { voptgenerror (FLG_IFBLOCK, message ("Body of if statement is not a block: %s", exprNode_unparse (tclause)), exprNode_loc (tclause)); } } if (exprNode_isError (pred)) { if (exprNode_isError (tclause)) { ret = exprNode_createLoc (ctype_unknown, g_currentloc); } else { ret = exprNode_createPartialCopy (tclause); } } else { if (exprNode_mustEscape (pred)) { voptgenerror (FLG_UNREACHABLE, message ("Predicate always exits: %s", exprNode_unparse (pred)), exprNode_loc (pred)); } exprNode_checkPred (cstring_makeLiteralTemp ("if"), pred); exprNode_checkUse (pred, pred->sref, pred->loc); if (!exprNode_isError (tclause)) { exprNode_mergeCondUSs (pred, tclause, exprNode_undefined); } ret = exprNode_createPartialCopy (pred); } ret->kind = XPR_IF; ret->edata = exprData_makePair (pred, tclause); ret->exitCode = XK_UNKNOWN; if (exprNode_isDefined (tclause)) { ret->exitCode = exitkind_makeConditional (tclause->exitCode); ret->canBreak = tclause->canBreak; ret->sets = sRefSet_union (ret->sets, tclause->sets); ret->msets = sRefSet_union (ret->msets, tclause->msets); ret->uses = sRefSet_union (ret->uses, tclause->uses); } ret->mustBreak = FALSE; return ret; }

exprNode exprNode_ifelse ( exprNode pred, exprNode tclause, exprNode eclause )

Definition at line 5788 of file exprNode.c. { exprNode ret; bool tEmptyErr = FALSE; bool eEmptyErr = FALSE; if (context_maybeSet (FLG_IFEMPTY)) { if (exprNode_isEmptyStatement (tclause)) { tEmptyErr = optgenerror (FLG_IFEMPTY, cstring_makeLiteral ("Body of if clause of if statement is empty"), exprNode_loc (tclause)); } if (exprNode_isEmptyStatement (eclause)) { eEmptyErr = optgenerror (FLG_IFEMPTY, cstring_makeLiteral ("Body of else clause of if statement is empty"), exprNode_loc (eclause)); } } if (context_maybeSet (FLG_IFBLOCK)) { if (!tEmptyErr && exprNode_isDefined (tclause) && !exprNode_isBlock (tclause)) { voptgenerror (FLG_IFBLOCK, message ("Body of if clause of if statement is not a block: %s", exprNode_unparse (tclause)), exprNode_loc (tclause)); } if (!eEmptyErr && exprNode_isDefined (eclause) && !exprNode_isBlock (eclause) && !(eclause->kind == XPR_IF) && !(eclause->kind == XPR_IFELSE)) { voptgenerror (FLG_IFBLOCK, message ("Body of else clause of if statement is not a block: %s", exprNode_unparse (eclause)), exprNode_loc (eclause)); } } if (context_maybeSet (FLG_ELSEIFCOMPLETE)) { if (exprNode_isDefined (eclause) && (eclause->kind == XPR_IF)) { voptgenerror (FLG_ELSEIFCOMPLETE, message ("Incomplete else if logic (no final else): %s", exprNode_unparse (eclause)), exprNode_loc (eclause)); } } if (exprNode_isError (pred)) { if (exprNode_isError (tclause)) { if (exprNode_isError (eclause)) { ret = exprNode_createLoc (ctype_unknown, g_currentloc); } else { ret = exprNode_createPartialCopy (eclause); } } else { ret = exprNode_createPartialCopy (tclause); } } else /* pred is okay */ { ret = exprNode_createPartialCopy (pred); if (exprNode_mustEscape (pred)) { voptgenerror (FLG_UNREACHABLE, message ("Predicate always exits: %s", exprNode_unparse (pred)), exprNode_loc (pred)); } exprNode_checkPred (cstring_makeLiteralTemp ("if"), pred); exprNode_checkUse (ret, pred->sref, pred->loc); exprNode_mergeCondUSs (ret, tclause, eclause); } ret->kind = XPR_IFELSE; ret->edata = exprData_makeCond (pred, tclause, eclause); if (exprNode_isDefined (tclause) && exprNode_isDefined (eclause)) { exprNode_combineControl (ret, tclause, eclause); ret->loc = fileloc_update (ret->loc, eclause->loc); } return ret; }

void exprNode_initMod ( void )

Definition at line 113 of file exprNode.c. Referenced by main(). { uentry ue; idDecl tmp; initMod = TRUE; cstringType = ctype_unknown; ctypeType = ctype_unknown; filelocType = ctype_unknown; defref = sRef_undefined; if (usymtab_existsType (cstring_makeLiteralTemp ("cstring"))) { cstringType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("cstring")); } if (usymtab_existsType (cstring_makeLiteralTemp ("ctype"))) { ctypeType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("ctype")); } if (usymtab_existsType (cstring_makeLiteralTemp ("fileloc"))) { filelocType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("fileloc")); } if (usymtab_existsGlob (cstring_makeLiteralTemp ("stdin"))) { ue = usymtab_lookupGlob (cstring_makeLiteralTemp ("stdin")); } else /* define stdin */ { ue = uentry_makeVariable (cstring_makeLiteralTemp ("stdin"), ctype_unknown, fileloc_getBuiltin (), FALSE); uentry_setHasNameError (ue); ue = usymtab_supGlobalEntryReturn (ue); } stdinRef = sRef_makePointer (uentry_getSref (ue)); if (usymtab_existsGlob (cstring_makeLiteralTemp ("stdout"))) { ue = usymtab_lookupGlob (cstring_makeLiteralTemp ("stdout")); } else { ue = uentry_makeVariable (cstring_makeLiteralTemp ("stdout"), ctype_unknown, fileloc_getBuiltin (), FALSE); uentry_setHasNameError (ue); ue = usymtab_supGlobalEntryReturn (ue); } stdoutRef = sRef_makePointer (uentry_getSref (ue)); tmp = idDecl_create (cstring_undefined, qtype_create (ctype_unknown)); regArg = uentry_makeParam (tmp, PARAMUNKNOWN); idDecl_setTyp (tmp, qtype_addQual (qtype_create (ctype_makePointer (ctype_unknown)), qual_createOut ())); outArg = uentry_makeParam (tmp, PARAMUNKNOWN); idDecl_setTyp (tmp, qtype_addQual (qtype_create (ctype_string), qual_createOut ())); outStringArg = uentry_makeParam (tmp, PARAMUNKNOWN); idDecl_setTyp (tmp, qtype_addQual (qtype_addQual (qtype_create (cstringType), qual_createOnly ()), qual_createNull ())); csOnlyArg = uentry_makeParam (tmp, PARAMUNKNOWN); idDecl_setTyp (tmp, qtype_addQual (qtype_create (cstringType), qual_createNull ())); csArg = uentry_makeParam (tmp, PARAMUNKNOWN); idDecl_free (tmp); }

bool exprNode_isAssign ( exprNode e )

Definition at line 5691 of file exprNode.c. Referenced by exprNode_checkPred(). { if (exprNode_isDefined (e)) { return (e->kind == XPR_ASSIGN); } return FALSE; }

bool exprNode_isCaseMarker ( exprNode e )

Definition at line 5353 of file exprNode.c. Referenced by exprNode_concat(), and exprNode_switch(). { if (exprNode_isDefined (e)) { return (e->kind == XPR_FTCASE || e->kind == XPR_CASE); } return FALSE; }

bool exprNode_isCharLit ( exprNode e )

Definition at line 8190 of file exprNode.c. { if (exprNode_isDefined (e)) { return (multiVal_isChar (exprNode_getValue (e))); } else { return FALSE; } }

bool exprNode_isDefaultMarker ( exprNode e )

Definition at line 5343 of file exprNode.c. Referenced by exprNode_concat(), and exprNode_switch(). { if (exprNode_isDefined (e)) { return (e->kind == XPR_DEFAULT || e->kind == XPR_FTDEFAULT); } return FALSE; }

bool exprNode_isLabelMarker ( exprNode e )

Definition at line 5363 of file exprNode.c. Referenced by exprNode_concat(), and exprNode_switch(). { if (exprNode_isDefined (e)) { return (e->kind == XPR_LABEL); } return FALSE; }

bool exprNode_isNullValue ( exprNode e )

Definition at line 605 of file exprNode.c. Referenced by exprNode_checkMacroBody(), and exprNode_cond(). { if (exprNode_isDefined (e)) { multiVal m = exprNode_getValue (e); if (multiVal_isInt (m)) { return (multiVal_forceInt (m) == 0); } } return FALSE; }

bool exprNode_isNumLit ( exprNode e )

Definition at line 8203 of file exprNode.c. { if (exprNode_isDefined (e)) { return (multiVal_isInt (exprNode_getValue (e))); } else { return FALSE; } }

exprNode exprNode_iter ( uentry name, exprNodeList alist, exprNode body, uentry end )

Definition at line 7209 of file exprNode.c. { exprNode ret; cstring iname; llassert (uentry_isValid (name)); uentry_setUsed (name, exprNode_loc (body)); ret = exprNode_createPartialCopy (body); iname = uentry_getName (name); if (uentry_isInvalid (end)) { llerror (FLG_ITER, message ("Iter %s not balanced with end_%s", iname, iname)); } else { cstring ename = uentry_getName (end); if (!cstring_equalPrefix (ename, "end_")) { llerror (FLG_ITER, message ("Iter %s not balanced with end_%s: %s", iname, iname, ename)); } else { if (!cstring_equal (iname, cstring_suffix (ename, 4))) { llerror (FLG_ITER, message ("Iter %s not balanced with end_%s: %s", iname, iname, ename)); } } cstring_free (ename); } context_exitIterClause (body); ret->kind = XPR_ITER; ret->edata = exprData_makeIter (name, alist, body, end); if (uentry_isIter (name)) { (void) checkArgsReal (name, body, uentry_getParams (name), alist, TRUE, ret); } cstring_free (iname); return ret; }

exprNode exprNode_iterExpr ( exprNode e )

Definition at line 7351 of file exprNode.c. { if (!processingIterVars ()) { llcontbuglit ("checkIterParam: not in iter"); return e; } if (uentry_isYield (uentryList_getN (uentry_getParams (getCurrentIter ()), iterParamNo ()))) { if (exprNode_isDefined (e)) { if (fileloc_isDefined (e->loc)) { voptgenerror (FLG_ITER, message ("Yield parameter is not simple identifier: %s", exprNode_unparse (e)), e->loc); } else { voptgenerror (FLG_ITER, message ("Yield parameter is not simple identifier: %s", exprNode_unparse (e)), g_currentloc); } } } return e; }

exprNode exprNode_iterId ( uentry c )

Definition at line 7387 of file exprNode.c. { uentry ue; llassert (processingIterVars ()); ue = uentryList_getN (uentry_getParams (getCurrentIter ()), iterParamNo ()); if (uentry_isYield (ue)) { ctype ct = uentry_getType (ue); exprNode e = exprNode_createPlain (ct); cstring name = uentry_getName (c); uentry le = uentry_makeVariable (name, ct, fileloc_undefined, FALSE); uentry_setUsed (ue, g_currentloc); uentry_setHasNameError (ue); cstring_free (name); e->kind = XPR_VAR; e->edata = exprData_makeId (le); e->loc = context_getSaveLocation (); e->sref = uentry_getSref (le); usymtab_supEntrySref (le); if (!context_inHeader ()) { if (optgenerror (FLG_ITER, message ("Yield parameter shadows local declaration: %q", uentry_getName (c)), fileloc_isDefined (e->loc) ? e->loc : g_currentloc)) { uentry_showWhereDeclared (c); } } return e; } return (exprNode_fromIdentifierAux (c)); }

exprNode exprNode_iterNewId ( cstring s )

Definition at line 7268 of file exprNode.c. { exprNode e = exprNode_new (); uentry ue = uentryList_getN (uentry_getParams (getCurrentIter ()), iterParamNo ()); llassert (processingIterVars ()); e->loc = context_getSaveLocation (); if (fileloc_isUndefined (e->loc)) { fileloc_free (e->loc); e->loc = fileloc_copy (g_currentloc); } e->uses = sRefSet_new (); e->sets = sRefSet_new (); e->msets = sRefSet_new (); e->kind = XPR_VAR; e->val = multiVal_unknown (); e->guards = guardSet_new (); e->sref = defref; e->isJumpPoint = FALSE; e->exitCode = XK_NEVERESCAPE; /*> missing fields, detected by lclint <*/ e->canBreak = FALSE; e->mustBreak = FALSE; e->etext = cstring_undefined; if (uentry_isYield (ue)) { uentry uue = uentry_makeVariable (s, uentry_getType (ue), fileloc_copy (e->loc), FALSE); sRef sr; uue = usymtab_supEntrySrefReturn (uue); sr = uentry_getSref (uue); sRef_mergeStateQuiet (sr, uentry_getSref (ue)); sr = uentry_getSref (uue); sRef_setDefined (sr, e->loc); e->typ = uentry_getType (uue); e->sref = sr; e->edata = exprData_makeId (uue); uentry_setUsed (uue, g_currentloc); } else { uentry uue; sRef_setGlobalScope (); uue = uentry_makeVariableLoc (s, ctype_unknown); e->typ = ctype_unknown; e->edata = exprData_makeId (uue); uentry_setUsed (uue, e->loc); uentry_setHasNameError (uue); if (context_getFlag (FLG_REPEATUNRECOG)) { uentry_markOwned (uue); } else { usymtab_supGlobalEntry (uue); } sRef_clearGlobalScope (); voptgenerror (FLG_UNRECOG, message ("Unrecognized identifier: %s", s), e->loc); } cstring_free (s); return (e); }

exprNode exprNode_iterStart ( uentry name, exprNodeList alist )

Definition at line 7433 of file exprNode.c. { exprNode ret = exprNode_create (ctype_unknown); ret->kind = XPR_ITERCALL; ret->edata = exprData_makeIterCall (name, alist); if (uentry_isIter (name)) { uentryList params = uentry_getParams (name); if (context_inIterDef () && uentryList_size (params) == exprNodeList_size (alist)) { int i = 0; exprNodeList_elements (alist, arg) { uentry parg = uentryList_getN (params, i); if (uentry_isYield (parg)) { uentry ue = exprNode_getUentry (arg); if (uentry_isValid (ue)) { ; } } i++; } end_exprNodeList_elements; } (void) checkArgsReal (name, ret, params, alist, TRUE, ret); checkUnspecCall (ret, params, alist); } return ret; }

exprNode exprNode_labelMarker ( cstring label )

Definition at line 5320 of file exprNode.c. { exprNode ret = exprNode_createPlain (ctype_undefined); ret->kind = XPR_LABEL; ret->edata = exprData_makeLiteral (label); ret->isJumpPoint = TRUE; return (ret); /* for now, ignore label */ }

fileloc exprNode_loc ( exprNode e )

Definition at line 7555 of file exprNode.c. Referenced by checkAssignTransfer(), checkInitTransfer(), checkPassTransfer(), checkReturnTransfer(), checkValueConstant(), exprNode_break(), exprNode_checkMSet(), exprNode_checkSet(), exprNode_comma(), exprNode_concat(), exprNode_continue(), exprNode_for(), exprNode_if(), exprNode_ifelse(), exprNode_makeInitialization(), exprNode_while(), uentry_checkMatchParam(), uentry_makeEnumInitializedConstant(), and usymtab_popBranches(). { if (exprNode_isError (e)) { return (g_currentloc); } else { return (e->loc); } }

exprNode exprNode_makeBlock ( exprNode e )

Definition at line 5669 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (e); if (!exprNode_isError (e)) { ret->exitCode = e->exitCode; ret->canBreak = e->canBreak; ret->mustBreak = e->mustBreak; } ret->edata = exprData_makeSingle (e); ret->kind = XPR_BLOCK; return ret; }

exprNode exprNode_makeError ( )

Definition at line 364 of file exprNode.c. Referenced by exprNode_arrayFetch(), and exprNode_functionCall(). { return exprNode_undefined; }

exprNode exprNode_makeInitBlock ( lltok brace, exprNodeList inits )

Definition at line 3154 of file exprNode.c. { exprNode ret = exprNode_createPlain (ctype_unknown); ret->kind = XPR_INITBLOCK; ret->edata = exprData_makeCall (exprNode_undefined, inits); ret->loc = fileloc_update (ret->loc, lltok_getLoc (brace)); return (ret); }

exprNode exprNode_makeInitialization ( idDecl t, exprNode e )

Definition at line 7083 of file exprNode.c. { uentry ue = usymtab_lookup (idDecl_observeId (t)); bool isUsed = uentry_isUsed (ue); exprNode ret = exprNode_fromIdentifierAux (ue); ctype ct = ctype_realishType (ret->typ); fileloc loc; if (ctype_isUnknown (ct)) { voptgenerror (FLG_IMPTYPE, message ("Variable has unknown (implicitly int) type: %s", idDecl_getName (t)), exprNode_isDefined (e) ? exprNode_loc (e) : g_currentloc); ct = ctype_int; } if (exprNode_isError (e)) { e = exprNode_createUnknown (); loc = g_currentloc; /* error: assume initializer is defined */ sRef_setDefined (ret->sref, loc); } else { loc = exprNode_loc (e); /* ** evs - 9 Apr 1995 ** ** was addSafeUse --- what's the problem? ** ** int x = 3, y = x ? */ exprNode_checkUse (ret, e->sref, e->loc); if (ctype_isUnknown (e->typ) && uentry_isValid (ue)) { exprNode lhs = exprNode_createId (ue); /* ** static storage should be undefined before initializing */ if (uentry_isStatic (ue)) { sRef_setDefState (lhs->sref, SS_PARTIAL, fileloc_undefined); } (void) exprNode_checkOneInit (lhs, e); if (uentry_isStatic (ue)) { sRef_setDefState (lhs->sref, SS_DEFINED, fileloc_undefined); } exprNode_free (lhs); } else { if (!exprNode_matchType (ct, e)) { if (exprNode_isZero (e) && ctype_isArrayPtr (ct)) { ; } else { (void) gentypeerror (exprNode_getType (e), e, exprNode_getType (ret), ret, message ("Variable %s initialized to type %t, expects %t: %s", exprNode_unparse (ret), exprNode_getType (e), exprNode_getType (ret), exprNode_unparse (e)), e->loc); } } } if (uentry_isStatic (ue)) { sRef_setDefState (ret->sref, SS_PARTIAL, fileloc_undefined); } doAssign (ret, e, TRUE); if (uentry_isStatic (ue)) { sRef_setDefState (ret->sref, SS_DEFINED, fileloc_undefined); } } if (context_inIterDef ()) { /* should check if it is yield */ uentry_setUsed (ue, loc); } else { if (!isUsed) /* could be @unused@-qualified variable */ { uentry_setNotUsed (ue); } } ret->exitCode = XK_NEVERESCAPE; ret->mustBreak = FALSE; /* ** Must be before new kind is assigned! */ exprData_free (ret->edata, ret->kind); ret->kind = XPR_INIT; ret->edata = exprData_makeInit (t, e); exprNode_mergeUSs (ret, e); return ret; }

exprNode exprNode_makeMustExit ( void )

Definition at line 413 of file exprNode.c. { if (exprNode_isUndefined (mustExitNode)) { mustExitNode = exprNode_createPlain (ctype_unknown); mustExitNode->exitCode = XK_MUSTEXIT; } return mustExitNode; }

bool exprNode_matchLiteral ( ctype expected, exprNode e )

Definition at line 8232 of file exprNode.c. Referenced by exprNode_assign(), and exprNode_matchType(). { if (exprNode_isDefined (e)) { multiVal m = exprNode_getValue (e); if (multiVal_isDefined (m)) { if (multiVal_isInt (m)) { long int val = multiVal_forceInt (m); if (ctype_isDirectBool (ctype_realishType (expected))) { if (val == 0) { return FALSE; /* really?! return TRUE; allow use of 0 for FALSE */ } else { return FALSE; } } if (ctype_isRealInt (expected)) { /* ** unsigned <- [ constant >= 0 is okay ] */ if (ctype_isUnsigned (expected)) { if (val < 0) { return FALSE; } } /* ** No checks on sizes of integers...maybe add ** these later. */ DPRINTF (("Here: %s => %s", exprNode_unparse (e), ctype_unparse (expected))); DPRINTF (("Type: %s / %s", ctype_unparse (exprNode_getType (e)), bool_unparse (ctype_isInt (exprNode_getType (e))))); if (context_getFlag (FLG_NUMLITERAL) && (ctype_isRegularInt (exprNode_getType (e)) || val == 0)) { return TRUE; } else { if (val == 0) { return TRUE; } else { return FALSE; /* evs 2000-05-17: previously, always returned TRUE */ } } } else if (ctype_isChar (expected)) { return FALSE; } else if (ctype_isArrayPtr (expected)) { return (val == 0); } else if (ctype_isAnyFloat (expected)) { return (context_getFlag (FLG_NUMLITERAL)); } else { return FALSE; } } else if (multiVal_isDouble (m)) { if (ctype_isAnyFloat (expected)) { return TRUE; } } else if (multiVal_isChar (m)) { char val = multiVal_forceChar (m); if (ctype_isChar (expected)) { if (ctype_isUnsigned (expected) && ((int)val) < 0) { return FALSE; } else { return TRUE; } } } else { return FALSE; } } } return FALSE; }

bool exprNode_matchType ( ctype expected, exprNode e )

Definition at line 8341 of file exprNode.c. Referenced by checkValueConstant(), exprNode_checkMacroBody(), and exprNode_makeInitialization(). { ctype actual; if (!exprNode_isDefined (e)) return TRUE; actual = ctype_realishType (exprNode_getType (e)); if (ctype_match (ctype_realishType (expected), actual)) { return TRUE; } llassert (!exprNode_isError (e)); return (exprNode_matchLiteral (expected, e)); }

bool exprNode_mayEscape ( exprNode e )

Definition at line 5447 of file exprNode.c. Referenced by exprNode_checkStatement(). { if (exprNode_isDefined (e)) { return exitkind_couldEscape (e->exitCode); } return FALSE; }

bool exprNode_mustEscape ( exprNode e )

Definition at line 5467 of file exprNode.c. Referenced by exprNode_checkFunctionBody(), exprNode_comma(), exprNode_concat(), exprNode_if(), exprNode_ifelse(), exprNode_while(), usymtab_exitScope(), usymtab_popBranches(), and usymtab_popOrBranch(). { if (exprNode_isDefined (e)) { return exitkind_mustEscape (e->exitCode) || exprNode_mustBreak (e); } return FALSE; }

exprNode exprNode_notReached ( exprNode stmt )

Definition at line 5330 of file exprNode.c. { if (exprNode_isDefined (stmt)) { stmt->isJumpPoint = TRUE; /* This prevent stray no return path errors, etc. */ stmt->exitCode = XK_MUSTEXIT; } return (stmt); }

exprNode exprNode_nullReturn ( lltok t )

Definition at line 6797 of file exprNode.c. { fileloc loc = lltok_getLoc (t); exprNode ret = exprNode_createLoc (ctype_unknown, fileloc_copy (loc)); context_returnFunction (); exprChecks_checkNullReturn (loc); ret->kind = XPR_NULLRETURN; ret->edata = exprData_makeTok (t); ret->exitCode = XK_MUSTRETURN; return ret; }

exprNode exprNode_numLiteral ( ctype c, cstring t, fileloc loc, long val )

Definition at line 643 of file exprNode.c. { exprNode e = exprNode_createLoc (c, loc); e->kind = XPR_NUMLIT; llassert (multiVal_isUndefined (e->val)); e->val = multiVal_makeInt (val); e->edata = exprData_makeLiteral (cstring_copy (t)); if (val == 0) { e->sref = sRef_makeUnknown (); sRef_setDefNull (e->sref, e->loc); } DPRINTF (("Num lit: %s / %s", exprNode_unparse (e), ctype_unparse (exprNode_getType (e)))); return (e); }

exprNode exprNode_offsetof ( qtype qt, cstringList s )

Definition at line 3922 of file exprNode.c. { exprNode ret = exprNode_create (sizeof_resultType ()); ctype ct = qtype_getType (qt); ret->kind = XPR_OFFSETOF; ret->edata = exprData_makeOffsetof (qt, s); if (!ctype_isRealSU (ct)) { voptgenerror (FLG_TYPE, message ("First parameter to offsetof is not a " "struct or union type (type %s): %s", ctype_unparse (ct), exprNode_unparse (ret)), ret->loc); } else { ctype lt = ct; cstringList_elements (s, el) { uentryList fields; uentry fld; if (ctype_isUndefined (lt)) { break; } else if (!ctype_isRealSU (lt)) { voptgenerror (FLG_TYPE, message ("Inner offsetof type is not a " "struct or union type (type %s before field %s): %s", ctype_unparse (lt), el, exprNode_unparse (ret)), ret->loc); break; } else { fields = ctype_getFields (ctype_realType (lt)); fld = uentryList_lookupField (fields, el); DPRINTF (("Try: %s / %s", ctype_unparse (lt), el)); if (uentry_isUndefined (fld)) { if (ctype_equal (lt, ct)) { voptgenerror (FLG_TYPE, message ("Field %s in offsetof is not the " "name of a field of %s: %s", el, ctype_unparse (ct), exprNode_unparse (ret)), ret->loc); } else { voptgenerror (FLG_TYPE, message ("Deep field %s in offsetof is not the " "name of a field of %s: %s", el, ctype_unparse (lt), exprNode_unparse (ret)), ret->loc); } } else { lt = uentry_getType (fld); } } } end_cstringList_elements; /* Should report error if its a bit field - behavior is undefined! */ } return (ret); }

exprNode exprNode_op ( exprNode e1, exprNode e2, lltok op )

Definition at line 4878 of file exprNode.c. { exprNode ret; checkMacroParen (e1); checkMacroParen (e2); if (evaluationOrderUndefined (op) && context_maybeSet (FLG_EVALORDER)) { checkExpressionDefined (e1, e2, op); } ret = exprNode_makeOp (e1, e2, op); return (ret); }

exprNode exprNode_postOp ( exprNode e, lltok op )

Definition at line 3541 of file exprNode.c. { /* check modification also */ /* cstring opname = lltok_unparse (op);*/ ctype t; exprNode ret = exprNode_createPartialCopy (e); ret->loc = fileloc_update (ret->loc, lltok_getLoc (op)); ret->kind = XPR_POSTOP; ret->edata = exprData_makeUop (e, op); if (!exprNode_isDefined (e)) { return ret; } checkMacroParen (e); exprNode_checkUse (ret, e->sref, e->loc); exprNode_checkSet (ret, e->sref); t = exprNode_getType (e); if (sRef_isUnsafe (e->sref)) { voptgenerror (FLG_MACROPARAMS, message ("Operand of %s is macro parameter (non-functional): %s%s", lltok_unparse (op), exprNode_unparse (e), lltok_unparse (op)), e->loc); sRef_makeSafe (e->sref); sRef_makeSafe (ret->sref); } if (ctype_isForceRealNumeric (&t) || ctype_isRealAP (t)) { ret->typ = e->typ; } else { if (ctype_isRealAbstract (t)) { voptgenerror (FLG_ABSTRACT, message ("Operand of %s is abstract type (%t): %s", lltok_unparse (op), t, exprNode_unparse (e)), e->loc); } else { voptgenerror (FLG_TYPE, message ("Operand of %s is non-numeric (%t): %s", lltok_unparse (op), t, exprNode_unparse (e)), e->loc); } ret->typ = ctype_unknown; } /* if (ctype_isZero (t)) e->typ = ctype_int; */ exprNode_checkModify (e, ret); return ret; }

exprNode exprNode_preOp ( exprNode e, lltok op )

Definition at line 3607 of file exprNode.c. { bool checkMod = FALSE; ctype te, tr; int opid = lltok_getTok (op); exprNode ret = exprNode_createSemiCopy (e); exprNode_copySets (ret, e); multiVal_free (ret->val); ret->val = multiVal_undefined; ret->loc = fileloc_update (ret->loc, lltok_getLoc (op)); ret->kind = XPR_PREOP; ret->edata = exprData_makeUop (e, op); if (exprNode_isError (e)) { return ret; } checkMacroParen (e); te = exprNode_getType (e); tr = ctype_realType (te); if (opid != TAMPERSAND) { exprNode_checkUse (ret, e->sref, e->loc); if (ctype_isRealAbstract (tr) && (!(ctype_isRealBool (te) && (opid == TEXCL)))) { if (optgenerror (FLG_ABSTRACT, message ("Operand of %s is abstract type (%t): %s", lltok_unparse (op), tr, exprNode_unparse (ret)), e->loc)) { tr = te = ctype_unknown; ret->typ = ctype_unknown; sRef_setNullError (e->sref); } } } switch (opid) { case INC_OP: case DEC_OP: /* should also check modification! */ if (sRef_isMacroParamRef (e->sref)) { voptgenerror (FLG_MACROPARAMS, message ("Operand of %s is macro parameter (non-functional): %s", lltok_unparse (op), exprNode_unparse (ret)), e->loc); } else { exprNode_checkSet (ret, e->sref); } if (ctype_isForceRealNumeric (&tr) || ctype_isRealAP (tr)) { } else { if (context_msgStrictOps ()) { voptgenerror (FLG_STRICTOPS, message ("Operand of %s is non-numeric (%t): %s", lltok_unparse (op), te, exprNode_unparse (ret)), e->loc); } ret->typ = ctype_int; } checkMod = TRUE; break; case TMINUS: case TPLUS: if (ctype_isForceRealNumeric (&tr)) { if (opid == TMINUS) { ret->val = multiVal_invert (exprNode_getValue (e)); } else { ret->val = multiVal_copy (exprNode_getValue (e)); } } else { if (context_msgStrictOps ()) { voptgenerror (FLG_STRICTOPS, message ("Operand of %s is non-numeric (%t): %s", lltok_unparse (op), te, exprNode_unparse (ret)), e->loc); } ret->typ = ctype_int; } break; case TEXCL: /* maybe this should be restricted */ guardSet_flip (ret->guards); if (ctype_isRealBool (te)) { ; } else { if (ctype_isRealPointer (tr)) { if (sRef_isKnown (e->sref)) { ret->guards = guardSet_addFalseGuard (ret->guards, e->sref); } voptgenerror2n (FLG_BOOLOPS, FLG_PTRNEGATE, message ("Operand of %s is non-boolean (%t): %s", lltok_unparse (op), te, exprNode_unparse (ret)), e->loc); } else { voptgenerror (FLG_BOOLOPS, message ("Operand of %s is non-boolean (%t): %s", lltok_unparse (op), te, exprNode_unparse (ret)), e->loc); } ret->typ = ctype_bool; } break; case TTILDE: if (ctype_isForceRealInt (&tr)) { } else { if (context_msgStrictOps ()) { voptgenerror (FLG_STRICTOPS, message ("Operand of %s is non-integer (%t): %s", lltok_unparse (op), te, exprNode_unparse (ret)), e->loc); } if (ctype_isInt (e->typ)) { ret->typ = e->typ; } else { ret->typ = ctype_int; } } break; case TAMPERSAND: ret->typ = ctype_makePointer (e->typ); if (sRef_isKnown (e->sref)) { ret->sref = sRef_makeAddress (e->sref); } break; case TMULT: if (ctype_isAP (tr)) { ret->typ = ctype_baseArrayPtr (e->typ); } else { if (ctype_isKnown (te)) { if (ctype_isFunction (te)) { ret->typ = e->typ; voptgenerror (FLG_FCNDEREF, message ("Dereference of function type (%t): %s", te, exprNode_unparse (ret)), e->loc); } else { voptgenerror (FLG_TYPE, message ("Dereference of non-pointer (%t): %s", te, exprNode_unparse (ret)), e->loc); ret->typ = ctype_unknown; } } else { ret->typ = ctype_unknown; } } if (sRef_isKnown (e->sref)) { if (sRef_possiblyNull (e->sref)) { if (!usymtab_isGuarded (e->sref) && !context_inProtectVars ()) { if (optgenerror (FLG_NULLDEREF, message ("Dereference of %s pointer %q: %s", sRef_nullMessage (e->sref), sRef_unparse (e->sref), exprNode_unparse (ret)), e->loc)) { sRef_showNullInfo (e->sref); sRef_setNotNull (e->sref, e->loc); /* suppress future messages */ } } } ret->sref = sRef_makePointer (e->sref); } break; default: llbug (message ("exprNode_preOp: unhandled op: %s", lltok_unparse (op))); } if (checkMod) { exprNode_checkModify (e, ret); } return ret; }

void exprNode_produceGuards ( exprNode pred )

Definition at line 5655 of file exprNode.c. Referenced by exprNode_whilePred(). { if (!exprNode_isError (pred)) { if (ctype_isRealPointer (pred->typ)) { pred->guards = guardSet_addTrueGuard (pred->guards, pred->sref); } exprNode_checkUse (pred, pred->sref, pred->loc); exprNode_resetSref (pred); } }

exprNode exprNode_return ( exprNode e )

Definition at line 6811 of file exprNode.c. { exprNode ret; if (exprNode_isError (e)) { ret = exprNode_createUnknown (); } else { ret = exprNode_createLoc (ctype_unknown, fileloc_copy (e->loc)); exprNode_checkUse (ret, e->sref, e->loc); exprNode_checkReturn (e); } context_returnFunction (); ret->kind = XPR_RETURN; ret->edata = exprData_makeSingle (e); ret->exitCode = XK_MUSTRETURN; return (ret); }

exprNode exprNode_sizeofExpr ( exprNode e )

Definition at line 4001 of file exprNode.c. { exprNode ret; if (exprNode_isUndefined (e)) { ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc)); ret->edata = exprData_makeSingle (e); ret->typ = sizeof_resultType (); ret->kind = XPR_SIZEOF; } else { uentry u = exprNode_getUentry (e); ret = exprNode_createPartialCopy (e); ret->edata = exprData_makeSingle (e); ret->typ = sizeof_resultType (); ret->kind = XPR_SIZEOF; if (uentry_isValid (u) && uentry_isRefParam (u) && ctype_isRealArray (uentry_getType (u))) { voptgenerror (FLG_SIZEOFFORMALARRAY, message ("Parameter to sizeof is an array-type function parameter: %s", exprNode_unparse (ret)), ret->loc); } } /* ** sizeof (x) doesn't "really" use x */ return (ret); }

exprNode exprNode_sizeofType ( qtype qt )

Definition at line 3887 of file exprNode.c. { exprNode ret = exprNode_create (sizeof_resultType ()); ctype ct = qtype_getType (qt); ret->kind = XPR_SIZEOFT; ret->edata = exprData_makeSizeofType (qt); voptgenerror (FLG_SIZEOFTYPE, message ("Parameter to sizeof is type %s: %s", ctype_unparse (ct), exprNode_unparse (ret)), ret->loc); return (ret); }

exprNode exprNode_statement ( exprNode e )

Definition at line 5610 of file exprNode.c. { if (!exprNode_isError (e)) { exprNode_checkStatement(e); } return (exprNode_statementError (e)); }

exprNode exprNode_stringLiteral ( cstring t, fileloc loc )

Definition at line 710 of file exprNode.c. { exprNode e = exprNode_createLoc (ctype_string, loc); int len = cstring_length (t) - 2; char *ts = cstring_toCharsSafe (t); char *s = cstring_toCharsSafe (cstring_create (len + 1)); if (context_getFlag (FLG_STRINGLITERALLEN)) { if (len > context_getValue (FLG_STRINGLITERALLEN)) { voptgenerror (FLG_STRINGLITERALLEN, message ("String literal length (%d) exceeds maximum " "length (%d): %s", len, context_getValue (FLG_STRINGLITERALLEN), t), e->loc); } } strncpy (s, ts+1, size_fromInt (len)); *(s + len) = '\0'; e->kind = XPR_STRINGLITERAL; e->val = multiVal_makeString (cstring_fromCharsO (s)); e->edata = exprData_makeLiteral (t); e->sref = sRef_makeType (ctype_string); if (context_getFlag (FLG_READONLYSTRINGS)) { sRef_setAliasKind (e->sref, AK_STATIC, fileloc_undefined); sRef_setExKind (e->sref, XO_OBSERVER, loc); } else { sRef_setAliasKind (e->sref, AK_ERROR, fileloc_undefined); } return (e); /* s released */ }

exprNode exprNode_switch ( exprNode e, exprNode s )

Definition at line 6064 of file exprNode.c. { exprNode ret = exprNode_createPartialCopy (e); bool allpaths; DPRINTF (("Switch: %s", exprNode_unparse (s))); ret->kind = XPR_SWITCH; ret->edata = exprData_makePair (e, s); if (!exprNode_isError (s)) { exprNode fs = exprNode_firstStatement (s); ret->loc = fileloc_update (ret->loc, s->loc); if (exprNode_isUndefined (fs) || exprNode_isCaseMarker (fs) || exprNode_isLabelMarker (fs) || exprNode_isDefaultMarker (fs)) { ; } else { voptgenerror (FLG_FIRSTCASE, message ("Statement after switch is not a case: %s", exprNode_unparse (fs)), fs->loc); } } if (!exprNode_isError (e)) { if (checkSwitchExpr (e, s, &allpaths)) { ret->exitCode = XK_MUSTRETURN; } else { ret->exitCode = e->exitCode; } ret->canBreak = e->canBreak; ret->mustBreak = e->mustBreak; } /* ** forgot this! ** exprNode.c:3883,32: Variable allpaths used before definition */ else { allpaths = FALSE; } DPRINTF (("Context exit switch!")); context_exitSwitch (ret, allpaths); DPRINTF (("Context exit switch done!")); return ret; }

cstring exprNode_unparse ( exprNode e )

Definition at line 7532 of file exprNode.c. Referenced by checkAssignTransfer(), checkPassTransfer(), checkReturnTransfer(), checkValueConstant(), exprNode_alignofType(), exprNode_arrayFetch(), exprNode_arrowAccess(), exprNode_assign(), exprNode_cast(), exprNode_checkMacroBody(), exprNode_checkPred(), exprNode_cond(), exprNode_fieldAccess(), exprNode_ifelse(), exprNode_makeInitialization(), exprNode_offsetof(), exprNode_postOp(), exprNode_preOp(), exprNode_sizeofType(), uentry_checkMatchParam(), and uentry_makeEnumInitializedConstant(). { if (exprNode_isError (e)) { return cstring_makeLiteralTemp ("<error>"); } if (cstring_isDefined (e->etext)) { return e->etext; } else { cstring ret = exprNode_doUnparse (e); /*@-modifies@*/ /* benevolent */ e->etext = ret; /*@=modifies@*/ return ret; } }

cstring exprNode_unparseFirst ( exprNode e )

Definition at line 7499 of file exprNode.c. Referenced by exprNode_checkStatement(). { if (exprNode_isDefined (e)) { cstring ret; if (e->kind == XPR_STMTLIST || e->kind == XPR_COMMA || e->kind == XPR_COND) { exprNode first = exprData_getPairA (e->edata); if (exprNode_isDefined (first)) { return (exprNode_unparseFirst (exprData_getPairA (e->edata))); } else { return (cstring_makeLiteralTemp ("...")); } } ret = cstring_elide (exprNode_unparse (e), 20); cstring_markOwned (ret); return (ret); } else { return cstring_makeLiteralTemp ("<error>"); } }

exprNode exprNode_updateLocation ( exprNode e, fileloc loc )

Definition at line 9627 of file exprNode.c. { if (exprNode_isDefined (e)) { e->loc = fileloc_update (e->loc, loc); } else { e = exprNode_createLoc (ctype_unknown, fileloc_copy (loc)); } return (e); }

exprNode exprNode_vaArg ( lltok tok, exprNode arg, qtype qt )

Definition at line 5273 of file exprNode.c. { ctype totype = qtype_getType (qt); exprNode ret = exprNode_createPartialLocCopy (arg, fileloc_copy (lltok_getLoc (tok))); ctype targ; /* ** check use of va_arg : <valist>, type -> type */ if (exprNode_isError (arg)) { } else { targ = exprNode_getType (arg); /* ** arg should have be a pointer */ if (!ctype_isUA (targ) || (!usymId_equal (ctype_typeId (targ), usymtab_getTypeId (cstring_makeLiteralTemp ("va_list"))))) { voptgenerror (FLG_TYPE, message ("First argument to va_arg is not a va_list (type %t): %s", targ, exprNode_unparse (arg)), arg->loc); } exprNode_checkSet (ret, arg->sref); } /* ** return type is totype */ ret->typ = totype; ret->kind = XPR_VAARG; ret->edata = exprData_makeCast (tok, arg, qt); return (ret); }

exprNode exprNode_while ( exprNode t, exprNode b )

Definition at line 6224 of file exprNode.c. { exprNode ret; bool emptyErr = FALSE; if (context_maybeSet (FLG_WHILEEMPTY)) { if (exprNode_isEmptyStatement (b)) { emptyErr = optgenerror (FLG_WHILEEMPTY, cstring_makeLiteral ("Body of while statement is empty"), exprNode_loc (b)); } } if (!emptyErr && context_maybeSet (FLG_WHILEBLOCK)) { if (exprNode_isDefined (b) && !exprNode_isBlock (b)) { if (context_inIterDef () && (b->kind == XPR_STMTLIST || b->kind == XPR_TOK)) { ; /* no error */ } else { voptgenerror (FLG_WHILEBLOCK, message ("Body of while statement is not a block: %s", exprNode_unparse (b)), exprNode_loc (b)); } } } if (exprNode_isError (t)) { if (exprNode_isError (b)) { ret = exprNode_createLoc (ctype_unknown, g_currentloc); } else { ret = exprNode_createPartialCopy (b); } } else { exprNode test; ret = exprNode_createPartialCopy (t); llassert (t->kind == XPR_WHILEPRED); test = exprData_getSingle (t->edata); if (!exprNode_isError (b) && exprNode_isDefined (test)) { if (context_maybeSet (FLG_INFLOOPS) || context_maybeSet (FLG_INFLOOPSUNCON)) { /* ** check that some variable in the predicate is set by the body ** if the predicate uses any variables */ checkInfiniteLoop (test, b); } exprNode_mergeUSs (ret, b); if (exprNode_isDefined (b)) { ret->exitCode = exitkind_makeConditional (b->exitCode); } } } ret->edata = exprData_makePair (t, b); ret->kind = XPR_WHILE; if (exprNode_isDefined (t) && exprNode_mustEscape (t)) { voptgenerror (FLG_CONTROL, message ("Predicate always exits: %s", exprNode_unparse (t)), exprNode_loc (t)); } ret->exitCode = XK_NEVERESCAPE; /* ** If loop is infinite, and there is no break inside, ** exit code is never reach. */ if (exprNode_knownIntValue (t)) { if (!exprNode_isZero (t)) { if (exprNode_isDefined (b)) { if (!b->canBreak) { /* Really, it means never reached. */ ret->exitCode = XK_MUSTEXIT; } } } } else { ; } ret->canBreak = FALSE; ret->mustBreak = FALSE; return ret; }

exprNode exprNode_whilePred ( exprNode test )

Definition at line 6538 of file exprNode.c. { exprNode ret = exprNode_createSemiCopy (test); if (exprNode_isDefined (test)) { exprNode_copySets (ret, test); exprNode_checkPred (cstring_makeLiteralTemp ("while"), test); exprNode_checkUse (ret, test->sref, test->loc); exprNode_produceGuards (test); ret->guards = guardSet_copy (test->guards); } ret->edata = exprData_makeSingle (test); ret->kind = XPR_WHILEPRED; return ret; }

---