src/mtContextNode.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   5 **
   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.
  10 **
  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.
  15 **
  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.
  19 **
  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
  23 */
  24 /*
  25 ** mtContextNode.c
  26 */
  27
  28 # include "splintMacros.nf"
  29 # include "basic.h"
  30
  31 static bool mtContextNode_matchesType (mtContextNode, ctype) /*@*/ ;
  32
  33 static /*@observer@*/ cstring mtContextKind_unparse (mtContextKind ck)
  34 {
  35   switch (ck)
  36     {
  37     case MTC_ANY: return cstring_makeLiteralTemp ("any");
  38     case MTC_PARAM: return cstring_makeLiteralTemp ("parameter");
  39     case MTC_RESULT: return cstring_makeLiteralTemp ("result");
  40     case MTC_REFERENCE: return cstring_makeLiteralTemp ("reference");
  41     case MTC_CLAUSE: return cstring_makeLiteralTemp ("clause");
  42     case MTC_LITERAL: return cstring_makeLiteralTemp ("literal");
  43     case MTC_NULL: return cstring_makeLiteralTemp ("null");
  44     }
  45
  46   BADBRANCHRET (cstring_undefined);
  47 }
  48
  49 static mtContextNode mtContextNode_create (mtContextKind context, ctype ct)
  50 {
  51   mtContextNode res = (mtContextNode) dmalloc (sizeof (*res));
  52   res->context = context;
  53   res->type = ct;
  54   DPRINTF (("Create: %s", mtContextNode_unparse (res)));
  55   return res;
  56 }
  57
  58 extern mtContextNode mtContextNode_createAny (void)
  59 {
  60   return mtContextNode_create (MTC_ANY, ctype_unknown);
  61 }
  62
  63 extern mtContextNode mtContextNode_createParameter (ctype ct)
  64 {
  65   return mtContextNode_create (MTC_PARAM, ct);
  66 }
  67
  68 extern mtContextNode mtContextNode_createResult (ctype ct)
  69 {
  70   return mtContextNode_create (MTC_RESULT, ct);
  71 }
  72
  73 extern mtContextNode mtContextNode_createReference (ctype ct)
  74 {
  75   return mtContextNode_create (MTC_REFERENCE, ct);
  76 }
  77
  78 extern mtContextNode mtContextNode_createClause (ctype ct)
  79 {
  80   return mtContextNode_create (MTC_CLAUSE, ct);
  81 }
  82
  83 extern mtContextNode mtContextNode_createLiteral (ctype ct)
  84 {
  85   return mtContextNode_create (MTC_LITERAL, ct);
  86 }
  87
  88 extern mtContextNode mtContextNode_createNull (ctype ct)
  89 {
  90   return mtContextNode_create (MTC_NULL, ct);
  91 }
  92
  93 extern void mtContextNode_free (/*@only@*/ mtContextNode node)
  94 {
  95   sfree (node);
  96 }
  97
  98 bool mtContextNode_matchesEntry (mtContextNode context, uentry ue)
  99 {
 100   ctype ct;
 101
 102   llassert (mtContextNode_isDefined (context));
 103
 104   DPRINTF (("Matches context: %s / %s",
 105             mtContextNode_unparse (context), uentry_unparse (ue)));
 106
 107   switch (context->context)
 108     {
 109     case MTC_ANY: break; /* everything matches */
 110     case MTC_RESULT:
 111       if (!uentry_isFunction (ue))
 112         {
 113           return FALSE;
 114         }
 115       break;
 116     case MTC_PARAM:
 117       if (!uentry_isAnyParam (ue))
 118         {
 119           DPRINTF (("not param: %s", uentry_unparseFull (ue)));
 120           return FALSE;
 121         }
 122       break;
 123     case MTC_LITERAL:
 124     case MTC_NULL:
 125       return FALSE;
 126     case MTC_REFERENCE:
 127       break;
 128     case MTC_CLAUSE:
 129       BADBRANCH;
 130     }
 131
 132   if (uentry_isFunction (ue))
 133     {
 134       ct = ctype_getReturnType (uentry_getType (ue));
 135     }
 136   else
 137     {
 138       ct = uentry_getType (ue);
 139     }
 140
 141   return mtContextNode_matchesType (context, ct);
 142 }
 143
 144 bool mtContextNode_matchesRef (mtContextNode context, sRef sr)
 145 {
 146   ctype ct;
 147
 148   llassert (mtContextNode_isDefined (context));
 149
 150   DPRINTF (("Matches context: %s / %s",
 151             mtContextNode_unparse (context), sRef_unparse (sr)));
 152
 153   switch (context->context)
 154     {
 155     case MTC_ANY: break; /* everything matches */
 156     case MTC_RESULT:
 157       DPRINTF (("Result? %s / %s",
 158                 sRef_unparseFull (sr),
 159                 bool_unparse (sRef_isResult (sr))));
 160       return sRef_isResult (sr);
 161     case MTC_PARAM:
 162       if (!sRef_isParam (sr))
 163         {
 164           return FALSE;
 165         }
 166       break;
 167     case MTC_LITERAL:
 168       DPRINTF (("Literal: %s", sRef_unparse (sr)));
 169       if (!sRef_isConst (sr))
 170         {
 171           return FALSE;
 172         }
 173       break;
 174     case MTC_NULL:
 175     case MTC_REFERENCE:
 176       break;
 177     case MTC_CLAUSE:
 178       BADBRANCH;
 179     }
 180
 181   ct = sRef_getType (sr);
 182   return mtContextNode_matchesType (context, ct);
 183 }
 184
 185 bool mtContextNode_matchesRefStrict (mtContextNode context, sRef s)
 186 {
 187   if (mtContextNode_isDefined (context)
 188       && mtContextNode_matchesRef (context, s))
 189     {
 190       if (ctype_isKnown (context->type)
 191           && (ctype_isUnknown (sRef_getType (s))
 192               || ctype_isVoidPointer (sRef_getType (s))))
 193         {
 194           return FALSE;
 195         }
 196       else
 197         {
 198           return TRUE;
 199         }
 200     }
 201
 202   return FALSE;
 203 }
 204
 205 bool mtContextNode_matchesType (mtContextNode context, ctype ct)
 206 {
 207   DPRINTF (("Context type..."));
 208   llassert (mtContextNode_isDefined (context));
 209
 210   if (!ctype_match (context->type, ct))
 211     {
 212       DPRINTF (("Type mismatch: %s / %s",
 213                 ctype_unparse (context->type),
 214                 ctype_unparse (ct)));
 215       return FALSE;
 216     }
 217   else
 218     {
 219       /* evans 2001-08-21 - don't match if only one type is unknown */
 220       if (ctype_isUnknown (ct) && !ctype_isUnknown (context->type))
 221         {
 222           return FALSE;
 223         }
 224
 225       DPRINTF (("Type okay: %s / %s",
 226                 ctype_unparse (context->type),
 227                 ctype_unparse (ct)));
 228     }
 229
 230   return TRUE;
 231 }
 232
 233 cstring mtContextNode_unparse (mtContextNode node)
 234 {
 235   llassert (mtContextNode_isDefined (node));
 236
 237   if (ctype_isKnown (node->type))
 238     {
 239       return message ("%s %s", mtContextKind_unparse (node->context),
 240                       ctype_unparse (node->type));
 241     }
 242   else
 243     {
 244       return message ("%s", mtContextKind_unparse (node->context));
 245     }
 246 }
 247
 248 # ifdef DEADCODE
 249 bool mtContextNode_isClause (mtContextNode n)
 250 {
 251   llassert (mtContextNode_isDefined (n));
 252   return (n->context == MTC_CLAUSE);
 253 }
 254 # endif /* DEADCODE */
 255
 256 bool mtContextNode_isParameter (mtContextNode n)
 257 {
 258   llassert (mtContextNode_isDefined (n));
 259   return (n->context == MTC_PARAM);
 260 }
 261
 262 bool mtContextNode_isReference (mtContextNode n)
 263 {
 264   llassert (mtContextNode_isDefined (n));
 265   return (n->context == MTC_REFERENCE);
 266 }
 267
 268 bool mtContextNode_isResult (mtContextNode n)
 269 {
 270   llassert (mtContextNode_isDefined (n));
 271   return (n->context == MTC_RESULT);
 272 }
 273
 274 bool mtContextNode_isLiteral (mtContextNode n)
 275 {
 276   llassert (mtContextNode_isDefined (n));
 277   return (n->context == MTC_LITERAL);
 278 }
 279
 280 bool mtContextNode_isNull (mtContextNode n)
 281 {
 282   llassert (mtContextNode_isDefined (n));
 283   return (n->context == MTC_NULL);
 284 }
 285
 286 # ifdef DEADCODE
 287 void mtContextNode_showRefError (mtContextNode context, sRef sr)
 288 {
 289   ctype ct;
 290
 291   llassert (mtContextNode_isDefined (context));
 292   llassert (!mtContextNode_matchesRef (context, sr));
 293
 294   DPRINTF (("Matches context: %s / %s",
 295             mtContextNode_unparse (context), sRef_unparse (sr)));
 296
 297   switch (context->context)
 298     {
 299     case MTC_ANY: break; /* everything matches */
 300     case MTC_RESULT:
 301       if (!sRef_isResult (sr))
 302         {
 303           llgenindentmsgnoloc
 304             (message ("Context is result, doesn't match %q", sRef_unparse (sr)));
 305           return;
 306         }
 307       break;
 308     case MTC_PARAM:
 309       if (!sRef_isResult (sr))
 310         {
 311           llgenindentmsgnoloc
 312             (message ("Context is parameter, doesn't match %q", sRef_unparse (sr)));
 313           return;
 314         }
 315       break;
 316     case MTC_LITERAL:
 317       DPRINTF (("Literal: %s", sRef_unparse (sr)));
 318       if (!sRef_isConst (sr))
 319         {
 320           llgenindentmsgnoloc
 321             (message ("Context is literal, doesn't match %q", sRef_unparse (sr)));
 322           return;
 323         }
 324       break;
 325     case MTC_NULL:
 326     case MTC_REFERENCE:
 327       break;
 328     case MTC_CLAUSE:
 329       BADBRANCH;
 330     }
 331
 332   ct = sRef_getType (sr);
 333
 334   if (!mtContextNode_matchesType (context, ct))
 335     {
 336       llgenindentmsgnoloc
 337         (message ("Context type is %s, doesn't match type %s",
 338                   ctype_unparse (context->type),
 339                   ctype_unparse (ct)));
 340     }
 341   else
 342     {
 343       BADBRANCH;
 344     }
 345 }
 346 # endif /* DEADCODE */
 347