src/library.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 ** library.c
  26 **
  27 ** routines for loading and creating library files
  28 **
  29 ** this is a brute-force implementation, a more efficient
  30 ** representation should be designed.
  31 **
  32 */
  33
  34 # include <float.h>
  35
  36 # include "splintMacros.nf"
  37 # include "basic.h"
  38 # include "osd.h"
  39
  40 # include "libversion.h"
  41 # include "library.h"
  42
  43 static void printDot (void)
  44 {
  45   displayScanContinue (cstring_makeLiteralTemp ("."));
  46 }
  47
  48 static bool loadLCDFile (FILE * p_f, cstring p_name);
  49
  50 void
  51 dumpState (cstring cfname)
  52 {
  53   FILE *f;
  54   cstring fname = fileLib_addExtension (cfname, cstring_makeLiteralTemp (DUMP_SUFFIX));
  55
  56   f = fileTable_openWriteFile (context_fileTable (), fname);
  57
  58   displayScanOpen (message ("Dumping to %s ", fname));
  59
  60   if (f == NULL)
  61     {
  62       lldiagmsg (message ("Cannot open dump file for writing: %s", fname));
  63     }
  64   else
  65     {
  66       /*
  67       ** sequence is convulted --- must call usymtab_prepareDump before
  68       **    dumping ctype table to convert type uid's
  69       */
  70
  71       printDot ();
  72
  73 # if 0
  74       DPRINTF (("Before prepare dump:"));
  75       ctype_printTable ();
  76       DPRINTF (("Preparing dump..."));
  77 # endif
  78
  79       usymtab_prepareDump ();
  80
  81       /*
  82       ** Be careful, these lines must match loadLCDFile checking.
  83       */
  84
  85       fprintf (f, "%s %s\n", LIBRARY_MARKER, cstring_toCharsSafe (fname));
  86       fprintf (f, ";;Splint %f\n", LIBVERSION);
  87       fprintf (f, ";;lib:%d\n", (int) context_getLibrary ());
  88       fprintf (f, ";;ctTable\n");
  89
  90       DPRINTF (("Dumping types..."));
  91       printDot ();
  92       ctype_dumpTable (f);
  93       printDot ();
  94
  95       DPRINTF (("Dumping type sets..."));
  96       fprintf (f, ";;tistable\n");
  97       typeIdSet_dumpTable (f);
  98       printDot ();
  99
 100       DPRINTF (("Dumping usymtab..."));
 101       fprintf (f, ";;symTable\n");
 102       usymtab_dump (f);
 103       printDot ();
 104
 105       DPRINTF (("Dumping modules..."));
 106       fprintf (f, ";; Modules access\n");
 107       context_dumpModuleAccess (f);
 108       fprintf (f, ";;End\n");
 109       check (fileTable_closeFile (context_fileTable (), f));
 110     }
 111
 112   displayScanClose ();
 113   cstring_free (fname);
 114 }
 115
 116 bool
 117 loadStandardState (void)
 118 {
 119   cstring fpath;
 120   FILE *stdlib;
 121   bool result;
 122   cstring libname = fileLib_addExtension (context_selectedLibrary (),
 123                                           cstring_makeLiteralTemp (DUMP_SUFFIX));
 124
 125   if (osd_getPath (context_getLarchPath (), libname, &fpath) != OSD_FILEFOUND)
 126     {
 127       lldiagmsg (message ("Cannot find standard library: %s", libname));
 128       lldiagmsg (cstring_makeLiteral ("     Check LARCH_PATH environment variable."));
 129       result = FALSE;
 130     }
 131   else
 132     {
 133       stdlib = fileTable_openReadFile (context_fileTable (), fpath);
 134
 135       if (stdlib == NULL)
 136         {
 137           lldiagmsg (message ("Cannot read standard library: %s",
 138                               fpath));
 139           lldiagmsg (cstring_makeLiteral ("     Check LARCH_PATH environment variable."));
 140
 141           result = FALSE;
 142         }
 143       else
 144         {
 145           if (context_getFlag (FLG_WHICHLIB))
 146             {
 147               char *t = mstring_create (MAX_NAME_LENGTH);
 148               char *ot = t;
 149
 150               if ((t = reader_readLine (stdlib, t, MAX_NAME_LENGTH)) == NULL)
 151                 {
 152                   llfatalerror (cstring_makeLiteral ("Standard library format invalid"));
 153                 }
 154
 155               if ((t = reader_readLine (stdlib, t, MAX_NAME_LENGTH)) != NULL)
 156                 {
 157                   if (*t == ';' && *(t + 1) == ';')
 158                     {
 159                       t += 2;
 160                     }
 161                 }
 162
 163               if (t == NULL)
 164                 {
 165                   lldiagmsg (message ("Standard library: %s <cannot read creation information>",
 166                                       fpath));
 167                 }
 168               else
 169                 {
 170                   char *tt;
 171
 172                   tt = strrchr (t, '\n');
 173                   if (tt != NULL)
 174                     *tt = '\0';
 175
 176                   lldiagmsg (message ("Standard library: %s", fpath));
 177                   /* evans 2004-01-13: removed this (it is the libversion which is confusing) */
 178                   /*   lldiagmsg (message ("   (created using %s)", cstring_fromChars (t)));                */
 179                 }
 180
 181               sfree (ot);
 182
 183               check (fileTable_closeFile (context_fileTable (), stdlib));
 184               stdlib = fileTable_openReadFile (context_fileTable (), fpath);
 185             }
 186
 187           llassert (stdlib != NULL);
 188
 189           fileloc_reallyFree (g_currentloc);
 190           g_currentloc = fileloc_createLib (libname, TRUE);
 191
 192           DPRINTF (("Loading: %s", fpath));
 193
 194           displayScanOpen (message ("loading standard library %s ", fpath));
 195           result = loadLCDFile (stdlib, fpath);
 196           displayScanClose ();
 197
 198           check (fileTable_closeFile (context_fileTable (), stdlib));
 199         }
 200     }
 201
 202   cstring_free (libname);
 203   return result;
 204 }
 205
 206 /*@constant int BUFLEN;@*/
 207 # define BUFLEN 128
 208
 209 static bool
 210 loadLCDFile (FILE *f, cstring name)
 211 {
 212   char buf[BUFLEN];
 213
 214   if (reader_readLine (f, buf, BUFLEN) == NULL
 215       || !mstring_equalPrefix (buf, LIBRARY_MARKER))
 216     {
 217       loadllmsg (message ("Load library %s is not in Splint library format.  Attempting "
 218                           "to continue without library.", name));
 219       return FALSE;
 220     }
 221
 222   if (reader_readLine (f, buf, BUFLEN) != NULL)
 223     {
 224       if (!mstring_equalPrefix (buf, ";;"))
 225         {
 226           loadllmsg (message ("Load library %s is not in Splint library format.  Attempting "
 227                               "to continue without library.", name));
 228           return FALSE;
 229         }
 230       else if (mstring_equalPrefix (buf, ";;ctTable"))
 231         {
 232           loadllmsg (message ("Load library %s is in obsolete Splint library format.  Attempting "
 233                               "to continue anyway, but results may be incorrect.  Rebuild "
 234                               "the library with this version of splint.",
 235                               name));
 236         }
 237       else
 238         {
 239           float version = 0.0;
 240
 241           if (sscanf (buf, ";;Splint %f", &version) != 1
 242               && (sscanf (buf, ";;LCLint %f", &version) != 1))
 243             {
 244               loadllmsg (message ("Load library %s is not in Splint library format (missing version "
 245                                   "number).  Attempting to continue without library.", name));
 246               return FALSE;
 247             }
 248           else
 249             {
 250               /*
 251               ** Check version.  Should be >= LIBVERSION
 252               */
 253
 254               if ((LIBVERSION - version) >= FLT_EPSILON)
 255                 {
 256                   cstring vname;
 257                   char *nl = strchr (buf, '\n');
 258
 259                   *nl = '\0';
 260
 261                   vname = cstring_fromChars (buf + 9);
 262
 263                   loadllmsg (message ("Load library %s is in obsolete Splint library "
 264                                       "format (version %f (%s), expecting version %f).  Attempting "
 265                                       "to continue anyway, but results may be incorrect.  Rebuild "
 266                                       "the library with this version of splint.",
 267                                       name,
 268                                       version,
 269                                       vname,
 270                                       LIBVERSION));
 271                 }
 272               else
 273                 {
 274                   if (reader_readLine (f, buf, BUFLEN) == NULL)
 275                     {
 276                       loadllmsg (message ("Load library %s is not in Splint library "
 277                                           "format (missing library code). Attempting "
 278                                           "to continue without library.", name));
 279                       return FALSE;
 280                     }
 281                   else
 282                     {
 283                       int lib;
 284
 285                       if (sscanf (buf, ";;lib:%d", &lib) != 1)
 286                         {
 287                           loadllmsg (message ("Load library %s is not in Splint library "
 288                                               "format (missing library code). Attempting "
 289                                               "to continue without library.", name));
 290                           return FALSE;
 291                         }
 292                       else
 293                         {
 294                           flagcode code = (flagcode) lib;
 295
 296                           if (flagcode_isLibraryFlag (code))
 297                             {
 298                               if (context_doMerge ())
 299                                 {
 300                                   context_setLibrary (code);
 301                                 }
 302                             }
 303                           else
 304                             {
 305                               loadllmsg (message ("Load library %s has invalid library code (%s).  "
 306                                                   "Attempting to continue without library.",
 307                                                   name,
 308                                                   flagcode_unparse (code)));
 309
 310                               return FALSE;
 311                             }
 312                         }
 313                     }
 314                 }
 315             }
 316         }
 317     }
 318   else
 319     {
 320       loadllmsg (message ("Load library %s is not in Splint library format (missing lines).  "
 321                           "Attempting to continue without library.", name));
 322       return FALSE;
 323     }
 324
 325   ctype_loadTable (f);
 326   printDot ();
 327
 328   typeIdSet_loadTable (f);
 329   printDot ();
 330
 331   usymtab_load (f);
 332   printDot ();
 333
 334   context_loadModuleAccess (f);
 335   printDot ();
 336
 337   return TRUE;
 338 }
 339
 340 /*
 341 ** load state from file created by dumpState
 342 */
 343
 344 void
 345 loadState (cstring cfname)
 346 {
 347   FILE *f;
 348   cstring fname = fileLib_addExtension (cfname, cstring_makeLiteralTemp (DUMP_SUFFIX));
 349
 350   f = fileTable_openReadFile (context_fileTable (), fname);
 351
 352   if (f == NULL)
 353     {
 354       displayScanClose ();
 355       llfatalerror (message ("Cannot open dump file for loading: %s",
 356                              fname));
 357     }
 358   else
 359     {
 360       fileloc_reallyFree (g_currentloc);
 361       g_currentloc = fileloc_createLib (cfname, FALSE);
 362
 363       if (!loadLCDFile (f, cfname))
 364         {
 365           if (!loadStandardState ())
 366             {
 367               ctype_initTable ();
 368             }
 369         }
 370
 371       check (fileTable_closeFile (context_fileTable (), f));
 372     }
 373
 374   /* usymtab_printAll (); */
 375   cstring_free (fname);
 376 }
 377