src/constraintExpr.c

   1 /*
   2 ** constraintExpr.c
   3 */
   4
   5 //#define DEBUGPRINT 1
   6
   7 # include "lclintMacros.nf"
   8 # include "basic.h"
   9 # include "cgrammar.h"
  10 # include "cgrammar_tokens.h"
  11
  12 # include "exprChecks.h"
  13 # include "aliasChecks.h"
  14 # include "exprNodeSList.h"
  15
  16
  17 # include "exprData.i"
  18 # include "exprDataQuite.i"
  19
  20
  21 /*@-czechfcns@*/
  22
  23
  24
  25 /*@access exprNode @*/
  26
  27 static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/constraintExpr expr, int literal);
  28
  29 /*@only@*/ static constraintExpr
  30 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, exprNodeList arglist) /*@modifies e@*/;
  31
  32 static constraintExpr
  33 doFixResultTerm (constraintExpr e, exprNode fcnCall) /*@modifies e@*/;
  34
  35
  36 /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void) /*@allocates result->data @*/ /*@sets result->kind @*/;
  37
  38 //constraintExpr constraintExpr_makeMaxSetConstraintExpr (constraintExpr c);
  39
  40 void constraintExpr_free (/*@only@*/ constraintExpr expr)
  41 {
  42   if (constraintExpr_isDefined(expr) )
  43     {
  44       switch (expr->kind)
  45         {
  46         case unaryExpr:
  47           constraintExprData_freeUnaryExpr(expr->data);
  48           break;
  49         case binaryexpr:
  50           constraintExprData_freeBinaryExpr(expr->data);
  51           break;
  52         case term:
  53           constraintExprData_freeTerm(expr->data);
  54           break;
  55         default:
  56           BADEXIT;
  57         }
  58
  59       expr->data = NULL;
  60       free (expr);
  61     }
  62   else
  63     {
  64       llcontbug(message("attempted to free null pointer in constraintExpr_free"));
  65     }
  66 }
  67
  68 bool constraintExpr_isLit (constraintExpr expr)
  69 {
  70   llassert (expr != NULL);
  71
  72   if (expr->kind == term)
  73     {
  74       constraintTerm term = constraintExprData_termGetTerm (expr->data);
  75       if (constraintTerm_isIntLiteral (term) )
  76         {
  77           return TRUE;
  78         }
  79
  80     }
  81   return FALSE;
  82 }
  83
  84
  85 /*@only@*/ constraintExpr constraintExpr_propagateConstants (/*@only@*/ constraintExpr expr,
  86                                                 /*@out@*/ bool * propagate,
  87                                                   /*@out@*/ int *literal)
  88 {
  89   constraintExpr expr1;
  90   constraintExpr expr2;
  91   bool propagate1, propagate2;
  92   int literal1, literal2;
  93   constraintExprBinaryOpKind  op;
  94
  95   propagate1 = FALSE;
  96   propagate2 = FALSE;
  97
  98   literal1 = 0;
  99   literal2 = 0;
 100
 101   *propagate = FALSE;
 102   *literal = 0;
 103
 104   llassert (expr != NULL);
 105
 106   // we simplify unaryExpr else where
 107   if (expr->kind != binaryexpr)
 108     return expr;
 109
 110   op = constraintExprData_binaryExprGetOp (expr->data);
 111
 112   DPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
 113
 114   expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
 115   expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
 116
 117   expr1 = constraintExpr_copy(expr1);
 118   expr2 = constraintExpr_copy(expr2);
 119
 120   expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
 121   expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
 122
 123   *propagate = propagate1 || propagate2;
 124   *literal    = literal1 +  literal2;
 125
 126   if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
 127     {
 128       int t1, t2;
 129       t1 = constraintExpr_getValue (expr1);
 130       t2 = constraintExpr_getValue (expr2);
 131       *propagate = FALSE;
 132
 133       constraintExpr_free (expr);
 134       constraintExpr_free (expr1);
 135       constraintExpr_free (expr2);
 136
 137       if (op == PLUS )
 138         return (constraintExpr_makeIntLiteral ( (t1+t2) ));
 139       else if (op ==  MINUS)
 140         return (constraintExpr_makeIntLiteral ( (t1-t2) ));
 141       else
 142         BADEXIT;
 143     }
 144
 145
 146
 147
 148   if (constraintExpr_isLit (expr1) )
 149     {
 150       *propagate = TRUE;
 151
 152       if (op == PLUS )
 153         *literal += constraintExpr_getValue (expr1);
 154       else
 155         *literal -= constraintExpr_getValue (expr1);
 156
 157       constraintExpr_free(expr1);
 158       constraintExpr_free(expr);
 159       return expr2;
 160     }
 161
 162   if (constraintExpr_isLit (expr2) )
 163     {
 164       *propagate = TRUE;
 165
 166       if ( op == PLUS )
 167         *literal += constraintExpr_getValue (expr2);
 168       else
 169         *literal -= constraintExpr_getValue (expr2);
 170
 171       constraintExpr_free(expr2);
 172       constraintExpr_free(expr);
 173       return expr1;
 174     }
 175
 176   DPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
 177
 178   expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
 179   expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
 180
 181   return expr;
 182 }
 183
 184 //  constraintExpr constraintExpr_propagateConstantsBak (constraintExpr expr,
 185 //                                              /*@out@*/ bool * propagate,
 186 //                                                /*@out@*/ int *literal)
 187 //  {
 188 //    constraintExpr expr1;
 189 //    constraintExpr expr2;
 190 //    bool propagate1, propagate2;
 191 //    int literal1, literal2;
 192
 193 //    propagate1 = FALSE;
 194 //    propagate2 = FALSE;
 195
 196 //    literal1 = 0;
 197 //    literal2 = 0;
 198
 199 //    *propagate = FALSE;
 200 //    *literal = 0;
 201
 202 //    llassert (expr != NULL);
 203
 204 //    // we simplify unaryExpr else where
 205 //    if (expr->kind == unaryExpr)
 206 //      return expr;
 207
 208 //    if (expr->kind == term)
 209 //      return expr;
 210
 211 //    if (constraintExpr_isLit (expr) )
 212 //      return expr;
 213
 214 //    DPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
 215
 216 //    expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
 217 //    expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
 218
 219 //    expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
 220 //    expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
 221
 222 //    expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
 223 //    expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
 224
 225 //    *propagate = propagate1 || propagate2;
 226 //    *literal    = literal1 +  literal2;
 227
 228 //    if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
 229 //      {
 230 //        int t1, t2;
 231 //        t1 = constraintExpr_getValue (expr1);
 232 //        t2 = constraintExpr_getValue (expr2);
 233 //        *propagate = FALSE;
 234
 235 //        if (constraintExprData_binaryExprGetOp (expr->data) == PLUS )
 236 //      return (constraintExpr_makeIntLiteral ( (t1+t2) ));
 237 //        else if (constraintExprData_binaryExprGetOp (expr->data) ==  MINUS)
 238 //      return (constraintExpr_makeIntLiteral ( (t1-t2) ));
 239 //        else
 240 //      llassert(FALSE);
 241 //      }
 242
 243 //    if (constraintExpr_isLit (expr1) )
 244 //      {
 245 //        /*@i334*/
 246 //        /*handle MINUS case right */
 247 //        *propagate = TRUE;
 248 //        *literal += constraintExpr_getValue (expr1);
 249 //        /*@-compdef@*/
 250 //        return expr2;
 251 //        /*@=compdef@*/
 252 //      }
 253
 254 //    /*@-compdef@*/
 255 //    if (constraintExpr_isLit (expr2) )
 256 //      {
 257 //        *propagate = TRUE;
 258
 259 //        if (constraintExprData_binaryExprGetOp (expr->data) == PLUS )
 260 //      *literal += constraintExpr_getValue (expr2);
 261 //        else
 262 //      *literal -= constraintExpr_getValue (expr2);
 263 //        return expr1;
 264 //      }
 265
 266
 267
 268
 269 //    DPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
 270
 271 //    return expr;
 272 //    /*@=compdef@*/
 273 //  }
 274
 275 /*@only@*/ static constraintExpr constraintExpr_combineConstants (/*@only@*/ constraintExpr expr ) /*@modifies expr@*/
 276 {
 277   bool propagate;
 278   int literal;
 279
 280   DPRINTF ( (message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
 281   expr = constraintExpr_propagateConstants (expr, &propagate, &literal);
 282
 283
 284   if (propagate)
 285     {
 286       constraintExpr ret;
 287
 288       if (literal != 0)
 289         {
 290           ret = constraintExpr_makeBinaryOpConstraintExprIntLiteral (expr, literal);
 291           expr = ret;
 292         }
 293     }
 294    DPRINTF ( (message ("After combine %s", constraintExpr_unparse(expr) ) ) );
 295   return expr;
 296 }
 297
 298 /*@special@*/
 299 static constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
 300 {
 301   constraintExpr ret;
 302   ret = dmalloc (sizeof (*ret) );
 303   ret->kind = term;
 304   ret->data = NULL;
 305   return ret;
 306 }
 307
 308 /*@only@*/ static constraintExprData copyExprData (constraintExprData data, constraintExprKind kind)
 309 {
 310   constraintExprData ret;
 311   llassert(constraintExprData_isDefined(data));
 312
 313   switch (kind)
 314     {
 315     case binaryexpr:
 316       ret = constraintExprData_copyBinaryExpr(data);
 317       break;
 318     case unaryExpr:
 319       ret = constraintExprData_copyUnaryExpr(data);
 320       break;
 321     case term:
 322       ret = constraintExprData_copyTerm(data);
 323       break;
 324     default:
 325       BADEXIT;
 326     }
 327   return ret;
 328 }
 329
 330 constraintExpr constraintExpr_copy (constraintExpr expr)
 331 {
 332   constraintExpr ret;
 333   ret = constraintExpr_alloc();
 334   ret->kind = expr->kind;
 335
 336   ret->data = copyExprData (expr->data, expr->kind);
 337   return ret;
 338 }
 339
 340
 341 /*@only@*/ static constraintExpr oldconstraintExpr_makeTermExprNode (exprNode e)
 342 {
 343   constraintExpr ret;
 344   constraintTerm t;
 345   ret = constraintExpr_alloc();
 346   ret->kind = term;
 347   ret->data = dmalloc (sizeof *(ret->data) );
 348   t = constraintTerm_makeExprNode (e);
 349   ret->data = constraintExprData_termSetTerm (ret->data, t);
 350   return ret;
 351 }
 352
 353 constraintExpr constraintExpr_makeExprNode (exprNode e)
 354 {
 355  sRef s;
 356  constraintExpr ret, ce1, ce2;
 357  exprData data;
 358  exprNode t, t1, t2;
 359  lltok tok;
 360
 361
 362  llassert (e != NULL);
 363
 364  data = e->edata;
 365
 366  switch (e->kind)
 367    {
 368    case XPR_SIZEOF:
 369      t = exprData_getSingle (data);
 370      s = exprNode_getSref (t);
 371      if (sRef_isFixedArray(s) )
 372       {
 373         int size;
 374
 375         size = (int) sRef_getArraySize(s);
 376         ret = constraintExpr_makeIntLiteral (size);
 377       }
 378      else
 379        {
 380          DPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
 381          ret = oldconstraintExpr_makeTermExprNode (e);
 382        }
 383      break;
 384
 385    case XPR_OP:
 386       DPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
 387      t1 = exprData_getOpA (data);
 388      t2 = exprData_getOpB (data);
 389      tok = exprData_getOpTok (data);
 390
 391      if (lltok_isPlus_Op (tok) || lltok_isMinus_Op (tok) )
 392        {
 393          ce1 = constraintExpr_makeExprNode (t1);
 394          ce2 = constraintExpr_makeExprNode (t2);
 395          ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2);
 396        }
 397      else
 398        {
 399         ret = oldconstraintExpr_makeTermExprNode (e);
 400        }
 401      break;
 402    case XPR_PARENS:
 403      t = exprData_getUopNode (data);
 404      ret = constraintExpr_makeExprNode (t);
 405      break;
 406
 407    case XPR_PREOP:
 408       t = exprData_getUopNode (data);
 409       tok =  exprData_getUopTok (data);
 410       if (lltok_isInc_Op (tok) )
 411         {
 412           constraintExpr temp;
 413           temp = constraintExpr_makeExprNode(t);
 414           ret = constraintExpr_makeIncConstraintExpr(temp);
 415         }
 416       else if (lltok_isDec_Op (tok) )
 417         {
 418           constraintExpr temp;
 419           temp = constraintExpr_makeExprNode(t);
 420           ret = constraintExpr_makeDecConstraintExpr(temp);
 421         }
 422       else
 423         ret =  oldconstraintExpr_makeTermExprNode (e);
 424       break;
 425
 426    case XPR_POSTOP:
 427      t = exprData_getUopNode (data);
 428           ret = constraintExpr_makeExprNode (t);
 429      break;
 430    case XPR_CAST:
 431      t = exprData_getCastNode (data);
 432      ret = constraintExpr_makeExprNode (t);
 433      break;
 434    case XPR_COMMA:
 435      t = exprData_getPairA(data);
 436      ret = constraintExpr_makeExprNode(t);
 437      /*@i3434*/ /*I'm not sure if this is right.  I'm adding a break to quite LCLint*/
 438      break;
 439    default:
 440      ret = oldconstraintExpr_makeTermExprNode (e);
 441
 442    }
 443   return ret;
 444 }
 445
 446
 447 /*@only@*/ static constraintExpr constraintExpr_makeTermExprNode (exprNode e)
 448 {
 449   return  oldconstraintExpr_makeTermExprNode(e); //constraintExpr_makeExprNode (e);
 450 }
 451
 452
 453 constraintExpr constraintExpr_makeTermsRef (/*@only@*/ sRef s)
 454 {
 455   constraintExpr ret;
 456   constraintTerm t;
 457   ret = constraintExpr_alloc();
 458   ret->kind = term;
 459   ret->data = dmalloc (sizeof *(ret->data) );
 460   t = constraintTerm_makesRef (s);
 461   ret->data = constraintExprData_termSetTerm (ret->data, t);
 462   return ret;
 463 }
 464
 465 /*@special@*/ static constraintExpr constraintExpr_makeUnaryOp (void) /*@allocates result->data@*/ /*@defines result->kind@*/
 466 {
 467   constraintExpr ret;
 468   ret = constraintExpr_alloc();
 469   ret->kind = unaryExpr;
 470   ret->data = dmalloc ( sizeof *(ret->data) );
 471   return ret;
 472 }
 473
 474 /*@only@*/ static constraintExpr constraintExpr_makeUnaryOpConstraintExpr (/*@only@*/ constraintExpr cexpr)
 475 {
 476   constraintExpr ret;
 477   ret = constraintExpr_makeUnaryOp();
 478
 479   /*@-uniondef@*/
 480   /*@-compdef@*/
 481     ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
 482     ret->data = constraintExprData_unaryExprSetOp (ret->data, UNARYOP_UNDEFINED);
 483
 484   return ret;
 485
 486   /*@=compdef@*/
 487   /*@=uniondef@*/
 488 }
 489
 490 /*@only@*/
 491 static constraintExpr constraintExpr_makeMaxSetConstraintExpr (/*@only@*/ constraintExpr c)
 492 {
 493   constraintExpr ret;
 494   ret = constraintExpr_makeUnaryOpConstraintExpr (c);
 495   ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
 496   return ret;
 497 }
 498
 499 /*@only@*/
 500 static constraintExpr constraintExpr_makeUnaryOpExprNode (exprNode expr)
 501 {
 502   constraintExpr ret;
 503   constraintExpr sub;
 504   sub = constraintExpr_makeExprNode (expr);
 505   ret = constraintExpr_makeUnaryOpConstraintExpr(sub);
 506
 507   return ret;
 508 }
 509
 510
 511
 512 /*@only@*/
 513 static constraintExpr constraintExpr_makeSRefUnaryOp (/*@only@*/ sRef s,  constraintExprUnaryOpKind op)
 514 {
 515   constraintExpr ret;
 516   constraintExpr t;
 517
 518   t = constraintExpr_makeTermsRef (s);
 519   ret = constraintExpr_makeUnaryOpConstraintExpr (t);
 520   ret->data = constraintExprData_unaryExprSetOp (ret->data, op);
 521
 522   return ret;
 523 }
 524
 525 /*@only@*/
 526 constraintExpr constraintExpr_makeSRefMaxRead(/*@only@*/ sRef s)
 527 {
 528   return (constraintExpr_makeSRefUnaryOp (s, MAXREAD) );
 529 }
 530
 531 /*@only@*/
 532 constraintExpr constraintExpr_makeSRefMaxset (/*@only@*/ sRef s)
 533 {
 534   return (constraintExpr_makeSRefUnaryOp (s, MAXSET) );
 535 }
 536
 537 /*@only@*/
 538 constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr)
 539 {
 540   constraintExpr ret;
 541   ret = constraintExpr_makeUnaryOpConstraintExpr ( cexpr);
 542
 543   switch (op.tok)
 544     {
 545     case QMAXSET:
 546       ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
 547       break;
 548     case QMAXREAD:
 549       ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
 550       break;
 551     default:
 552       llfatalbug(message("Unhandled Operation in Constraint") );
 553     }
 554   return ret;
 555 }
 556
 557 /*@only@*/
 558 constraintExpr constraintExpr_makeMaxSetExpr (exprNode expr)
 559 {
 560   constraintExpr ret;
 561   ret = constraintExpr_makeExprNode (expr);
 562
 563   ret = constraintExpr_makeMaxSetConstraintExpr (ret);
 564
 565   llassert (ret != NULL);
 566   return ret;
 567 }
 568
 569 /*@only@*/
 570 constraintExpr  constraintExpr_makeMaxReadExpr (exprNode expr)
 571 {
 572   constraintExpr ret;
 573   ret = constraintExpr_makeUnaryOpExprNode(expr);
 574   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
 575   return ret;
 576 }
 577
 578 /*@only@*/
 579 /*@unused@*/ constraintExpr  constraintExpr_makeMinSetExpr (exprNode expr)
 580 {
 581   constraintExpr ret;
 582   ret = constraintExpr_makeUnaryOpExprNode(expr);
 583   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MINSET);
 584   return ret;
 585 }
 586
 587 /*@only@*/
 588 /*@unused@*/ constraintExpr constraintExpr_makeMinReadExpr (exprNode expr)
 589 {
 590   constraintExpr ret;
 591   ret = constraintExpr_makeUnaryOpExprNode(expr);
 592   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MINREAD);
 593   return ret;
 594 }
 595
 596
 597 /*@only@*/
 598 constraintExpr constraintExpr_makeValueExpr (exprNode expr)
 599 {
 600   constraintExpr ret;
 601   ret = constraintExpr_makeExprNode (expr);
 602   return ret;
 603 }
 604
 605 /*@only@*/
 606 constraintExpr constraintExpr_makeIntLiteral (int i)
 607 {
 608   constraintExpr ret;
 609   constraintTerm t;
 610   ret = constraintExpr_alloc();
 611   ret->kind = term;
 612   ret->data = dmalloc (sizeof *(ret->data) );
 613   t = constraintTerm_makeIntLiteral (i);
 614   ret->data = constraintExprData_termSetTerm (ret->data, t);
 615   return ret;
 616 }
 617
 618 /*
 619 constraintExpr constraintExpr_makeValueInt (int i)
 620 {
 621   return constraintExpr_makeIntLiteral (i);
 622 }
 623 */
 624
 625 /*@only@*/
 626  /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void) /*@allocates result->data @*/ /*@sets result->kind @*/
 627 {
 628   constraintExpr ret;
 629   ret = constraintExpr_alloc();
 630   ret->kind = binaryexpr;
 631   ret->data = dmalloc ( sizeof *(ret->data) );
 632   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
 633   return ret;
 634 }
 635
 636
 637 static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExpr (/*@only@*/constraintExpr expr1, /*@only@*/ constraintExpr expr2)
 638
 639 {
 640   constraintExpr ret;
 641
 642   ret = constraintExpr_makeBinaryOp();
 643   ret->data = constraintExprData_binaryExprSetExpr1 (ret->data, expr1);
 644   ret->data = constraintExprData_binaryExprSetExpr2 (ret->data, expr2);
 645   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
 646   return ret;
 647 }
 648
 649 /*@only@*/
 650 constraintExpr constraintExpr_parseMakeBinaryOp (/*@only@*/ constraintExpr expr1, lltok op,/*@only@*/ constraintExpr expr2)
 651 {
 652   constraintExpr ret;
 653   ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
 654   if (op.tok == TPLUS)
 655     ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 656   else if (op.tok == TMINUS)
 657     ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS);
 658     else
 659       {
 660         llassert(FALSE);
 661       }
 662   return ret;
 663 }
 664
 665 /*@only@*/
 666 /*@unused@*/ constraintExpr constraintExpr_makeBinaryOpExprNode (exprNode expr1, exprNode expr2)
 667 {
 668   constraintExpr ret;
 669   constraintExpr sub1, sub2;
 670   sub1 = constraintExpr_makeTermExprNode (expr1);
 671   sub2 = constraintExpr_makeTermExprNode (expr2);
 672   ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2);
 673   return ret;
 674 }
 675
 676 /*@only@*/
 677 constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/ constraintExpr expr, int literal)
 678 {
 679   constraintExpr ret;
 680   constraintExpr constExpr;
 681
 682   constExpr = constraintExpr_makeIntLiteral (literal);
 683   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, constExpr);
 684   ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 685   return ret;
 686 }
 687
 688 /*@only@*/
 689 constraintExpr constraintExpr_makeDecConstraintExpr (/*@only@*/constraintExpr expr)
 690 {
 691   constraintExpr ret;
 692   constraintExpr inc;
 693
 694   inc = constraintExpr_makeIntLiteral (1);
 695   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
 696   ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS);
 697   return ret;
 698 }
 699
 700 /*@only@*/
 701 constraintExpr constraintExpr_makeAddConstraintExpr (/*@only@*/
 702 constraintExpr expr, /*@only@*/
 703 constraintExpr add)
 704 {
 705   constraintExpr ret;
 706
 707   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, add);
 708
 709   ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 710
 711   return ret;
 712 }
 713
 714 /*@only@*/
 715 constraintExpr constraintExpr_makeIncConstraintExpr (/*@only@*/ constraintExpr expr)
 716 {
 717   constraintExpr ret;
 718   constraintExpr inc;
 719
 720   inc = constraintExpr_makeIntLiteral (1);
 721   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
 722   ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 723   return ret;
 724 }
 725
 726 /*@only@*/
 727 static cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
 728 {
 729   switch (op)
 730     {
 731     case MAXSET:
 732       return message("MAXSET");
 733     case MINSET:
 734       return message("MINSET");
 735     case MAXREAD:
 736       return message("MAXREAD");
 737     case MINREAD:
 738       return message("MINREAD");
 739     default:
 740       llassert(FALSE);
 741       return message ("<(Unary OP OTHER>");
 742     }
 743 }
 744
 745
 746 /*@only@*/
 747 static cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
 748 {
 749
 750   switch (op)
 751     {
 752     case PLUS:
 753       return message("+");
 754     case MINUS:
 755       return message("-");
 756
 757     default:
 758       llassert(FALSE);
 759       return message ("<binary OP Unknown>");
 760     }
 761 }
 762
 763 bool constraintExpr_similar (constraintExpr expr1, constraintExpr expr2)
 764 {
 765   constraintExprKind kind;
 766
 767   llassert (expr1 != NULL);
 768   llassert (expr2 != NULL);
 769   if (expr1->kind != expr2->kind)
 770     return FALSE;
 771
 772   kind = expr1->kind;
 773
 774   switch (kind)
 775     {
 776     case term:
 777       return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
 778                                   constraintExprData_termGetTerm(expr2->data) );
 779       /*@notreached@*/ break;
 780
 781     case unaryExpr:
 782       if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
 783         return FALSE;
 784
 785       return (constraintExpr_similar (
 786               constraintExprData_unaryExprGetExpr (expr1->data),
 787               constraintExprData_unaryExprGetExpr (expr2->data)
 788               ));
 789
 790     case binaryexpr:
 791       if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
 792         return FALSE;
 793
 794       if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr1 (expr1->data),
 795                                  constraintExprData_binaryExprGetExpr1 (expr2->data)) )
 796         return FALSE;
 797
 798       if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr2 (expr1->data),
 799                                  constraintExprData_binaryExprGetExpr2 (expr2->data)) )
 800         return FALSE;
 801       else
 802         return TRUE;
 803       /*@notreached@*/
 804       break;
 805
 806     default:
 807       llassert(FALSE);
 808       return FALSE;
 809     }
 810   /*@notreached@*/
 811   return FALSE;
 812 }
 813
 814 bool constraintExpr_same (constraintExpr expr1, constraintExpr expr2)
 815 {
 816   constraintExprKind kind;
 817
 818   llassert (expr1 != NULL);
 819   llassert (expr2 != NULL);
 820   if (expr1->kind != expr2->kind)
 821     return FALSE;
 822
 823   kind = expr1->kind;
 824
 825   switch (kind)
 826     {
 827     case term:
 828       return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
 829                                   constraintExprData_termGetTerm(expr2->data) );
 830       /*@notreached@*/ break;
 831
 832     case unaryExpr:
 833       if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
 834         return FALSE;
 835
 836       return (constraintExpr_same (
 837               constraintExprData_unaryExprGetExpr (expr1->data),
 838               constraintExprData_unaryExprGetExpr (expr2->data)
 839               ));
 840
 841
 842     case binaryexpr:
 843       if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
 844         return FALSE;
 845
 846       if (! constraintExpr_same (constraintExprData_binaryExprGetExpr1 (expr1->data),
 847                                  constraintExprData_binaryExprGetExpr1 (expr2->data)) )
 848         return FALSE;
 849
 850       if (! constraintExpr_same (constraintExprData_binaryExprGetExpr2 (expr1->data),
 851                                  constraintExprData_binaryExprGetExpr2 (expr2->data)) )
 852         return FALSE;
 853       else
 854         return TRUE;
 855       /*@notreached@*/ break;
 856
 857     default:
 858       llassert(FALSE);
 859       return FALSE;
 860     }
 861
 862   /*@notreached@*/
 863   BADEXIT;
 864 }
 865
 866 bool constraintExpr_search (/*@observer@*/ constraintExpr c, /*@observer@*/ constraintExpr old)
 867 {
 868   bool ret = FALSE;
 869   constraintExprKind kind;
 870   constraintExpr temp;
 871
 872   if ( constraintExpr_similar (c, old) )
 873     {
 874       DPRINTF((message ("Found  %q",
 875                         constraintExpr_unparse(old)
 876                         )));
 877       return TRUE;
 878     }
 879
 880   kind = c->kind;
 881
 882   switch (kind)
 883     {
 884     case term:
 885       break;
 886     case unaryExpr:
 887       temp = constraintExprData_unaryExprGetExpr (c->data);
 888       ret = ret || constraintExpr_search (temp, old);
 889       break;
 890     case binaryexpr:
 891
 892       temp = constraintExprData_binaryExprGetExpr1 (c->data);
 893       ret = ret || constraintExpr_search(temp, old);
 894
 895       temp = constraintExprData_binaryExprGetExpr2 (c->data);
 896       ret = ret || constraintExpr_search(temp, old);
 897       break;
 898     default:
 899       llassert(FALSE);
 900     }
 901   return ret;
 902
 903 }
 904
 905
 906 /*@only@*/ constraintExpr constraintExpr_searchandreplace (/*@only@*/ /*@unique@*/ constraintExpr c, constraintExpr old, constraintExpr new )
 907 {
 908   constraintExprKind kind;
 909   constraintExpr temp;
 910
 911   if ( constraintExpr_similar (c, old) )
 912     {
 913
 914       DPRINTF((message ("Replacing %s with %s",
 915                         constraintExpr_unparse(old), constraintExpr_unparse(new)
 916                         )));
 917       constraintExpr_free(c);
 918       return constraintExpr_copy (new);
 919     }
 920
 921   kind = c->kind;
 922
 923   switch (kind)
 924     {
 925     case term:
 926       break;
 927     case unaryExpr:
 928       temp = constraintExprData_unaryExprGetExpr (c->data);
 929       temp = constraintExpr_copy(temp);
 930       temp = constraintExpr_searchandreplace (temp, old, new);
 931       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
 932       break;
 933     case binaryexpr:
 934
 935       temp = constraintExprData_binaryExprGetExpr1 (c->data);
 936       temp = constraintExpr_copy(temp);
 937       temp = constraintExpr_searchandreplace (temp, old, new);
 938       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
 939
 940       temp = constraintExprData_binaryExprGetExpr2 (c->data);
 941       temp = constraintExpr_copy(temp);
 942       temp = constraintExpr_searchandreplace (temp, old, new);
 943       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
 944       break;
 945     default:
 946       llassert(FALSE);
 947     }
 948   return c;
 949
 950 }
 951
 952 static constraintExpr constraintExpr_simplifyChildren (/*@returned@*/ constraintExpr c)
 953 {
 954   constraintExprKind kind;
 955   constraintExpr temp;
 956
 957   kind = c->kind;
 958
 959   switch (kind)
 960     {
 961     case term:
 962       break;
 963     case unaryExpr:
 964       temp = constraintExprData_unaryExprGetExpr (c->data);
 965       temp = constraintExpr_copy(temp);
 966       temp = constraintExpr_simplify (temp);
 967       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
 968       break;
 969     case binaryexpr:
 970       DPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) );
 971       temp = constraintExprData_binaryExprGetExpr1 (c->data);
 972       temp = constraintExpr_copy(temp);
 973       temp = constraintExpr_simplify (temp);
 974
 975       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
 976
 977       temp = constraintExprData_binaryExprGetExpr2 (c->data);
 978       temp = constraintExpr_copy(temp);
 979       temp = constraintExpr_simplify (temp);
 980
 981       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
 982       break;
 983     default:
 984       llassert(FALSE);
 985     }
 986   return c;
 987
 988 }
 989
 990
 991 constraintExpr constraintExpr_setFileloc (/*@returned@*/ constraintExpr c, fileloc loc) /*@modifies c->data @*/
 992 {
 993   constraintTerm t;
 994   constraintExpr temp;
 995
 996   llassert(c != NULL);
 997
 998   switch (c->kind)
 999     {
1000     case term:
1001       t = constraintExprData_termGetTerm (c->data);
1002       t = constraintTerm_copy(t);
1003       t = constraintTerm_setFileloc (t, loc);
1004       c->data = constraintExprData_termSetTerm (c->data, t);
1005       break;
1006     case binaryexpr:
1007
1008       temp = constraintExprData_binaryExprGetExpr1 (c->data);
1009       temp = constraintExpr_copy(temp);
1010       temp = constraintExpr_setFileloc (temp, loc);
1011       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1012
1013       temp = constraintExprData_binaryExprGetExpr2 (c->data);
1014       temp = constraintExpr_copy(temp);
1015       temp = constraintExpr_setFileloc (temp, loc);
1016       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1017       break;
1018     case unaryExpr:
1019       temp = constraintExprData_unaryExprGetExpr (c->data);
1020       temp = constraintExpr_copy(temp);
1021       temp = constraintExpr_setFileloc (temp, loc);
1022       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1023       break;
1024     }
1025   return c;
1026 }
1027
1028 static /*@only@*/ constraintExpr constraintExpr_simplifybinaryExpr (/*@only@*/constraintExpr c)
1029 {
1030   constraintExpr e1, e2;
1031
1032   e1 = constraintExprData_binaryExprGetExpr1 (c->data);
1033   e2 = constraintExprData_binaryExprGetExpr2 (c->data);
1034
1035   if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) )
1036     {
1037       int i;
1038
1039       i = constraintExpr_getValue(e1) + constraintExpr_getValue (e2);
1040       constraintExpr_free(c);
1041       c = constraintExpr_makeIntLiteral (i);
1042
1043     }
1044   return c;
1045 }
1046
1047
1048 /*@only@*/ static constraintExpr constraintExpr_subtractExpr (/*@only@*/ constraintExpr expr, /*@only@*/ constraintExpr addent)
1049 {
1050   constraintExpr  new;
1051
1052   DPRINTF ( (message ("Doing subtraceTerm simplification") ) );
1053
1054   new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
1055   new->data = constraintExprData_binaryExprSetOp (new->data, MINUS);
1056   return new;
1057 }
1058
1059 /*@only@*/
1060 static constraintExpr constraintExpr_addExpr (/*@only@*/
1061 constraintExpr expr, /*@only@*/
1062 constraintExpr addent)
1063 {
1064   constraintExpr  new;
1065
1066   DPRINTF ( (message ("Doing addTerm simplification") ) );
1067
1068   new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
1069   new->data = constraintExprData_binaryExprSetOp (new->data, PLUS);
1070   return new;
1071 }
1072
1073 /*
1074   this thing takes the lexpr and expr of a constraint and modifies lexpr
1075   and returns a (possiblly new) value for expr
1076 */
1077 /* if lexpr is a binary express say x + y, we set lexpr to x and return a value for expr such as expr_old - y */
1078
1079 /* the approach is a little Kludgy but seems to work.  I should probably use something cleaner at some point ... */
1080
1081
1082 /*@only@*/ constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, /*@only@*/ constraintExpr expr)
1083 {
1084   constraintExpr expr1, expr2;
1085   constraintExprBinaryOpKind op;
1086
1087   if (lexpr->kind != binaryexpr)
1088     return expr;
1089
1090   expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data);
1091   expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data);
1092
1093   op    = constraintExprData_binaryExprGetOp (lexpr->data);
1094
1095   expr1 = constraintExpr_copy(expr1);
1096   expr2 = constraintExpr_copy(expr2);
1097
1098 #warning make sure this works
1099
1100     lexpr->kind = expr1->kind;
1101     free (lexpr->data);
1102
1103     lexpr->data = copyExprData (expr1->data, expr1->kind);
1104     free(expr1);
1105
1106     if (op == PLUS)
1107       expr = constraintExpr_subtractExpr (expr, expr2);
1108     else if (op == MINUS)
1109       expr = constraintExpr_addExpr (expr, expr2);
1110     else
1111       BADEXIT;
1112
1113
1114     return expr;
1115
1116   /*
1117     #warning this needs to be checked
1118     expr = constraintExpr_solveBinaryExpr (expr1, expr);
1119
1120     expr = constraintExpr_solveBinaryExpr (expr2, expr);
1121     return expr;
1122   */
1123 }
1124
1125 static /*@only@*/ constraintExpr constraintExpr_simplifyunaryExpr (/*@only@*/ constraintExpr c)
1126 {
1127   constraintExpr exp;
1128
1129   llassert (c->kind == unaryExpr);
1130
1131   DPRINTF ( (message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
1132
1133   if ( (constraintExprData_unaryExprGetOp (c->data) != MAXSET) &&
1134        (constraintExprData_unaryExprGetOp (c->data) != MAXREAD) )
1135     {
1136       return c;
1137     }
1138   // pattern mxr ( var + const) = mxr(var) - const
1139
1140   exp = constraintExprData_unaryExprGetExpr (c->data);
1141
1142   if (exp->kind == term)
1143     {
1144       constraintTerm cterm;
1145
1146       cterm = constraintExprData_termGetTerm (exp->data);
1147
1148       if (constraintTerm_isStringLiteral(cterm) )
1149         {
1150           cstring val;
1151           val = constraintTerm_getStringLiteral (cterm);
1152           if (constraintExprData_unaryExprGetOp (c->data) == MAXSET)
1153             {
1154               constraintExpr temp;
1155
1156               temp = constraintExpr_makeIntLiteral ((int)strlen (val) );
1157               cstring_free(val);
1158               constraintExpr_free(c);
1159               return temp;
1160             }
1161           if (constraintExprData_unaryExprGetOp (c->data) == MAXREAD)
1162             {
1163               constraintExpr temp;
1164
1165               temp = constraintExpr_makeIntLiteral ((int)strlen (val) );
1166               cstring_free(val);
1167               constraintExpr_free(c);
1168               return temp;
1169             }
1170           BADEXIT;
1171         }
1172       return c;
1173     }
1174
1175   if (exp->kind != binaryexpr)
1176     return c;
1177
1178   if (constraintExprData_binaryExprGetOp (exp->data) == PLUS  )
1179     {
1180
1181       //      if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) )
1182         {
1183
1184           constraintExpr  temp, temp2, new;
1185
1186           DPRINTF ( (message ("Doing fancy simplification") ) );
1187
1188           temp = constraintExprData_binaryExprGetExpr2 (exp->data);
1189
1190           temp2 = constraintExprData_binaryExprGetExpr1 (exp->data);
1191
1192           temp2 = constraintExpr_copy(temp2);
1193           c->data = constraintExprData_unaryExprSetExpr (c->data, temp2);
1194
1195
1196           temp = constraintExpr_copy (temp);
1197
1198           new = constraintExpr_subtractExpr (c, temp);
1199
1200           DPRINTF ( (message ("Done fancy simplification:%s", constraintExpr_unparse (new) ) ) );
1201           c = new;
1202         }
1203     }
1204
1205   DPRINTF ( (message ("Done simplification:%s", constraintExpr_unparse (c) ) ) );
1206   return c;
1207 }
1208
1209
1210 /*@only@*/ constraintExpr constraintExpr_simplify (/*@only@*/ constraintExpr c)
1211 {
1212   constraintExprKind kind;
1213   constraintExpr ret;
1214   constraintTerm t;
1215
1216   DPRINTF ( (message ("Doing constraintExpr_simplify:%s", constraintExpr_unparse (c) ) ) );
1217
1218
1219   /*@i22*/
1220
1221   /*I think this is an LCLint bug */
1222
1223   ret =  constraintExpr_copy(c);
1224
1225   constraintExpr_free(c);
1226
1227   ret = constraintExpr_simplifyChildren (ret);
1228
1229   ret = constraintExpr_combineConstants (ret);
1230
1231   ret = constraintExpr_simplifyChildren (ret);
1232
1233
1234   kind = ret->kind;
1235
1236   switch (kind)
1237     {
1238     case term:
1239       t = constraintExprData_termGetTerm (ret->data);
1240       t = constraintTerm_copy(t);
1241       t = constraintTerm_simplify (t);
1242       ret->data = constraintExprData_termSetTerm (ret->data, t);
1243       break;
1244     case unaryExpr:
1245       ret = constraintExpr_simplifyunaryExpr (ret);
1246       break;
1247     case binaryexpr:
1248       ret = constraintExpr_simplifybinaryExpr (ret);
1249       break;
1250     default:
1251       llassert(FALSE);
1252     }
1253
1254   DPRINTF ( (message ("constraintExpr_simplify returning :%s", constraintExpr_unparse (ret) ) ) );
1255   return ret;
1256
1257 }
1258
1259 /*@only@*/
1260 cstring constraintExpr_unparse (/*@observer@*/ constraintExpr ex) /*@*/
1261 {
1262   cstring st;
1263   constraintExprKind kind;
1264
1265   llassert (ex != NULL);
1266
1267   kind = ex->kind;
1268
1269   switch (kind)
1270     {
1271     case term:
1272       st = message ("(%q) ", constraintTerm_print (constraintExprData_termGetTerm(ex->data) ) );
1273       break;
1274     case unaryExpr:
1275       st = message ("%q (%q)",
1276                     constraintExprUnaryOpKind_print (constraintExprData_unaryExprGetOp (ex->data)
1277                                                      ),
1278                     constraintExpr_unparse (constraintExprData_unaryExprGetExpr (ex->data) )
1279                     );
1280       break;
1281     case binaryexpr:
1282       st = message ("(%q) %q (%q)",
1283                     constraintExpr_unparse (constraintExprData_binaryExprGetExpr1 (ex->data) ),
1284                     constraintExprBinaryOpKind_print (constraintExprData_binaryExprGetOp (ex->data)
1285                                                      ),
1286                     constraintExpr_unparse (constraintExprData_binaryExprGetExpr2 (ex->data) )
1287                     );
1288       break;
1289     default:
1290       llassert(FALSE);
1291       st = message ("error");
1292
1293     }
1294
1295   DPRINTF((message ("constraintExpr_unparse: '%s'",st) ) );
1296   return st;
1297 }
1298
1299 constraintExpr constraintExpr_doSRefFixBaseParam (/*@returned@*/  constraintExpr expr, exprNodeList arglist)
1300 {
1301   constraintTerm Term;
1302   constraintExprKind kind;
1303   constraintExpr expr1, expr2;
1304   constraintExprData data;
1305   llassert (expr != NULL);
1306
1307   data = expr->data;
1308
1309   kind = expr->kind;
1310
1311   switch (kind)
1312     {
1313     case term:
1314       Term = constraintExprData_termGetTerm(data);
1315       Term = constraintTerm_copy(Term);
1316
1317       Term = constraintTerm_doSRefFixBaseParam (Term, arglist);
1318       data = constraintExprData_termSetTerm(data, Term);
1319       break;
1320     case unaryExpr:
1321       expr1 = constraintExprData_unaryExprGetExpr (data);
1322       expr1 = constraintExpr_copy(expr1);
1323
1324       expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
1325       data = constraintExprData_unaryExprSetExpr (data, expr1);
1326       break;
1327     case binaryexpr:
1328       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1329       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1330
1331       expr1 = constraintExpr_copy(expr1);
1332       expr2 = constraintExpr_copy(expr2);
1333
1334       expr1 = constraintExpr_doSRefFixBaseParam (expr1, arglist);
1335       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1336       expr2 = constraintExpr_doSRefFixBaseParam (expr2, arglist);
1337       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1338
1339       break;
1340     default:
1341       llassert(FALSE);
1342       data = NULL;
1343     }
1344   return expr;
1345 }
1346
1347 /*@only@*/ constraintExpr constraintExpr_doSRefFixConstraintParam (/*@only@*/ constraintExpr expr, exprNodeList arglist) /*@modifies expr@*/
1348 {
1349   constraintExprKind kind;
1350   constraintExpr expr1, expr2;
1351   constraintExprData data;
1352   llassert (expr != NULL);
1353
1354   data = expr->data;
1355
1356   kind = expr->kind;
1357
1358   switch (kind)
1359     {
1360     case term:
1361       expr = doSRefFixConstraintParamTerm (expr, arglist);
1362       break;
1363     case unaryExpr:
1364       expr1 = constraintExprData_unaryExprGetExpr (data);
1365       expr1 = constraintExpr_copy(expr1);
1366       expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
1367       data = constraintExprData_unaryExprSetExpr (data, expr1);
1368       break;
1369     case binaryexpr:
1370       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1371       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1372
1373       expr1 = constraintExpr_copy(expr1);
1374       expr2 = constraintExpr_copy(expr2);
1375
1376       expr1 = constraintExpr_doSRefFixConstraintParam (expr1, arglist);
1377       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1378       expr2 = constraintExpr_doSRefFixConstraintParam (expr2, arglist);
1379       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1380
1381       break;
1382     default:
1383       llassert(FALSE);
1384       data = NULL;
1385     }
1386   return expr;
1387 }
1388
1389 constraintExpr constraintExpr_doFixResult (/*@returned@*/  constraintExpr expr, exprNode fcnCall)
1390 {
1391   constraintExprKind kind;
1392   constraintExpr expr1, expr2;
1393   constraintExprData data;
1394   llassert (expr != NULL);
1395
1396   data = expr->data;
1397
1398   kind = expr->kind;
1399
1400   switch (kind)
1401     {
1402     case term:
1403       expr = doFixResultTerm (expr, fcnCall);
1404       break;
1405     case unaryExpr:
1406       expr1 = constraintExprData_unaryExprGetExpr (data);
1407       expr1 = constraintExpr_copy(expr1);
1408
1409       expr1 = constraintExpr_doFixResult (expr1, fcnCall);
1410       data = constraintExprData_unaryExprSetExpr (data, expr1);
1411       break;
1412     case binaryexpr:
1413       expr1 = constraintExprData_binaryExprGetExpr1 (data);
1414       expr2 = constraintExprData_binaryExprGetExpr2 (data);
1415
1416       expr1 = constraintExpr_copy(expr1);
1417       expr2 = constraintExpr_copy(expr2);
1418
1419       expr1 = constraintExpr_doFixResult (expr1, fcnCall);
1420       data = constraintExprData_binaryExprSetExpr1 (data, expr1);
1421       expr2 = constraintExpr_doFixResult (expr2, fcnCall);
1422       data = constraintExprData_binaryExprSetExpr2 (data, expr2);
1423
1424       break;
1425     default:
1426       llassert(FALSE);
1427       data = NULL;
1428     }
1429   return expr;
1430 }
1431
1432 cstring constraintExpr_print (constraintExpr expr) /*@*/
1433 {
1434   return constraintExpr_unparse(expr);
1435 }
1436
1437 bool constraintExpr_hasMaxSet (constraintExpr expr) /*@*/
1438 {
1439   cstring t;
1440
1441   t = constraintExpr_unparse(expr);
1442
1443   if (strstr (t, "MAXSET") != NULL )
1444     {
1445       cstring_free(t);
1446       return (TRUE);
1447     }
1448   else
1449     {
1450       cstring_free(t);
1451       return FALSE;
1452     }
1453 }
1454
1455
1456
1457       /*returns 1 0 -1 like strcmp
1458         1 => expr1 > expr2
1459         0 => expr1 == expr2
1460         -1 => expr1 < expr2
1461        */
1462 int constraintExpr_compare (constraintExpr expr1, constraintExpr expr2)
1463 {
1464   int value1, value2;
1465
1466   if (constraintExpr_similar (expr1, expr2) )
1467     {
1468       return 0;
1469     }
1470   value1 = constraintExpr_getValue(expr1);
1471   value2 = constraintExpr_getValue(expr2);
1472
1473   if (value1 > value2)
1474     return 1;
1475
1476   if (value1 == value2)
1477     return 0;
1478
1479   else
1480     return -1;
1481 }
1482
1483 int constraintExpr_getValue (constraintExpr expr)
1484 {
1485   llassert (expr->kind == term);
1486   return (constraintTerm_getValue (constraintExprData_termGetTerm (expr->data) ) );
1487 }
1488
1489 bool constraintExpr_canGetValue (constraintExpr expr)
1490 {
1491   switch (expr->kind)
1492     {
1493     case term:
1494       return constraintTerm_canGetValue (constraintExprData_termGetTerm (expr->data) );
1495     default:
1496       return FALSE;
1497
1498     }
1499
1500   BADEXIT;
1501 }
1502
1503 fileloc constraintExpr_getFileloc (constraintExpr expr)
1504 {
1505   constraintExpr e;
1506 constraintTerm t;
1507   constraintExprKind kind;
1508
1509  kind = expr->kind;
1510
1511   switch (kind)
1512     {
1513     case term:
1514       t = constraintExprData_termGetTerm (expr->data);
1515       return (constraintTerm_getFileloc (t) );
1516       /*@notreached@*/
1517       break;
1518     case unaryExpr:
1519       e = constraintExprData_unaryExprGetExpr (expr->data);
1520       return (constraintExpr_getFileloc (e) );
1521       /*@notreached@*/
1522       break;
1523     case binaryexpr:
1524       e = constraintExprData_binaryExprGetExpr1 (expr->data);
1525       return (constraintExpr_getFileloc (e) );
1526       /*@notreached@*/
1527       break;
1528     }
1529   llassert (FALSE);
1530   return (fileloc_undefined);
1531 }
1532
1533 /*drl moved from constriantTerm.c 5/20/001*/
1534 static constraintExpr
1535 doFixResultTerm (constraintExpr e, exprNode fcnCall)
1536 {
1537   constraintTerm t;
1538   sRef s;
1539   /*maybe this should move to cosntraintExpr.c -drl7x 5/18/01*/
1540   /*@i22*/ constraintExprData data = e->data;
1541
1542   /*@i22*/constraintExprKind kind = e->kind;
1543
1544   constraintExpr ret;
1545
1546   llassert(kind == term);
1547
1548   t = constraintExprData_termGetTerm (data);
1549   llassert (t != NULL);
1550
1551   ret = e;
1552   switch (constraintTerm_getKind(t) )
1553     {
1554     case EXPRNODE:
1555       break;
1556     case INTLITERAL:
1557       break;
1558
1559     case SREF:
1560       s = constraintTerm_getSRef(t);
1561       if (sRef_isResult (s))
1562         {
1563           ret = constraintExpr_makeExprNode(fcnCall);
1564         }
1565       break;
1566     default:
1567       BADEXIT;
1568     }
1569
1570   return ret;
1571
1572 }
1573
1574 /*drl moved from constriantTerm.c 5/20/001*/
1575 /*@only@*/ static constraintExpr
1576 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, exprNodeList arglist)
1577 {
1578   constraintTerm t;
1579
1580   constraintExprData data = e->data;
1581
1582   constraintExprKind kind = e->kind;
1583
1584   constraintExpr ret;
1585
1586   llassert(kind == term);
1587
1588   t = constraintExprData_termGetTerm (data);
1589   llassert (t != NULL);
1590
1591   ret = e;
1592   /*@i1*/ switch (t->kind)
1593     {
1594     case EXPRNODE:
1595       DPRINTF((message ("%q @ %q ", constraintTerm_print(t),
1596                         fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
1597       break;
1598     case INTLITERAL:
1599       DPRINTF((message (" %q ", constraintTerm_print (t)) ));
1600       break;
1601
1602     case SREF:
1603       DPRINTF (( message("Doing sRef_fixConstraintParam for %q ",
1604                          constraintTerm_print (t) ) ));
1605       ret = sRef_fixConstraintParam (t->value.sref, arglist);
1606
1607       constraintExpr_free(e);
1608
1609       DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
1610                          constraintExpr_print (ret) ) ));
1611       break;
1612     default:
1613       BADEXIT;
1614     }
1615   return ret;
1616
1617 }
1618
1619
1620 /* bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term) */
1621 /* { */
1622 /*   if (constraintTerm_hasTerm (expr->term, term) ) */
1623 /*     return TRUE; */
1624
1625 /*   if ( (expr->expr) != NULL) */
1626 /*     { */
1627 /*       return ( constraintExpr_includesTerm (expr->expr, term) ); */
1628 /*     } */
1629 /*   return FALSE; */
1630
1631 /* } */
1632
1633 /*drl added 6/11/01 */
1634 bool constraintExpr_isBinaryExpr (/*@observer@*/ constraintExpr c)
1635 {
1636   if (c->kind == binaryexpr)
1637     return TRUE;
1638
1639   else
1640     return FALSE;
1641 }
1642
1643