src/cprim.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2002 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 ** cprim.c
  26 */
  27
  28 # include "splintMacros.nf"
  29 # include "basic.h"
  30
  31 static bool cprim_isReal (cprim c)
  32 {
  33   return (cprim_isAnyReal (c));
  34 }
  35
  36 static bool cprim_isNumeric (cprim c)
  37 {
  38   return (cprim_isReal (c) || cprim_isInt (c));
  39 }
  40
  41 cprim
  42 cprim_fromInt (int i)
  43 {
  44   if (i < CTX_UNKNOWN || i > CTX_LAST)
  45     {
  46       llcontbug (message ("cprim_fromInt: out of range: %d", i));
  47       return CTX_UNKNOWN;
  48     }
  49   return (cprim) i;
  50 }
  51
  52
  53 /*
  54 ** not symmetric:  c1 := c2 or c2 is passed as c1
  55 **    (if RELAXQUALS, c1 must be "bigger" than c2)
  56 */
  57
  58 static bool cprim_closeEnoughAux (cprim p_c1, cprim p_c2, bool p_deep);
  59
  60 bool
  61 cprim_closeEnoughDeep (cprim c1, cprim c2)
  62 {
  63   /*
  64   ** If * c2 is passed as * c1
  65   ** Comparison is slightly different since it is safe to pass int as long,
  66   ** but not to pass int * as long *!
  67   **
  68   ** For deep comparisons, +relaxquals does not permit the long/int break.
  69   */
  70
  71   return cprim_closeEnoughAux (c1, c2, TRUE);
  72 }
  73
  74 bool
  75 cprim_closeEnough (cprim c1, cprim c2)
  76 {
  77   return cprim_closeEnoughAux (c1, c2, FALSE);
  78 }
  79
  80 static bool
  81 cprim_closeEnoughAux (cprim c1, cprim c2, bool deep)
  82 {
  83   if (c1 == c2) return TRUE;
  84
  85   DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
  86
  87   if (c1 == CTX_ANYINTEGRAL)
  88     {
  89       if (context_getFlag (FLG_MATCHANYINTEGRAL)
  90           || context_getFlag (FLG_IGNOREQUALS))
  91         {
  92           return (cprim_isAnyInt (c2)
  93                   || (cprim_isAnyChar (c2) && context_msgCharInt ()));
  94         }
  95       else if (context_getFlag (FLG_LONGINTEGRAL))
  96         {
  97           return (cprim_closeEnough (CTX_LINT, c2));
  98         }
  99       else if (context_getFlag (FLG_LONGUNSIGNEDINTEGRAL))
 100         {
 101           return (cprim_closeEnough (CTX_ULINT, c2));
 102         }
 103       else
 104         {
 105           return FALSE;
 106         }
 107     }
 108
 109   if (c1 == CTX_UNSIGNEDINTEGRAL)
 110     {
 111       if (context_getFlag (FLG_MATCHANYINTEGRAL)
 112           || context_getFlag (FLG_IGNOREQUALS))
 113         {
 114           if (context_getFlag (FLG_IGNORESIGNS))
 115             {
 116               return (cprim_isAnyUnsignedInt (c2)
 117                       || (cprim_isUnsignedChar (c2) && context_msgCharInt ()));
 118             }
 119           else
 120             {
 121               return (cprim_isAnyInt (c2)
 122                       || (cprim_isAnyChar (c2) && context_msgCharInt ()));
 123             }
 124         }
 125       else if (context_getFlag (FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL))
 126         {
 127           return (cprim_closeEnough (CTX_ULINT, c2));
 128         }
 129       else
 130         {
 131           return FALSE;
 132         }
 133     }
 134
 135   if (c1 == CTX_SIGNEDINTEGRAL)
 136     {
 137       if (context_getFlag (FLG_MATCHANYINTEGRAL)
 138           || context_getFlag (FLG_IGNOREQUALS))
 139         {
 140           return (cprim_isAnyInt (c2)
 141                   || (cprim_isAnyChar (c2) && context_msgCharInt ()));
 142         }
 143       else if (context_getFlag (FLG_LONGSIGNEDINTEGRAL))
 144         {
 145           return (cprim_closeEnough (CTX_LINT, c2));
 146         }
 147       else
 148         {
 149           return FALSE;
 150         }
 151     }
 152
 153   if (c2 == CTX_ANYINTEGRAL)
 154     {
 155       if (context_getFlag (FLG_MATCHANYINTEGRAL))
 156         {
 157           return (cprim_isAnyInt (c1)
 158                   || (cprim_isAnyChar (c1) && context_msgCharInt ()));
 159         }
 160       else if (context_getFlag (FLG_LONGINTEGRAL))
 161         {
 162           return (cprim_closeEnough (c1, CTX_LINT));
 163         }
 164       else if (context_getFlag (FLG_LONGUNSIGNEDINTEGRAL))
 165         {
 166           return (cprim_closeEnough (c1, CTX_ULINT));
 167         }
 168       else
 169         {
 170           return FALSE;
 171         }
 172     }
 173
 174   if (c2 == CTX_UNSIGNEDINTEGRAL)
 175     {
 176       if (context_getFlag (FLG_MATCHANYINTEGRAL))
 177         {
 178           return (cprim_isAnyInt (c1)
 179                   || (cprim_isAnyChar (c1) && context_msgCharInt ()));
 180         }
 181       else if (context_getFlag (FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL))
 182         {
 183           return (cprim_closeEnough (c1, CTX_ULINT));
 184         }
 185       else
 186         {
 187           return FALSE;
 188         }
 189     }
 190
 191   if (c2 == CTX_SIGNEDINTEGRAL)
 192     {
 193       if (context_getFlag (FLG_MATCHANYINTEGRAL))
 194         {
 195           return (cprim_isAnyInt (c2)
 196                   || (cprim_isAnyChar (c2) && context_msgCharInt ()));
 197         }
 198       else if (context_getFlag (FLG_LONGSIGNEDINTEGRAL))
 199         {
 200           return (cprim_closeEnough (c1, CTX_LINT));
 201         }
 202       else
 203         {
 204           return FALSE;
 205         }
 206     }
 207
 208
 209   DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
 210
 211   if (context_getFlag (FLG_RELAXTYPES))
 212     {
 213       if (cprim_isNumeric (c1) && cprim_isNumeric (c2)) return TRUE;
 214     }
 215
 216   if (context_getFlag (FLG_IGNOREQUALS))
 217     {
 218       switch (c1)
 219         {
 220         case CTX_CHAR:
 221         case CTX_UCHAR:
 222           if (cprim_isAnyChar (c2)
 223               || (cprim_isAnyInt (c2) && (context_msgCharInt ()))) {
 224             return TRUE;
 225           }
 226           break;
 227         case CTX_DOUBLE:
 228         case CTX_FLOAT:
 229         case CTX_LDOUBLE:
 230           if (c2 == CTX_DOUBLE || c2 == CTX_FLOAT || c2 == CTX_LDOUBLE) {
 231             return TRUE;
 232           }
 233           break;
 234         case CTX_INT:
 235         case CTX_LINT:
 236         case CTX_LLINT:
 237         case CTX_ULLINT:
 238         case CTX_SINT:
 239         case CTX_UINT:
 240         case CTX_ULINT:
 241         case CTX_USINT:
 242           if (cprim_isAnyInt (c2)
 243               || (cprim_isAnyChar (c2) && context_msgCharInt ())) {
 244             return TRUE;
 245           }
 246         default:
 247           ;
 248         }
 249     }
 250
 251   if (context_getFlag (FLG_IGNORESIGNS))
 252     {
 253       if (c1 == CTX_UCHAR)
 254         {
 255           c1 = CTX_CHAR;
 256         }
 257       else if (c1 == CTX_UINT)
 258         {
 259           c1 = CTX_INT;
 260         }
 261       else if (c1 == CTX_ULINT)
 262         {
 263           c1 = CTX_LINT;
 264         }
 265       /* 2001-06-10: This fix provided by Jim Zelenka: */
 266       else if (c1 == CTX_ULLINT)
 267         {
 268           c1 = CTX_LLINT;
 269         }
 270       /* End fix */
 271       else if (c1 == CTX_USINT)
 272         {
 273           c1 = CTX_SINT;
 274         }
 275       else
 276         {
 277           ;
 278         }
 279
 280       if (c2 == CTX_UCHAR)
 281         {
 282           c2 = CTX_CHAR;
 283         }
 284       else if (c2 == CTX_UINT)
 285         {
 286           c2 = CTX_INT;
 287         }
 288       else if (c2 == CTX_ULINT)
 289         {
 290           c2 = CTX_LINT;
 291         }
 292       /* 2001-06-10: This fix provided by Jim Zelenka: */
 293       else if (c2 == CTX_ULLINT)
 294         {
 295           c2 = CTX_LLINT;
 296         }
 297       /* End fix */
 298       else if (c2 == CTX_USINT)
 299         {
 300           c2 = CTX_SINT;
 301         }
 302       else
 303         {
 304           ;
 305         }
 306     }
 307
 308   if (c1 == c2) return TRUE;
 309
 310   if (context_getFlag (FLG_FLOATDOUBLE))
 311     {
 312       if (c1 == CTX_FLOAT && c2 == CTX_DOUBLE)
 313         {
 314           return TRUE;
 315         }
 316       if (c2 == CTX_FLOAT && c1 == CTX_DOUBLE)
 317         {
 318           return TRUE;
 319         }
 320     }
 321
 322   DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
 323
 324   if (!deep && context_getFlag (FLG_RELAXQUALS))
 325     {
 326       switch (c1)
 327         {
 328         case CTX_DOUBLE:
 329           return (c2 == CTX_FLOAT);
 330         case CTX_LDOUBLE:
 331           return (c2 == CTX_DOUBLE || c2 == CTX_FLOAT);
 332         case CTX_SINT:
 333           return ((c2 == CTX_CHAR && context_msgCharInt ())
 334                   || (c2 == CTX_INT && context_msgShortInt ())
 335                   || (c2 == CTX_LINT && context_msgShortInt () && context_msgLongInt ()));
 336
 337         case CTX_INT:
 338           return ((c2 == CTX_SINT
 339                    || (cprim_isAnyChar (c2) && context_msgCharInt ())
 340                    || (c2 == CTX_LINT && context_msgLongInt ())));
 341
 342         case CTX_LLINT:
 343           return (c2 == CTX_SINT
 344                   || c2 == CTX_INT
 345                       || c2 == CTX_LINT
 346                   || (cprim_isAnyChar (c2) && context_msgCharInt ()));
 347         case CTX_ULLINT:
 348           return (c2 == CTX_USINT
 349                   || c2 == CTX_UINT
 350                   || c2 == CTX_ULINT
 351                   /* 2001-06-10: This fix provided by Jim Zelenka: */
 352                   || (cprim_isAnyChar (c2) && context_msgCharInt ()));
 353         case CTX_LINT:
 354           return (c2 == CTX_SINT
 355                   || c2 == CTX_INT
 356                   || (cprim_isAnyChar (c2) && context_msgCharInt ()));
 357         case CTX_UINT:
 358           return (c2 == CTX_USINT
 359                   || (c2 == CTX_UCHAR && context_msgCharInt ()));
 360         case CTX_USINT:
 361           return (c2 == CTX_UCHAR && context_msgCharInt ());
 362         case CTX_ULINT:
 363           /* 2001-06-10: This fix provided by Jim Zelenka: */
 364           return (c2 == CTX_UINT || c2 == CTX_USINT
 365                   || (c2 == CTX_UCHAR && context_msgCharInt()));
 366         case CTX_UCHAR:
 367           return (c2 == CTX_UINT && context_msgCharInt ());
 368         case CTX_CHAR:
 369           return ((c2 == CTX_INT || c2 == CTX_SINT)
 370                   && context_msgCharInt ());
 371         default:
 372           return FALSE;
 373         }
 374     }
 375   else
 376     {
 377       switch (c1)
 378         {
 379         case CTX_DOUBLE:
 380         case CTX_LDOUBLE:
 381           return FALSE;
 382         case CTX_SINT:
 383           if (c2 == CTX_INT && context_msgShortInt ()) {
 384             return TRUE;
 385           }
 386           /*@fallthrough@*/
 387         case CTX_INT:
 388           if (c2 == CTX_INT && context_msgLongInt ()) {
 389             return TRUE;
 390           }
 391
 392           if (c2 == CTX_SINT && context_msgShortInt ()) {
 393             return TRUE;
 394           }
 395           /*@fallthrough@*/
 396         case CTX_LINT:
 397           if (c2 == CTX_INT && context_msgLongInt ()) {
 398             return TRUE;
 399           }
 400           /*@fallthrough@*/
 401         case CTX_LLINT:
 402           return (c2 == CTX_CHAR && context_msgCharInt ());
 403         case CTX_UINT:
 404         case CTX_USINT:
 405         case CTX_ULINT:
 406         case CTX_ULLINT:
 407           return (c2 == CTX_UCHAR && context_msgCharInt ());
 408         case CTX_UCHAR:
 409           return (c2 == CTX_UINT && context_msgCharInt ());
 410         case CTX_CHAR:
 411           return ((c2 == CTX_INT || c2 == CTX_SINT)
 412                   && context_msgCharInt ());
 413         default:
 414           return FALSE;
 415         }
 416     }
 417 }
 418
 419 /*@only@*/ cstring
 420 cprim_unparse (cprim c)
 421 {
 422   switch (c)
 423     {
 424     case CTX_UNKNOWN:
 425       return cstring_makeLiteral ("-");
 426     case CTX_VOID:
 427       return cstring_makeLiteral ("void");
 428     case CTX_CHAR:
 429       return cstring_makeLiteral ("char");
 430     case CTX_UCHAR:
 431       return cstring_makeLiteral ("unsigned char");
 432    case CTX_DOUBLE:
 433       return cstring_makeLiteral ("double");
 434     case CTX_LDOUBLE:
 435       return cstring_makeLiteral ("long double");
 436     case CTX_FLOAT:
 437       return cstring_makeLiteral ("float");
 438     case CTX_INT:
 439       return cstring_makeLiteral ("int");
 440     case CTX_LINT:
 441       return cstring_makeLiteral ("long int");
 442     case CTX_LLINT:
 443       return cstring_makeLiteral ("long long");
 444     case CTX_ULLINT:
 445       return cstring_makeLiteral ("unsigned long long");
 446     case CTX_SINT:
 447       return cstring_makeLiteral ("short int");
 448     case CTX_UINT:
 449       return cstring_makeLiteral ("unsigned int");
 450     case CTX_ULINT:
 451       return cstring_makeLiteral ("unsigned long int");
 452     case CTX_USINT:
 453       return cstring_makeLiteral ("unsigned short int");
 454     case CTX_UNSIGNEDINTEGRAL:
 455       return cstring_makeLiteral ("arbitrary unsigned integral type");
 456     case CTX_SIGNEDINTEGRAL:
 457       return cstring_makeLiteral ("arbitrary signed integral type");
 458     case CTX_ANYINTEGRAL:
 459       return cstring_makeLiteral ("arbitrary integral type");
 460     default:
 461       return cstring_makeLiteral ("unknown prim");
 462     }
 463 }
 464
 465 bool cprim_isInt (cprim c)
 466 {
 467   return (cprim_isAnyInt (c)
 468           || (cprim_isAnyChar (c) && context_msgCharInt ()));
 469 }
 470
 471
 472
 473