src/fileTable.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 ** fileTable.c
  26 **
  27 ** replaces filenamemap.c
  28 ** based (loosely) on typeTable.c
  29 **
  30 ** entries in the fileTable are:
  31 **
  32 **        name - name of the file
  33 **        type - kind of file (a temp file to be deleted?)
  34 **        link - derived from this file
  35 **
  36 */
  37
  38 # include "splintMacros.nf"
  39 # include "basic.h"
  40 # include "osd.h"
  41
  42 /*@access fileId*/
  43
  44 static void
  45 fileTable_addOpen (fileTable p_ft, /*@observer@*/ FILE *p_f, /*@only@*/ cstring p_fname)
  46   /*@modifies p_ft@*/ ;
  47
  48 static bool fileTable_inRange (fileTable ft, fileId fid) /*@*/
  49 {
  50   return (fileTable_isDefined (ft) && (fid >= 0) && (fid < ft->nentries));
  51 }
  52
  53 static fileId fileTable_internAddEntry (fileTable p_ft, /*@only@*/ ftentry p_e)
  54    /*@modifies p_ft@*/ ;
  55 static /*@only@*/ cstring makeTempName (cstring p_pre, cstring p_suf);
  56
  57 # ifdef DEADCODE
  58 static /*@only@*/ cstring
  59 fileType_unparse (fileType ft)
  60 {
  61   switch (ft)
  62     {
  63     case FILE_NORMAL:     return cstring_makeLiteral ("normal");
  64     case FILE_HEADER:     return cstring_makeLiteral ("header");
  65     case FILE_XH:         return cstring_makeLiteral ("xh");
  66     case FILE_METASTATE:  return cstring_makeLiteral ("metastate");
  67     case FILE_RC:         return cstring_makeLiteral ("rc");
  68     case FILE_LCL:        return cstring_makeLiteral ("lcl");
  69     case FILE_LCD:        return cstring_makeLiteral ("lcd");
  70     case FILE_IMPORT:     return cstring_makeLiteral ("import");
  71     case FILE_PP:         return cstring_makeLiteral ("pp");
  72
  73     case FILE_LSLTEMP:    return cstring_makeLiteral ("lsltemp");
  74     case FILE_MACROS:     return cstring_makeLiteral ("macros");
  75     case FILE_NODELETE:   return cstring_makeLiteral ("nodelete");
  76     }
  77
  78   BADEXIT;
  79 }
  80 # endif /* DEADCODE */
  81
  82 static int
  83 fileTable_getIndex (fileTable ft, cstring s)
  84 {
  85   int res;
  86   cstring abspath;
  87   if (ft == NULL) return NOT_FOUND;
  88   abspath = osd_absolutePath (s);
  89
  90   if (context_getFlag (FLG_CASEINSENSITIVEFILENAMES))
  91     {
  92       abspath = cstring_downcase (abspath);
  93     }
  94
  95   DPRINTF (("Absolute path: %s: %s", s, abspath));
  96   res = cstringTable_lookup (ft->htable, abspath);
  97   cstring_free (abspath);
  98   return res;
  99 }
 100
 101 # ifdef DEADCODE
 102 static cstring ftentry_unparse (fileTable ft, ftentry fte)
 103 {
 104   if (fileId_isValid (fte->fder))
 105     {
 106       llassert (fileTable_isDefined (ft));
 107
 108       return message ("%s %q %d (%s)",
 109                       fte->fname,
 110                       fileType_unparse (fte->ftype),
 111                       fte->fder,
 112                       ft->elements[fte->fder]->fname);
 113     }
 114   else
 115     {
 116       return message ("%s %q", fte->fname,
 117                       fileType_unparse (fte->ftype));
 118     }
 119 }
 120
 121 /*@only@*/ cstring
 122 fileTable_unparse (fileTable ft)
 123 {
 124   cstring s = cstring_undefined;
 125   int i;
 126
 127   if (fileTable_isUndefined (ft))
 128     {
 129       return (cstring_makeLiteral ("<fileTable undefined>"));
 130     }
 131
 132   for (i = 0; i < ft->nentries; i++)
 133     {
 134       s = message ("%s\n[%d] %q", s, i, ftentry_unparse (ft, ft->elements[i]));
 135     }
 136
 137   return s;
 138 }
 139 # endif /* DEADCODE */
 140
 141 void fileTable_printTemps (fileTable ft)
 142 {
 143   if (fileTable_isDefined (ft))
 144     {
 145       int i;
 146
 147       for (i = 0; i < ft->nentries; i++)
 148         {
 149           if (ft->elements[i]->ftemp)
 150             {
 151               if (fileId_isValid (ft->elements[i]->fder))
 152                 {
 153                   fprintf (stderr, "  %s:1\n\t%s:1\n",
 154                            cstring_toCharsSafe (ft->elements[ft->elements[i]->fder]->fname),
 155                            cstring_toCharsSafe (ft->elements[i]->fname));
 156                 }
 157               else
 158                 {
 159                   fprintf (stderr, "[no file]\n\t%s:1\n",
 160                            cstring_toCharsSafe (ft->elements[i]->fname));
 161                 }
 162             }
 163         }
 164     }
 165 }
 166
 167 /*
 168 ** loads in fileTable from fileTable_dump
 169 */
 170
 171 static /*@notnull@*/ ftentry
 172 ftentry_create (/*@keep@*/ cstring tn, bool temp, fileType typ, fileId der)
 173 {
 174   ftentry t = (ftentry) dmalloc (sizeof (*t));
 175
 176   if (cstring_isUndefined (tn))
 177     {
 178       llbug (cstring_makeLiteral ("Undefined filename!"));
 179     }
 180
 181   t->fname = tn;
 182   t->ftemp = temp;
 183   t->ftype = typ;
 184   t->fder  = der;
 185
 186   /* Don't set these until needed. */
 187   t->basename = cstring_undefined;
 188   t->fsystem = FALSE;
 189   t->fspecial = FALSE;
 190
 191   return t;
 192 }
 193
 194 static void
 195 ftentry_free (/*@only@*/ ftentry t)
 196 {
 197   cstring_free (t->fname);
 198   cstring_free (t->basename);
 199   sfree (t);
 200 }
 201
 202 /*@only@*/ /*@notnull@*/ fileTable
 203 fileTable_create (void)
 204 {
 205   fileTable ft = (fileTable) dmalloc (sizeof (*ft));
 206
 207   ft->nentries = 0;
 208   ft->nspace = FTBASESIZE;
 209   ft->elements = (ftentry *) dmalloc (FTBASESIZE * sizeof (*ft->elements));
 210   ft->htable = cstringTable_create (FTHASHSIZE);
 211
 212   ft->nopen = 0;
 213   ft->nopenspace = FTBASESIZE;
 214   ft->openelements = (foentry *) dmalloc (FTBASESIZE * sizeof (*ft->openelements));
 215
 216   return (ft);
 217 }
 218
 219 /*@-bounds@*/
 220 static void
 221 fileTable_grow (fileTable ft)
 222 {
 223   int i;
 224   ftentry *newent;
 225
 226   llassert (fileTable_isDefined (ft));
 227
 228   ft->nspace = FTBASESIZE;
 229
 230   newent = (ftentry *) dmalloc ((ft->nentries + ft->nspace) * sizeof (*newent));
 231
 232   for (i = 0; i < ft->nentries; i++)
 233     {
 234       newent[i] = ft->elements[i];
 235     }
 236
 237   sfree (ft->elements);
 238   ft->elements = newent;
 239 }
 240 /*@=bounds@*/
 241 static void
 242 fileTable_growOpen (fileTable ft)
 243 {
 244   int i;
 245   foentry *newent;
 246
 247   llassert (fileTable_isDefined (ft));
 248
 249   ft->nopenspace = FTBASESIZE;
 250
 251   newent = (foentry *) dmalloc ((ft->nopen + ft->nopenspace) * sizeof (*newent));
 252
 253   for (i = 0; i < ft->nopen; i++)
 254     {
 255       newent[i] = ft->openelements[i];
 256     }
 257
 258   sfree (ft->openelements);
 259   ft->openelements = newent;
 260 }
 261
 262 static fileId
 263 fileTable_internAddEntry (fileTable ft, /*@only@*/ ftentry e)
 264 {
 265   cstring sd;
 266   llassert (fileTable_isDefined (ft));
 267
 268   if (ft->nspace <= 0)
 269     fileTable_grow (ft);
 270
 271   ft->nspace--;
 272
 273   DPRINTF (("Adding: %s", e->fname));
 274
 275   if (context_getFlag (FLG_CASEINSENSITIVEFILENAMES))
 276     {
 277       sd = cstring_downcase (e->fname);
 278     }
 279   else
 280     {
 281       sd = cstring_copy (e->fname);
 282     }
 283   /* evans 2002-07-12:
 284      Before, there was no cstring_copy above, and e->fname was free'd in the if branch.
 285      Splint should have caught this, and produced a warning for this assignment.
 286      Why not?
 287   */
 288   cstringTable_insert (ft->htable, sd, ft->nentries);
 289
 290   ft->elements[ft->nentries] = e;
 291   ft->nentries++;
 292   return (ft->nentries - 1);
 293 }
 294
 295 void fileTable_noDelete (fileTable ft, cstring name)
 296 {
 297   fileId fid = fileTable_lookup (ft, name);
 298
 299   if (fileId_isValid (fid))
 300     {
 301       llassert (fileTable_isDefined (ft));
 302       ft->elements[fid]->ftype = FILE_NODELETE;
 303     }
 304   else
 305     {
 306       DPRINTF (("Invalid no delete: %s", name));
 307     }
 308 }
 309
 310 static fileId
 311 fileTable_addFilePrim (fileTable ft, /*@temp@*/ cstring name,
 312                        bool temp, fileType typ, fileId der)
 313    /*@modifies ft@*/
 314 {
 315   ftentry e;
 316   cstring absname = osd_absolutePath (name);
 317   int tindex = fileTable_getIndex (ft, absname);
 318
 319   llassert (ft != fileTable_undefined);
 320
 321   if (tindex != NOT_FOUND)
 322     {
 323       llcontbug (message ("%s: duplicate entry: %q", __func__, absname));
 324       return tindex;
 325     }
 326
 327   e = ftentry_create (absname, temp, typ, der);
 328   llassert (cstring_isUndefined (e->basename));
 329   if (der == fileId_invalid)
 330     {
 331       e->basename = fileLib_removePathFree (fileLib_removeAnyExtension (absname));
 332       e->fsystem = !temp &&
 333         (typ == FILE_NORMAL || typ == FILE_HEADER) &&
 334         (context_isSystemDir (absname)
 335           /*
 336           ** evans 2002-03-15: change suggested by Jim Zelenka
 337           **                   support relative paths for system directories
 338           */
 339          || context_isSystemDir (name));
 340       e->fspecial = fileLib_isSpecialFile (absname);
 341
 342       if (e->fspecial)
 343         {
 344           cstring srcname = cstring_concatFree1 (fileLib_removeAnyExtension (absname),
 345                                                  C_EXTENSION);
 346           fileId fid = fileTable_lookup (ft, srcname);
 347           cstring_free (srcname);
 348
 349           if (fileId_isValid (fid))
 350             {
 351               fileId derid = ft->elements[fid]->fder;
 352
 353               ft->elements[fid]->fspecial = TRUE;
 354
 355               if (fileId_isValid (derid))
 356                 {
 357                   ft->elements[derid]->fspecial = TRUE;
 358                 }
 359             }
 360         }
 361     }
 362   else
 363     {
 364       ftentry de = ft->elements[der];
 365
 366       e->basename = cstring_copy (de->basename);
 367       e->fsystem = de->fsystem;
 368       e->fspecial = de->fspecial;
 369     }
 370
 371   return (fileTable_internAddEntry (ft, e));
 372 }
 373
 374 fileId
 375 fileTable_addFile (fileTable ft, fileType typ, cstring name)
 376 {
 377   switch (typ)
 378     {
 379       case FILE_RC:
 380       case FILE_PP:
 381       case FILE_NORMAL:
 382       case FILE_HEADER:
 383       case FILE_METASTATE:
 384       case FILE_XH:
 385       case FILE_LCL:
 386       case FILE_IMPORT:
 387       case FILE_LCD:
 388         return fileTable_addFilePrim (ft, name, FALSE, typ, fileId_invalid);
 389
 390       default:
 391         BADBRANCH;
 392         return fileId_invalid;
 393     }
 394 }
 395
 396 fileId
 397 fileTable_addTempFile (fileTable ft, fileType ftype, fileId fid)
 398 {
 399   fileId res;
 400   cstring newname, pre, suf;
 401
 402   llassert (fileTable_isDefined (ft));
 403
 404   switch (ftype) {
 405     case FILE_MACROS:
 406       llassert (fid == fileId_invalid);
 407       pre = cstring_makeLiteralTemp ("lmx");
 408       suf = cstring_makeLiteralTemp (".llm");
 409       break;
 410
 411     case FILE_LSLTEMP:
 412       llassert (fid == fileId_invalid);
 413       pre = cstring_makeLiteralTemp ("ls");
 414       suf = cstring_makeLiteralTemp (".lsl");
 415       break;
 416
 417     case FILE_NORMAL:
 418     case FILE_HEADER:
 419     case FILE_XH:
 420       /* temporary files for C preprocessing */
 421       llassert (fileId_isValid (fid));
 422
 423       pre = cstring_makeLiteralTemp ("cl");
 424       suf = C_EXTENSION;
 425
 426       if (fileId_isValid (ft->elements[fid]->fder))
 427       {
 428         fid = ft->elements[fid]->fder;
 429       }
 430       break;
 431
 432     default:
 433       BADBRANCH;
 434       return fileId_invalid;
 435   }
 436
 437   newname = makeTempName (pre, suf);
 438   res = fileTable_addFilePrim (ft, newname, TRUE, ftype, fid);
 439   DPRINTF (("Added file: %s", fileTable_getName (ft, res)));
 440   cstring_free (newname);
 441   return res;
 442 }
 443
 444 void
 445 fileTable_addStreamFile (fileTable ft, FILE *fstream, cstring name)
 446 {
 447   fileTable_addOpen (ft, fstream, cstring_copy (name));
 448 }
 449
 450 bool
 451 fileTable_isHeader (fileTable ft, fileId fid)
 452 {
 453   if (fileId_isInvalid (fid))
 454     {
 455       return FALSE;
 456     }
 457
 458   llassert (fileTable_isDefined (ft) && fileTable_inRange (ft, fid));
 459   return (ft->elements[fid]->ftype == FILE_HEADER);
 460 }
 461
 462 bool
 463 fileTable_isSystemFile (fileTable ft, fileId fid)
 464 {
 465   if (fileId_isInvalid (fid))
 466     {
 467       return FALSE;
 468     }
 469
 470   llassert (fileTable_isDefined (ft) && fileTable_inRange (ft, fid));
 471   return (ft->elements[fid]->fsystem);
 472 }
 473
 474 bool
 475 fileTable_isXHFile (fileTable ft, fileId fid)
 476 {
 477   if (fileId_isInvalid (fid))
 478     {
 479       return FALSE;
 480     }
 481
 482   if (!(fileTable_isDefined (ft) && fileTable_inRange (ft, fid)))
 483     {
 484       llcontbug (message ("Bad file table or id: %s %d", bool_unparse (fileTable_isDefined (ft)), fid));
 485       return FALSE;
 486     }
 487   else
 488     {
 489       return (ft->elements[fid]->ftype == FILE_XH);
 490     }
 491 }
 492
 493 bool
 494 fileTable_isSpecialFile (fileTable ft, fileId fid)
 495 {
 496   if (fileId_isInvalid (fid))
 497     {
 498       return FALSE;
 499     }
 500
 501   llassert (fileTable_isDefined (ft) && fileTable_inRange (ft, fid));
 502   return (ft->elements[fid]->fspecial);
 503 }
 504
 505 bool
 506 fileTable_exists (fileTable ft, cstring s)
 507 {
 508   int tindex = fileTable_getIndex (ft, s);
 509
 510   if (tindex == NOT_FOUND)
 511     {
 512       DPRINTF (("Not found: %s", s));
 513       return FALSE;
 514     }
 515   else
 516     {
 517       return TRUE;
 518     }
 519 }
 520
 521 fileId
 522 fileTable_lookup (fileTable ft, cstring s)
 523 {
 524   int tindex = fileTable_getIndex (ft, s);
 525
 526   if (tindex == NOT_FOUND)
 527     {
 528       return fileId_invalid;
 529     }
 530   else
 531     {
 532       return tindex;
 533     }
 534 }
 535
 536 fileId
 537 fileTable_lookupBase (fileTable ft, cstring base)
 538 {
 539   int tindex;
 540
 541   if (context_getFlag (FLG_CASEINSENSITIVEFILENAMES))
 542     {
 543       cstring dbase = cstring_downcase (base);
 544       tindex = fileTable_getIndex (ft, dbase);
 545       cstring_free (dbase);
 546     }
 547   else
 548     {
 549       tindex = fileTable_getIndex (ft, base);
 550     }
 551
 552   if (tindex == NOT_FOUND)
 553     {
 554       return fileId_invalid;
 555     }
 556   else
 557     {
 558       fileId der;
 559
 560       llassert (fileTable_isDefined (ft));
 561
 562       der = ft->elements[tindex]->fder;
 563
 564       if (!fileId_isValid (der))
 565         {
 566           der = tindex;
 567         }
 568
 569       return der;
 570     }
 571 }
 572
 573 cstring
 574 fileTable_getName (fileTable ft, fileId fid)
 575 {
 576   if (!fileId_isValid (fid))
 577     {
 578       llcontbug
 579         (message ("%s: called with invalid type id: %d", __func__, fid));
 580       return cstring_makeLiteralTemp ("<invalid>");
 581     }
 582
 583   llassert (fileTable_isDefined (ft));
 584   return (ft->elements[fid]->fname);
 585 }
 586
 587 cstring
 588 fileTable_getRootName (fileTable ft, fileId fid)
 589 {
 590   fileId fder;
 591
 592   if (!fileId_isValid (fid))
 593     {
 594       llcontbug (message ("%s: called with invalid id: %d", __func__, fid));
 595       return cstring_makeLiteralTemp ("<invalid>");
 596     }
 597
 598   if (!fileTable_isDefined (ft))
 599     {
 600       return cstring_makeLiteralTemp ("<no file table>");
 601     }
 602
 603   fder = ft->elements[fid]->fder;
 604
 605   if (fileId_isValid (fder))
 606     {
 607       return (ft->elements[fder]->fname);
 608     }
 609   else
 610     {
 611       return (ft->elements[fid]->fname);
 612     }
 613 }
 614
 615 cstring
 616 fileTable_getNameBase (fileTable ft, fileId fid)
 617 {
 618   if (!fileId_isValid (fid))
 619     {
 620       llcontbug (message ("%s: called with invalid id: %d", __func__, fid));
 621       return cstring_makeLiteralTemp ("<invalid>");
 622     }
 623
 624   if (!fileTable_isDefined (ft))
 625     {
 626       return cstring_makeLiteralTemp ("<no file table>");
 627     }
 628
 629   return (ft->elements[fid]->basename);
 630 }
 631
 632 bool
 633 fileTable_sameBase (fileTable ft, fileId f1, fileId f2)
 634 {
 635   fileId fd1, fd2;
 636
 637   if (!fileId_isValid (f1))
 638     {
 639       return FALSE;
 640     }
 641
 642   if (!fileId_isValid (f2))
 643     {
 644       return FALSE;
 645     }
 646
 647   llassert (fileTable_isDefined (ft));
 648
 649   if (f1 == f2)
 650     {
 651       return TRUE;
 652     }
 653
 654   fd1 = ft->elements[f1]->fder;
 655
 656   if (!fileId_isValid (fd1))
 657     {
 658       fd1 = f1;
 659     }
 660
 661   fd2 = ft->elements[f2]->fder;
 662
 663
 664   if (!fileId_isValid (fd2))
 665     {
 666       fd2 = f2;
 667     }
 668
 669   return (fd1 == fd2);
 670 }
 671
 672 void
 673 fileTable_cleanup (fileTable ft)
 674 {
 675   int i;
 676   bool msg;
 677   int skip;
 678
 679   llassert (fileTable_isDefined (ft));
 680
 681   msg = ((ft->nentries > 40) && context_getFlag (FLG_SHOWSCAN));
 682   skip = ft->nentries / 10;
 683
 684   if (msg)
 685     {
 686       (void) fflush (g_warningstream);
 687       displayScanOpen (cstring_makeLiteral ("cleaning"));
 688     }
 689
 690   for (i = 0; i < ft->nentries; i++)
 691     {
 692       ftentry fe = ft->elements[i];
 693
 694       if (fe->ftemp)
 695         {
 696           /* let's be real careful now, hon! */
 697
 698           switch (fe->ftype) {
 699             case FILE_NODELETE:
 700               break; /* nothing to do */
 701
 702             case FILE_LSLTEMP:
 703               break; /* already removed */
 704
 705             case FILE_MACROS:
 706               goto delete;
 707
 708             default:
 709               /*
 710               ** Make sure it is really a derived file
 711               */
 712               if (fileId_isValid (fe->fder))
 713                 {
 714                 delete:
 715                   /* this should use close (fd) also... */
 716                   (void) osd_unlink (fe->fname);
 717                 }
 718               else
 719                 {
 720                   llbug (message ("Temporary file is not derivative: %s "
 721                         "(not deleted)", fe->fname));
 722                 }
 723           }
 724         }
 725       else
 726         {
 727           ;
 728         }
 729
 730       if (msg && ((i % skip) == 0))
 731         {
 732           displayScanContinue (cstring_makeLiteral (i == 0 ? " " : "."));
 733         }
 734     }
 735
 736   if (msg)
 737     {
 738       displayScanClose ();
 739     }
 740 }
 741
 742 void
 743 fileTable_free (/*@only@*/ fileTable f)
 744 {
 745   int i = 0;
 746
 747   if (f == (fileTable)NULL)
 748     {
 749       return;
 750     }
 751
 752   while ( i < f->nentries )
 753     {
 754       ftentry_free (f->elements[i]);
 755       i++;
 756     }
 757
 758   cstringTable_free (f->htable);
 759   sfree (f->elements);
 760   sfree (f->openelements); /*!! why didn't splint report this? */
 761   sfree (f);
 762 }
 763
 764 /*
 765 ** unique temp filename are constructed from <dir><pre><pid><msg>.<suf>
 766 ** requires: <dir> must end in '/'
 767 */
 768
 769 static void nextMsg (char *msg)
 770 {
 771   /*@+charint@*/
 772   if (msg[0] < 'Z')
 773     {
 774       msg[0]++;
 775     }
 776   else
 777     {
 778       msg[0] = 'A';
 779       if (msg[1] < 'Z')
 780         {
 781           msg[1]++;
 782         }
 783       else
 784         {
 785           msg[1] = 'A';
 786           if (msg[2] < 'Z')
 787             {
 788               msg[2]++;
 789             }
 790           else
 791             {
 792               msg[2] = 'A';
 793               if (msg[3] < 'Z')
 794                 {
 795                   msg[3]++;
 796                 }
 797               else
 798                 {
 799                   llassertprint (FALSE, ("nextMsg: out of unique names!!!"));
 800                 }
 801             }
 802         }
 803     }
 804   /*@-charint@*/
 805 }
 806
 807 static /*@only@*/ cstring makeTempName (cstring pre, cstring suf)
 808 {
 809   static /*@owned@*/ char *msg = NULL;
 810   static /*@only@*/ cstring pidname = cstring_undefined;
 811   static cstring dir = cstring_undefined;
 812   cstring smsg;
 813
 814   llassert (cstring_length (pre) <= 3);
 815
 816   /*
 817   ** We limit the temp name to 8 characters:
 818   **   pre: 3 or less
 819   **   msg: 3
 820   **   pid: 2  (% 100)
 821   */
 822
 823   if (msg == NULL)
 824     {
 825       msg = mstring_copy ("AAA"); /* there are 26^3 temp names */
 826     }
 827
 828   if (cstring_isUndefined (pidname))
 829     {
 830       pidname = message ("%d", osd_getPid () % 100);
 831     }
 832
 833   if (cstring_isUndefined (dir))
 834     {
 835       dir = context_tmpdir ();
 836     }
 837
 838   DPRINTF (("Dir: %s / %s / %s / %s / %s", dir, pre, pidname, msg, suf));
 839
 840   smsg = message ("%s%s%s%s%s", dir, pre, pidname, cstring_fromChars (msg), suf);
 841   nextMsg (msg);
 842
 843   DPRINTF (("Trying: %s", smsg));
 844
 845   while (osd_fileExists (smsg))
 846     {
 847       cstring_free (smsg);
 848       smsg = message ("%s%s%s%s%s", dir, pre, pidname, cstring_fromChars (msg), suf);
 849       nextMsg (msg);
 850     }
 851
 852   return smsg;
 853 }
 854
 855 static foentry
 856 foentry_create (/*@exposed@*/ FILE *f, /*@only@*/ cstring fname)
 857 {
 858   foentry t = (foentry) dmalloc (sizeof (*t));
 859   t->f = f;
 860   t->fname = fname;
 861   return t;
 862 }
 863
 864 static void
 865 foentry_free (/*@only@*/ foentry foe)
 866 {
 867   cstring_free (foe->fname);
 868   sfree (foe);
 869 }
 870
 871 static void
 872 fileTable_addOpen (fileTable ft, /*@observer@*/ FILE *f, /*@only@*/ cstring fname)
 873 {
 874   llassert (fileTable_isDefined (ft));
 875
 876   if (ft->nopenspace <= 0)
 877     {
 878       fileTable_growOpen (ft);
 879     }
 880
 881   ft->nopenspace--;
 882   ft->openelements[ft->nopen] = foentry_create (f, fname);
 883   ft->nopen++;
 884 }
 885
 886 FILE *fileTable_createTempFile (fileTable ft, cstring fname, bool read)
 887 {
 888   FILE *res = osd_createTmpFile(fname, read);
 889
 890   if (res != NULL)
 891     {
 892       fileTable_addOpen (ft, res, cstring_copy (fname));
 893       DPRINTF (("Opening file: %s / %p", fname, res));
 894     }
 895   else
 896     {
 897       DPRINTF (("Error opening: %s", fname));
 898     }
 899
 900   return res;
 901 }
 902
 903 FILE *fileTable_openReadFile (fileTable ft, cstring fname)
 904 {
 905   FILE *res = fopen (cstring_toCharsSafe (fname), "r");
 906
 907   if (res != NULL)
 908     {
 909       fileTable_addOpen (ft, res, cstring_copy (fname));
 910       DPRINTF (("Opening read file: %s / %p", fname, res));
 911     }
 912   else
 913     {
 914       DPRINTF (("Cannot open read file: %s", fname));
 915     }
 916
 917   return res;
 918 }
 919
 920 /*
 921 ** Allows overwriting
 922 */
 923
 924 FILE *fileTable_openWriteFile (fileTable ft, cstring fname)
 925 {
 926   FILE *res = fopen (cstring_toCharsSafe (fname), "w");
 927
 928   if (res != NULL) {
 929     fileTable_addOpen (ft, res, cstring_copy (fname));
 930     DPRINTF (("Opening file: %s / %p", fname, res));
 931   }
 932
 933   return res;
 934 }
 935
 936 FILE *fileTable_openWriteUpdateFile (fileTable ft, cstring fname)
 937 {
 938   FILE *res = fopen (cstring_toCharsSafe (fname), "w+");
 939
 940   if (res != NULL) {
 941     fileTable_addOpen (ft, res, cstring_copy (fname));
 942     DPRINTF (("Opening file: %s / %p", fname, res));
 943   }
 944
 945   return res;
 946 }
 947
 948 bool fileTable_closeFile (fileTable ft, FILE *f)
 949 {
 950   bool foundit = FALSE;
 951   int i = 0;
 952
 953   llassert (fileTable_isDefined (ft));
 954
 955   DPRINTF (("Closing file: %p", f));
 956
 957   for (i = 0; i < ft->nopen; i++)
 958     {
 959       if (ft->openelements[i]->f == f)
 960         {
 961           DPRINTF (("Closing file: %p = %s", f, ft->openelements[i]->fname));
 962
 963           if (i == ft->nopen - 1)
 964             {
 965               foentry_free (ft->openelements[i]);
 966               ft->openelements[i] = NULL;
 967             }
 968           else
 969             {
 970               foentry_free (ft->openelements[i]);
 971               ft->openelements[i] = ft->openelements[ft->nopen - 1];
 972               ft->openelements[ft->nopen - 1] = NULL;
 973             }
 974
 975           ft->nopen--;
 976           ft->nopenspace++;
 977           foundit = TRUE;
 978           break;
 979         }
 980     }
 981
 982   llassert (foundit);
 983   return (fclose (f) == 0);
 984 }
 985
 986 void fileTable_closeAll (fileTable ft)
 987 {
 988   int i = 0;
 989
 990   llassert (fileTable_isDefined (ft));
 991
 992   for (i = 0; i < ft->nopen; i++)
 993     {
 994       /*
 995          lldiagmsg (message ("Unclosed file at exit: %s", ft->openelements[i]->fname));
 996       */
 997
 998       if (ft->openelements[i]->f != NULL)
 999         {
1000           (void) fclose (ft->openelements[i]->f); /* No check - cleaning up after errors */
1001         }
1002
1003       ft->openelements[i]->f = NULL;
1004       foentry_free (ft->openelements[i]);
1005       ft->openelements[i] = NULL;
1006     }
1007
1008   ft->nopenspace += ft->nopen;
1009   ft->nopen = 0;
1010 }
1011