src/cstringList.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 ** cstringList.c
  26 **
  27 ** based on list_template.c
  28 **
  29 ** where T has T_equal (or change this) and T_unparse
  30 */
  31
  32 # include "splintMacros.nf"
  33 # include "basic.h"
  34
  35 cstringList
  36 cstringList_new (void)
  37 {
  38   return cstringList_undefined;
  39 }
  40
  41 static /*@notnull@*/ cstringList
  42 cstringList_newEmpty (void)
  43 {
  44   cstringList s = (cstringList) dmalloc (sizeof (*s));
  45
  46   s->nelements = 0;
  47   s->nspace = cstringListBASESIZE;
  48   s->elements = (cstring *) dmalloc (sizeof (*s->elements) * cstringListBASESIZE);
  49
  50   return (s);
  51 }
  52
  53 static /*@notnull@*/ cstringList
  54 cstringList_newPredict (int size)
  55 {
  56   cstringList s = (cstringList) dmalloc (sizeof (*s));
  57
  58   s->nelements = 0;
  59   s->nspace = size;
  60   s->elements = (cstring *) dmalloc (sizeof (*s->elements) * size);
  61
  62   return (s);
  63 }
  64
  65 static void
  66 cstringList_grow (/*@notnull@*/ cstringList s)
  67 {
  68   int i;
  69   cstring *newelements;
  70
  71   s->nspace += cstringListBASESIZE;
  72
  73   newelements = (cstring *) dmalloc (sizeof (*newelements)
  74                                      * (s->nelements + s->nspace));
  75
  76
  77   if (newelements == (cstring *) 0)
  78     {
  79       llfatalerror (cstring_makeLiteral ("cstringList_grow: out of memory!"));
  80     }
  81
  82   for (i = 0; i < s->nelements; i++)
  83     {
  84       newelements[i] = s->elements[i];
  85     }
  86
  87   sfree (s->elements);
  88   s->elements = newelements;
  89 }
  90
  91 cstringList cstringList_single (/*@keep@*/ cstring el)
  92 {
  93   cstringList s = cstringList_new ();
  94   s = cstringList_add (s, el);
  95   return s;
  96 }
  97
  98 cstringList cstringList_add (cstringList s, /*@keep@*/ cstring el)
  99 {
 100   if (!cstringList_isDefined (s))
 101     {
 102       s = cstringList_newEmpty ();
 103     }
 104
 105   if (s->nspace <= 0)
 106     {
 107       cstringList_grow (s);
 108     }
 109
 110   s->nspace--;
 111   s->elements[s->nelements] = el;
 112   s->nelements++;
 113
 114   return s;
 115 }
 116
 117 cstringList cstringList_prepend (cstringList s, /*@keep@*/ cstring el)
 118 {
 119   int i;
 120
 121   DPRINTF (("Prepend:  %s + %s",
 122             cstringList_unparse (s), cstring_toCharsSafe (el)));
 123
 124   if (!cstringList_isDefined (s))
 125     {
 126       return cstringList_single (el);
 127     }
 128
 129   if (s->nspace <= 0)
 130     {
 131       cstringList_grow (s);
 132     }
 133
 134   s->nspace--;
 135
 136   for (i = s->nelements; i > 0; i--)
 137     {
 138       s->elements[i] = s->elements [i - 1];
 139     }
 140
 141   s->elements[0] = el;
 142   s->nelements++;
 143
 144   return s;
 145 }
 146
 147 cstring
 148 cstringList_unparse (cstringList s)
 149 {
 150   return cstringList_unparseSep (s, cstring_makeLiteralTemp (", "));
 151 }
 152
 153 cstring
 154 cstringList_unparseSep (cstringList s, cstring sep)
 155 {
 156    cstring st = cstring_undefined;
 157
 158    if (cstringList_isDefined (s))
 159      {
 160        int i;
 161
 162        for (i = 0; i < s->nelements; i++)
 163          {
 164            if (i == 0)
 165              {
 166                st = cstring_copy (s->elements[i]);
 167              }
 168            else
 169              st = message ("%q%s%s", st, sep, s->elements[i]);
 170          }
 171      }
 172
 173    return st;
 174 }
 175
 176 # ifdef DEADCODE
 177 void
 178 cstringList_printSpaced (cstringList s, size_t indent, size_t gap, int linelen)
 179 {
 180   if (cstringList_isDefined (s))
 181     {
 182       cstring line = cstring_undefined;
 183       cstring istring = cstring_fill (cstring_undefined, indent);
 184       cstring gstring = cstring_fill (cstring_undefined, gap);
 185       int numcol;
 186       size_t longest = 0;
 187       int i;
 188
 189       /*
 190       ** find the longest string
 191       */
 192
 193       for (i = 0; i < s->nelements; i++)
 194         {
 195           size_t len = cstring_length (s->elements[i]);
 196
 197           if (len > longest)
 198             {
 199               longest = len;
 200             }
 201         }
 202
 203       numcol = size_toInt ((linelen - indent) / (longest + gap));
 204
 205       if (numcol <= 1)
 206         {
 207           numcol = 1;
 208         }
 209
 210       for (i = 0; i < s->nelements; i++)
 211         {
 212           if (i % numcol == 0)
 213             {
 214               if (i != 0)
 215                 {
 216                   llmsg (line);
 217                 }
 218
 219               line = message ("%s%q", istring,
 220                               cstring_fill (s->elements[i], longest));
 221             }
 222           else
 223             {
 224               line = message ("%q%s%q", line, gstring,
 225                               cstring_fill (s->elements[i], longest));
 226             }
 227         }
 228
 229       cstring_free (line);
 230       cstring_free (istring);
 231       cstring_free (gstring);
 232     }
 233 }
 234
 235 /*@only@*/ cstring
 236 cstringList_unparseAbbrev (cstringList s)
 237 {
 238    cstring st = cstring_undefined;
 239
 240    if (cstringList_isDefined (s))
 241      {
 242        int i;
 243
 244        for (i = 0; i < s->nelements; i++)
 245          {
 246            if (i == 0)
 247              {
 248                st = cstring_copy (s->elements[i]);
 249              }
 250            else if (i > 3 && s->nelements > 5)
 251              {
 252                st = message ("%q, ...", st);
 253                break;
 254              }
 255            else
 256              {
 257                st = message ("%q, %s", st, s->elements[i]);
 258              }
 259          }
 260      }
 261
 262    return st;
 263 }
 264 # endif /* DEADCODE */
 265
 266 void
 267 cstringList_free (cstringList s)
 268 {
 269   if (cstringList_isDefined (s))
 270     {
 271       int i;
 272
 273       DPRINTF (("cstringList free: [%p] %s",
 274                 s, cstringList_unparse (s)));
 275
 276       /* evans 2002-07-12: this was missing, not detected because of reldef */
 277       for (i = 0; i < s->nelements; i++)
 278         {
 279           cstring_free (s->elements[i]);
 280         }
 281
 282       sfree (s->elements);
 283       sfree (s);
 284     }
 285 }
 286
 287 # ifdef DEADCODE
 288 void
 289 cstringList_alphabetize (cstringList s)
 290 {
 291   if (cstringList_isDefined (s))
 292     {
 293       /*@-modobserver@*/
 294       qsort (s->elements, (size_t) s->nelements,
 295              sizeof (*s->elements), (int (*)(const void *, const void *)) cstring_xcompare);
 296       /*@=modobserver@*/
 297     }
 298 }
 299 # endif /* DEADCODE */
 300
 301 int cstringList_getIndex (cstringList s, cstring key)
 302 {
 303   int index = 0;
 304
 305   cstringList_elements (s, el)
 306     {
 307       if (cstring_equal (el, key))
 308         {
 309           return index;
 310         }
 311
 312       index++;
 313     } end_cstringList_elements ;
 314
 315   BADBRANCHRET (0);
 316 }
 317
 318 bool cstringList_contains (cstringList s, cstring key)
 319 {
 320   int index = 0;
 321
 322   cstringList_elements (s, el)
 323     {
 324       if (cstring_equal (el, key))
 325         {
 326           return TRUE;
 327         }
 328
 329       index++;
 330     } end_cstringList_elements ;
 331
 332   return FALSE;
 333 }
 334
 335 cstringList cstringList_copy (cstringList s)
 336 {
 337   cstringList res = cstringList_newPredict (cstringList_size (s));
 338
 339   cstringList_elements (s, el)
 340     {
 341       res = cstringList_add (res, cstring_copy (el));
 342     } end_cstringList_elements ;
 343
 344   return res;
 345 }
 346
 347 cstring
 348 cstringList_get (cstringList s, int index)
 349 {
 350   llassertretval (s != NULL, cstring_undefined);
 351   llassertretval (index >= 0, cstring_undefined);
 352   llassertretval (index < s->nelements, cstring_undefined);
 353   return s->elements[index];
 354 }
 355
 356 ob_cstring *
 357 cstringList_getElements (cstringList s)
 358 {
 359   if (cstringList_isDefined (s))
 360     {
 361       /*@-compmempass@*/
 362       return s->elements;
 363       /*@=compmempass@*/ /* This is exposed */
 364     }
 365   else
 366     {
 367       return NULL;
 368     }
 369 }