2 ** Splint - annotation-assisted static program checker
3 ** Copyright (C) 1994-2002 University of Virginia,
4 ** Massachusetts Institute of Technology
6 ** This program is free software; you can redistribute it and/or modify it
7 ** under the terms of the GNU General Public License as published by the
8 ** Free Software Foundation; either version 2 of the License, or (at your
9 ** option) any later version.
11 ** This program is distributed in the hope that it will be useful, but
12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 ** General Public License for more details.
16 ** The GNU General Public License is available from http://www.gnu.org/ or
17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 ** MA 02111-1307, USA.
20 ** For information on splint: info@splint.org
21 ** To report a bug: splint-bug@splint.org
22 ** For more information: http://www.splint.org
25 ** usymtab_interface.c
27 ** Grammar interface to symtab.
29 ** The Splint parser will build symbol tables for abstract types and
30 ** function declarations.
34 # include "splintMacros.nf"
38 # include "lclsyntable.h"
39 # include "lslparse.h"
40 # include "usymtab_interface.h"
41 # include "structNames.h"
44 declareFcnAux (fcnNode p_f, /*@only@*/ qtype p_qt, ctype p_ct, typeId p_tn,
45 bool p_priv, bool p_spec);
47 static uentryList paramNodeList_toUentryList (paramNodeList p_p);
48 static /*@observer@*/ cstring getVarName (/*@null@*/ typeExpr p_x);
49 static qtype convertLclTypeSpecNode (/*@null@*/ lclTypeSpecNode p_n);
50 static ctype convertTypeExpr (ctype p_c, /*@null@*/ typeExpr p_x);
51 static ctype convertCTypeExpr (ctype p_c, /*@null@*/ typeExpr p_x);
52 static /*@exposed@*/ sRef fixTermNode (termNode p_n, fcnNode p_f, uentryList p_cl);
53 static sRefSet fixModifies (fcnNode p_f, uentryList p_cl);
56 convertuentryList (stDeclNodeList x)
58 uentryList fl = uentryList_new ();
61 stDeclNodeList_elements (x, i)
63 declaratorNodeList d = i->declarators;
64 qtype q = convertLclTypeSpecNode (i->lcltypespec);
66 declaratorNodeList_elements (d, j)
70 qtype_setType (q, convertTypeExpr (qtype_getType (q), j->type));
71 id = idDecl_create (cstring_copy (getVarName (j->type)), qtype_copy (q));
72 fl = uentryList_add (fl, uentry_makeIdVariable (id));
74 } end_declaratorNodeList_elements;
77 } end_stDeclNodeList_elements;
84 convert_uentryList (paramNodeList x)
86 uentryList p = uentryList_undefined;
87 bool first_one = TRUE;
90 paramNodeList_elements (x, i)
92 if (i != (paramNode) 0)
94 if (paramNode_isElipsis (i))
97 p = uentryList_add (p, uentry_makeElipsisMarker ());
101 qtype q = convertLclTypeSpecNode (i->type);
102 typeExpr t = i->paramdecl;
104 qtype_setType (q, convertTypeExpr (qtype_getType (q), t));
106 /* note: has to be like this to hack around void ???? still */
110 if (ctype_isVoid (qtype_getType (q)))
112 llassert (uentryList_isUndefined (p));
121 ** don't do qualifiers here, will get errors later
124 p = uentryList_add (p, uentry_makeUnnamedVariable (qtype_getType (q)));
130 llbug (cstring_makeLiteral ("convertuentryList: null paramNode"));
132 } end_paramNodeList_elements;
136 llassert (uentryList_isUndefined (p));
138 p = uentryList_makeMissingParams ();
147 ** modify c with pointer, array, function
149 ** (based on printTypeExpr2 from abstract.c)
154 convertTypeExpr (ctype c, typeExpr x)
156 if (x == (typeExpr) 0)
166 return (convertTypeExpr (ctype_makePointer (c), x->content.pointer));
168 return (convertTypeExpr (ctype_makeArray (c), x->content.array.elementtype));
171 ctype rv = convertTypeExpr (c, x->content.function.returntype);
172 uentryList p = paramNodeList_toUentryList (x->content.function.args);
174 if (x->content.function.returntype != NULL
175 && x->content.function.returntype->wrapped == 1
176 && ctype_isPointer (rv))
178 rv = ctype_baseArrayPtr (rv);
181 return (ctype_makeParamsFunction (rv, p));
185 llfatalbug (message ("convertTypeExpr: unknown typeExprKind: %d",
194 ctype convertCTypeExpr (ctype c, typeExpr x)
196 if (x == (typeExpr) 0)
203 case TEXPR_BASE: return (c);
204 case TEXPR_PTR: return (convertCTypeExpr (ctype_makePointer (c),
205 x->content.pointer));
206 case TEXPR_ARRAY: return (convertCTypeExpr (ctype_makeArray (c),
207 x->content.array.elementtype));
210 ctype rv = convertCTypeExpr (c, x->content.function.returntype);
211 uentryList p = convert_uentryList (x->content.function.args);
213 return (ctype_makeParamsFunction (rv, p));
217 llfatalbug (message ("convertCTypeExpr: unknown typeExprKind: %d", (int) x->kind));
224 ** convertLclTypeSpecNode
226 ** LclTypeSpecNode --> ctype
227 ** this is the base type only!
233 ** for now, assume only last leaf is relevant.
234 ** this should be a safe assumption in general???
238 convertLeaves (ltokenList f)
240 ctype c = ctype_unknown;
242 ltokenList_reset (f);
244 ltokenList_elements (f, current)
246 switch (ltoken_getCode (current))
248 case LLT_TYPEDEF_NAME:
250 cstring tn = ltoken_getRawString (current);
252 if (usymtab_existsTypeEither (tn))
254 c = ctype_combine (uentry_getAbstractType
255 (usymtab_lookupEither (tn)), c);
257 else if (cstring_equalLit (tn, "bool"))
260 ** Bogus...keep consistent with old lcl builtin.
266 fileloc loc = fileloc_fromTok (current);
268 voptgenerror (FLG_UNRECOG,
269 message ("Unrecognized type: %s", tn), loc);
274 (tn, ctype_unknown, MAYBE, NO, fileloc_getBuiltin ()));
277 /*@switchbreak@*/ break;
280 c = ctype_combine (ctype_char, c);
281 /*@switchbreak@*/ break;
284 c = ctype_combine (ctype_double, c);
285 /*@switchbreak@*/ break;
287 c = ctype_combine (ctype_float, c);
288 /*@switchbreak@*/ break;
291 /*@switchbreak@*/ break;
293 c = ctype_combine (ctype_int, c);
294 /*@switchbreak@*/ break;
296 c = ctype_combine (c, ctype_lint);
297 /*@switchbreak@*/ break;
299 c = ctype_combine (c, ctype_sint);
300 /*@switchbreak@*/ break;
302 c = ctype_combine (c, ctype_int);
303 /*@switchbreak@*/ break;
305 c = ctype_combine (c, ctype_uint);
306 /*@switchbreak@*/ break;
308 c = ctype_combine (ctype_unknown, c);
309 /*@switchbreak@*/ break;
311 c = ctype_combine (ctype_void, c);
312 /*@switchbreak@*/ break;
314 llcontbug (cstring_makeLiteral ("convertLeaves: enum"));
316 /*@switchbreak@*/ break;
318 llfatalbug (message ("convertLeaves: bad token: %q",
319 ltoken_unparseCodeName (current)));
321 } end_ltokenList_elements;
327 convertEnumList (ltokenList enums)
329 enumNameList el = enumNameList_new ();
331 if (ltokenList_isDefined (enums))
333 ltokenList_elements (enums, i)
336 (el, enumName_create (cstring_copy (ltoken_unparse (i))));
337 } end_ltokenList_elements;
343 static /*@only@*/ qtype
344 convertLclTypeSpecNode (/*@null@*/ lclTypeSpecNode n)
347 if (n != (lclTypeSpecNode) 0)
355 qtype c1 = convertLclTypeSpecNode (n->content.conj->a);
356 qtype c2 = convertLclTypeSpecNode (n->content.conj->b);
362 if (fileloc_isLib (g_currentloc)
363 || fileloc_isStandardLibrary (g_currentloc))
365 result = qtype_mergeImplicitAlt (c1, c2);
369 result = qtype_mergeAlt (c1, c2);
375 llassert (n->content.type != NULL);
376 result = qtype_create (convertLeaves (n->content.type->ctypes));
378 case LTS_STRUCTUNION:
381 cstring cn = cstring_undefined;
383 sn = n->content.structorunion;
385 llassert (sn != (strOrUnionNode) 0);
387 if (!ltoken_isUndefined (sn->opttagid))
389 cn = cstring_copy (ltoken_getRawString (sn->opttagid));
399 if (usymtab_existsStructTag (cn))
402 result = qtype_create (uentry_getAbstractType
403 (usymtab_lookupStructTag (cn)));
408 uentryList fl = convertuentryList (sn->structdecls);
411 ct = ctype_createStruct (cstring_copy (cn), fl);
414 ** If it was a forward declaration, this could add it to
415 ** the table. Need to check if it exists again...
418 if (usymtab_existsStructTag (cn))
420 result = qtype_create (uentry_getAbstractType
421 (usymtab_lookupStructTag (cn)));
425 fileloc loc = fileloc_fromTok (n->content.structorunion->tok);
426 uentry ue = uentry_makeStructTag (cn, ct, loc);
428 result = qtype_create (usymtab_supTypeEntry (ue));
433 /*@switchbreak@*/ break;
435 if (usymtab_existsUnionTag (cn))
438 result = qtype_create (uentry_getAbstractType
439 (usymtab_lookupUnionTag (cn)));
447 fl = convertuentryList (sn->structdecls);
448 ct = ctype_createUnion (cstring_copy (cn), fl);
451 ** If it was a forward declaration, this could add it to
452 ** the table. Need to check if it exists again...
457 if (usymtab_existsUnionTag (cn))
460 result = qtype_create (uentry_getAbstractType
461 (usymtab_lookupUnionTag (cn)));
465 fileloc loc = fileloc_fromTok (n->content.structorunion->tok);
466 uentry ue = uentry_makeUnionTag (cn, ct, loc);
468 result = qtype_create (usymtab_supTypeEntry (ue));
473 /*@switchbreak@*/ break;
480 enumSpecNode e = n->content.enumspec;
487 llassert (e != NULL);
488 el = convertEnumList (e->enums);
490 if (!ltoken_isUndefined (e->opttagid)) /* named enumerator */
492 ename = cstring_copy (ltoken_getRawString (e->opttagid));
499 cet = ctype_createEnum (ename, el);
501 if (usymtab_existsEnumTag (ename))
503 ta = uentry_getAbstractType (usymtab_lookupEnumTag (ename));
507 fileloc loc = fileloc_fromTok (e->tok);
508 uentry ue = uentry_makeEnumTag (ename, cet, loc);
510 ta = usymtab_supTypeEntry (ue);
513 enumNameList_elements (el, en)
520 ltokenList_reset (e->enums);
525 ltokenList_advance (e->enums);
528 loc = fileloc_fromTok (ltokenList_current (e->enums));
529 ue = uentry_makeSpecEnumConstant (en, cet, loc);
532 ** Can't check name here, might not have
533 ** type yet. Will check in .lh file?
536 ue = usymtab_supGlobalEntryReturn (ue);
538 if (context_inLCLLib ())
540 uentry_setDefined (ue, loc);
542 } end_enumNameList_elements;
544 result = qtype_create (ta);
549 llfatalbug (message ("convertLclTypeSpecNode: unknown lclTypeSpec kind: %d",
554 result = qtype_addQualList (result, n->quals);
558 qtype_adjustPointers (n->pointers, result);
565 llcontbug (cstring_makeLiteral ("convertLclTypeSpecNode: null"));
566 return qtype_unknown ();
571 static /*@only@*/ multiVal
572 literalValue (ctype ct, ltoken lit)
574 cstring text = cstring_fromChars (lsymbol_toChars (ltoken_getText (lit)));
577 if (cstring_length (text) > 0)
579 first = cstring_firstChar (text);
583 return multiVal_unknown ();
587 if /*@-usedef@*/ (first == '\"') /*@=usedef@*/
589 size_t len = cstring_length (text) - 2;
590 char *val = mstring_create (len);
592 llassert (cstring_lastChar (text) == '\"');
593 strncpy (val, cstring_toCharsSafe (text) + 1, len);
594 return (multiVal_makeString (cstring_fromCharsO (val)));
597 if (ctype_isDirectInt (ct) || ctype_isPointer (ct))
601 if (sscanf (cstring_toCharsSafe (text), "%ld", &val) == 1)
603 return multiVal_makeInt (val);
607 return multiVal_unknown ();
614 ** unfortunately, because the abstract types are different, this
615 ** cannot be easily subsumed into declareVar.
619 doDeclareConstant (constDeclarationNode c, bool priv)
625 if (c == (constDeclarationNode) 0)
631 qt = convertLclTypeSpecNode (t);
633 ctx = qtype_getType (qt);
635 initDeclNodeList_elements (c->decls, i)
637 ctype ct = convertTypeExpr (ctx, i->declarator->type);
638 cstring s = getVarName (i->declarator->type);
640 if (ctype_isFunction (ct))
642 fcnNode fcn = fcnNode_fromDeclarator (lclTypeSpecNode_copy (t),
643 declaratorNode_copy (i->declarator));
645 /* FALSE == unspecified function, only a declaration */
647 doDeclareFcn (fcn, typeId_invalid, priv, FALSE);
653 fileloc loc = fileloc_fromTok (i->declarator->id);
655 if (i->value != (termNode)0 &&
656 i->value->kind == TRM_LITERAL)
658 ue = uentry_makeConstantValue (s, ct, loc, priv, literalValue (ct, i->value->literal));
662 ue = uentry_makeConstantValue (s, ct, loc, priv, multiVal_unknown ());
665 uentry_reflectQualifiers (ue, qtype_getQuals (qt));
667 if (context_inLCLLib () && !priv)
669 uentry_setDefined (ue, loc);
672 usymtab_supGlobalEntry (ue);
674 } end_initDeclNodeList_elements;
680 getVarName (/*@null@*/ typeExpr x)
682 cstring s = cstring_undefined;
684 if (x != (typeExpr) 0)
689 s = ltoken_getRawString (x->content.base);
692 s = getVarName (x->content.pointer);
695 s = getVarName (x->content.array.elementtype);
698 s = getVarName (x->content.function.returntype);
701 llfatalbug (message ("getVarName: unknown typeExprKind: %d", (int) x->kind));
709 doDeclareVar (varDeclarationNode v, bool priv)
714 if (v == (varDeclarationNode) 0)
720 c = convertLclTypeSpecNode (t);
722 initDeclNodeList_elements (v->decls, i)
724 ctype ct = convertTypeExpr (qtype_getType (c), i->declarator->type);
725 cstring s = getVarName (i->declarator->type);
727 qtype_setType (c, ct);
729 if (ctype_isFunction (ct))
734 fcn = fcnNode_fromDeclarator (lclTypeSpecNode_copy (t),
735 declaratorNode_copy (i->declarator));
737 /* FALSE == unspecified function, only a declaration */
738 declareFcnAux (fcn, qtype_unknown (), ct,
739 typeId_invalid, priv, FALSE);
744 fileloc loc = fileloc_fromTok (i->declarator->id);
745 uentry le = uentry_makeVariable (s, ct, loc, priv);
747 uentry_reflectQualifiers (le, qtype_getQuals (c));
749 if (uentry_isCheckedUnknown (le))
751 if (context_getFlag (FLG_IMPCHECKEDSTRICTSPECGLOBALS))
753 uentry_setCheckedStrict (le);
755 else if (context_getFlag (FLG_IMPCHECKEDSPECGLOBALS))
757 uentry_setChecked (le);
759 else if (context_getFlag (FLG_IMPCHECKMODSPECGLOBALS))
761 uentry_setCheckMod (le);
769 if (context_inLCLLib () && !priv)
771 uentry_setDefined (le, loc);
774 if (initDeclNode_isRedeclaration (i))
776 usymtab_replaceEntry (le);
780 le = usymtab_supEntrySrefReturn (le);
783 } end_initDeclNodeList_elements;
789 processGlob (/*@returned@*/ globSet globs, varDeclarationNode v)
791 if (v == (varDeclarationNode) 0)
798 globs = globSet_insert (globs, v->sref);
802 lclTypeSpecNode t = v->type;
803 qtype qt = convertLclTypeSpecNode (t);
804 ctype c = qtype_getType (qt);
807 initDeclNodeList_elements (v->decls, i)
811 qualList quals = qtype_getQuals (qt);
813 s = getVarName (i->declarator->type);
814 ue = usymtab_lookupGlobSafe (s);
816 if (uentry_isInvalid (ue))
818 ; /* error already reported */
822 if (uentry_isPriv (ue))
824 globs = globSet_insert (globs, sRef_makeSpecState ());
828 uentry ce = uentry_copy (ue);
829 ctype lt = uentry_getType (ce);
830 fileloc loc = fileloc_fromTok (i->declarator->id);
832 ct = convertTypeExpr (c, i->declarator->type);
834 if (!ctype_match (lt, ct))
837 (lt, exprNode_undefined,
838 ct, exprNode_undefined,
839 message ("Global type mismatch %s (%t, %t)",
844 uentry_reflectQualifiers (ce, quals);
845 globs = globSet_insert (globs,
846 sRef_copy (uentry_getSref (ce)));
851 } end_initDeclNodeList_elements;
860 declareAbstractType (abstractNode n, bool priv)
868 if (n == (abstractNode) 0)
874 tn = ltoken_getRawString (n->name);
876 loc = fileloc_fromTok (n->tok);
878 ue = uentry_makeDatatypeAux (tn, ctype_unknown,
879 ynm_fromBool (n->isMutable), YES, loc, priv);
883 uentry_setRefCounted (ue);
886 if (context_inLCLLib () && !priv)
888 uentry_setDefined (ue, loc);
891 uid = usymtab_supAbstractTypeEntry (ue, context_inLCLLib() && !priv);
894 if (!priv && (ab = n->body) != (abstBodyNode) 0)
896 fcnNodeList ops = ab->fcns;
898 if (!fcnNodeList_isEmpty (ops))
900 fcnNodeList_elements (ops, i)
902 if (i->typespec == (lclTypeSpecNode) 0)
904 cstring fname = ltoken_getRawString (i->name);
906 if (usymtab_exists (fname))
908 uentry e = usymtab_lookup (fname);
909 fileloc floc = fileloc_fromTok (i->declarator->id);
911 if (uentry_isForward (e))
914 (uentry_makeTypeListFunction
915 (fname, typeIdSet_insert (uentry_accessType (e), uid),
921 (uentry_makeSpecFunction
922 (fname, uentry_getType (e),
923 typeIdSet_insert (uentry_accessType (e), uid),
928 if (context_inLCLLib ())
930 llbuglit ("Jolly jeepers Wilma, it ain't dead after all!");
937 (uentry_makeForwardFunction (fname, uid, loc));
944 } end_fcnNodeList_elements;
950 declareExposedType (exposedNode n, bool priv)
957 if (n == (exposedNode) 0)
962 c = convertLclTypeSpecNode (n->type);
964 declaratorInvNodeList_elements (n->decls, i)
966 ctype realType = convertTypeExpr (qtype_getType (c), i->declarator->type);
967 fileloc loc = fileloc_fromTok (i->declarator->id);
970 s = getVarName (i->declarator->type);
972 ue = uentry_makeDatatypeAux (s, realType, MAYBE, NO, loc, priv);
974 uentry_reflectQualifiers (ue, qtype_getQuals (c));
976 if (context_inLCLLib () && !priv)
978 uentry_setDefined (ue, loc);
981 uid = usymtab_supExposedTypeEntry (ue, context_inLCLLib () && !priv);
982 } end_declaratorInvNodeList_elements;
988 ** ah...remember ye old days...
990 ** wow...same thing in THREE symbol tables! talk about space efficiency
991 ** (or as Joe Theory once said, its only a constant factor)
995 doDeclareType (typeNode t, bool priv)
998 if (t != (typeNode) 0)
1003 declareAbstractType (t->content.abstract, priv);
1007 declareExposedType (t->content.exposed, priv);
1013 llfatalbug (message ("declareType ERROR: unknown kind: %q",
1014 cstring_fromCharsO (FormatInt ((int)t->kind))));
1022 declareIter (iterNode iter)
1024 fileloc loc = fileloc_fromTok (iter->name);
1026 uentry_makeIter (ltoken_unparse (iter->name),
1029 paramNodeList_toUentryList (iter->params)),
1030 fileloc_copy (loc));
1032 usymtab_supEntry (ue);
1034 (uentry_makeEndIter (ltoken_unparse (iter->name), loc));
1042 declareFcnAux (fcnNode f, /*@only@*/ qtype qt, ctype ct,
1043 typeId tn, bool priv, bool spec)
1047 sRefSet sl = sRefSet_undefined;
1048 globSet globlist = globSet_undefined;
1049 cstring s = getVarName (f->declarator->type);
1050 fileloc loc = fileloc_fromTok (f->declarator->id);
1054 ** type conversion generates args
1057 if (ctype_isFunction (ct))
1059 args = ctype_argsFunction (ct);
1063 llcontbug (message ("Not function: %s", ctype_unparse (ct)));
1064 args = uentryList_undefined;
1068 fileloc_setColumnUndefined (loc);
1072 globals = f->globals;
1074 sl = fixModifies (f, args);
1077 ** Bind let declarations in modifies list
1080 varDeclarationNodeList_elements (globals, glob)
1082 globlist = processGlob (globlist, glob);
1083 } end_varDeclarationNodeList_elements;
1086 if (f->checks != (lclPredicateNode) 0)
1087 /* push stderr on globalList */
1088 /* modifies *stderr^ */
1092 if (!(usymtab_existsVar (cstring_makeLiteralTemp ("stderr"))))
1096 llmsglit ("Global stderr implied by checks clause, "
1097 "not declared in initializations.");
1099 tfile = usymtab_lookupType (cstring_makeLiteralTemp ("FILE"));
1101 if (ctype_isUndefined (tfile))
1103 llmsglit ("FILE datatype implied by checks clause not defined.");
1104 tfile = ctype_unknown;
1107 usymtab_supGlobalEntry
1108 (uentry_makeVariable (cstring_makeLiteralTemp ("stderr"),
1109 tfile, fileloc_getBuiltin (), FALSE));
1112 ue = usymtab_lookupGlob (cstring_makeLiteralTemp ("stderr"));
1114 globlist = globSet_insert (globlist, sRef_copy (uentry_getSref (ue)));
1115 sl = sRefSet_insert (sl, sRef_buildPointer (uentry_getSref (ue)));
1119 if (usymId_isInvalid (tn))
1121 acct = context_fileAccessTypes ();
1125 acct = typeIdSet_single (tn);
1128 if (usymtab_exists (s))
1130 uentry l = usymtab_lookup (s);
1133 if (uentry_isForward (l) || (fileloc_isLib (uentry_whereSpecified (l))))
1135 typeIdSet accessType;
1137 if (uentry_isFunction (l))
1139 accessType = typeIdSet_union (uentry_accessType (l),
1140 context_fileAccessTypes ());
1144 accessType = context_fileAccessTypes ();
1149 ue = uentry_makeSpecFunction (s, ct, accessType, globlist, sl, loc);
1154 globSet_free (globlist);
1156 ue = uentry_makeUnspecFunction (s, ct, accessType, loc);
1159 uentry_reflectQualifiers (ue, qtype_getQuals (qt));
1160 usymtab_supEntry (ue);
1165 ** error reported by symtable already
1167 ** llgenerror (message ("Function redeclared: %s (previous declaration: %s)", s,
1168 ** fileloc_unparse (uentry_whereSpecified (l))),
1174 globSet_free (globlist);
1185 le = uentry_makePrivFunction2 (s, ct, acct, globlist, sl, loc);
1189 le = uentry_makeSpecFunction (s, ct, acct, globlist, sl, loc);
1194 le = uentry_makeUnspecFunction (s, ct, acct, loc);
1197 globSet_free (globlist);
1200 if (context_inLCLLib () && !priv)
1202 uentry_setDefined (le, loc);
1205 uentry_reflectQualifiers (le, qtype_getQuals (qt));
1207 if (qual_isUnknown (f->special)) {
1209 } else if (qual_isPrintfLike (f->special)) {
1210 uentry_setPrintfLike (le);
1211 } else if (qual_isScanfLike (f->special)) {
1212 uentry_setScanfLike (le);
1213 } else if (qual_isMessageLike (f->special)) {
1214 uentry_setMessageLike (le);
1219 usymtab_supEntry (le);
1226 doDeclareFcn (fcnNode f, typeId tn, bool priv, bool spec)
1228 qtype qt = convertLclTypeSpecNode (f->typespec);
1229 ctype ct = convertTypeExpr (qtype_getType (qt), f->declarator->type);
1231 declareFcnAux (f, qt, ct, tn, priv, spec);
1235 ** is s is an argument to f, return its arg no.
1236 ** otherwise, return 0
1240 getParamNo (cstring s, fcnNode f)
1242 /* gasp, maybe should do run-time checks here */
1243 paramNodeList params;
1244 typeExpr fd = f->declarator->type;
1246 /* is this a bug in the LCL grammar? */
1248 while (fd != NULL && (fd->kind == TEXPR_PTR || fd->kind == TEXPR_ARRAY))
1250 if (fd->kind == TEXPR_PTR)
1252 fd = fd->content.pointer;
1256 /*@-null@*/ fd = fd->content.array.elementtype; /*@=null@*/
1259 ** This is a bug in checking, that I should eventually fix.
1260 ** Need some way of deleting the guard from the true branch,
1261 ** but adding it back in the false branch...
1266 llassert (fd != NULL);
1268 if (fd->kind != TEXPR_FCN)
1270 llfatalbug (message ("getParamNo: not a function: %q (%d)",
1271 typeExpr_unparse (fd), (int) fd->kind));
1274 params = fd->content.function.args;
1276 if (paramNodeList_empty (params))
1284 paramNodeList_elements (params, i)
1286 if (i->paramdecl != (typeExpr) 0) /* handle (void) */
1288 if (cstring_equal (s, getVarName (i->paramdecl)))
1294 } end_paramNodeList_elements;
1299 static /*@null@*/ /*@observer@*/ termNode
1300 getLetDecl (cstring s, fcnNode f)
1302 letDeclNodeList x = f->lets;
1304 letDeclNodeList_elements (x, i)
1306 if (cstring_equal (s, ltoken_getRawString (i->varid)))
1308 if (i->sortspec != NULL)
1310 llbuglit ("getLetDecl: cannot return sort!");
1313 { /* is a termNode */
1317 } end_letDeclNodeList_elements;
1319 return (termNode) 0;
1323 ** processTermNode --- based on printTermNode2
1326 static /*@exposed@*/ sRef
1327 processTermNode (/*@null@*/ opFormNode op, termNodeList args,
1328 fcnNode f, uentryList cl)
1330 if (op != (opFormNode) 0)
1335 llcontbuglit ("processTermNode: OPF_IF: not handled");
1338 llcontbuglit ("processTermNode: OPF_ANYOP: not handled");
1342 int size = termNodeList_size (args);
1345 && (cstring_equalLit (ltoken_getRawString (op->content.anyop), "'") ||
1346 cstring_equalLit (ltoken_getRawString (op->content.anyop), "^")))
1348 return (fixTermNode (termNodeList_head (args), f, cl));
1358 int size = termNodeList_size (args);
1361 && (cstring_equalLit (ltoken_getRawString (op->content.anyop), "*")))
1366 ft = fixTermNode (termNodeList_head (args), f, cl);
1367 res = sRef_buildPointer (ft);
1377 llcontbuglit ("OPF_MANYOPM: not handled\n");
1380 llcontbuglit ("OPF_MIDDLE: not handled\n");
1383 llcontbuglit ("OPF_MMIDDLE: not handled\n");
1386 llcontbuglit ("OPF_MIDDLEM: not handled\n");
1389 llcontbuglit ("OPF_MMIDDLEM: not handled\n");
1392 if (op->content.middle == 1)
1393 llbug (message ("array fetch: [%q]",
1394 termNodeList_unparse (args)));
1396 llcontbuglit ("OPF_BMIDDLE: bad\n");
1400 if (op->content.middle <= 1)
1402 sRef arr = fixTermNode (termNodeList_head (args), f, cl);
1405 if (op->content.middle == 1)
1407 termNode t = (termNodeList_reset (args),
1408 termNodeList_advance (args),
1409 termNodeList_current (args));
1411 if (t->kind == TRM_LITERAL)
1416 (cstring_toCharsSafe
1417 (ltoken_getRawString (t->literal)),
1420 ret = sRef_buildArrayFetchKnown (arr, i);
1424 ret = sRef_buildArrayFetch (arr);
1433 ret = sRef_buildArrayFetch (arr);
1439 llcontbug (message ("op->content.middle = %d",
1440 op->content.middle));
1445 llcontbuglit ("OPF_BMIDDLEM not handled");
1449 llcontbuglit ("OPF_BMMIDDLEM not handled");
1453 llcontbug (message ("select: .%s",
1454 ltoken_getRawString (op->content.id)));
1458 llcontbug (message ("map: .%s",
1459 ltoken_getRawString (op->content.id)));
1464 sRef rec = fixTermNode (termNodeList_head (args), f, cl);
1466 ctype ct = ctype_realType (sRef_deriveType (rec, cl));
1467 cstring fieldname = ltoken_getRawString (op->content.id);
1469 ct = ctype_realType (ct);
1472 ** does it correspond to a typedef struct field
1474 ** (kind of kludgey, but there is no direct way to
1475 ** tell if it is an lsl operator instead)
1478 if (ctype_isStructorUnion (ct) &&
1480 (uentryList_lookupField (ctype_getFields (ct), fieldname)))
1482 cstring fname = cstring_copy (fieldname);
1484 ret = sRef_buildField (rec, fname);
1485 cstring_markOwned (fname);
1489 ret = sRef_undefined;
1496 sRef rec = fixTermNode (termNodeList_head (args), f, cl);
1497 sRef ret = sRef_undefined;
1498 ctype ct = ctype_realType (sRef_deriveType (rec, cl));
1499 cstring fieldname = ltoken_getRawString (op->content.id);
1502 ** does it correspond to a typedef struct field
1505 if (ctype_isPointer (ct))
1507 ctype ctb = ctype_realType (ctype_baseArrayPtr (ct));
1509 if (ctype_isStructorUnion (ctb) &&
1510 uentry_isValid (uentryList_lookupField
1511 (ctype_getFields (ctb), fieldname)))
1513 cstring fname = cstring_copy (fieldname);
1515 ret = sRef_buildArrow (rec, fname);
1516 cstring_markOwned (fname);
1525 return sRef_undefined;
1531 ** o replace anything in modifies that is bound with let with value
1532 ** o replace spec variables with internal state
1533 ** o replace paramaters with paramno identifiers
1534 ** o replace globals with their usymid's
1535 ** o make everything sRefs
1538 static /*@exposed@*/ sRef fixTermNode (termNode n, fcnNode f, uentryList cl)
1540 if (n != (termNode) 0)
1550 cstring s = ltoken_getRawString (n->literal);
1551 termNode tl = getLetDecl (s, f);
1553 if (tl != (termNode) 0)
1555 return (fixTermNode (tl, f, cl));
1559 int i = getParamNo (s, f);
1563 usymId usym = usymtab_getId (s);
1565 if (usymId_isInvalid (usym))
1567 if (usymtab_existsEither (s))
1569 return sRef_makeSpecState ();
1573 llcontbuglit ("Invalid symbol in modifies list");
1574 return sRef_undefined;
1578 return (sRef_makeGlobal (usym, ctype_unknown, stateInfo_currentLoc ()));
1583 sRef p = sRef_makeParam (i, ctype_unknown, stateInfo_currentLoc ());
1588 case TRM_APPLICATION:
1590 nameNode nn = n->name;
1592 if (nn != (nameNode) 0)
1596 /* must we handle n->given ? skip for now */
1599 (message ("fixTermNode: expect non-empty nameNode: "
1600 "TRM_APPLICATION: %q",
1601 nameNode_unparse (nn)));
1607 sr = processTermNode (nn->content.opform, n->args, f, cl);
1612 return sRef_undefined;
1614 case TRM_UNCHANGEDALL:
1615 case TRM_UNCHANGEDOTHERS:
1617 case TRM_QUANTIFIER:
1618 return sRef_undefined;
1622 return sRef_undefined;
1626 /*@only@*/ sRefSet fixModifies (fcnNode f, uentryList cl)
1628 static bool shownWarning = FALSE;
1629 modifyNode m = f->modify;
1630 sRefSet sl = sRefSet_new ();
1632 if (m != (modifyNode) 0)
1634 if (m->hasStoreRefList)
1636 storeRefNodeList srefs = m->list;
1638 storeRefNodeList_elements (srefs, i)
1640 if (storeRefNode_isObj (i) || storeRefNode_isType (i))
1644 fileloc loc = fileloc_fromTok (f->name);
1647 ("%q: Warning: object and type modifications "
1648 "not understood by Splint",
1649 fileloc_unparse (loc)));
1651 shownWarning = TRUE;
1654 else if (storeRefNode_isSpecial (i))
1656 sl = sRefSet_insert (sl, i->content.ref);
1658 else if (storeRefNode_isTerm (i))
1660 sRef s = fixTermNode (i->content.term, f, cl);
1662 if (sRef_isKnown (s))
1664 sl = sRefSet_insert (sl, s);
1671 } end_storeRefNodeList_elements;
1679 static /*@only@*/ cstring
1680 paramNode_name (paramNode x)
1682 return (typeExpr_name (x->paramdecl));
1685 static /*@only@*/ uentry
1686 paramNode_toUentry (paramNode p)
1688 if (p != (paramNode) 0)
1690 if (p->kind == PELIPSIS)
1692 return uentry_makeElipsisMarker ();
1696 qtype ct = convertLclTypeSpecNode (p->type);
1697 ctype cr = convertTypeExpr (qtype_getType (ct), p->paramdecl);
1698 cstring pname = (p->paramdecl == (typeExpr)0) ? cstring_undefined
1699 : paramNode_name (p);
1700 uentry ue = uentry_makeVariableParam (pname, cr, g_currentloc);
1702 uentry_reflectQualifiers (ue, qtype_getQuals (ct));
1709 llcontbuglit ("paramNode_toUentry: NULL");
1710 return uentry_undefined;
1716 paramNodeList_toUentryList (paramNodeList p)
1718 uentryList cl = uentryList_new ();
1720 if (paramNodeList_isNull (p)) return (cl);
1722 paramNodeList_elements (p, current)
1724 cl = uentryList_add (cl, paramNode_toUentry (current));
1725 } end_paramNodeList_elements;