src/exprNode.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 ** exprNode.c
  26 */
  27
  28 # include <ctype.h> /* for isdigit */
  29 # include "splintMacros.nf"
  30 # include "basic.h"
  31 # include "cgrammar.h"
  32 # include "cscanner.h"
  33 # include "cscannerHelp.h"
  34 # include "cgrammar_tokens.h"
  35
  36 # include "exprChecks.h"
  37 # include "transferChecks.h"
  38 # include "exprNodeSList.h"
  39
  40 static bool exprNode_sameStorage (exprNode p_e1, exprNode p_e2) /*@*/ ;
  41 static bool exprNode_isEmptyStatement (exprNode p_e);
  42 static /*@exposed@*/ exprNode exprNode_firstStatement (/*@returned@*/ exprNode p_e);
  43 static bool exprNode_isFalseConstant (exprNode p_e) /*@*/ ;
  44 static bool exprNode_isStatement (exprNode p_e);
  45 static void checkGlobUse (uentry p_glob, bool p_isCall, /*@notnull@*/ exprNode p_e);
  46 static void exprNode_addUse (exprNode p_e, /*@exposed@*/ sRef p_s);
  47 static bool exprNode_matchArgType (ctype p_ct, exprNode p_e);
  48 static exprNode exprNode_fakeCopy (exprNode p_e) /*@*/ ;
  49 static exprNode exprNode_statementError (/*@only@*/ exprNode p_e, /*@only@*/ lltok p_t);
  50 static bool exprNode_matchTypes (exprNode p_e1, exprNode p_e2);
  51 static void checkUniqueParams (exprNode p_fcn,
  52                                /*@notnull@*/ exprNode p_current, exprNodeList p_args,
  53                                int p_paramno, uentry p_ucurrent);
  54 static void updateAliases (/*@notnull@*/ exprNode p_e1, /*@notnull@*/ exprNode p_e2);
  55 static bool abstractOpError (ctype p_tr1, ctype p_tr2, lltok p_op,
  56                              /*@notnull@*/ exprNode p_e1, /*@notnull@*/ exprNode p_e2,
  57                              fileloc p_loc1, fileloc p_loc2)
  58    /*@modifies g_warningstream@*/ ;
  59 static ctype checkNumerics (ctype p_tr1, ctype p_tr2, ctype p_te1, ctype p_te2,
  60                             /*@notnull@*/ exprNode p_e1, /*@notnull@*/ exprNode p_e2, lltok p_op);
  61 static void doAssign (/*@notnull@*/ exprNode p_e1, /*@notnull@*/ exprNode p_e2, bool p_isInit);
  62 static void checkSafeUse (exprNode p_e, /*@exposed@*/ sRef p_s);
  63 static void reflectNullTest (/*@notnull@*/ exprNode p_e, bool p_isnull);
  64 static void checkMacroParen (exprNode p_e);
  65 static exprNodeSList exprNode_flatten (/*@dependent@*/ exprNode p_e);
  66 static void exprNode_checkSetAny (exprNode p_e, /*@dependent@*/ cstring p_name);
  67 static void exprNode_checkUse (exprNode p_e, /*@exposed@*/ sRef p_s, fileloc p_loc);
  68 static void exprNode_mergeUSs (exprNode p_res, exprNode p_other);
  69 static void exprNode_mergeCondUSs (exprNode p_res, exprNode p_other1, exprNode p_other2);
  70 static /*@only@*/ /*@notnull@*/ exprNode exprNode_fromIdentifierAux (/*@observer@*/ uentry p_c);
  71 static void checkAnyCall (/*@notnull@*/ /*@dependent@*/ exprNode p_fcn,
  72                           /*@dependent@*/ cstring p_fname,
  73                           uentryList p_pn, exprNodeList p_args,
  74                           bool p_hasMods, sRefSet p_mods, bool p_isSpec,
  75                           int p_specialArgs);
  76 static void checkOneArg (uentry p_ucurrent, /*@notnull@*/ exprNode p_current,
  77                          /*@dependent@*/ exprNode p_fcn, bool p_isSpec, int p_argno, int p_totargs);
  78 static void
  79   checkUnspecCall (/*@notnull@*/ /*@dependent@*/ exprNode p_fcn, uentryList p_params, exprNodeList p_args);
  80
  81 static /*@only@*/ exprNode exprNode_effect (exprNode p_e)
  82   /*@globals internalState@*/ ;
  83 static /*@only@*/ cstring exprNode_doUnparse (exprNode p_e);
  84 static /*@observer@*/ cstring exprNode_rootVarName (exprNode p_e);
  85 static /*@exposed@*/ exprNode
  86   exprNode_lastStatement (/*@returned@*/ exprNode p_e);
  87
  88 static /*@only@*/ exprNode s_mustExitNode = exprNode_undefined;
  89
  90 static int checkArgsReal (uentry p_fcn, /*@dependent@*/ exprNode p_f,
  91                           uentryList p_cl,
  92                           exprNodeList p_args, bool p_isIter, exprNode p_ret);
  93
  94 static bool inEffect = FALSE;
  95 static int nowalloc = 0;
  96 static int totalloc = 0;
  97 static int maxalloc = 0;
  98
  99 static /*@only@*/ uentry regArg;
 100 static /*@only@*/ uentry outArg;
 101 static /*@only@*/ uentry outStringArg;
 102 static /*@exposed@*/ sRef stdinRef;
 103 static /*@exposed@*/ sRef stdoutRef;
 104 static /*@only@*/ uentry csArg;
 105 static /*@only@*/ uentry csOnlyArg;
 106 static ctype cstringType;
 107 static ctype ctypeType;
 108 static ctype filelocType;
 109 static bool initMod = FALSE;
 110
 111 /*@function void exprNode_swap (sef exprNode, sef exprNode)@*/
 112 /*@-macroassign@*/
 113 # define exprNode_swap(e1,e2) do { exprNode m_tmp = (e1); (e1) = (e2); (e2) = m_tmp; } while (FALSE)
 114 /*@=macroassign@*/
 115
 116 static void exprNode_defineConstraints(/*@sef@*/ /*@special@*/ /*@notnull@*/ exprNode e)
 117    /*@defines e->requiresConstraints,  e->ensuresConstraints,
 118               e->trueEnsuresConstraints,  e->falseEnsuresConstraints @*/
 119 {
 120   e->requiresConstraints = constraintList_makeNew ();
 121   e->ensuresConstraints = constraintList_makeNew ();
 122   e->trueEnsuresConstraints = constraintList_makeNew ();
 123   e->falseEnsuresConstraints = constraintList_makeNew ();
 124 }
 125
 126 /*
 127 ** must occur after library has been read
 128 */
 129
 130 void exprNode_initMod (void)
 131   /*@globals undef regArg, undef outArg, undef outStringArg,
 132              undef csOnlyArg, undef csArg;
 133    @*/
 134 {
 135   uentry ue;
 136   idDecl tmp;
 137
 138   initMod = TRUE;
 139   cstringType = ctype_unknown;
 140   ctypeType = ctype_unknown;
 141   filelocType = ctype_unknown;
 142
 143   if (usymtab_existsType (cstring_makeLiteralTemp ("cstring")))
 144     {
 145       cstringType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("cstring"));
 146     }
 147
 148   if (usymtab_existsType (cstring_makeLiteralTemp ("ctype")))
 149     {
 150       ctypeType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("ctype"));
 151     }
 152
 153   if (usymtab_existsType (cstring_makeLiteralTemp ("fileloc")))
 154     {
 155       filelocType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("fileloc"));
 156     }
 157
 158   if (usymtab_existsGlob (cstring_makeLiteralTemp ("stdin")))
 159     {
 160       ue = usymtab_lookupGlob (cstring_makeLiteralTemp ("stdin"));
 161     }
 162   else /* define stdin */
 163     {
 164       ue = uentry_makeVariable (cstring_makeLiteralTemp ("stdin"),
 165                                 ctype_unknown,
 166                                 fileloc_getBuiltin (),
 167                                 FALSE);
 168       uentry_setHasNameError (ue);
 169       ue = usymtab_supGlobalEntryReturn (ue);
 170     }
 171
 172   stdinRef = sRef_makePointer (uentry_getSref (ue));
 173
 174   if (usymtab_existsGlob (cstring_makeLiteralTemp ("stdout")))
 175     {
 176       ue = usymtab_lookupGlob (cstring_makeLiteralTemp ("stdout"));
 177     }
 178   else
 179     {
 180       ue = uentry_makeVariable (cstring_makeLiteralTemp ("stdout"),
 181                                 ctype_unknown,
 182                                 fileloc_getBuiltin (),
 183                                 FALSE);
 184       uentry_setHasNameError (ue);
 185       ue = usymtab_supGlobalEntryReturn (ue);
 186     }
 187
 188   stdoutRef = sRef_makePointer (uentry_getSref (ue));
 189
 190   tmp = idDecl_create (cstring_undefined, qtype_create (ctype_unknown));
 191
 192   regArg = uentry_makeParam (tmp, PARAMUNKNOWN);
 193
 194   idDecl_setTyp (tmp,
 195                  qtype_addQual (qtype_create (ctype_makePointer (ctype_unknown)),
 196                                 qual_createOut ()));
 197
 198   outArg = uentry_makeParam (tmp, PARAMUNKNOWN);
 199
 200   idDecl_setTyp (tmp, qtype_addQual (qtype_create (ctype_string),
 201                                      qual_createOut ()));
 202
 203   outStringArg = uentry_makeParam (tmp, PARAMUNKNOWN);
 204
 205   idDecl_setTyp (tmp, qtype_addQual (qtype_addQual (qtype_create (cstringType),
 206                                                     qual_createOnly ()),
 207                                      qual_createNull ()));
 208
 209   csOnlyArg = uentry_makeParam (tmp, PARAMUNKNOWN);
 210
 211   idDecl_setTyp (tmp, qtype_addQual (qtype_create (cstringType), qual_createNull ()));
 212   csArg = uentry_makeParam (tmp, PARAMUNKNOWN);
 213
 214   idDecl_free (tmp);
 215 }
 216
 217 void
 218 exprNode_destroyMod (void)
 219    /*@globals killed regArg, killed outArg, killed outStringArg,
 220               killed s_mustExitNode, initMod @*/
 221 {
 222   if (initMod)
 223     {
 224       /* evans 2002-07-12: changed uentry_free to uentry_freeComplete */
 225       uentry_freeComplete (regArg);
 226       uentry_freeComplete (outArg);
 227       uentry_freeComplete (outStringArg);
 228
 229       exprNode_free (s_mustExitNode);
 230       initMod = FALSE;
 231       /*@-branchstate@*/
 232     }
 233   /*@=branchstate@*/
 234 }
 235
 236 static void exprNode_resetSref (/*@notnull@*/ exprNode e)
 237 {
 238   e->sref = sRef_undefined;
 239 }
 240
 241 exprNode exprNode_fakeCopy (exprNode e)
 242 {
 243   /*@-temptrans@*/ /*@-retalias@*/
 244   return e;
 245   /*@=temptrans@*/ /*@=retalias@*/
 246 }
 247
 248 static bool isFlagKey (char key)
 249 {
 250   return (key == '-' || key == '+' || key == ' ' || key == '#');
 251 }
 252
 253 static void exprNode_combineControl (/*@notnull@*/ exprNode ret,
 254                                      /*@notnull@*/ exprNode ifclause,
 255                                      /*@notnull@*/ exprNode elseclause)
 256 {
 257   ret->canBreak = ifclause->canBreak || elseclause->canBreak;
 258
 259   ret->mustBreak =
 260     (ifclause->mustBreak || exprNode_mustEscape (ifclause))
 261       && (elseclause->mustBreak || exprNode_mustEscape (elseclause));
 262
 263   ret->exitCode = exitkind_combine (ifclause->exitCode,
 264                                     elseclause->exitCode);
 265
 266 }
 267
 268 /*
 269 ** For exprNode's returned by exprNode_effect.
 270 */
 271
 272 static bool shallowKind (exprKind kind)
 273 {
 274   return (kind == XPR_STRINGLITERAL
 275           || kind == XPR_NUMLIT
 276           || kind == XPR_EMPTY
 277           || kind == XPR_BODY
 278           || kind == XPR_NODE);
 279 }
 280
 281 static void
 282 exprNode_freeIniter (/*@only@*/ exprNode e)
 283 {
 284   if (!exprNode_isError (e))
 285     {
 286       switch (e->kind)
 287         {
 288         case XPR_FACCESS:
 289           /*
 290           ** Its a fake copy, don't free the field->rec and field->field
 291           ** fields.
 292           */
 293
 294           /*@-compdestroy@*/
 295           sfree (e->edata->field);
 296           /*@=compdestroy@*/
 297
 298           sfree (e->edata);
 299           break;
 300         case XPR_FETCH:
 301           exprNode_free (e->edata->op->b);
 302           /*@-compdestroy@*/ sfree (e->edata->op); /*@=compdestroy@*/
 303           sfree (e->edata);
 304           break;
 305         default:
 306           llbug (message ("other: %s", exprNode_unparse (e)));
 307         }
 308
 309       multiVal_free (e->val);
 310       cstring_free (e->etext);
 311       fileloc_free (e->loc);
 312       sRefSet_free (e->uses);
 313       sRefSet_free (e->sets);
 314       sRefSet_free (e->msets);
 315       guardSet_free (e->guards);
 316
 317       constraintList_free(e->requiresConstraints);
 318       constraintList_free(e->ensuresConstraints);
 319       constraintList_free(e->trueEnsuresConstraints);
 320       constraintList_free(e->falseEnsuresConstraints);
 321
 322       e->requiresConstraints = NULL;
 323       e->ensuresConstraints = NULL;
 324       e->trueEnsuresConstraints = NULL;
 325       e->falseEnsuresConstraints = NULL;
 326
 327       sfree (e);
 328     }
 329 }
 330
 331 void
 332 exprNode_freeShallow (/*@only@*/ exprNode e)
 333 {
 334   if (!exprNode_isError (e))
 335     {
 336       if (shallowKind (e->kind))
 337         {
 338                 }
 339       else
 340         {
 341           if (!inEffect)
 342             {
 343               if (e->kind == XPR_EMPTY
 344                   || e->kind == XPR_BODY
 345                   || e->kind == XPR_STRINGLITERAL
 346                   || e->kind == XPR_NUMLIT
 347                   || e->kind == XPR_NODE
 348                   || e->kind == XPR_OFFSETOF
 349                   || e->kind == XPR_ALIGNOFT
 350                   || e->kind == XPR_ALIGNOF
 351                   || e->kind == XPR_SIZEOFT
 352                   || e->kind == XPR_SIZEOF)
 353                 {
 354                   /* don't free anything */
 355                 }
 356               else
 357                 {
 358                   /* multiVal_free (e->val);  */
 359                   cstring_free (e->etext);
 360                   fileloc_free (e->loc);
 361                   sRefSet_free (e->uses);
 362                   sRefSet_free (e->sets);
 363                   sRefSet_free (e->msets);
 364                   guardSet_free (e->guards);
 365                   exprData_freeShallow (e->edata, e->kind);
 366                   nowalloc--;
 367                   /*@-compdestroy@*/ sfree (e); /*@=compdestroy@*/
 368                   /*@-branchstate@*/
 369                 }
 370             }
 371         } /*@=branchstate@*/
 372     }
 373   }
 374
 375 void
 376 exprNode_free (exprNode e)
 377 {
 378   if (!exprNode_isError (e))
 379     {
 380       if (!inEffect)
 381         {
 382           multiVal_free (e->val);
 383           cstring_free (e->etext);
 384           fileloc_free (e->loc);
 385           sRefSet_free (e->uses);
 386           sRefSet_free (e->sets);
 387           sRefSet_free (e->msets);
 388           guardSet_free (e->guards);
 389           exprData_free (e->edata, e->kind);
 390
 391           constraintList_free(e->requiresConstraints);
 392           constraintList_free(e->ensuresConstraints);
 393           constraintList_free(e->trueEnsuresConstraints);
 394           constraintList_free(e->falseEnsuresConstraints);
 395
 396           e->requiresConstraints = NULL;
 397           e->ensuresConstraints = NULL;
 398           e->trueEnsuresConstraints = NULL;
 399           e->falseEnsuresConstraints = NULL;
 400
 401           nowalloc--;
 402           sfree (e);
 403           /*@-branchstate@*/
 404         } /*@=branchstate@*/
 405     }
 406 }
 407
 408 exprNode
 409 exprNode_makeError ()
 410 {
 411   return exprNode_undefined;
 412 }
 413
 414 static /*@out@*/ /*@only@*/ /*@notnull@*/ exprNode
 415 exprNode_new (void)
 416 {
 417   exprNode ret = (exprNode) dmalloc (sizeof (*ret));
 418   /* static int lastexpnodes = 0; */
 419
 420   nowalloc++;
 421   totalloc++;
 422
 423   if (nowalloc > maxalloc)
 424     {
 425       maxalloc = nowalloc;
 426     }
 427
 428   return ret;
 429 }
 430
 431 static /*@notnull@*/ /*@special@*/ exprNode
 432   exprNode_createPlain (ctype c)
 433   /*@defines result@*/
 434   /*@ensures isnull result->edata, result->loc, result->val, result->guards,
 435                     result->uses, result->sets, result->msets, result->etext @*/
 436   /*@*/
 437 {
 438   exprNode e = exprNode_new ();
 439
 440   e->typ = c;
 441   e->kind = XPR_EMPTY;
 442   e->val = multiVal_undefined;
 443   e->sref = sRef_undefined;
 444   e->etext = cstring_undefined;
 445   e->loc = fileloc_undefined;
 446   e->guards = guardSet_undefined;
 447   e->uses = sRefSet_undefined;
 448   e->sets = sRefSet_undefined;
 449   e->msets = sRefSet_undefined;
 450   e->edata = exprData_undefined;
 451   e->exitCode = XK_NEVERESCAPE;
 452   e->canBreak = FALSE;
 453   e->mustBreak = FALSE;
 454   e->isJumpPoint = FALSE;
 455
 456   exprNode_defineConstraints(e);
 457
 458   return (e);
 459 }
 460
 461 /*@observer@*/ exprNode exprNode_makeMustExit (void)
 462 {
 463   if (exprNode_isUndefined (s_mustExitNode))
 464     {
 465       s_mustExitNode = exprNode_createPlain (ctype_unknown);
 466       s_mustExitNode->exitCode = XK_MUSTEXIT;
 467     }
 468
 469   return s_mustExitNode;
 470 }
 471
 472
 473 static /*@notnull@*/ /*@special@*/ exprNode exprNode_create (ctype c)
 474   /*@defines result@*/
 475   /*@post:isnull result->edata, result->guards, result->val,
 476                  result->uses, result->sets, result->msets@*/
 477   /*@*/
 478 {
 479   exprNode e = exprNode_createPlain (c);
 480   e->loc = fileloc_copy (g_currentloc);
 481   return (e);
 482 }
 483
 484 static /*@notnull@*/ /*@special@*/ exprNode exprNode_createUnknown (void)
 485   /*@defines result@*/
 486   /*@post:isnull result->edata, result->guards,
 487                  result->uses, result->sets, result->msets@*/
 488   /*@*/
 489 {
 490   return (exprNode_create (ctype_unknown));
 491 }
 492
 493 static /*@notnull@*/ /*@special@*/ exprNode
 494   exprNode_createLoc (ctype c, /*@keep@*/ fileloc loc)
 495   /*@defines result@*/
 496   /*@post:isnull result->edata, result->guards, result->val,
 497                  result->uses, result->sets, result->msets@*/
 498   /*@*/
 499 {
 500   exprNode e = exprNode_createPlain (c);
 501   e->loc = loc;
 502   return (e);
 503 }
 504
 505 static void
 506   exprNode_copySets (/*@special@*/ /*@notnull@*/ exprNode ret, exprNode e)
 507   /*@defines ret->guards, ret->uses, ret->sets, ret->msets@*/
 508 {
 509   if (exprNode_isDefined (e))
 510     {
 511       ret->guards = guardSet_copy (e->guards);
 512       ret->uses = sRefSet_newCopy (e->uses);
 513       ret->sets = sRefSet_newCopy (e->sets);
 514       ret->msets = sRefSet_newCopy (e->msets);
 515     }
 516   else
 517     {
 518       ret->guards = guardSet_undefined;
 519       ret->uses = sRefSet_undefined;
 520       ret->sets = sRefSet_undefined;
 521       ret->msets = sRefSet_undefined;
 522     }
 523 }
 524
 525 static /*@notnull@*/ /*@special@*/ exprNode
 526   exprNode_createPartialLocCopy (exprNode e, /*@only@*/ fileloc loc)
 527   /*@defines result@*/
 528   /*@post:isnull result->edata, result->etext@*/
 529   /*@*/
 530 {
 531   exprNode ret = exprNode_new ();
 532
 533   if (exprNode_isError (e))
 534     {
 535       ret->typ = ctype_unknown;
 536       ret->val = multiVal_undefined;
 537       ret->loc = loc;
 538       ret->guards = guardSet_undefined;
 539       ret->uses = sRefSet_undefined;
 540       ret->sets = sRefSet_undefined;
 541       ret->msets = sRefSet_undefined;
 542     }
 543   else
 544     {
 545       ret->typ = e->typ;
 546       ret->val = multiVal_copy (e->val);
 547       ret->loc = loc;
 548       ret->guards = guardSet_copy (e->guards);
 549       ret->uses = sRefSet_newCopy (e->uses);
 550       ret->sets = sRefSet_newCopy (e->sets);
 551       ret->msets = sRefSet_newCopy (e->msets);
 552     }
 553
 554   ret->kind = XPR_EMPTY;
 555   ret->sref = sRef_undefined;
 556   ret->etext = cstring_undefined;
 557   ret->exitCode = XK_NEVERESCAPE;
 558   ret->canBreak = FALSE;
 559   ret->mustBreak = FALSE;
 560   ret->isJumpPoint = FALSE;
 561   ret->edata = exprData_undefined;
 562
 563   exprNode_defineConstraints(ret);
 564
 565   return (ret);
 566 }
 567
 568
 569 static /*@notnull@*/ /*@special@*/ exprNode
 570   exprNode_createPartialCopy (exprNode e)
 571   /*@defines result@*/
 572   /*@post:isnull result->edata, result->etext@*/
 573   /*@*/
 574 {
 575   return (exprNode_createPartialLocCopy (e, fileloc_copy (exprNode_loc (e))));
 576 }
 577
 578 static /*@notnull@*/ /*@special@*/ exprNode
 579   exprNode_createPartialNVCopy (exprNode e)
 580   /*@defines result@*/
 581   /*@post:isnull result->edata, result->etext, result->val @*/
 582   /*@*/
 583 {
 584   exprNode ret = exprNode_new ();
 585
 586   if (exprNode_isError (e))
 587     {
 588       ret->typ = ctype_unknown;
 589       ret->loc = fileloc_undefined;
 590       ret->guards = guardSet_undefined;
 591       ret->uses = sRefSet_undefined;
 592       ret->sets = sRefSet_undefined;
 593       ret->msets = sRefSet_undefined;
 594     }
 595   else
 596     {
 597       ret->typ = e->typ;
 598       ret->loc = fileloc_copy (e->loc);
 599       ret->guards = guardSet_copy (e->guards);
 600       ret->uses = sRefSet_newCopy (e->uses);
 601       ret->sets = sRefSet_newCopy (e->sets);
 602       ret->msets = sRefSet_newCopy (e->msets);
 603     }
 604
 605   ret->val = multiVal_undefined;
 606   ret->kind = XPR_EMPTY;
 607   ret->sref = sRef_undefined;
 608   ret->etext = cstring_undefined;
 609   ret->exitCode = XK_NEVERESCAPE;
 610   ret->canBreak = FALSE;
 611   ret->mustBreak = FALSE;
 612   ret->isJumpPoint = FALSE;
 613   ret->edata = exprData_undefined;
 614
 615   exprNode_defineConstraints(ret);
 616
 617   return (ret);
 618 }
 619
 620 static /*@notnull@*/ /*@special@*/ exprNode
 621   exprNode_createSemiCopy (exprNode e)
 622   /*@defines result@*/
 623   /*@post:isnull result->edata, result->etext, result->sets,
 624                  result->msets, result->uses, result->guards@*/
 625   /*@*/
 626 {
 627   if (exprNode_isError (e))
 628     {
 629       return exprNode_createPlain (ctype_unknown);
 630     }
 631   else
 632     {
 633       exprNode ret = exprNode_new ();
 634
 635       ret->typ = e->typ;
 636       ret->val = multiVal_copy (e->val);
 637       ret->loc = fileloc_copy (e->loc);
 638       ret->guards = guardSet_undefined;
 639       ret->uses = sRefSet_undefined;
 640       ret->sets = sRefSet_undefined;
 641       ret->msets = sRefSet_undefined;
 642
 643       ret->kind = XPR_EMPTY;
 644       ret->sref = sRef_undefined;
 645       ret->etext = cstring_undefined;
 646       ret->exitCode = XK_NEVERESCAPE;
 647       ret->canBreak = FALSE;
 648       ret->mustBreak = FALSE;
 649       ret->isJumpPoint = FALSE;
 650       ret->edata = exprData_undefined;
 651
 652       exprNode_defineConstraints(ret);
 653
 654       return (ret);
 655     }
 656 }
 657
 658 bool
 659 exprNode_isNullValue (exprNode e)
 660 {
 661   if (exprNode_isDefined (e))
 662     {
 663       multiVal m = exprNode_getValue (e);
 664
 665       if (multiVal_isInt (m))
 666         {
 667           return (multiVal_forceInt (m) == 0);
 668         }
 669     }
 670
 671   return FALSE;
 672 }
 673
 674 static bool
 675 exprNode_isUnknownConstant (/*@notnull@*/ exprNode e)
 676 {
 677   while (e->kind == XPR_PARENS)
 678     {
 679       e = exprData_getUopNode (e->edata);
 680
 681       if (!exprNode_isDefined (e))
 682         {
 683           return FALSE;
 684         }
 685
 686       /* evans 2002-02-05: was llassert (exprNode_isDefined (e)); but this can fail */
 687     }
 688
 689   if (e->kind == XPR_CONST)
 690     {
 691       multiVal m = exprNode_getValue (e);
 692
 693       if (multiVal_isUnknown (m))
 694         {
 695           return TRUE;
 696         }
 697     }
 698
 699   return FALSE;
 700 }
 701
 702 /*@only@*/ exprNode
 703   exprNode_numLiteral (ctype c, /*@temp@*/ cstring t,
 704                        /*@only@*/ fileloc loc, long val)
 705 {
 706   exprNode e = exprNode_createLoc (c, loc);
 707
 708   e->kind = XPR_NUMLIT;
 709
 710   llassert (multiVal_isUndefined (e->val));
 711   e->val = multiVal_makeInt (val);
 712   e->edata = exprData_makeLiteral (cstring_copy (t));
 713
 714   if (val == 0)
 715     {
 716       e->sref = sRef_makeUnknown ();
 717       sRef_setDefNull (e->sref, e->loc);
 718     }
 719
 720   DPRINTF (("Num lit: %s / %s", exprNode_unparse (e), ctype_unparse (exprNode_getType (e))));
 721   return (e);
 722 }
 723
 724 /*@only@*/ exprNode
 725 exprNode_charLiteral (char c, cstring text, /*@only@*/ fileloc loc)
 726 {
 727   exprNode e = exprNode_createLoc (ctype_char, loc);
 728
 729   if (context_getFlag (FLG_CHARINTLITERAL))
 730     {
 731       e->typ = ctype_makeConj (ctype_char, ctype_int);
 732     }
 733
 734   e->kind = XPR_NUMLIT;
 735   e->val = multiVal_makeChar (c);
 736
 737   e->edata = exprData_makeLiteral (cstring_copy (text));
 738   return (e);
 739 }
 740
 741 /*@only@*/ exprNode
 742 exprNode_floatLiteral (double d, ctype ct, cstring text, /*@only@*/ fileloc loc)
 743 {
 744   exprNode e = exprNode_createLoc (ct, loc);
 745
 746   e->kind = XPR_NUMLIT;
 747     e->val = multiVal_makeDouble (d);
 748   e->edata = exprData_makeLiteral (cstring_copy (text));
 749   return (e);
 750 }
 751
 752 multiVal exprNode_getValue (exprNode e)
 753 {
 754   while (exprNode_isInParens (e)) {
 755     if (e->edata != NULL) {
 756       e = exprData_getUopNode (e->edata);
 757     } else {
 758       break;
 759     }
 760   }
 761
 762   if (exprNode_isDefined (e)) {
 763     return e->val;
 764   } else {
 765     return multiVal_undefined;
 766   }
 767 }
 768
 769 /*@only@*/ exprNode
 770 exprNode_combineLiterals (exprNode e, exprNode rest)
 771 {
 772   cstring ns;
 773
 774   /* Both must be string literals. */
 775
 776   if (exprNode_isUndefined (rest) || exprNode_isUndefined (e))
 777     {
 778       exprNode_free (rest);
 779       return e;
 780     }
 781
 782   if (!exprNode_isStringLiteral (e))
 783     {
 784       voptgenerror
 785         (FLG_SYNTAX,
 786          message ("Constant concatentation is ungrammatical: %s %s", exprNode_unparse (e),
 787                   exprNode_unparse (rest)),
 788          e->loc);
 789       exprNode_free (rest);
 790       return e;
 791     }
 792
 793   if (!exprNode_isStringLiteral (rest))
 794     {
 795       voptgenerror
 796         (FLG_SYNTAX,
 797          message ("Constant concatentation is ungrammatical: %s %s", exprNode_unparse (e), exprNode_unparse (rest)),
 798          rest->loc);
 799
 800       exprNode_free (rest);
 801       return e;
 802     }
 803
 804   ns = cstring_concat (multiVal_forceString (exprNode_getValue (e)),
 805                        multiVal_forceString (exprNode_getValue (rest)));
 806
 807   multiVal_free (e->val);
 808   exprData_free (e->edata, e->kind);
 809   e->edata = exprData_makeLiteral (cstring_copy (ns));
 810   e->val = multiVal_makeString (ns);
 811   exprNode_free (rest);
 812   return e;
 813 }
 814
 815 /*@only@*/ exprNode
 816 exprNode_rawStringLiteral (/*@only@*/ cstring t, /*@only@*/ fileloc loc)
 817 {
 818   exprNode e = exprNode_createLoc (ctype_string, loc);
 819   size_t len = cstring_length (t);
 820
 821   if (context_getFlag (FLG_STRINGLITERALLEN))
 822     {
 823       if (len > size_fromInt (context_getValue (FLG_STRINGLITERALLEN)))
 824         {
 825           voptgenerror (FLG_STRINGLITERALLEN,
 826                         message
 827                         ("String literal length (%d) exceeds maximum "
 828                          "length (%d): \"%s\"",
 829                          size_toInt (len),
 830                          context_getValue (FLG_STRINGLITERALLEN),
 831                          t),
 832                         e->loc);
 833         }
 834     }
 835
 836   e->kind = XPR_STRINGLITERAL;
 837   e->val = multiVal_makeString (cstring_copy (t));
 838   e->edata = exprData_makeLiteral (t);
 839   e->sref = sRef_makeConst (ctype_string);
 840
 841   if (context_getFlag (FLG_READONLYSTRINGS))
 842     {
 843       sRef_setAliasKind (e->sref, AK_STATIC, fileloc_undefined);
 844       sRef_setExKind (e->sref, XO_OBSERVER, loc);
 845     }
 846   else
 847     {
 848       sRef_setAliasKind (e->sref, AK_ERROR, fileloc_undefined);
 849     }
 850
 851   return (e); /* s released */
 852 }
 853
 854 /*@only@*/ exprNode
 855 exprNode_wideStringLiteral (/*@only@*/ cstring t, /*@only@*/ fileloc loc)
 856 {
 857   exprNode res = exprNode_stringLiteral (t, loc);
 858   res->typ = ctype_makeWideString ();
 859   return res;
 860 }
 861
 862 /*@only@*/ exprNode
 863 exprNode_stringLiteral (/*@only@*/ cstring t, /*@only@*/ fileloc loc)
 864 {
 865   size_t len = size_fromInt (size_toInt (cstring_length (t)) - 2);
 866   char *ts = cstring_toCharsSafe (t);
 867   char *s = cstring_toCharsSafe (cstring_create (len + 1));
 868
 869   llassert (*ts == '\"' && *(ts + len + 1) == '\"');
 870   strncpy (s, ts+1, len);
 871   *(s + len) = '\0';
 872   cstring_free (t);
 873   return exprNode_rawStringLiteral (cstring_fromCharsO (s), loc);
 874 }
 875
 876 exprNode exprNode_fromUIO (cstring c)
 877 {
 878   fileloc loc = context_getSaveLocation ();
 879   exprNode e  = exprNode_createPlain (ctype_unknown);
 880
 881   e->kind = XPR_VAR;
 882
 883   if (fileloc_isUndefined (loc))
 884     {
 885       loc = fileloc_copy (g_currentloc);
 886     }
 887
 888   e->loc = loc; /* save loc was mangled */
 889   e->sref = sRef_undefined;
 890
 891   if (usymtab_exists (c))
 892     {
 893       uentry ue = usymtab_lookupEither (c);
 894
 895       if (uentry_isDatatype (ue)
 896           && uentry_isSpecified (ue))
 897         {
 898           llfatalerror
 899             (message ("%q: Specified datatype %s used in code, but not defined. "
 900                       "(Cannot continue reasonably from this error.)",
 901                       fileloc_unparse (e->loc), c));
 902         }
 903       else
 904         {
 905           BADBRANCH;
 906         }
 907     }
 908
 909   llassertprint (!usymtab_exists (c), ("Entry exists: %s", c));
 910
 911   /*
 912   ** was supercedeGlobalEntry...is this better?
 913   */
 914
 915   if (!context_inIterEnd ())
 916     {
 917       if (context_inMacro ())
 918         {
 919           if (context_getFlag (FLG_UNRECOG))
 920             {
 921               voptgenerror
 922                 (FLG_MACROUNDEF,
 923                  message ("Unrecognized identifier in macro definition: %s", c), e->loc);
 924             }
 925           else
 926             {
 927               flagcode_recordSuppressed (FLG_UNRECOG);
 928             }
 929         }
 930       else
 931         {
 932           voptgenerror
 933             (FLG_UNRECOG, message ("Unrecognized identifier: %s", c),  e->loc);
 934         }
 935     }
 936
 937   e->edata = exprData_makeId (uentry_makeUnrecognized (c, fileloc_copy (loc)));
 938
 939   /* No alias errors for unrecognized identifiers */
 940   sRef_setAliasKind (e->sref, AK_ERROR, loc);
 941
 942   return (e);
 943 }
 944
 945 exprNode exprNode_makeConstantString (cstring c, /*@only@*/ fileloc loc)
 946 {
 947   exprNode e  = exprNode_createPlain (ctype_unknown);
 948   e->kind = XPR_VAR;
 949   e->loc = loc;
 950   e->sref = sRef_makeConst (ctype_string);
 951   e->edata = exprData_makeId (uentry_makeUnrecognized (c, fileloc_copy (loc)));
 952   e->typ = ctype_string;
 953
 954   /* No alias errors for unrecognized identifiers */
 955   sRef_setAliasKind (e->sref, AK_STATIC, loc);
 956   sRef_setExKind (e->sref, XO_OBSERVER, loc);
 957
 958   return (e);
 959 }
 960
 961 exprNode exprNode_createId (/*@observer@*/ uentry c)
 962 {
 963   if (uentry_isValid (c))
 964     {
 965       exprNode e = exprNode_new ();
 966
 967       DPRINTF (("create id: %s", uentry_unparse (c)));
 968
 969       e->typ = uentry_getType (c);
 970
 971       if (uentry_isFunction (c)
 972           && !sRef_isLocalVar (uentry_getSref (c)))
 973         {
 974           e->sref = sRef_undefined;
 975         }
 976       else
 977         {
 978           e->sref = uentry_getSref (c);
 979         }
 980
 981       if (sRef_isStateUnknown (e->sref) && uentry_isNonLocal (c))
 982         {
 983           sRef_setDefined (e->sref, fileloc_undefined);
 984         }
 985
 986       /*
 987       ** yoikes!  leaving this out was a heinous bug...that would have been
 988       ** caught if i had splint working first.  gag!
 989       */
 990
 991       e->etext = cstring_undefined;
 992
 993       if (uentry_isEitherConstant (c))
 994         {
 995           e->kind = XPR_CONST;
 996           e->val = multiVal_copy (uentry_getConstantValue (c));
 997         }
 998       else
 999         {
1000           e->kind = XPR_VAR;
1001           e->val = multiVal_unknown ();
1002         }
1003
1004       e->edata = exprData_makeId (c);
1005       e->loc = context_getSaveLocation ();
1006
1007       if (fileloc_isUndefined (e->loc))
1008         {
1009           fileloc_free (e->loc);
1010           e->loc = fileloc_copy (g_currentloc);
1011         }
1012
1013       e->guards = guardSet_new ();
1014       e->sets = sRefSet_new ();
1015       e->msets = sRefSet_new ();
1016       e->uses = sRefSet_new ();
1017
1018       /*> missing fields, detected by splint <*/
1019       e->exitCode = XK_NEVERESCAPE;
1020       e->isJumpPoint = FALSE;
1021       e->canBreak = FALSE;
1022       e->mustBreak = FALSE;
1023
1024       exprNode_defineConstraints (e);
1025       return e;
1026     }
1027   else
1028     {
1029       return exprNode_createUnknown ();
1030     }
1031 }
1032
1033 /*@notnull@*/ exprNode
1034 exprNode_fromIdentifier (/*@observer@*/ uentry c)
1035 {
1036   exprNode ret;
1037
1038   if (context_justPopped ()) /* watch out! c could be dead */
1039     {
1040       uentry ce = usymtab_lookupSafe (cscannerHelp_observeLastIdentifier ());
1041
1042       if (uentry_isValid (ce))
1043         {
1044           c = ce;
1045         }
1046       else
1047         {
1048           llbuglit ("Looks like Aunt Millie forgot to walk to dog again.");
1049         }
1050     }
1051
1052   ret = exprNode_fromIdentifierAux (c);
1053   return ret;
1054 }
1055
1056 static void exprNode_checkStringLiteralLength (ctype t1, exprNode e2)
1057 {
1058   multiVal mval = exprNode_getValue (e2);
1059   cstring slit;
1060   size_t len;
1061
1062   if (ctype_isFixedArray (t1))
1063     {
1064       size_t nelements = ctype_getArraySize (t1);
1065
1066       llassert (multiVal_isString (mval));
1067       slit = multiVal_forceString (mval);
1068
1069       len = cstring_lengthExpandEscapes (slit);
1070
1071       llassert (exprNode_isDefined (e2));
1072
1073       if (len == nelements)
1074         {
1075           mstring temp;
1076
1077           temp = cstring_expandEscapes (slit);
1078
1079           if (temp[len-1] == '\0')
1080             {
1081               voptgenerror
1082                 (FLG_STRINGLITNOROOMFINALNULL,
1083                  message ("String literal with %d character%& "
1084                           "is assigned to %s (no room for final null terminator): %s",
1085                           size_toInt (len + 1),
1086                           ctype_unparse (t1),
1087                           exprNode_unparse (e2)),
1088                  e2->loc);
1089             }
1090           else
1091             {
1092               voptgenerror
1093                 (FLG_STRINGLITNOROOM,
1094                  message ("String literal with %d character%& "
1095                           "is assigned to %s (no room for null terminator): %s",
1096                           size_toInt (len + 1),
1097                           ctype_unparse (t1),
1098                           exprNode_unparse (e2)),
1099                  e2->loc);
1100             }
1101         }
1102       else if (len > nelements)
1103         {
1104           voptgenerror
1105             (FLG_STRINGLITTOOLONG,
1106              message ("String literal with %d character%& (counting null terminator) "
1107                       "is assigned to %s (insufficient storage available): %s",
1108                       size_toInt (len + 1),
1109                       ctype_unparse (t1),
1110                       exprNode_unparse (e2)),
1111              e2->loc);
1112         }
1113       else if (len < nelements - 1)
1114         {
1115           voptgenerror
1116             (FLG_STRINGLITSMALLER,
1117              message ("String literal with %d character%& is assigned to %s (possible waste of storage): %s",
1118                       size_toInt (len + 1),
1119                       ctype_unparse (t1),
1120                       exprNode_unparse (e2)),
1121              e2->loc);
1122         }
1123       else
1124         {
1125           ; /* okay */
1126         }
1127     }
1128 }
1129
1130 static /*@only@*/ /*@notnull@*/ exprNode
1131 exprNode_fromIdentifierAux (/*@observer@*/ uentry c)
1132 {
1133   exprNode e = exprNode_createId (c);
1134   sRef sr = e->sref;
1135
1136   uentry_setUsed (c, e->loc);
1137
1138   if (uentry_isVar (c) && sRef_isFileOrGlobalScope (sr))
1139     {
1140       checkGlobUse (c, FALSE, e);
1141     }
1142
1143   return (e);
1144 }
1145
1146 static bool
1147 exprNode_isZero (exprNode e)
1148 {
1149   if (exprNode_isDefined (e))
1150     {
1151       multiVal m = exprNode_getValue (e);
1152
1153       if (multiVal_isInt (m))
1154         {
1155           return (multiVal_forceInt (m) == 0);
1156         }
1157     }
1158
1159   return FALSE;
1160 }
1161
1162 static bool
1163 exprNode_isNonNegative (exprNode e)
1164 {
1165   if (exprNode_isDefined (e))
1166     {
1167       multiVal m = exprNode_getValue (e);
1168
1169       if (multiVal_isInt (m))
1170         {
1171           return (multiVal_forceInt (m) >= 0);
1172         }
1173
1174       /*
1175       ** This is not always true if programmer defines enum
1176       ** values, but then the constant should be known.
1177       */
1178
1179       if (ctype_isEnum (ctype_realType (e->typ)))
1180         {
1181           return TRUE;
1182         }
1183     }
1184
1185   return FALSE;
1186 }
1187
1188 /*
1189 ** a[x]  - uses a but NOT a[]
1190 **         result sref = a[]  (set/use in assignment)
1191 **
1192 ** The syntax x[a] is also legal in C, and has the same
1193 ** semantics.  If ind is an array, and arr is an int, flip
1194 ** the arguments.
1195 */
1196
1197 /*@only@*/ exprNode
1198 exprNode_arrayFetch (/*@only@*/ exprNode e1, /*@only@*/ exprNode e2)
1199 {
1200   /*
1201   ** error in arr, error propagates (no new messages)
1202   ** error in ind, assume valid and continue
1203   */
1204
1205   DPRINTF (("Array fetch: %s / %s",
1206             exprNode_unparse (e1), exprNode_unparse (e2)));
1207
1208   if (exprNode_isError (e1))
1209     {
1210       exprNode_free (e2);
1211       return (exprNode_makeError ());
1212     }
1213   else
1214     {
1215       exprNode arr;
1216       exprNode ind;
1217       ctype carr = exprNode_getType (e1);
1218       ctype crarr = ctype_realType (carr);
1219
1220       /*
1221       ** this sets up funny aliasing, that leads to spurious
1222       ** splint errors.  Hence, the i2 comments.
1223       */
1224
1225       /* evans 2001-09-09 added ctype_isKnown so there is no swap when e1 type is unknown */
1226       if (ctype_isKnown (crarr)
1227           && !ctype_isRealArray (crarr)
1228           && ctype_isRealNumeric (crarr)
1229           && !exprNode_isError (e2)
1230           && ctype_isRealAP (exprNode_getType (e2)))  /* fetch like 3[a] */
1231         {
1232           arr = e2;
1233           ind = e1;
1234
1235           carr = exprNode_getType (arr);
1236           crarr = ctype_realType (carr);
1237         }
1238       else
1239         {
1240           arr = e1;
1241           ind = e2;
1242         }
1243
1244       DPRINTF (("arr: %s", exprNode_unparse (arr)));
1245
1246       if (sRef_possiblyNull (arr->sref))
1247         {
1248           if (!usymtab_isGuarded (arr->sref))
1249             {
1250               if (!context_inSizeof() )
1251                 {
1252                   if (optgenerror (FLG_NULLDEREF,
1253                                    message ("Index of %s pointer %q: %s",
1254                                             sRef_nullMessage (arr->sref),
1255                                             sRef_unparse (arr->sref),
1256                                             exprNode_unparse (arr)),
1257                                    arr->loc))
1258                     {
1259                       DPRINTF (("ref: %s", sRef_unparseFull (arr->sref)));
1260                       sRef_showNullInfo (arr->sref);
1261
1262                       /* suppress future messages */
1263                       sRef_setNullError (arr->sref);
1264                     }
1265                 }
1266             }
1267         }
1268
1269       if (exprNode_isError (ind))
1270         {
1271           if ((ctype_isArrayPtr (crarr)
1272                && !ctype_isFunction (crarr))
1273               || ctype_isUnknown (carr))
1274             {
1275               exprNode ret = exprNode_createPartialCopy (arr);
1276
1277               if (ctype_isKnown (carr))
1278                 {
1279                   ret->typ = ctype_baseArrayPtr (crarr);
1280                 }
1281               else
1282                 {
1283                   ret->typ = ctype_unknown;
1284                 }
1285
1286               ret->sref = sRef_makeArrayFetch (arr->sref);
1287
1288               ret->kind = XPR_FETCH;
1289
1290               /*
1291               ** Because of funny aliasing (when arr and ind are
1292               ** flipped) spurious errors would be reported here.
1293               */
1294
1295               /*@i2@*/ ret->edata = exprData_makePair (arr, ind);
1296               checkSafeUse (ret, arr->sref);
1297               return (ret);
1298             }
1299           else
1300             {
1301               voptgenerror (FLG_TYPE,
1302                             message ("Array fetch from non-array (%t): %s[%s]", carr,
1303                                      exprNode_unparse (e1), exprNode_unparse (e2)),
1304                             arr->loc);
1305               exprNode_free (arr);
1306               return (exprNode_makeError ());
1307             }
1308         }
1309       else
1310         {
1311           if (!ctype_isForceRealInt (&(ind->typ)))
1312             {
1313               ctype rt = ctype_realType (ind->typ);
1314
1315               if (ctype_isChar (rt))
1316                 {
1317                   vnoptgenerror
1318                     (FLG_CHARINDEX,
1319                      message ("Array fetch using non-integer, %t: %s[%s]",
1320                               ind->typ,
1321                               exprNode_unparse (e1), exprNode_unparse (e2)),
1322                      arr->loc);
1323                 }
1324               else if (ctype_isEnum (rt))
1325                 {
1326                   vnoptgenerror
1327                     (FLG_ENUMINDEX,
1328                      message ("Array fetch using non-integer, %t: %s[%s]",
1329                               ind->typ,
1330                               exprNode_unparse (e1), exprNode_unparse (e2)),
1331                      arr->loc);
1332                 }
1333               else
1334                 {
1335                   voptgenerror
1336                     (FLG_TYPE,
1337                      message ("Array fetch using non-integer, %t: %s[%s]",
1338                               ind->typ,
1339                               exprNode_unparse (e1), exprNode_unparse (e2)),
1340                      arr->loc);
1341                 }
1342
1343               multiVal_free (ind->val);
1344               ind->val = multiVal_unknown ();
1345             }
1346
1347           if (ctype_isArrayPtr (crarr) && !ctype_isFunction (crarr))
1348             {
1349               exprNode ret = exprNode_createSemiCopy (arr);
1350               multiVal m = exprNode_getValue (ind);
1351
1352               ret->typ = ctype_baseArrayPtr (crarr);
1353               ret->kind = XPR_FETCH;
1354
1355               if (multiVal_isInt (m))
1356                 {
1357                   int i = (int) multiVal_forceInt (m);
1358
1359                   if (sRef_isValid (arr->sref)) {
1360                     ret->sref = sRef_makeArrayFetchKnown (arr->sref, i);
1361                   } else {
1362                     ret->sref = sRef_undefined;
1363                   }
1364                 }
1365               else
1366                 {
1367                   ret->sref = sRef_makeArrayFetch (arr->sref);
1368                 }
1369
1370               ret->sets = sRefSet_realNewUnion (arr->sets, ind->sets);
1371               ret->msets = sRefSet_realNewUnion (arr->msets, ind->msets);
1372               ret->uses = sRefSet_realNewUnion (arr->uses, ind->uses);
1373
1374               /* (see comment on spurious errors above) */
1375               /*@i2@*/ ret->edata = exprData_makePair (arr, ind);
1376
1377               exprNode_checkUse (ret, ind->sref, ind->loc);
1378               exprNode_checkUse (ret, arr->sref, arr->loc);
1379
1380               return (ret);
1381             }
1382           else
1383             {
1384               if (ctype_isUnknown (carr))
1385                 {
1386                   exprNode ret = exprNode_createPartialCopy (arr);
1387
1388                   ret->kind = XPR_FETCH;
1389                   ret->typ = ctype_unknown;
1390                   ret->sets = sRefSet_union (ret->sets, ind->sets);
1391                   ret->msets = sRefSet_union (ret->msets, ind->msets);
1392                   ret->uses = sRefSet_union (ret->uses, ind->uses);
1393
1394                   /* (see comment on spurious errors above) */
1395                   /*@i2@*/ ret->edata = exprData_makePair (arr, ind);
1396
1397                   exprNode_checkUse (ret, ind->sref, ind->loc);
1398                   exprNode_checkUse (ret, arr->sref, arr->loc);
1399                   return (ret);
1400                 }
1401               else
1402                 {
1403                   voptgenerror
1404                     (FLG_TYPE,
1405                      message ("Array fetch from non-array (%t): %s[%s]", carr,
1406                               exprNode_unparse (e1), exprNode_unparse (e2)),
1407                      arr->loc);
1408
1409                   exprNode_free (arr);
1410                   exprNode_free (ind);
1411
1412                   return (exprNode_makeError ());
1413                 }
1414             }
1415         }
1416     }
1417   BADEXIT;
1418 }
1419
1420
1421 static int
1422 checkArgs (uentry fcn, /*@dependent@*/ exprNode f, ctype t,
1423            exprNodeList args, exprNode ret)
1424 {
1425   return (checkArgsReal (fcn, f, ctype_argsFunction (t), args, FALSE, ret));
1426 }
1427
1428 /*
1429 ** checkPrintfArgs --- checks arguments for printf-like functions
1430 **    Arguments before ... have already been checked.
1431 **    The argument before the ... is a char *.
1432 **    argno is the format string argument.
1433 */
1434
1435 static void
1436 checkPrintfArgs (/*@notnull@*/ /*@dependent@*/ exprNode f, uentry fcn,
1437                  exprNodeList args, exprNode ret, int argno)
1438 {
1439   /*
1440   ** the last argument before the elips is the format string
1441   */
1442
1443   int i = argno;
1444   fileloc formatloc;
1445   int nargs = exprNodeList_size (args);
1446   uentryList params = uentry_getParams (fcn);
1447   exprNode a;
1448
1449   /*
1450   ** These should be ensured by checkSpecialFunction
1451   */
1452
1453   llassert (uentryList_size (params) == argno + 1);
1454   llassert (uentry_isElipsisMarker (uentryList_getN (params, argno)));
1455
1456   a = exprNodeList_getN (args, argno - 1);
1457   formatloc = fileloc_copy (exprNode_loc (a));
1458
1459   if (exprNode_isDefined (a) && exprNode_isStringLiteral (a)
1460       && exprNode_knownStringValue (a))
1461     {
1462       char *format = cstring_toCharsSafe (multiVal_forceString (exprNode_getValue (a)));
1463       char *code = format;
1464       char *ocode = code;
1465
1466       nargs = exprNodeList_size (args);
1467
1468       while ((code = strchr (code, '%')) != NULL)
1469         {
1470           char *origcode = code;
1471           cstring codetext = cstring_newEmpty ();
1472           char key = *(++code);
1473           ctype modtype = ctype_int;
1474           bool modified = FALSE;
1475
1476           fileloc_addColumn (formatloc, code - ocode);
1477
1478           codetext = cstring_appendChar (codetext, key);
1479
1480           /* ignore flags */
1481           while (isFlagKey (key))
1482             {
1483               key = *(++code);
1484               codetext = cstring_appendChar (codetext, key);
1485               fileloc_incColumn (formatloc);
1486             }
1487
1488           if (key == 'm') /* skipped in syslog */
1489             {
1490               continue;
1491             }
1492
1493           /* ignore field width */
1494           while (isdigit ((int) key) != 0)
1495             {
1496               key = *(++code);
1497               codetext = cstring_appendChar (codetext, key);
1498               fileloc_incColumn (formatloc);
1499             }
1500
1501           /* ignore precision */
1502           if (key == '.')
1503             {
1504               key = *(++code);
1505               codetext = cstring_appendChar (codetext, key);
1506               fileloc_incColumn (formatloc);
1507
1508               /*
1509               ** In printf, '*' means: read the next arg as an int for the
1510               ** field width.  This seems to be missing from my copy of the
1511               ** standard x3.159-1989.  Setion 4.9.6.1 refers to * (described
1512               ** later) but never does.
1513               */
1514
1515               if (key == '*')
1516                 {
1517                   ; /* don't do anything --- handle later */
1518                 }
1519               else
1520                 {
1521                   while (isdigit ((int) key) != 0)
1522                     {
1523                       key = *(++code);
1524                       codetext = cstring_appendChar (codetext, key);
1525                       fileloc_incColumn (formatloc);
1526                     }
1527                 }
1528             }
1529
1530           if (key == 'h')
1531             {
1532               modtype = ctype_sint;  /* short */
1533               key = *(++code);
1534               codetext = cstring_appendChar (codetext, key);
1535               fileloc_incColumn (formatloc);
1536             }
1537           else if (key == 'l' || key == 'L')
1538             {
1539               modtype = ctype_lint; /* long */
1540               key = *(++code);
1541               codetext = cstring_appendChar (codetext, key);
1542               fileloc_incColumn (formatloc);
1543
1544               if (key == 'l' || key == 'L') {
1545                 modtype = ctype_llint; /* long long */
1546                 key = *(++code);
1547                 codetext = cstring_appendChar (codetext, key);
1548                 fileloc_incColumn (formatloc);
1549               }
1550             }
1551           else
1552             {
1553               ; /* no modifier */
1554             }
1555
1556           /* now, key = type of conversion to apply */
1557           ++code;
1558           fileloc_incColumn (formatloc);
1559
1560           if (key != '%')
1561             {
1562               if (i >= nargs)
1563                 {
1564                   if (optgenerror
1565                       (FLG_TYPE,
1566                        message ("No argument corresponding to %q format "
1567                                 "code %d (%%%s): \"%s\"",
1568                                 uentry_getName (fcn),
1569                                 i, codetext,
1570                                 cstring_fromChars (format)),
1571                        f->loc))
1572                     {
1573                       if (fileloc_isDefined (formatloc)
1574                           && context_getFlag (FLG_SHOWCOL))
1575                         {
1576                           llgenindentmsg (cstring_makeLiteral ("Corresponding format code"),
1577                                           formatloc);
1578                         }
1579                     }
1580                   i++;
1581                 }
1582               else
1583                 {
1584                   a = exprNodeList_getN (args, i);
1585                   i++;
1586
1587                   if (!exprNode_isError (a))
1588                     {
1589                       ctype expecttype;
1590
1591                       switch (key)
1592                         {
1593                         case '*': /* int argument for fieldwidth */
1594                           expecttype = ctype_int;
1595                           *(--code) = '%'; /* convert it for next code */
1596                           fileloc_subColumn (formatloc, 1);
1597                           /*@switchbreak@*/ break;
1598                         case 'u':
1599                         case 'o':
1600                           expecttype = ctype_combine (ctype_uint, modtype);
1601                           /*@switchbreak@*/ break;
1602
1603                         case 'i': /* int argument */
1604                         case 'd':
1605                           expecttype = ctype_combine (ctype_int, modtype);
1606                           /*@switchbreak@*/ break;
1607
1608                         case 'x': /* unsigned int */
1609                         case 'X':
1610                           expecttype = ctype_combine (ctype_uint, modtype);
1611
1612                           /*@switchbreak@*/ break;
1613
1614                         case 'e':
1615                         case 'E':
1616                         case 'g':
1617                         case 'G':
1618                         case 'f': /* double */
1619                           expecttype = ctype_combine (ctype_double, modtype);
1620                           /*@switchbreak@*/ break;
1621
1622                         case 'c': /* int converted to char (check its a char?) */
1623                           expecttype = ctype_makeConj (ctype_int,
1624                                                        ctype_makeConj (ctype_char,
1625                                                                        ctype_uchar));
1626                           /*@i231@*/
1627                           /* evans 2001-10-05 - changed to reflect correct ISO spec:
1628                              int converted to char */
1629
1630                           /* expecttype = ctype_makeConj (ctype_char, ctype_uchar); */
1631                           /*@switchbreak@*/ break;
1632
1633                         case 's': /* string */
1634                           expecttype = ctype_string;
1635                           /*@switchbreak@*/ break;
1636                         case '[':
1637                           /* skip to ']' */
1638                           while (((key = *(++code)) != ']')
1639                                  && (key != '\0'))
1640                             {
1641                               codetext = cstring_appendChar (codetext, key);
1642                               fileloc_incColumn (formatloc);
1643                             }
1644
1645                           if (key == '\0')
1646                             {
1647                               llfatalerrorLoc
1648                                 (message ("Bad character set format: %s",
1649                                           cstring_fromChars (origcode)));
1650                             }
1651
1652                           expecttype = ctype_string;
1653                           /*@switchbreak@*/ break;
1654
1655                         case 'p': /* pointer */
1656                           expecttype = ctype_makePointer (ctype_void);
1657                           /* need not be defined */
1658                           uentry_setDefState (regArg, SS_RELDEF);
1659                           sRef_setPosNull (uentry_getSref (regArg),
1660                                            fileloc_undefined);
1661                           /* could be null */
1662                           /*@switchbreak@*/ break;
1663
1664                         case 'n': /* pointer to int, modified by call! */
1665                           expecttype = ctype_combine (ctype_makePointer (ctype_int), modtype);
1666                           modified = TRUE;
1667                           uentry_setDefState (regArg, SS_ALLOCATED); /* corresponds to out */
1668                           /*@switchbreak@*/ break;
1669
1670                         case 'm': /* in a syslog, it doesn't consume an argument */
1671                           /* should check we're really doing syslog */
1672
1673                           /*@switchbreak@*/ break;
1674
1675
1676                         default:
1677                           expecttype = ctype_unknown;
1678
1679                           voptgenerror
1680                             (FLG_FORMATCODE,
1681                              message ("Unrecognized format code: %s",
1682                                       cstring_fromChars (origcode)),
1683                              fileloc_isDefined (formatloc)
1684                              ? formatloc : g_currentloc);
1685
1686                           /*@switchbreak@*/ break;
1687                         }
1688
1689                       if (!(exprNode_matchArgType (expecttype, a)))
1690                         {
1691                           if (ctype_isVoidPointer (expecttype)
1692                               && ctype_isRealAbstract (a->typ)
1693                               && (context_getFlag (FLG_ABSTVOIDP)))
1694                             {
1695                               ;
1696                             }
1697                           else
1698                             {
1699                               if (llgenformattypeerror
1700                                   (expecttype, exprNode_undefined,
1701                                    a->typ, a,
1702                                    message ("Format argument %d to %q (%%%s) expects "
1703                                             "%t gets %t: %s",
1704                                             i - argno,
1705                                             uentry_getName (fcn),
1706                                             codetext,
1707                                             expecttype,
1708                                             a->typ, exprNode_unparse (a)),
1709                                    a->loc))
1710                                 {
1711                                   if (fileloc_isDefined (formatloc)
1712                                       && context_getFlag (FLG_SHOWCOL))
1713                                     {
1714                                       llgenindentmsg
1715                                         (cstring_makeLiteral
1716                                          ("Corresponding format code"),
1717                                          formatloc);
1718                                     }
1719                                 }
1720                             }
1721                         }
1722
1723                       uentry_setType (regArg, expecttype);
1724                       checkOneArg (regArg, a, f, FALSE, i+1, nargs);
1725
1726                       if (ctype_equal (expecttype, ctype_string))
1727                         {
1728                           exprNode_checkUse (a, sRef_makePointer (a->sref), a->loc);
1729                         }
1730
1731                       uentry_setType (regArg, ctype_unknown);
1732                       uentry_fixupSref (regArg);
1733
1734                       if (modified)
1735                         {
1736                           exprNode_checkCallModifyVal (a->sref, args, f, ret);
1737                         }
1738                     }
1739                   else
1740                     {
1741                       ;
1742                     }
1743                 }
1744             }
1745
1746           ocode = code;
1747           cstring_free (codetext);
1748         }
1749
1750       if (i < nargs)
1751         {
1752           voptgenerror (FLG_TYPE,
1753                         message ("Format string for %q has %d arg%&, given %d",
1754                                  uentry_getName (fcn), i - argno, nargs - argno),
1755                         f->loc);
1756         }
1757     }
1758   else
1759     {
1760       /* no checking possible for compile-time unknown format strings */
1761       if (exprNode_isDefined (a))
1762         {
1763           voptgenerror
1764             (FLG_FORMATCONST,
1765              message ("Format string parameter to %s is not a compile-time constant: %s",
1766                       exprNode_unparse (f),
1767                       exprNode_unparse (a)),
1768              f->loc);
1769         }
1770     }
1771
1772   fileloc_free (formatloc);
1773 }
1774
1775 static void
1776 checkScanfArgs (/*@notnull@*/ /*@dependent@*/ exprNode f, uentry fcn,
1777                  exprNodeList args, exprNode ret, int argno)
1778 {
1779   int i = argno;
1780   fileloc formatloc;
1781   int nargs = exprNodeList_size (args);
1782   uentryList params = uentry_getParams (fcn);
1783   exprNode a;
1784
1785   /*
1786   ** These should be ensured by checkSpecialFunction
1787   */
1788
1789   llassert (uentryList_size (params) == argno + 1);
1790   llassert (uentry_isElipsisMarker (uentryList_getN (params, argno)));
1791
1792   a = exprNodeList_getN (args, argno - 1);
1793   formatloc = fileloc_copy (exprNode_loc (a));
1794
1795   if (exprNode_isDefined (a) && exprNode_isStringLiteral (a)
1796       && exprNode_knownStringValue (a))
1797     {
1798       char *format = cstring_toCharsSafe (multiVal_forceString (exprNode_getValue (a)));
1799       char *code = format;
1800       char *ocode = code;
1801
1802       nargs = exprNodeList_size (args);
1803
1804       while ((code = strchr (code, '%')) != NULL)
1805         {
1806           char *origcode = code;
1807           char key = *(++code);
1808           cstring codetext = cstring_newEmpty ();
1809           ctype modtype = ctype_int;
1810           char modifier = '\0';
1811           bool modified = TRUE;
1812           bool ignore = FALSE;
1813
1814           codetext = cstring_appendChar (codetext, key);
1815           fileloc_addColumn (formatloc, code - ocode);
1816
1817           /*
1818           ** this is based on ANSI standard library description of fscanf
1819           ** (from ANSI standard X3.159-1989, 4.9.6.1)
1820           */
1821
1822           /* '*' suppresses assignment (does not need match argument) */
1823
1824           if (key == '*')
1825             {
1826               key = *(++code);
1827               codetext = cstring_appendChar (codetext, key);
1828               modified = FALSE;
1829               ignore = TRUE;
1830               fileloc_incColumn (formatloc);
1831             }
1832
1833           /* ignore field width */
1834           while (isdigit ((int) key) != 0)
1835             {
1836               key = *(++code);
1837               codetext = cstring_appendChar (codetext, key);
1838               fileloc_incColumn (formatloc);
1839             }
1840
1841           if (key == 'h')
1842             {
1843               modtype = ctype_sint;  /* short */
1844               key = *(++code);
1845               codetext = cstring_appendChar (codetext, key);
1846               fileloc_incColumn (formatloc);
1847             }
1848           else if (key == 'l' || key == 'L')
1849             {
1850               modtype = ctype_lint; /* long */
1851               modifier = key;
1852
1853               key = *(++code);
1854               codetext = cstring_appendChar (codetext, key);
1855
1856               fileloc_incColumn (formatloc);
1857
1858               if (key == 'l' || key == 'L') {
1859                 modtype = ctype_llint; /* long long */
1860                 key = *(++code);
1861                 codetext = cstring_appendChar (codetext, key);
1862                 fileloc_incColumn (formatloc);
1863               }
1864             }
1865           else
1866             {
1867               ; /* no modifier */
1868             }
1869
1870           /* now, key = type of conversion to apply */
1871           ++code;
1872           fileloc_incColumn (formatloc);
1873
1874           if (key != '%')
1875             {
1876               if (ignore)
1877                 {
1878                   ;
1879                 }
1880               else
1881                 {
1882                   if (i >= nargs)
1883                     {
1884                       if (optgenerror
1885                           (FLG_TYPE,
1886                            message ("No argument corresponding to %q format "
1887                                     "code %d (%%%s): \"%s\"",
1888                                     uentry_getName (fcn),
1889                                     i, codetext,
1890                                     cstring_fromChars (format)),
1891                            f->loc))
1892                         {
1893                           if (fileloc_isDefined (formatloc)
1894                               && context_getFlag (FLG_SHOWCOL))
1895                             {
1896                               llgenindentmsg
1897                                 (cstring_makeLiteral ("Corresponding format code"),
1898                                  formatloc);
1899                             }
1900                         }
1901                       i++;
1902                     }
1903                   else
1904                     {
1905                       a = exprNodeList_getN (args, i);
1906                       i++;
1907
1908                       if (!exprNode_isError (a))
1909                         {
1910                           ctype expecttype;
1911
1912                           switch (key)
1913                             {
1914                             case '*': /* int argument for fieldwidth */
1915                               expecttype = ctype_makePointer (ctype_int);
1916                               *(--code) = '%'; /* convert it for next code */
1917                               fileloc_subColumn (formatloc, 1);
1918                               /*@switchbreak@*/ break;
1919                             case 'u':
1920                             case 'o':
1921                               expecttype = ctype_makePointer (ctype_combine (ctype_uint, modtype));
1922                               /*@switchbreak@*/ break;
1923
1924                             case 'i':
1925                             case 'd':
1926                             case 'x':
1927                             case 'X': /* unsigned int */
1928                               expecttype = ctype_makePointer (ctype_combine (ctype_int, modtype));
1929                               /*@switchbreak@*/ break;
1930
1931                             case 'e':
1932                             case 'E':
1933                             case 'g':
1934                             case 'G':
1935                             case 'f':
1936                               /* printf is double, scanf is float! */
1937
1938                               if (modifier == 'l')
1939                                 {
1940                                   expecttype = ctype_makePointer (ctype_double);
1941                                 }
1942                               else if (modifier == 'L')
1943                                 {
1944                                   expecttype = ctype_makePointer (ctype_ldouble);
1945                                 }
1946                               else
1947                                 {
1948                                   llassert (modifier == '\0');
1949                                   expecttype = ctype_makePointer (ctype_float);
1950                                 }
1951                               /*@switchbreak@*/ break;
1952
1953                             case 'c': /* int converted to char (check its a char?) */
1954                               expecttype = ctype_makePointer (ctype_makeConj (ctype_char, ctype_uchar));
1955                               /*@switchbreak@*/ break;
1956
1957                             case 's': /* string */
1958                               expecttype = ctype_string;
1959                               /*@switchbreak@*/ break;
1960
1961                             case '[':
1962                               /* skip to ']' */
1963                               while (((key = *(++code)) != ']')
1964                                      && (key != '\0'))
1965                                 {
1966                                   codetext = cstring_appendChar (codetext, key);
1967                                   fileloc_incColumn (formatloc);
1968                                 }
1969
1970                               if (key == '\0')
1971                                 {
1972                                   llfatalerrorLoc
1973                                     (message ("Bad character set format: %s",
1974                                               cstring_fromChars (origcode)));
1975                                 }
1976
1977                               expecttype = ctype_string;
1978                               /*@switchbreak@*/ break;
1979
1980
1981                             case 'p': /* pointer */
1982                               voptgenerror
1983                                 (FLG_FORMATCODE,
1984                                  message ("Format code should not be used in scanf: %s",
1985                                           cstring_fromChars (origcode)),
1986                                  fileloc_isDefined (formatloc)
1987                                  ? formatloc : g_currentloc);
1988
1989                               expecttype = ctype_unknown;
1990                               /*@switchbreak@*/ break;
1991
1992                             case 'n': /* pointer to int, modified by call! */
1993                               expecttype = ctype_makePointer (ctype_int);
1994                               /*@switchbreak@*/ break;
1995
1996                             default:
1997                               expecttype = ctype_unknown;
1998
1999                               voptgenerror
2000                                 (FLG_FORMATCODE,
2001                                  message ("Unrecognized format code: %s",
2002                                           cstring_fromChars (origcode)),
2003                                  fileloc_isDefined (formatloc)
2004                                  ? formatloc : g_currentloc);
2005
2006                               /*@switchbreak@*/ break;
2007                             }
2008
2009                           if (!(exprNode_matchArgType (expecttype, a)))
2010                             {
2011                               if (ctype_isVoidPointer (expecttype)
2012                                   && ctype_isRealAbstract (a->typ)
2013                                   && (context_getFlag (FLG_ABSTVOIDP)))
2014                                 {
2015                                   ;
2016                                 }
2017                               else
2018                                 {
2019                                   if (llgenformattypeerror
2020                                       (expecttype, exprNode_undefined,
2021                                        a->typ, a,
2022                                        message ("Format argument %d to %q (%%%s) expects "
2023                                                 "%t gets %t: %s",
2024                                                 i - argno,
2025                                                 uentry_getName (fcn),
2026                                                 codetext, expecttype,
2027                                                 a->typ, exprNode_unparse (a)),
2028                                        a->loc))
2029                                     {
2030                                       if (fileloc_isDefined (formatloc)
2031                                           && context_getFlag (FLG_SHOWCOL))
2032                                         {
2033                                           llgenindentmsg
2034                                             (cstring_makeLiteral
2035                                              ("Corresponding format code"),
2036                                              formatloc);
2037                                         }
2038                                     }
2039                                 }
2040                             }
2041
2042                           uentry_setType (outArg, expecttype);
2043                           checkOneArg (outArg, a, f, FALSE, i+1, nargs);
2044                           uentry_setType (outArg, ctype_unknown);
2045                           uentry_fixupSref (outArg);
2046
2047                           if (modified)
2048                             {
2049                               exprNode_checkCallModifyVal (a->sref, args, f, ret);
2050                             }
2051                         }
2052                       else
2053                         {
2054                                                   /* a->sref = sRef_undefined; */
2055                         }
2056                     }
2057                 }
2058             }
2059
2060           ocode = code;
2061           cstring_free (codetext);
2062         }
2063
2064       if (i < nargs)
2065         {
2066           voptgenerror (FLG_TYPE,
2067                         message ("Format string for %q has %d arg%&, given %d",
2068                                  uentry_getName (fcn), i - argno, nargs - argno),
2069                         f->loc);
2070         }
2071     }
2072   else
2073     {
2074       /* no checking possible for compile-time unknown format strings */
2075     }
2076
2077   fileloc_free (formatloc);
2078 }
2079
2080 static void
2081 checkMessageArgs (/*@notnull@*/ /*@dependent@*/ exprNode f,
2082                   uentry fcn,
2083                   exprNodeList args,
2084                   /*@unused@*/ int argno)
2085 {
2086   /*
2087   ** the last argument before the elips is the format string
2088   */
2089
2090   int nargs = exprNodeList_size (args);
2091   int i = argno;
2092   fileloc formatloc;
2093   exprNode a;
2094
2095   a = exprNodeList_getN (args, argno - 1);
2096   formatloc = fileloc_copy (exprNode_loc (a));
2097
2098   if (ctype_isUnknown (cstringType)) {
2099     if (usymtab_existsType (cstring_makeLiteralTemp ("cstring")))
2100       {
2101         cstringType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("cstring"));
2102       }
2103   }
2104
2105   if (ctype_isUnknown (ctypeType)) {
2106     if (usymtab_existsType (cstring_makeLiteralTemp ("ctype")))
2107       {
2108         ctypeType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("ctype"));
2109       }
2110   }
2111
2112   if (ctype_isUnknown (filelocType)) {
2113     if (usymtab_existsType (cstring_makeLiteralTemp ("fileloc")))
2114       {
2115         filelocType = usymtab_lookupAbstractType (cstring_makeLiteralTemp ("fileloc"));
2116       }
2117   }
2118
2119   if (exprNode_isDefined (a) && exprNode_isStringLiteral (a)
2120       && exprNode_knownStringValue (a))
2121     {
2122       cstring format = multiVal_forceString (exprNode_getValue (a));
2123       char *code = cstring_toCharsSafe (format);
2124       char *ocode = code;
2125
2126       nargs = exprNodeList_size (args);
2127
2128       while ((code = strchr (code, '%')) != NULL)
2129         {
2130           char *origcode = code;
2131           char key = *(++code);
2132           cstring codetext = cstring_newEmpty ();
2133           bool isOnly = FALSE;
2134
2135           codetext = cstring_appendChar (codetext, key);
2136
2137           fileloc_addColumn (formatloc, code - ocode);
2138
2139           while (key >= '0' && key <= '9')
2140             {
2141               key = *(++code);
2142               codetext = cstring_appendChar (codetext, key);
2143               fileloc_incColumn (formatloc);
2144             }
2145
2146           ++code;
2147           fileloc_incColumn (formatloc);
2148
2149           if (key != '%')
2150             {
2151               if (key == '&') /* plural marker */
2152                 {
2153                   goto nextKey;
2154                 }
2155
2156               if (i >= nargs)
2157                 {
2158                   voptgenerror
2159                     (FLG_TYPE,
2160                      message ("Message missing format arg %d (%%%s): \"%s\"",
2161                               i + 1, codetext, format),
2162                      f->loc);
2163                   i++;
2164                 }
2165               else
2166                 {
2167                   a = exprNodeList_getN (args, i);
2168                   i++;
2169
2170                 nextKey:
2171                   if (!exprNode_isError (a))
2172                     {
2173                       ctype expecttype;
2174
2175                       /*@-loopswitchbreak@*/
2176
2177                       switch (key)
2178                         {
2179                         case 'c':
2180                         case 'h':
2181                           expecttype = ctype_char; break;
2182                         case 's':
2183                           expecttype = cstringType; break;
2184                         case 'q':
2185                           expecttype = cstringType; isOnly = TRUE; break;
2186                         case 'x':
2187                           expecttype = cstringType; isOnly = TRUE; break;
2188                         case 'd': expecttype = ctype_int; break;
2189                         case 'u': expecttype = ctype_uint; break;
2190                         case 'w': expecttype = ctype_ulint; break;
2191                         case 'f': expecttype = ctype_float; break;
2192                         case 'b': expecttype = ctype_bool; break;
2193                         case 't': expecttype = ctypeType; break;
2194                         case 'p':
2195                           expecttype = ctype_makePointer (ctype_void);
2196                           /* need not be defined */
2197                           uentry_setDefState (regArg, SS_RELDEF);
2198                           sRef_setPosNull (uentry_getSref (regArg),
2199                                            fileloc_undefined);
2200                           /* could be null */
2201                           /*@switchbreak@*/ break;
2202                         case 'l': expecttype = filelocType; break;
2203                         case '&':  /* a wee bit of a hack methinks */
2204                           expecttype = ctype_int;
2205                           break;
2206                         case 'r': expecttype = ctype_bool; break;
2207                         default:
2208                           expecttype = ctype_unknown;
2209                           voptgenerror
2210                             (FLG_FORMATCODE,
2211                              message ("Unrecognized format code: %s",
2212                                       cstring_fromChars (origcode)),
2213                              fileloc_isDefined (formatloc)
2214                              ? formatloc : g_currentloc);
2215                           break;
2216                         }
2217                       /*@=loopswitchbreak@*/
2218
2219                       if (!(exprNode_matchArgType (expecttype, a)))
2220                         {
2221                           if (ctype_isVoidPointer (expecttype)
2222                               && ctype_isRealAbstract (a->typ)
2223                               && (context_getFlag (FLG_ABSTVOIDP)))
2224                             {
2225                               ;
2226                             }
2227                           else
2228                             {
2229                               if (llgenformattypeerror
2230                                   (expecttype, exprNode_undefined,
2231                                    a->typ, a,
2232                                    message ("Format argument %d to %q (%%%s) expects "
2233                                             "%t gets %t: %s",
2234                                             i - argno,
2235                                             uentry_getName (fcn),
2236                                             codetext, expecttype,
2237                                             a->typ, exprNode_unparse (a)),
2238                                    a->loc))
2239                                   {
2240                                   if (fileloc_isDefined (formatloc)
2241                                       && context_getFlag (FLG_SHOWCOL))
2242                                     {
2243                                       llgenindentmsg
2244                                         (cstring_makeLiteral
2245                                          ("Corresponding format code"),
2246                                          formatloc);
2247                                     }
2248                                 }
2249                             }
2250                         }
2251
2252                       if (ctype_equal (expecttype, cstringType))
2253                         {
2254                           if (isOnly)
2255                             {
2256                               checkOneArg (csOnlyArg, a, f, FALSE, i+1, nargs);
2257                               uentry_fixupSref (csOnlyArg);
2258                             }
2259                           else
2260                             {
2261                               checkOneArg (csArg, a, f, FALSE, i+1, nargs);
2262                               uentry_fixupSref (csArg);
2263                             }
2264                         }
2265                       else
2266                         {
2267                                                   checkOneArg (regArg, a, f, FALSE, i+1, nargs);
2268                           uentry_fixupSref (regArg);
2269                         }
2270                     }
2271                 }
2272             }
2273
2274           cstring_free (codetext);
2275         }
2276
2277       if (i < nargs)
2278         {
2279           voptgenerror (FLG_TYPE,
2280                         message ("Format string for %q has %d arg%&, given %d",
2281                                  uentry_getName (fcn), i - argno, nargs -argno),
2282                         f->loc);
2283         }
2284     }
2285   else
2286     {
2287       /* no checking possible for compile-time unknown format strings */
2288     }
2289
2290   fileloc_free (formatloc);
2291 }
2292
2293 static void
2294   checkExpressionDefinedAux (/*@notnull@*/ exprNode e1,
2295                              /*@notnull@*/ exprNode e2,
2296                              sRefSet sets1,
2297                              sRefSet sets2,
2298                              lltok op,
2299                              flagcode flag)
2300 {
2301   bool hadUncon = FALSE;
2302
2303   if (sRef_isFileOrGlobalScope (sRef_getRootBase (e1->sref)) &&
2304       sRefSet_hasUnconstrained (sets2))
2305     {
2306       voptgenerror
2307         (FLG_EVALORDERUNCON,
2308          message
2309          ("Expression may have undefined behavior (%q used in right operand "
2310           "may set global variable %q used in left operand): %s %s %s",
2311           sRefSet_unparseUnconstrained (sets2),
2312           sRef_unparse (sRef_getRootBase (e1->sref)),
2313           exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
2314          e2->loc);
2315     }
2316
2317   if (sRef_isFileOrGlobalScope (sRef_getRootBase (e2->sref)) &&
2318       sRefSet_hasUnconstrained (sets1))
2319     {
2320       voptgenerror
2321         (FLG_EVALORDERUNCON,
2322          message
2323          ("Expression has undefined behavior (%q used in left operand "
2324           "may set global variable %q used in right operand): %s %s %s",
2325           sRefSet_unparseUnconstrained (sets1),
2326           sRef_unparse (e2->sref),
2327           exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
2328          e2->loc);
2329     }
2330
2331   sRefSet_realElements (e1->uses, sr)
2332     {
2333       if (sRef_isMeaningful (sr) && sRefSet_member (sets2, sr))
2334         {
2335           voptgenerror
2336             (FLG_EVALORDER,
2337              message
2338              ("Expression has undefined behavior (left operand uses %q, "
2339               "modified by right operand): %s %s %s",
2340               sRef_unparse (sr),
2341               exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
2342              e2->loc);
2343         }
2344     } end_sRefSet_realElements;
2345
2346   sRefSet_realElements (sets1, sr)
2347     {
2348       if (sRef_isMeaningful (sr))
2349         {
2350           if (sRef_same (sr, e2->sref))
2351             {
2352               voptgenerror
2353                 (flag,
2354                  message
2355                  ("Expression has undefined behavior (value of right operand "
2356                   "modified by left operand): %s %s %s",
2357                   exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
2358                  e2->loc);
2359             }
2360           else if (sRefSet_member (e2->uses, sr))
2361             {
2362               voptgenerror
2363                 (flag,
2364                  message
2365                  ("Expression has undefined behavior (left operand modifies %q, "
2366                   "used by right operand): %s %s %s",
2367                   sRef_unparse (sr),
2368                   exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
2369                  e2->loc);
2370             }
2371           else
2372             {
2373               if (sRefSet_member (sets2, sr))
2374                 {
2375                   if (sRef_isUnconstrained (sr))
2376                     {
2377                       if (hadUncon)
2378                         {
2379                           ;
2380                         }
2381                       else
2382                         {
2383                           hadUncon = optgenerror
2384                             (FLG_EVALORDERUNCON,
2385                              message
2386                              ("Expression may have undefined behavior.  Left operand "
2387                               "calls %q; right operand calls %q.  The unconstrained "
2388                               "functions may modify global state used by "
2389                               "the other operand): %s %s %s",
2390                               sRefSet_unparseUnconstrained (sets1),
2391                               sRefSet_unparseUnconstrained (sets2),
2392                               exprNode_unparse (e1), lltok_unparse (op),
2393                               exprNode_unparse (e2)),
2394                              e2->loc);
2395                         }
2396                     }
2397                   else
2398                     {
2399                       voptgenerror
2400                         (flag,
2401                          message
2402                          ("Expression has undefined behavior (both "
2403                           "operands modify %q): %s %s %s",
2404                           sRef_unparse (sr),
2405                           exprNode_unparse (e1),
2406                           lltok_unparse (op), exprNode_unparse (e2)),
2407                          e2->loc);
2408                     }
2409                 }
2410             }
2411         }
2412     } end_sRefSet_realElements;
2413 }
2414
2415 static void checkExpressionDefined (exprNode e1, exprNode e2, lltok op)
2416 {
2417   bool hasError = FALSE;
2418
2419   if (exprNode_isError (e1) || exprNode_isError (e2))
2420     {
2421       return;
2422     }
2423
2424   if (sRefSet_member (e2->sets, e1->sref))
2425     {
2426       if (e2->kind == XPR_CALL)
2427         {
2428          ;
2429         }
2430       else
2431         {
2432           hasError = optgenerror
2433             (FLG_EVALORDER,
2434              message ("Expression has undefined behavior "
2435                       "(value of left operand %s is modified "
2436                       "by right operand %s): %s %s %s",
2437                       exprNode_unparse (e1),
2438                       exprNode_unparse (e2),
2439                       exprNode_unparse (e1), lltok_unparse (op),
2440                       exprNode_unparse (e2)),
2441              e2->loc);
2442         }
2443     }
2444
2445   if (context_getFlag (FLG_EVALORDERUNCON))
2446     {
2447       if (sRefSet_member (e2->msets, e1->sref))
2448         {
2449           if (e2->kind == XPR_CALL)
2450             {
2451               ;
2452             }
2453           else
2454             {
2455               hasError = optgenerror
2456                 (FLG_EVALORDER,
2457                  message
2458                  ("Expression has undefined behavior (value of left "
2459                   "operand may be modified by right operand): %s %s %s",
2460                   exprNode_unparse (e1), lltok_unparse (op),
2461                   exprNode_unparse (e2)),
2462                  e2->loc);
2463             }
2464         }
2465     }
2466
2467   if (!hasError)
2468     {
2469       checkExpressionDefinedAux (e1, e2, e1->sets, e2->sets, op, FLG_EVALORDER);
2470
2471       if (context_maybeSet (FLG_EVALORDERUNCON))
2472         {
2473           checkExpressionDefinedAux (e1, e2, e1->msets,
2474                                      e2->msets, op, FLG_EVALORDERUNCON);
2475         }
2476     }
2477 }
2478
2479 static void checkSequencing (exprNode p_f, exprNodeList p_args);
2480
2481 static int
2482   checkArgsReal (uentry fcn, /*@dependent@*/ exprNode f, uentryList cl,
2483                  exprNodeList args, bool isIter, exprNode ret)
2484 {
2485   int special = 0;
2486
2487   if (!exprNode_isError (f))
2488     {
2489       if (!uentryList_isMissingParams (cl))
2490         {
2491           int nargs = exprNodeList_size (args);
2492           int expectargs = uentryList_size (cl);
2493           ctype last;
2494           int i = 0;
2495
2496           if (expectargs == 0)
2497             {
2498               if (nargs != 0)
2499                 {
2500                   if (isIter)
2501                     {
2502                       voptgenerror
2503                         (FLG_TYPE,
2504                          message ("Iter %q invoked with %d args, "
2505                                   "declared void",
2506                                   uentry_getName (fcn),
2507                                   nargs),
2508                          f->loc);
2509                     }
2510                   else
2511                     {
2512                       voptgenerror
2513                         (FLG_TYPE,
2514                          message ("Function %s called with %d args, "
2515                                   "declared void",
2516                                   exprNode_unparse (f), nargs),
2517                          f->loc);
2518                     }
2519                 }
2520               return special;
2521             }
2522
2523           last = uentry_getType (uentryList_getN (cl, expectargs - 1));
2524
2525           exprNodeList_reset (args);
2526
2527           uentryList_elements (cl, current)
2528             {
2529               ctype ct = uentry_getType (current);
2530               exprNode a;
2531
2532               if (ctype_isElips (ct))
2533                 {
2534                   /*
2535                    ** do special checking for printf/scanf library functions
2536                    **
2537                    ** this is kludgey code, just for handling the special case
2538                    **
2539                    */
2540
2541                   if (uentry_isPrintfLike (fcn))
2542                     {
2543                       checkPrintfArgs (f, fcn, args, ret, i);
2544                       special = i;
2545                     }
2546                   else if (uentry_isScanfLike (fcn))
2547                     {
2548                       checkScanfArgs (f, fcn, args, ret, i);
2549                       special = i;
2550                     }
2551                   else if (uentry_isMessageLike (fcn))
2552                     {
2553                       checkMessageArgs (f, fcn, args, i);
2554                       special = i;
2555                     }
2556                   else
2557                     {
2558                       llassert (!uentry_isSpecialFunction (fcn));
2559                     }
2560
2561                   nargs = expectargs; /* avoid errors */
2562                   break;
2563                 }
2564               else
2565                 {
2566                   if (i >= nargs) break;
2567
2568                   a = exprNodeList_current (args);
2569                   exprNodeList_advance (args);
2570
2571                   i++;
2572
2573                   if (exprNode_isError (a))
2574                     {
2575                      ;
2576                     }
2577                   else
2578                     {
2579                       /*
2580                         probably necessary? I'm not sure about this one
2581                         checkMacroParen (a);
2582                         */
2583
2584                       f->guards = guardSet_union (f->guards, a->guards);
2585
2586                       DPRINTF (("match arg: %s / %s", ctype_unparse (ct), ctype_unparse (a->typ)));
2587
2588                       if (!(exprNode_matchArgType (ct, a)))
2589                         {
2590                           DPRINTF (("Args mismatch!"));
2591
2592                           if (ctype_isVoidPointer (ct)
2593                               && (ctype_isPointer (a->typ)
2594                                   && (ctype_isRealAbstract (ctype_baseArrayPtr (a->typ)))))
2595                             {
2596                               vnoptgenerror
2597                                 (FLG_ABSTVOIDP,
2598                                  message
2599                                  ("Pointer to abstract type (%t) used "
2600                                   "as void pointer "
2601                                   "(arg %d to %q): %s",
2602                                   a->typ, i,
2603                                   uentry_getName (fcn),
2604                                   exprNode_unparse (a)),
2605                                  a->loc);
2606                             }
2607                           else
2608                             {
2609                               if (isIter)
2610                                 {
2611                                   (void) gentypeerror
2612                                     (ct, exprNode_undefined,
2613                                      a->typ, a,
2614                                      message
2615                                      ("Iter %q expects arg %d to "
2616                                       "be %t gets %t: %s",
2617                                       uentry_getName (fcn),
2618                                       i, ct, a->typ, exprNode_unparse (a)),
2619                                      a->loc);
2620                                 }
2621                               else
2622                                 {
2623                                   if (gentypeerror
2624                                       (ct,
2625                                        exprNode_undefined,
2626                                        a->typ,
2627                                        a,
2628                                        message
2629                                        ("Function %q expects arg %d to be %t gets %t: %s",
2630                                         uentry_getName (fcn),
2631                                         i, ct, a->typ, exprNode_unparse (a)),
2632                                        a->loc))
2633                                     {
2634                                       DPRINTF (("Types: %s / %s",
2635                                                 ctype_unparse (ct),
2636                                                 ctype_unparse (a->typ)));
2637                                     }
2638
2639                                   /*
2640                                   ** Clear null marker for abstract types.
2641                                   ** (It is not revealed, so suppress future messages.)
2642                                   */
2643
2644                                   if (ctype_isAbstract (a->typ))
2645                                     {
2646                                       sRef_setNullUnknown (exprNode_getSref (a), a->loc);
2647                                     }
2648                                 }
2649                             }
2650                         }
2651                     }
2652                 }
2653             } end_uentryList_elements ;
2654
2655
2656           if (expectargs != nargs) /* note: not != since we may have ... */
2657             {
2658               if (ctype_isElips (last))
2659                 {
2660                   voptgenerror
2661                     (FLG_TYPE,
2662                      message ("Function %s called with %d args, expects at least %d",
2663                               exprNode_unparse (f),
2664                               nargs, expectargs - 1),
2665                      f->loc);
2666                 }
2667               else
2668                 {
2669                   if (isIter)
2670                     {
2671                       voptgenerror
2672                         (FLG_TYPE,
2673                          message ("Iter %q invoked with %d args, expects %d",
2674                                   uentry_getName (fcn), nargs, expectargs),
2675                          f->loc);
2676                     }
2677                   else
2678                     {
2679                       voptgenerror
2680                         (FLG_TYPE,
2681                          message ("Function %s called with %d args, expects %d",
2682                                   exprNode_unparse (f),
2683                                   nargs, expectargs),
2684                          f->loc);
2685                     }
2686                 }
2687             }
2688         }
2689     }
2690
2691   return special;
2692 }
2693
2694 /*
2695 ** Check for undefined code sequences in function arguments:
2696 **
2697 **   one parameter sets something used by another parameter
2698 **   one parameter sets something set  by another parameter
2699 */
2700
2701 static void
2702 checkSequencingOne (exprNode f, exprNodeList args,
2703                     /*@notnull@*/ exprNode el, int argno)
2704 {
2705   /*
2706   ** Do second loop, iff +undefunspec
2707   */
2708
2709   int checkloop;
2710   int numloops = context_maybeSet (FLG_EVALORDERUNCON) ? 2 : 1;
2711
2712   for (checkloop = 0; checkloop < numloops; checkloop++)
2713     {
2714       sRefSet thissets;
2715
2716       if (checkloop == 0)
2717         {
2718           thissets = el->sets;
2719         }
2720       else
2721         {
2722           llassert (checkloop == 1);
2723           thissets = el->msets;
2724         }
2725
2726       sRefSet_realElements (thissets, thisset)
2727         {
2728           int j;
2729
2730           /*@access exprNodeList@*/
2731           for (j = 0; j < args->nelements; j++)
2732             {
2733               exprNode jl = args->elements[j];
2734               int thisargno = j + 1;
2735
2736               if (thisargno != argno && exprNode_isDefined (jl))
2737                 {
2738                   sRefSet otheruses = jl->uses;
2739
2740                   if (sRef_isFileOrGlobalScope (sRef_getRootBase (jl->sref)) &&
2741                       sRefSet_hasUnconstrained (thissets))
2742                     {
2743                       voptgenerror
2744                         (FLG_EVALORDERUNCON,
2745                          /*@-sefparams@*/
2746                          message
2747                          ("%q used in argument %d may set "
2748                           "global variable %q used by argument %d: %s(%q)",
2749                           cstring_capitalizeFree (sRefSet_unparseUnconstrained (thissets)),
2750                           /*@=sefparams@*/
2751                           argno,
2752                           sRef_unparse (sRef_getRootBase (jl->sref)),
2753                           thisargno,
2754                           exprNode_unparse (f), exprNodeList_unparse (args)),
2755                          el->loc);
2756                     }
2757
2758                   if (sRefSet_member (otheruses, thisset))
2759                     {
2760                       if (sRef_isUnconstrained (thisset))
2761                         {
2762                           voptgenerror
2763                             (FLG_EVALORDERUNCON,
2764                              message
2765                              ("Unconstrained functions used in arguments %d (%q) "
2766                               "and %d (%s) may modify "
2767                               "or use global state in undefined way: %s(%q)",
2768                               argno,
2769                               sRefSet_unparseUnconstrainedPlain (otheruses),
2770                               thisargno,
2771                               sRef_unconstrainedName (thisset),
2772                               exprNode_unparse (f),
2773                               exprNodeList_unparse (args)),
2774                              el->loc);
2775                         }
2776                       else
2777                         {
2778                           voptgenerror
2779                             (FLG_EVALORDER,
2780                              message
2781                              ("Argument %d modifies %q, used by argument %d "
2782                               "(order of evaluation of actual parameters is "
2783                               "undefined): %s(%q)",
2784                               argno, sRef_unparse (thisset), thisargno,
2785                               exprNode_unparse (f), exprNodeList_unparse (args)),
2786                              el->loc);
2787                         }
2788                     }
2789                   else
2790                     {
2791                       sRefSet othersets = jl->sets;
2792
2793                       if (sRefSet_member (othersets, thisset))
2794                         {
2795                           if (sRef_isUnconstrained (thisset))
2796                             {
2797                               voptgenerror
2798                                 (FLG_EVALORDERUNCON,
2799                                  message
2800                                  ("Unconstrained functions used in "
2801                                   "arguments %d (%q) and %d (%s) may modify "
2802                                   "or use global state in undefined way: %s(%q)",
2803                                   argno,
2804                                   sRefSet_unparseUnconstrainedPlain (othersets),
2805                                   thisargno,
2806                                   sRef_unconstrainedName (thisset),
2807                                   exprNode_unparse (f), exprNodeList_unparse (args)),
2808                                  el->loc);
2809                             }
2810                           else
2811                             {
2812                               voptgenerror
2813                                 (FLG_EVALORDER,
2814                                  message
2815                                  ("Argument %d modifies %q, set by argument %d (order of"
2816                                   " evaluation of actual parameters is undefined): %s(%q)",
2817                                   argno, sRef_unparse (thisset), thisargno,
2818                                   exprNode_unparse (f), exprNodeList_unparse (args)),
2819                                  el->loc);
2820                             }
2821                         }
2822                     }
2823                 }
2824             }
2825           /*@noaccess exprNodeList@*/
2826         } end_sRefSet_realElements;
2827     }
2828 }
2829
2830 static void
2831 checkSequencing (exprNode f, exprNodeList args)
2832 {
2833   if (exprNodeList_size (args) > 1)
2834     {
2835       int i;
2836       exprNode el;
2837
2838       /*@access exprNodeList*/
2839
2840       for (i = 0; i < args->nelements; i++)
2841         {
2842           el = args->elements[i];
2843
2844           if (!exprNode_isError (el))
2845             {
2846               checkSequencingOne (f, args, el, i + 1);
2847             }
2848         }
2849       /*@noaccess exprNodeList*/
2850     }
2851 }
2852
2853 /*
2854 ** requires le = exprNode_getUentry (f)
2855 */
2856
2857 static void
2858 checkGlobMods (/*@notnull@*/ /*@dependent@*/ exprNode f,
2859                uentry le, exprNodeList args,
2860                /*@notnull@*/ exprNode ret, int specialArgs)
2861 {
2862   bool isSpec = FALSE;
2863   bool hasMods = FALSE;
2864   cstring fname;
2865   globSet usesGlobs = globSet_undefined;
2866   sRefSet mods = sRefSet_undefined;
2867   bool freshMods = FALSE;
2868   uentryList params = uentryList_undefined;
2869
2870   DPRINTF (("Check glob mods: %s", exprNode_unparse (ret)));
2871
2872   /*
2873   ** check globals and modifies
2874   */
2875
2876   setCodePoint ();
2877
2878   if (!uentry_isValid (le))
2879     {
2880       ctype fr = ctype_realType (f->typ);
2881
2882       if (ctype_isFunction (fr))
2883         {
2884           params = ctype_argsFunction (fr);
2885         }
2886       else
2887         {
2888           params = uentryList_missingParams;
2889         }
2890
2891       if (!context_getFlag (FLG_MODNOMODS)
2892           && !context_getFlag (FLG_GLOBUNSPEC))
2893         {
2894           checkUnspecCall (f, params, args);
2895         }
2896
2897       return;
2898     }
2899
2900   fname = uentry_rawName (le);
2901
2902   setCodePoint ();
2903
2904   if (uentry_isFunction (le))
2905     {
2906       params = uentry_getParams (le);
2907       mods = uentry_getMods (le);
2908       hasMods = uentry_hasMods (le);
2909       usesGlobs = uentry_getGlobs (le);
2910       isSpec = uentry_isSpecified (le);
2911     }
2912   else /* not a function */
2913     {
2914       ctype ct = ctype_realType (uentry_getType (le));
2915
2916       llassertprint (uentry_isVar (le) && ctype_isFunction (ct),
2917                      ("checkModGlobs: uentry not a function: %s",
2918                       uentry_unparse (le)));
2919
2920       params = ctype_argsFunction (ct);
2921       return; /*@32 ! remove this? */
2922     }
2923
2924   /*
2925   ** check globals
2926   */
2927
2928   setCodePoint ();
2929
2930   globSet_allElements (usesGlobs, el)
2931     {
2932       if (sRef_isValid (el))
2933         {
2934           if (sRef_isInternalState (el) || sRef_isSystemState (el))
2935             {
2936               context_usedGlobal (el);
2937               exprNode_checkUse (f, el, f->loc);
2938
2939               if (context_checkInternalUse ())
2940                 {
2941                   if (!context_globAccess (el))
2942                     {
2943                       if (sRef_isSystemState (el)
2944                           && !context_getFlag (FLG_MODFILESYSTEM))
2945                         {
2946                           ;
2947                         }
2948                       else
2949                         {
2950                           voptgenerror
2951                             (FLG_INTERNALGLOBS,
2952                              message
2953                              ("Called procedure %s may access %q, but "
2954                               "globals list does not include globals %s",
2955                               exprNode_unparse (f),
2956                               sRef_unparse (el),
2957                               cstring_makeLiteralTemp (sRef_isInternalState (el)
2958                                                        ? "internalState"
2959                                                        : "fileSystem")),
2960                              f->loc);
2961                         }
2962                     }
2963                 }
2964             }
2965           else if (sRef_isNothing (el) || sRef_isSpecState (el))
2966             {
2967               ;
2968             }
2969           else
2970             {
2971               uentry gle = sRef_getUentry (el);
2972               sRef sr = sRef_updateSref (el);
2973
2974               if (sRef_isUndefGlob (el))
2975                 {
2976                   sRef_setDefined (sr, f->loc);
2977                   exprNode_checkSet (f, sr);
2978                 }
2979               else
2980                 {
2981                   /*
2982                   ** check definition
2983                   */
2984
2985                   if (sRef_isAllocated (el))
2986                     {
2987                       exprNode_checkSet (f, sr);
2988                     }
2989                   else
2990                     {
2991                       if (sRef_isStateUndefined (sr))
2992                         {
2993                           voptgenerror
2994                             (FLG_GLOBSTATE,
2995                              message
2996                              ("%s %q used by function undefined before call: %s",
2997                               sRef_getScopeName (sr),
2998                               sRef_unparse (sr),
2999                               exprNode_unparse (f)),
3000                              f->loc);
3001                           sRef_setDefined (sr, f->loc);
3002                         }
3003                       exprNode_checkUse (f, sr, f->loc);
3004                     }
3005
3006                   checkGlobUse (gle, TRUE, f);
3007                 }
3008
3009               if (sRef_isKilledGlob (el))
3010                 {
3011                   sRef_kill (sr, f->loc);
3012                   context_usedGlobal (sr);
3013                 }
3014             }
3015         }
3016     } end_globSet_allElements;
3017
3018   /*
3019   ** check modifies
3020   */
3021
3022   if (context_hasMods () || context_getFlag (FLG_MODNOMODS))
3023     {
3024       sRefSet smods = sRefSet_undefined;
3025
3026       /*
3027       ** NEED to check for modifies anything
3028       */
3029
3030       /*
3031       ** check each sRef that called function modifies (ml), is
3032       ** modifiable by tl
3033       */
3034
3035       setCodePoint ();
3036
3037       sRefSet_allElements (mods, s) /* s is something which may be modified */
3038         {
3039           DPRINTF (("Check modify: %s", sRef_unparse (s)));
3040
3041           if (sRef_isKindSpecial (s))
3042             {
3043               if (sRef_isSpecInternalState (s))
3044                 {
3045                   if (context_getFlag (FLG_MODINTERNALSTRICT))
3046                     {
3047                       exprNode_checkCallModifyVal (s, args, f, ret);
3048                     }
3049                   else
3050                     {
3051                       sRefSet mmods = context_modList ();
3052
3053                       sRefSet_allElements (mmods, el)
3054                         {
3055                           if (sRef_isInternalState (el))
3056                             {
3057                               sRef_setModified (el);
3058                             }
3059                         } end_sRefSet_allElements ;
3060                     }
3061                 }
3062               else
3063                 {
3064                   exprNode_checkCallModifyVal (s, args, f, ret);
3065                 }
3066             }
3067           else
3068             {
3069               sRef rb = sRef_getRootBase (s);
3070
3071               if (sRef_isFileOrGlobalScope (rb))
3072                 {
3073                   context_usedGlobal (rb);
3074                 }
3075
3076               if (sRef_isFileStatic (s)
3077                   && !fileId_equal (fileloc_fileId (f->loc),
3078                                     fileloc_fileId (uentry_whereDefined (le))))
3079                 {
3080                   smods = sRefSet_insert (smods, s);
3081                 }
3082               else
3083                 {
3084                   exprNode_checkCallModifyVal (s, args, f, ret);
3085                 }
3086             }
3087         } end_sRefSet_allElements;
3088
3089       setCodePoint ();
3090
3091       /*
3092       ** Static elements in modifies set can have nasty consequences.
3093       ** (I think...have not been able to reproduce a possible bug.)
3094       */
3095
3096       if (!sRefSet_isDefined (smods))
3097         {
3098           mods = sRefSet_newCopy (mods);
3099           freshMods = TRUE;
3100
3101           sRefSet_allElements (smods, el)
3102             {
3103               bool res = sRefSet_delete (mods, el);
3104
3105               llassert (res);
3106             } end_sRefSet_allElements;
3107
3108           sRefSet_free (smods);
3109         /*@-branchstate@*/
3110         }
3111       /*@=branchstate@*/
3112     }
3113   else if (sRefSet_isDefined (mods))
3114     { /* just check observers */
3115       setCodePoint ();
3116
3117       sRefSet_allElements (mods, s) /* s is something which may be modified */
3118         {
3119           sRef rb = sRef_getRootBase (s);
3120
3121           setCodePoint ();
3122
3123           if (sRef_isParam (rb))
3124             {
3125               sRef b = sRef_fixBaseParam (s, args);
3126
3127               if (sRef_isObserver (b))
3128                 {
3129                   exprNode e = exprNodeList_nth (args, sRef_getParam (rb));
3130
3131                   if (optgenerror
3132                       (FLG_MODOBSERVER,
3133                        message ("Function call may modify observer%q: %s",
3134                                 sRef_unparsePreOpt (b), exprNode_unparse (e)),
3135                        exprNode_loc (e)))
3136                     {
3137                       sRef_showExpInfo (b);
3138                     }
3139                 }
3140             }
3141         } end_sRefSet_allElements;
3142     }
3143   else
3144     {
3145       if (!hasMods) /* no specified modifications */
3146         {
3147           if (context_getFlag (FLG_MODOBSERVERUNCON))
3148             {
3149               exprNodeList_elements (args, e)
3150                 {
3151                   if (exprNode_isDefined (e))
3152                     {
3153                       sRef s = exprNode_getSref (e);
3154
3155                       if (sRef_isObserver (s)
3156                           && ctype_isMutable (sRef_getType (s)))
3157                         {
3158                           if (optgenerror
3159                               (FLG_MODOBSERVERUNCON,
3160                                message
3161                                ("Call to unconstrained function %s may modify observer%q: %s",
3162                                 exprNode_unparse (f),
3163                                 sRef_unparsePreOpt (s), exprNode_unparse (e)),
3164                                exprNode_loc (e)))
3165                             {
3166                               sRef_showExpInfo (s);
3167                             }
3168                         }
3169                     }
3170                 } end_exprNodeList_elements;
3171             }
3172         }
3173     }
3174
3175   checkAnyCall (f, fname, params, args, hasMods, mods, isSpec, specialArgs);
3176
3177   ret->uses = sRefSet_union (ret->uses, f->uses);
3178   ret->sets = sRefSet_union (ret->sets, f->sets);
3179   ret->msets = sRefSet_union (ret->msets, f->msets);
3180
3181   if (freshMods)
3182     {
3183       /*
3184       ** Spurious errors reported, because splint can't tell
3185       ** mods must be fresh if freshMods is true.
3186       */
3187
3188       /*@i@*/ sRefSet_free (mods);
3189     }
3190
3191   setCodePoint ();
3192 }
3193
3194 void checkGlobUse (uentry glob, bool isCall, /*@notnull@*/ exprNode e)
3195 {
3196   if (uentry_isVar (glob))
3197     {
3198       if (context_inFunctionLike ())
3199         {
3200           sRef sr = uentry_getSref (glob);
3201
3202           context_usedGlobal (sr);
3203
3204           if (context_checkGlobUse (glob))
3205             {
3206               if (!context_globAccess (sr))
3207                 {
3208                   if (isCall)
3209                     {
3210                       voptgenerror
3211                         (FLG_GLOBALS,
3212                          message ("Called procedure %s may access %s %q",
3213                                   exprNode_unparse (e),
3214                                   sRef_unparseScope (sr),
3215                                   uentry_getName (glob)),
3216                          e->loc);
3217                     }
3218                   else
3219                     {
3220                       voptgenerror
3221                         (FLG_GLOBALS,
3222                          message ("Undocumented use of %s %s",
3223                                   sRef_unparseScope (sr),
3224                                   exprNode_unparse (e)),
3225                          e->loc);
3226                     }
3227                 }
3228             }
3229         }
3230     }
3231   else
3232     {
3233       llbug (message ("Global not variable: %q", uentry_unparse (glob)));
3234     }
3235 }
3236
3237 static void
3238 reflectEnsuresClause (exprNode ret, uentry le, exprNode f, exprNodeList args)
3239 {
3240   DPRINTF (("Reflect ensures clause: %s(%s) / %s / %s",
3241             exprNode_unparse (f), exprNodeList_unparse (args),
3242             uentry_unparseFull (le),
3243             stateClauseList_unparse (uentry_getStateClauseList (le))));
3244
3245   if (uentry_isValid (le) && uentry_isFunction (le))
3246     {
3247       stateClauseList sclauses = uentry_getStateClauseList (le);
3248
3249       if (stateClauseList_isDefined (sclauses))
3250         {
3251           DPRINTF (("Reflect ensures: %s / %s / %s",
3252                     uentry_unparse (le),
3253                     exprNode_unparse (f), exprNodeList_unparse (args)));
3254
3255           stateClauseList_elements (sclauses, cl)
3256             {
3257               if (stateClause_hasEnsures (cl))
3258                 {
3259                   /* Same in usymtab.c:1904 */
3260                   if (stateClause_setsMetaState (cl))
3261                     {
3262                       qual q = stateClause_getMetaQual (cl);
3263                       annotationInfo ainfo = qual_getAnnotationInfo (q);
3264                       metaStateInfo minfo = annotationInfo_getState (ainfo);
3265                       cstring key = metaStateInfo_getName (minfo);
3266                       int mvalue = annotationInfo_getValue (ainfo);
3267
3268                       sRefSet osrs = sRefSet_undefined;
3269                       sRefSet srs;
3270
3271                       if (stateClause_isGlobal (cl))
3272                         {
3273                           srs = sRefSet_single (usymtab_lookupGlobalMarker ());
3274                           osrs = srs;
3275                         }
3276                       else
3277                         {
3278                           srs = stateClause_getRefs (cl);
3279                         }
3280
3281                       DPRINTF (("Reflect ensures clause: %s", stateClause_unparse (cl)));
3282
3283
3284                       DPRINTF (("Sets meta state! %s", stateClause_unparse (cl)));
3285
3286                       sRefSet_elements (srs, sel)
3287                         {
3288                           sRef s;
3289
3290                           if (sRef_isResult (sRef_getRootBase (sel)))
3291                             {
3292                               s = exprNode_getSref (ret);
3293                             }
3294                           else
3295                             {
3296                               s = sRef_fixBaseParam (sel, args);
3297                             }
3298
3299                           DPRINTF (("Reflecting state clause on: %s / %s",
3300                                     sRef_unparse (sel), sRef_unparse (s)));
3301
3302                           sRef_setMetaStateValueComplete (s, key, mvalue, exprNode_loc (f));
3303                         } end_sRefSet_elements;
3304
3305                       sRefSet_free (osrs);
3306                     }
3307                   else
3308                     {
3309                       sRefSet srs = stateClause_getRefs (cl);
3310                       sRefModVal modf = stateClause_getEnsuresFunction (cl);
3311                       int eparam = stateClause_getStateParameter (cl);
3312
3313                       llassert (modf != NULL);
3314
3315                       DPRINTF (("Reflect after clause: %s / %s",
3316                                 stateClause_unparse (cl),
3317                                 sRefSet_unparse (srs)));
3318
3319                       sRefSet_elements (srs, sel)
3320                         {
3321                           sRef s;
3322
3323                           DPRINTF (("elements: %s", sRef_unparse (sel)));
3324                           DPRINTF (("elements: %s", sRef_unparseFull (sel)));
3325
3326                           if (sRef_isResult (sRef_getRootBase (sel)))
3327                             {
3328                               DPRINTF (("Fix base: %s / %s",
3329                                         sRef_unparse (sel), sRef_unparse (exprNode_getSref (ret))));
3330                               s = sRef_fixBase (sel, exprNode_getSref (ret));
3331                               DPRINTF (("==> %s", sRef_unparseFull (s)));
3332                             }
3333                           else
3334                             {
3335                               s = sRef_fixBaseParam (sel, args);
3336                             }
3337
3338                           DPRINTF (("elements: %s", sRef_unparse (s)));
3339                           DPRINTF (("elements: %s", sRef_unparseFull (s)));
3340
3341                           DPRINTF (("Reflecting state clause on: %s / %s",
3342                                     sRef_unparseFull (sel), sRef_unparseFull (s)));
3343
3344                           /* evans 2001-08-24 - added aliasSetCompleteParam */
3345                           sRef_aliasSetCompleteParam (modf, s, eparam, exprNode_loc (f));
3346
3347                           DPRINTF (("After reflecting state clause on: %s / %s",
3348                                     sRef_unparseFull (sel), sRef_unparseFull (s)));
3349                         } end_sRefSet_elements;
3350                     }
3351                 }
3352             } end_stateClauseList_elements ;
3353         }
3354
3355       DPRINTF (("Here: %s / %s",
3356                 uentry_unparseFull (le),
3357                 bool_unparse (uentry_hasMetaStateEnsures (le))));
3358
3359       if (uentry_hasMetaStateEnsures (le))
3360         {
3361           fileloc loc = exprNode_loc (f);
3362
3363           metaStateConstraintList mscl = uentry_getMetaStateEnsures (le);
3364
3365           metaStateConstraintList_elements (mscl, msc)
3366             {
3367               metaStateSpecifier msspec = metaStateConstraint_getSpecifier (msc);
3368               metaStateInfo msinfo = metaStateSpecifier_getMetaStateInfo (msspec);
3369               metaStateExpression msexpr = metaStateConstraint_getExpression (msc);
3370               cstring key = metaStateInfo_getName (msinfo);
3371               sRef mlsr = metaStateSpecifier_getSref (msspec);
3372               sRef s;
3373               sRef lastref = sRef_undefined;
3374               stateValue sval = stateValue_undefined;
3375
3376               DPRINTF (("Meta state constraint for %s: %s", uentry_unparse (le),
3377                         metaStateConstraint_unparse (msc)));
3378               DPRINTF (("Matches left: %s", sRef_unparseDebug (mlsr)));
3379
3380               if (sRef_isResult (sRef_getRootBase (mlsr)))
3381                 {
3382                   s = exprNode_getSref (ret);
3383                 }
3384               else
3385                 {
3386                   s = sRef_fixBaseParam (mlsr, args);
3387                 }
3388
3389               DPRINTF (("Setting state: %s", sRef_unparseFull (s)));
3390
3391               while (metaStateExpression_isDefined (msexpr))
3392                 {
3393                   metaStateSpecifier ms = metaStateExpression_getSpecifier (msexpr);
3394                   metaStateInfo msi = metaStateSpecifier_getMetaStateInfo (ms);
3395                   sRef msr, fs;
3396
3397                   DPRINTF (("Check expression: %s", metaStateExpression_unparse (msexpr)));
3398
3399                   if (metaStateExpression_isMerge (msexpr))
3400                     {
3401                       msexpr = metaStateExpression_getRest (msexpr);
3402                     }
3403                   else
3404                     {
3405                       msexpr = metaStateExpression_undefined;
3406                     }
3407
3408                   if (metaStateInfo_isDefined (msi))
3409                     {
3410                       /* Must match lhs state */
3411                       llassert (metaStateInfo_equal (msinfo, msi));
3412                     }
3413
3414                   if (metaStateSpecifier_isElipsis (ms))
3415                     {
3416                       /*
3417                       ** For elipsis, we need to merge all the relevant elipsis parameters
3418                       **
3419                       */
3420
3421                       uentryList params = uentry_getParams (le);
3422                       int paramno = uentryList_size (params) - 1;
3423
3424                       if (!uentry_isElipsisMarker (uentryList_getN (params, paramno)))
3425                         {
3426                           voptgenerror
3427                             (FLG_TYPE,
3428                              message ("Ensures clauses uses ... for function without ... in parameter list: %q",
3429                                       uentry_getName (le)),
3430                              uentry_whereLast (le));
3431                           /*@innerbreak@*/ break;
3432                         }
3433
3434                       while (paramno < exprNodeList_size (args))
3435                         {
3436                           exprNode arg = exprNodeList_getN (args, paramno);
3437                           fs = exprNode_getSref (arg);
3438                           DPRINTF (("Merge arg: %s", exprNode_unparse (arg)));
3439
3440                           /* cut and pasted... gack*/
3441                           if (stateValue_isDefined (sval))
3442                             {
3443                               /* Use combination table to merge old state value with new one: */
3444                               stateValue tval = sRef_getMetaStateValue (fs, key);
3445
3446                               if (stateValue_isDefined (tval))
3447                                 {
3448                                   stateCombinationTable sctable = metaStateInfo_getMergeTable (msinfo);
3449                                   cstring msg = cstring_undefined;
3450                                   int nval = stateCombinationTable_lookup (sctable,
3451                                                                            stateValue_getValue (sval),
3452                                                                            stateValue_getValue (tval),
3453                                                                            &msg);
3454                                   DPRINTF (("Combining: %s + %s -> %d",
3455                                             stateValue_unparseValue (sval, msinfo),
3456                                             stateValue_unparseValue (tval, msinfo),
3457                                             nval));
3458
3459                                   if (nval == stateValue_error)
3460                                     {
3461                                       if (optgenerror
3462                                           (FLG_STATEMERGE,
3463                                            message
3464                                            ("Attributes merged in ensures clause in states that "
3465                                             "cannot be combined (%q is %q, %q is %q)%q",
3466                                             sRef_unparse (lastref),
3467                                             stateValue_unparseValue (sval, msinfo),
3468                                             sRef_unparse (fs),
3469                                             stateValue_unparseValue (tval, msinfo),
3470                                             cstring_isDefined (msg) ?
3471                                             message (": %s", msg) : cstring_undefined),
3472                                            exprNode_loc (f)))
3473                                         {
3474                                           sRef_showMetaStateInfo (fs, key);
3475                                         }
3476                                     }
3477
3478                                   stateValue_updateValueLoc (sval, nval, fileloc_undefined);
3479                                   loc = exprNode_loc (arg);
3480                                 }
3481                               else
3482                                 {
3483                                   DPRINTF (("No value for: %s:%s", sRef_unparse (fs), key));
3484                                 }
3485                             }
3486                           else
3487                             {
3488                               sval = sRef_getMetaStateValue (fs, key);
3489                             }
3490
3491                           lastref = fs;
3492
3493                           if (stateValue_isError (sval))
3494                             {
3495                               /*@innerbreak@*/ break; /* Don't merge any more values if here was an error */
3496                             }
3497
3498
3499                           paramno++;
3500                         }
3501                     }
3502                   else
3503                     {
3504                       msr = metaStateSpecifier_getSref (ms);
3505
3506
3507                       llassert (sRef_isParam (sRef_getRootBase (msr)));
3508                       fs = sRef_fixBaseParam (msr, args);
3509
3510                       if (stateValue_isDefined (sval))
3511                         {
3512                           /* Use combination table to merge old state value with new one: */
3513                           stateValue tval = sRef_getMetaStateValue (fs, key);
3514
3515                           if (stateValue_isDefined (tval))
3516                             {
3517                               stateCombinationTable sctable = metaStateInfo_getMergeTable (msinfo);
3518                               cstring msg = cstring_undefined;
3519                               int nval = stateCombinationTable_lookup (sctable,
3520                                                                        stateValue_getValue (sval),
3521                                                                        stateValue_getValue (tval),
3522                                                                        &msg);
3523                               DPRINTF (("Combining: %s + %s -> %d",
3524                                         stateValue_unparseValue (sval, msinfo),
3525                                         stateValue_unparseValue (tval, msinfo),
3526                                         nval));
3527
3528                               if (nval == stateValue_error)
3529                                 {
3530                                   if (optgenerror
3531                                       (FLG_STATEMERGE,
3532                                        message
3533                                        ("Attributes merged in ensures clause in states that "
3534                                         "cannot be combined (%q is %q, %q is %q)%q",
3535                                         sRef_unparse (lastref),
3536                                         stateValue_unparseValue (sval, msinfo),
3537                                         sRef_unparse (fs),
3538                                         stateValue_unparseValue (tval, msinfo),
3539                                         cstring_isDefined (msg)
3540                                         ? message (": %s", msg) : cstring_undefined),
3541                                        exprNode_loc (f)))
3542                                     {
3543                                       sRef_showMetaStateInfo (fs, key);
3544                                     }
3545                                 }
3546
3547                               stateValue_updateValueLoc (sval, nval, fileloc_undefined);
3548                             }
3549                           else
3550                             {
3551                               DPRINTF (("No value for: %s:%s", sRef_unparse (fs), key));
3552                             }
3553                         }
3554                       else
3555                         {
3556                           sval = sRef_getMetaStateValue (fs, key);
3557                         }
3558
3559                       lastref = fs;
3560
3561                       if (stateValue_isError (sval))
3562                         {
3563                           /*@innerbreak@*/ break; /* Don't merge any more values if here was an error */
3564                         }
3565                     }
3566                 }
3567
3568               DPRINTF (("Setting: %s:%s <- %s", sRef_unparse (s), key, stateValue_unparse (sval)));
3569
3570               if (stateValue_isDefined (sval))
3571                 {
3572                   sRef_setMetaStateValueComplete (s, key, stateValue_getValue (sval), loc);
3573                 }
3574               else
3575                 {
3576                   DPRINTF (("Undefined state: %s", cstring_toCharsSafe (sRef_unparse (s))));
3577                 }
3578             } end_metaStateConstraintList_elements ;
3579
3580           metaStateConstraintList_free (mscl);
3581         }
3582     }
3583 }
3584
3585 static void
3586 checkRequiresClause (uentry le, exprNode f, exprNodeList args)
3587 {
3588   DPRINTF (("Check requires clause: %s(%s) / %s / %s",
3589             exprNode_unparse (f), exprNodeList_unparse (args),
3590             uentry_unparseFull (le),
3591             stateClauseList_unparse (uentry_getStateClauseList (le))));
3592
3593   if (uentry_isValid (le) && uentry_isFunction (le))
3594     {
3595       stateClauseList sclauses = uentry_getStateClauseList (le);
3596
3597       if (stateClauseList_isDefined (sclauses))
3598         {
3599           DPRINTF (("Check requires: %s / %s / %s",
3600                     uentry_unparse (le),
3601                     exprNode_unparse (f), exprNodeList_unparse (args)));
3602
3603           stateClauseList_elements (sclauses, cl)
3604             {
3605               DPRINTF (("Check clause: %s / %s",
3606                         stateClause_unparse (cl),
3607                         bool_unparse (stateClause_hasRequires (cl))));
3608
3609               if (stateClause_hasRequires (cl))
3610                 {
3611                   sRefSet osrs = sRefSet_undefined;
3612                   sRefSet srs;
3613
3614                   if (stateClause_isGlobal (cl))
3615                     {
3616                       srs = sRefSet_single (usymtab_lookupGlobalMarker ());
3617                       osrs = srs;
3618                     }
3619                   else
3620                     {
3621                       srs = stateClause_getRefs (cl);
3622                     }
3623
3624                   DPRINTF (("Refs: %s", sRefSet_unparse (srs)));
3625
3626                   if (stateClause_setsMetaState (cl))
3627                     {
3628                       qual q = stateClause_getMetaQual (cl);
3629                       annotationInfo ainfo = qual_getAnnotationInfo (q);
3630                       metaStateInfo minfo = annotationInfo_getState (ainfo);
3631                       cstring key = metaStateInfo_getName (minfo);
3632                       int mvalue = annotationInfo_getValue (ainfo);
3633
3634                       DPRINTF (("Requires meta state! %s = %d", key, mvalue));
3635
3636                       sRefSet_elements (srs, sel)
3637                         {
3638                           sRef s = sRef_fixBaseParam (sel, args);
3639
3640                           if (sRef_isResult (sRef_getRootBase (sel)))
3641                             {
3642                               BADBRANCH;
3643                             }
3644                           else
3645                             {
3646                               DPRINTF (("Checking state clause on: %s / %s / %s = %d",
3647                                         sRef_unparseFull (sel), sRef_unparseFull (s),
3648                                         key, mvalue));
3649
3650                               if (!sRef_checkMetaStateValue (s, key, mvalue))
3651                                 {
3652                                   DPRINTF (("HERE: %s", sRef_unparse (s)));
3653                                   if (optgenerror
3654                                       (FLG_STATETRANSFER,
3655                                        message
3656                                        ("Requires clause of called function %q not satisfied%q (state is %q): %q",
3657                                         uentry_getName (le),
3658                                         sRef_isGlobalMarker (s)
3659                                            ? message ("")
3660                                            : message (" by %q", sRef_unparse (s)),
3661                                         stateValue_unparseValue (sRef_getMetaStateValue (s, key),
3662                                                                  minfo),
3663                                         stateClause_unparse (cl)),
3664                                        exprNode_loc (f)))
3665                                     {
3666                                       sRef_showAliasInfo (s);
3667                                     }
3668                                   else
3669                                     {
3670                                       DPRINTF (("Error supressed!"));
3671                                       DPRINTF (("Loc: %s", fileloc_unparse (exprNode_loc (f))));
3672                                       DPRINTF (("Context supress: %s",
3673                                                 bool_unparse (context_suppressFlagMsg (FLG_STATETRANSFER, exprNode_loc (f)))));
3674                                     }
3675                                 }
3676                             }
3677                         } end_sRefSet_elements;
3678                     }
3679                   else
3680                     {
3681                       sRefModVal modf = stateClause_getRequiresBodyFunction (cl);
3682                       int eparam = stateClause_getStateParameter (cl);
3683
3684                       DPRINTF (("Reflect after clause: %s / %s",
3685                                 stateClause_unparse (cl),
3686                                 sRefSet_unparse (srs)));
3687
3688                       llassert (modf != NULL);
3689
3690                       sRefSet_elements (srs, sel)
3691                         {
3692                           sRef s;
3693
3694                           DPRINTF (("elements: %s", sRef_unparse (sel)));
3695                           DPRINTF (("elements: %s", sRef_unparseFull (sel)));
3696
3697                           s = sRef_fixBaseParam (sel, args);
3698
3699                           DPRINTF (("elements: %s", sRef_unparse (s)));
3700                           DPRINTF (("elements: %s", sRef_unparseFull (s)));
3701
3702                           if (sRef_isResult (sRef_getRootBase (sel)))
3703                             {
3704                               ; /*@i423 what do we do about results */
3705                             }
3706                           else
3707                             {
3708                               DPRINTF (("Reflecting state clause on: %s / %s",
3709                                         sRef_unparse (sel), sRef_unparse (s)));
3710
3711                               modf (s, eparam, exprNode_loc (f));
3712                             }
3713                         } end_sRefSet_elements;
3714                     }
3715
3716                   sRefSet_free (osrs);
3717                 }
3718             } end_stateClauseList_elements ;
3719         }
3720     }
3721 }
3722
3723 static /*@only@*/ exprNode
3724 functionCallSafe (/*@only@*/ /*@notnull@*/ exprNode f,
3725                   ctype t, /*@keep@*/ exprNodeList args)
3726 {
3727   /* requires f is a non-error exprNode, with type function */
3728   cstring fname = exprNode_unparse (f);
3729   uentry le = exprNode_getUentry (f);
3730   exprNode ret = exprNode_createPartialCopy (f);
3731   int special;
3732
3733   setCodePoint ();
3734
3735   DPRINTF (("Call: %s %s",exprNode_unparse (f), exprNodeList_unparse (args)));
3736
3737   ret->typ = ctype_getReturnType (t);
3738   ret->kind = XPR_CALL;
3739
3740   ret->edata = exprData_makeCall (f, args);
3741
3742   /*
3743   ** Order of these steps is very important!
3744   **
3745   ** Must check for argument dependencies before messing up uses and sets.
3746   */
3747
3748   if (context_getFlag (FLG_EVALORDER))
3749     {
3750       exprNodeList_elements (args, current)
3751         {
3752           if (exprNode_isDefined (current))
3753             {
3754               exprNode_addUse (current, current->sref);
3755             }
3756         } end_exprNodeList_elements;
3757
3758       if (context_maybeSet (FLG_EVALORDER) || context_maybeSet (FLG_EVALORDERUNCON))
3759         {
3760           checkSequencing (f, args);
3761         }
3762
3763       exprNodeList_elements (args, current)
3764         {
3765           if (exprNode_isDefined (current) && sRef_isMeaningful (current->sref))
3766             {
3767               exprNode_addUse (ret, sRef_makeDerived (current->sref));
3768             }
3769         } end_exprNodeList_elements ;
3770     }
3771
3772   special = checkArgs (le, f, t, args, ret);
3773   checkGlobMods (f, le, args, ret, special);
3774   checkRequiresClause (le, f, args);
3775   setCodePoint ();
3776
3777   if (uentry_isValid (le)
3778       && (uentry_isFunction (le)
3779           || (uentry_isVariable (le)
3780               && ctype_isFunction (uentry_getType (le)))))
3781     {
3782       exitkind exk = uentry_getExitCode (le);
3783
3784       /* f->typ is already set to the return type */
3785
3786       DPRINTF (("Function: %s", uentry_unparseFull (le)));
3787       ret->sref = uentry_returnedRef (le, args, exprNode_loc (f));
3788       DPRINTF (("Returned: %s / %s",
3789                 uentry_unparseFull (le),
3790                 sRef_unparseFull (ret->sref)));
3791
3792       if (uentry_isFunction (le) && exprNodeList_size (args) >= 1)
3793         {
3794           qual nullPred = uentry_nullPred (le);
3795
3796           if (qual_isTrueNull (nullPred))
3797             {
3798               exprNode arg = exprNodeList_head (args);
3799
3800               if (exprNode_isDefined (arg))
3801                 {
3802                   ret->guards = guardSet_addFalseGuard (ret->guards, arg->sref);
3803                 }
3804             }
3805           else if (qual_isFalseNull (nullPred))
3806             {
3807               exprNode arg = exprNodeList_head (args);
3808
3809               if (exprNode_isDefined (arg))
3810                 {
3811                   ret->guards = guardSet_addTrueGuard (ret->guards, arg->sref);
3812                 }
3813             }
3814           else
3815             {
3816               llassert (qual_isUnknown (nullPred));
3817             }
3818         }
3819
3820       if (exitkind_isConditionalExit (exk))
3821         {
3822           /*
3823           ** True exit is:
3824           **    if (arg0) then { exit! } else { ; }
3825           ** False exit is:
3826           **    if (arg0) then { ; } else { exit! }
3827           */
3828
3829           exprNode firstArg;
3830
3831           llassert (!exprNodeList_isEmpty (args));
3832           firstArg = exprNodeList_head (args);
3833
3834           if (exprNode_isDefined (firstArg)
3835               && !guardSet_isEmpty (firstArg->guards))
3836             {
3837               usymtab_trueBranch (guardSet_undefined);
3838               usymtab_altBranch (guardSet_undefined);
3839
3840               if (exitkind_isTrueExit (exk))
3841                 {
3842                   usymtab_popBranches (firstArg,
3843                                        exprNode_makeMustExit (),
3844                                        exprNode_undefined,
3845                                        TRUE, TRUEEXITCLAUSE);
3846                 }
3847               else
3848                 {
3849                   usymtab_popBranches (firstArg,
3850                                        exprNode_undefined,
3851                                        exprNode_makeMustExit (),
3852                                        TRUE, FALSEEXITCLAUSE);
3853                 }
3854             }
3855
3856           ret->exitCode = XK_MAYEXIT;
3857         }
3858       else if (exitkind_mustExit (exk))
3859         {
3860           ret->exitCode = XK_MUSTEXIT;
3861         }
3862       else if (exitkind_couldExit (exk))
3863         {
3864           ret->exitCode = XK_MAYEXIT;
3865         }
3866       else
3867         {
3868           ;
3869         }
3870
3871       if (cstring_equalLit (fname, "exit"))
3872         {
3873           if (exprNodeList_size (args) == 1)
3874             {
3875               exprNode arg = exprNodeList_head (args);
3876
3877               if (exprNode_isDefined (arg) && exprNode_knownIntValue (arg))
3878                 {
3879                   long int val = multiVal_forceInt (exprNode_getValue (arg));
3880
3881                   if (val != 0)
3882                     {
3883                       voptgenerror
3884                         (FLG_EXITARG,
3885                          message
3886                          ("Argument to exit has implementation defined behavior: %s",
3887                           exprNode_unparse (arg)),
3888                          exprNode_loc (arg));
3889                     }
3890                 }
3891             }
3892         }
3893     }
3894   else
3895     {
3896       ret->sref = sRef_undefined;
3897       exprNode_checkSetAny (ret, uentry_rawName (le));
3898     }
3899
3900   DPRINTF (("Before reflect: %s", sRef_unparseFull (ret->sref)));
3901   DPRINTF (("Reflect: %s", uentry_unparseFull (le)));
3902   reflectEnsuresClause (ret, le, f, args);
3903   setCodePoint ();
3904
3905   DPRINTF (("Here: %s", sRef_unparseFull (ret->sref)));
3906   return (ret);
3907 }
3908
3909 /*
3910 ** this is yucky!  should keep the uentry as part of exprNode!
3911 */
3912
3913 uentry exprNode_getUentry (exprNode e)
3914 {
3915   if (exprNode_isError (e))
3916     {
3917       return uentry_undefined;
3918     }
3919   else
3920     {
3921       cstring s = exprNode_rootVarName (e);
3922       uentry ue = usymtab_lookupSafe (s);
3923
3924       return ue;
3925     }
3926 }
3927
3928 /*
3929 ** Returns true iff e1 and e2 are both exactly the same storage
3930 ** (conservative).
3931 */
3932
3933 static bool exprNode_sameStorage (exprNode e1, exprNode e2)
3934 {
3935   sRef s1 = exprNode_getSref (e1);
3936   sRef s2 = exprNode_getSref (e2);
3937
3938   return (sRef_realSame (s1, s2));
3939 }
3940
3941 exprNode
3942 exprNode_makeInitBlock (lltok brace, /*@only@*/ exprNodeList inits)
3943 {
3944   exprNode ret = exprNode_createPlain (ctype_unknown);
3945
3946   ret->kind = XPR_INITBLOCK;
3947   ret->edata = exprData_makeCall (exprNode_undefined, inits);
3948   ret->loc = fileloc_update (ret->loc, lltok_getLoc (brace));
3949
3950   return (ret);
3951 }
3952
3953 exprNode
3954 exprNode_functionCall (/*@only@*/ exprNode f, /*@only@*/ exprNodeList args)
3955 {
3956   ctype t;
3957
3958 # ifdef DEBUGSPLINT
3959   usymtab_checkAllValid ();
3960 # endif
3961
3962   if (exprNode_isUndefined (f))
3963     {
3964       exprNode_free (f);
3965       exprNodeList_free (args);
3966       return exprNode_undefined;
3967     }
3968
3969   t = exprNode_getType (f);
3970
3971   if (sRef_isLocalVar (f->sref))
3972     {
3973       exprNode_checkUse (f, f->sref, f->loc);
3974
3975       if (sRef_possiblyNull (f->sref))
3976         {
3977           if (!usymtab_isGuarded (f->sref))
3978             {
3979               if (optgenerror (FLG_NULLDEREF,
3980                                message ("Function call using %s pointer %q",
3981                                         sRef_nullMessage (f->sref),
3982                                         sRef_unparse (f->sref)),
3983                                f->loc))
3984                 {
3985                   sRef_showNullInfo (f->sref);
3986                   sRef_setNullError (f->sref);
3987                 }
3988             }
3989         }
3990     }
3991
3992   setCodePoint ();
3993
3994   if (ctype_isRealFunction (t))
3995     {
3996       exprNode ret = functionCallSafe (f, t, args);
3997       setCodePoint ();
3998       return ret;
3999     }
4000   else if (ctype_isUnknown (t))
4001     {
4002       exprNode ret = exprNode_createPartialCopy (f);
4003       cstring tstring;
4004
4005       setCodePoint ();
4006
4007       ret->typ = t;
4008       exprNodeList_elements (args, current)
4009         {
4010           if (exprNode_isDefined (current))
4011             {
4012               exprNode_checkUse (ret, current->sref, ret->loc);
4013
4014               /*
4015               ** also, anything derivable from current->sref may be used
4016               */
4017
4018               exprNode_addUse (ret, sRef_makeDerived (current->sref));
4019               exprNode_mergeUSs (ret, current);
4020             }
4021         } end_exprNodeList_elements;
4022
4023       ret->edata = exprData_makeCall (f, args);
4024       ret->kind = XPR_CALL;
4025
4026       tstring = cstring_copy (exprNode_unparse (f));
4027
4028       cstring_markOwned (tstring);
4029       exprNode_checkSetAny (ret, tstring);
4030
4031       return (ret);
4032     }
4033   else
4034     {
4035       voptgenerror (FLG_TYPE,
4036                     message ("Call to non-function (type %t): %s", t,
4037                              exprNode_unparse (f)),
4038                     f->loc);
4039       exprNode_free (f);
4040       exprNodeList_free (args);
4041
4042       return (exprNode_makeError ());
4043     }
4044 }
4045
4046 static exprNode
4047 exprNode_fieldAccessAux (/*@only@*/ exprNode s, /*@observer@*/ fileloc loc,
4048                          /*@only@*/ cstring f)
4049 {
4050   exprNode ret = exprNode_createPartialCopy (s);
4051
4052   ret->kind = XPR_FACCESS;
4053
4054   if (exprNode_isError (s))
4055     {
4056       ret->edata = exprData_makeField (s, f);
4057       return ret;
4058     }
4059   else
4060     {
4061       ctype t = exprNode_getType (s);
4062       ctype tr = ctype_realType (t);
4063
4064       checkMacroParen (s);
4065
4066       ret->edata = exprData_makeField (s, f);
4067
4068       if (ctype_isStructorUnion (tr))
4069         {
4070           uentry tf = uentryList_lookupField (ctype_getFields (tr), f);
4071
4072           if (uentry_isUndefined (tf))
4073             {
4074               voptgenerror (FLG_TYPE,
4075                             message ("Access non-existent field %s of %t: %s", f, t,
4076                                      exprNode_unparse (ret)),
4077                             loc);
4078               /*! cstring_free (f); */ /* evans 2001-03-25 self-detect */
4079               return (ret);
4080             }
4081           else
4082             {
4083               uentry_setUsed (tf, exprNode_loc (ret));
4084
4085               ret->typ = uentry_getType (tf);
4086               checkSafeUse (ret, s->sref);
4087
4088               ret->sref = sRef_makeField (s->sref, uentry_rawName (tf));
4089               /*!? exprNode_free (s); */ /* evans 2001-03-25 self-detect */
4090               return (ret);
4091             }
4092         }
4093       else /* isStructorUnion */
4094         {
4095           if (ctype_isRealAbstract (tr))
4096             {
4097               voptgenerror
4098                 (FLG_ABSTRACT,
4099                  message ("Access field of abstract type (%t): %s.%s",
4100                           t, exprNode_unparse (s), f),
4101                  loc);
4102               ret->typ = ctype_unknown;
4103             }
4104           else
4105             {
4106               if (ctype_isKnown (tr))
4107                 {
4108                   voptgenerror
4109                     (FLG_TYPE,
4110                      message
4111                      ("Access field of non-struct or union (%t): %s.%s",
4112                       t, exprNode_unparse (s), f),
4113                      loc);
4114
4115                   ret->typ = ctype_unknown;
4116                 }
4117               else
4118                 {
4119                   cstring sn = cstring_copy (f);
4120
4121                   checkSafeUse (ret, s->sref);
4122                   cstring_markOwned (sn);
4123                   ret->sref = sRef_makeField (s->sref, sn);
4124                   return (ret);
4125                 }
4126             }
4127
4128           return (ret);
4129         }
4130     }
4131   BADEXIT;
4132 }
4133
4134 exprNode
4135 exprNode_fieldAccess (/*@only@*/ exprNode s, /*@only@*/ lltok dot,
4136                       /*@only@*/ cstring f)
4137 {
4138   exprNode res = exprNode_fieldAccessAux (s, lltok_getLoc (dot), f);
4139   lltok_free (dot);
4140   return res;
4141 }
4142
4143 exprNode
4144 exprNode_addParens (/*@only@*/ lltok lpar, /*@only@*/ exprNode e)
4145 {
4146   exprNode ret = exprNode_createPartialCopy (e);
4147
4148   ret->loc = fileloc_update (ret->loc, lltok_getLoc (lpar));
4149   ret->kind = XPR_PARENS;
4150   ret->edata = exprData_makeUop (e, lpar);
4151
4152   if (!exprNode_isError (e))
4153     {
4154       ret->exitCode = e->exitCode;
4155       ret->canBreak = e->canBreak;
4156       ret->mustBreak = e->mustBreak;
4157       ret->isJumpPoint = e->isJumpPoint;
4158       ret->sref = e->sref;
4159     }
4160
4161   return ret;
4162 }
4163
4164 static exprNode
4165 exprNode_arrowAccessAux (/*@only@*/ exprNode s, /*@observer@*/ fileloc loc,
4166                          /*@only@*/ cstring f)
4167 {
4168   exprNode ret = exprNode_createPartialCopy (s);
4169
4170   ret->edata = exprData_makeField (s, f);
4171   ret->kind = XPR_ARROW;
4172
4173   if (exprNode_isError (s))
4174     {
4175       return (ret);
4176     }
4177   else
4178     {
4179       ctype t = exprNode_getType (s);
4180       ctype tr = ctype_realType (t);
4181
4182       checkMacroParen (s);
4183
4184       (void) ctype_fixArrayPtr (tr); /* REWRITE THIS */
4185
4186       if (ctype_isRealPointer (tr))
4187         {
4188           ctype b = ctype_realType (ctype_baseArrayPtr (tr));
4189
4190           if (ctype_isStructorUnion (b))
4191             {
4192               uentry fentry = uentryList_lookupField (ctype_getFields (b), f);
4193
4194               if (sRef_isKnown (s->sref) && sRef_possiblyNull (s->sref))
4195                 {
4196                   if (!usymtab_isGuarded (s->sref) && !context_inProtectVars ())
4197                     {
4198                       if (optgenerror
4199                           (FLG_NULLDEREF,
4200                            message ("Arrow access from %s pointer%q: %s",
4201                                     sRef_nullMessage (s->sref),
4202                                     sRef_unparsePreOpt (s->sref),
4203                                     exprNode_unparse (ret)),
4204                            loc))
4205                         {
4206                           sRef_showNullInfo (s->sref);
4207                           sRef_setNullError (s->sref);
4208                         }
4209                     }
4210                 }
4211
4212               if (uentry_isUndefined (fentry))
4213                 {
4214                   voptgenerror
4215                     (FLG_TYPE,
4216                      message ("Access non-existent field %s of %t: %s",
4217                               f, t, exprNode_unparse (ret)),
4218                      loc);
4219                   ret->typ = ctype_unknown;
4220                   return (ret);
4221                 }
4222               else
4223                 {
4224                   /*
4225                   ** was safeUse: shouldn't be safe!
4226                   **
4227                   ** to do rec->field
4228                   ** rec must be defined,
4229                   ** *rec must be allocated
4230                   ** rec->field need only be defined it if is an rvalue
4231                   */
4232
4233                   uentry_setUsed (fentry, exprNode_loc (ret));
4234                   ret->typ = uentry_getType (fentry);
4235
4236                   exprNode_checkUse (ret, s->sref, s->loc);
4237
4238                   /* exprNode_checkUse (ret, sRef_makePointer (s->sref), s->loc); */
4239                   ret->sref = sRef_makeArrow (s->sref, uentry_rawName (fentry));
4240                   return (ret);
4241                 }
4242             }
4243           else /* Pointer to something that is not a struct or union*/
4244             {
4245               if (ctype_isRealAbstract (tr))
4246                 {
4247                   ctype xrt = ctype_forceRealType (tr);
4248
4249                   voptgenerror
4250                     (FLG_ABSTRACT,
4251                      message ("Arrow access field of abstract type (%t): %s->%s",
4252                               t, exprNode_unparse (s), f),
4253                      loc);
4254
4255                   /*
4256                   ** Set the state correctly, as if the abstraction is broken.
4257                   */
4258
4259                   if (ctype_isRealPointer (xrt) &&
4260                       (b = ctype_realType (ctype_baseArrayPtr (xrt)),
4261                        ctype_isStructorUnion (b)))
4262                     {
4263                       uentry fentry = uentryList_lookupField (ctype_getFields (b), f);
4264                       ret->typ = uentry_getType (fentry);
4265                       ret->sref = sRef_makeArrow (s->sref, uentry_rawName (fentry));
4266                     }
4267                   else
4268                     {
4269                       ret->typ = ctype_unknown;
4270                       ret->sref = sRef_undefined;
4271                     }
4272                 }
4273               else /* not a struct, union or abstract */
4274                 {
4275                   if (ctype_isUnknown (tr)) {
4276                     cstring sn = cstring_copy (f);
4277
4278                     DPRINTF (("Here: %s", exprNode_unparse (s)));
4279
4280                     exprNode_checkUse (ret, s->sref, s->loc);
4281                     exprNode_checkUse (ret, sRef_makePointer (s->sref), s->loc);
4282
4283                     cstring_markOwned (sn);
4284                     ret->sref = sRef_makeArrow (s->sref, sn);
4285
4286                     ret->kind = XPR_ARROW;
4287                     return (ret);
4288                   } else {
4289                     voptgenerror
4290                       (FLG_TYPE,
4291                        message ("Arrow access field of non-struct or union "
4292                                 "pointer (%t): %s->%s",
4293                                 t, exprNode_unparse (s), f),
4294                        loc);
4295
4296                     ret->typ = ctype_unknown;
4297                     ret->sref = sRef_undefined;
4298                   }
4299                 }
4300             }
4301         }
4302       else /* its not a pointer */
4303         {
4304           if (!ctype_isUnknown (tr))
4305             {
4306               voptgenerror
4307                 (FLG_TYPE,
4308                  message ("Arrow access of non-pointer (%t): %s->%s",
4309                           t, exprNode_unparse (s), f),
4310                  loc);
4311
4312               ret->typ = ctype_unknown;
4313               ret->sref = sRef_undefined;
4314             }
4315           else
4316             {
4317               cstring sn = cstring_copy (f);
4318
4319               DPRINTF (("Here: %s", exprNode_unparse (s)));
4320
4321               exprNode_checkUse (ret, s->sref, s->loc);
4322               exprNode_checkUse (ret, sRef_makePointer (s->sref), s->loc);
4323
4324               cstring_markOwned (sn);
4325               ret->sref = sRef_makeArrow (s->sref, sn);
4326
4327               ret->kind = XPR_ARROW;
4328               return (ret);
4329             }
4330         }
4331
4332       return (ret);
4333     }
4334   BADEXIT;
4335 }
4336
4337 exprNode
4338 exprNode_arrowAccess (/*@only@*/ exprNode s,
4339                       /*@only@*/ lltok arrow,
4340                       /*@only@*/ cstring f)
4341 {
4342   exprNode res = exprNode_arrowAccessAux (s, lltok_getLoc (arrow), f);
4343   lltok_free (arrow);
4344   return res;
4345 }
4346
4347 /*
4348 ** only postOp's in C: i++ and i--
4349 */
4350
4351 exprNode
4352 exprNode_postOp (/*@only@*/ exprNode e, /*@only@*/ lltok op)
4353 {
4354   /* check modification also */
4355   /* cstring opname = lltok_unparse (op);*/
4356   ctype t;
4357   exprNode ret = exprNode_createPartialCopy (e);
4358
4359   ret->loc = fileloc_update (ret->loc, lltok_getLoc (op));
4360   ret->kind = XPR_POSTOP;
4361   ret->edata = exprData_makeUop (e, op);
4362
4363   if (!exprNode_isDefined (e))
4364     {
4365       return ret;
4366     }
4367
4368   checkMacroParen (e);
4369
4370   exprNode_checkUse (ret, e->sref, e->loc);
4371   exprNode_checkSet (ret, e->sref);
4372
4373   t = exprNode_getType (e);
4374
4375   if (sRef_isUnsafe (e->sref))
4376     {
4377       voptgenerror (FLG_MACROPARAMS,
4378                     message ("Operand of %s is macro parameter (non-functional): %s%s",
4379                              lltok_unparse (op), exprNode_unparse (e), lltok_unparse (op)),
4380                     e->loc);
4381       sRef_makeSafe (e->sref);
4382       sRef_makeSafe (ret->sref);
4383     }
4384
4385   if (ctype_isForceRealNumeric (&t) || ctype_isRealAP (t))
4386     {
4387       ret->typ = e->typ;
4388     }
4389   else
4390     {
4391       if (ctype_isRealAbstract (t))
4392         {
4393           if (ctype_isRealNumAbstract (t)) {
4394             ; /* Allow operations on numabstract types */
4395           } else {
4396             voptgenerror
4397               (FLG_ABSTRACT,
4398                message ("Operand of %s is abstract type (%t): %s",
4399                         lltok_unparse (op), t, exprNode_unparse (e)),
4400                e->loc);
4401           }
4402         }
4403       else
4404         {
4405           voptgenerror
4406             (FLG_TYPE,
4407              message ("Operand of %s is non-numeric (%t): %s",
4408                       lltok_unparse (op), t, exprNode_unparse (e)),
4409              e->loc);
4410         }
4411       ret->typ = ctype_unknown;
4412     }
4413
4414   /* if (ctype_isZero (t)) e->typ = ctype_int; */
4415
4416   exprNode_checkModify (e, ret);
4417
4418   /* added 7/11/2000 D.L */
4419   /*@i223*/
4420   /*DRL 6/8/01 I decided to disable all Splint warnings here since the code
4421     probably needs a rewrite any way */
4422
4423
4424   /* updateEnvironmentForPostOp (e); */
4425
4426   /* start modifications */
4427   /* added by Seejo on 4/16/2000 */
4428
4429   /* Arithmetic operations on pointers wil modify the size/len/null terminated
4430      status */
4431   if ((sRef_isPossiblyNullTerminated (e->sref)) || (sRef_isNullTerminated(e->sref))) {
4432
4433     ret->sref = sRef_copy (e->sref);
4434
4435     /* Operator : ++ */
4436     if (lltok_getTok (op) == INC_OP) {
4437       if (sRef_getSize(e->sref) > 0) {
4438
4439         sRef_setSize (ret->sref, sRef_getSize(e->sref) - 1);
4440
4441         if (sRef_getLen(e->sref) == 1) { /* i.e. the first character is \0 */
4442           /* Assumption: there is only 1 \0 in the buffer */
4443           /* This will not be correct if there are 2 \0's in the buffer */
4444           sRef_setNotNullTerminatedState(ret->sref);
4445           sRef_resetLen(ret->sref);
4446         } else {
4447           sRef_setNullTerminatedState(ret->sref);
4448           sRef_setLen (ret->sref, sRef_getLen(e->sref) - 1);
4449         }
4450         if (sRef_isNullTerminated (ret->sref))
4451           printf ("ret->sref is Null Terminated\n");
4452         else if (sRef_isPossiblyNullTerminated (ret->sref))
4453           printf ("ret->sref is Possibly Null Terminated\n");
4454         else if (sRef_isNotNullTerminated (ret->sref))
4455           printf ("ret->sref is Not Null Terminated\n");
4456         else
4457           {}
4458       }
4459     }
4460
4461     /* Operator : -- */
4462     if (lltok_getTok (op) == DEC_OP) {
4463       if (sRef_getSize(e->sref) >= 0) {
4464         sRef_setSize (ret->sref, sRef_getSize(e->sref) + 1);
4465         sRef_setLen (ret->sref, sRef_getLen(e->sref) + 1);
4466       }
4467     }
4468   }
4469   /* end modifications */
4470
4471   return ret;
4472 }
4473
4474 exprNode
4475 exprNode_preOp (/*@only@*/ exprNode e, /*@only@*/ lltok op)
4476 {
4477   bool checkMod = FALSE;
4478   ctype te, tr;
4479   int opid = lltok_getTok (op);
4480   exprNode ret = exprNode_createSemiCopy (e);
4481
4482   exprNode_copySets (ret, e);
4483
4484   multiVal_free (ret->val);
4485   ret->val = multiVal_undefined;
4486   ret->loc = fileloc_update (ret->loc, lltok_getLoc (op));
4487   ret->kind = XPR_PREOP;
4488   ret->edata = exprData_makeUop (e, op);
4489
4490   if (exprNode_isError (e))
4491     {
4492       return ret;
4493     }
4494
4495   checkMacroParen (e);
4496
4497   te = exprNode_getType (e);
4498   tr = ctype_realType (te);
4499
4500   if (opid != TAMPERSAND)
4501     {
4502       exprNode_checkUse (ret, e->sref, e->loc);
4503
4504       if (ctype_isRealAbstract (tr)
4505           && (!(ctype_isRealBool (te) && (opid == TEXCL))))
4506         {
4507           if (ctype_isRealNumAbstract (tr))
4508             {
4509               ; /* no warning for numabstract types */
4510             }
4511           else
4512             {
4513               if (optgenerror (FLG_ABSTRACT,
4514                                message ("Operand of %s is abstract type (%t): %s",
4515                                         lltok_unparse (op), tr,
4516                                         exprNode_unparse (ret)),
4517                                e->loc))
4518                 {
4519                   tr = te = ctype_unknown;
4520                   ret->typ = ctype_unknown;
4521                   sRef_setNullError (e->sref);
4522                 }
4523             }
4524         }
4525     }
4526
4527   switch (opid)
4528     {
4529     case INC_OP:
4530     case DEC_OP:                /* should also check modification! */
4531       if (sRef_isMacroParamRef (e->sref))
4532         {
4533           voptgenerror
4534             (FLG_MACROPARAMS,
4535              message ("Operand of %s is macro parameter (non-functional): %s",
4536                       lltok_unparse (op), exprNode_unparse (ret)),
4537              e->loc);
4538         }
4539       else
4540         {
4541           exprNode_checkSet (ret, e->sref);
4542         }
4543
4544       if (ctype_isForceRealNumeric (&tr) || ctype_isRealAP (tr))
4545         {
4546         }
4547       else
4548         {
4549           if (context_msgStrictOps ())
4550             {
4551               voptgenerror
4552                 (FLG_STRICTOPS,
4553                  message ("Operand of %s is non-numeric (%t): %s",
4554                           lltok_unparse (op), te, exprNode_unparse (ret)),
4555                  e->loc);
4556             }
4557           ret->typ = ctype_int;
4558         }
4559
4560         /* start modifications */
4561         /* added by Seejo on 4/16/2000 */
4562
4563         /* Arithmetic operations on pointers wil modify the size/len/null terminated
4564                  status */
4565         if ((sRef_isPossiblyNullTerminated (e->sref))
4566             || (sRef_isNullTerminated(e->sref))) {
4567                 ret->sref = sRef_copy (e->sref);
4568
4569                 /* Operator : ++ */
4570                 if (lltok_getTok (op) == INC_OP) {
4571                         if (sRef_getSize(e->sref) > 0) {
4572
4573                                 sRef_setSize (ret->sref, sRef_getSize(e->sref) - 1);
4574
4575                                 if (sRef_getLen(e->sref) == 1) { /* i.e. the first character is \0 */
4576                                         /* Assumption: there is only 1 \0 in the buffer */
4577                                         /* This will not be correct if there are 2 \0's in the buffer */
4578                                         sRef_setNotNullTerminatedState(ret->sref);
4579                                         sRef_resetLen (ret->sref);
4580                                 } else {
4581                                         sRef_setNullTerminatedState(ret->sref);
4582                                         sRef_setLen (ret->sref, sRef_getLen(e->sref) - 1);
4583                                 }
4584                         }
4585                 }
4586
4587                 /* Operator : -- */
4588                 if (lltok_getTok (op) == DEC_OP) {
4589                         if (sRef_getSize(e->sref) >= 0) {
4590                                 sRef_setSize (ret->sref, sRef_getSize(e->sref) + 1);
4591                                 sRef_setLen (ret->sref, sRef_getLen(e->sref) + 1);
4592                         }
4593                 }
4594         }
4595
4596         /* end modifications */
4597
4598       checkMod = TRUE;
4599       break;
4600
4601     case TMINUS:
4602     case TPLUS:
4603       if (ctype_isForceRealNumeric (&tr))
4604         {
4605           if (opid == TMINUS)
4606             {
4607               ret->val = multiVal_invert (exprNode_getValue (e));
4608             }
4609           else
4610             {
4611               ret->val = multiVal_copy (exprNode_getValue (e));
4612             }
4613         }
4614       else
4615         {
4616           if (context_msgStrictOps ())
4617             {
4618               voptgenerror
4619                 (FLG_STRICTOPS,
4620                  message ("Operand of %s is non-numeric (%t): %s",
4621                           lltok_unparse (op), te, exprNode_unparse (ret)),
4622                  e->loc);
4623             }
4624
4625           ret->typ = ctype_int;
4626         }
4627       break;
4628
4629     case TEXCL:         /* maybe this should be restricted */
4630       guardSet_flip (ret->guards);
4631
4632       if (ctype_isRealBool (te) || ctype_isUnknown (te))
4633         {
4634          ;
4635         }
4636       else
4637         {
4638           if (ctype_isRealPointer (tr))
4639             {
4640               if (sRef_isKnown (e->sref))
4641                 {
4642                   ret->guards = guardSet_addFalseGuard (ret->guards, e->sref);
4643                 }
4644
4645               voptgenerror2n
4646                 (FLG_BOOLOPS, FLG_PTRNEGATE,
4647                  message ("Operand of %s is non-boolean (%t): %s",
4648                           lltok_unparse (op), te, exprNode_unparse (ret)),
4649                  e->loc);
4650             }
4651           else
4652             {
4653               voptgenerror
4654                 (FLG_BOOLOPS,
4655                  message ("Operand of %s is non-boolean (%t): %s",
4656                           lltok_unparse (op), te, exprNode_unparse (ret)),
4657                  e->loc);
4658             }
4659
4660           ret->typ = ctype_bool;
4661         }
4662       break;
4663
4664     case TTILDE:
4665       if (ctype_isForceRealInt (&tr))
4666         {
4667         }
4668       else
4669         {
4670           if (context_msgStrictOps ())
4671             {
4672               voptgenerror
4673                 (FLG_STRICTOPS,
4674                  message ("Operand of %s is non-integer (%t): %s",
4675                           lltok_unparse (op), te, exprNode_unparse (ret)),
4676                  e->loc);
4677             }
4678
4679           if (ctype_isInt (e->typ))
4680             {
4681               ret->typ = e->typ;
4682             }
4683           else
4684             {
4685               ret->typ = ctype_int;
4686             }
4687         }
4688       break;
4689
4690     case TAMPERSAND:
4691       ret->typ = ctype_makePointer (e->typ);
4692
4693       if (sRef_isKnown (e->sref))
4694         {
4695           ret->sref = sRef_makeAddress (e->sref);
4696         }
4697
4698       break;
4699
4700     case TMULT:
4701
4702       if (ctype_isAP (tr))
4703         {
4704           ret->typ = ctype_baseArrayPtr (e->typ);
4705         }
4706       else
4707         {
4708           if (ctype_isKnown (te))
4709             {
4710               if (ctype_isFunction (te))
4711                 {
4712                   ret->typ = e->typ;
4713
4714                   voptgenerror
4715                     (FLG_FCNDEREF,
4716                      message ("Dereference of function type (%t): %s",
4717                               te, exprNode_unparse (ret)),
4718                      e->loc);
4719                 }
4720               else
4721                 {
4722                   voptgenerror (FLG_TYPE,
4723                                 message ("Dereference of non-pointer (%t): %s",
4724                                          te, exprNode_unparse (ret)),
4725                                 e->loc);
4726                   ret->typ = ctype_unknown;
4727                 }
4728             }
4729           else
4730             {
4731               ret->typ = ctype_unknown;
4732             }
4733
4734         }
4735
4736       if (sRef_isKnown (e->sref))
4737         {
4738           DPRINTF (("Checking possibly null: %s", sRef_unparseFull (e->sref)));
4739
4740           if (sRef_possiblyNull (e->sref))
4741             {
4742               DPRINTF (("Checking possibly null: %s", sRef_unparse (e->sref)));
4743               if (!usymtab_isGuarded (e->sref) && !context_inProtectVars ())
4744                 {
4745                   if (optgenerror
4746                       (FLG_NULLDEREF,
4747                        message ("Dereference of %s pointer %q: %s",
4748                                 sRef_nullMessage (e->sref),
4749                                 sRef_unparse (e->sref),
4750                                 exprNode_unparse (ret)),
4751                        e->loc))
4752                     {
4753                       sRef_showNullInfo (e->sref);
4754                       sRef_setNotNull (e->sref, e->loc); /* suppress future messages */
4755                     }
4756                 }
4757             }
4758
4759           ret->sref = sRef_makePointer (e->sref);
4760         }
4761       break;
4762
4763     default:
4764       llbug (message ("exprNode_preOp: unhandled op: %s", lltok_unparse (op)));
4765     }
4766
4767   if (checkMod)
4768     {
4769       exprNode_checkModify (e, ret);
4770     }
4771
4772   return ret;
4773 }
4774
4775 /*
4776 ** any reason to disallow sizeof (abstract type) ?
4777 */
4778
4779 /*
4780 ** used by both sizeof
4781 */
4782
4783 static
4784 ctype sizeof_resultType (void)
4785 {
4786   static ctype sizet = ctype_unknown;
4787
4788   if (ctype_isUnknown (sizet))
4789     {
4790       if (usymtab_existsType (cstring_makeLiteralTemp ("size_t")))
4791         {
4792           sizet = uentry_getAbstractType (usymtab_lookup (cstring_makeLiteralTemp ("size_t")));
4793         }
4794       else
4795         {
4796           sizet = ctype_ulint;
4797         }
4798     }
4799   return sizet;
4800 }
4801
4802 exprNode
4803 exprNode_sizeofType (/*@only@*/ qtype qt)
4804 {
4805   exprNode ret = exprNode_create (sizeof_resultType ());
4806   ctype ct = qtype_getType (qt);
4807
4808   ret->kind = XPR_SIZEOFT;
4809   ret->edata = exprData_makeSizeofType (qt);
4810
4811   voptgenerror (FLG_SIZEOFTYPE,
4812                 message ("Parameter to sizeof is type %s: %s",
4813                          ctype_unparse (ct),
4814                          exprNode_unparse (ret)),
4815                 ret->loc);
4816
4817   return (ret);
4818 }
4819
4820 exprNode
4821 exprNode_alignofType (/*@only@*/ qtype qt)
4822 {
4823   exprNode ret = exprNode_create (sizeof_resultType ());
4824   ctype ct = qtype_getType (qt);
4825
4826   ret->kind = XPR_ALIGNOFT;
4827   ret->edata = exprData_makeSizeofType (qt);
4828
4829   voptgenerror (FLG_SIZEOFTYPE,
4830                 message ("Parameter to alignof is type %s: %s",
4831                          ctype_unparse (ct),
4832                          exprNode_unparse (ret)),
4833                 ret->loc);
4834
4835   return (ret);
4836 }
4837
4838 exprNode exprNode_offsetof (qtype qt, cstringList s)
4839 {
4840   exprNode ret = exprNode_create (sizeof_resultType ());
4841   ctype ct = qtype_getType (qt);
4842
4843   ret->kind = XPR_OFFSETOF;
4844   ret->edata = exprData_makeOffsetof (qt, s);
4845
4846   if (!ctype_isRealSU (ct))
4847     {
4848       voptgenerror (FLG_TYPE,
4849                     message ("First parameter to offsetof is not a "
4850                              "struct or union type (type %s): %s",
4851                              ctype_unparse (ct),
4852                              exprNode_unparse (ret)),
4853                     ret->loc);
4854     }
4855   else
4856     {
4857       ctype lt = ct;
4858
4859       cstringList_elements (s, el) {
4860         uentryList fields;
4861         uentry fld;
4862
4863         if (ctype_isUndefined (lt))
4864           {
4865             break;
4866           }
4867         else if (!ctype_isRealSU (lt))
4868           {
4869             voptgenerror (FLG_TYPE,
4870                           message ("Inner offsetof type is not a "
4871                                    "struct or union type (type %s before field %s): %s",
4872                                    ctype_unparse (lt), el,
4873                                    exprNode_unparse (ret)),
4874                           ret->loc);
4875             break;
4876           }
4877         else
4878           {
4879             fields = ctype_getFields (ctype_realType (lt));
4880             fld = uentryList_lookupField (fields, el);
4881             DPRINTF (("Try: %s / %s", ctype_unparse (lt), el));
4882
4883             if (uentry_isUndefined (fld))
4884               {
4885                 if (ctype_equal (lt, ct)) {
4886                   voptgenerror (FLG_TYPE,
4887                                 message ("Field %s in offsetof is not the "
4888                                          "name of a field of %s: %s",
4889                                          el,
4890                                          ctype_unparse (ct),
4891                                          exprNode_unparse (ret)),
4892                                 ret->loc);
4893                 } else {
4894                   voptgenerror (FLG_TYPE,
4895                                 message ("Deep field %s in offsetof is not the "
4896                                          "name of a field of %s: %s",
4897                                          el,
4898                                          ctype_unparse (lt),
4899                                          exprNode_unparse (ret)),
4900                                 ret->loc);
4901                 }
4902               }
4903             else
4904               {
4905                 lt = uentry_getType (fld);
4906               }
4907           }
4908       } end_cstringList_elements;
4909
4910       /* Should report error if its a bit field - behavior is undefined! */
4911     }
4912
4913   return (ret);
4914 }
4915
4916 /*@only@*/ exprNode
4917 exprNode_sizeofExpr (/*@only@*/ exprNode e)
4918 {
4919   exprNode ret;
4920
4921   if (exprNode_isUndefined (e))
4922     {
4923       ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
4924       ret->edata = exprData_makeSingle (e);
4925       ret->typ = sizeof_resultType ();
4926       ret->kind = XPR_SIZEOF;
4927     }
4928   else
4929     {
4930       uentry u = exprNode_getUentry (e);
4931
4932       ret = exprNode_createPartialCopy (e);
4933       ret->edata = exprData_makeSingle (e);
4934
4935       ret->typ = sizeof_resultType ();
4936       ret->kind = XPR_SIZEOF;
4937
4938       if (uentry_isValid (u)
4939           && uentry_isRefParam (u)
4940           && ctype_isRealArray (uentry_getType (u)))
4941         {
4942           voptgenerror
4943             (FLG_SIZEOFFORMALARRAY,
4944              message ("Parameter to sizeof is an array-type function parameter: %s",
4945                       exprNode_unparse (ret)),
4946              ret->loc);
4947         }
4948     }
4949
4950   /*
4951   ** sizeof (x) doesn't "really" use x
4952   */
4953
4954   return (ret);
4955 }
4956
4957 /*@only@*/ exprNode
4958 exprNode_alignofExpr (/*@only@*/ exprNode e)
4959 {
4960   exprNode ret;
4961
4962   if (exprNode_isUndefined (e))
4963     {
4964       ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
4965     }
4966   else
4967     {
4968       ret = exprNode_createPartialCopy (e);
4969     }
4970
4971   ret->edata = exprData_makeSingle (e);
4972   ret->typ = sizeof_resultType ();
4973   ret->kind = XPR_ALIGNOF;
4974
4975   /*
4976   ** sizeof (x) doesn't "really" use x
4977   */
4978
4979   return (ret);
4980 }
4981
4982 /*@only@*/ exprNode
4983 exprNode_cast (/*@only@*/ lltok tok, /*@only@*/ exprNode e, /*@only@*/ qtype q)
4984 {
4985   ctype c;
4986   ctype t;
4987   exprNode ret;
4988
4989   if (exprNode_isError (e))
4990     {
4991       qtype_free (q);
4992       lltok_free (tok);
4993       return exprNode_undefined;
4994     }
4995
4996   checkMacroParen (e);
4997
4998   c = qtype_getType (q);
4999   t = exprNode_getType (e);
5000
5001   ret = exprNode_createPartialCopy (e);
5002
5003   ret->loc = fileloc_update (ret->loc, lltok_getLoc (tok));
5004   ret->typ = c;
5005   ret->kind = XPR_CAST;
5006   ret->edata = exprData_makeCast (tok, e, q);
5007
5008   ret->sref = sRef_copy (e->sref);
5009
5010   DPRINTF (("Cast 2: -> %s", sRef_unparseFull (ret->sref)));
5011
5012   if (!sRef_isConst (e->sref))
5013     {
5014       usymtab_addForceMustAlias (ret->sref, e->sref);
5015     }
5016
5017   DPRINTF (("Cast 2: -> %s", sRef_unparseFull (ret->sref)));
5018   sRef_setTypeFull (ret->sref, c);
5019   DPRINTF (("Cast 2: -> %s", sRef_unparseFull (ret->sref)));
5020
5021   /*
5022   ** we allow
5023   **       abstract  -> void
5024   **              0 <-> abstract *
5025   **         void * <-> abstract *  (if FLG_ABSTVOIDP)
5026   **     abstract * <-> void *      (if FLG_ABSTVOIDP)
5027   */
5028
5029   if (ctype_isVoid (c)) /* cast to void is always okay --- discard value */
5030     {
5031       /* evans 2002-07-19: added this warning */
5032       DPRINTF (("Checking: %s / %s", exprNode_unparse (ret), sRef_unparseFull (ret->sref)));
5033       if (sRef_isFresh (ret->sref))
5034         {
5035           voptgenerror
5036             (FLG_MUSTFREEFRESH,
5037              message ("New fresh storage %q(type %s) cast to void (not released): %s",
5038                       sRef_unparseOpt (ret->sref),
5039                       ctype_unparse (exprNode_getType (ret)),
5040                       exprNode_unparse (ret)),
5041              exprNode_loc (ret));
5042         }
5043     }
5044   else if (ctype_isRealAP (c)) /* casting to array or pointer */
5045     {
5046       ctype bc = ctype_getBaseType (c);
5047       ctype bt = ctype_getBaseType (t);
5048       ctype rt = ctype_realType (t);
5049
5050       if (ctype_isFunction (ctype_baseArrayPtr (ctype_realType (c)))
5051           && (ctype_isArrayPtr (rt)
5052               && !ctype_isFunction (ctype_realType (ctype_baseArrayPtr (rt)))))
5053         {
5054           voptgenerror
5055             (FLG_CASTFCNPTR,
5056              message ("Cast from function pointer type (%t) to "
5057                       "non-function pointer (%t): %s",
5058                       c, t, exprNode_unparse (ret)),
5059              e->loc);
5060         }
5061
5062       if (!ctype_isFunction (ctype_baseArrayPtr (c))
5063           && (ctype_isArrayPtr (rt)
5064               && ctype_isFunction (ctype_realType (ctype_baseArrayPtr (rt)))))
5065         {
5066           voptgenerror
5067             (FLG_CASTFCNPTR,
5068              message ("Cast from non-function pointer type (%t) to "
5069                       "function pointer (%t): %s",
5070                       c, t, exprNode_unparse (ret)),
5071              e->loc);
5072         }
5073
5074       if (exprNode_isZero (e) && context_getFlag (FLG_ZEROPTR) &&
5075           !(ctype_isRealAbstract (bc)
5076             && context_hasAccess (ctype_typeId (bc))))
5077         {
5078          ; /* okay to cast zero */
5079         }
5080       else
5081         {
5082           if (ctype_isRealAbstract (bc)
5083               && !context_hasAccess (ctype_typeId (bc)))
5084             {
5085               if (ctype_isVoidPointer (t) || ctype_isUnknown (t))
5086                 {
5087                   vnoptgenerror
5088                     (FLG_ABSTVOIDP,
5089                      message ("Cast to underlying abstract type %t: %s",
5090                               c, exprNode_unparse (ret)),
5091                      e->loc);
5092                 }
5093               else
5094                 {
5095                   voptgenerror
5096                     (FLG_ABSTRACT,
5097                      message ("Cast to underlying abstract type %t: %s",
5098                               c, exprNode_unparse (ret)),
5099                      e->loc);
5100                 }
5101             }
5102
5103           if (ctype_isRealAbstract (bt)
5104               && !context_hasAccess (ctype_typeId (bt)))
5105             {
5106               if (ctype_isUnknown (c) || ctype_isVoidPointer (c))
5107                 {
5108                   vnoptgenerror
5109                     (FLG_ABSTVOIDP,
5110                      message ("Cast from underlying abstract type %t: %s",
5111                               t, exprNode_unparse (ret)),
5112                      e->loc);
5113                 }
5114               else
5115                 {
5116                   voptgenerror
5117                     (FLG_ABSTRACT,
5118                      message ("Cast from underlying abstract type %t: %s",
5119                               t, exprNode_unparse (ret)),
5120                      e->loc);
5121                 }
5122             }
5123         }
5124     }
5125   else
5126     {
5127       ctype bt = ctype_realType (ctype_getBaseType (t));
5128       ctype bc = ctype_realType (ctype_getBaseType (c));
5129
5130       if (ctype_isAbstract (bt) && !context_hasAccess (ctype_typeId (bt)))
5131         {
5132           if (ctype_match (c, t))
5133             {
5134               if (ctype_equal (c, t))
5135                 {
5136                   voptgenerror
5137                     (FLG_TYPE,
5138                      message ("Redundant cast involving abstract type %t: %s",
5139                               bt, exprNode_unparse (ret)),
5140                      e->loc);
5141                 }
5142             }
5143           else
5144             {
5145               voptgenerror
5146                 (FLG_ABSTRACT,
5147                  message ("Cast from abstract type %t: %s",
5148                           bt, exprNode_unparse (ret)),
5149                  e->loc);
5150             }
5151         }
5152
5153       if (ctype_isAbstract (bc)
5154           && !context_hasAccess (ctype_typeId (bc)))
5155         {
5156           if (ctype_match (c, t))
5157             {
5158              ;
5159             }
5160           else
5161             {
5162               if (ctype_isNumAbstract (bc))
5163                 {
5164                   if (exprNode_isNumLiteral (e))
5165                     {
5166                       voptgenerror
5167                         (FLG_NUMABSTRACTCAST,
5168                          message ("Cast from literal to numabstract type %t: %s", bc,
5169                                   exprNode_unparse (ret)),
5170                          e->loc);
5171                     }
5172                   else
5173                     {
5174                       voptgenerror
5175                         (FLG_NUMABSTRACT,
5176                          message ("Cast to numabstract type %t: %s", bc,
5177                                   exprNode_unparse (ret)),
5178                          e->loc);
5179                     }
5180                 }
5181               else
5182                 {
5183                   DPRINTF (("No access to: %s / %d",
5184                             ctype_unparse (bc), ctype_typeId (bc)));
5185                   DPRINTF (("Context %s %s",
5186                             bool_unparse (context_inFunctionLike ()),
5187                             context_unparse ()));
5188                   voptgenerror
5189                     (FLG_ABSTRACT,
5190                      message ("Cast to abstract type %t: %s", bc,
5191                               exprNode_unparse (ret)),
5192                      e->loc);
5193                 }
5194             }
5195         }
5196     }
5197
5198   if (ctype_isAbstract (c))
5199     {
5200       if (sRef_isExposed (e->sref) || sRef_isOnly (e->sref))
5201         {
5202           /* okay, cast exposed to abstract */
5203           sRef_clearExKindComplete (ret->sref, fileloc_undefined);
5204         }
5205       else
5206         {
5207           if (ctype_isVisiblySharable (t)
5208               && sRef_isExternallyVisible (e->sref)
5209               && !(ctype_isAbstract (t)
5210                    && context_hasAccess (ctype_typeId (t))))
5211             {
5212               voptgenerror
5213                 (FLG_CASTEXPOSE,
5214                  message ("Cast to abstract type from externally visible "
5215                           "mutable storage exposes rep of %s: %s",
5216                           ctype_unparse (c),
5217                           exprNode_unparse (e)),
5218                  e->loc);
5219             }
5220         }
5221     }
5222
5223   return (ret);
5224 }
5225
5226 static bool
5227 evaluationOrderUndefined (lltok op)
5228 {
5229   int opid = lltok_getTok (op);
5230
5231   return (opid != AND_OP && opid != OR_OP);
5232 }
5233
5234 static bool checkIntegral (/*@notnull@*/ exprNode e1,
5235                            /*@notnull@*/ exprNode e2,
5236                            /*@notnull@*/ exprNode ret,
5237                            lltok op)
5238 {
5239   bool error = FALSE;
5240
5241   ctype te1 = exprNode_getType (e1);
5242   ctype te2 = exprNode_getType (e2);
5243
5244   ctype tr1 = ctype_realishType (te1);
5245   ctype tr2 = ctype_realishType (te2);
5246
5247   if (ctype_isForceRealInt (&tr1) && ctype_isForceRealInt (&tr2))
5248     {
5249       ;
5250     }
5251   else
5252     {
5253       if (context_msgStrictOps ())
5254         {
5255           if (!ctype_isInt (tr1) && !ctype_isInt (tr2))
5256             {
5257               if (ctype_sameName (te1, te2))
5258                 {
5259                   error = optgenerror
5260                     (FLG_STRICTOPS,
5261                      message ("Operands of %s are non-integer (%t): %s",
5262                               lltok_unparse (op), te1,
5263                               exprNode_unparse (ret)),
5264                      e1->loc);
5265                 }
5266               else
5267                 {
5268                   error = optgenerror
5269                     (FLG_STRICTOPS,
5270                      message ("Operands of %s are non-integers (%t, %t): %s",
5271                               lltok_unparse (op), te1, te2,
5272                               exprNode_unparse (ret)),
5273                      e1->loc);
5274                 }
5275             }
5276           else if (!ctype_isInt (tr1))
5277             {
5278               error = optgenerror
5279                 (FLG_STRICTOPS,
5280                  message ("Left operand of %s is non-integer (%t): %s",
5281                           lltok_unparse (op), te1, exprNode_unparse (ret)),
5282                  e1->loc);
5283             }
5284           else
5285             /* !ctype_isInt (te2) */
5286             {
5287               error = optgenerror
5288                 (FLG_STRICTOPS,
5289                  message ("Right operand of %s is non-integer (%t): %s",
5290                           lltok_unparse (op), te2, exprNode_unparse (ret)),
5291                  e2->loc);
5292             }
5293         }
5294     }
5295
5296   return !error;
5297 }
5298
5299 /*
5300 ** returns exprNode representing e1 op e2
5301 **
5302 ** uses msg if there are errors
5303 ** can be used for both assignment ops and regular ops
5304 **
5305 ** modifies e1
5306 */
5307
5308 static /*@only@*/ /*@notnull@*/ exprNode
5309 exprNode_makeOp (/*@keep@*/ exprNode e1, /*@keep@*/ exprNode e2,
5310                  /*@keep@*/ lltok op)
5311 {
5312   ctype te1, te2, tr1, tr2, tret;
5313   int opid = lltok_getTok (op);
5314   bool hasError = FALSE;
5315   exprNode ret;
5316
5317   if (exprNode_isError (e1))
5318     {
5319       ret = exprNode_createPartialNVCopy (e2);
5320     }
5321   else
5322     {
5323       ret = exprNode_createPartialNVCopy (e1);
5324     }
5325
5326   ret->val = multiVal_undefined;
5327
5328   ret->kind = XPR_OP;
5329   ret->edata = exprData_makeOp (e1, e2, op);
5330
5331   if (exprNode_isError (e1) || exprNode_isError (e2))
5332     {
5333       if (opid == TLT || opid == TGT || opid == LE_OP || opid == GE_OP
5334           || opid == EQ_OP || opid == NE_OP
5335           || opid == AND_OP || opid == OR_OP)
5336         {
5337           ret->typ = ctype_bool;
5338         }
5339
5340       if (exprNode_isDefined (e1))
5341         {
5342           exprNode_checkUse (ret, e1->sref, e1->loc);
5343         }
5344
5345       if (exprNode_isDefined (e2))
5346         {
5347           exprNode_mergeUSs (ret, e2);
5348           exprNode_checkUse (ret, e2->sref, e2->loc);
5349         }
5350
5351       return ret;
5352     }
5353
5354   tret = ctype_unknown;
5355   te1 = exprNode_getType (e1);
5356
5357   DPRINTF (("te1 = %s / %s", exprNode_unparse (e1), ctype_unparse (te1)));
5358
5359   te2 = exprNode_getType (e2);
5360
5361   tr1 = ctype_realishType (te1);
5362   tr2 = ctype_realishType (te2);
5363
5364   if (opid == OR_OP)
5365     {
5366       ret->guards = guardSet_or (ret->guards, e2->guards);
5367     }
5368   else if (opid == AND_OP)
5369     {
5370       ret->guards = guardSet_and (ret->guards, e2->guards);
5371     }
5372   else
5373     {
5374       /* no guards */
5375     }
5376
5377   if (opid == EQ_OP || opid == NE_OP)
5378     {
5379       exprNode temp1 = e1, temp2 = e2;
5380
5381       /* could do NULL == x */
5382
5383       if (exprNode_isNullValue (e1) || exprNode_isUnknownConstant (e1))
5384         {
5385           temp1 = e2; temp2 = e1;
5386         }
5387
5388       if (exprNode_isNullValue (temp2) || exprNode_isUnknownConstant (temp2))
5389         {
5390           reflectNullTest (temp1, (opid == NE_OP));
5391           guardSet_free (ret->guards);
5392           ret->guards = guardSet_copy (temp1->guards);
5393         }
5394     }
5395
5396   if (opid == TLT || opid == TGT || opid == LE_OP || opid == GE_OP
5397       || opid == EQ_OP || opid == NE_OP || opid == AND_OP || opid == OR_OP)
5398     {
5399       tret = ctype_bool;
5400     }
5401
5402   if (anyAbstract (tr1, tr2) &&
5403       (!((ctype_isRealBool (te1) || ctype_isRealBool (te2)) &&
5404          (opid == AND_OP || opid == OR_OP
5405           || opid == EQ_OP || opid == NE_OP))))
5406     {
5407       if (abstractOpError (tr1, tr2, op, e1, e2, e1->loc, e2->loc))
5408         {
5409           tret = ctype_unknown;
5410           goto skiprest;
5411         }
5412     }
5413
5414   if (ctype_isUnknown (te1) || ctype_isUnknown (te2))
5415     {
5416       /* unknown types, no comparisons possible */
5417       goto skiprest;
5418     }
5419
5420   switch (opid)
5421     {
5422     case TMULT:         /* multiplication and division:           */
5423     case TDIV:          /*                                        */
5424     case MUL_ASSIGN:    /*    numeric, numeric -> numeric         */
5425     case DIV_ASSIGN:    /*                                        */
5426       if (opid == TMULT || opid == MUL_ASSIGN)
5427         {
5428           ret->val = multiVal_multiply (exprNode_getValue (e1),
5429                                         exprNode_getValue (e2));
5430         }
5431       else
5432         {
5433           ret->val = multiVal_divide (exprNode_getValue (e1),
5434                                       exprNode_getValue (e2));
5435         }
5436
5437       tret = checkNumerics (tr1, tr2, te1, te2, e1, e2, op);
5438       break;
5439
5440     case TPLUS:         /* addition and subtraction:               */
5441     case TMINUS:        /*    pointer, int     -> pointer          */
5442     case SUB_ASSIGN:    /*    int, pointer     -> pointer          */
5443     case ADD_ASSIGN:    /*    numeric, numeric -> numeric          */
5444       if (opid == TPLUS || opid == ADD_ASSIGN)
5445         {
5446           ret->val = multiVal_add (exprNode_getValue (e1),
5447                                    exprNode_getValue (e2));
5448         }
5449       else
5450         {
5451           ret->val = multiVal_subtract (exprNode_getValue (e1),
5452                                         exprNode_getValue (e2));
5453         }
5454
5455       tr1 = ctype_fixArrayPtr (tr1);
5456
5457       if ((ctype_isRealPointer (tr1) && !exprNode_isNullValue (e1))
5458           && (!ctype_isRealPointer (tr2) && ctype_isRealInt (tr2)))
5459         {
5460           /* pointer + int */
5461
5462           if (context_msgPointerArith ())
5463             {
5464               voptgenerror
5465                 (FLG_POINTERARITH,
5466                  message ("Pointer arithmetic (%t, %t): %s",
5467                           te1, te2, exprNode_unparse (ret)),
5468                  e1->loc);
5469             }
5470
5471           /*
5472           ** Swap terms so e1 is always the pointer
5473           */
5474
5475           if (ctype_isRealPointer (tr1))
5476             {
5477               ;
5478             }
5479           else
5480             {
5481               exprNode_swap (e1, e2);
5482             }
5483
5484           if (sRef_possiblyNull (e1->sref)
5485               && !usymtab_isGuarded (e1->sref))
5486             {
5487               voptgenerror
5488                 (FLG_NULLPOINTERARITH,
5489                  message ("Pointer arithmetic involving possibly "
5490                           "null pointer %s: %s",
5491                           exprNode_unparse (e1),
5492                           exprNode_unparse (ret)),
5493                  e1->loc);
5494             }
5495
5496           ret->sref = sRef_copy (e1->sref);
5497
5498           /* start modifications */
5499           /* added by Seejo on 4/16/2000 */
5500
5501           /* Arithmetic operations on pointers wil modify the size/len/null terminated
5502              status */
5503           if ((sRef_isPossiblyNullTerminated (e1->sref)) || (sRef_isNullTerminated(e1->sref))) {
5504             int val;
5505             /*drl 1-4-2002
5506               added ugly fixed to stop
5507               program from crashing on point + int +int
5508               one day I'll fix this or ask Seejo wtf the codes supposed to do. */
5509
5510             if (!multiVal_isInt (e2->val) )
5511               break;
5512             /*end drl*/
5513
5514             val = (int) multiVal_forceInt (e2->val);
5515
5516             /* Operator : + or += */
5517             if ((lltok_getTok (op) == TPLUS) || (lltok_getTok(op) == ADD_ASSIGN)) {
5518               if (sRef_getSize(e1->sref) >= val) {/* Incrementing the pointer by
5519                                                      val should not result in a
5520                                                      size < 0 (size = 0 is ok !) */
5521
5522                 sRef_setSize (ret->sref, sRef_getSize(e1->sref) - val);
5523
5524                 if (sRef_getLen(e1->sref) == val) { /* i.e. the character at posn val is \0 */
5525                   sRef_setNotNullTerminatedState(ret->sref);
5526                   sRef_resetLen (ret->sref);
5527                 } else {
5528                   sRef_setNullTerminatedState(ret->sref);
5529                   sRef_setLen (ret->sref, sRef_getLen(e1->sref) - val);
5530                 }
5531               }
5532             }
5533
5534             /* Operator : - or -= */
5535             if ((lltok_getTok (op) == TMINUS) || (lltok_getTok (op) == SUB_ASSIGN)) {
5536               if (sRef_getSize(e1->sref) >= 0) {
5537                 sRef_setSize (ret->sref, sRef_getSize(e1->sref) + val);
5538                 sRef_setLen (ret->sref, sRef_getLen(e1->sref) + val);
5539               }
5540             }
5541           }
5542
5543           /* end modifications */
5544
5545           sRef_setNullError (ret->sref);
5546
5547           /*
5548           ** Fixed for 2.2c: the alias state of ptr + int is dependent,
5549           ** since is points to storage that should not be deallocated
5550           ** through this pointer.
5551           */
5552
5553           if (sRef_isOnly (ret->sref)
5554               || sRef_isFresh (ret->sref))
5555             {
5556               sRef_setAliasKind (ret->sref, AK_DEPENDENT, exprNode_loc (ret));
5557             }
5558
5559           tret = e1->typ;
5560         }
5561       else if ((!ctype_isRealPointer(tr1) && ctype_isRealInt (tr1))
5562                && (ctype_isRealPointer (tr2) && !exprNode_isNullValue (e2)))
5563         {
5564           if (context_msgPointerArith ())
5565             {
5566               voptgenerror
5567                 (FLG_POINTERARITH,
5568                  message ("Pointer arithmetic (%t, %t): %s",
5569                           te1, te2, exprNode_unparse (ret)),
5570                  e1->loc);
5571             }
5572
5573           if (sRef_possiblyNull (e1->sref)
5574               && !usymtab_isGuarded (e1->sref))
5575             {
5576               voptgenerror
5577                 (FLG_NULLPOINTERARITH,
5578                  message ("Pointer arithmetic involving possibly "
5579                           "null pointer %s: %s",
5580                           exprNode_unparse (e2),
5581                           exprNode_unparse (ret)),
5582                  e2->loc);
5583             }
5584
5585           ret->sref = sRef_copy (e2->sref);
5586
5587           /* start modifications */
5588           /* added by Seejo on 4/16/2000 */
5589
5590           /* Arithmetic operations on pointers wil modify the size/len/null terminated
5591              status */
5592
5593           if ((sRef_isPossiblyNullTerminated (e2->sref)) || (sRef_isNullTerminated(e2->sref))) {
5594             int val = (int) multiVal_forceInt (e1->val);
5595
5596             /* Operator : + or += */
5597             if ((lltok_getTok (op) == TPLUS) || (lltok_getTok(op) == ADD_ASSIGN)) {
5598               if (sRef_getSize(e2->sref) >= val) {/* Incrementing the pointer by
5599                                                      val should not result in a
5600                                                      size < 0 (size = 0 is ok !) */
5601
5602                 sRef_setSize (ret->sref, sRef_getSize(e2->sref) - val);
5603
5604                 if (sRef_getLen(e2->sref) == val) { /* i.e. the character at posn val is \0 */
5605                   sRef_setNotNullTerminatedState(ret->sref);
5606                   sRef_resetLen (ret->sref);
5607                 } else {
5608                   sRef_setNullTerminatedState(ret->sref);
5609                   sRef_setLen (ret->sref, sRef_getLen(e2->sref) - val);
5610                 }
5611               }
5612             }
5613
5614             /* Operator : - or -= */
5615             if ((lltok_getTok (op) == TMINUS) || (lltok_getTok (op) == SUB_ASSIGN)) {
5616               if (sRef_getSize(e2->sref) >= 0) {
5617                 sRef_setSize (ret->sref, sRef_getSize(e2->sref) + val);
5618                 sRef_setLen (ret->sref, sRef_getLen(e2->sref) + val);
5619               }
5620             }
5621           }
5622           /* end modifications */
5623
5624           sRef_setNullError (ret->sref);
5625
5626           /*
5627           ** Fixed for 2.2c: the alias state of ptr + int is dependent,
5628           ** since is points to storage that should not be deallocated
5629           ** through this pointer.
5630           */
5631
5632           if (sRef_isOnly (ret->sref)
5633               || sRef_isFresh (ret->sref)) {
5634             sRef_setAliasKind (ret->sref, AK_DEPENDENT, exprNode_loc (ret));
5635           }
5636
5637           tret = e2->typ;
5638           ret->sref = e2->sref;
5639         }
5640       else
5641         {
5642           tret = checkNumerics (tr1, tr2, te1, te2, e1, e2, op);
5643         }
5644
5645       break;
5646
5647     case LEFT_ASSIGN:
5648     case RIGHT_ASSIGN:
5649     case LEFT_OP:
5650     case RIGHT_OP:
5651     case TAMPERSAND:    /* bitwise & */
5652     case AND_ASSIGN:
5653     case TCIRC:         /* ^ (XOR) */
5654     case TBAR:
5655     case XOR_ASSIGN:
5656     case OR_ASSIGN:
5657       {
5658         bool reported = FALSE;
5659
5660         /*
5661         ** Shift Operator
5662         */
5663
5664         if (opid == LEFT_OP || opid == LEFT_ASSIGN
5665             || opid == RIGHT_OP || opid == RIGHT_ASSIGN)
5666           {
5667             /*
5668             ** evans 2002-01-01: fixed this to follow ISO 6.5.7.
5669             */
5670
5671             if (!ctype_isUnsigned (tr2)
5672                 && !exprNode_isNonNegative (e2))
5673               {
5674                 reported = optgenerror
5675                   (FLG_SHIFTNEGATIVE,
5676                    message ("Right operand of %s may be negative (%t): %s",
5677                             lltok_unparse (op), te2,
5678                             exprNode_unparse (ret)),
5679                    e2->loc);
5680               }
5681
5682             if (!ctype_isUnsigned (tr1)
5683                 && !exprNode_isNonNegative (e1))
5684               {
5685                 reported = optgenerror
5686                   (FLG_SHIFTIMPLEMENTATION,
5687                    message ("Left operand of %s may be negative (%t): %s",
5688                             lltok_unparse (op), te1,
5689                             exprNode_unparse (ret)),
5690                    e1->loc);
5691               }
5692
5693             /*
5694             ** Should check size of right operand also...
5695             */
5696
5697           }
5698         else
5699           {
5700             if (!ctype_isUnsigned (tr1))
5701               {
5702                 if (exprNode_isNonNegative (e1)) {
5703                   ;
5704                 } else {
5705                   reported = optgenerror
5706                     (FLG_BITWISEOPS,
5707                      message ("Left operand of %s is not unsigned value (%t): %s",
5708                               lltok_unparse (op), te1,
5709                               exprNode_unparse (ret)),
5710                      e1->loc);
5711
5712                   if (reported) {
5713                     te1 = ctype_uint;
5714                   }
5715                 }
5716               }
5717             else
5718               {
5719                 if (!ctype_isUnsigned (tr2))
5720                   {
5721                     if (!exprNode_isNonNegative (e2)) {
5722                       reported = optgenerror
5723                         (FLG_BITWISEOPS,
5724                          message ("Right operand of %s is not unsigned value (%t): %s",
5725                                   lltok_unparse (op), te2,
5726                                   exprNode_unparse (ret)),
5727                          e2->loc);
5728                     }
5729                   }
5730               }
5731           }
5732
5733         if (!reported)
5734           {
5735             if (!checkIntegral (e1, e2, ret, op)) {
5736               te1 = ctype_unknown;
5737             }
5738           }
5739
5740         DPRINTF (("Set: %s", ctype_unparse (te1)));
5741
5742         /*
5743         ** tret is the widest type of te1 and te2
5744         */
5745
5746         tret = ctype_widest (te1, te2);
5747         break;
5748       }
5749     case MOD_ASSIGN:
5750     case TPERCENT:
5751       if (checkIntegral (e1, e2, ret, op)) {
5752         tret = te1;
5753       } else {
5754         tret = ctype_unknown;
5755       }
5756       break;
5757     case EQ_OP:
5758     case NE_OP:
5759     case TLT:           /* comparisons                           */
5760     case TGT:           /*    numeric, numeric -> bool           */
5761
5762       DPRINTF (("Here we go: %s / %s",
5763                 ctype_unparse (tr1), ctype_unparse (tr2)));
5764
5765       if ((ctype_isReal (tr1) && !ctype_isInt (tr1))
5766           || (ctype_isReal (tr2) && !ctype_isInt (tr2)))
5767         {
5768           ctype rtype = tr1;
5769           bool fepsilon = FALSE;
5770
5771           if (!ctype_isReal (rtype) || ctype_isInt (rtype))
5772             {
5773               rtype = tr2;
5774             }
5775
5776           if (opid == TLT || opid == TGT)
5777             {
5778               uentry ue1 = exprNode_getUentry (e1);
5779               uentry ue2 = exprNode_getUentry (e2);
5780
5781               /*
5782               ** FLT_EPSILON, etc. really is a variable, not
5783               ** a constant.
5784               */
5785
5786               if (uentry_isVariable (ue1))
5787                 {
5788                   cstring uname = uentry_rawName (ue1);
5789
5790                   if (cstring_equalLit (uname, "FLT_EPSILON")
5791                       || cstring_equalLit (uname, "DBL_EPSILON")
5792                       || cstring_equalLit (uname, "LDBL_EPSILON"))
5793                     {
5794                       fepsilon = TRUE;
5795                     }
5796                 }
5797
5798               if (uentry_isVariable (ue2))
5799                 {
5800                   cstring uname = uentry_rawName (ue2);
5801
5802                   if (cstring_equalLit (uname, "FLT_EPSILON")
5803                       || cstring_equalLit (uname, "DBL_EPSILON")
5804                       || cstring_equalLit (uname, "LDBL_EPSILON"))
5805                     {
5806                       fepsilon = TRUE;
5807                     }
5808                 }
5809             }
5810
5811           if (fepsilon)
5812             {
5813               ; /* Don't complain. */
5814             }
5815           else
5816             {
5817               voptgenerror
5818                 (FLG_REALCOMPARE,
5819                  message ("Dangerous comparison involving %s types: %s",
5820                           ctype_unparse (rtype),
5821                           exprNode_unparse (ret)),
5822                  ret->loc);
5823             }
5824         }
5825       /*@fallthrough@*/
5826     case LE_OP:
5827     case GE_OP:
5828
5829       /*
5830       ** Types should match.
5831       */
5832
5833       DPRINTF (("Match types: %s / %s", exprNode_unparse (e1),
5834                 exprNode_unparse (e2)));
5835
5836       if (!exprNode_matchTypes (e1, e2))
5837         {
5838           hasError = gentypeerror
5839             (te1, e1, te2, e2,
5840              message ("Operands of %s have incompatible types (%t, %t): %s",
5841                       lltok_unparse (op), te1, te2, exprNode_unparse (ret)),
5842              e1->loc);
5843
5844         }
5845
5846       if (hasError
5847           || (ctype_isForceRealNumeric (&tr1)
5848               && ctype_isForceRealNumeric (&tr2)) ||
5849           (ctype_isRealPointer (tr1) && ctype_isRealPointer (tr2)))
5850         {
5851           ; /* okay */
5852         }
5853       else
5854         {
5855           if ((ctype_isRealNumeric (tr1) && ctype_isRealPointer (tr2)) ||
5856               (ctype_isRealPointer (tr1) && ctype_isRealNumeric (tr2)))
5857             {
5858               voptgenerror
5859                 (FLG_PTRNUMCOMPARE,
5860                  message ("Comparison of pointer and numeric (%t, %t): %s",
5861                           te1, te2, exprNode_unparse (ret)),
5862                  e1->loc);
5863             }
5864           else
5865             {
5866               (void) checkNumerics (tr1, tr2, te1, te2, e1, e2, op);
5867             }
5868           tret = ctype_bool;
5869         }
5870
5871       /* certain comparisons on unsigned's and zero look suspicious */
5872
5873       if (opid == TLT || opid == LE_OP || opid == GE_OP)
5874         {
5875           if ((ctype_isUnsigned (tr1) && exprNode_isZero (e2))
5876               || (ctype_isUnsigned (tr2) && exprNode_isZero (e1)))
5877             {
5878               voptgenerror
5879                 (FLG_UNSIGNEDCOMPARE,
5880                  message ("Comparison of unsigned value involving zero: %s",
5881                           exprNode_unparse (ret)),
5882                  e1->loc);
5883             }
5884         }
5885
5886       /* EQ_OP should NOT be used with booleans (unless one is FALSE) */
5887
5888       if ((opid == EQ_OP || opid == NE_OP) &&
5889           ctype_isDirectBool (tr1) && ctype_isDirectBool (tr2))
5890         {
5891           /*
5892           ** is one a variable?
5893           */
5894
5895           if (uentry_isVariable (exprNode_getUentry (e1))
5896               || uentry_isVariable (exprNode_getUentry (e2)))
5897             {
5898               /*
5899               ** comparisons with FALSE are okay
5900               */
5901
5902               if (exprNode_isFalseConstant (e1)
5903                   || exprNode_isFalseConstant (e2))
5904                 {
5905                   ;
5906                 }
5907               else
5908                 {
5909                   voptgenerror
5910                     (FLG_BOOLCOMPARE,
5911                      message
5912                      ("Use of %q with %s variables (risks inconsistency because "
5913                       "of multiple true values): %s",
5914                       cstring_makeLiteral ((opid == EQ_OP) ? "==" : "!="),
5915                       context_printBoolName (), exprNode_unparse (ret)),
5916                      e1->loc);
5917                 }
5918             }
5919         }
5920       break;
5921
5922     case AND_OP:                /* bool, bool -> bool */
5923     case OR_OP:
5924       if (ctype_isForceRealBool (&tr1) && ctype_isForceRealBool (&tr2))
5925         {
5926           ;
5927         }
5928       else
5929         {
5930           if (context_maybeSet (FLG_BOOLOPS))
5931             {
5932               if (!ctype_isRealBool (te1) && !ctype_isRealBool (te2))
5933                 {
5934                   if (ctype_sameName (te1, te2))
5935                     {
5936                       voptgenerror
5937                         (FLG_BOOLOPS,
5938                          message ("Operands of %s are non-boolean (%t): %s",
5939                                   lltok_unparse (op), te1,
5940                                   exprNode_unparse (ret)),
5941                          e1->loc);
5942                     }
5943                   else
5944                     {
5945                       voptgenerror
5946                         (FLG_BOOLOPS,
5947                          message
5948                          ("Operands of %s are non-booleans (%t, %t): %s",
5949                           lltok_unparse (op), te1, te2, exprNode_unparse (ret)),
5950                          e1->loc);
5951                     }
5952                 }
5953               else if (!ctype_isRealBool (te1))
5954                 {
5955                   voptgenerror
5956                     (FLG_BOOLOPS,
5957                      message ("Left operand of %s is non-boolean (%t): %s",
5958                               lltok_unparse (op), te1, exprNode_unparse (ret)),
5959                      e1->loc);
5960                 }
5961               else if (!ctype_isRealBool (te2))
5962                 {
5963                   voptgenerror
5964                     (FLG_BOOLOPS,
5965                      message ("Right operand of %s is non-boolean (%t): %s",
5966                               lltok_unparse (op), te2, exprNode_unparse (ret)),
5967                      e2->loc);
5968                 }
5969               else
5970                 {
5971                   ;
5972                 }
5973             }
5974           tret = ctype_bool;
5975         }
5976       break;
5977     default:
5978       llfatalbug
5979         (cstring_makeLiteral
5980          ("There has been a problem in the parser. This is believed to result "
5981           "from a problem with bison v. 1.25.  Please try rebuidling Splint "
5982           "using the pre-compiled grammar files by commenting out the "
5983           "BISON= line in the top-level Makefile."));
5984     }
5985
5986 skiprest:
5987   ret->typ = tret;
5988   DPRINTF (("Return type %s: %s", exprNode_unparse (ret), ctype_unparse (tret)));
5989
5990   exprNode_checkUse (ret, e1->sref, e1->loc);
5991   exprNode_mergeUSs (ret, e2);
5992   exprNode_checkUse (ret, e2->sref, e2->loc);
5993
5994   return ret;
5995 }
5996
5997 /*@only@*/ exprNode
5998 exprNode_op (/*@only@*/ exprNode e1, /*@keep@*/ exprNode e2,
5999              /*@only@*/ lltok op)
6000 {
6001   exprNode ret;
6002
6003   checkMacroParen (e1);
6004   checkMacroParen (e2);
6005
6006   if (evaluationOrderUndefined (op) && context_maybeSet (FLG_EVALORDER))
6007     {
6008       checkExpressionDefined (e1, e2, op);
6009     }
6010
6011   ret = exprNode_makeOp (e1, e2, op);
6012   return (ret);
6013 }
6014
6015 static
6016 void exprNode_checkAssignMod (exprNode e1, exprNode ret)
6017 {
6018   /*
6019   ** This is somewhat bogus!
6020   **
6021   ** Assigning to a nested observer in a non-observer datatype
6022   ** should not produce an error.
6023   */
6024
6025   sRef ref = exprNode_getSref (e1);
6026
6027   DPRINTF (("Check assign mod: %s",
6028             sRef_unparseFull (ref)));
6029
6030   if (sRef_isObserver (ref)
6031       || ((sRef_isFileStatic (ref) || sRef_isFileOrGlobalScope (ref))
6032           && ctype_isArray (ctype_realType (sRef_getType (ref)))))
6033     {
6034       sRef base = sRef_getBase (ref);
6035
6036       if (sRef_isValid (base) && sRef_isObserver (base))
6037         {
6038           exprNode_checkModify (e1, ret);
6039         }
6040       else
6041         {
6042           exprNode_checkModifyVal (e1, ret);
6043         }
6044     }
6045   else
6046     {
6047       exprNode_checkModify (e1, ret);
6048     }
6049 }
6050
6051 exprNode
6052 exprNode_assign (/*@only@*/ exprNode e1, /*@only@*/ exprNode e2, /*@only@*/ lltok op)
6053 {
6054   bool isalloc = FALSE;
6055   bool isjustalloc = FALSE;
6056   bool noalias = FALSE;
6057   exprNode ret;
6058
6059   DPRINTF (("%s [%s] <- %s [%s]",
6060             exprNode_unparse (e1),
6061             ctype_unparse (e1->typ),
6062             exprNode_unparse (e2),
6063             ctype_unparse (e2->typ)));
6064
6065   if (lltok_getTok (op) != TASSIGN)
6066     {
6067       ret = exprNode_makeOp (e1, e2, op);
6068
6069       DPRINTF (("Here goes: %s %s",
6070                 ctype_unparse (e1->typ),
6071                 ctype_unparse (e2->typ)));
6072
6073       if (exprNode_isDefined (e1)
6074           && exprNode_isDefined (e2))
6075         {
6076           if (ctype_isNumeric (e2->typ)
6077               || ctype_isNumeric (e1->typ))
6078             {
6079               /* Its a pointer arithmetic expression like ptr += i */
6080               noalias = TRUE;
6081             }
6082         }
6083     }
6084   else
6085     {
6086       ret = exprNode_createPartialCopy (e1);
6087       ret->kind = XPR_ASSIGN;
6088       ret->edata = exprData_makeOp (e1, e2, op);
6089
6090       if (!exprNode_isError (e2))
6091         {
6092           ret->sets = sRefSet_union (ret->sets, e2->sets);
6093           ret->msets = sRefSet_union (ret->msets, e2->msets);
6094           ret->uses = sRefSet_union (ret->uses, e2->uses);
6095         }
6096     }
6097
6098   checkExpressionDefined (e1, e2, op);
6099
6100   if (exprNode_isError (e1))
6101     {
6102       if (!exprNode_isError (e2))
6103         {
6104           ret->loc = fileloc_update (ret->loc, e2->loc);
6105         }
6106       else
6107         {
6108           ret->loc = fileloc_update (ret->loc, g_currentloc);
6109         }
6110     }
6111
6112   if (!exprNode_isError (e2))
6113     {
6114       checkMacroParen (e2);
6115     }
6116
6117   if (exprNode_isDefined (e1))
6118     {
6119       if (sRef_isMacroParamRef (e1->sref))
6120         {
6121           if (context_inIterDef ())
6122             {
6123               uentry ue = sRef_getUentry (e1->sref);
6124
6125               if (uentry_isYield (ue))
6126                 {
6127                   ;
6128                 }
6129               else
6130                 {
6131                   if (fileloc_isDefined (e1->loc))
6132                     {
6133                       voptgenerror
6134                         (FLG_MACROPARAMS,
6135                          message ("Assignment to non-yield iter parameter: %q",
6136                                   sRef_unparse (e1->sref)),
6137                          e1->loc);
6138                     }
6139                   else
6140                     {
6141                       voptgenerror
6142                         (FLG_MACROPARAMS,
6143                          message ("Assignment to non-yield iter parameter: %q",
6144                                   sRef_unparse (e1->sref)),
6145                          g_currentloc);
6146                     }
6147                 }
6148             }
6149           else
6150             {
6151               if (fileloc_isDefined (e1->loc))
6152                 {
6153                   voptgenerror
6154                     (FLG_MACROASSIGN,
6155                      message ("Assignment to macro parameter: %q",
6156                               sRef_unparse (e1->sref)),
6157                      e1->loc);
6158                 }
6159               else
6160                 {
6161                   voptgenerror
6162                     (FLG_MACROASSIGN,
6163                      message ("Assignment to macro parameter: %q",
6164                               sRef_unparse (e1->sref)),
6165                      g_currentloc);
6166                 }
6167
6168               exprNode_checkAssignMod (e1, ret); /* evans 2001-07-22 */
6169             }
6170         }
6171       else
6172         {
6173           exprNode_checkAssignMod (e1, ret);
6174         }
6175
6176       if (exprNode_isDefined (e2))
6177         {
6178           if (lltok_getTok (op) == TASSIGN)
6179             {
6180               ctype te1 = exprNode_getType (e1);
6181               ctype te2 = exprNode_getType (e2);
6182
6183               if (ctype_isVoid (te2))
6184                 {
6185                   (void) gentypeerror
6186                     (te2, e2, te1, e1,
6187                      message ("Assignment of void value to %t: %s %s %s",
6188                               te1, exprNode_unparse (e1),
6189                               lltok_unparse (op),
6190                               exprNode_unparse (e2)),
6191                      e1->loc);
6192                 }
6193               else if (!ctype_forceMatch (te1, te2))
6194                 {
6195                   if (exprNode_matchLiteral (te1, e2))
6196                     {
6197                       DPRINTF (("Literals match: %s / %s",
6198                                 ctype_unparse (te1), exprNode_unparse (e2)));
6199                       if (ctype_isNumAbstract (te1)) {
6200                         if (!context_flagOn (FLG_NUMABSTRACTLIT, e1->loc)) {
6201                           (void) llgenhinterror
6202                             (FLG_NUMABSTRACT,
6203                              message
6204                              ("Assignment of %t literal to numabstract type %t: %s %s %s",
6205                               te2, te1,
6206                               exprNode_unparse (e1),
6207                               lltok_unparse (op),
6208                               exprNode_unparse (e2)),
6209                              cstring_makeLiteral
6210                              ("Use +numabstractlit to allow numeric literals to be used as numabstract values"),
6211                              e1->loc);
6212                         }
6213                       }
6214                     }
6215                   else
6216                     {
6217                       (void) gentypeerror
6218                         (te2, e2, te1, e1,
6219                          message ("Assignment of %t to %t: %s %s %s",
6220                                   te2, te1, exprNode_unparse (e1),
6221                                   lltok_unparse (op),
6222                                   exprNode_unparse (e2)),
6223                          e1->loc);
6224                     }
6225                 }
6226               else
6227                 {
6228                   /* Type checks okay */
6229                 }
6230             }
6231
6232           exprNode_mergeUSs (ret, e2);
6233           exprNode_checkUse (ret, e2->sref, e2->loc);
6234
6235           DPRINTF (("Do assign! %s %s", exprNode_unparse (e1), exprNode_unparse (e2)));
6236           if (noalias)
6237             {
6238               ;
6239             }
6240           else
6241             {
6242               doAssign (e1, e2, FALSE);
6243             }
6244
6245           ret->sref = e1->sref;
6246         }
6247       else
6248         {
6249           if (exprNode_isDefined (e2))
6250             {
6251               exprNode_mergeUSs (ret, e2);
6252               exprNode_checkUse (ret, e2->sref, e2->loc);
6253             }
6254         }
6255
6256       if (sRef_isPointer (e1->sref) && !sRef_isMacroParamRef (e1->sref))
6257         {
6258           exprNode_checkUse (ret, sRef_getBase (e1->sref), e1->loc);
6259         }
6260
6261       isjustalloc = sRef_isJustAllocated (e1->sref);
6262       isalloc = sRef_isAllocated (e1->sref);
6263
6264       if (sRef_isField (e1->sref))
6265         {
6266           sRef root = sRef_getRootBase (sRef_getBase (e1->sref));
6267
6268           if (!sRef_isAllocated (root) && !sRef_isMacroParamRef (root))
6269             {
6270               exprNode_checkUse (ret, root, e1->loc);
6271             }
6272
6273         }
6274
6275       /*
6276       ** be careful!  this defines e1->sref.
6277       */
6278
6279       /* evans 2001-07-22: removed if (!sRef_isMacroParamRef (e1->sref)) */
6280
6281       DPRINTF (("Setting: %s -> %s", exprNode_unparse (ret), sRef_unparse (e1->sref)));
6282       exprNode_checkSet (ret, e1->sref);
6283
6284       if (isjustalloc)
6285         {
6286           sRef_setAllocatedComplete (e1->sref, exprNode_isDefined (e2)
6287                                      ? e2->loc : e1->loc);
6288         }
6289       else
6290         {
6291           if (isalloc)
6292             {
6293               sRef_setAllocatedShallowComplete (e1->sref, exprNode_loc (e2));
6294             }
6295         }
6296     }
6297
6298   return ret;
6299 }
6300
6301 exprNode
6302 exprNode_cond (/*@keep@*/ exprNode pred, /*@keep@*/ exprNode ifclause,
6303                /*@keep@*/ exprNode elseclause)
6304 {
6305   exprNode ret;
6306
6307   if (!exprNode_isError (pred))
6308     {
6309       ret = exprNode_createPartialCopy (pred);
6310       checkMacroParen (pred);
6311       exprNode_checkPred (cstring_makeLiteralTemp ("conditional"), pred);
6312
6313       if (!exprNode_isError (ifclause))
6314         {
6315           checkMacroParen (ifclause);   /* update macro counts! */
6316
6317           if (!exprNode_isError (elseclause))
6318             {
6319               checkMacroParen (elseclause);
6320
6321               if (!exprNode_matchTypes (ifclause, elseclause))
6322                 {
6323                   if (gentypeerror
6324                       (exprNode_getType (ifclause),
6325                        ifclause,
6326                        exprNode_getType (elseclause),
6327                        elseclause,
6328                        message ("Conditional clauses are not of same type: "
6329                                 "%s (%t), %s (%t)",
6330                                 exprNode_unparse (ifclause),
6331                                 exprNode_getType (ifclause),
6332                                 exprNode_unparse (elseclause),
6333                                 exprNode_getType (elseclause)),
6334                        ifclause->loc))
6335                     {
6336                       ret->sref = sRef_undefined;
6337                       ret->typ = ctype_unknown;
6338                     }
6339                 }
6340               else
6341                 {
6342                   /* for now...should merge the states */
6343                   ret->sref = ifclause->sref;
6344                   ret->typ = ifclause->typ;
6345
6346                   if (exprNode_isNullValue (ifclause))
6347                     {
6348                       ret->typ = elseclause->typ;
6349                     }
6350                 }
6351
6352               exprNode_checkUse (ret, pred->sref, pred->loc);
6353               exprNode_checkUse (ifclause, ifclause->sref, ifclause->loc);
6354               exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc);
6355
6356               exprNode_mergeCondUSs (ret, ifclause, elseclause);
6357
6358             }
6359           else
6360             {
6361               ret->typ = ifclause->typ;
6362
6363               exprNode_checkUse (pred, pred->sref, pred->loc);
6364               exprNode_checkUse (ifclause, ifclause->sref, ifclause->loc);
6365
6366               exprNode_mergeCondUSs (ret, ifclause, exprNode_undefined);
6367             }
6368         }
6369       else
6370         {
6371           if (!exprNode_isError (elseclause))
6372             {
6373               ret->typ = elseclause->typ;
6374
6375               exprNode_checkUse (pred, pred->sref, pred->loc);
6376               exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc);
6377
6378               exprNode_mergeCondUSs (ret, exprNode_undefined, elseclause);
6379             }
6380         }
6381     }
6382   else /* pred is error */
6383     {
6384       if (!exprNode_isError (ifclause))
6385         {
6386           ret = exprNode_createSemiCopy (ifclause);
6387
6388           checkMacroParen (ifclause);   /* update macro counts! */
6389
6390           if (!exprNode_isError (elseclause))
6391             {
6392               checkMacroParen (elseclause);
6393
6394               ret->typ = ifclause->typ;
6395
6396               if (!ctype_forceMatch (ifclause->typ, elseclause->typ))
6397                 {
6398                   if (gentypeerror
6399                       (exprNode_getType (ifclause),
6400                        ifclause,
6401                        exprNode_getType (elseclause),
6402                        elseclause,
6403                        message ("Conditional clauses are not of same type: "
6404                                 "%s (%t), %s (%t)",
6405                                 exprNode_unparse (ifclause),
6406                                 exprNode_getType (ifclause),
6407                                 exprNode_unparse (elseclause),
6408                                 exprNode_getType (elseclause)),
6409                        ifclause->loc))
6410                     {
6411                       ret->typ = ctype_unknown;
6412                     }
6413                 }
6414
6415               exprNode_checkUse (ifclause, ifclause->sref, ifclause->loc);
6416               exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc);
6417
6418               exprNode_mergeCondUSs (ret, ifclause, elseclause);
6419             }
6420         }
6421       else if (!exprNode_isError (elseclause)) /* pred, if errors */
6422         {
6423           ret = exprNode_createSemiCopy (ifclause);
6424
6425           ret->typ = elseclause->typ;
6426           checkMacroParen (elseclause);
6427
6428           exprNode_checkUse (elseclause, elseclause->sref, elseclause->loc);
6429           exprNode_mergeCondUSs (ret, exprNode_undefined, elseclause);
6430         }
6431       else /* all errors! */
6432         {
6433           ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
6434         }
6435     }
6436
6437   ret->kind = XPR_COND;
6438   ret->edata = exprData_makeCond (pred, ifclause, elseclause);
6439
6440   if (exprNode_isDefined (ifclause) && exprNode_isDefined (elseclause))
6441     {
6442       exprNode_combineControl (ret, ifclause, elseclause);
6443     }
6444
6445   return (ret);
6446 }
6447
6448 exprNode
6449 exprNode_vaArg (/*@only@*/ lltok tok, /*@only@*/ exprNode arg, /*@only@*/ qtype qt)
6450 {
6451   ctype totype = qtype_getType (qt);
6452   exprNode ret =
6453     exprNode_createPartialLocCopy (arg, fileloc_copy (lltok_getLoc (tok)));
6454   ctype targ;
6455
6456   /*
6457   ** check use of va_arg : <valist>, type -> type
6458   */
6459
6460   if (exprNode_isError (arg))
6461     {
6462     }
6463   else
6464     {
6465       targ = exprNode_getType (arg);
6466
6467       /*
6468       ** arg should have be a pointer
6469       */
6470
6471       if (!ctype_isUA (targ) ||
6472           (!usymId_equal (ctype_typeId (targ),
6473                          usymtab_getTypeId (cstring_makeLiteralTemp ("va_list")))))
6474         {
6475           voptgenerror
6476             (FLG_TYPE,
6477              message ("First argument to va_arg is not a va_list (type %t): %s",
6478                       targ, exprNode_unparse (arg)),
6479              arg->loc);
6480         }
6481
6482       exprNode_checkSet (ret, arg->sref);
6483     }
6484
6485   /*
6486   ** return type is totype
6487   */
6488
6489   ret->typ = totype;
6490   ret->kind = XPR_VAARG;
6491   ret->edata = exprData_makeCast (tok, arg, qt);
6492
6493   return (ret);
6494 }
6495
6496 exprNode exprNode_labelMarker (/*@only@*/ cstring label)
6497 {
6498   exprNode ret = exprNode_createPlain (ctype_undefined);
6499   ret->kind = XPR_LABEL;
6500   ret->edata = exprData_makeLiteral (label);
6501   ret->isJumpPoint = TRUE;
6502
6503   return (ret); /* for now, ignore label */
6504 }
6505
6506 exprNode exprNode_notReached (/*@returned@*/ exprNode stmt)
6507 {
6508   if (exprNode_isDefined (stmt))
6509     {
6510       stmt->isJumpPoint = TRUE;
6511
6512       /* This prevent stray no return path errors, etc. */
6513       stmt->exitCode = XK_MUSTEXIT;
6514     }
6515
6516   return (stmt);
6517 }
6518
6519 bool exprNode_isDefaultMarker (exprNode e)
6520 {
6521   if (exprNode_isDefined (e))
6522     {
6523       return (e->kind == XPR_DEFAULT || e->kind == XPR_FTDEFAULT);
6524     }
6525
6526   return FALSE;
6527 }
6528
6529 bool exprNode_isCaseMarker (exprNode e)
6530 {
6531   if (exprNode_isDefined (e))
6532     {
6533       return (e->kind == XPR_FTCASE || e->kind == XPR_CASE);
6534     }
6535
6536   return FALSE;
6537 }
6538
6539 bool exprNode_isLabelMarker (exprNode e)
6540 {
6541   if (exprNode_isDefined (e))
6542     {
6543       return (e->kind == XPR_LABEL);
6544     }
6545
6546   return FALSE;
6547 }
6548
6549 exprNode exprNode_caseMarker (/*@only@*/ exprNode test, bool fallThrough)
6550 {
6551   exprNode ret = exprNode_createPartialCopy (test);
6552
6553   ret->kind = fallThrough ? XPR_FTCASE : XPR_CASE;
6554
6555   if (exprNode_isError (test)) {
6556     return ret;
6557   }
6558
6559   exprNode_checkUse (ret, test->sref, test->loc);
6560
6561   usymtab_setExitCode (ret->exitCode);
6562
6563   if (ret->mustBreak)
6564     {
6565       usymtab_setMustBreak ();
6566     }
6567
6568   ret->edata = exprData_makeSingle (test);
6569   ret->isJumpPoint = TRUE;
6570
6571   return ret;
6572 }
6573
6574 # if 0
6575 exprNode exprNode_caseStatement (/*@only@*/ exprNode test, /*@only@*/ exprNode stmt, bool fallThrough)
6576 {
6577   exprNode ret = exprNode_createPartialCopy (test);
6578
6579   ret->kind = fallThrough ? XPR_FTCASE : XPR_CASE;
6580   ret->edata = exprData_makePair (test, stmt);
6581   ret->isJumpPoint = TRUE;
6582
6583   if (exprNode_isError (test))
6584     {
6585       return ret;
6586     }
6587
6588   exprNode_checkUse (ret, test->sref, test->loc);
6589
6590   if (exprNode_isError (stmt))
6591     {
6592       return ret;
6593     }
6594
6595   exprNode_mergeUSs (ret, stmt);
6596
6597   ret->exitCode = stmt->exitCode;
6598   ret->mustBreak = stmt->mustBreak;
6599   ret->canBreak = stmt->canBreak;
6600
6601   usymtab_setExitCode (ret->exitCode);
6602
6603   if (ret->mustBreak)
6604     {
6605       usymtab_setMustBreak ();
6606     }
6607
6608   return ret;
6609 }
6610 # endif
6611
6612 /*@notnull@*/ /*@only@*/ exprNode
6613 exprNode_defaultMarker (/*@only@*/ lltok def, bool fallThrough)
6614 {
6615   exprNode ret = exprNode_createTok (def);
6616
6617   ret->isJumpPoint = TRUE;
6618   ret->kind = fallThrough ? XPR_FTDEFAULT : XPR_DEFAULT;
6619   return (ret);
6620 }
6621
6622 bool
6623 exprNode_mayEscape (exprNode e)
6624 {
6625   if (exprNode_isDefined (e))
6626     {
6627       return exitkind_couldEscape (e->exitCode);
6628     }
6629   return FALSE;
6630 }
6631
6632 static bool
6633 exprNode_mustBreak (exprNode e)
6634 {
6635   if (exprNode_isDefined (e))
6636     {
6637       return e->mustBreak;
6638     }
6639
6640   return FALSE;
6641 }
6642
6643 bool
6644 exprNode_mustEscape (exprNode e)
6645 {
6646   if (exprNode_isDefined (e))
6647     {
6648       return exitkind_mustEscape (e->exitCode) || exprNode_mustBreak (e);
6649     }
6650
6651   return FALSE;
6652 }
6653
6654 bool
6655 exprNode_errorEscape (exprNode e)
6656 {
6657   if (exprNode_isDefined (e))
6658     {
6659       return exitkind_isError (e->exitCode);
6660     }
6661
6662   return FALSE;
6663 }
6664
6665 exprNode exprNode_concat (/*@only@*/ exprNode e1, /*@only@*/ exprNode e2)
6666 {
6667   exprNode ret = exprNode_createPartialCopy (e1);
6668
6669   DPRINTF (("Concat: %s / %s", exprNode_unparse (e1), exprNode_unparse (e2)));
6670
6671   ret->edata = exprData_makePair (e1, e2);
6672   ret->kind = XPR_STMTLIST;
6673
6674   if (exprNode_isDefined (e1))
6675     {
6676       ret->isJumpPoint = e1->isJumpPoint;
6677       ret->canBreak = e1->canBreak;
6678     }
6679   else
6680     {
6681       if (exprNode_isDefined (e2))
6682         {
6683           ret->loc = fileloc_update (ret->loc, e2->loc);
6684         }
6685     }
6686
6687   if (exprNode_isDefined (e2))
6688     {
6689       ret->exitCode = e2->exitCode;
6690       ret->mustBreak = e2->mustBreak;
6691       if (e2->canBreak) ret->canBreak = TRUE;
6692     }
6693
6694   /*
6695   ** if e1 must return, then e2 is unreachable!
6696   */
6697
6698   if (exprNode_isDefined (e1) && exprNode_isDefined (e2))
6699     {
6700       if ((exprNode_mustEscape (e1) || exprNode_mustBreak (e1))
6701           && !(e2->isJumpPoint))
6702         {
6703           if (context_getFlag (FLG_UNREACHABLE))
6704             {
6705               exprNode nr = e2;
6706
6707               if (e2->kind == XPR_STMT)
6708                 {
6709                   nr = exprData_getUopNode (e2->edata);
6710                 }
6711
6712               if ((nr->kind == XPR_TOK
6713                    && lltok_isSemi (exprData_getTok (nr->edata))))
6714                 {
6715                   /* okay to have unreachable ";" */
6716                   ret->exitCode = XK_MUSTEXIT;
6717                   ret->canBreak = TRUE;
6718                 }
6719               else
6720                 {
6721                   if (optgenerror (FLG_UNREACHABLE,
6722                                    message ("Unreachable code: %s",
6723                                             exprNode_unparseFirst (nr)),
6724                                    exprNode_loc (nr)))
6725                     {
6726                       ret->isJumpPoint = TRUE;
6727                       ret->mustBreak = FALSE;
6728                       ret->exitCode = XK_ERROR;
6729                       DPRINTF (("Jump point: %s", exprNode_unparse (ret)));
6730                     }
6731                   else
6732                     {
6733                       ret->exitCode = XK_MUSTEXIT;
6734                       ret->canBreak = TRUE;
6735                     }
6736
6737                 }
6738             }
6739         }
6740       else
6741         {
6742           if ((e2->kind == XPR_CASE || e2->kind == XPR_DEFAULT))
6743             {
6744               /*
6745               ** We want a warning anytime we have:
6746               **         case xxx: ...
6747               **                   yyy;  <<<- no break or return
6748               **         case zzz: ...
6749               */
6750
6751               exprNode lastStmt = exprNode_lastStatement (e1);
6752
6753               if (exprNode_isDefined (lastStmt)
6754                   && !exprNode_mustEscape (lastStmt)
6755                   && !exprNode_mustBreak (lastStmt)
6756                   && !exprNode_isCaseMarker (lastStmt)
6757                   && !exprNode_isDefaultMarker (lastStmt)
6758                   && !exprNode_isLabelMarker (lastStmt))
6759                 {
6760                   voptgenerror (FLG_CASEBREAK,
6761                                 cstring_makeLiteral
6762                                 ("Fall through case (no preceding break)"),
6763                                 e2->loc);
6764                 }
6765             }
6766         }
6767     }
6768
6769   exprNode_mergeUSs (ret, e2);
6770
6771   usymtab_setExitCode (ret->exitCode);
6772
6773   if (ret->mustBreak)
6774     {
6775       usymtab_setMustBreak ();
6776     }
6777
6778   DPRINTF (("==> %s", exprNode_unparse (ret)));
6779   return ret;
6780 }
6781
6782 exprNode exprNode_createTok (/*@only@*/ lltok t)
6783 {
6784   exprNode ret; /*@i23 if on same line, bad things happen...!@*/
6785   ret = exprNode_create (ctype_unknown);
6786   ret->kind = XPR_TOK;
6787   ret->edata = exprData_makeTok (t);
6788   return ret;
6789 }
6790
6791 exprNode exprNode_statement (/*@only@*/ exprNode e, /*@only@*/ lltok t)
6792 {
6793   if (!exprNode_isError (e))
6794     {
6795       exprChecks_checkStatementEffect(e);
6796     }
6797
6798   return (exprNode_statementError (e, t));
6799 }
6800
6801 static exprNode exprNode_statementError (/*@only@*/ exprNode e, /*@only@*/ lltok t)
6802 {
6803   exprNode ret = exprNode_createPartialCopy (e);
6804
6805   if (!exprNode_isError (e))
6806     {
6807       if (e->kind != XPR_ASSIGN)
6808         {
6809           exprNode_checkUse (ret, e->sref, e->loc);
6810         }
6811
6812       ret->exitCode = e->exitCode;
6813       ret->canBreak = e->canBreak;
6814       ret->mustBreak = e->mustBreak;
6815     }
6816
6817   ret->edata = exprData_makeUop (e, t);
6818   ret->kind = XPR_STMT;
6819
6820   return ret;
6821 }
6822
6823 exprNode exprNode_checkExpr (/*@returned@*/ exprNode e)
6824 {
6825   if (!exprNode_isError (e))
6826     {
6827       if (e->kind != XPR_ASSIGN)
6828         {
6829           exprNode_checkUse (e, e->sref, e->loc);
6830         }
6831     }
6832
6833   return e;
6834 }
6835
6836 void exprNode_produceGuards (exprNode pred)
6837 {
6838   if (!exprNode_isError (pred))
6839     {
6840       if (ctype_isRealPointer (pred->typ))
6841         {
6842           pred->guards = guardSet_addTrueGuard (pred->guards, pred->sref);
6843         }
6844
6845       exprNode_checkUse (pred, pred->sref, pred->loc);
6846       exprNode_resetSref (pred);
6847     }
6848 }
6849
6850 exprNode exprNode_compoundStatementExpression (/*@only@*/ lltok tlparen, /*@only@*/ exprNode e)
6851 {
6852   exprNode laststmt;
6853
6854   DPRINTF (("Compound: %s", exprNode_unparse (e)));
6855
6856   if (!context_flagOn (FLG_GNUEXTENSIONS, exprNode_loc (e)))
6857     {
6858       (void) llgenhinterror
6859         (FLG_SYNTAX,
6860          message ("Compound statement expressions is not supported by ISO C99"),
6861          message ("Use +gnuextensions to allow compound statement expressions (and other GNU language extensions) "
6862                   "without this warning"),
6863          exprNode_loc (e));
6864     }
6865
6866   /*
6867   ** The type of a compoundStatementExpression is the type of the last statement
6868   */
6869
6870   llassert (exprNode_isBlock (e));
6871   laststmt = exprNode_lastStatement (e);
6872
6873   DPRINTF (("Last statement: %s / %s", exprNode_unparse (laststmt), ctype_unparse (exprNode_getType (laststmt))));
6874   DPRINTF (("e: %s", exprNode_unparse (e)));
6875   e->typ = exprNode_getType (laststmt);
6876   return exprNode_addParens (tlparen, e);
6877 }
6878
6879
6880 exprNode exprNode_makeBlock (/*@only@*/ exprNode e)
6881 {
6882   exprNode ret = exprNode_createPartialCopy (e);
6883
6884   if (!exprNode_isError (e))
6885     {
6886       ret->exitCode = e->exitCode;
6887       ret->canBreak = e->canBreak;
6888       ret->mustBreak = e->mustBreak;
6889     }
6890
6891   DPRINTF (("Block e: %s", exprNode_unparse (e)));
6892   ret->edata = exprData_makeSingle (e);
6893   ret->kind = XPR_BLOCK;
6894   DPRINTF (("Block: %s", exprNode_unparse (ret)));
6895   return ret;
6896 }
6897
6898 bool exprNode_isBlock (exprNode e)
6899 {
6900   return (exprNode_isDefined (e)
6901           && ((e)->kind == XPR_BLOCK));
6902 }
6903
6904 bool exprNode_isStatement (exprNode e)
6905 {
6906   return (exprNode_isDefined (e)
6907           && ((e)->kind == XPR_STMT));
6908 }
6909
6910 bool exprNode_isAssign (exprNode e)
6911 {
6912   if (exprNode_isDefined (e))
6913     {
6914       return (e->kind == XPR_ASSIGN);
6915     }
6916
6917   return FALSE;
6918 }
6919
6920 bool exprNode_isEmptyStatement (exprNode e)
6921 {
6922   return (exprNode_isDefined (e)
6923           && (e->kind == XPR_TOK)
6924           && (lltok_isSemi (exprData_getTok (e->edata))));
6925 }
6926
6927 bool exprNode_isMultiStatement (exprNode e)
6928 {
6929   return (exprNode_isDefined (e)
6930           && ((e->kind == XPR_FOR)
6931               || (e->kind == XPR_FORPRED)
6932               || (e->kind == XPR_IF)
6933               || (e->kind == XPR_IFELSE)
6934               || (e->kind == XPR_WHILE)
6935               || (e->kind == XPR_WHILEPRED)
6936               || (e->kind == XPR_DOWHILE)
6937               || (e->kind == XPR_BLOCK)
6938               || (e->kind == XPR_STMT)
6939               || (e->kind == XPR_STMTLIST)
6940               || (e->kind == XPR_SWITCH)));
6941 }
6942
6943 void exprNode_checkIfPred (exprNode pred)
6944 {
6945   exprNode_checkPred (cstring_makeLiteralTemp ("if"), pred);
6946 }
6947
6948 exprNode exprNode_if (/*@only@*/ exprNode pred, /*@only@*/ exprNode tclause)
6949 {
6950   exprNode ret;
6951   bool emptyErr = FALSE;
6952
6953   if (context_maybeSet (FLG_IFEMPTY))
6954     {
6955       if (exprNode_isEmptyStatement (tclause))
6956         {
6957           emptyErr = optgenerror (FLG_IFEMPTY,
6958                                   cstring_makeLiteral
6959                                   ("Body of if statement is empty"),
6960                                   exprNode_loc (tclause));
6961         }
6962     }
6963
6964   if (!emptyErr && context_maybeSet (FLG_IFBLOCK))
6965     {
6966       if (exprNode_isDefined (tclause)
6967           && !exprNode_isBlock (tclause))
6968         {
6969           voptgenerror (FLG_IFBLOCK,
6970                         message
6971                         ("Body of if statement is not a block: %s",
6972                          exprNode_unparse (tclause)),
6973                         exprNode_loc (tclause));
6974         }
6975     }
6976
6977   if (exprNode_isError (pred))
6978     {
6979       if (exprNode_isError (tclause))
6980         {
6981           ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
6982         }
6983       else
6984         {
6985           ret = exprNode_createPartialCopy (tclause);
6986         }
6987     }
6988   else
6989     {
6990       if (exprNode_mustEscape (pred))
6991         {
6992           voptgenerror
6993             (FLG_UNREACHABLE,
6994              message ("Predicate always exits: %s", exprNode_unparse (pred)),
6995              exprNode_loc (pred));
6996         }
6997
6998       /*! exprNode_checkPred (cstring_makeLiteralTemp ("if"), pred); */ /*@i523@*/
6999       exprNode_checkUse (pred, pred->sref, pred->loc);
7000
7001       if (!exprNode_isError (tclause))
7002         {
7003           exprNode_mergeCondUSs (pred, tclause, exprNode_undefined);
7004         }
7005
7006       ret = exprNode_createPartialCopy (pred);
7007     }
7008
7009   ret->kind = XPR_IF;
7010   ret->edata = exprData_makePair (pred, tclause);
7011
7012   ret->exitCode = XK_UNKNOWN;
7013
7014   if (exprNode_isDefined (tclause))
7015     {
7016       ret->exitCode = exitkind_makeConditional (tclause->exitCode);
7017       ret->canBreak = tclause->canBreak;
7018       ret->sets = sRefSet_union (ret->sets, tclause->sets);
7019       ret->msets = sRefSet_union (ret->msets, tclause->msets);
7020       ret->uses = sRefSet_union (ret->uses, tclause->uses);
7021     }
7022
7023   ret->mustBreak = FALSE;
7024
7025   return ret;
7026 }
7027
7028 exprNode exprNode_ifelse (/*@only@*/ exprNode pred,
7029                           /*@only@*/ exprNode tclause,
7030                           /*@only@*/ exprNode eclause)
7031 {
7032   exprNode ret;
7033   bool tEmptyErr = FALSE;
7034   bool eEmptyErr = FALSE;
7035
7036   if (context_maybeSet (FLG_IFEMPTY))
7037     {
7038       if (exprNode_isEmptyStatement (tclause))
7039         {
7040           tEmptyErr = optgenerror
7041             (FLG_IFEMPTY,
7042              cstring_makeLiteral
7043              ("Body of if clause of if statement is empty"),
7044              exprNode_loc (tclause));
7045         }
7046
7047       if (exprNode_isEmptyStatement (eclause))
7048         {
7049           eEmptyErr = optgenerror
7050             (FLG_IFEMPTY,
7051              cstring_makeLiteral
7052              ("Body of else clause of if statement is empty"),
7053              exprNode_loc (eclause));
7054         }
7055     }
7056
7057   if (context_maybeSet (FLG_IFBLOCK))
7058     {
7059       if (!tEmptyErr
7060           && exprNode_isDefined (tclause)
7061           && !exprNode_isBlock (tclause))
7062         {
7063           voptgenerror (FLG_IFBLOCK,
7064                         message
7065                         ("Body of if clause of if statement is not a block: %s",
7066                          exprNode_unparse (tclause)),
7067                         exprNode_loc (tclause));
7068         }
7069
7070       if (!eEmptyErr
7071           && exprNode_isDefined (eclause)
7072           && !exprNode_isBlock (eclause)
7073           && !(eclause->kind == XPR_IF)
7074           && !(eclause->kind == XPR_IFELSE))
7075         {
7076           voptgenerror
7077             (FLG_IFBLOCK,
7078              message
7079              ("Body of else clause of if statement is not a block: %s",
7080               exprNode_unparse (eclause)),
7081              exprNode_loc (eclause));
7082         }
7083     }
7084
7085   if (context_maybeSet (FLG_ELSEIFCOMPLETE))
7086     {
7087       if (exprNode_isDefined (eclause)
7088           && (eclause->kind == XPR_IF))
7089         {
7090           voptgenerror (FLG_ELSEIFCOMPLETE,
7091                         message ("Incomplete else if logic (no final else): %s",
7092                                  exprNode_unparse (eclause)),
7093                         exprNode_loc (eclause));
7094         }
7095     }
7096
7097   if (exprNode_isError (pred))
7098     {
7099       if (exprNode_isError (tclause))
7100         {
7101           if (exprNode_isError (eclause))
7102             {
7103               ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
7104             }
7105           else
7106             {
7107               ret = exprNode_createPartialCopy (eclause);
7108             }
7109         }
7110       else
7111         {
7112           ret = exprNode_createPartialCopy (tclause);
7113         }
7114     }
7115   else /* pred is okay */
7116     {
7117       ret = exprNode_createPartialCopy (pred);
7118
7119       if (exprNode_mustEscape (pred))
7120         {
7121           voptgenerror
7122             (FLG_UNREACHABLE,
7123              message ("Predicate always exits: %s", exprNode_unparse (pred)),
7124              exprNode_loc (pred));
7125         }
7126
7127       /*@i3423 exprNode_checkPred (cstring_makeLiteralTemp ("if"), pred);*/
7128       exprNode_checkUse (ret, pred->sref, pred->loc);
7129
7130       exprNode_mergeCondUSs (ret, tclause, eclause);
7131     }
7132
7133   ret->kind = XPR_IFELSE;
7134   ret->edata = exprData_makeCond (pred, tclause, eclause);
7135
7136   if (exprNode_isDefined (tclause) && exprNode_isDefined (eclause))
7137     {
7138       exprNode_combineControl (ret, tclause, eclause);
7139       ret->loc = fileloc_update (ret->loc, eclause->loc);
7140     }
7141
7142   return ret;
7143 }
7144
7145 /*
7146 ** *allpaths <- TRUE iff all executions paths must go through the switch
7147 */
7148
7149 static bool
7150 checkSwitchExpr (exprNode test, /*@dependent@*/ exprNode e, /*@out@*/ bool *allpaths)
7151 {
7152   exprNodeSList el = exprNode_flatten (e);
7153   bool mustReturn = TRUE; /* find a branch that doesn't */
7154   bool thisReturn = FALSE;
7155   bool hasDefault = FALSE;
7156   bool hasAllMembers = FALSE;
7157   bool inSwitch = FALSE;
7158   bool isEnumSwitch = FALSE;
7159   bool canBreak = FALSE;
7160   bool fallThrough = FALSE;
7161   ctype ct = ctype_unknown;
7162   enumNameSList usedEnums;
7163   enumNameList enums;
7164
7165   if (exprNode_isDefined (test))
7166     {
7167       ctype ttype;
7168
7169       ct = test->typ;
7170       ttype = ctype_realType (ct);
7171
7172       if (ctype_isEnum (ttype))
7173         {
7174           isEnumSwitch = TRUE;
7175           enums = ctype_elist (ttype);
7176           usedEnums = enumNameSList_new ();
7177         }
7178     }
7179
7180   exprNodeSList_elements (el, current)
7181     {
7182
7183       DPRINTF ((message("checkSwitchExpr current = %s ", exprNode_unparse(current) ) ));
7184
7185       if (exprNode_isDefined (current))
7186         {
7187           switch (current->kind)
7188             {
7189             case XPR_FTDEFAULT:
7190             case XPR_DEFAULT:
7191               if (hasDefault)
7192                 {
7193                   voptgenerror
7194                     (FLG_DUPLICATECASES,
7195                      message ("Duplicate default cases in switch"),
7196                      exprNode_loc (current));
7197                 }
7198             /*@fallthrough@*/
7199             case XPR_FTCASE:
7200             case XPR_CASE:
7201               if (current->kind == XPR_DEFAULT || current->kind == XPR_FTDEFAULT)
7202                 {
7203                   hasDefault = TRUE;
7204                 }
7205               else
7206                 {
7207                   if (isEnumSwitch)
7208                     {
7209                       exprNode st = exprData_getSingle (current->edata);
7210                       uentry ue = exprNode_getUentry (st);
7211
7212                       if (uentry_isValid (ue))
7213                         {
7214                           cstring cname = uentry_rawName (ue);
7215
7216                           if (enumNameList_member (/*@-usedef@*/enums/*@=usedef@*/, cname))
7217                             {
7218                               if (enumNameSList_member
7219                                   (/*@-usedef@*/usedEnums/*@=usedef@*/, cname))
7220                                 {
7221                                   voptgenerror
7222                                     (FLG_DUPLICATECASES,
7223                                      message ("Duplicate case in switch: %s",
7224                                               cname),
7225                                      current->loc);
7226                                 }
7227                               else
7228                                 {
7229                                   enumNameSList_addh (usedEnums, cname);
7230                                 }
7231                             }
7232                           else
7233                             {
7234                               voptgenerror
7235                                 (FLG_TYPE,
7236                                  message ("Case in switch not %s member: %s",
7237                                           ctype_unparse (ct), cname),
7238                                  current->loc);
7239                             }
7240                         }
7241                     }
7242                 }
7243
7244               if (inSwitch && !fallThrough)
7245                 {
7246                   if (!thisReturn || canBreak)
7247                     {
7248                       mustReturn = FALSE;
7249                     }
7250                 }
7251
7252               fallThrough = TRUE;
7253               inSwitch = TRUE;
7254               thisReturn = FALSE;
7255               canBreak = FALSE;
7256               /*@switchbreak@*/ break;
7257             default:
7258               thisReturn = thisReturn || exprNode_mustEscape (current);
7259               canBreak = canBreak || current->canBreak;
7260               if (canBreak) fallThrough = FALSE;
7261             }
7262         }
7263     } end_exprNodeSList_elements;
7264
7265   if (inSwitch) /* check the last one! */
7266     {
7267       if (!thisReturn || canBreak)
7268         {
7269           mustReturn = FALSE;
7270         }
7271     }
7272
7273   if (isEnumSwitch)
7274     {
7275       if (!hasDefault
7276           && (enumNameSList_size (/*@-usedef@*/usedEnums/*@=usedef@*/) !=
7277               enumNameList_size (/*@-usedef@*/enums/*@=usedef@*/)))
7278         {
7279           enumNameSList unused = enumNameSList_subtract (enums, usedEnums);
7280
7281           voptgenerror (FLG_MISSCASE,
7282                         message ("Missing case%s in switch: %q",
7283                                  cstring_makeLiteralTemp
7284                                  ((enumNameSList_size (unused) > 1) ? "s" : ""),
7285                                  enumNameSList_unparse (unused)),
7286                         g_currentloc);
7287
7288           enumNameSList_free (unused);
7289           *allpaths = FALSE; /* evans 2002-01-01 */
7290         }
7291       else
7292         {
7293           hasAllMembers = TRUE;
7294           *allpaths = TRUE;
7295         }
7296
7297       enumNameSList_free (usedEnums);
7298     }
7299   else
7300     {
7301       *allpaths = hasDefault;
7302     }
7303
7304   exprNodeSList_free (el);
7305   return ((hasDefault || hasAllMembers) && mustReturn);
7306 }
7307
7308 exprNode exprNode_switch (/*@only@*/ exprNode e, /*@only@*/ exprNode s)
7309 {
7310   exprNode ret = exprNode_createPartialCopy (e);
7311   bool allpaths;
7312
7313   DPRINTF (("Switch: %s", exprNode_unparse (s)));
7314
7315   ret->kind = XPR_SWITCH;
7316   ret->edata = exprData_makePair (e, s);
7317
7318   if (!exprNode_isError (s))
7319     {
7320       exprNode fs = exprNode_firstStatement (s);
7321       ret->loc = fileloc_update (ret->loc, s->loc);
7322
7323       if (exprNode_isUndefined (fs)
7324           || exprNode_isCaseMarker (fs) || exprNode_isLabelMarker (fs)
7325           || exprNode_isDefaultMarker (fs)) {
7326         ;
7327       } else {
7328         voptgenerror (FLG_FIRSTCASE,
7329                       message
7330                       ("Statement after switch is not a case: %s", exprNode_unparse (fs)),
7331                       fs->loc);
7332       }
7333     }
7334
7335   if (!exprNode_isError (e))
7336     {
7337       if (checkSwitchExpr (e, s, &allpaths))
7338         {
7339           ret->exitCode = XK_MUSTRETURN;
7340         }
7341       else
7342         {
7343           ret->exitCode = e->exitCode;
7344         }
7345
7346       ret->canBreak = e->canBreak;
7347       ret->mustBreak = e->mustBreak;
7348     }
7349   /*
7350   ** forgot this!
7351   **   exprNode.c:3883,32: Variable allpaths used before definition
7352   */
7353   else
7354     {
7355       allpaths = FALSE;
7356     }
7357
7358   DPRINTF (("Context exit switch!"));
7359   context_exitSwitch (ret, allpaths);
7360   DPRINTF (("Context exit switch done!"));
7361
7362   return ret;
7363 }
7364
7365 static void checkInfiniteLoop (/*@notnull@*/ exprNode test,
7366                                /*@notnull@*/ exprNode body)
7367 {
7368   sRefSet tuses = test->uses;
7369
7370   if (!sRefSet_isEmpty (test->uses))
7371     {
7372       sRefSet sets = sRefSet_newCopy (body->sets);
7373       bool hasError = TRUE;
7374       bool innerState = FALSE;
7375       sRefSet tuncon = sRefSet_undefined;
7376
7377       sets = sRefSet_union (sets, test->sets);
7378       sets = sRefSet_union (sets, body->msets);
7379       sets = sRefSet_union (sets, test->msets);
7380
7381       sRefSet_allElements (tuses, el)
7382         {
7383           if (sRef_isUnconstrained (el))
7384             {
7385               tuncon = sRefSet_insert (tuncon, el);
7386             }
7387           else
7388             {
7389               if (sRefSet_member (sets, el))
7390                 {
7391                   hasError = FALSE;
7392                   break;
7393                 }
7394             }
7395
7396           if (sRef_isInternalState (el)
7397               || sRef_isFileStatic (sRef_getRootBase (el)))
7398             {
7399               innerState = TRUE;
7400             }
7401         } end_sRefSet_allElements ;
7402
7403       if (hasError)
7404         {
7405           sRefSet suncon = sRefSet_undefined;
7406           bool sinner = FALSE;
7407
7408           sRefSet_allElements (sets, el)
7409             {
7410               if (sRef_isUnconstrained (el))
7411                 {
7412                   suncon = sRefSet_insert (suncon, el);
7413                 }
7414               else if (sRef_isInternalState (el))
7415                 {
7416                   sinner = TRUE;
7417                 }
7418               else
7419                 {
7420                   ;
7421                 }
7422             } end_sRefSet_allElements ;
7423
7424           if (sinner && innerState)
7425             {
7426               ;
7427             }
7428           else if (sRefSet_isEmpty (tuncon)
7429                    && sRefSet_isEmpty (suncon))
7430             {
7431               voptgenerror
7432                 (FLG_INFLOOPS,
7433                  message
7434                  ("Suspected infinite loop.  No value used in loop test (%q) "
7435                   "is modified by test or loop body.",
7436                   sRefSet_unparsePlain (tuses)),
7437                  test->loc);
7438             }
7439           else
7440             {
7441               if (sRefSet_isEmpty (tuncon))
7442                 {
7443                   voptgenerror
7444                     (FLG_INFLOOPSUNCON,
7445                      message ("Suspected infinite loop.  No condition values "
7446                               "modified.  Modification possible through "
7447                               "unconstrained calls: %q",
7448                               sRefSet_unparsePlain (suncon)),
7449                      test->loc);
7450                 }
7451               else
7452                 {
7453                   voptgenerror
7454                     (FLG_INFLOOPSUNCON,
7455                      message ("Suspected infinite loop.  No condition values "
7456                               "modified.  Possible undetected dependency through "
7457                               "unconstrained calls in loop test: %q",
7458                               sRefSet_unparsePlain (tuncon)),
7459                      test->loc);
7460                 }
7461             }
7462         }
7463
7464       sRefSet_free (sets);
7465     }
7466 }
7467
7468 exprNode exprNode_while (/*@keep@*/ exprNode t, /*@keep@*/ exprNode b)
7469 {
7470   exprNode ret;
7471   bool emptyErr = FALSE;
7472
7473   if (context_maybeSet (FLG_WHILEEMPTY))
7474     {
7475       if (exprNode_isEmptyStatement (b))
7476         {
7477           emptyErr = optgenerror
7478             (FLG_WHILEEMPTY,
7479              cstring_makeLiteral
7480              ("Body of while statement is empty"),
7481              exprNode_loc (b));
7482         }
7483     }
7484
7485   if (!emptyErr && context_maybeSet (FLG_WHILEBLOCK))
7486     {
7487       if (exprNode_isDefined (b)
7488           && !exprNode_isBlock (b))
7489         {
7490           if (context_inIterDef ()
7491               && (b->kind == XPR_STMTLIST
7492                   || b->kind == XPR_TOK))
7493             {
7494               ; /* no error */
7495             }
7496           else
7497             {
7498               voptgenerror (FLG_WHILEBLOCK,
7499                             message
7500                             ("Body of while statement is not a block: %s",
7501                              exprNode_unparse (b)),
7502                             exprNode_loc (b));
7503             }
7504         }
7505     }
7506
7507   if (exprNode_isError (t))
7508     {
7509       if (exprNode_isError (b))
7510         {
7511           ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
7512         }
7513       else
7514         {
7515           ret = exprNode_createPartialCopy (b);
7516         }
7517     }
7518   else
7519     {
7520       exprNode test;
7521
7522       ret = exprNode_createPartialCopy (t);
7523
7524       llassert (t->kind == XPR_WHILEPRED);
7525
7526       test = exprData_getSingle (t->edata);
7527
7528       if (!exprNode_isError (b) && exprNode_isDefined (test))
7529         {
7530           if (context_maybeSet (FLG_INFLOOPS)
7531               || context_maybeSet (FLG_INFLOOPSUNCON))
7532             {
7533               /*
7534               ** check that some variable in the predicate is set by the body
7535               ** if the predicate uses any variables
7536               */
7537
7538               checkInfiniteLoop (test, b);
7539             }
7540
7541           exprNode_mergeUSs (ret, b);
7542
7543           if (exprNode_isDefined (b))
7544             {
7545               ret->exitCode = exitkind_makeConditional (b->exitCode);
7546             }
7547         }
7548     }
7549
7550   ret->edata = exprData_makePair (t, b);
7551   ret->kind = XPR_WHILE;
7552
7553   if (exprNode_isDefined (t) && exprNode_mustEscape (t))
7554     {
7555       voptgenerror
7556         (FLG_ALWAYSEXITS,
7557          message ("Predicate always exits: %s", exprNode_unparse (t)),
7558          exprNode_loc (t));
7559     }
7560
7561   ret->exitCode = XK_NEVERESCAPE;
7562
7563   /*
7564   ** If loop is infinite, and there is no break inside,
7565   ** exit code is never reach.
7566   */
7567
7568   if (exprNode_knownIntValue (t))
7569     {
7570       if (!exprNode_isZero (t))
7571         {
7572           if (exprNode_isDefined (b))
7573             {
7574               if (!b->canBreak)
7575                 {
7576                   /* Really, it means never reached. */
7577                   ret->exitCode = XK_MUSTEXIT;
7578                 }
7579             }
7580         }
7581     }
7582   else
7583     {
7584       ;
7585     }
7586
7587   ret->canBreak = FALSE;
7588   ret->mustBreak = FALSE;
7589
7590   return ret;
7591 }
7592
7593 /*
7594 ** do { b } while (t);
7595 **
7596 ** note: body passed as first argument
7597 */
7598
7599 exprNode exprNode_doWhile (/*@only@*/ exprNode b, /*@only@*/ exprNode t)
7600 {
7601   exprNode ret;
7602
7603   DPRINTF (("Do while: %s / %s",
7604             exprNode_unparse (b), exprNode_unparse (t)));
7605
7606   if (exprNode_isError (t))
7607     {
7608       if (exprNode_isError (b))
7609         {
7610           ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
7611         }
7612       else
7613         {
7614           ret = exprNode_createPartialCopy (b);
7615
7616           ret->exitCode = exitkind_makeConditional (b->exitCode);
7617           exprNode_checkUse (ret, b->sref, b->loc);
7618           ret->exitCode = b->exitCode;
7619           ret->canBreak = b->canBreak;
7620           ret->mustBreak = FALSE;
7621         }
7622     }
7623   else
7624     {
7625       DPRINTF (("Do while: %s / %s",
7626                 exitkind_unparse (t->exitCode),
7627                 exitkind_unparse (b->exitCode)));
7628
7629       ret = exprNode_createPartialCopy (t);
7630       exprNode_checkPred (cstring_makeLiteralTemp ("while"), t);
7631
7632       if (!exprNode_isError (b))
7633         {
7634           /*
7635           ** forgot the copy's --- why wasn't this detected??
7636           */
7637
7638           ret->sets = sRefSet_copyInto (ret->sets, b->sets);
7639           ret->msets = sRefSet_copyInto (ret->msets, b->msets);
7640           ret->uses = sRefSet_copyInto (ret->uses, b->uses);
7641
7642           /* left this out --- causes and aliasing bug (infinite loop)
7643              should be detected?? */
7644
7645           exprNode_checkUse (ret, b->sref, b->loc);
7646           exprNode_mergeUSs (ret, t);
7647           exprNode_checkUse (ret, t->sref, t->loc);
7648
7649           /* evans 2001-10-05: while loop can break */
7650           ret->exitCode = exitkind_makeConditional (b->exitCode);
7651
7652           DPRINTF (("Do while: %s",
7653                     exitkind_unparse (ret->exitCode)));
7654
7655           ret->canBreak = b->canBreak;
7656
7657           /* Always FALSE for doWhile loops - break's when test is false */
7658           ret->mustBreak = FALSE; /* b->mustBreak; */
7659         }
7660     }
7661
7662   context_exitDoWhileClause (t);
7663
7664   ret->kind = XPR_DOWHILE;
7665   ret->edata = exprData_makePair (t, b);
7666   return ret;
7667 }
7668
7669 bool exprNode_loopMustExec (exprNode forPred)
7670 {
7671   /*
7672   ** Returns true if it is obvious that the loop always executes at least once
7673   **
7674   ** For now, we only identify the most obvious cases.  Should be true anytime
7675   ** we can prove init => !test.
7676   */
7677
7678   if (exprNode_isDefined (forPred))
7679     {
7680       exprNode init, test, inc;
7681       exprData edata;
7682
7683       llassert (forPred->kind == XPR_FORPRED);
7684
7685       edata = forPred->edata;
7686       init = exprData_getTripleInit (edata);
7687       test = exprData_getTripleTest (edata);
7688       inc = exprData_getTripleInc (edata);
7689
7690       if (exprNode_isAssign (init))
7691         {
7692           exprNode loopVar = exprData_getOpA (init->edata);
7693           exprNode loopInit = exprData_getOpB (init->edata);
7694
7695           if (exprNode_isDefined (test) && test->kind == XPR_OP)
7696             {
7697               exprNode testVar = exprData_getOpA (test->edata);
7698               exprNode testVal = exprData_getOpB (test->edata);
7699               lltok comp = exprData_getOpTok (test->edata);
7700               int opid = lltok_getTok (comp);
7701
7702               DPRINTF (("Same storage: %s / %s", exprNode_unparse (loopVar),
7703                         exprNode_unparse (testVar)));
7704
7705               if (exprNode_sameStorage (loopVar, testVar))
7706                 {
7707                   multiVal valinit = exprNode_getValue (loopInit);
7708                   multiVal valtest = exprNode_getValue (testVal);
7709
7710                   DPRINTF (("Values: %s / %s", multiVal_unparse (valinit),
7711                             multiVal_unparse (valtest)));
7712
7713                   if (multiVal_isInt (valinit) && multiVal_isInt (valtest))
7714                     {
7715                       long v1 = multiVal_forceInt (valinit);
7716                       long v2 = multiVal_forceInt (valtest);
7717
7718                       DPRINTF (("Here: %ld %ld", v1, v2));
7719
7720                       if ((opid == EQ_OP && v1 < v2)
7721                           || (opid == NE_OP && v1 != v2)
7722                           || (opid == TLT && v1 <= v2)
7723                           || (opid == TGT && v1 >= v2)
7724                           || (opid == LE_OP && v1 < v2)
7725                           || (opid == GE_OP && v1 > v2))
7726                         {
7727                           DPRINTF (("mustexec if inc"));
7728                           return TRUE;
7729                         }
7730                     }
7731                 }
7732             }
7733         }
7734     }
7735
7736   DPRINTF (("loop must exec: FALSE"));
7737   return FALSE;
7738 }
7739
7740 exprNode exprNode_for (/*@keep@*/ exprNode inc, /*@keep@*/ exprNode body)
7741 {
7742   exprNode ret;
7743   bool emptyErr = FALSE;
7744
7745   if (context_maybeSet (FLG_FOREMPTY))
7746     {
7747       if (exprNode_isEmptyStatement (body))
7748         {
7749           emptyErr = optgenerror
7750             (FLG_FOREMPTY,
7751              cstring_makeLiteral
7752              ("Body of for statement is empty"),
7753              exprNode_loc (body));
7754         }
7755     }
7756
7757   if (!emptyErr && context_maybeSet (FLG_FORBLOCK))
7758     {
7759       if (exprNode_isDefined (body)
7760           && !exprNode_isBlock (body))
7761         {
7762           if (context_inIterDef ()
7763               && (body->kind == XPR_STMTLIST
7764                   || body->kind == XPR_TOK))
7765             {
7766               ; /* no error */
7767             }
7768           else
7769             {
7770               voptgenerror (FLG_FORBLOCK,
7771                             message
7772                             ("Body of for statement is not a block: %s",
7773                              exprNode_unparse (body)),
7774                             exprNode_loc (body));
7775             }
7776         }
7777     }
7778
7779   /*
7780   ** for ud purposes:  (alreadly) init -> test -> (now) LOOP: body + inc + test
7781   */
7782
7783   if (exprNode_isError (body))
7784     {
7785       ret = exprNode_createPartialCopy (inc);
7786     }
7787   else
7788     {
7789       ret = exprNode_createPartialCopy (body);
7790
7791       ret->exitCode = exitkind_makeConditional (body->exitCode);
7792
7793       exprNode_mergeUSs (inc, body);
7794
7795       if (exprNode_isDefined (inc))
7796         {
7797           exprNode tmp;
7798
7799           context_setMessageAnnote (cstring_makeLiteral ("in post loop increment"));
7800
7801           tmp = exprNode_effect (exprData_getTripleInc (inc->edata));
7802           exprNode_freeShallow (tmp);
7803
7804           context_clearMessageAnnote ();
7805           context_setMessageAnnote (cstring_makeLiteral ("in post loop test"));
7806
7807           tmp = exprNode_effect (exprData_getTripleTest (inc->edata));
7808           exprNode_freeShallow (tmp);
7809
7810           context_clearMessageAnnote ();
7811
7812           ret->uses = sRefSet_copyInto (ret->uses, inc->uses);
7813           ret->sets = sRefSet_copyInto (ret->sets, inc->sets);
7814           ret->msets = sRefSet_copyInto (ret->msets, inc->msets);
7815         }
7816     }
7817
7818   ret->kind = XPR_FOR;
7819   ret->edata = exprData_makePair (inc, body);
7820
7821   if (exprNode_isDefined (inc)) {
7822     exprNode test = exprData_getTripleTest (inc->edata);
7823
7824     if (exprNode_isUndefined (test)) {
7825       if (exprNode_isDefined (body)) {
7826         if (!body->canBreak) {
7827           /* Really, it means never reached. */
7828           ret->exitCode = XK_MUSTEXIT;
7829         }
7830       }
7831     }
7832   }
7833
7834   return (ret);
7835 }
7836
7837 /*
7838 ** for (init; test; inc)
7839 ** ==>
7840 ** init;
7841 ** while (test) { body; inc; }
7842 **
7843 ** Now: check use of init (may set vars for test)
7844 **      check use of test
7845 **      no checks on inc
7846 _*/
7847
7848 /*@observer@*/ guardSet exprNode_getForGuards (exprNode pred)
7849 {
7850   exprNode test;
7851
7852   if (exprNode_isError (pred)) return guardSet_undefined;
7853
7854   llassert (pred->kind == XPR_FORPRED);
7855
7856   test = exprData_getTripleTest (pred->edata);
7857
7858   if (!exprNode_isError (test))
7859     {
7860       return (test->guards);
7861     }
7862
7863   return guardSet_undefined;
7864 }
7865
7866 exprNode exprNode_whilePred (/*@only@*/ exprNode test)
7867 {
7868   exprNode ret = exprNode_createSemiCopy (test);
7869
7870   if (exprNode_isDefined (test))
7871     {
7872       exprNode_copySets (ret, test);
7873       exprNode_checkPred (cstring_makeLiteralTemp ("while"), test);
7874       exprNode_checkUse (ret, test->sref, test->loc);
7875
7876       exprNode_produceGuards (test);
7877
7878       ret->guards = guardSet_copy (test->guards);
7879     }
7880
7881   ret->edata = exprData_makeSingle (test);
7882   ret->kind = XPR_WHILEPRED;
7883   return ret;
7884 }
7885
7886 exprNode exprNode_forPred (/*@only@*/ exprNode init, /*@only@*/ exprNode test,
7887                            /*@only@*/ exprNode inc)
7888 {
7889   exprNode ret;
7890
7891   /*
7892   ** for ud purposes:  init -> test -> LOOP: [ body, inc ]
7893   */
7894
7895   exprNode_checkPred (cstring_makeLiteralTemp ("for"), test);
7896
7897   if (!exprNode_isError (inc))
7898     {
7899       ret = exprNode_createPartialCopy (inc);
7900     }
7901   else
7902     {
7903       if (!exprNode_isError (init))
7904         {
7905           ret = exprNode_createPartialCopy (init);
7906         }
7907       else if (!exprNode_isError (test))
7908         {
7909           ret = exprNode_createPartialCopy (test);
7910         }
7911       else
7912         {
7913           ret = exprNode_createUnknown ();
7914         }
7915     }
7916
7917   exprNode_mergeUSs (ret, init);
7918
7919   if (exprNode_isDefined (init))
7920     {
7921       exprNode_checkUse (ret, init->sref, init->loc);
7922     }
7923
7924   exprNode_mergeUSs (ret, test);
7925
7926   if (exprNode_isDefined (test))
7927     {
7928       exprNode_checkUse (ret, test->sref, test->loc);
7929     }
7930
7931   ret->kind = XPR_FORPRED;
7932   ret->edata = exprData_makeFor (init, test, inc);
7933   return (ret);
7934 }
7935
7936 /*@notnull@*/ /*@only@*/ exprNode exprNode_goto (/*@only@*/ cstring label)
7937 {
7938   exprNode ret = exprNode_createUnknown ();
7939
7940   if (context_inMacro ())
7941     {
7942       voptgenerror (FLG_MACROSTMT,
7943                     message ("Macro %s uses goto (not functional)",
7944                              context_inFunctionName ()),
7945                     g_currentloc);
7946     }
7947
7948   ret->kind = XPR_GOTO;
7949   ret->edata = exprData_makeLiteral (label);
7950   ret->mustBreak = TRUE;
7951   ret->exitCode = XK_GOTO;
7952   ret->canBreak = TRUE;
7953   return ret;
7954 }
7955
7956 exprNode exprNode_continue (/*@only@*/ lltok l, int qcontinue)
7957 {
7958   exprNode ret = exprNode_createLoc (ctype_unknown, fileloc_copy (lltok_getLoc (l)));
7959
7960   ret->kind = XPR_CONTINUE;
7961   ret->edata = exprData_makeTok (l);
7962   ret->canBreak = TRUE;
7963   ret->mustBreak = TRUE;
7964
7965   if (qcontinue == QSAFEBREAK)
7966     {
7967       ; /* no checking */
7968     }
7969   else if (qcontinue == QINNERCONTINUE)
7970     {
7971       if (!context_inDeepLoop ())
7972         {
7973           voptgenerror
7974             (FLG_LOOPLOOPCONTINUE,
7975              cstring_makeLiteral ("Continue statement marked with innercontinue "
7976                                   "is not inside a nested loop"),
7977              exprNode_loc (ret));
7978         }
7979     }
7980   else if (qcontinue == BADTOK)
7981     {
7982       if (context_inDeepLoop ())
7983         {
7984           voptgenerror
7985             (FLG_LOOPLOOPCONTINUE,
7986              cstring_makeLiteral ("Continue statement in nested loop"),
7987              exprNode_loc (ret));
7988         }
7989     }
7990   else
7991     {
7992       llbuglit ("exprNode_continue: bad qcontinue");
7993     }
7994
7995   return ret;
7996 }
7997
7998 exprNode exprNode_break (/*@only@*/ lltok l, int bqual)
7999 {
8000   exprNode ret = exprNode_createLoc (ctype_unknown, fileloc_copy (lltok_getLoc (l)));
8001   clause breakClause = context_breakClause ();
8002
8003   ret->kind = XPR_BREAK;
8004   ret->edata = exprData_makeTok (l);
8005   ret->canBreak = TRUE;
8006   ret->mustBreak = TRUE;
8007
8008   if (breakClause == NOCLAUSE)
8009     {
8010       voptgenerror
8011         (FLG_SYNTAX,
8012          cstring_makeLiteral ("Break not inside while, for or switch statement"),
8013          exprNode_loc (ret));
8014     }
8015   else
8016     {
8017       if (bqual != BADTOK)
8018         {
8019           switch (bqual)
8020             {
8021             case QSAFEBREAK:
8022               break;
8023             case QINNERBREAK:
8024               if (breakClause == SWITCHCLAUSE)
8025                 {
8026                   if (!context_inDeepSwitch ())
8027                     {
8028                       voptgenerror (FLG_SYNTAX,
8029                                     cstring_makeLiteral
8030                                     ("Break preceded by innerbreak is not in a deep switch"),
8031                                     exprNode_loc (ret));
8032                     }
8033                 }
8034               else
8035                 {
8036                   if (!context_inDeepLoop ())
8037                     {
8038                       voptgenerror (FLG_SYNTAX,
8039                                     cstring_makeLiteral
8040                                     ("Break preceded by innerbreak is not in a deep loop"),
8041                                     exprNode_loc (ret));
8042                     }
8043                 }
8044               break;
8045             case QLOOPBREAK:
8046               if (breakClause == SWITCHCLAUSE)
8047                 {
8048                   voptgenerror (FLG_SYNTAX,
8049                                 cstring_makeLiteral
8050                                 ("Break preceded by loopbreak is breaking a switch"),
8051                                 exprNode_loc (ret));
8052                 }
8053               break;
8054             case QSWITCHBREAK:
8055               if (breakClause != SWITCHCLAUSE)
8056                 {
8057                   voptgenerror
8058                     (FLG_SYNTAX,
8059                      message ("Break preceded by switchbreak is breaking %s",
8060                               cstring_makeLiteralTemp
8061                               ((breakClause == WHILECLAUSE
8062                                 || breakClause == DOWHILECLAUSE) ? "a while loop"
8063                                : (breakClause == FORCLAUSE) ? "a for loop"
8064                                : (breakClause == ITERCLAUSE) ? "an iterator"
8065                                : "<error loop>")),
8066                      exprNode_loc (ret));
8067                 }
8068               break;
8069             BADDEFAULT;
8070             }
8071         }
8072       else
8073         {
8074           if (breakClause == SWITCHCLAUSE)
8075             {
8076               clause nextBreakClause = context_nextBreakClause ();
8077
8078               switch (nextBreakClause)
8079                 {
8080                 case NOCLAUSE: break;
8081                 case WHILECLAUSE:
8082                 case DOWHILECLAUSE:
8083                 case FORCLAUSE:
8084                 case ITERCLAUSE:
8085                   voptgenerror
8086                     (FLG_LOOPSWITCHBREAK,
8087                      cstring_makeLiteral ("Break statement in switch inside loop"),
8088                      exprNode_loc (ret));
8089                   break;
8090                 case SWITCHCLAUSE:
8091                   voptgenerror
8092                     (FLG_SWITCHSWITCHBREAK,
8093                      cstring_makeLiteral ("Break statement in switch inside switch"),
8094                      exprNode_loc (ret));
8095                   break;
8096                 BADDEFAULT;
8097                 }
8098             }
8099           else
8100             {
8101               if (context_inDeepLoop ())
8102                 {
8103                   voptgenerror
8104                     (FLG_LOOPLOOPBREAK,
8105                      cstring_makeLiteral ("Break statement in nested loop"),
8106                      exprNode_loc (ret));
8107                 }
8108               else
8109                 {
8110                   if (context_inDeepLoopSwitch ())
8111                     {
8112                       voptgenerror
8113                         (FLG_SWITCHLOOPBREAK,
8114                          cstring_makeLiteral ("Break statement in loop inside switch"),
8115                          exprNode_loc (ret));
8116                     }
8117                 }
8118             }
8119         }
8120     }
8121
8122   return ret;
8123 }
8124
8125 exprNode exprNode_nullReturn (/*@only@*/ lltok t)
8126 {
8127   fileloc loc = lltok_getLoc (t);
8128   exprNode ret = exprNode_createLoc (ctype_unknown, fileloc_copy (loc));
8129
8130   context_returnFunction ();
8131   exprChecks_checkNullReturn (loc);
8132
8133   ret->kind = XPR_NULLRETURN;
8134   ret->edata = exprData_makeTok (t);
8135   ret->exitCode = XK_MUSTRETURN;
8136   return ret;
8137 }
8138
8139 exprNode exprNode_return (/*@only@*/ exprNode e)
8140 {
8141   exprNode ret;
8142
8143   if (exprNode_isError (e))
8144     {
8145       ret = exprNode_createUnknown ();
8146     }
8147   else
8148     {
8149       ret = exprNode_createLoc (ctype_unknown, fileloc_copy (e->loc));
8150
8151       exprNode_checkUse (ret, e->sref, e->loc);
8152       exprNode_checkReturn (e);
8153     }
8154
8155   context_returnFunction ();
8156   ret->kind = XPR_RETURN;
8157   ret->edata = exprData_makeSingle (e);
8158   ret->exitCode = XK_MUSTRETURN;
8159
8160   return (ret);
8161 }
8162
8163 exprNode exprNode_comma (/*@only@*/ exprNode e1, /*@only@*/ exprNode e2)
8164 {
8165   exprNode ret;
8166
8167   if (exprNode_isError (e1))
8168     {
8169       if (exprNode_isError (e2))
8170         {
8171           ret = exprNode_createLoc (ctype_unknown, fileloc_copy (g_currentloc));
8172         }
8173       else
8174         {
8175           ret = exprNode_createPartialCopy (e2);
8176           exprNode_checkUse (ret, e2->sref, e2->loc);
8177           ret->sref = e2->sref;
8178         }
8179     }
8180   else
8181     {
8182       ret = exprNode_createPartialCopy (e1);
8183
8184       exprNode_checkUse (ret, e1->sref, e1->loc);
8185
8186       if (!exprNode_isError (e2))
8187         {
8188           exprNode_mergeUSs (ret, e2);
8189           exprNode_checkUse (ret, e2->sref, e2->loc);
8190           ret->sref = e2->sref;
8191         }
8192     }
8193
8194   ret->kind = XPR_COMMA;
8195   ret->edata = exprData_makePair (e1, e2);
8196
8197   if (exprNode_isDefined (e1))
8198     {
8199       if (exprNode_isDefined (e2))
8200         {
8201           ret->typ = e2->typ;
8202
8203           if (exprNode_mustEscape (e1) || e1->mustBreak)
8204             {
8205               voptgenerror
8206                 (FLG_UNREACHABLE,
8207                  message ("Second clause of comma expression is unreachable: %s",
8208                           exprNode_unparse (e2)),
8209                  exprNode_loc (e2));
8210             }
8211
8212           ret->exitCode = exitkind_combine (e1->exitCode, e2->exitCode);
8213           ret->mustBreak = e1->mustBreak || e2->mustBreak;
8214           ret->canBreak = e1->canBreak || e2->canBreak;
8215         }
8216       else
8217         {
8218           if (exprNode_mustEscape (e1) || e1->mustBreak)
8219             {
8220               voptgenerror
8221                 (FLG_UNREACHABLE,
8222                  message ("Second clause of comma expression is unreachable: %s",
8223                           exprNode_unparse (e2)),
8224                  exprNode_loc (e2));
8225             }
8226
8227           ret->exitCode = e1->exitCode;
8228           ret->canBreak = e1->canBreak;
8229         }
8230     }
8231   else
8232     {
8233       if (exprNode_isDefined (e2))
8234         {
8235           ret->exitCode = e2->exitCode;
8236           ret->mustBreak = e2->mustBreak;
8237           ret->canBreak = e2->canBreak;
8238         }
8239     }
8240
8241   return (ret);
8242 }
8243
8244 static bool exprNode_checkOneInit (/*@notnull@*/ exprNode el, exprNode val)
8245 {
8246   ctype t1 = exprNode_getType (el);
8247   ctype t2 = exprNode_getType (val);
8248   bool hasError = FALSE;
8249
8250   DPRINTF (("Check one init: %s / %s",
8251             exprNode_unparse (el),
8252             exprNode_unparse (val)));
8253
8254   if (ctype_isUnknown (t1))
8255     {
8256       voptgenerror (FLG_IMPTYPE,
8257                     message ("Variable has unknown (implicitly int) type: %s",
8258                              exprNode_unparse (el)),
8259                     el->loc);
8260
8261       t1 = ctype_int;
8262       el->typ = ctype_int;
8263     }
8264
8265   if (exprNode_isDefined (val) && val->kind == XPR_INITBLOCK)
8266     {
8267       exprNodeList vals = exprData_getArgs (val->edata);
8268
8269       DPRINTF (("Check one init: %s", exprNodeList_unparse (vals)));
8270       DPRINTF (("Type: %s", ctype_unparse (t1)));
8271
8272       if (ctype_isRealAP (t1))
8273         {
8274           int i = 0;
8275           int nerrors = 0;
8276
8277           if (ctype_isFixedArray (t1))
8278             {
8279               size_t nelements = ctype_getArraySize (t1);
8280
8281               DPRINTF (("Checked array: %s / %d",
8282                         ctype_unparse (t1), nelements));
8283
8284               if (exprNode_isStringLiteral (val))
8285                 {
8286                   exprNode_checkStringLiteralLength (t1, val);
8287                 }
8288               else
8289                 {
8290                   if (exprNodeList_size (vals) != size_toInt (nelements))
8291                     {
8292                       hasError = optgenerror
8293                         (exprNodeList_size (vals) > size_toInt (nelements)
8294                          ? FLG_INITSIZE : FLG_INITALLELEMENTS,
8295                          message ("Initializer block for "
8296                                   "%s has %d element%&, but declared as %s: %q",
8297                                   exprNode_unparse (el),
8298                                   exprNodeList_size (vals),
8299                                   ctype_unparse (t1),
8300                                   exprNodeList_unparse (vals)),
8301                          val->loc);
8302                     }
8303                 }
8304             }
8305
8306           exprNodeList_elements (vals, oneval)
8307             {
8308               cstring istring = message ("%d", i);
8309               exprNode newel =
8310                 exprNode_arrayFetch
8311                   (exprNode_fakeCopy (el),
8312                    exprNode_numLiteral (ctype_int, istring,
8313                                         fileloc_copy (el->loc), i));
8314
8315               if (exprNode_isDefined (newel))
8316                 {
8317                   if (exprNodeList_size (vals) == 1
8318                       && ctype_isString (exprNode_getType (oneval))
8319                       && ctype_isChar (exprNode_getType (newel)))
8320                     {
8321                       exprNode_freeIniter (newel);
8322                     }
8323                   else
8324                     {
8325                       if (exprNode_checkOneInit (newel, oneval))
8326                         {
8327                           hasError = TRUE;
8328                           nerrors++;
8329
8330                           if (nerrors > 3 && exprNodeList_size (vals) > 6)
8331                             {
8332                               llgenmsg
8333                                 (message ("Additional initialization errors "
8334                                           "for %s not reported",
8335                                           exprNode_unparse (el)),
8336                                  exprNode_loc (el));
8337                               exprNode_freeIniter (newel);
8338                               break;
8339                             }
8340                           else
8341                             {
8342                               exprNode_freeIniter (newel);
8343                             }
8344                         }
8345                       else
8346                         {
8347                           exprNode_freeIniter (newel);
8348                         }
8349                     }
8350                 }
8351
8352               cstring_free (istring);
8353               i++;
8354               /*@-branchstate@*/
8355             } end_exprNodeList_elements;
8356           /*@=branchstate@*/
8357         }
8358       else if (ctype_isStruct (ctype_realType (t1)))
8359         {
8360           uentryList fields = ctype_getFields (t1);
8361           int i = 0;
8362
8363           if (uentryList_size (fields) != exprNodeList_size (vals))
8364             {
8365               if (uentryList_size (fields) > exprNodeList_size (vals))
8366                 {
8367                   hasError = optgenerror
8368                     (FLG_FULLINITBLOCK,
8369                      message ("Initializer block for "
8370                               "%s has %d field%&, but %s has %d field%&: %q",
8371                               exprNode_unparse (el),
8372                               exprNodeList_size (vals),
8373                               ctype_unparse (t1),
8374                               uentryList_size (fields),
8375                               exprNodeList_unparse (vals)),
8376                      val->loc);
8377                 }
8378               else
8379                 {
8380                   hasError = optgenerror
8381                     (FLG_TYPE,
8382                      message ("Initializer block for "
8383                               "%s has %d field%&, but %s has %d field%&: %q",
8384                               exprNode_unparse (el),
8385                               exprNodeList_size (vals),
8386                               ctype_unparse (t1),
8387                               uentryList_size (fields),
8388                               exprNodeList_unparse (vals)),
8389                      val->loc);
8390                 }
8391             }
8392           else
8393             {
8394               exprNodeList_elements (vals, oneval)
8395                 {
8396                   uentry thisfield = uentryList_getN (fields, i);
8397                   exprNode newel =
8398                     exprNode_fieldAccessAux (exprNode_fakeCopy (el),
8399                                              exprNode_loc (el),
8400                                              uentry_getName (thisfield));
8401
8402                   if (exprNode_isDefined (newel))
8403                     {
8404                       if (exprNode_checkOneInit (newel, oneval))
8405                         {
8406                           hasError = TRUE;
8407                         }
8408
8409                       exprNode_freeIniter (newel);
8410                     }
8411
8412                   i++;
8413                 } end_exprNodeList_elements;
8414             }
8415         }
8416       /* evans 2001-12-30: added to fix bug reported by Jim Zelenka */
8417       else if (ctype_isUnion (ctype_realType (t1)))
8418         {
8419           uentryList fields = ctype_getFields (t1);
8420           int i = 0;
8421
8422           /*
8423           ** Union initializers set the first member always.
8424           */
8425
8426           DPRINTF (("Union initializer: %s / %s",
8427                     exprNode_unparse (el), ctype_unparse (ctype_realType (t1))));
8428
8429           if (exprNodeList_size (vals) != 1)
8430             {
8431               hasError = optgenerror
8432                 (FLG_TYPE,
8433                  message ("Initializer block for union "
8434                           "%s has %d elements, union initializers should have one element: %q",
8435                           exprNode_unparse (el),
8436                           exprNodeList_size (vals),
8437                           exprNodeList_unparse (vals)),
8438                  val->loc);
8439             }
8440           else
8441             {
8442               exprNode oneval = exprNodeList_head (vals);
8443               uentry thisfield = uentryList_getN (fields, i);
8444               exprNode newel =
8445                 exprNode_fieldAccessAux (exprNode_fakeCopy (el),
8446                                          exprNode_loc (el),
8447                                          uentry_getName (thisfield));
8448
8449               if (exprNode_isDefined (newel))
8450                 {
8451                   if (exprNode_checkOneInit (newel, oneval))
8452                     {
8453                       hasError = TRUE;
8454                     }
8455
8456                   exprNode_freeIniter (newel);
8457                 }
8458             }
8459         }
8460       else
8461         {
8462           hasError = optgenerror
8463             (FLG_TYPE,
8464              message ("Initializer block used for "
8465                       "%s where %t is expected: %s",
8466                       exprNode_unparse (el), t1, exprNode_unparse (val)),
8467              val->loc);
8468         }
8469     }
8470   else
8471     {
8472       if (exprNode_isDefined (val))
8473         {
8474           doAssign (el, val, TRUE);
8475
8476           if (!exprNode_matchType (t1, val))
8477             {
8478               hasError = gentypeerror
8479                 (t1, val, t2, el,
8480                  message ("Initial value of %s is type %t, "
8481                           "expects %t: %s",
8482                           exprNode_unparse (el),
8483                           t2, t1, exprNode_unparse (val)),
8484                  val->loc);
8485             }
8486         }
8487     }
8488
8489   return hasError;
8490 }
8491
8492 static /*@notnull@*/ exprNode
8493 exprNode_makeInitializationAux (/*@temp@*/ idDecl t)
8494 {
8495   exprNode ret;
8496
8497   DPRINTF (("Initialization: %s", idDecl_unparse (t)));
8498
8499   if (usymtab_exists (idDecl_observeId (t)))
8500     {
8501       uentry ue = usymtab_lookup (idDecl_observeId (t));
8502       ret = exprNode_createId (ue);
8503
8504       /*@i723 don't do this...but why? */
8505 # if 0
8506       ct = ctype_realishType (ret->typ);
8507
8508       DPRINTF (("Type: %s", ctype_unparse (ret->typ)));
8509
8510       if (ctype_isUnknown (ct))
8511         {
8512           if (uentry_isAnyTag (ue))
8513             {
8514               voptgenerror
8515                 (FLG_IMPTYPE,
8516                  message ("%s used but not previously declared: %s",
8517                           uentry_ekindName (ue),
8518                           idDecl_getName (t)),
8519                  g_currentloc);
8520
8521             }
8522           else
8523             {
8524               voptgenerror
8525                 (FLG_IMPTYPE,
8526                  message ("Variable has unknown (implicitly int) type: %s",
8527                           idDecl_getName (t)),
8528                  g_currentloc);
8529             }
8530
8531           ct = ctype_int;
8532         }
8533 # endif
8534     }
8535   else
8536     {
8537       uentry ue;
8538
8539       DPRINTF (("Unrecognized: %s", idDecl_unparse (t)));
8540
8541       ue = uentry_makeUnrecognized (idDecl_observeId (t), fileloc_copy (g_currentloc));
8542       /*!! fileloc_copy (g_currentloc)); */
8543       /*@i32!!! should get error without this */
8544
8545       ret = exprNode_fromIdentifierAux (ue);
8546
8547       /*
8548       ** No error - this happens in old style declarations:
8549
8550       voptgenerror
8551         (FLG_UNRECOG,
8552          message ("Unrecognized identifier in intializer: %s", idDecl_observeId (t)),
8553          g_currentloc);
8554
8555       **
8556       */
8557     }
8558
8559   exprData_free (ret->edata, ret->kind);
8560   ret->edata = exprData_undefined;
8561   ret->exitCode = XK_NEVERESCAPE;
8562   ret->mustBreak = FALSE;
8563   ret->kind = XPR_INIT;
8564   return ret;
8565 }
8566
8567 exprNode exprNode_makeEmptyInitialization (/*@only@*/ idDecl t)
8568 {
8569   exprNode ret = exprNode_makeInitializationAux (t);
8570   llassert (ret->edata == exprData_undefined);
8571   ret->edata = exprData_makeInit (t, exprNode_undefined);
8572   return ret;
8573 }
8574
8575 exprNode exprNode_makeInitialization (/*@only@*/ idDecl t,
8576                                       /*@only@*/ exprNode e)
8577 {
8578   uentry ue = usymtab_lookup (idDecl_observeId (t));
8579   exprNode ret = exprNode_makeInitializationAux (t);
8580   fileloc loc = exprNode_loc (e);
8581
8582   DPRINTF (("initialization: %s = %s", idDecl_unparse (t), exprNode_unparse (e)));
8583
8584   if (exprNode_isError (e))
8585     {
8586       e = exprNode_createUnknown ();
8587       /* error: assume initializer is defined */
8588       sRef_setDefined (ret->sref, g_currentloc);
8589       ret->edata = exprData_makeInit (t, e);
8590     }
8591   else
8592     {
8593       ctype ct = ctype_realishType (ret->typ);
8594
8595       /*
8596       ** evs - 9 Apr 1995
8597       **
8598       ** was addSafeUse --- what's the problem?
8599       **
8600       **   int x = 3, y = x ?
8601       */
8602
8603       exprData_free (ret->edata, ret->kind);
8604       ret->edata = exprData_makeInit (t, e);
8605       DPRINTF (("ret: %s", exprNode_unparse (ret)));
8606
8607       exprNode_checkUse (ret, e->sref, e->loc);
8608
8609       if (ctype_isUnknown (e->typ) && uentry_isValid (ue))
8610         {
8611           exprNode lhs = exprNode_createId (ue);
8612
8613           /*
8614           ** static storage should be undefined before initializing
8615           */
8616
8617           if (uentry_isStatic (ue))
8618             {
8619               sRef_setDefState (lhs->sref, SS_PARTIAL, fileloc_undefined);
8620             }
8621
8622           (void) exprNode_checkOneInit (lhs, e);
8623
8624           if (uentry_isStatic (ue))
8625             {
8626               sRef_setDefState (lhs->sref, SS_DEFINED, fileloc_undefined);
8627             }
8628
8629           exprNode_free (lhs);
8630         }
8631       else
8632         {
8633           if (!exprNode_matchType (ct, e))
8634             {
8635               if (exprNode_isZero (e) && ctype_isArrayPtr (ct))
8636                 {
8637                   ;
8638                 }
8639               else
8640                 {
8641                   (void) gentypeerror
8642                     (exprNode_getType (e), e, exprNode_getType (ret), ret,
8643                      message
8644                      ("Variable %q initialized to type %t, expects %t: %s",
8645                       uentry_getName (ue), exprNode_getType (e),
8646                       exprNode_getType (ret),
8647                       exprNode_unparse (e)),
8648                      e->loc);
8649                 }
8650             }
8651         }
8652
8653       if (uentry_isStatic (ue))
8654         {
8655           sRef_setDefState (ret->sref, SS_PARTIAL, fileloc_undefined);
8656         }
8657
8658       if (exprNode_isStringLiteral (e)
8659           && (ctype_isArray (ct))
8660           && (ctype_isChar (ctype_realType (ctype_baseArrayPtr (ct)))))
8661         {
8662           /*
8663           ** If t is a char [], the literal is copied.
8664           */
8665
8666           exprNode_checkStringLiteralLength (ct, e);
8667           sRef_setDefState (ret->sref, SS_DEFINED, e->loc);
8668           ret->val = multiVal_copy (e->val);
8669
8670           sRef_setNullTerminatedState (ret->sref);
8671
8672           if (multiVal_isDefined (e->val))
8673             {
8674               cstring slit = multiVal_forceString (e->val);
8675               sRef_setLen (ret->sref, size_toInt (cstring_length (slit) + 1));
8676             }
8677
8678           if (ctype_isFixedArray (ct))
8679             {
8680               sRef_setSize (ret->sref, size_toInt (ctype_getArraySize (ct)));
8681             }
8682         }
8683       else
8684         {
8685           doAssign (ret, e, TRUE);
8686         }
8687
8688       if (uentry_isStatic (ue))
8689         {
8690           sRef_setDefState (ret->sref, SS_DEFINED, fileloc_undefined);
8691         }
8692     }
8693
8694   if (context_inIterDef ())
8695     {
8696       /* should check if it is yield */
8697       uentry_setUsed (ue, loc);
8698     }
8699   else
8700     {
8701       ;
8702     }
8703
8704   exprNode_mergeUSs (ret, e);
8705   DPRINTF (("Ret: %s %p %p",
8706             exprNode_unparse (ret),
8707             ret->requiresConstraints,
8708             ret->ensuresConstraints));
8709
8710   DPRINTF (("Ret: %s %s %s",
8711             exprNode_unparse (ret),
8712             constraintList_unparse (ret->requiresConstraints),
8713             constraintList_unparse (ret->ensuresConstraints)));
8714   return ret;
8715 }
8716
8717 exprNode exprNode_iter (/*@observer@*/ uentry name,
8718                         /*@only@*/ exprNodeList alist,
8719                         /*@only@*/ exprNode body,
8720                         /*@observer@*/ uentry end)
8721 {
8722   exprNode ret;
8723   cstring iname;
8724
8725   llassert (uentry_isValid (name));
8726
8727   uentry_setUsed (name, exprNode_loc (body));
8728
8729   ret = exprNode_createPartialCopy (body);
8730   iname = uentry_getName (name);
8731
8732   if (uentry_isInvalid (end))
8733     {
8734       llerror (FLG_ITERBALANCE,
8735                message ("Iter %s not balanced with end_%s", iname, iname));
8736     }
8737   else
8738     {
8739       cstring ename = uentry_getName (end);
8740
8741       if (!cstring_equalPrefixLit (ename, "end_"))
8742         {
8743           llerror (FLG_ITERBALANCE, message ("Iter %s not balanced with end_%s: %s",
8744                                       iname, iname, ename));
8745         }
8746       else
8747         {
8748           if (!cstring_equal (iname, cstring_suffix (ename, 4)))
8749             {
8750               llerror (FLG_ITERBALANCE,
8751                        message ("Iter %s not balanced with end_%s: %s",
8752                                 iname, iname, ename));
8753             }
8754         }
8755
8756       cstring_free (ename);
8757     }
8758
8759   context_exitIterClause (body);
8760
8761   ret->kind = XPR_ITER;
8762   ret->edata = exprData_makeIter (name, alist, body, end);
8763
8764   if (uentry_isIter (name))
8765     {
8766       (void) checkArgsReal (name, body,
8767                             uentry_getParams (name), alist, TRUE, ret);
8768     }
8769
8770   cstring_free (iname);
8771
8772   return ret;
8773 }
8774
8775 exprNode
8776 exprNode_iterNewId (/*@only@*/ cstring s)
8777 {
8778   exprNode e = exprNode_new ();
8779   uentry ue = uentryList_getN (uentry_getParams (getCurrentIter ()), iterParamNo ());
8780
8781   llassert (processingIterVars ());
8782
8783   e->loc = context_getSaveLocation ();
8784
8785   if (fileloc_isUndefined (e->loc))
8786     {
8787       fileloc_free (e->loc);
8788       e->loc = fileloc_copy (g_currentloc);
8789     }
8790
8791   e->uses = sRefSet_new ();
8792   e->sets = sRefSet_new ();
8793   e->msets = sRefSet_new ();
8794   e->kind = XPR_VAR;
8795   e->val = multiVal_unknown ();
8796   e->guards = guardSet_new ();
8797   e->sref = sRef_undefined;
8798   e->isJumpPoint = FALSE;
8799   e->exitCode = XK_NEVERESCAPE;
8800
8801   /*> missing fields, detected by splint <*/
8802   e->canBreak = FALSE;
8803   e->mustBreak = FALSE;
8804   e->etext = cstring_undefined;
8805
8806   if (uentry_isYield (ue))
8807     {
8808       uentry uue = uentry_makeVariable (s, uentry_getType (ue),
8809                                         fileloc_copy (e->loc),
8810                                         FALSE);
8811       sRef sr;
8812
8813       uue = usymtab_supEntrySrefReturn (uue);
8814
8815       sr = uentry_getSref (uue);
8816       sRef_mergeStateQuiet (sr, uentry_getSref (ue));
8817       sr = uentry_getSref (uue);
8818       sRef_setDefined (sr, e->loc);
8819
8820       e->typ = uentry_getType (uue);
8821       e->sref = sr;
8822       e->edata = exprData_makeId (uue);
8823       uentry_setUsed (uue, g_currentloc);
8824     }
8825   else
8826     {
8827       uentry uue;
8828
8829       sRef_setGlobalScope ();
8830       uue = uentry_makeVariableLoc (s, ctype_unknown);
8831
8832       e->typ = ctype_unknown;
8833       e->edata = exprData_makeId (uue);
8834
8835       uentry_setUsed (uue, e->loc);
8836       uentry_setHasNameError (uue);
8837
8838       if (context_getFlag (FLG_REPEATUNRECOG))
8839         {
8840           uentry_markOwned (uue);
8841         }
8842       else
8843         {
8844           usymtab_supGlobalEntry (uue);
8845         }
8846
8847       sRef_clearGlobalScope ();
8848
8849       voptgenerror (FLG_UNRECOG, message ("Unrecognized identifier: %s", s),
8850                     e->loc);
8851     }
8852
8853
8854   cstring_free (s);
8855
8856   exprNode_defineConstraints(e);
8857   return (e);
8858 }
8859
8860 exprNode
8861 exprNode_iterExpr (/*@returned@*/ exprNode e)
8862 {
8863   if (!processingIterVars ())
8864     {
8865       llcontbuglit ("checkIterParam: not in iter");
8866       return e;
8867     }
8868
8869   if (uentry_isYield (uentryList_getN (uentry_getParams (getCurrentIter ()),
8870                                        iterParamNo ())))
8871     {
8872       if (exprNode_isDefined (e))
8873         {
8874           if (fileloc_isDefined (e->loc))
8875             {
8876               voptgenerror
8877                 (FLG_ITERYIELD,
8878                  message ("Yield parameter is not simple identifier: %s",
8879                           exprNode_unparse (e)),
8880                  e->loc);
8881             }
8882           else
8883             {
8884               voptgenerror
8885                 (FLG_ITERYIELD,
8886                  message ("Yield parameter is not simple identifier: %s",
8887                           exprNode_unparse (e)),
8888                  g_currentloc);
8889
8890             }
8891         }
8892     }
8893   return e;
8894 }
8895
8896 exprNode
8897 exprNode_iterId (/*@observer@*/ uentry c)
8898 {
8899   uentry ue;
8900
8901   llassert (processingIterVars ());
8902
8903   ue = uentryList_getN (uentry_getParams (getCurrentIter ()),
8904                         iterParamNo ());
8905
8906   if (uentry_isYield (ue))
8907     {
8908       ctype ct = uentry_getType (ue);
8909       exprNode e = exprNode_createPlain (ct);
8910       cstring name = uentry_getName (c);
8911       uentry le = uentry_makeVariable (name, ct, fileloc_undefined, FALSE);
8912
8913       uentry_setUsed (ue, g_currentloc);
8914       uentry_setHasNameError (ue);
8915
8916       cstring_free (name);
8917
8918       e->kind = XPR_VAR;
8919       e->edata = exprData_makeId (le);
8920       e->loc = context_getSaveLocation ();
8921       e->sref = uentry_getSref (le);
8922
8923       usymtab_supEntrySref (le);
8924
8925       if (!context_inHeader ())
8926         {
8927           if (optgenerror
8928               (FLG_ITERYIELD,
8929                message ("Yield parameter shadows local declaration: %q",
8930                         uentry_getName (c)),
8931                fileloc_isDefined (e->loc) ? e->loc : g_currentloc))
8932             {
8933               uentry_showWhereDeclared (c);
8934             }
8935         }
8936
8937       return e;
8938     }
8939
8940   return (exprNode_fromIdentifierAux (c));
8941 }
8942
8943 exprNode exprNode_iterStart (/*@observer@*/ uentry name, /*@only@*/ exprNodeList alist)
8944 {
8945   exprNode ret = exprNode_create (ctype_unknown);
8946
8947   ret->kind = XPR_ITERCALL;
8948   ret->edata = exprData_makeIterCall (name, alist);
8949
8950   if (uentry_isIter (name))
8951     {
8952       uentryList params = uentry_getParams (name);
8953
8954       if (context_inIterDef ()
8955           && uentryList_size (params) == exprNodeList_size (alist))
8956         {
8957           int i = 0;
8958
8959           exprNodeList_elements (alist, arg)
8960             {
8961               uentry parg = uentryList_getN (params, i);
8962
8963               if (uentry_isYield (parg))
8964                 {
8965                   uentry ue = exprNode_getUentry (arg);
8966
8967                   if (uentry_isValid (ue))
8968                     {
8969                       ;
8970                     }
8971                 }
8972
8973               i++;
8974             } end_exprNodeList_elements;
8975         }
8976
8977       (void) checkArgsReal (name, ret, params, alist, TRUE, ret);
8978       checkUnspecCall (ret, params, alist);
8979     }
8980
8981   return ret;
8982 }
8983
8984 /*@exposed@*/ sRef exprNode_getSref (exprNode e)
8985 {
8986   if (exprNode_isDefined (e))
8987     {
8988       if (sRef_isInvalid (e->sref))
8989         {
8990           /*@-mods@*/
8991           e->sref = sRef_makeUnknown ();
8992           sRef_setAliasKind (e->sref, AK_ERROR, fileloc_undefined);
8993           /*@=mods@*/
8994           return e->sref;
8995         }
8996       else
8997         {
8998           return e->sref;
8999         }
9000     }
9001   else
9002     {
9003       return sRef_undefined;
9004     }
9005 }
9006
9007 /*@observer@*/ cstring
9008 exprNode_unparseFirst (exprNode e)
9009 {
9010   if (exprNode_isDefined (e))
9011     {
9012       cstring ret;
9013
9014       if (e->kind == XPR_STMTLIST
9015           || e->kind == XPR_COMMA || e->kind == XPR_COND)
9016         {
9017           exprNode first = exprData_getPairA (e->edata);
9018
9019           if (exprNode_isDefined (first))
9020             {
9021               return (exprNode_unparseFirst (exprData_getPairA (e->edata)));
9022             }
9023           else
9024             {
9025               return (cstring_makeLiteralTemp ("..."));
9026             }
9027         }
9028
9029       ret = cstring_elide (exprNode_unparse (e), 20);
9030       cstring_markOwned (ret);
9031
9032       return (ret);
9033     }
9034   else
9035     {
9036       return cstring_makeLiteralTemp ("<error>");
9037     }
9038 }
9039
9040 /*@observer@*/ cstring
9041 exprNode_unparse (/*@temp@*/ exprNode e)
9042 {
9043   if (exprNode_isError (e))
9044     {
9045       return cstring_makeLiteralTemp ("<error>");
9046     }
9047
9048   if (cstring_isDefined (e->etext))
9049     {
9050       return e->etext;
9051     }
9052   else
9053     {
9054       cstring ret = exprNode_doUnparse (e);
9055
9056       /*@-modifies@*/ /* benevolent */
9057       e->etext = ret;
9058       /*@=modifies@*/
9059       return ret;
9060     }
9061 }
9062
9063 /*@observer@*/ fileloc
9064 exprNode_loc (exprNode e)
9065 {
9066   if (exprNode_isError (e))
9067     {
9068       return (g_currentloc);
9069     }
9070   else
9071     {
9072       return (e->loc);
9073     }
9074 }
9075
9076 /*
9077 ** executes exprNode e
9078 **    recursively rexecutes as though in original parse using
9079 **    information in e->edata
9080 */
9081
9082 static /*@only@*/ exprNodeList exprNodeList_effect (exprNodeList e)
9083 {
9084   exprNodeList ret = exprNodeList_new ();
9085
9086   exprNodeList_elements (e, current)
9087     {
9088       exprNodeList_addh (ret, exprNode_effect (current));
9089     } end_exprNodeList_elements;
9090
9091   return ret;
9092 }
9093
9094 static /*@only@*/ exprNode exprNode_effect (exprNode e)
9095    /*@globals internalState@*/
9096 {
9097   bool innerEffect = inEffect;
9098   exprNode ret;
9099   exprData data;
9100
9101   inEffect = TRUE;
9102
9103   context_clearJustPopped ();
9104
9105   if (exprNode_isError (e))
9106     {
9107       ret = exprNode_undefined;
9108     }
9109   else
9110     {
9111       /*
9112       ** Turn off expose and dependent transfer checking.
9113       ** Need to pass exposed internal nodes,
9114       ** [ copying would be a waste! ]
9115       ** [ Actually, I think I wasted a lot more time than its worth ]
9116       ** [ trying to do this. ]
9117       */
9118
9119       /*@-exposetrans@*/
9120       /*@-observertrans@*/
9121       /*@-dependenttrans@*/
9122
9123       data = e->edata;
9124
9125       switch (e->kind)
9126         {
9127         case XPR_PARENS:
9128           ret = exprNode_addParens (exprData_getUopTok (data),
9129                                     exprNode_effect (exprData_getUopNode (data)));
9130           break;
9131         case XPR_ASSIGN:
9132           ret = exprNode_assign (exprNode_effect (exprData_getOpA (data)),
9133                                  exprNode_effect (exprData_getOpB (data)),
9134                                  exprData_getOpTok (data));
9135           break;
9136         case XPR_INITBLOCK:
9137           ret = exprNode_undefined;
9138           break;
9139         case XPR_CALL:
9140           ret = exprNode_functionCall (exprNode_effect (exprData_getFcn (data)),
9141                                        exprNodeList_effect (exprData_getArgs (data)));
9142           break;
9143         case XPR_EMPTY:
9144           ret = e;
9145           break;
9146
9147         case XPR_LABEL:
9148           ret = e;
9149           break;
9150
9151         case XPR_CONST:
9152         case XPR_VAR:
9153           {
9154             cstring id = exprData_getId (data);
9155             uentry ue = usymtab_lookupSafe (id);
9156
9157             ret = exprNode_fromIdentifierAux (ue);
9158             ret->loc = fileloc_update (ret->loc, e->loc);
9159             break;
9160           }
9161         case XPR_BODY:
9162           ret = e;
9163           break;
9164         case XPR_FETCH:
9165           ret = exprNode_arrayFetch (exprNode_effect (exprData_getPairA (data)),
9166                                      exprNode_effect (exprData_getPairB (data)));
9167           break;
9168         case XPR_OP:
9169           /*
9170           ** evans 2002-03-15: for && and ||, need to do the guards also
9171           **                   this is what cgrammar.y does - should be
9172           **                   able to avoid duplication, but need to
9173           **                   time with grammar productions.
9174           */
9175
9176           DPRINTF (("Effect: %s", exprNode_unparse (e)));
9177
9178           if (lltok_getTok (exprData_getOpTok (data)) == AND_OP)
9179             {
9180               exprNode e1 = exprNode_effect (exprData_getOpA (data));
9181               exprNode e2;
9182               exprNode_produceGuards (e1);
9183               context_enterAndClause (e1);
9184               e2 = exprNode_effect (exprData_getOpB (data));
9185
9186               ret = exprNode_op (e1, e2,
9187                                  exprData_getOpTok (data));
9188
9189               context_exitAndClause (ret, e2);
9190             }
9191           else if (lltok_getTok (exprData_getOpTok (data)) == OR_OP)
9192             {
9193               exprNode e1 = exprNode_effect (exprData_getOpA (data));
9194               exprNode e2;
9195               exprNode_produceGuards (e1);
9196               context_enterOrClause (e1);
9197               e2 = exprNode_effect (exprData_getOpB (data));
9198
9199               ret = exprNode_op (e1, e2,
9200                                  exprData_getOpTok (data));
9201
9202               context_exitOrClause (ret, e2);
9203             }
9204           else
9205             {
9206               ret = exprNode_op (exprNode_effect (exprData_getOpA (data)),
9207                                  exprNode_effect (exprData_getOpB (data)),
9208                                  exprData_getOpTok (data));
9209             }
9210           break;
9211
9212         case XPR_POSTOP:
9213           ret = exprNode_postOp (exprNode_effect (exprData_getUopNode (data)),
9214                                  exprData_getUopTok (data));
9215           break;
9216         case XPR_PREOP:
9217           ret = exprNode_preOp (exprNode_effect (exprData_getUopNode (data)),
9218                                 exprData_getUopTok (data));
9219           break;
9220
9221         case XPR_OFFSETOF:
9222         case XPR_SIZEOFT:
9223         case XPR_SIZEOF:
9224         case XPR_ALIGNOFT:
9225         case XPR_ALIGNOF:
9226           ret = e;
9227           break;
9228
9229         case XPR_VAARG:
9230           ret = exprNode_vaArg (exprData_getCastTok (data),
9231                                 exprNode_effect (exprData_getCastNode (data)),
9232                                 exprData_getCastType (data));
9233           break;
9234
9235         case XPR_CAST:
9236           ret = exprNode_cast (exprData_getCastTok (data),
9237                                exprNode_effect (exprData_getCastNode (data)),
9238                                exprData_getCastType (data));
9239           break;
9240         case XPR_ITERCALL:
9241           ret = exprNode_iterStart (exprData_getIterCallIter (data),
9242                                     exprNodeList_effect
9243                                     (exprData_getIterCallArgs (data)));
9244           break;
9245
9246         case XPR_ITER:
9247           ret = exprNode_iter (exprData_getIterSname (data),
9248                                exprNodeList_effect (exprData_getIterAlist (data)),
9249                                exprNode_effect (exprData_getIterBody (data)),
9250                                exprData_getIterEname (data));
9251           break;
9252
9253         case XPR_FOR:
9254           ret = exprNode_for (exprNode_effect (exprData_getPairA (data)),
9255                               exprNode_effect (exprData_getPairB (data)));
9256           break;
9257
9258         case XPR_FORPRED:
9259           ret = exprNode_forPred (exprNode_effect (exprData_getTripleInit (data)),
9260                                   exprNode_effect (exprData_getTripleTest (data)),
9261                                   exprNode_effect (exprData_getTripleInc (data)));
9262           break;
9263
9264         case XPR_TOK:
9265           ret = exprNode_createTok (exprData_getTok (data));
9266           break;
9267
9268         case XPR_GOTO:
9269           ret = exprNode_goto (exprData_getLiteral (data));
9270           ret->loc = fileloc_update (ret->loc, e->loc);
9271           break;
9272
9273         case XPR_CONTINUE:
9274           ret = exprNode_continue (exprData_getTok (data), QSAFEBREAK);
9275           break;
9276
9277         case XPR_BREAK:
9278           ret = exprNode_break (exprData_getTok (data), QSAFEBREAK);
9279           break;
9280
9281         case XPR_RETURN:
9282           ret = exprNode_return (exprNode_effect (exprData_getSingle (data)));
9283           break;
9284
9285         case XPR_NULLRETURN:
9286           ret = exprNode_nullReturn (exprData_getTok (data));
9287           break;
9288
9289         case XPR_COMMA:
9290           ret = exprNode_comma (exprNode_effect (exprData_getPairA (data)),
9291                                 exprNode_effect (exprData_getPairB (data)));
9292           break;
9293
9294         case XPR_COND:
9295           ret = exprNode_cond (exprNode_effect (exprData_getTriplePred (data)),
9296                                exprNode_effect (exprData_getTripleTrue (data)),
9297                                exprNode_effect (exprData_getTripleFalse (data)));
9298           break;
9299         case XPR_IF:
9300           ret = exprNode_if (exprNode_effect (exprData_getPairA (data)),
9301                              exprNode_effect (exprData_getPairB (data)));
9302           break;
9303
9304         case XPR_IFELSE:
9305           ret = exprNode_ifelse (exprNode_effect (exprData_getTriplePred (data)),
9306                                  exprNode_effect (exprData_getTripleTrue (data)),
9307                                  exprNode_effect (exprData_getTripleFalse (data)));
9308           break;
9309         case XPR_WHILEPRED:
9310           ret = exprNode_whilePred (exprData_getSingle (data));
9311           break;
9312
9313         case XPR_WHILE:
9314           ret = exprNode_while (exprNode_effect (exprData_getPairA (data)),
9315                                 exprNode_effect (exprData_getPairB (data)));
9316           break;
9317
9318         case XPR_DOWHILE:
9319           ret = exprNode_doWhile (exprNode_effect (exprData_getPairA (data)),
9320                                   exprNode_effect (exprData_getPairB (data)));
9321           break;
9322
9323         case XPR_BLOCK:
9324           ret = exprNode_makeBlock (exprNode_effect (exprData_getSingle (data)));
9325           break;
9326
9327         case XPR_STMT:
9328           ret = exprNode_statement (exprNode_effect (exprData_getUopNode (data)),
9329                                     exprData_getUopTok (data));
9330           break;
9331
9332         case XPR_STMTLIST:
9333           ret = exprNode_concat (exprNode_effect (exprData_getPairA (data)),
9334                                  exprNode_effect (exprData_getPairB (data)));
9335           break;
9336
9337         case XPR_FTCASE:
9338         case XPR_CASE:
9339           ret = exprNode_caseMarker
9340             (exprNode_effect (exprData_getSingle (data)),
9341              TRUE);
9342           break;
9343
9344         case XPR_FTDEFAULT:
9345         case XPR_DEFAULT:
9346           ret = exprNode_createTok (exprData_getTok (data));
9347           break;
9348
9349         case XPR_SWITCH:
9350           ret = exprNode_switch (exprNode_effect (exprData_getPairA (data)),
9351                                  exprNode_effect (exprData_getPairB (data)));
9352           break;
9353
9354         case XPR_INIT:
9355           ret = exprNode_makeInitialization
9356             (exprData_getInitId (data),
9357              exprNode_effect (exprData_getInitNode (data)));
9358           break;
9359
9360         case XPR_FACCESS:
9361           ret = exprNode_fieldAccessAux
9362             (exprNode_effect (exprData_getFieldNode (data)),
9363              exprNode_loc (exprData_getFieldNode (data)),
9364              cstring_copy (exprData_getFieldName (data)));
9365           break;
9366
9367         case XPR_ARROW:
9368           ret = exprNode_arrowAccessAux
9369             (exprNode_effect (exprData_getFieldNode (data)),
9370              exprNode_loc (exprData_getFieldNode (data)),
9371              cstring_copy (exprData_getFieldName (data)));
9372           break;
9373
9374         case XPR_STRINGLITERAL:
9375           ret = e;
9376           break;
9377
9378         case XPR_NUMLIT:
9379           ret = e;
9380           break;
9381
9382         case XPR_NODE:
9383           ret = e;
9384           break;
9385           /*@-branchstate@*/
9386         }
9387       /*@=branchstate@*/
9388       /*@=observertrans@*/
9389       /*@=exposetrans@*/
9390       /*@=dependenttrans@*/
9391     }
9392
9393   if (!innerEffect)
9394     {
9395       inEffect = FALSE;
9396     }
9397
9398   return ret;
9399 }
9400
9401 static /*@observer@*/ cstring exprNode_rootVarName (exprNode e)
9402 {
9403   cstring ret;
9404   exprData data;
9405
9406   if (exprNode_isError (e))
9407     {
9408       return cstring_undefined;
9409     }
9410
9411   data = e->edata;
9412
9413   switch (e->kind)
9414     {
9415     case XPR_PARENS:
9416       ret = exprNode_rootVarName (exprData_getUopNode (data));
9417       break;
9418     case XPR_ASSIGN:
9419       ret = exprNode_rootVarName (exprData_getOpA (data));
9420       break;
9421     case XPR_CONST:
9422     case XPR_VAR:
9423       ret = exprData_getId (data);
9424       break;
9425     case XPR_INIT:
9426       ret = idDecl_getName (exprData_getInitId (data));
9427       break;
9428     case XPR_LABEL:
9429     case XPR_TOK:
9430     case XPR_ITERCALL:
9431     case XPR_EMPTY:
9432     case XPR_CALL:
9433     case XPR_INITBLOCK:
9434     case XPR_BODY:
9435     case XPR_FETCH:
9436     case XPR_OP:
9437     case XPR_POSTOP:
9438     case XPR_PREOP:
9439     case XPR_OFFSETOF:
9440     case XPR_ALIGNOFT:
9441     case XPR_ALIGNOF:
9442     case XPR_SIZEOFT:
9443     case XPR_SIZEOF:
9444     case XPR_VAARG:
9445     case XPR_CAST:
9446     case XPR_ITER:
9447     case XPR_FOR:
9448     case XPR_FORPRED:
9449     case XPR_BREAK:
9450     case XPR_RETURN:
9451     case XPR_NULLRETURN:
9452     case XPR_COMMA:
9453     case XPR_COND:
9454     case XPR_IF:
9455     case XPR_IFELSE:
9456     case XPR_WHILE:
9457     case XPR_WHILEPRED:
9458     case XPR_DOWHILE:
9459     case XPR_GOTO:
9460     case XPR_CONTINUE:
9461     case XPR_FTDEFAULT:
9462     case XPR_DEFAULT:
9463     case XPR_SWITCH:
9464     case XPR_FTCASE:
9465     case XPR_CASE:
9466     case XPR_BLOCK:
9467     case XPR_STMT:
9468     case XPR_STMTLIST:
9469     case XPR_FACCESS:
9470     case XPR_ARROW:
9471     case XPR_NODE:
9472     case XPR_NUMLIT:
9473     case XPR_STRINGLITERAL:
9474       ret = cstring_undefined;
9475       break;
9476     }
9477
9478   return ret;
9479 }
9480
9481 static /*@only@*/ cstring exprNode_doUnparse (exprNode e)
9482 {
9483   cstring ret;
9484   exprData data;
9485
9486   if (exprNode_isError (e))
9487     {
9488       static /*@only@*/ cstring error = cstring_undefined;
9489
9490       if (!cstring_isDefined (error))
9491         {
9492           error = cstring_makeLiteral ("<error>");
9493         }
9494
9495       return error;
9496     }
9497
9498   data = e->edata;
9499
9500   switch (e->kind)
9501     {
9502     case XPR_PARENS:
9503       ret = message ("(%s)", exprNode_unparse (exprData_getUopNode (e->edata)));
9504       break;
9505     case XPR_ASSIGN:
9506       ret = message ("%s %s %s",
9507                      exprNode_unparse (exprData_getOpA (data)),
9508                      lltok_unparse (exprData_getOpTok (data)),
9509                      exprNode_unparse (exprData_getOpB (data)));
9510       break;
9511     case XPR_CALL:
9512       ret = message ("%s(%q)",
9513                      exprNode_unparse (exprData_getFcn (data)),
9514                      exprNodeList_unparse (exprData_getArgs (data)));
9515       break;
9516     case XPR_INITBLOCK:
9517       ret = message ("{ %q }", exprNodeList_unparse (exprData_getArgs (data)));
9518       break;
9519     case XPR_EMPTY:
9520       ret = cstring_undefined;
9521       break;
9522     case XPR_LABEL:
9523       ret = message ("%s:", exprData_getId (data));
9524       break;
9525     case XPR_CONST:
9526     case XPR_VAR:
9527       ret = cstring_copy (exprData_getId (data));
9528       break;
9529     case XPR_FETCH:
9530       ret = message ("%s[%s]", exprNode_unparse (exprData_getPairA (data)),
9531                      exprNode_unparse (exprData_getPairB (data)));
9532       break;
9533     case XPR_BODY:
9534       ret = message ("<body>");
9535       break;
9536     case XPR_OP:
9537       ret = message ("%s %s %s",
9538                      exprNode_unparse (exprData_getOpA (data)),
9539                      lltok_unparse (exprData_getOpTok (data)),
9540                      exprNode_unparse (exprData_getOpB (data)));
9541       break;
9542
9543     case XPR_PREOP:
9544       ret = message ("%s%s",
9545                      lltok_unparse (exprData_getUopTok (data)),
9546                      exprNode_unparse (exprData_getUopNode (data)));
9547       break;
9548
9549     case XPR_POSTOP:
9550       ret = message ("%s%s",
9551                      exprNode_unparse (exprData_getUopNode (data)),
9552                      lltok_unparse (exprData_getUopTok (data)));
9553       break;
9554
9555     case XPR_OFFSETOF:
9556       ret = message ("offsetof(%s,%q)",
9557                      ctype_unparse (qtype_getType (exprData_getOffsetType (data))),
9558                      cstringList_unparseSep (exprData_getOffsetName (data), cstring_makeLiteralTemp (".")));
9559       break;
9560
9561     case XPR_SIZEOFT:
9562       ret = message ("sizeof(%s)", ctype_unparse (qtype_getType (exprData_getType (data))));
9563       break;
9564
9565     case XPR_SIZEOF:
9566       ret = message ("sizeof(%s)", exprNode_unparse (exprData_getSingle (data)));
9567       break;
9568
9569     case XPR_ALIGNOFT:
9570       ret = message ("alignof(%s)", ctype_unparse (qtype_getType (exprData_getType (data))));
9571       break;
9572
9573     case XPR_ALIGNOF:
9574       ret = message ("alignof(%s)", exprNode_unparse (exprData_getSingle (data)));
9575       break;
9576
9577     case XPR_VAARG:
9578       ret = message ("va_arg(%s, %q)",
9579                      exprNode_unparse (exprData_getCastNode (data)),
9580                      qtype_unparse (exprData_getCastType (data)));
9581       break;
9582
9583     case XPR_ITERCALL:
9584       ret = message ("%q(%q)",
9585                      uentry_getName (exprData_getIterCallIter (data)),
9586                      exprNodeList_unparse (exprData_getIterCallArgs (data)));
9587       break;
9588     case XPR_ITER:
9589       ret = message ("%q(%q) %s %q",
9590                      uentry_getName (exprData_getIterSname (data)),
9591                      exprNodeList_unparse (exprData_getIterAlist (data)),
9592                      exprNode_unparse (exprData_getIterBody (data)),
9593                      uentry_getName (exprData_getIterEname (data)));
9594       break;
9595     case XPR_CAST:
9596       ret = message ("(%q)%s",
9597                      qtype_unparse (exprData_getCastType (data)),
9598                      exprNode_unparse (exprData_getCastNode (data)));
9599       break;
9600
9601     case XPR_FOR:
9602       ret = message ("%s %s",
9603                      exprNode_unparse (exprData_getPairA (data)),
9604                      exprNode_unparse (exprData_getPairB (data)));
9605       break;
9606
9607     case XPR_FORPRED:
9608             ret = message ("for (%s; %s; %s)",
9609                      exprNode_unparse (exprData_getTripleInit (data)),
9610                      exprNode_unparse (exprData_getTripleTest (data)),
9611                      exprNode_unparse (exprData_getTripleInc (data)));
9612       break;
9613
9614     case XPR_GOTO:
9615       ret = message ("goto %s", exprData_getLiteral (data));
9616       break;
9617
9618     case XPR_CONTINUE:
9619       ret = cstring_makeLiteral ("continue");
9620       break;
9621
9622     case XPR_BREAK:
9623       ret = cstring_makeLiteral ("break");
9624       break;
9625
9626     case XPR_RETURN:
9627       ret = message ("return %s", exprNode_unparse (exprData_getSingle (data)));
9628       break;
9629
9630     case XPR_NULLRETURN:
9631       ret = cstring_makeLiteral ("return");
9632       break;
9633
9634     case XPR_COMMA:
9635       ret = message ("%s, %s",
9636                      exprNode_unparse (exprData_getPairA (data)),
9637                      exprNode_unparse (exprData_getPairB (data)));
9638       break;
9639
9640     case XPR_COND:
9641       ret = message ("%s ? %s : %s",
9642                      exprNode_unparse (exprData_getTriplePred (data)),
9643                      exprNode_unparse (exprData_getTripleTrue (data)),
9644                      exprNode_unparse (exprData_getTripleFalse (data)));
9645       break;
9646     case XPR_IF:
9647       ret = message ("if (%s) %s",
9648                      exprNode_unparse (exprData_getPairA (data)),
9649                      exprNode_unparse (exprData_getPairB (data)));
9650       break;
9651
9652     case XPR_IFELSE:
9653       ret = message ("if (%s) %s else %s",
9654                      exprNode_unparse (exprData_getTriplePred (data)),
9655                      exprNode_unparse (exprData_getTripleTrue (data)),
9656                      exprNode_unparse (exprData_getTripleFalse (data)));
9657       break;
9658     case XPR_WHILE:
9659       ret = message ("while (%s) %s",
9660                      exprNode_unparse (exprData_getPairA (data)),
9661                      exprNode_unparse (exprData_getPairB (data)));
9662       break;
9663
9664     case XPR_WHILEPRED:
9665       ret = cstring_copy (exprNode_unparse (exprData_getSingle (data)));
9666       break;
9667
9668     case XPR_TOK:
9669       ret = cstring_copy (lltok_unparse (exprData_getTok (data)));
9670       break;
9671
9672     case XPR_DOWHILE:
9673       ret = message ("do { %s } while (%s)",
9674                      exprNode_unparse (exprData_getPairB (data)),
9675                      exprNode_unparse (exprData_getPairA (data)));
9676       break;
9677
9678     case XPR_BLOCK:
9679       ret = message ("{ %s }", exprNode_unparse (exprData_getSingle (data)));
9680       /* evans 2002-02-20 was unparseFirst! */
9681       break;
9682
9683     case XPR_STMT:
9684       ret = message ("%s;", exprNode_unparse (exprData_getUopNode (data)));
9685       break;
9686
9687     case XPR_STMTLIST:
9688       if (exprNode_isStatement (exprData_getPairA (data)))
9689         {
9690           /*
9691           ** statement expressions already print the ;
9692           */
9693
9694           ret = message ("%s %s",
9695                          exprNode_unparse (exprData_getPairA (data)),
9696                          exprNode_unparse (exprData_getPairB (data)));
9697         }
9698       else
9699         {
9700           ret = message ("%s; %s",
9701                          exprNode_unparse (exprData_getPairA (data)),
9702                          exprNode_unparse (exprData_getPairB (data)));
9703         }
9704       break;
9705
9706     case XPR_FTDEFAULT:
9707     case XPR_DEFAULT:
9708       ret = cstring_makeLiteral ("default:");
9709       break;
9710
9711     case XPR_SWITCH:
9712       ret = message ("switch (%s) %s",
9713                      exprNode_unparse (exprData_getPairA (data)),
9714                      exprNode_unparse (exprData_getPairB (data)));
9715       break;
9716
9717     case XPR_FTCASE:
9718     case XPR_CASE:
9719       ret = message ("case %s:",
9720                      exprNode_unparse (exprData_getSingle (data)));
9721       break;
9722
9723     case XPR_INIT:
9724       if (exprNode_isError (exprData_getInitNode (data)))
9725         {
9726           ret = message ("%q", idDecl_unparseC (exprData_getInitId (data)));
9727         }
9728       else
9729         {
9730           ret = message ("%q = %s",
9731                          idDecl_unparseC (exprData_getInitId (data)),
9732                          exprNode_unparse (exprData_getInitNode (data)));
9733         }
9734       break;
9735
9736     case XPR_FACCESS:
9737       ret = message ("%s.%s",
9738                      exprNode_unparse (exprData_getFieldNode (data)),
9739                      exprData_getFieldName (data));
9740       break;
9741
9742     case XPR_ARROW:
9743             ret = message ("%s->%s",
9744                      exprNode_unparse (exprData_getFieldNode (data)),
9745                      exprData_getFieldName (data));
9746       break;
9747
9748     case XPR_STRINGLITERAL:
9749       if (ctype_isWideString (e->typ))
9750         {
9751           ret = message ("L\"%s\"", exprData_getLiteral (data));
9752         }
9753       else
9754         {
9755           ret = message ("\"%s\"", exprData_getLiteral (data));
9756         }
9757       break;
9758
9759     case XPR_NUMLIT:
9760       ret = cstring_copy (exprData_getLiteral (data));
9761       break;
9762
9763     case XPR_NODE:
9764       ret = cstring_makeLiteral ("<node>");
9765       break;
9766     }
9767
9768   return ret;
9769 }
9770
9771 bool
9772 exprNode_isInitializer (exprNode e)
9773 {
9774   return (exprNode_isDefined (e)
9775           && e->kind == XPR_INIT);
9776 }
9777
9778 bool
9779 exprNode_isCharLiteral (exprNode e)
9780 {
9781   if (exprNode_isDefined (e))
9782     {
9783       return (multiVal_isChar (exprNode_getValue (e)));
9784     }
9785   else
9786     {
9787       return FALSE;
9788     }
9789 }
9790
9791 bool
9792 exprNode_isNumLiteral (exprNode e)
9793 {
9794   if (exprNode_isDefined (e))
9795     {
9796       return (multiVal_isInt (exprNode_getValue (e)));
9797     }
9798   else
9799     {
9800       return FALSE;
9801     }
9802 }
9803
9804 static bool
9805 exprNode_isFalseConstant (exprNode e)
9806 {
9807   if (exprNode_isDefined (e))
9808     {
9809       cstring s = exprNode_rootVarName (e);
9810
9811       if (cstring_equal (s, context_getFalseName ()))
9812         {
9813           return TRUE;
9814         }
9815     }
9816
9817   return FALSE;
9818 }
9819
9820 bool
9821 exprNode_matchLiteral (ctype expected, exprNode e)
9822 {
9823   if (exprNode_isDefined (e))
9824     {
9825       multiVal m = exprNode_getValue (e);
9826
9827       if (multiVal_isDefined (m))
9828         {
9829           if (multiVal_isInt (m))
9830             {
9831               long int val = multiVal_forceInt (m);
9832
9833               if (ctype_isNumAbstract (expected)
9834                   && context_flagOn (FLG_NUMABSTRACTLIT, exprNode_loc (e)))
9835                 {
9836                   return TRUE;
9837                 }
9838
9839               if (ctype_isDirectBool (ctype_realishType (expected)))
9840                 {
9841                   if (val == 0)
9842                     {
9843                       return FALSE; /* really?! return TRUE; allow use of 0 for FALSE */
9844                     }
9845                   else
9846                     {
9847                       return FALSE;
9848                     }
9849                 }
9850
9851               if (ctype_isRealInt (expected))
9852                 {
9853                   /*
9854                   ** unsigned <- [ constant >= 0 is okay ]
9855                   */
9856
9857                   if (ctype_isUnsigned (expected))
9858                     {
9859                       if (val < 0)
9860                         {
9861                           return FALSE;
9862                         }
9863                     }
9864
9865                   /*
9866                   ** No checks on sizes of integers...maybe add
9867                   ** these later.
9868                   */
9869
9870                   DPRINTF (("Here: %s => %s", exprNode_unparse (e), ctype_unparse (expected)));
9871                   DPRINTF (("Type: %s / %s", ctype_unparse (exprNode_getType (e)),
9872                             bool_unparse (ctype_isInt (exprNode_getType (e)))));
9873
9874                   if (context_getFlag (FLG_NUMLITERAL)
9875                       && (ctype_isRegularInt (exprNode_getType (e)) || val == 0)) {
9876                     return TRUE;
9877                   } else {
9878                     if (val == 0) {
9879                       return TRUE;
9880                     } else {
9881                       return FALSE; /* evs 2000-05-17: previously, always returned TRUE */
9882                     }
9883                   }
9884                 }
9885               else if (ctype_isChar (expected))
9886                 {
9887                   return FALSE;
9888                 }
9889               else if (ctype_isArrayPtr (expected))
9890                 {
9891                   /*
9892                   ** evans 2001-10-14: We allow 0 to match any pointer, but only if the type matches or is void *.
9893                   */
9894
9895                   if (val == 0)
9896                     {
9897                       if (ctype_match (exprNode_getType (e), expected)
9898                           || ctype_isVoidPointer (exprNode_getType (e)))
9899                         {
9900                           return TRUE;
9901                         }
9902                     }
9903                   else
9904                     {
9905                       return FALSE;
9906                     }
9907                 }
9908               else if (ctype_isAnyFloat (expected))
9909                 {
9910                   return (context_getFlag (FLG_NUMLITERAL));
9911                 }
9912               else
9913                 {
9914                   return FALSE;
9915                 }
9916             }
9917           else if (multiVal_isDouble (m))
9918             {
9919               if (ctype_isAnyFloat (expected))
9920                 {
9921                   return TRUE;
9922                 }
9923             }
9924           else if (multiVal_isChar (m))
9925             {
9926               char val = multiVal_forceChar (m);
9927
9928               if (ctype_isChar (expected))
9929                 {
9930                   if (ctype_isUnsigned (expected) && ((int)val) < 0)
9931                     {
9932                       return FALSE;
9933                     }
9934                   else
9935                     {
9936                       return TRUE;
9937                     }
9938                 }
9939             }
9940           else
9941             {
9942               return FALSE;
9943             }
9944         }
9945     }
9946
9947   return FALSE;
9948 }
9949
9950 bool
9951 exprNode_matchType (ctype expected, exprNode e)
9952 {
9953   ctype actual;
9954
9955   if (!exprNode_isDefined (e)) return TRUE;
9956
9957   actual = ctype_realishType (exprNode_getType (e));
9958
9959   if (ctype_match (ctype_realishType (expected), actual))
9960     {
9961       return TRUE;
9962     }
9963
9964   llassert (!exprNode_isError (e));
9965   return (exprNode_matchLiteral (expected, e));
9966 }
9967
9968 static bool
9969 exprNode_matchTypes (exprNode e1, exprNode e2)
9970 {
9971   ctype t1;
9972   ctype t2;
9973
9974   if (!exprNode_isDefined (e1)) return TRUE;
9975   if (!exprNode_isDefined (e2)) return TRUE;
9976
9977   /*
9978   ** realish type --- keep bools, bools
9979   */
9980
9981   t1 = ctype_realishType (exprNode_getType (e1));
9982   t2 = ctype_realishType (exprNode_getType (e2));
9983
9984   if (ctype_match (t1, t2))
9985     {
9986       return TRUE;
9987     }
9988
9989   DPRINTF (("Matching literal! %s %s %s %s",
9990             ctype_unparse (t1), exprNode_unparse (e2),
9991             ctype_unparse (t2), exprNode_unparse (e1)));
9992
9993   return (exprNode_matchLiteral (t1, e2) || exprNode_matchLiteral (t2, e1));
9994 }
9995
9996 /*
9997 ** pass e as ct
9998 */
9999
10000 static bool
10001   exprNode_matchArgType (ctype ct, exprNode e)
10002 {
10003   ctype et;
10004
10005   if (!exprNode_isDefined (e))
10006     {
10007       return TRUE;
10008     }
10009
10010   et = ctype_realType (exprNode_getType (e));
10011
10012   if (ctype_matchArg (ct, et)) return TRUE;
10013
10014   llassert (!exprNode_isError (e));
10015   return (exprNode_matchLiteral (ct, e));
10016 }
10017
10018 static /*@only@*/ exprNodeSList
10019   exprNode_flatten (/*@dependent@*/ exprNode e) /*@*/
10020 {
10021   if (exprNode_isDefined (e))
10022     {
10023       if (e->kind == XPR_STMTLIST)
10024         {
10025           return (exprNodeSList_append
10026                   (exprNode_flatten (exprData_getPairA (e->edata)),
10027                    exprNode_flatten (exprData_getPairB (e->edata))));
10028         }
10029       else if (e->kind == XPR_BLOCK)
10030         {
10031           return (exprNode_flatten (exprData_getSingle (e->edata)));
10032         }
10033       else
10034         {
10035           return (exprNodeSList_singleton (e));
10036         }
10037     }
10038
10039   return exprNodeSList_new ();
10040 }
10041
10042 static /*@exposed@*/ exprNode
10043 exprNode_lastStatement (/*@returned@*/ exprNode e)
10044 {
10045   if (exprNode_isDefined (e))
10046     {
10047       if (e->kind == XPR_STMTLIST)
10048         {
10049           exprNode b = exprData_getPairB (e->edata);
10050
10051           if (exprNode_isDefined (b))
10052             {
10053               return exprNode_lastStatement (b);
10054             }
10055           else
10056             {
10057               return exprNode_lastStatement (exprData_getPairA (e->edata));
10058             }
10059         }
10060       else if (e->kind == XPR_BLOCK)
10061         {
10062           return (exprNode_lastStatement (exprData_getSingle (e->edata)));
10063         }
10064       else
10065         {
10066           return (e);
10067         }
10068     }
10069
10070   return exprNode_undefined;
10071 }
10072
10073 static /*@exposed@*/ exprNode
10074 exprNode_firstStatement (/*@returned@*/ exprNode e)
10075 {
10076   if (exprNode_isDefined (e))
10077     {
10078       if (e->kind == XPR_STMTLIST)
10079         {
10080           exprNode b = exprData_getPairA (e->edata);
10081
10082           if (exprNode_isDefined (b))
10083             {
10084               return exprNode_firstStatement (b);
10085             }
10086           else
10087             {
10088               return exprNode_firstStatement (exprData_getPairB (e->edata));
10089             }
10090         }
10091       else if (e->kind == XPR_BLOCK)
10092         {
10093           return (exprNode_firstStatement (exprData_getSingle (e->edata)));
10094         }
10095       else
10096         {
10097           return (e);
10098         }
10099     }
10100
10101   return exprNode_undefined;
10102 }
10103
10104 static void
10105 exprNode_mergeUSs (exprNode res, exprNode other)
10106 {
10107   if (exprNode_isDefined (res) && exprNode_isDefined (other))
10108     {
10109       res->msets = sRefSet_union (res->msets, other->msets);
10110       res->sets = sRefSet_union (res->sets, other->sets);
10111       res->uses = sRefSet_union (res->uses, other->uses);
10112     }
10113 }
10114
10115 static void
10116 exprNode_mergeCondUSs (exprNode res, exprNode other1, exprNode other2)
10117 {
10118   if (exprNode_isDefined (res))
10119     {
10120       if (exprNode_isDefined (other1))
10121         {
10122           res->sets = sRefSet_union (res->sets, other1->sets);
10123           res->msets = sRefSet_union (res->msets, other1->msets);
10124           res->uses = sRefSet_union (res->uses, other1->uses);
10125         }
10126       if (exprNode_isDefined (other2))
10127         {
10128           res->sets = sRefSet_union (res->sets, other2->sets);
10129           res->msets = sRefSet_union (res->msets, other2->msets);
10130           res->uses = sRefSet_union (res->uses, other2->uses);
10131         }
10132     }
10133 }
10134
10135 /*
10136 ** modifies e->uses
10137 **
10138 ** Reports errors is s is not defined.
10139 */
10140
10141 static void
10142 exprNode_addUse (exprNode e, /*@exposed@*/ sRef s)
10143 {
10144   if (exprNode_isDefined (e))
10145     {
10146       e->uses = sRefSet_insert (e->uses, s);
10147     }
10148 }
10149
10150 void
10151 exprNode_checkUse (exprNode e, /*@exposed@*/ sRef s, fileloc loc)
10152 {
10153   if (sRef_isKnown (s) && !sRef_isConst (s))
10154     {
10155       /*
10156       ** need to check all outer types are useable
10157       */
10158
10159       DPRINTF (("Check use: %s / %s",
10160                 exprNode_unparse (e), sRef_unparse (s)));
10161
10162       exprNode_addUse (e, s);
10163
10164       if (!context_inProtectVars ())
10165         {
10166           /*
10167           ** only report the deepest error
10168           */
10169
10170           sRef errorRef = sRef_undefined;
10171           sRef lastRef  = sRef_undefined;
10172           bool deadRef = FALSE;
10173           bool unuseable = FALSE;
10174           bool errorMaybe = FALSE;
10175
10176           while (sRef_isValid (s) && sRef_isKnown (s))
10177             {
10178               ynm readable = sRef_isValidLvalue (s);
10179
10180               DPRINTF (("Readable: %s / %s",
10181                         sRef_unparseFull (s), ynm_unparse (readable)));
10182
10183               if (!(ynm_toBoolStrict (readable)))
10184                 {
10185                   if (ynm_isMaybe (readable))
10186                     {
10187                       lastRef = errorRef;
10188                       errorRef = s;
10189                       DPRINTF (("Setting ERROR: %s", sRef_unparseFull (s)));
10190                       deadRef = sRef_isPossiblyDead (errorRef);
10191                       unuseable = sRef_isUnuseable (errorRef);
10192                       errorMaybe = TRUE;
10193                     }
10194                   else
10195                     {
10196                       lastRef = errorRef;
10197                       errorRef = s;
10198                       DPRINTF (("Setting ERROR: %s", sRef_unparseFull (s)));
10199                       deadRef = sRef_isDead (errorRef);
10200                       unuseable = sRef_isUnuseable (errorRef);
10201                       errorMaybe = FALSE;
10202                     }
10203
10204                   /*
10205                   if (!sRef_isPartial (s))
10206                     {
10207                       DPRINTF (("Defining! %s", sRef_unparseFull (s)));
10208                       sRef_setDefined (s, loc);
10209                       DPRINTF (("Defining! %s", sRef_unparseFull (s)));
10210                     }
10211                   */
10212                 }
10213
10214               s = sRef_getBaseSafe (s);
10215             } /* end while */
10216
10217           if (sRef_isValid (errorRef))
10218             {
10219               if (sRef_isValid (lastRef) && sRef_isField (lastRef)
10220                   && sRef_isPointer (errorRef))
10221                 {
10222                   errorRef = lastRef;
10223                   DPRINTF (("errorRef: %s", sRef_unparseFull (errorRef)));
10224                 }
10225
10226               if (deadRef)
10227                 {
10228                   if (sRef_isThroughArrayFetch (errorRef))
10229                     {
10230                       if (optgenerror
10231                           (FLG_STRICTUSERELEASED,
10232                            message ("%q %q may be used after being released",
10233                                     sRef_unparseKindNamePlain (errorRef),
10234                                     sRef_unparse (errorRef)),
10235                            loc))
10236                         {
10237                           sRef_showRefKilled (errorRef);
10238
10239                           if (sRef_isKept (errorRef))
10240                             {
10241                               sRef_clearAliasState (errorRef, loc);
10242                             }
10243                         }
10244                     }
10245                   else
10246                     {
10247                       DPRINTF (("HERE: %s", sRef_unparseFull (errorRef)));
10248
10249                       if (optgenerror
10250                           (FLG_USERELEASED,
10251                            message ("%q %q %qused after being released",
10252                                     sRef_unparseKindNamePlain (errorRef),
10253                                     sRef_unparse (errorRef),
10254                                     cstring_makeLiteral (errorMaybe
10255                                                          ? "may be " : "")),
10256                            loc))
10257                         {
10258                           sRef_showRefKilled (errorRef);
10259
10260                           if (sRef_isKept (errorRef))
10261                             {
10262                               sRef_clearAliasState (errorRef, loc);
10263                             }
10264                         }
10265                     }
10266                 }
10267               else if (unuseable)
10268                 {
10269                   if (optgenerror
10270                       (FLG_USEDEF,
10271                        message ("%q %q%qused in inconsistent state",
10272                                 sRef_unparseKindName (errorRef),
10273                                 sRef_unparseOpt (errorRef),
10274                                 cstring_makeLiteral (errorMaybe ? "may be " : "")),
10275                        loc))
10276                     {
10277                       sRef_showStateInconsistent (errorRef);
10278                     }
10279                 }
10280               else
10281                 {
10282                   DPRINTF (("HERE: %s", sRef_unparseFull (errorRef)));
10283
10284                   if (optgenerror
10285                       (FLG_USEDEF,
10286                        message ("%q %q%qused before definition",
10287                                 sRef_unparseKindName (errorRef),
10288                                 sRef_unparseOpt (errorRef),
10289                                 cstring_makeLiteral (errorMaybe ? "may be " : "")),
10290                        loc))
10291                     {
10292                       ;
10293                     }
10294
10295                   DPRINTF (("Error: %s", sRef_unparseFull (errorRef)));
10296                 }
10297
10298               sRef_setDefined (errorRef, loc);
10299
10300               if (sRef_isAddress (errorRef))
10301                 {
10302                   sRef_setDefined (sRef_getRootBase (errorRef), loc);
10303                 }
10304             } /* end is error */
10305         }
10306     }
10307
10308   setCodePoint ();
10309 }
10310
10311 static void
10312 checkSafeUse (exprNode e, /*@exposed@*/ sRef s)
10313 {
10314   if (exprNode_isDefined (e) && sRef_isKnown (s))
10315     {
10316       e->uses = sRefSet_insert (e->uses, s);
10317     }
10318 }
10319
10320 static void
10321 exprNode_checkSetAny (exprNode e, /*@dependent@*/ cstring name)
10322 {
10323   if (exprNode_isDefined (e))
10324     {
10325       e->sets = sRefSet_insert (e->sets, sRef_makeUnconstrained (name));
10326     }
10327 }
10328
10329 void
10330 exprNode_checkSet (exprNode e, /*@exposed@*/ sRef s)
10331 {
10332   sRef defines = sRef_undefined;
10333
10334   if (sRef_isValid (s) && !sRef_isNothing (s))
10335     {
10336       uentry ue = sRef_getBaseUentry (s);
10337
10338       if (uentry_isValid (ue))
10339         {
10340           uentry_setLset (ue);
10341         }
10342
10343       if (!ynm_toBoolStrict (sRef_isWriteable (s)))
10344         {
10345           voptgenerror (FLG_USEDEF,
10346                         message ("Attempt to set unuseable storage: %q",
10347                                  sRef_unparse (s)),
10348                         exprNode_loc (e));
10349         }
10350
10351       if (sRef_isMeaningful (s))
10352         {
10353           if (sRef_isDead (s))
10354             {
10355               sRef base = sRef_getBaseSafe (s);
10356
10357               if (sRef_isValid (base)
10358                   && sRef_isDead (base))
10359                 {
10360                   sRef_setPartial (s, exprNode_loc (e));
10361                 }
10362
10363               defines = s; /* okay - modifies for only param */
10364             }
10365           else if (sRef_isPartial (s))
10366             {
10367               sRef eref = exprNode_getSref (e);
10368
10369               if (!sRef_isPartial (eref))
10370                 {
10371                   /*
10372                   ** should do something different here???
10373                   */
10374
10375                   sRef_setDefinedComplete (eref, exprNode_loc (e));
10376                 }
10377               else
10378                 {
10379                   sRef_setPartialDefinedComplete (eref, exprNode_loc (e));
10380                 }
10381
10382               if (sRef_isMeaningful (eref))
10383                 {
10384                   defines = eref;
10385                 }
10386               else
10387                 {
10388                   defines = s;
10389                 }
10390             }
10391           else if (sRef_isAllocated (s))
10392             {
10393               sRef eref = exprNode_getSref (e);
10394
10395
10396               if (!sRef_isAllocated (eref))
10397                 {
10398                   sRef_setDefinedComplete (eref, exprNode_loc (e));
10399                 }
10400               else
10401                 {
10402                   sRef base = sRef_getBaseSafe (eref);
10403
10404                   if (sRef_isValid (base))
10405                     {
10406                       sRef_setPdefined (base, exprNode_loc (e));
10407                     }
10408                 }
10409
10410               defines = s;
10411             }
10412           else
10413             {
10414               sRef_setDefinedNCComplete (s, exprNode_loc (e));
10415               defines = s;
10416             }
10417
10418         }
10419       else /* not meaningful...but still need to insert it */
10420         {
10421           defines = s;
10422         }
10423     }
10424
10425   if (exprNode_isDefined (e) && sRef_isValid (defines))
10426     {
10427       e->sets = sRefSet_insert (e->sets, defines);
10428     }
10429 }
10430
10431 void
10432 exprNode_checkMSet (exprNode e, /*@exposed@*/ sRef s)
10433 {
10434   if (sRef_isValid (s) && !sRef_isNothing (s))
10435     {
10436       uentry ue = sRef_getBaseUentry (s);
10437
10438       if (uentry_isValid (ue))
10439         {
10440           uentry_setLset (ue);
10441         }
10442
10443       if (!ynm_toBoolStrict (sRef_isWriteable (s)))
10444         {
10445           voptgenerror (FLG_USEDEF,
10446                         message ("Attempt to set unuseable storage: %q", sRef_unparse (s)),
10447                         exprNode_loc (e));
10448         }
10449
10450       if (sRef_isMeaningful (s))
10451         {
10452           sRef_setDefinedComplete (s, exprNode_loc (e));
10453         }
10454
10455       if (exprNode_isDefined (e))
10456         {
10457           e->msets = sRefSet_insert (e->msets, s);
10458         }
10459     }
10460 }
10461
10462 static void
10463 checkUnspecCall (/*@notnull@*/ /*@dependent@*/ exprNode fcn, uentryList params, exprNodeList args)
10464 {
10465   checkAnyCall (fcn, cstring_undefined, params, args,
10466                 FALSE, sRefSet_undefined, FALSE, 0);
10467 }
10468
10469 static void
10470 checkOneArg (uentry ucurrent, /*@notnull@*/ exprNode current,
10471              /*@dependent@*/ exprNode fcn, bool isSpec, int argno, int totargs)
10472 {
10473   setCodePoint ();
10474
10475   if (uentry_isYield (ucurrent))
10476     {
10477       sRef_setDefined (exprNode_getSref (current), exprNode_loc (current));
10478       exprNode_checkSet (current, current->sref);
10479     }
10480   else
10481     {
10482       if (uentry_isSefParam (ucurrent))
10483         {
10484           sRefSet sets = current->sets;
10485           sRef ref = exprNode_getSref (current);
10486
10487           if (sRef_isMacroParamRef (ref))
10488             {
10489               uentry ue = sRef_getUentry (ref);
10490
10491               if (!uentry_isSefParam (ue))
10492                 {
10493                   voptgenerror
10494                     (FLG_SEFPARAMS,
10495                      message
10496                      ("Parameter %d to %s is declared sef, but "
10497                       "the argument is a macro parameter declared "
10498                       "without sef: %s",
10499                       argno, exprNode_unparse (fcn),
10500                       exprNode_unparse (current)),
10501                      exprNode_loc (current));
10502                 }
10503             }
10504
10505           if (!sRefSet_isEmpty (sets))
10506             {
10507               sRefSet reported = sRefSet_undefined;
10508
10509               sRefSet_realElements (current->sets, el)
10510                 {
10511                   if (sRefSet_isSameNameMember (reported, el))
10512                     {
10513                       ; /* don't report again */
10514                     }
10515                   else
10516                     {
10517                       if (sRef_isUnconstrained (el))
10518                         {
10519                           voptgenerror
10520                             (FLG_SEFUNSPEC,
10521                              message
10522                              ("Parameter %d to %s is declared sef, but "
10523                               "the argument calls unconstrained function %s "
10524                               "(no guarantee it will not modify something): %s",
10525                               argno, exprNode_unparse (fcn),
10526                               sRef_unconstrainedName (el),
10527                               exprNode_unparse (current)),
10528                              exprNode_loc (current));
10529                         }
10530                       else
10531                         {
10532                           voptgenerror
10533                             (FLG_SEFPARAMS,
10534                              message
10535                              ("Parameter %d to %s is declared sef, but "
10536                               "the argument may modify %q: %s",
10537                               argno, exprNode_unparse (fcn),
10538                               sRef_unparse (el),
10539                               exprNode_unparse (current)),
10540                              exprNode_loc (current));
10541                         }
10542                     }
10543                 } end_sRefSet_realElements;
10544             }
10545         }
10546
10547       transferChecks_passParam (current, ucurrent, isSpec, fcn, argno, totargs);
10548       exprNode_mergeUSs (fcn, current);
10549     }
10550 }
10551
10552 static void
10553   checkAnyCall (/*@dependent@*/ exprNode fcn,
10554                 /*@dependent@*/ cstring fname,
10555                 uentryList pn,
10556                 exprNodeList args,
10557                 bool hasMods, sRefSet mods,
10558                 bool isSpec,
10559                 int specialArgs)
10560 {
10561   int paramno = 0;
10562   int nargs = exprNodeList_size (args);
10563
10564   setCodePoint ();
10565
10566   /*
10567   ** concat all args ud's to f, add each arg sref as a use unless
10568   ** it was specified as "out", in which case it is a def.
10569   */
10570
10571   uentryList_reset (pn);
10572
10573   /*
10574   ** aliasing checks:
10575   **
10576   **    if paramn is only or unique, no other arg may alias argn
10577   */
10578
10579   exprNodeList_elements (args, current)
10580     {
10581       paramno++;
10582
10583       if (exprNode_isDefined (current))
10584         {
10585           if ((!uentryList_isUndefined (pn) && !uentryList_isFinished (pn)))
10586             {
10587               uentry ucurrent = uentryList_current (pn);
10588
10589               if (specialArgs == 0
10590                   || (paramno < specialArgs))
10591                 {
10592                   checkOneArg (ucurrent, current, fcn, isSpec, paramno, nargs);
10593
10594                   if (context_maybeSet (FLG_ALIASUNIQUE))
10595                     {
10596                       if (uentry_isOnly (ucurrent)
10597                           || uentry_isUnique (ucurrent))
10598                         {
10599                           checkUniqueParams (fcn, current, args,
10600                                              paramno, ucurrent);
10601                         }
10602                     }
10603                 }
10604             }
10605           else /* uentry is undefined */
10606             {
10607               if (specialArgs == 0)
10608                 {
10609                   exprNode_checkUseParam (current);
10610                 }
10611
10612               exprNode_mergeUSs (fcn, current);
10613             }
10614         }
10615       uentryList_advanceSafe (pn);
10616     } end_exprNodeList_elements;
10617
10618   if (hasMods)
10619     {
10620       setCodePoint ();
10621
10622       sRefSet_allElements (mods, s)
10623         {
10624           sRef fb;
10625           sRef rb = sRef_getRootBase (s);
10626
10627           if (sRef_isFileOrGlobalScope (rb))
10628             {
10629               context_usedGlobal (rb);
10630             }
10631
10632           fb = sRef_fixBaseParam (s, args);
10633
10634           if (!sRef_isMacroParamRef (fb))
10635             {
10636               if (sRef_isNothing (fb))
10637                 {
10638                   ;
10639                 }
10640               else
10641                 {
10642                   if (sRef_isValid (fb))
10643                     {
10644                       uentry ue = sRef_getBaseUentry (s);
10645
10646                       if (uentry_isValid (ue))
10647                         {
10648                           uentry_setLset (ue);
10649                         }
10650                     }
10651
10652                   fcn->sets = sRefSet_insert (fcn->sets, fb);
10653                 }
10654             }
10655           sRef_clearDerivedComplete (s);
10656         } end_sRefSet_allElements;
10657
10658       setCodePoint ();
10659     }
10660   else
10661     {
10662       if (context_hasMods ())
10663         {
10664           if (context_maybeSet (FLG_MODUNCON))
10665             {
10666               voptgenerror
10667                 (FLG_MODUNCON,
10668                  message ("Undetected modification possible "
10669                           "from call to unconstrained function %s: %s",
10670                           fname,
10671                           exprNode_unparse (fcn)),
10672                  exprNode_loc (fcn));
10673             }
10674         }
10675       else
10676         {
10677           if (context_maybeSet (FLG_MODUNCONNOMODS)
10678               && !(context_inIterDef () || context_inIterEnd ()))
10679             {
10680               voptgenerror
10681                 (FLG_MODUNCONNOMODS,
10682                  message ("Undetected modification possible "
10683                           "from call to unconstrained function %s: %s",
10684                           fname,
10685                           exprNode_unparse (fcn)),
10686                  exprNode_loc (fcn));
10687             }
10688         }
10689
10690       exprNode_checkSetAny (fcn, fname);
10691     }
10692 }
10693
10694 void exprNode_checkUseParam (exprNode current)
10695 {
10696   if (exprNode_isDefined (current))
10697     {
10698       exprNode_checkUse (current, current->sref, current->loc);
10699     }
10700 }
10701
10702 static ctype
10703   checkNumerics (ctype tr1, ctype tr2, ctype te1, ctype te2,
10704                  /*@notnull@*/ exprNode e1, /*@notnull@*/ exprNode e2,
10705                  lltok op)
10706 {
10707   ctype ret = tr1;
10708
10709   if (!ctype_match (tr1, tr2))
10710     {
10711       if ((ctype_isRealInt (tr1) || ctype_isReal (tr1)) &&
10712           (ctype_isRealInt (tr2) || ctype_isReal (tr2)))
10713         {
10714           DPRINTF (("No error: [%s] %s / [%s]  %s",
10715                     exprNode_unparse (e1), ctype_unparse (tr1),
10716                     exprNode_unparse (e2), ctype_unparse (tr2)));
10717
10718           ret = ctype_biggerType (tr1, tr2);
10719         }
10720       else
10721         {
10722           if (ctype_isNumAbstract (tr1)
10723               && exprNode_isNumLiteral (e2)
10724               && context_flagOn (FLG_NUMABSTRACTLIT, e1->loc))
10725             {
10726               ret = tr1; /* No error */
10727             }
10728           else if (ctype_isNumAbstract (tr2)
10729                    && exprNode_isNumLiteral (e1)
10730                    && context_flagOn (FLG_NUMABSTRACTLIT, e1->loc))
10731             {
10732               ret = tr2;
10733             }
10734           else
10735             {
10736               if (gentypeerror
10737                   (tr1, e1, tr2, e2,
10738                    message ("Incompatible types for %s (%s, %s): %s %s %s",
10739                             lltok_unparse (op),
10740                             ctype_unparse (te1),
10741                             ctype_unparse (te2),
10742                             exprNode_unparse (e1), lltok_unparse (op),
10743                             exprNode_unparse (e2)),
10744                    e1->loc))
10745                 {
10746                   ret = ctype_unknown;
10747                 }
10748               else
10749                 {
10750                   ret = ctype_biggerType (tr1, tr2);
10751                 }
10752             }
10753         }
10754     }
10755   else
10756     {
10757       if (ctype_isNumAbstract (tr1))
10758         {
10759           ret = tr1;
10760         }
10761       else if (ctype_isForceRealNumeric (&tr1)
10762                && ctype_isForceRealNumeric (&tr2))
10763         {
10764           ret = ctype_resolveNumerics (tr1, tr2);
10765         }
10766       else if (!context_msgStrictOps ())
10767         {
10768           if (ctype_isPointer (tr1))
10769             {
10770               if (ctype_isPointer (tr2) && !exprNode_isNullValue (e2))
10771                 {
10772                   ret = ctype_int;
10773                 }
10774               else if (ctype_isInt (tr2))
10775                 {
10776                   ret = te1;
10777                 }
10778               else
10779                 {
10780                   ret = ctype_unknown;
10781                 }
10782             }
10783           else if (ctype_isPointer (tr2))
10784             {
10785               if (ctype_isPointer (tr1))
10786                 {
10787                   ret = ctype_int;
10788                 }
10789               else if (ctype_isInt (tr1))
10790                 {
10791                   ret = te2;
10792                 }
10793               else
10794                 {
10795                   ret = ctype_unknown;
10796                 }
10797             }
10798           else
10799             {
10800               ret = ctype_resolveNumerics (tr1, tr2);
10801             }
10802         }
10803       else
10804         {
10805           int opid = lltok_getTok (op);
10806           bool comparop = (opid == EQ_OP || opid == NE_OP
10807                            || opid == TLT || opid == TGT
10808                            || opid == LE_OP || opid == GE_OP);
10809
10810           if (!ctype_isNumeric (tr1) && !ctype_isNumeric (tr2))
10811             {
10812               if (comparop
10813                   && ((ctype_isEnum (tr1) && ctype_isEnum (tr2))
10814                       || (ctype_isBool (tr1) && ctype_isBool (tr2))
10815                       || (ctype_isChar (tr1) && ctype_isChar (tr2))))
10816                 {
10817                   ; /* no error */
10818                 }
10819               else
10820                 {
10821                   if (ctype_sameName (te1, te2))
10822                     {
10823                       voptgenerror
10824                         (FLG_STRICTOPS,
10825                          message ("Operands of %s are non-numeric (%t): %s %s %s",
10826                                   lltok_unparse (op), te1,
10827                                   exprNode_unparse (e1), lltok_unparse (op),
10828                                   exprNode_unparse (e2)),
10829                          e1->loc);
10830                     }
10831                   else
10832                     {
10833                       voptgenerror
10834                         (FLG_STRICTOPS,
10835                          message ("Operands of %s are non-numerics (%t, %t): %s %s %s",
10836                                   lltok_unparse (op), te1, te2,
10837                                   exprNode_unparse (e1), lltok_unparse (op),
10838                                   exprNode_unparse (e2)),
10839                          e1->loc);
10840                     }
10841                 }
10842             }
10843           else if (!ctype_isNumeric (tr1))
10844             {
10845               voptgenerror
10846                 (FLG_STRICTOPS,
10847                  message ("Right operand of %s is non-numeric (%t): %s %s %s",
10848                           lltok_unparse (op), te1,
10849                           exprNode_unparse (e1), lltok_unparse (op),
10850                           exprNode_unparse (e2)),
10851                  e1->loc);
10852             }
10853           else
10854             {
10855               if (!ctype_isNumeric (tr2))
10856                 {
10857                   voptgenerror
10858                     (FLG_STRICTOPS,
10859                      message ("Left operand of %s is non-numeric (%t): %s %s %s",
10860                               lltok_unparse (op), te2,
10861                               exprNode_unparse (e1), lltok_unparse (op),
10862                               exprNode_unparse (e2)),
10863                      e2->loc);
10864                 }
10865             }
10866
10867           ret = ctype_unknown;
10868         }
10869     }
10870
10871   return ret;
10872 }
10873
10874 static bool
10875 abstractOpError (ctype tr1, ctype tr2, lltok op,
10876                  /*@notnull@*/ exprNode e1, /*@notnull@*/ exprNode e2,
10877                  fileloc loc1, fileloc loc2)
10878 {
10879   if (ctype_isRealAbstract (tr1) && ctype_isRealAbstract (tr2))
10880     {
10881       if (ctype_match (tr1, tr2))
10882         {
10883           if (ctype_isRealNumAbstract (tr1))
10884             {
10885               ; /* No warning for numabstract types */
10886             }
10887           else
10888             {
10889               if (lltok_isEqOp (op) || lltok_isNotEqOp (op))
10890                 {
10891                   return optgenerror
10892                     (FLG_ABSTRACTCOMPARE,
10893                      message ("Object equality comparison (%s) on objects of abstract type (%t): %s %s %s",
10894                               lltok_unparse (op), tr1,
10895                               exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
10896                      loc1);
10897                 }
10898               else
10899                 {
10900                   return optgenerror
10901                     (FLG_ABSTRACT,
10902                      message ("Operands of %s are abstract type (%t): %s %s %s",
10903                               lltok_unparse (op), tr1,
10904                               exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
10905                      loc1);
10906                 }
10907             }
10908         }
10909       else
10910         {
10911           if (ctype_isRealNumAbstract (tr1) && ctype_isRealNumAbstract (tr2))
10912             {
10913               return optgenerror
10914                 (FLG_NUMABSTRACT,
10915                  message
10916                  ("Operands of %s are different numabstract types (%t, %t): %s %s %s",
10917                   lltok_unparse (op), tr1, tr2,
10918                   exprNode_unparse (e1),
10919                   lltok_unparse (op), exprNode_unparse (e2)),
10920                  loc1);
10921             }
10922           else
10923             {
10924               return optgenerror
10925                 (FLG_ABSTRACT,
10926                  message ("Operands of %s are abstract types (%t, %t): %s %s %s",
10927                           lltok_unparse (op), tr1, tr2,
10928                           exprNode_unparse (e1), lltok_unparse (op),
10929                           exprNode_unparse (e2)),
10930                  loc1);
10931             }
10932         }
10933     }
10934   else if (ctype_isRealAbstract (tr1) && !ctype_isRealNumAbstract (tr1))
10935     {
10936       return optgenerror
10937         (FLG_ABSTRACT,
10938          message ("Left operand of %s is abstract type (%t): %s %s %s",
10939                   lltok_unparse (op), tr1,
10940                   exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
10941          loc1);
10942     }
10943   else
10944     {
10945       if (ctype_isRealAbstract (tr2) && !ctype_isRealNumAbstract (tr2))
10946         {
10947           return optgenerror
10948             (FLG_ABSTRACT,
10949              message ("Right operand of %s is abstract type (%t): %s %s %s",
10950                       lltok_unparse (op), tr2,
10951                       exprNode_unparse (e1), lltok_unparse (op), exprNode_unparse (e2)),
10952              loc2);
10953         }
10954     }
10955
10956   return FALSE;
10957 }
10958
10959 /*
10960 ** e1 <= e2
10961 **
10962 ** requies e1 and e2 and not error exprNode's.
10963 **
10964 ** Checks:
10965 **
10966 **    If e1 is a component of an abstract type, and e2 is mutable and client-visible,
10967 **    the rep of the abstract type is exposed.
10968 **
10969 ** The order is very important:
10970 **
10971 **    check rep expose (move into check transfer)
10972 **    check transfer
10973 **    setup aliases
10974 */
10975
10976 /*
10977 ** This isn't really a sensible procedure, but the indententation
10978 ** was getting too deep.
10979 */
10980
10981 static void
10982 checkOneRepExpose (sRef ysr, sRef base,
10983                    /*@notnull@*/ exprNode e1,
10984                    /*@notnull@*/ exprNode e2, ctype ct,
10985                    sRef s2b)
10986 {
10987   if (!(sRef_isOnly (ysr) || sRef_isKeep (ysr)
10988         || sRef_isOwned (ysr)
10989         || sRef_isExposed (ysr)))
10990     {
10991       if (sRef_isAnyParam (base) && !sRef_isExposed (base)
10992           && !sRef_isObserver (base)) /* evans 2001-07-11: added isObserver */
10993
10994         {
10995           if (sRef_isIReference (ysr))
10996             {
10997               if (sRef_sameName (base, sRef_getRootBase (e2->sref)))
10998                 {
10999                   voptgenerror
11000                     (FLG_ASSIGNEXPOSE,
11001                      message
11002                      ("Assignment of mutable component of parameter %q "
11003                       "to component of abstract "
11004                       "type %s exposes rep: %s = %s",
11005                       sRef_unparse (base),
11006                       ctype_unparse (ct),
11007                       exprNode_unparse (e1), exprNode_unparse (e2)),
11008                      e1->loc);
11009                 }
11010               else
11011                 {
11012                   voptgenerror
11013                     (FLG_ASSIGNEXPOSE,
11014                      message
11015                      ("Assignment of mutable component of parameter %q "
11016                       "(through alias %q) to component of abstract "
11017                       "type %s exposes rep: %s = %s",
11018                       sRef_unparse (base),
11019                       sRef_unparse (e2->sref),
11020                       ctype_unparse (ct),
11021                       exprNode_unparse (e1), exprNode_unparse (e2)),
11022                      e1->loc);
11023                 }
11024             }
11025           else
11026             {
11027               if (sRef_sameName (base, sRef_getRootBase (e2->sref)))
11028                 {
11029                   voptgenerror
11030                     (FLG_ASSIGNEXPOSE,
11031                      message ("Assignment of mutable parameter %q "
11032                               "to component of abstract type %s "
11033                               "exposes rep: %s = %s",
11034                               sRef_unparse (base),
11035                               ctype_unparse (ct),
11036                               exprNode_unparse (e1),
11037                               exprNode_unparse (e2)),
11038                      e1->loc);
11039                 }
11040               else
11041                 {
11042                   voptgenerror
11043                     (FLG_ASSIGNEXPOSE,
11044                      message ("Assignment of mutable parameter %q "
11045                               "(through alias %q) to "
11046                               "component of abstract type %s exposes "
11047                               "rep: %s = %s",
11048                               sRef_unparse (base),
11049                               sRef_unparse (e2->sref),
11050                               ctype_unparse (ct),
11051                               exprNode_unparse (e1),
11052                               exprNode_unparse (e2)),
11053                      e1->loc);
11054                 }
11055             }
11056         }
11057
11058       if (sRef_isFileOrGlobalScope (s2b))
11059         {
11060           if (sRef_sameName (base, sRef_getRootBase (e2->sref)))
11061             {
11062               voptgenerror
11063                 (FLG_REPEXPOSE,
11064                  message ("Assignment of global %q "
11065                           "to component of "
11066                           "abstract type %s exposes rep: %s = %s",
11067                           sRef_unparse (base),
11068                           ctype_unparse (ct),
11069                           exprNode_unparse (e1), exprNode_unparse (e2)),
11070                  e1->loc);
11071             }
11072           else
11073             {
11074               voptgenerror
11075                 (FLG_REPEXPOSE,
11076                  message ("Assignment of global %q (through alias %q) "
11077                           "to component of "
11078                           "abstract type %s exposes rep: %s = %s",
11079                           sRef_unparse (base),
11080                           sRef_unparse (e2->sref),
11081                           ctype_unparse (ct),
11082                           exprNode_unparse (e1), exprNode_unparse (e2)),
11083                  e1->loc);
11084             }
11085         }
11086     }
11087 }
11088
11089 static void
11090 doAssign (/*@notnull@*/ exprNode e1, /*@notnull@*/ exprNode e2, bool isInit)
11091 {
11092   DPRINTF (("Do assign: %s <- %s",
11093             exprNode_unparse (e1), exprNode_unparse (e2)));
11094   DPRINTF (("Ctype: %s", ctype_unparse (exprNode_getType (e1))));
11095
11096   if (ctype_isRealFunction (exprNode_getType (e1))
11097       && !ctype_isRealPointer (exprNode_getType (e1)))
11098     {
11099       voptgenerror
11100         (FLG_TYPE,
11101          message ("Invalid left-hand side of assignment (function type %s): %s",
11102                   ctype_unparse (exprNode_getType (e1)),
11103                   exprNode_unparse (e1)),
11104          e1->loc);
11105     }
11106
11107   if (context_getFlag (FLG_ASSIGNEXPOSE) && ctype_isMutable (e2->typ))
11108     {
11109       ctype t2 = exprNode_getType (e2);
11110       sRef sr = sRef_getRootBase (e1->sref);
11111       ctype ct = sRef_getType (sr);
11112
11113       if (ctype_isAbstract (t2)
11114           && !(uentry_isMutableDatatype (usymtab_getTypeEntry (ctype_typeId (t2)))))
11115         {
11116           /* it is immutable, okay to reference */
11117           goto donerepexpose;
11118         }
11119
11120       if (ctype_isAbstract (ct) && sRef_isIReference (e1->sref))
11121         {
11122           sRef s2b = sRef_getRootBase (e2->sref);
11123           sRef s1 = e1->sref;
11124           sRef s1b = sRef_getRootBase (s1);
11125           sRefSet aliases;
11126
11127           aliases = usymtab_canAlias (e2->sref);
11128
11129           if (!sRef_similar (s2b, s1b)
11130               && !sRef_isExposed (s1)
11131               && !(sRef_isOnly (s2b) || sRef_isKeep (s2b) || sRef_isExposed (s2b)))
11132             {
11133               if (sRef_isAnyParam (s2b) && !sRef_isOnly (s2b)
11134                   && !sRef_isOwned (s2b) && !sRef_isKeep (s2b)
11135                   && !sRef_isExposed (s2b))
11136                 {
11137                   if (sRef_isIReference (e2->sref))
11138                     {
11139                       voptgenerror
11140                         (FLG_ASSIGNEXPOSE,
11141                          message
11142                          ("Assignment of mutable component of parameter %q "
11143                           "to component of abstract type %s exposes rep: %s = %s",
11144                           sRef_unparse (s2b),
11145                           ctype_unparse (ct),
11146                           exprNode_unparse (e1), exprNode_unparse (e2)),
11147                          e1->loc);
11148                     }
11149                   else
11150                     {
11151                       voptgenerror
11152                         (FLG_ASSIGNEXPOSE,
11153                          message ("Assignment of mutable parameter %q to "
11154                                   "component of abstract type %s exposes rep: %s = %s",
11155                                   sRef_unparse (s2b),
11156                                   ctype_unparse (ct),
11157                                   exprNode_unparse (e1), exprNode_unparse (e2)),
11158                          e1->loc);
11159                     }
11160                 }
11161
11162               if (sRef_isFileOrGlobalScope (s2b))
11163                 {
11164                   voptgenerror
11165                     (FLG_ASSIGNEXPOSE,
11166                      message ("Assignment of global %q to component of "
11167                               "abstract type %s exposes rep: %s = %s",
11168                               sRef_unparse (s2b),
11169                               ctype_unparse (ct),
11170                               exprNode_unparse (e1), exprNode_unparse (e2)),
11171                      e1->loc);
11172                 }
11173
11174               sRefSet_realElements (aliases, ysr)
11175                 {
11176                   sRef base = sRef_getRootBase (ysr);
11177
11178                   if (sRef_similar (ysr, s2b) || sRef_similar (s1b, base)
11179                       || sRef_sameName (base, s1b))
11180                     {
11181                      ; /* error already reported or same sref */
11182                     }
11183                   else
11184                     {
11185                       checkOneRepExpose (ysr, base, e1, e2, ct, s2b);
11186                     }
11187                 } end_sRefSet_realElements;
11188             }
11189           sRefSet_free (aliases);
11190         }
11191     }
11192
11193  donerepexpose:
11194
11195   /*
11196   ** function variables don't really work...
11197   */
11198
11199   if (!ctype_isFunction (ctype_realType (e2->typ)))
11200     {
11201       if (isInit)
11202         {
11203             DPRINTF (("Check init: %s / %s",
11204                       exprNode_unparse (e1), exprNode_unparse (e2)));
11205           transferChecks_initialization (e1, e2);
11206         }
11207       else
11208         {
11209           transferChecks_assign (e1, e2);
11210         }
11211     }
11212   else
11213     {
11214       sRef fref = e2->sref;
11215
11216       sRef_setDefState (e1->sref, sRef_getDefState (fref), e1->loc);
11217       sRef_setNullState (e1->sref, sRef_getNullState (fref), e1->loc);
11218
11219             /* Need to typecheck the annotation on the parameters */
11220
11221       if (ctype_isRealFunction (e1->typ)) {
11222         uentryList e1p = ctype_argsFunction (ctype_realType (e1->typ));
11223         uentryList e2p = ctype_argsFunction (ctype_realType (e2->typ));
11224
11225         if (!uentryList_isMissingParams (e1p)
11226             && !uentryList_isMissingParams (e2p)
11227             && uentryList_size (e1p) > 0) {
11228           if (uentryList_size (e1p) == uentryList_size (e2p)) {
11229             int n = 0;
11230
11231             uentryList_elements (e1p, el1) {
11232               uentry el2;
11233
11234               el2 = uentryList_getN (e2p, n);
11235               n++;
11236               uentry_checkMatchParam (el1, el2, n, e2);
11237             } end_uentryList_elements;
11238           }
11239         }
11240       }
11241     }
11242
11243   if (exprNode_isStringLiteral (e2))
11244     {
11245       exprNode_checkStringLiteralLength (exprNode_getType (e1), e2);
11246     }
11247
11248   if (isInit && sRef_isFileOrGlobalScope (e1->sref))
11249     {
11250        ;
11251     }
11252   else
11253     {
11254       DPRINTF (("Update aliases: %s / %s", exprNode_unparse (e1), exprNode_unparse (e2)));
11255       updateAliases (e1, e2);
11256     }
11257 }
11258
11259 static void
11260 checkMacroParen (exprNode e)
11261 {
11262   if (exprNode_isError (e) || e->kind == XPR_CAST)
11263     {
11264      ;
11265     }
11266   else
11267     {
11268       if (sRef_isUnsafe (e->sref) && !exprNode_isInParens (e))
11269         {
11270           voptgenerror
11271             (FLG_MACROPARENS,
11272              message ("Macro parameter used without parentheses: %s",
11273                       exprNode_unparse (e)),
11274              e->loc);
11275         }
11276     }
11277 }
11278
11279 static void
11280 reflectNullTest (/*@notnull@*/ exprNode e, bool isnull)
11281 {
11282   if (isnull)
11283     {
11284       e->guards = guardSet_addTrueGuard (e->guards, e->sref);
11285     }
11286   else
11287     {
11288       e->guards = guardSet_addFalseGuard (e->guards, e->sref);
11289     }
11290 }
11291
11292 /*
11293 ** e1 <= e2
11294 **
11295 ** if e2 is a parameter or global derived location which
11296 ** can be modified (that is, e2 is a mutable abstract type,
11297 ** or a derived pointer), then e1 can alias e2.
11298 **
11299 ** e1 can alias everything which e2 can alias.
11300 **
11301 ** Also, if e1 is guarded, remove from guard sets!
11302 */
11303
11304 static void updateAliases (/*@notnull@*/ exprNode e1, /*@notnull@*/ exprNode e2)
11305 {
11306   if (!context_inProtectVars ())
11307     {
11308       /*
11309       ** depends on types of e1 and e2
11310       */
11311
11312       sRef s1 = e1->sref;
11313       sRef s2 = e2->sref;
11314       ctype t1 = exprNode_getType (e1);
11315
11316       /* handle pointer sRefs, record fields, arrays, etc... */
11317
11318       if (!ctype_isRealSU (t1))
11319         {
11320           DPRINTF (("Copying real! %s", ctype_unparse (t1)));
11321           sRef_copyRealDerivedComplete (s1, s2);
11322         }
11323       else
11324         {
11325           /*
11326           ** Fields should alias
11327           */
11328
11329           DPRINTF (("Not COPYING!: %s", ctype_unparse (t1)));
11330         }
11331
11332       if (ctype_isMutable (t1) && sRef_isKnown (s1))
11333         {
11334           usymtab_clearAlias (s1);
11335           usymtab_addMustAlias (s1, s2);
11336           DPRINTF (("Add must alias: %s / %s", sRef_unparse (s1), sRef_unparse (s2)));
11337         }
11338       else
11339         {
11340           DPRINTF (("Not mutable: %s", ctype_unparse (t1)));
11341         }
11342
11343       if (sRef_possiblyNull (s1) && usymtab_isGuarded (s1))
11344         {
11345           usymtab_unguard (s1);
11346         }
11347     }
11348 }
11349
11350 exprNode exprNode_updateLocation (/*@returned@*/ exprNode e, /*@temp@*/ fileloc loc)
11351 {
11352   if (exprNode_isDefined (e))
11353     {
11354       e->loc = fileloc_update (e->loc, loc);
11355     }
11356   else
11357     {
11358       e = exprNode_createLoc (ctype_unknown, fileloc_copy (loc));
11359     }
11360
11361   return (e);
11362 }
11363
11364 static void checkUniqueParams (exprNode fcn,
11365                                /*@notnull@*/ exprNode current,
11366                                exprNodeList args,
11367                                int paramno, uentry ucurrent)
11368 {
11369   int iparamno = 0;
11370   sRef thisref = exprNode_getSref (current);
11371
11372   /*
11373   ** Check if any argument could match this argument.
11374   */
11375
11376   exprNodeList_elements (args, icurrent)
11377     {
11378       iparamno++;
11379
11380       if (iparamno != paramno)
11381         {
11382           sRef sr = exprNode_getSref (icurrent);
11383
11384           if (sRef_similarRelaxed (thisref, sr))
11385             {
11386               if (!sRef_isConst (thisref) && !sRef_isConst (sr))
11387                 {
11388                   voptgenerror
11389                     (FLG_ALIASUNIQUE,
11390                      message
11391                      ("Parameter %d (%s) to function %s is declared %s but "
11392                       "is aliased by parameter %d (%s)",
11393                       paramno,
11394                       exprNode_unparse (current),
11395                       exprNode_unparse (fcn),
11396                       alkind_unparse (uentry_getAliasKind (ucurrent)),
11397                       iparamno, exprNode_unparse (icurrent)),
11398                      current->loc);
11399                 }
11400             }
11401           else
11402             {
11403               sRefSet aliases = usymtab_canAlias (sr);
11404
11405               sRefSet_allElements (aliases, asr)
11406                 {
11407                   if (ctype_isUnknown (sRef_getType (thisref)))
11408                     {
11409                       sRef_setType (thisref, uentry_getType (ucurrent));
11410                     }
11411
11412                   if (sRef_similarRelaxed (thisref, asr))
11413                     {
11414                       if (sRef_isExternal (asr))
11415                         {
11416                           if (sRef_isLocalState (thisref))
11417                             {
11418                               ; /* okay */
11419                             }
11420                           else
11421                             {
11422                               sRef base = sRef_getRootBase (asr);
11423
11424                               if (!sRef_similar (sRef_getBase (asr), thisref))
11425                                 {
11426                                   if (sRef_isUnique (base) || sRef_isOnly (base)
11427                                       || sRef_isKept (base)
11428                                       || (sRef_isAddress (asr) && sRef_isLocalVar (base))
11429                                       || (sRef_isAddress (thisref)
11430                                           && sRef_isLocalVar (sRef_getRootBase (thisref))))
11431                                     {
11432                                       ; /* okay, no error */
11433                                     }
11434                                   else
11435                                     {
11436                                       voptgenerror
11437                                         (FLG_MAYALIASUNIQUE,
11438                                          message
11439                                          ("Parameter %d (%s) to function %s is declared %s but "
11440                                           "may be aliased externally by parameter %d (%s)",
11441                                           paramno,
11442                                           exprNode_unparse (current),
11443                                           exprNode_unparse (fcn),
11444                                           alkind_unparse (uentry_getAliasKind (ucurrent)),
11445                                           iparamno, exprNode_unparse (icurrent)),
11446                                          current->loc);
11447                                     }
11448                                 }
11449                             }
11450                         }
11451                       else
11452                         {
11453                           voptgenerror
11454                             (FLG_ALIASUNIQUE,
11455                              message
11456                              ("Parameter %d (%s) to function %s is declared %s but "
11457                               "is aliased externally by parameter %d (%s) through "
11458                               "alias %q",
11459                               paramno,
11460                               exprNode_unparse (current),
11461                               exprNode_unparse (fcn),
11462                               alkind_unparse (uentry_getAliasKind (ucurrent)),
11463                               iparamno, exprNode_unparse (icurrent),
11464                               sRef_unparse (asr)),
11465                              current->loc);
11466                         }
11467                     }
11468                 } end_sRefSet_allElements;
11469               sRefSet_free (aliases);
11470             }
11471         }
11472     } end_exprNodeList_elements;
11473 }
11474
11475 long exprNode_getLongValue (exprNode e) {
11476   long value;
11477
11478   if (exprNode_hasValue (e)
11479       && multiVal_isInt (exprNode_getValue (e)))
11480     {
11481       value = multiVal_forceInt (exprNode_getValue (e));
11482     }
11483   else
11484     {
11485       /*@!! BADBRANCH;*/
11486       value = 0;
11487     }
11488
11489   return value;
11490 }
11491
11492 /*@observer@*/ fileloc exprNode_getfileloc (exprNode p_e)
11493 {
11494   if (exprNode_isDefined (p_e) )
11495     return ( p_e->loc );
11496   else
11497     return fileloc_undefined;
11498 }
11499
11500 /*@only@*/ fileloc exprNode_getNextSequencePoint (exprNode e)
11501 {
11502   /*
11503   ** Returns the location of the sequence point following e.
11504   **
11505   ** Only works for statements (for now).
11506   */
11507
11508   if (exprNode_isDefined (e) && e->kind == XPR_STMT) {
11509     lltok t = exprData_getUopTok (e->edata);
11510     return fileloc_copy(lltok_getLoc (t));
11511   } else {
11512     /* drl possible problem : warning fix
11513        llcontbug (message ("Cannot get next sequence point: %s", exprNode_unparse (e)));
11514     */
11515     return fileloc_undefined;
11516   }
11517  }
11518
11519 exprNode exprNode_createNew(ctype c)
11520 {
11521   exprNode ret;
11522
11523   ret = exprNode_createPlain (c);
11524
11525   return ret;
11526 }
11527
11528 bool exprNode_isInitBlock (exprNode e)
11529 {
11530   return (exprNode_isDefined(e) && e->kind == XPR_INITBLOCK);
11531 }
11532
11533 /*drl 3/2/2003 moved this function out of constraint.c */
11534 exprNode exprNode_copyConstraints (/*@returned@*/ exprNode dst, exprNode src)
11535 {
11536
11537   llassert (exprNode_isDefined (dst) );
11538   llassert (exprNode_isDefined (src) );
11539
11540   constraintList_free (dst->ensuresConstraints);
11541   constraintList_free (dst->requiresConstraints);
11542   constraintList_free (dst->trueEnsuresConstraints);
11543   constraintList_free (dst->falseEnsuresConstraints);
11544
11545   dst->ensuresConstraints = constraintList_copy (src->ensuresConstraints);
11546   dst->requiresConstraints = constraintList_copy (src->requiresConstraints);
11547   dst->trueEnsuresConstraints = constraintList_copy (src->trueEnsuresConstraints);
11548   dst->falseEnsuresConstraints = constraintList_copy (src->falseEnsuresConstraints);
11549   return dst;
11550 }