src/lslsyntable.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 ** lslsyntable.c
  26 **
  27 ** Larch shared language synonym table
  28 **
  29 **      This table stores synonyms for the Larch Shared Language.  It is
  30 **      essentially a array of token-handles indexed by string-handles.
  31 **      Therefore, synonyms (strings) can be converted to the actual token.
  32 **
  33 **  AUTHORS:
  34 **      J.P. Wild
  35 */
  36
  37 # include "splintMacros.nf"
  38 # include "basic.h"
  39
  40 # include "lsltokentable.h"
  41 # include "lslsyntable.h"
  42
  43 /*@+ignorequals@*/
  44
  45 typedef lsymbol *lsymbolTable;
  46
  47 static /*@only@*/ /*@null@*/ lsymbolTable SynTable;
  48 static unsigned long int SynTableEntries;
  49
  50 static void SynTable_grow (int p_size);
  51
  52 /*
  53 **++
  54 **  FUNCTION NAME:
  55 **
  56 **      LSLAddSyn ()
  57 **
  58 **  FORMAL PARAMETERS:
  59 **
  60 **      otok  - token-handle for token associated with oldToken
  61 **      ntok  - string-handle for the string to be a synonym with oldToken.
  62 **
  63 **  RETURN VALUE:
  64 **
  65 **  INVARIANTS:
  66 **
  67 **      A context must be established.
  68 **
  69 **  DESCRIPTION:
  70 **
  71 **    This routine inserts a synonym into the synonym table.  The synonym table
  72 **    is used to define synonyms in the form:
  73 **
  74 **          synonym oldToken newToken
  75 **
  76 **    The table associates the string for newToken with the token for oldToken.
  77 **    This table is used to find the the actual token (oldToken) from a synonym
  78 **    string (newToken).
  79 **
  80 **    A new SynTable is allocated when:
  81 **      . The SynTable[] is empty (initial case)
  82 **      . The location where to insert the synonym is not in SynTable[]
  83 **
  84 **  IMPLICIT INPUTS/OUTPUT:
  85 **
  86 **    SynTable      - (input/output) SynTable array
  87 **
  88 **  EXCEPTIONS:
  89 **    A synonym already exists at the location where the it is to be added.
  90 **
  91 **--
  92 */
  93
  94 void
  95 LSLAddSyn (lsymbol ntok, lsymbol otok)
  96 {
  97   if (ntok >= SynTableEntries) /* was otok */
  98     {
  99       SynTable_grow (otok);
 100     }
 101
 102   llassert (SynTable != NULL);
 103
 104   if (SynTable[ntok] == (lsymbol) 0)
 105     {                           /* Entry is empty. Fill it in. */
 106       SynTable[ntok] = otok;
 107       LSLSetTokenHasSyn (otok, TRUE);   /* Mark oldToken as having a synonym. */
 108     }
 109   else
 110     {
 111       llbuglit ("LSLAddSyn: duplicate SynTable entry");
 112     }
 113 }
 114
 115 /*@exposed@*/ ltoken
 116 LSLGetTokenForSyn (lsymbol ntok)
 117 {
 118   llassert (SynTable != NULL);
 119   llassert (!(!((ntok < SynTableEntries) || (SynTable[ntok] != 0))));
 120
 121   return LSLGetToken (SynTable[ntok]);
 122 }
 123
 124 bool
 125 LSLIsSyn (lsymbol str)
 126 {
 127   if (str < SynTableEntries)
 128     {
 129       llassert (SynTable != NULL);
 130       return (SynTable[str] != 0);
 131     }
 132   else
 133     {
 134       return FALSE;
 135     }
 136 }
 137
 138 static void
 139 SynTable_grow (int size)
 140 {
 141   int oldSize;
 142   int i;
 143   lsymbolTable oldSynTable = SynTable;
 144
 145   llassert (oldSynTable != NULL);
 146   oldSize = SynTableEntries;
 147
 148   if (size <= oldSize)
 149     {
 150       llcontbuglit ("SynTable_grow: goal size is smaller than oldSize");
 151       return;
 152     }
 153
 154   if (size < (oldSize + SYNTABLE_BASESIZE))
 155     {
 156       size = oldSize + SYNTABLE_BASESIZE;
 157     }
 158
 159   SynTable = (lsymbolTable) dmalloc (size * sizeof (*SynTable));
 160   SynTableEntries = size;
 161
 162   for (i = 0; i < oldSize; i++)
 163     {
 164       SynTable[i] = oldSynTable[i];
 165     }
 166
 167   /* Zero out new allocated space.  Need to detect when cells are empty   */
 168   /* and do this by checking that SynTable[x] == 0.                       */
 169
 170   /*@+loopexec@*/
 171   for (i = oldSize; i < size; i++)
 172     {
 173       SynTable[i] = (lsymbol) 0;
 174     }
 175   /*@=loopexec@*/
 176
 177   sfree (oldSynTable);
 178 /*@-compdef@*/ } /*=compdef@*/
 179
 180 void
 181 lsynTableInit (void) /*@globals undef SynTable; @*/
 182 {
 183   int i;
 184
 185   SynTable = (lsymbolTable) dmalloc (sizeof (*SynTable) * SYNTABLE_BASESIZE);
 186
 187   /*@+loopexec@*/
 188   for (i = 0; i < SYNTABLE_BASESIZE; i++)
 189     {
 190       SynTable[i] = (lsymbol) 0;
 191     }
 192   /*@=loopexec@*/
 193
 194   SynTableEntries = SYNTABLE_BASESIZE;
 195 /*@-compdef@*/ } /*@=compdef@*/
 196
 197 void
 198 lsynTableReset (void)
 199 {
 200 }
 201
 202 void
 203 lsynTableCleanup (void)
 204 {
 205   sfree (SynTable);
 206   SynTable = NULL;
 207 }
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219