src/enumNameList.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 ** enumNameList.c
  26 **
  27 ** based on list_template.c
  28 **
  29 ** where T has T_equal (or change this) and T_unparse
  30 **
  31 ** used to be cenum.c
  32 */
  33
  34 # include "splintMacros.nf"
  35 # include "basic.h"
  36
  37
  38 /*@constant int enumNameListBASESIZE;@*/
  39 # define enumNameListBASESIZE SMALLBASESIZE
  40
  41 enumNameList
  42 enumNameList_new (void)
  43 {
  44   enumNameList s = (enumNameList) dmalloc (sizeof (*s));
  45
  46   s->nelements = 0;
  47   s->nspace = enumNameListBASESIZE;
  48   s->elements = (enumName *)
  49     dmalloc (sizeof (*s->elements) * enumNameListBASESIZE);
  50
  51   return (s);
  52 }
  53
  54 /*@only@*/ enumNameList
  55 enumNameList_single (/*@keep@*/ enumName t)
  56 {
  57   enumNameList s = (enumNameList) dmalloc (sizeof (*s));
  58
  59   s->nelements = 1;
  60   s->nspace = enumNameListBASESIZE - 1;
  61   s->elements = (enumName *) dmalloc (sizeof (*s->elements) * enumNameListBASESIZE);
  62           s->elements[0] = t;
  63
  64   return (s);
  65 }
  66
  67 bool
  68 enumNameList_match (enumNameList e1, enumNameList e2)
  69 {
  70   int i;
  71
  72   if (e1->nelements != e2->nelements) return FALSE;
  73
  74   for (i = 0; i < e1->nelements; i++)
  75     {
  76                               if (!cstring_equal (e1->elements[i], e2->elements[i]))
  77         return FALSE;
  78     }
  79   return TRUE;
  80 }
  81
  82 static void
  83 enumNameList_grow (enumNameList s)
  84 {
  85   int i;
  86   enumName *newelements;
  87
  88   s->nspace += enumNameListBASESIZE;
  89   newelements = (enumName *) dmalloc (sizeof (*newelements) * (s->nelements + s->nspace));
  90
  91   if (newelements == (enumName *) 0)
  92     {
  93       llfatalerror (cstring_makeLiteral ("enumNameList_grow: out of memory!"));
  94     }
  95
  96   for (i = 0; i < s->nelements; i++)
  97     {
  98                               newelements[i] = s->elements[i];
  99     }
 100
 101   sfree (s->elements);
 102   s->elements = newelements;
 103 }
 104
 105 void
 106 enumNameList_addh (enumNameList s, /*@keep@*/ enumName el)
 107 {
 108   if (s->nspace <= 0)
 109     enumNameList_grow (s);
 110
 111   s->nspace--;
 112     s->elements[s->nelements] = el;
 113   s->nelements++;
 114 }
 115
 116 enumNameList
 117 enumNameList_push (/*@returned@*/ enumNameList s, /*@only@*/ enumName el)
 118 {
 119   enumNameList_addh (s, el);
 120   return s;
 121 }
 122
 123 #ifdef DEADCODE
 124 /*@only@*/ enumNameList
 125 enumNameList_copy (enumNameList s)
 126 {
 127   enumNameList r = enumNameList_new ();
 128
 129   enumNameList_elements (s, x)
 130   {
 131     enumNameList_addh (r, cstring_copy (x));
 132   } end_enumNameList_elements;
 133
 134   return r;
 135 }
 136 #endif
 137
 138 bool
 139 enumNameList_member (enumNameList s, cstring m)
 140 {
 141   enumNameList_elements (s, x)
 142   {
 143     if (cstring_equal (m, x)) return TRUE;
 144   } end_enumNameList_elements;
 145
 146   return FALSE;
 147 }
 148
 149 /*@only@*/ enumNameList
 150 enumNameList_subtract (enumNameList source, enumNameList del)
 151 {
 152   enumNameList ret = enumNameList_new ();
 153
 154   enumNameList_elements (source, el)
 155     {
 156       if (!enumNameList_member (del, el))
 157         {
 158           enumNameList_addh (ret, cstring_copy (el));
 159         }
 160     } end_enumNameList_elements;
 161
 162   return ret;
 163 }
 164
 165 cstring
 166 enumNameList_unparse (enumNameList s)
 167 {
 168   int i;
 169   cstring st = cstring_undefined;
 170
 171   for (i = 0; i < s->nelements; i++)
 172     {
 173       if (i == 0)
 174         {
 175                           st = cstring_copy (s->elements[i]);
 176         }
 177       else
 178         {
 179                           st = message ("%q, %s", st, s->elements[i]);
 180         }
 181     }
 182
 183   return st;
 184 }
 185
 186 cstring enumNameList_unparseBrief (enumNameList s)
 187 {
 188   int i;
 189   cstring st = cstring_undefined;
 190
 191   for (i = 0; i < s->nelements; i++)
 192     {
 193       if (i == 0)
 194         {
 195                           st = cstring_copy (s->elements[i]);
 196         }
 197       else if (i == 3 && s->nelements > 5)
 198         {
 199           st = message ("%q, ...", st);
 200           i = s->nelements - 2;
 201         }
 202       else
 203         {
 204                           st = message ("%q, %s", st, s->elements[i]);
 205         }
 206     }
 207
 208   return st;
 209 }
 210
 211 /*@only@*/ cstring
 212 enumNameList_dump (enumNameList s)
 213 {
 214   int i;
 215   cstring st = cstring_undefined;
 216
 217   for (i = 0; i < s->nelements; i++)
 218     {
 219       if (i == 0)
 220         {
 221                           st = cstring_copy (s->elements[i]);
 222         }
 223       else
 224                 st = message ("%q,%s", st, s->elements[i]);
 225     }
 226   return st;
 227 }
 228
 229 /*@only@*/ enumNameList
 230 enumNameList_undump (d_char *s)
 231 {
 232   enumNameList e = enumNameList_new ();
 233
 234   if (**s == '}')
 235     (*s)++;
 236   else
 237     {
 238       while (TRUE)
 239         {
 240           char *t = strchr (*s, ',');
 241           char mt;
 242
 243           if (t == NULL)
 244             {
 245               t = strchr (*s, '}');
 246
 247               if (t == NULL)
 248                 {
 249                   llcontbug (message ("enumNameList_undump: bad line: %s", cstring_fromChars (*s)));
 250                   return e;
 251                 }
 252             }
 253
 254           mt = *t;
 255           *t = '\0';
 256
 257           enumNameList_addh (e, cstring_fromChars (mstring_copy (*s)));
 258           *s = t + 1;
 259           if (mt == '}')
 260             break;
 261         }
 262     }
 263   return e;
 264 }
 265
 266 void
 267 enumNameList_free (enumNameList s)
 268 {
 269   int i;
 270
 271
 272   for (i = 0; i < s->nelements; i++)
 273     {
 274       cstring_free (s->elements[i]);
 275     }
 276
 277   sfree (s->elements);
 278   sfree (s);
 279 }
 280
 281