src/flagMarkerList.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 ** flagMarkerList.c
  26 **
  27 ** based on list_template.c
  28 **
  29 ** where T has T_equal (or change this) and T_unparse
  30 **
  31 ** invariant: flagMarker's are listed in order
  32 */
  33
  34 # include "splintMacros.nf"
  35 # include "basic.h"
  36
  37 /*@constant int flagMarkerListBASESIZE;@*/
  38 # define flagMarkerListBASESIZE SMALLBASESIZE
  39
  40 static int flagMarkerList_lastBeforeLoc (flagMarkerList p_s, fileloc p_loc) /*@*/ ;
  41 static /*@only@*/ cstring flagMarkerList_unparse (flagMarkerList p_s) /*@*/ ;
  42
  43 static bool
  44 flagMarkerList_contains (flagMarkerList p_s, flagMarker p_fm) /*@*/ ;
  45
  46 flagMarkerList
  47 flagMarkerList_new (void)
  48 {
  49   flagMarkerList s = (flagMarkerList) dmalloc (sizeof (*s));
  50
  51   s->nelements = 0;
  52   s->nspace = flagMarkerListBASESIZE;
  53   s->elements = (flagMarker *)
  54     dmalloc (sizeof (*s->elements) * flagMarkerListBASESIZE);
  55
  56   return (s);
  57 }
  58
  59 static void
  60 flagMarkerList_grow (flagMarkerList s)
  61 {
  62   int i;
  63   flagMarker *newelements;
  64
  65   s->nspace += flagMarkerListBASESIZE;
  66
  67   newelements = (flagMarker *) dmalloc (sizeof (*newelements)
  68                                         * (s->nelements + s->nspace));
  69
  70   for (i = 0; i < s->nelements; i++)
  71     {
  72       newelements[i] = s->elements[i];
  73     }
  74
  75   sfree (s->elements);
  76   s->elements = newelements;
  77 }
  78
  79 bool flagMarkerList_add (flagMarkerList s, flagMarker fm)
  80 {
  81   int i = s->nelements - 1;
  82   int lastloc;
  83
  84   DPRINTF (("Add: %s", flagMarker_unparse (fm)));
  85
  86   if (flagMarkerList_contains (s, fm))
  87     {
  88       flagMarker_free (fm);
  89       DPRINTF (("List contains: %s", flagMarkerList_unparse (s)));
  90       return FALSE;
  91     }
  92
  93   if (i > 0)
  94     {
  95       flagMarker last = s->elements[i];
  96
  97       if (flagMarker_isIgnoreCount (last))
  98         {
  99           if (!flagMarker_isIgnoreOff (fm))
 100             {
 101               if (flagMarker_isLocalSet (fm))
 102                 {
 103                   if (llforceerror
 104                       (FLG_WARNFLAGS,
 105                        cstring_makeLiteral ("Cannot set flag inside ignore "
 106                                             "count region."),
 107                        flagMarker_getLoc (fm)))
 108                     {
 109                       llgenindentmsg
 110                         (cstring_makeLiteral ("Ignore count region starts"),
 111                          flagMarker_getLoc (last));
 112                     }
 113                 }
 114               else
 115                 {
 116                   if (flagMarker_isIgnoreOn (fm))
 117                     {
 118                       if (llforceerror
 119                           (FLG_WARNFLAGS,
 120                            cstring_makeLiteral ("Cannot nest ignore regions."),
 121                            flagMarker_getLoc (fm)))
 122                         {
 123                           llgenindentmsg
 124                             (cstring_makeLiteral ("Previous ignore region starts"),
 125                              flagMarker_getLoc (last));
 126                         }
 127                     }
 128                 }
 129
 130               flagMarker_free (fm);
 131               return FALSE;
 132             }
 133         }
 134       else
 135         {
 136           if (flagMarker_isIgnoreOff (last))
 137             {
 138               flagMarker nlast = s->elements [i - 1];
 139
 140               if (flagMarker_isIgnoreCount (nlast))
 141                 {
 142                   if (fileloc_sameFileAndLine (flagMarker_getLoc (fm),
 143                                                flagMarker_getLoc (nlast)))
 144                     {
 145                       if (flagMarker_isLocalSet (fm))
 146                         {
 147                           if (llforceerror
 148                               (FLG_WARNFLAGS,
 149                                cstring_makeLiteral
 150                                ("Cannot set flag inside ignore "
 151                                 "count region."),
 152                                flagMarker_getLoc (fm)))
 153                             {
 154                               llgenindentmsg
 155                                 (cstring_makeLiteral
 156                                  ("Ignore count region starts"),
 157                                  flagMarker_getLoc (nlast));
 158                               DPRINTF (("Last: %s / %s",
 159                                         fileloc_unparse (flagMarker_getLoc (last)),
 160                                         fileloc_unparse (flagMarker_getLoc (fm))));
 161
 162                             }
 163                         }
 164                       else
 165                         {
 166                           if (flagMarker_isIgnoreOn (fm))
 167                             {
 168                               if (llforceerror
 169                                   (FLG_WARNFLAGS,
 170                                    cstring_makeLiteral ("Cannot nest ignore regions."),
 171                                    flagMarker_getLoc (fm)))
 172                                 {
 173                                   llgenindentmsg
 174                                     (cstring_makeLiteral ("Previous ignore region starts"),
 175                                      flagMarker_getLoc (nlast));
 176                                 }
 177                             }
 178                         }
 179
 180                       flagMarker_free (fm);
 181                       return FALSE;
 182                     }
 183                 }
 184             }
 185         }
 186     }
 187
 188
 189   /*
 190   ** Need to insert this flag in the right place (after the last before loc flag)
 191   */
 192
 193   lastloc = flagMarkerList_lastBeforeLoc (s, flagMarker_getLoc (fm));
 194
 195   if (s->nspace <= 0)
 196     {
 197       flagMarkerList_grow (s);
 198     }
 199
 200   s->nspace--;
 201
 202   if (lastloc == -1)
 203     {
 204       /* Add it to the end of the list */
 205       s->elements[s->nelements] = fm;
 206     }
 207   else
 208     {
 209       DPRINTF (("Inserting: %s in %s",
 210                 flagMarker_unparse (fm),
 211                 flagMarkerList_unparse (s)));
 212
 213       /* Insert it at location lastloc + 1, push other flags down */
 214       for (i = s->nelements; i > lastloc + 1; i--)
 215         {
 216           s->elements [i] = s->elements [i - 1];
 217         }
 218
 219       s->elements [lastloc + 1] = fm;
 220
 221     }
 222
 223   s->nelements++;
 224   return TRUE;
 225 }
 226
 227 void flagMarkerList_checkSuppressCounts (flagMarkerList s)
 228 {
 229   int nexpected = 0;
 230   int nsuppressed = 0;
 231   fileloc loc = fileloc_undefined;
 232   bool inCount = FALSE;
 233   int i;
 234
 235   for (i = 0; i < s->nelements; i++)
 236     {
 237       flagMarker current = s->elements[i];
 238       DPRINTF (("flagMarker: %s / %s",
 239                 flagMarker_unparse (current),
 240                 bool_unparse (inCount)));
 241
 242       if (flagMarker_isIgnoreCount (current))
 243         {
 244           llassert (!inCount);
 245           inCount = TRUE;
 246           nexpected = flagMarker_getCount (current);
 247           loc = flagMarker_getLoc (current);
 248           nsuppressed = 0;
 249         }
 250       else if (flagMarker_isIgnoreOff (current))
 251         {
 252           if (inCount)
 253             {
 254               inCount = FALSE;
 255               llassert (fileloc_isDefined (loc));
 256
 257               if (nexpected > 0 && nexpected != nsuppressed)
 258                 {
 259                   /* Must use forceerror to prevent self-suppression! */
 260                   llforceerror
 261                     (FLG_SUPCOUNTS,
 262                      message
 263                      ("Line expects to suppress %d error%&, found %d error%&",
 264                       nexpected, nsuppressed),
 265                      loc);
 266                 }
 267             }
 268         }
 269       else if (flagMarker_isSuppress (current))
 270         {
 271           nsuppressed++;
 272         }
 273       else
 274         {
 275           ;
 276         }
 277     }
 278
 279   llassert (!inCount);
 280 }
 281
 282 static void flagMarkerList_splice (flagMarkerList s,
 283                                    int index,
 284                                    /*@keep@*/ flagMarker fm)
 285 {
 286   fileloc loc = flagMarker_getLoc (fm);
 287   fileloc beforeloc, afterloc;
 288   int i;
 289
 290   llassert (index >= 0 && (index + 1 < s->nelements));
 291
 292   beforeloc = flagMarker_getLoc (s->elements[index]);
 293   afterloc = flagMarker_getLoc (s->elements[index + 1]);;
 294
 295   llassert (fileloc_sameFile (beforeloc, loc));
 296   llassert (fileloc_sameFile (afterloc, loc));
 297
 298   if (s->nspace <= 0)
 299     {
 300       flagMarkerList_grow (s);
 301     }
 302
 303   for (i = s->nelements; i > index + 1; i--)
 304     {
 305       s->elements[i] = s->elements[i - 1];
 306     }
 307
 308   s->elements[index + 1] = fm;
 309   s->nelements++;
 310   s->nspace--;
 311
 312   }
 313
 314 static /*@only@*/ cstring
 315 flagMarkerList_unparse (flagMarkerList s)
 316 {
 317    int i;
 318    cstring st = cstring_makeLiteral ("[");
 319
 320    for (i = 0; i < s->nelements; i++)
 321      {
 322        if (i == 0)
 323          {
 324            st = message ("%q %q", st, flagMarker_unparse (s->elements[i]));
 325          }
 326        else
 327          st = message ("%q, %q", st, flagMarker_unparse (s->elements[i]));
 328      }
 329
 330    st = message ("%q ]", st);
 331    return st;
 332 }
 333
 334 void
 335 flagMarkerList_free (flagMarkerList s)
 336 {
 337   int i;
 338   for (i = 0; i < s->nelements; i++)
 339     {
 340       flagMarker_free (s->elements[i]);
 341     }
 342
 343   sfree (s->elements);
 344   sfree (s);
 345 }
 346
 347 static int
 348 flagMarkerList_lastBeforeLoc (flagMarkerList s, fileloc loc)
 349 {
 350   int i;
 351
 352   for (i = s->nelements - 1; i >= 0; i--)
 353     {
 354       flagMarker current = s->elements[i];
 355
 356       if (fileloc_sameFile (current->loc, loc)
 357           && (!flagMarker_beforeMarker (current, loc)))
 358         {
 359           return i;
 360         }
 361     }
 362
 363   return -1;
 364 }
 365
 366 static bool
 367 flagMarkerList_contains (flagMarkerList s, flagMarker fm)
 368 {
 369   int i;
 370
 371   for (i = s->nelements - 1; i >= 0; i--)
 372     {
 373       flagMarker current = s->elements[i];
 374
 375       if (flagMarker_equal (current, fm))
 376         {
 377           return TRUE;
 378         }
 379     }
 380
 381   return FALSE;
 382 }
 383
 384 /*
 385 ** returns YES iff
 386 **    > in ignore region (there is an ignore ON marker not followed by OFF)
 387 **    > code is OFF (-)
 388 **
 389 ** returns NO iff
 390 **    > not in ignore region
 391 **    > code is ON (+)
 392 **
 393 ** returns MAYBE iff
 394 **    > not in ignore region
 395 **    > code is unset or =
 396 **
 397 ** requires: invariant for flagMarkerList:
 398 **    flagMarker's are sorted by line and col
 399 */
 400
 401 ynm
 402 flagMarkerList_suppressError (flagMarkerList s, flagcode code, fileloc loc)
 403 {
 404   int i;
 405   bool ignoreOff = FALSE;
 406   bool nameChecksOff = FALSE;
 407   bool flagOff = FALSE;
 408   ynm flagSet = MAYBE;
 409   bool islib = FALSE;
 410   bool isNameChecksFlag = flagcode_isNameChecksFlag (code);
 411
 412   if (fileloc_isLib (loc))
 413     {
 414       i = s->nelements - 1;
 415       islib = TRUE;
 416     }
 417   else
 418     {
 419       i = flagMarkerList_lastBeforeLoc (s, loc);
 420     }
 421
 422   if (i < 0)
 423     {
 424       DPRINTF (("RETURNING!"));
 425       return MAYBE;
 426     }
 427
 428   /*
 429   ** Go backwards through the remaining flagMarkers in this file.
 430   */
 431
 432   for (; i >= 0; i--)
 433     {
 434       flagMarker current = s->elements[i];
 435
 436       DPRINTF (("Check current: %s", flagMarker_unparse (current)));
 437
 438       if (!islib && !flagMarker_sameFile (current, loc))
 439         {
 440           DPRINTF (("Not same file: %s", fileloc_unparse (loc)));
 441           break;
 442         }
 443
 444       if (flagMarker_isIgnoreOff (current))
 445         {
 446           ignoreOff = TRUE;
 447         }
 448       else if (flagMarker_isIgnoreOn (current))
 449         {
 450           if (!ignoreOff)
 451             {
 452               return YES;
 453             }
 454         }
 455       else if (flagMarker_isIgnoreCount (current))
 456         {
 457           if (!ignoreOff)
 458             {
 459               flagMarkerList_splice (s, i,
 460                                      flagMarker_createSuppress (code, loc));
 461               return YES;
 462             }
 463         }
 464       else if (flagMarker_isLocalSet (current))
 465         {
 466
 467           if (!flagOff && flagMarker_getCode (current) == code)
 468             {
 469               ynm set  = flagMarker_getSet (current);
 470
 471               if (ynm_isOff (set))
 472                 {
 473                   return YES;
 474                 }
 475               else
 476                 {
 477                   if (ynm_isOn (set))
 478                     {
 479                       flagOff = TRUE;
 480                       flagSet = NO;
 481                     }
 482                   else
 483                     {
 484                       flagOff = TRUE;
 485                       flagSet = MAYBE;
 486                     }
 487
 488                   if (ignoreOff)
 489                     {
 490                       if (isNameChecksFlag && !nameChecksOff)
 491                         {
 492                           ;
 493                         }
 494                       else
 495                         {
 496                           return flagSet;
 497                         }
 498                     }
 499                 }
 500             }
 501
 502           if (flagMarker_getCode (current) == FLG_NAMECHECKS
 503               && !nameChecksOff && isNameChecksFlag)
 504             {
 505               ynm set  = flagMarker_getSet (current);
 506
 507               if (ynm_isOff (set))
 508                 {
 509                   return YES;
 510                 }
 511               else
 512                 {
 513                   if (ynm_isOn (set))
 514                     {
 515                       nameChecksOff = TRUE;
 516                       flagSet = NO;
 517                     }
 518                   else
 519                     {
 520                       nameChecksOff = TRUE;
 521                       flagSet = MAYBE;
 522                     }
 523
 524                   if (ignoreOff && flagOff)
 525                     {
 526                       return flagSet;
 527                     }
 528                 }
 529             }
 530         }
 531       else
 532         {
 533           llassert (flagMarker_isSuppress (current));
 534         }
 535     }
 536
 537   return flagSet;
 538 }
 539
 540 bool
 541 flagMarkerList_inIgnore (flagMarkerList s, fileloc loc)
 542 {
 543   int i;
 544
 545   if (fileloc_isLib (loc))
 546     {
 547       return FALSE;
 548     }
 549
 550   i = flagMarkerList_lastBeforeLoc (s, loc);
 551
 552   /*
 553   ** Go backwards through the remaining flagMarkers in this file.
 554   */
 555
 556   for (; i >= 0; i--)
 557     {
 558       flagMarker current = s->elements[i];
 559
 560       if (!flagMarker_sameFile (current, loc))
 561         {
 562           break;
 563         }
 564
 565       if (flagMarker_isIgnoreOff (current))
 566         {
 567           return FALSE;;
 568         }
 569       else if (flagMarker_isIgnoreOn (current))
 570         {
 571           return TRUE;
 572         }
 573       else if (flagMarker_isIgnoreCount (current))
 574         {
 575           flagMarkerList_splice (s, i,
 576                                  flagMarker_createSuppress (SKIP_FLAG, loc));
 577           return TRUE;
 578         }
 579       else
 580         {
 581           llassert (flagMarker_isLocalSet (current)
 582                     || flagMarker_isSuppress (current));
 583         }
 584     }
 585
 586   return FALSE;
 587 }
 588