src/macrocache.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 ** macrocache.c
  26 **
  27 ** rep Invariant:
  28 **     no two fileloc's may be equal
  29 **
  30 */
  31
  32 # include "splintMacros.nf"
  33 # include "basic.h"
  34 # include "cscanner.h"
  35 # include "cgrammar.h"
  36
  37 /*@constant int MCEBASESIZE;@*/
  38 # define MCEBASESIZE 8
  39
  40 /*@constant int DNE;@*/
  41 # define DNE -1
  42
  43 /*
  44 ** Temporary file used for processing macros.
  45 */
  46
  47 static /*:open:*/ /*@null@*/ FILE *s_macFile = NULL;
  48
  49 /*
  50 ** mcDisable is set to TRUE when a macro is being processed, so
  51 ** its contents are not added to the macrocache again, creating
  52 ** a nasty infinite loop.
  53 */
  54
  55 static bool mcDisable = TRUE;
  56 static void macrocache_grow (macrocache p_s);
  57 static int macrocache_exists (macrocache p_s, fileloc p_fl);
  58 static void macrocache_processMacro (macrocache p_m, int p_i);
  59
  60 static /*@only@*/ mce
  61   mce_create (/*@only@*/ fileloc fl, /*@only@*/ cstring def, bool comment)
  62 {
  63   mce m = (mce) dmalloc (sizeof (*m));
  64   m->fl = fl;
  65   m->def = def; /*< had a copy here! check this carefully */
  66   m->defined = FALSE;
  67   m->scomment = comment;
  68   return m;
  69 }
  70
  71 static void mce_free (/*@only@*/ mce m)
  72 {
  73   fileloc_free (m->fl);
  74   cstring_free (m->def);
  75   sfree (m);
  76 }
  77
  78 /*@only@*/ macrocache
  79 macrocache_create (void)
  80 {
  81   macrocache s = (macrocache) dmalloc (sizeof (*s));
  82
  83   s->entries = 0;
  84   s->nspace = MCEBASESIZE;
  85   s->contents = (mce *) dmalloc (sizeof (*s->contents) * MCEBASESIZE);
  86
  87   mcDisable = FALSE;
  88
  89   return (s);
  90 }
  91
  92 void
  93 macrocache_free (macrocache s)
  94 {
  95   int i;
  96
  97   llassert (s_macFile == NULL);
  98
  99   for (i = 0; i < s->entries; i++)
 100     {
 101        mce_free (s->contents[i]);
 102     }
 103
 104   sfree (s->contents);
 105   sfree (s);
 106 }
 107
 108 static void
 109 macrocache_grow (macrocache s)
 110 {
 111   int i;
 112   o_mce *oldcontents = s->contents;
 113
 114   s->nspace = MCEBASESIZE;
 115   s->contents = (mce *) dmalloc (sizeof (*s->contents) * (s->entries + s->nspace));
 116
 117   for (i = 0; i < s->entries; i++)
 118     {
 119        s->contents[i] = oldcontents[i];
 120     }
 121
 122   sfree (oldcontents);
 123 }
 124
 125 static void
 126 macrocache_addGenEntry (macrocache s, /*@only@*/ fileloc fl,
 127                         /*@only@*/ cstring def, bool sup)
 128 {
 129   int i;
 130
 131   if (mcDisable)
 132     {
 133       fileloc_free (fl);
 134       cstring_free (def);
 135       return;
 136     }
 137
 138   if ((i = macrocache_exists (s, fl)) != DNE)
 139     {
 140         if (cstring_equal (def, s->contents[i]->def))
 141         {
 142           fileloc_free (fl);
 143           cstring_free (def);
 144
 145           return;
 146         }
 147       else
 148         {
 149           /*
 150           ** macro definition contained macro that is expanded
 151           ** replace with def
 152           **
 153           ** how do we know which is better??
 154           */
 155
 156           cstring_free (s->contents[i]->def);
 157             s->contents[i]->def = def;
 158
 159           fileloc_free (fl);
 160           return;
 161         }
 162     }
 163
 164   if (s->nspace <= 0) {
 165     macrocache_grow (s);
 166   }
 167
 168   s->nspace--;
 169     s->contents[s->entries] = mce_create (fl, def, sup);
 170   s->entries++;
 171 }
 172
 173 void
 174 macrocache_addEntry (macrocache s, /*@only@*/ fileloc fl, /*@only@*/ cstring def)
 175 {
 176   macrocache_addGenEntry (s, fl, def, FALSE);
 177 }
 178
 179
 180 void
 181 macrocache_addComment (macrocache s, /*@only@*/ fileloc fl, /*@only@*/ cstring def)
 182 {
 183   DPRINTF (("Macrocache add comment: %s / %s", fileloc_unparse (fl), def));
 184   macrocache_addGenEntry (s, fl, def, TRUE);
 185 }
 186
 187 static int
 188 macrocache_exists (macrocache s, fileloc fl)
 189 {
 190   int i;
 191
 192   for (i = 0; i < s->entries; i++)
 193     {
 194         if (fileloc_equal (s->contents[i]->fl, fl))
 195         return (i);
 196     }
 197
 198   return (DNE);
 199 }
 200
 201 # ifdef DEADCODE
 202 /*@only@*/ cstring
 203 macrocache_unparse (macrocache m)
 204 {
 205   cstring s = cstring_undefined;
 206   int i;
 207
 208   for (i = 0; i < m->entries; i++)
 209     {
 210         fileloc fl = m->contents[i]->fl;
 211       cstring def = m->contents[i]->def;
 212       bool defined = m->contents[i]->defined;
 213
 214       s = message ("%q%q: %s [%s]\n", s, fileloc_unparse (fl), def,
 215                    bool_unparse (defined));
 216     }
 217
 218   return (s);
 219 }
 220 # endif /* DEADCODE */
 221
 222 /*
 223 ** needs to call lex by hand...yuk!
 224 **
 225 ** modifies gc fileloc!
 226 */
 227
 228 /*
 229 ** there's gotta be a better way of doing this!
 230 */
 231
 232 static void pushString (/*@only@*/ cstring s)
 233 {
 234   static fileId mtid = fileId_invalid;
 235   long floc;
 236
 237   if (s_macFile == NULL)
 238     {
 239       cstring fname;
 240       mtid = fileTable_addTempFile (context_fileTable (), FILE_MACROS, fileId_invalid);
 241
 242       fname = fileTable_fileName (mtid);
 243       s_macFile = fileTable_createTempFile (context_fileTable (), fname, TRUE);
 244
 245       if (s_macFile == NULL)
 246         {
 247           llfatalerror (message ("Cannot open tmp file %s needed to process macro: %s",
 248                               fname, s));
 249           cstring_free (s);
 250           return;
 251         }
 252     }
 253
 254   llassert (s_macFile != NULL);
 255
 256   check (fseek (s_macFile, 0, SEEK_CUR) == 0);
 257
 258   floc = ftell (s_macFile);
 259
 260   if (cstring_length (s) > 0) {
 261     check (fputs (cstring_toCharsSafe (s), s_macFile) != EOF);
 262   }
 263
 264   check (fputc ('\n', s_macFile) == (int) '\n');
 265
 266   check (fseek (s_macFile, floc, SEEK_SET) == 0);
 267
 268   c_in = s_macFile;
 269   (void) c_restart (c_in);
 270   cstring_free (s);
 271 }
 272
 273 static void
 274 macrocache_processMacro (macrocache m, int i)
 275 {
 276     fileloc fl = m->contents[i]->fl;
 277
 278     m->contents[i]->defined = TRUE;
 279
 280   if (!fileId_equal (currentFile (), fileloc_fileId (fl)))
 281     {
 282       g_currentloc = fileloc_update (g_currentloc, fl);
 283       context_enterMacroFile ();
 284     }
 285   else
 286     {
 287       setLine (fileloc_lineno (fl));
 288     }
 289
 290   beginLine ();
 291
 292   DPRINTF (("Process macro: %s", m->contents[i]->def));
 293
 294   if (m->contents[i]->scomment)
 295     {
 296       pushString (message ("%s%s%s",
 297                            cstring_fromChars (BEFORE_COMMENT_MARKER),
 298                            m->contents[i]->def,
 299                            cstring_fromChars (AFTER_COMMENT_MARKER)));
 300       (void) c_parse ();
 301     }
 302   else
 303     {
 304       bool insup = context_inSuppressRegion ();
 305
 306       pushString (message ("%s %s",
 307                            cstring_makeLiteralTemp (PPMRCODE),
 308                            m->contents[i]->def));
 309       (void) c_parse ();
 310
 311       if (context_inSuppressRegion () && !insup)
 312         {
 313           voptgenerror
 314             (FLG_SYNTAX,
 315              message ("Macro ends in ignore region: %s", m->contents[i]->def),
 316              fl);
 317         }
 318     }
 319
 320   incLine ();
 321   context_exitAllClauses ();
 322   context_exitMacroCache ();
 323 }
 324
 325 extern void macrocache_processUndefinedElements (macrocache m)
 326 {
 327   fileloc lastfl = fileloc_undefined;
 328   int i;
 329
 330   mcDisable = TRUE;
 331
 332   DPRINTF (("Processing undefined elements"));
 333
 334   if (!context_getFlag (FLG_PARTIAL))
 335     {
 336       for (i = 0; i < m->entries; i++)
 337         {
 338             if (m->contents[i]->defined)
 339             {
 340               ;
 341             }
 342           else
 343             {
 344               fileloc fl = m->contents[i]->fl;
 345
 346               if (fileloc_isDefined (lastfl) && fileloc_sameFile (fl, lastfl))
 347                 {
 348                   ;
 349                 }
 350               else
 351                 {
 352                   if (!fileloc_isLib (fl))
 353                     {
 354                       displayScan (message ("checking macros %q",
 355                                             fileloc_outputFilename (fl)));
 356                     }
 357
 358                   lastfl = fl;
 359                   cleanupMessages ();
 360                 }
 361
 362               macrocache_processMacro (m, i);
 363             }
 364         }
 365     }
 366
 367   mcDisable = FALSE;
 368 }
 369
 370 extern /*@observer@*/ fileloc macrocache_processFileElements (macrocache m, cstring base)
 371 {
 372   fileloc lastfl = fileloc_undefined;
 373   int i;
 374
 375   mcDisable = TRUE;
 376
 377   for (i = 0; i < m->entries; i++)
 378     {
 379         if (m->contents[i]->defined)
 380         {
 381           ;
 382         }
 383       else
 384         {
 385           fileloc fl = m->contents[i]->fl;  /* should be dependent! */
 386           cstring fb = fileloc_getBase (fl);
 387
 388           if (cstring_equal (fb, base))
 389             {
 390               lastfl = fl;
 391               macrocache_processMacro (m, i);
 392             }
 393         }
 394     }
 395
 396   mcDisable = FALSE;
 397   return lastfl;
 398 }
 399
 400 void macrocache_finalize (void)
 401 {
 402   if (s_macFile != NULL)
 403     {
 404       check (fileTable_closeFile (context_fileTable (), s_macFile));
 405       s_macFile = NULL;
 406     }
 407 }