src/multiVal.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 ** multiVal.c
  26 */
  27
  28 # include "splintMacros.nf"
  29 # include "basic.h"
  30
  31 /*@only@*/ multiVal multiVal_unknown (void)
  32 {
  33   return multiVal_undefined;
  34 }
  35
  36 static /*@special@*/ /*@notnull@*/ multiVal multiVal_create (mvkind kind)
  37    /*@defines result->kind@*/
  38 {
  39   multiVal mv = (multiVal) dmalloc (sizeof (*mv));
  40
  41   mv->kind = kind;
  42   return mv;
  43 }
  44
  45 /*@only@*/ multiVal multiVal_makeInt (long x)
  46 {
  47   multiVal mv = multiVal_create (MVLONG);
  48
  49   mv->value.ival = x;
  50   return mv;
  51 }
  52
  53 /*@only@*/ multiVal multiVal_makeChar (char x)
  54 {
  55   multiVal mv = multiVal_create (MVCHAR);
  56   mv->value.cval = x;
  57   return mv;
  58 }
  59
  60 /*@only@*/ multiVal multiVal_makeDouble (double x)
  61 {
  62   multiVal mv = multiVal_create (MVDOUBLE);
  63
  64     mv->value.fval = x;
  65     return mv;
  66 }
  67
  68 /*@only@*/ multiVal multiVal_makeString (/*@only@*/ cstring s)
  69 {
  70   multiVal mv = multiVal_create (MVSTRING);
  71
  72   mv->value.sval = s;
  73   return mv;
  74 }
  75
  76
  77 /*@only@*/ multiVal multiVal_copy (multiVal m)
  78 {
  79   multiVal r;
  80
  81   if (multiVal_isUndefined (m))
  82     {
  83       return multiVal_undefined;
  84     }
  85
  86   r = multiVal_create (m->kind);
  87
  88   switch (m->kind)
  89     {
  90     case MVLONG:
  91       r->value.ival = m->value.ival;
  92       break;
  93     case MVCHAR:
  94       r->value.cval = m->value.cval;
  95       break;
  96     case MVDOUBLE:
  97       r->value.fval = m->value.fval;
  98       break;
  99     case MVSTRING:
 100       r->value.sval = cstring_copy (m->value.sval);
 101       break;
 102     }
 103
 104   return r;
 105 }
 106
 107 multiVal multiVal_invert (multiVal m)
 108 {
 109   if (multiVal_isUndefined (m))
 110     {
 111       return multiVal_undefined;
 112     }
 113
 114   switch (m->kind)
 115     {
 116     case MVLONG:
 117       return multiVal_makeInt (-1 * m->value.ival);
 118     case MVCHAR:
 119       BADBRANCHCONT;
 120       return multiVal_undefined;
 121     case MVDOUBLE:
 122       return multiVal_makeDouble (-1.0 * m->value.fval);
 123     case MVSTRING:
 124       BADBRANCHCONT;
 125       return multiVal_undefined;
 126     }
 127
 128   BADEXIT;
 129 }
 130
 131 long multiVal_forceInt (multiVal m)
 132 {
 133   if (multiVal_isInt (m)) {
 134     return m->value.ival;
 135   } else {
 136     llcontbug (message ("Multival is not int: %s", multiVal_unparse (m)));
 137     return 0;
 138   }
 139 }
 140
 141 char multiVal_forceChar (multiVal m)
 142 {
 143   llassert (multiVal_isChar (m));
 144
 145   return m->value.cval;
 146 }
 147
 148 # ifdef DEADCODE
 149 double multiVal_forceDouble (multiVal m)
 150 {
 151   llassert (multiVal_isDouble (m));
 152
 153   return m->value.fval;
 154 }
 155 # endif /* DEADCODE */
 156
 157 /*@dependent@*/ /*@observer@*/ cstring multiVal_forceString (multiVal m)
 158 {
 159   llassert (multiVal_isString (m));
 160
 161   return m->value.sval;
 162 }
 163
 164 bool multiVal_isInt (multiVal m)
 165 {
 166   return (multiVal_isDefined (m) && m->kind == MVLONG);
 167 }
 168
 169 bool multiVal_isChar (multiVal m)
 170 {
 171   return (multiVal_isDefined (m) && m->kind == MVCHAR);
 172 }
 173
 174 bool multiVal_isDouble (multiVal m)
 175 {
 176   return (multiVal_isDefined (m) && m->kind == MVDOUBLE);
 177 }
 178
 179 bool multiVal_isString (multiVal m)
 180 {
 181   return (multiVal_isDefined (m) && m->kind == MVSTRING);
 182 }
 183
 184 /*@only@*/ cstring multiVal_unparse (multiVal m)
 185 {
 186   if (multiVal_isDefined (m))
 187     {
 188       switch (m->kind)
 189         {
 190         case MVLONG:
 191           return message ("%d", (int)m->value.ival);
 192         case MVCHAR:
 193                   return message ("'%h'", m->value.cval);
 194         case MVDOUBLE:
 195           return message ("%f", (float)m->value.fval);
 196         case MVSTRING:
 197           return message ("%s", m->value.sval);
 198         }
 199       BADEXIT;
 200     }
 201   else
 202     {
 203       return (cstring_makeLiteral ("?"));
 204     }
 205 }
 206
 207 /*@only@*/ cstring multiVal_dump (multiVal m)
 208 {
 209   if (multiVal_isDefined (m))
 210     {
 211       switch (m->kind)
 212         {
 213         case MVLONG:
 214           return (message ("i%d", (int)m->value.ival));
 215         case MVCHAR:
 216           return (message ("c%d", (int)m->value.cval));
 217         case MVDOUBLE:
 218           return (message ("d%f", (float)m->value.fval));
 219         case MVSTRING:
 220           return (message ("s%s", m->value.sval));
 221         }
 222       BADEXIT;
 223     }
 224   else
 225     {
 226       return (cstring_undefined);
 227     }
 228 }
 229
 230 /*@only@*/ multiVal multiVal_undump (char **s)
 231 {
 232   char tchar = **s;
 233
 234   switch (tchar)
 235     {
 236     case 'i':
 237       (*s)++;
 238       return multiVal_makeInt (reader_getInt (s));
 239     case 'c':
 240       (*s)++;
 241       return multiVal_makeChar ((char) reader_getInt (s));
 242     case 'd':
 243       (*s)++;
 244       return multiVal_makeDouble (reader_getDouble (s));
 245     case 's':
 246       {
 247         cstring st = cstring_undefined;
 248
 249         (*s)++;
 250         while (**s != '#')
 251           {
 252             st = cstring_appendChar (st, **s);
 253             (*s)++;
 254           }
 255
 256         return multiVal_makeString (st);
 257       }
 258     case '@':
 259     case '#':
 260       return multiVal_unknown ();
 261     BADDEFAULT;
 262     }
 263
 264   BADEXIT;
 265 }
 266
 267 int multiVal_compare (multiVal m1, multiVal m2)
 268 {
 269   if (multiVal_isUndefined (m1))
 270     {
 271       if (multiVal_isUndefined (m2))
 272         {
 273           return 0;
 274         }
 275
 276       else return -1;
 277     }
 278   if (multiVal_isUndefined (m2))
 279     {
 280       return -1;
 281     }
 282
 283   COMPARERETURN (generic_compare (m1->kind, m2->kind));
 284
 285   switch (m1->kind)
 286     {
 287     case MVLONG:   return (generic_compare (m1->value.ival, m2->value.ival));
 288     case MVCHAR:   return (generic_compare (m1->value.cval, m2->value.cval));
 289     case MVDOUBLE: return (generic_compare (m1->value.fval, m2->value.fval));
 290     case MVSTRING: return (cstring_compare (m1->value.sval, m2->value.sval));
 291     }
 292
 293   BADEXIT;
 294 }
 295
 296 multiVal multiVal_add (multiVal m1, multiVal m2)
 297 {
 298   if (multiVal_isUndefined (m1) || multiVal_isUndefined (m2) || m1->kind != m2->kind)
 299     {
 300       return multiVal_undefined;
 301     }
 302
 303   switch (m1->kind)
 304     {
 305     case MVLONG:   return (multiVal_makeInt (m1->value.ival + m2->value.ival));
 306     case MVCHAR:   return (multiVal_makeChar ((char) (m1->value.cval + m2->value.cval)));
 307     case MVDOUBLE: return (multiVal_makeDouble (m1->value.fval + m2->value.fval));
 308     case MVSTRING: return multiVal_undefined;
 309     }
 310
 311   BADEXIT;
 312 }
 313
 314 multiVal multiVal_subtract (multiVal m1, multiVal m2)
 315 {
 316   if (multiVal_isUndefined (m1) || multiVal_isUndefined (m2) || m1->kind != m2->kind)
 317     {
 318       return multiVal_undefined;
 319     }
 320
 321   switch (m1->kind)
 322     {
 323     case MVLONG:   return (multiVal_makeInt (m1->value.ival - m2->value.ival));
 324     case MVCHAR:   return (multiVal_makeChar ((char) (m1->value.cval - m2->value.cval)));
 325     case MVDOUBLE: return (multiVal_makeDouble (m1->value.fval - m2->value.fval));
 326     case MVSTRING: return multiVal_undefined;
 327     }
 328
 329   BADEXIT;
 330 }
 331
 332 multiVal multiVal_multiply (multiVal m1, multiVal m2)
 333 {
 334   if (multiVal_isUndefined (m1) || multiVal_isUndefined (m2) || m1->kind != m2->kind)
 335     {
 336       return multiVal_undefined;
 337     }
 338
 339   switch (m1->kind)
 340     {
 341     case MVLONG:   return (multiVal_makeInt (m1->value.ival * m2->value.ival));
 342     case MVCHAR:   return (multiVal_makeChar ((char) (m1->value.cval * m2->value.cval)));
 343     case MVDOUBLE: return (multiVal_makeDouble (m1->value.fval * m2->value.fval));
 344     case MVSTRING: return multiVal_undefined;
 345     }
 346
 347   BADEXIT;
 348 }
 349
 350 multiVal multiVal_divide (multiVal m1, multiVal m2)
 351 {
 352   if (multiVal_isUndefined (m1) || multiVal_isUndefined (m2) || m1->kind != m2->kind)
 353     {
 354       return multiVal_undefined;
 355     }
 356
 357   switch (m1->kind)
 358     {
 359     case MVLONG:
 360       if (m2->value.ival != 0)
 361         {
 362           return (multiVal_makeInt (m1->value.ival / m2->value.ival));
 363         }
 364       else
 365         {
 366           return multiVal_undefined;
 367         }
 368     case MVCHAR:
 369       if (m2->value.cval != (char) 0)
 370         {
 371           return (multiVal_makeChar ((char) (m1->value.cval / m2->value.cval)));
 372         }
 373       else
 374         {
 375           return multiVal_undefined;
 376         }
 377     case MVDOUBLE:
 378       return multiVal_undefined; /* Don't attempt to divide floats */
 379     case MVSTRING: return multiVal_undefined;
 380     }
 381
 382   BADEXIT;
 383 }
 384
 385 void multiVal_free (/*@only@*/ multiVal m)
 386 {
 387   if (multiVal_isDefined (m))
 388     {
 389       if (m->kind == MVSTRING)
 390         {
 391           cstring_free (m->value.sval);
 392         }
 393
 394       sfree (m);
 395     }
 396 }
 397
 398
 399
 400