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, /*@temp@*/ /*@observer@*/ exprNodeList arglist) /*@modifies e@*/;
  31
  32 static /*@only@*/ constraintExpr
  33 doFixResultTerm (/*@only@*/ constraintExpr e, /*@exposed@*/ exprNode fcnCall)
  34      /*@modifies e@*/;
  35
  36
  37 /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void) /*@allocates result->data @*/ /*@sets result->kind @*/;
  38
  39 //constraintExpr constraintExpr_makeMaxSetConstraintExpr (constraintExpr c);
  40
  41 void constraintExpr_free (/*@only@*/ constraintExpr expr)
  42 {
  43   if (constraintExpr_isDefined(expr) )
  44     {
  45       switch (expr->kind)
  46         {
  47         case unaryExpr:
  48           constraintExprData_freeUnaryExpr(expr->data);
  49           break;
  50         case binaryexpr:
  51           constraintExprData_freeBinaryExpr(expr->data);
  52           break;
  53         case term:
  54           constraintExprData_freeTerm(expr->data);
  55           break;
  56         default:
  57           BADEXIT;
  58         }
  59
  60       expr->data = NULL;
  61       free (expr);
  62     }
  63   else
  64     {
  65       llcontbug(message("attempted to free null pointer in constraintExpr_free"));
  66     }
  67 }
  68
  69 bool constraintExpr_isLit (constraintExpr expr)
  70 {
  71   llassert (expr != NULL);
  72
  73   if (expr->kind == term)
  74     {
  75       constraintTerm term = constraintExprData_termGetTerm (expr->data);
  76       if (constraintTerm_isIntLiteral (term) )
  77         {
  78           return TRUE;
  79         }
  80
  81     }
  82   return FALSE;
  83 }
  84
  85
  86 /*@only@*/ constraintExpr constraintExpr_propagateConstants (/*@only@*/ constraintExpr expr,
  87                                                 /*@out@*/ bool * propagate,
  88                                                   /*@out@*/ int *literal)
  89 {
  90   constraintExpr expr1;
  91   constraintExpr expr2;
  92   bool propagate1, propagate2;
  93   int literal1, literal2;
  94   constraintExprBinaryOpKind  op;
  95
  96   propagate1 = FALSE;
  97   propagate2 = FALSE;
  98
  99   literal1 = 0;
 100   literal2 = 0;
 101
 102   *propagate = FALSE;
 103   *literal = 0;
 104
 105   llassert (expr != NULL);
 106
 107   // we simplify unaryExpr else where
 108   if (expr->kind != binaryexpr)
 109     return expr;
 110
 111   op = constraintExprData_binaryExprGetOp (expr->data);
 112
 113   DPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
 114
 115   expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
 116   expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
 117
 118   expr1 = constraintExpr_copy(expr1);
 119   expr2 = constraintExpr_copy(expr2);
 120
 121   expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
 122   expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
 123
 124   *propagate = propagate1 || propagate2;
 125   *literal    = literal1 +  literal2;
 126
 127   if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
 128     {
 129       int t1, t2;
 130       t1 = constraintExpr_getValue (expr1);
 131       t2 = constraintExpr_getValue (expr2);
 132       *propagate = FALSE;
 133
 134       constraintExpr_free (expr);
 135       constraintExpr_free (expr1);
 136       constraintExpr_free (expr2);
 137
 138       if (op == PLUS )
 139         return (constraintExpr_makeIntLiteral ( (t1+t2) ));
 140       else if (op ==  MINUS)
 141         return (constraintExpr_makeIntLiteral ( (t1-t2) ));
 142       else
 143         BADEXIT;
 144     }
 145
 146
 147
 148
 149   if (constraintExpr_isLit (expr1) )
 150     {
 151       *propagate = TRUE;
 152
 153       if (op == PLUS )
 154         *literal += constraintExpr_getValue (expr1);
 155       else
 156         *literal -= constraintExpr_getValue (expr1);
 157
 158       constraintExpr_free(expr1);
 159       constraintExpr_free(expr);
 160       return expr2;
 161     }
 162
 163   if (constraintExpr_isLit (expr2) )
 164     {
 165       *propagate = TRUE;
 166
 167       if ( op == PLUS )
 168         *literal += constraintExpr_getValue (expr2);
 169       else
 170         *literal -= constraintExpr_getValue (expr2);
 171
 172       constraintExpr_free(expr2);
 173       constraintExpr_free(expr);
 174       return expr1;
 175     }
 176
 177   DPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
 178
 179   expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
 180   expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
 181
 182   return expr;
 183 }
 184
 185 //  constraintExpr constraintExpr_propagateConstantsBak (constraintExpr expr,
 186 //                                              /*@out@*/ bool * propagate,
 187 //                                                /*@out@*/ int *literal)
 188 //  {
 189 //    constraintExpr expr1;
 190 //    constraintExpr expr2;
 191 //    bool propagate1, propagate2;
 192 //    int literal1, literal2;
 193
 194 //    propagate1 = FALSE;
 195 //    propagate2 = FALSE;
 196
 197 //    literal1 = 0;
 198 //    literal2 = 0;
 199
 200 //    *propagate = FALSE;
 201 //    *literal = 0;
 202
 203 //    llassert (expr != NULL);
 204
 205 //    // we simplify unaryExpr else where
 206 //    if (expr->kind == unaryExpr)
 207 //      return expr;
 208
 209 //    if (expr->kind == term)
 210 //      return expr;
 211
 212 //    if (constraintExpr_isLit (expr) )
 213 //      return expr;
 214
 215 //    DPRINTF( (message("constraintExpr_propagateConstants: binaryexpr: %s", constraintExpr_unparse(expr) ) ) );
 216
 217 //    expr1 = constraintExprData_binaryExprGetExpr1(expr->data);
 218 //    expr2 = constraintExprData_binaryExprGetExpr2(expr->data);
 219
 220 //    expr1 = constraintExpr_propagateConstants (expr1, &propagate1, &literal1);
 221 //    expr2 = constraintExpr_propagateConstants (expr2, &propagate2, &literal2);
 222
 223 //    expr->data = constraintExprData_binaryExprSetExpr1 (expr->data, expr1);
 224 //    expr->data = constraintExprData_binaryExprSetExpr2 (expr->data, expr2);
 225
 226 //    *propagate = propagate1 || propagate2;
 227 //    *literal    = literal1 +  literal2;
 228
 229 //    if ( constraintExpr_isLit (expr1) && constraintExpr_isLit (expr2) )
 230 //      {
 231 //        int t1, t2;
 232 //        t1 = constraintExpr_getValue (expr1);
 233 //        t2 = constraintExpr_getValue (expr2);
 234 //        *propagate = FALSE;
 235
 236 //        if (constraintExprData_binaryExprGetOp (expr->data) == PLUS )
 237 //      return (constraintExpr_makeIntLiteral ( (t1+t2) ));
 238 //        else if (constraintExprData_binaryExprGetOp (expr->data) ==  MINUS)
 239 //      return (constraintExpr_makeIntLiteral ( (t1-t2) ));
 240 //        else
 241 //      llassert(FALSE);
 242 //      }
 243
 244 //    if (constraintExpr_isLit (expr1) )
 245 //      {
 246 //        /*@i334*/
 247 //        /*handle MINUS case right */
 248 //        *propagate = TRUE;
 249 //        *literal += constraintExpr_getValue (expr1);
 250 //        /*@-compdef@*/
 251 //        return expr2;
 252 //        /*@=compdef@*/
 253 //      }
 254
 255 //    /*@-compdef@*/
 256 //    if (constraintExpr_isLit (expr2) )
 257 //      {
 258 //        *propagate = TRUE;
 259
 260 //        if (constraintExprData_binaryExprGetOp (expr->data) == PLUS )
 261 //      *literal += constraintExpr_getValue (expr2);
 262 //        else
 263 //      *literal -= constraintExpr_getValue (expr2);
 264 //        return expr1;
 265 //      }
 266
 267
 268
 269
 270 //    DPRINTF( (message("constraintExpr_propagateConstants returning: %s", constraintExpr_unparse(expr) ) ) );
 271
 272 //    return expr;
 273 //    /*@=compdef@*/
 274 //  }
 275
 276 /*@only@*/ static constraintExpr constraintExpr_combineConstants (/*@only@*/ constraintExpr expr ) /*@modifies expr@*/
 277 {
 278   bool propagate;
 279   int literal;
 280
 281   DPRINTF ( (message ("Before combine %s", constraintExpr_unparse(expr) ) ) );
 282   expr = constraintExpr_propagateConstants (expr, &propagate, &literal);
 283
 284
 285   if (propagate)
 286     {
 287       constraintExpr ret;
 288
 289       if (literal != 0)
 290         {
 291           ret = constraintExpr_makeBinaryOpConstraintExprIntLiteral (expr, literal);
 292           expr = ret;
 293         }
 294     }
 295    DPRINTF ( (message ("After combine %s", constraintExpr_unparse(expr) ) ) );
 296   return expr;
 297 }
 298
 299 /*@special@*/
 300 static constraintExpr constraintExpr_alloc (void) /*@post:isnull result->data@*/
 301 {
 302   constraintExpr ret;
 303   ret = dmalloc (sizeof (*ret) );
 304   ret->kind = term;
 305   ret->data = NULL;
 306   return ret;
 307 }
 308
 309 /*@only@*/ static constraintExprData copyExprData (/*@observer@*/ constraintExprData data, constraintExprKind kind)
 310 {
 311   constraintExprData ret;
 312   llassert(constraintExprData_isDefined(data));
 313
 314   switch (kind)
 315     {
 316     case binaryexpr:
 317       ret = constraintExprData_copyBinaryExpr(data);
 318       break;
 319     case unaryExpr:
 320       ret = constraintExprData_copyUnaryExpr(data);
 321       break;
 322     case term:
 323       ret = constraintExprData_copyTerm(data);
 324       break;
 325     default:
 326       BADEXIT;
 327     }
 328   return ret;
 329 }
 330
 331 constraintExpr constraintExpr_copy (constraintExpr expr)
 332 {
 333   constraintExpr ret;
 334   ret = constraintExpr_alloc();
 335   ret->kind = expr->kind;
 336
 337   ret->data = copyExprData (expr->data, expr->kind);
 338   return ret;
 339 }
 340
 341
 342 /*@only@*/ static constraintExpr oldconstraintExpr_makeTermExprNode (/*@exposed@*/ exprNode e)
 343 {
 344   constraintExpr ret;
 345   constraintTerm t;
 346   ret = constraintExpr_alloc();
 347   ret->kind = term;
 348   ret->data = dmalloc (sizeof *(ret->data) );
 349   t = constraintTerm_makeExprNode (e);
 350   ret->data = constraintExprData_termSetTerm (ret->data, t);
 351   return ret;
 352 }
 353
 354 constraintExpr constraintExpr_makeExprNode (/*@exposed@*/ exprNode e)
 355 {
 356  sRef s;
 357  constraintExpr ret, ce1, ce2;
 358  exprData data;
 359  exprNode t, t1, t2;
 360  lltok tok;
 361
 362
 363  llassert (e != NULL);
 364
 365  data = e->edata;
 366
 367  switch (e->kind)
 368    {
 369    case XPR_SIZEOF:
 370      t = exprData_getSingle (data);
 371      s = exprNode_getSref (t);
 372      if (sRef_isFixedArray(s) )
 373       {
 374         int size;
 375
 376         size = (int) sRef_getArraySize(s);
 377         ret = constraintExpr_makeIntLiteral (size);
 378       }
 379      else
 380        {
 381          DPRINTF ((message ("could not determine the size of %s", exprNode_unparse (e) ) ) );
 382          ret = oldconstraintExpr_makeTermExprNode (e);
 383        }
 384      break;
 385
 386    case XPR_OP:
 387       DPRINTF ((message ("Examining operation %s", exprNode_unparse (e) ) ) );
 388      t1 = exprData_getOpA (data);
 389      t2 = exprData_getOpB (data);
 390      tok = exprData_getOpTok (data);
 391
 392      if (lltok_isPlus_Op (tok) || lltok_isMinus_Op (tok) )
 393        {
 394          ce1 = constraintExpr_makeExprNode (t1);
 395          ce2 = constraintExpr_makeExprNode (t2);
 396          ret = constraintExpr_parseMakeBinaryOp (ce1, tok, ce2);
 397        }
 398      else
 399        {
 400         ret = oldconstraintExpr_makeTermExprNode (e);
 401        }
 402      break;
 403    case XPR_PARENS:
 404      t = exprData_getUopNode (data);
 405      ret = constraintExpr_makeExprNode (t);
 406      break;
 407
 408    case XPR_PREOP:
 409       t = exprData_getUopNode (data);
 410       tok =  exprData_getUopTok (data);
 411       if (lltok_isInc_Op (tok) )
 412         {
 413           constraintExpr temp;
 414           temp = constraintExpr_makeExprNode(t);
 415           ret = constraintExpr_makeIncConstraintExpr(temp);
 416         }
 417       else if (lltok_isDec_Op (tok) )
 418         {
 419           constraintExpr temp;
 420           temp = constraintExpr_makeExprNode(t);
 421           ret = constraintExpr_makeDecConstraintExpr(temp);
 422         }
 423       else
 424         ret =  oldconstraintExpr_makeTermExprNode (e);
 425       break;
 426
 427    case XPR_POSTOP:
 428      t = exprData_getUopNode (data);
 429           ret = constraintExpr_makeExprNode (t);
 430      break;
 431    case XPR_CAST:
 432      t = exprData_getCastNode (data);
 433      ret = constraintExpr_makeExprNode (t);
 434      break;
 435    case XPR_COMMA:
 436      t = exprData_getPairA(data);
 437      ret = constraintExpr_makeExprNode(t);
 438      /*@i3434*/ /*I'm not sure if this is right.  I'm adding a break to quite LCLint*/
 439      break;
 440    default:
 441      ret = oldconstraintExpr_makeTermExprNode (e);
 442
 443    }
 444   return ret;
 445 }
 446
 447
 448 /*@only@*/ static constraintExpr constraintExpr_makeTermExprNode (/*@exposed@*/ exprNode e)
 449 {
 450   return  oldconstraintExpr_makeTermExprNode(e); //constraintExpr_makeExprNode (e);
 451 }
 452
 453
 454 constraintExpr constraintExpr_makeTermsRef ( sRef s)
 455 {
 456   constraintExpr ret;
 457   constraintTerm t;
 458   ret = constraintExpr_alloc();
 459   ret->kind = term;
 460   ret->data = dmalloc (sizeof *(ret->data) );
 461   t = constraintTerm_makesRef (s);
 462   ret->data = constraintExprData_termSetTerm (ret->data, t);
 463   return ret;
 464 }
 465
 466 /*@special@*/ static constraintExpr constraintExpr_makeUnaryOp (void) /*@allocates result->data@*/ /*@defines result->kind@*/
 467 {
 468   constraintExpr ret;
 469   ret = constraintExpr_alloc();
 470   ret->kind = unaryExpr;
 471   ret->data = dmalloc ( sizeof *(ret->data) );
 472   return ret;
 473 }
 474
 475 /*@only@*/ static constraintExpr constraintExpr_makeUnaryOpConstraintExpr (/*@only@*/ constraintExpr cexpr)
 476 {
 477   constraintExpr ret;
 478   ret = constraintExpr_makeUnaryOp();
 479
 480   /*@-uniondef@*/
 481   /*@-compdef@*/
 482     ret->data = constraintExprData_unaryExprSetExpr (ret->data, cexpr);
 483     ret->data = constraintExprData_unaryExprSetOp (ret->data, UNARYOP_UNDEFINED);
 484
 485   return ret;
 486
 487   /*@=compdef@*/
 488   /*@=uniondef@*/
 489 }
 490
 491 /*@only@*/
 492 static constraintExpr constraintExpr_makeMaxSetConstraintExpr (/*@only@*/ constraintExpr c)
 493 {
 494   constraintExpr ret;
 495   ret = constraintExpr_makeUnaryOpConstraintExpr (c);
 496   ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
 497   return ret;
 498 }
 499
 500 /*@only@*/
 501 static constraintExpr constraintExpr_makeUnaryOpExprNode (/*@exposed@*/ exprNode expr)
 502 {
 503   constraintExpr ret;
 504   constraintExpr sub;
 505   sub = constraintExpr_makeExprNode (expr);
 506   ret = constraintExpr_makeUnaryOpConstraintExpr(sub);
 507
 508   return ret;
 509 }
 510
 511
 512
 513 /*@only@*/
 514 static constraintExpr constraintExpr_makeSRefUnaryOp (/*@exposed@*/ sRef s,  constraintExprUnaryOpKind op)
 515 {
 516   constraintExpr ret;
 517   constraintExpr t;
 518
 519   t = constraintExpr_makeTermsRef (s);
 520   ret = constraintExpr_makeUnaryOpConstraintExpr (t);
 521   ret->data = constraintExprData_unaryExprSetOp (ret->data, op);
 522
 523   return ret;
 524 }
 525
 526 /*@only@*/
 527 constraintExpr constraintExpr_makeSRefMaxRead(/*@exposed@*/ sRef s)
 528 {
 529   return (constraintExpr_makeSRefUnaryOp (s, MAXREAD) );
 530 }
 531
 532 /*@only@*/
 533 constraintExpr constraintExpr_makeSRefMaxset (/*@exposed@*/ sRef s)
 534 {
 535   return (constraintExpr_makeSRefUnaryOp (s, MAXSET) );
 536 }
 537
 538 /*@only@*/
 539 constraintExpr constraintExpr_parseMakeUnaryOp (lltok op, constraintExpr cexpr)
 540 {
 541   constraintExpr ret;
 542   ret = constraintExpr_makeUnaryOpConstraintExpr ( cexpr);
 543
 544   switch (op.tok)
 545     {
 546     case QMAXSET:
 547       ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXSET);
 548       break;
 549     case QMAXREAD:
 550       ret->data = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
 551       break;
 552     default:
 553       llfatalbug(message("Unhandled Operation in Constraint") );
 554     }
 555   return ret;
 556 }
 557
 558 /*@only@*/
 559 constraintExpr constraintExpr_makeMaxSetExpr (/*@exposed@*/ exprNode expr)
 560 {
 561   constraintExpr ret;
 562   ret = constraintExpr_makeExprNode (expr);
 563
 564   ret = constraintExpr_makeMaxSetConstraintExpr (ret);
 565
 566   llassert (ret != NULL);
 567   return ret;
 568 }
 569
 570 /*@only@*/
 571 constraintExpr  constraintExpr_makeMaxReadExpr (exprNode expr)
 572 {
 573   constraintExpr ret;
 574   ret = constraintExpr_makeUnaryOpExprNode(expr);
 575   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MAXREAD);
 576   return ret;
 577 }
 578
 579 /*@only@*/
 580 /*@unused@*/ constraintExpr  constraintExpr_makeMinSetExpr (/*@exposed@*/ exprNode expr)
 581 {
 582   constraintExpr ret;
 583   ret = constraintExpr_makeUnaryOpExprNode(expr);
 584   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MINSET);
 585   return ret;
 586 }
 587
 588 /*@only@*/
 589 /*@unused@*/ constraintExpr constraintExpr_makeMinReadExpr (/*@exposed@*/ exprNode expr)
 590 {
 591   constraintExpr ret;
 592   ret = constraintExpr_makeUnaryOpExprNode(expr);
 593   ret->data      = constraintExprData_unaryExprSetOp (ret->data, MINREAD);
 594   return ret;
 595 }
 596
 597
 598 /*@only@*/
 599 constraintExpr constraintExpr_makeValueExpr (/*@exposed@*/ exprNode expr)
 600 {
 601   constraintExpr ret;
 602   ret = constraintExpr_makeExprNode (expr);
 603   return ret;
 604 }
 605
 606 /*@only@*/
 607 constraintExpr constraintExpr_makeIntLiteral (int i)
 608 {
 609   constraintExpr ret;
 610   constraintTerm t;
 611   ret = constraintExpr_alloc();
 612   ret->kind = term;
 613   ret->data = dmalloc (sizeof *(ret->data) );
 614   t = constraintTerm_makeIntLiteral (i);
 615   ret->data = constraintExprData_termSetTerm (ret->data, t);
 616   return ret;
 617 }
 618
 619 /*
 620 constraintExpr constraintExpr_makeValueInt (int i)
 621 {
 622   return constraintExpr_makeIntLiteral (i);
 623 }
 624 */
 625
 626 /*@only@*/
 627  /*@special@*/ static constraintExpr constraintExpr_makeBinaryOp (void) /*@allocates result->data @*/ /*@sets result->kind @*/
 628 {
 629   constraintExpr ret;
 630   ret = constraintExpr_alloc();
 631   ret->kind = binaryexpr;
 632   ret->data = dmalloc ( sizeof *(ret->data) );
 633   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
 634   return ret;
 635 }
 636
 637
 638 static /*@only@*/ constraintExpr constraintExpr_makeBinaryOpConstraintExpr (/*@only@*/constraintExpr expr1, /*@only@*/ constraintExpr expr2)
 639
 640 {
 641   constraintExpr ret;
 642
 643   ret = constraintExpr_makeBinaryOp();
 644   ret->data = constraintExprData_binaryExprSetExpr1 (ret->data, expr1);
 645   ret->data = constraintExprData_binaryExprSetExpr2 (ret->data, expr2);
 646   ret->data = constraintExprData_binaryExprSetOp (ret->data, BINARYOP_UNDEFINED);
 647   return ret;
 648 }
 649
 650 /*@only@*/
 651 constraintExpr constraintExpr_parseMakeBinaryOp (/*@only@*/ constraintExpr expr1, lltok op,/*@only@*/ constraintExpr expr2)
 652 {
 653   constraintExpr ret;
 654   ret = constraintExpr_makeBinaryOpConstraintExpr (expr1, expr2);
 655   if (op.tok == TPLUS)
 656     ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 657   else if (op.tok == TMINUS)
 658     ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS);
 659     else
 660       {
 661         llassert(FALSE);
 662       }
 663   return ret;
 664 }
 665
 666 /*@only@*/
 667 /*@unused@*/ constraintExpr constraintExpr_makeBinaryOpExprNode (/*@exposed@*/ exprNode expr1, /*@exposed@*/ exprNode expr2)
 668 {
 669   constraintExpr ret;
 670   constraintExpr sub1, sub2;
 671   sub1 = constraintExpr_makeTermExprNode (expr1);
 672   sub2 = constraintExpr_makeTermExprNode (expr2);
 673   ret = constraintExpr_makeBinaryOpConstraintExpr(sub1, sub2);
 674   return ret;
 675 }
 676
 677 /*@only@*/
 678 constraintExpr constraintExpr_makeBinaryOpConstraintExprIntLiteral (/*@only@*/ constraintExpr expr, int literal)
 679 {
 680   constraintExpr ret;
 681   constraintExpr constExpr;
 682
 683   constExpr = constraintExpr_makeIntLiteral (literal);
 684   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, constExpr);
 685   ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 686   return ret;
 687 }
 688
 689 /*@only@*/
 690 constraintExpr constraintExpr_makeDecConstraintExpr (/*@only@*/constraintExpr expr)
 691 {
 692   constraintExpr ret;
 693   constraintExpr inc;
 694
 695   inc = constraintExpr_makeIntLiteral (1);
 696   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
 697   ret->data = constraintExprData_binaryExprSetOp(ret->data, MINUS);
 698   return ret;
 699 }
 700
 701 /*@only@*/
 702 constraintExpr constraintExpr_makeAddConstraintExpr (/*@only@*/
 703 constraintExpr expr, /*@only@*/
 704 constraintExpr add)
 705 {
 706   constraintExpr ret;
 707
 708   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, add);
 709
 710   ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 711
 712   return ret;
 713 }
 714
 715 /*@only@*/
 716 constraintExpr constraintExpr_makeIncConstraintExpr (/*@only@*/ constraintExpr expr)
 717 {
 718   constraintExpr ret;
 719   constraintExpr inc;
 720
 721   inc = constraintExpr_makeIntLiteral (1);
 722   ret = constraintExpr_makeBinaryOpConstraintExpr (expr, inc);
 723   ret->data = constraintExprData_binaryExprSetOp(ret->data, PLUS);
 724   return ret;
 725 }
 726
 727 /*@only@*/
 728 static cstring constraintExprUnaryOpKind_print (constraintExprUnaryOpKind op)
 729 {
 730   switch (op)
 731     {
 732     case MAXSET:
 733       return message("MAXSET");
 734     case MINSET:
 735       return message("MINSET");
 736     case MAXREAD:
 737       return message("MAXREAD");
 738     case MINREAD:
 739       return message("MINREAD");
 740     default:
 741       llassert(FALSE);
 742       return message ("<(Unary OP OTHER>");
 743     }
 744 }
 745
 746
 747 /*@only@*/
 748 static cstring constraintExprBinaryOpKind_print (constraintExprBinaryOpKind op)
 749 {
 750
 751   switch (op)
 752     {
 753     case PLUS:
 754       return message("+");
 755     case MINUS:
 756       return message("-");
 757
 758     default:
 759       llassert(FALSE);
 760       return message ("<binary OP Unknown>");
 761     }
 762 }
 763
 764 bool constraintExpr_similar (constraintExpr expr1, constraintExpr expr2)
 765 {
 766   constraintExprKind kind;
 767
 768   llassert (expr1 != NULL);
 769   llassert (expr2 != NULL);
 770   if (expr1->kind != expr2->kind)
 771     return FALSE;
 772
 773   kind = expr1->kind;
 774
 775   switch (kind)
 776     {
 777     case term:
 778       return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
 779                                   constraintExprData_termGetTerm(expr2->data) );
 780       /*@notreached@*/ break;
 781
 782     case unaryExpr:
 783       if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
 784         return FALSE;
 785
 786       return (constraintExpr_similar (
 787               constraintExprData_unaryExprGetExpr (expr1->data),
 788               constraintExprData_unaryExprGetExpr (expr2->data)
 789               ));
 790
 791     case binaryexpr:
 792       if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
 793         return FALSE;
 794
 795       if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr1 (expr1->data),
 796                                  constraintExprData_binaryExprGetExpr1 (expr2->data)) )
 797         return FALSE;
 798
 799       if (! constraintExpr_similar (constraintExprData_binaryExprGetExpr2 (expr1->data),
 800                                  constraintExprData_binaryExprGetExpr2 (expr2->data)) )
 801         return FALSE;
 802       else
 803         return TRUE;
 804       /*@notreached@*/
 805       break;
 806
 807     default:
 808       llassert(FALSE);
 809       return FALSE;
 810     }
 811   /*@notreached@*/
 812   return FALSE;
 813 }
 814
 815 bool constraintExpr_same (constraintExpr expr1, constraintExpr expr2)
 816 {
 817   constraintExprKind kind;
 818
 819   llassert (expr1 != NULL);
 820   llassert (expr2 != NULL);
 821   if (expr1->kind != expr2->kind)
 822     return FALSE;
 823
 824   kind = expr1->kind;
 825
 826   switch (kind)
 827     {
 828     case term:
 829       return constraintTerm_similar (constraintExprData_termGetTerm(expr1->data),
 830                                   constraintExprData_termGetTerm(expr2->data) );
 831       /*@notreached@*/ break;
 832
 833     case unaryExpr:
 834       if (constraintExprData_unaryExprGetOp (expr1->data) != constraintExprData_unaryExprGetOp (expr2->data) )
 835         return FALSE;
 836
 837       return (constraintExpr_same (
 838               constraintExprData_unaryExprGetExpr (expr1->data),
 839               constraintExprData_unaryExprGetExpr (expr2->data)
 840               ));
 841
 842
 843     case binaryexpr:
 844       if (constraintExprData_binaryExprGetOp (expr1->data) != constraintExprData_binaryExprGetOp (expr2->data) )
 845         return FALSE;
 846
 847       if (! constraintExpr_same (constraintExprData_binaryExprGetExpr1 (expr1->data),
 848                                  constraintExprData_binaryExprGetExpr1 (expr2->data)) )
 849         return FALSE;
 850
 851       if (! constraintExpr_same (constraintExprData_binaryExprGetExpr2 (expr1->data),
 852                                  constraintExprData_binaryExprGetExpr2 (expr2->data)) )
 853         return FALSE;
 854       else
 855         return TRUE;
 856       /*@notreached@*/ break;
 857
 858     default:
 859       llassert(FALSE);
 860       return FALSE;
 861     }
 862
 863   /*@notreached@*/
 864   BADEXIT;
 865 }
 866
 867 bool constraintExpr_search (/*@observer@*/ constraintExpr c, /*@observer@*/ constraintExpr old)
 868 {
 869   bool ret = FALSE;
 870   constraintExprKind kind;
 871   constraintExpr temp;
 872
 873   if ( constraintExpr_similar (c, old) )
 874     {
 875       DPRINTF((message ("Found  %q",
 876                         constraintExpr_unparse(old)
 877                         )));
 878       return TRUE;
 879     }
 880
 881   kind = c->kind;
 882
 883   switch (kind)
 884     {
 885     case term:
 886       break;
 887     case unaryExpr:
 888       temp = constraintExprData_unaryExprGetExpr (c->data);
 889       ret = ret || constraintExpr_search (temp, old);
 890       break;
 891     case binaryexpr:
 892
 893       temp = constraintExprData_binaryExprGetExpr1 (c->data);
 894       ret = ret || constraintExpr_search(temp, old);
 895
 896       temp = constraintExprData_binaryExprGetExpr2 (c->data);
 897       ret = ret || constraintExpr_search(temp, old);
 898       break;
 899     default:
 900       llassert(FALSE);
 901     }
 902   return ret;
 903
 904 }
 905
 906
 907 /*@only@*/ constraintExpr constraintExpr_searchandreplace (/*@only@*/ /*@unique@*/ constraintExpr c, constraintExpr old, constraintExpr new )
 908 {
 909   constraintExprKind kind;
 910   constraintExpr temp;
 911
 912   if ( constraintExpr_similar (c, old) )
 913     {
 914
 915       DPRINTF((message ("Replacing %s with %s",
 916                         constraintExpr_unparse(old), constraintExpr_unparse(new)
 917                         )));
 918       constraintExpr_free(c);
 919       return constraintExpr_copy (new);
 920     }
 921
 922   kind = c->kind;
 923
 924   switch (kind)
 925     {
 926     case term:
 927       break;
 928     case unaryExpr:
 929       temp = constraintExprData_unaryExprGetExpr (c->data);
 930       temp = constraintExpr_copy(temp);
 931       temp = constraintExpr_searchandreplace (temp, old, new);
 932       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
 933       break;
 934     case binaryexpr:
 935
 936       temp = constraintExprData_binaryExprGetExpr1 (c->data);
 937       temp = constraintExpr_copy(temp);
 938       temp = constraintExpr_searchandreplace (temp, old, new);
 939       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
 940
 941       temp = constraintExprData_binaryExprGetExpr2 (c->data);
 942       temp = constraintExpr_copy(temp);
 943       temp = constraintExpr_searchandreplace (temp, old, new);
 944       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
 945       break;
 946     default:
 947       llassert(FALSE);
 948     }
 949   return c;
 950
 951 }
 952
 953 static constraintExpr constraintExpr_simplifyChildren (/*@returned@*/ constraintExpr c)
 954 {
 955   constraintExprKind kind;
 956   constraintExpr temp;
 957
 958   kind = c->kind;
 959
 960   switch (kind)
 961     {
 962     case term:
 963       break;
 964     case unaryExpr:
 965       temp = constraintExprData_unaryExprGetExpr (c->data);
 966       temp = constraintExpr_copy(temp);
 967       temp = constraintExpr_simplify (temp);
 968       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
 969       break;
 970     case binaryexpr:
 971       DPRINTF((message("constraintExpr_simplfiyChildren: simplify binary expression: %s",constraintExpr_unparse(c) ) ) );
 972       temp = constraintExprData_binaryExprGetExpr1 (c->data);
 973       temp = constraintExpr_copy(temp);
 974       temp = constraintExpr_simplify (temp);
 975
 976       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
 977
 978       temp = constraintExprData_binaryExprGetExpr2 (c->data);
 979       temp = constraintExpr_copy(temp);
 980       temp = constraintExpr_simplify (temp);
 981
 982       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
 983       break;
 984     default:
 985       llassert(FALSE);
 986     }
 987   return c;
 988
 989 }
 990
 991
 992 constraintExpr constraintExpr_setFileloc (/*@returned@*/ constraintExpr c, fileloc loc) /*@modifies c->data @*/
 993 {
 994   constraintTerm t;
 995   constraintExpr temp;
 996
 997   llassert(c != NULL);
 998
 999   switch (c->kind)
1000     {
1001     case term:
1002       t = constraintExprData_termGetTerm (c->data);
1003       t = constraintTerm_copy(t);
1004       t = constraintTerm_setFileloc (t, loc);
1005       c->data = constraintExprData_termSetTerm (c->data, t);
1006       break;
1007     case binaryexpr:
1008
1009       temp = constraintExprData_binaryExprGetExpr1 (c->data);
1010       temp = constraintExpr_copy(temp);
1011       temp = constraintExpr_setFileloc (temp, loc);
1012       c->data = constraintExprData_binaryExprSetExpr1 (c->data, temp);
1013
1014       temp = constraintExprData_binaryExprGetExpr2 (c->data);
1015       temp = constraintExpr_copy(temp);
1016       temp = constraintExpr_setFileloc (temp, loc);
1017       c->data = constraintExprData_binaryExprSetExpr2 (c->data, temp);
1018       break;
1019     case unaryExpr:
1020       temp = constraintExprData_unaryExprGetExpr (c->data);
1021       temp = constraintExpr_copy(temp);
1022       temp = constraintExpr_setFileloc (temp, loc);
1023       c->data = constraintExprData_unaryExprSetExpr (c->data, temp);
1024       break;
1025     }
1026   return c;
1027 }
1028
1029 static /*@only@*/ constraintExpr constraintExpr_simplifybinaryExpr (/*@only@*/constraintExpr c)
1030 {
1031   constraintExpr e1, e2;
1032
1033   e1 = constraintExprData_binaryExprGetExpr1 (c->data);
1034   e2 = constraintExprData_binaryExprGetExpr2 (c->data);
1035
1036   if (constraintExpr_canGetValue (e1) && constraintExpr_canGetValue(e2) )
1037     {
1038       int i;
1039
1040       i = constraintExpr_getValue(e1) + constraintExpr_getValue (e2);
1041       constraintExpr_free(c);
1042       c = constraintExpr_makeIntLiteral (i);
1043
1044     }
1045   return c;
1046 }
1047
1048
1049 static /*@only@*/  constraintExpr constraintExpr_subtractExpr (/*@only@*/ constraintExpr expr, /*@only@*/ constraintExpr addent)
1050 {
1051   constraintExpr  new;
1052
1053   DPRINTF ( (message ("Doing subtraceTerm simplification") ) );
1054
1055   new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
1056   new->data = constraintExprData_binaryExprSetOp (new->data, MINUS);
1057   return new;
1058 }
1059
1060 /*@only@*/
1061 static constraintExpr constraintExpr_addExpr (/*@only@*/
1062 constraintExpr expr, /*@only@*/
1063 constraintExpr addent)
1064 {
1065   constraintExpr  new;
1066
1067   DPRINTF ( (message ("Doing addTerm simplification") ) );
1068
1069   new = constraintExpr_makeBinaryOpConstraintExpr (expr, addent);
1070   new->data = constraintExprData_binaryExprSetOp (new->data, PLUS);
1071   return new;
1072 }
1073
1074 /*
1075   this thing takes the lexpr and expr of a constraint and modifies lexpr
1076   and returns a (possiblly new) value for expr
1077 */
1078 /* 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 */
1079
1080 /* the approach is a little Kludgy but seems to work.  I should probably use something cleaner at some point ... */
1081
1082
1083 /*@only@*/ constraintExpr constraintExpr_solveBinaryExpr (constraintExpr lexpr, /*@only@*/ constraintExpr expr)
1084 {
1085   constraintExpr expr1, expr2;
1086   constraintExprBinaryOpKind op;
1087
1088   if (lexpr->kind != binaryexpr)
1089     return expr;
1090
1091   expr2 = constraintExprData_binaryExprGetExpr2 (lexpr->data);
1092   expr1 = constraintExprData_binaryExprGetExpr1 (lexpr->data);
1093
1094   op    = constraintExprData_binaryExprGetOp (lexpr->data);
1095
1096   expr1 = constraintExpr_copy(expr1);
1097   expr2 = constraintExpr_copy(expr2);
1098
1099 #warning make sure this works
1100
1101     lexpr->kind = expr1->kind;
1102     free (lexpr->data);
1103
1104     lexpr->data = copyExprData (expr1->data, expr1->kind);
1105     free(expr1);
1106
1107     if (op == PLUS)
1108       expr = constraintExpr_subtractExpr (expr, expr2);
1109     else if (op == MINUS)
1110       expr = constraintExpr_addExpr (expr, expr2);
1111     else
1112       BADEXIT;
1113
1114
1115     return expr;
1116
1117   /*
1118     #warning this needs to be checked
1119     expr = constraintExpr_solveBinaryExpr (expr1, expr);
1120
1121     expr = constraintExpr_solveBinaryExpr (expr2, expr);
1122     return expr;
1123   */
1124 }
1125
1126 static /*@only@*/ constraintExpr constraintExpr_simplifyunaryExpr (/*@only@*/ constraintExpr c)
1127 {
1128   constraintExpr exp;
1129
1130   llassert (c->kind == unaryExpr);
1131
1132   DPRINTF ( (message ("Doing constraintExpr_simplifyunaryExpr:%s", constraintExpr_unparse (c) ) ) );
1133
1134   if ( (constraintExprData_unaryExprGetOp (c->data) != MAXSET) &&
1135        (constraintExprData_unaryExprGetOp (c->data) != MAXREAD) )
1136     {
1137       return c;
1138     }
1139   // pattern mxr ( var + const) = mxr(var) - const
1140
1141   exp = constraintExprData_unaryExprGetExpr (c->data);
1142
1143   if (exp->kind == term)
1144     {
1145       constraintTerm cterm;
1146
1147       cterm = constraintExprData_termGetTerm (exp->data);
1148
1149       if (constraintTerm_isStringLiteral(cterm) )
1150         {
1151           cstring val;
1152           val = constraintTerm_getStringLiteral (cterm);
1153           if (constraintExprData_unaryExprGetOp (c->data) == MAXSET)
1154             {
1155               constraintExpr temp;
1156
1157               temp = constraintExpr_makeIntLiteral ((int)strlen (val) );
1158               cstring_free(val);
1159               constraintExpr_free(c);
1160               return temp;
1161             }
1162           if (constraintExprData_unaryExprGetOp (c->data) == MAXREAD)
1163             {
1164               constraintExpr temp;
1165
1166               temp = constraintExpr_makeIntLiteral ((int)strlen (val) );
1167               cstring_free(val);
1168               constraintExpr_free(c);
1169               return temp;
1170             }
1171           BADEXIT;
1172         }
1173       return c;
1174     }
1175
1176   if (exp->kind != binaryexpr)
1177     return c;
1178
1179   if (constraintExprData_binaryExprGetOp (exp->data) == PLUS  )
1180     {
1181
1182       //      if (constraintExpr_canGetValue (constraintExprData_binaryExprGetExpr2 (exp->data) ) )
1183         {
1184
1185           constraintExpr  temp, temp2;
1186
1187           DPRINTF ( (message ("Doing fancy simplification") ) );
1188
1189           temp = constraintExprData_binaryExprGetExpr2 (exp->data);
1190
1191           temp2 = constraintExprData_binaryExprGetExpr1 (exp->data);
1192
1193           temp2 = constraintExpr_copy(temp2);
1194           c->data = constraintExprData_unaryExprSetExpr (c->data, temp2);
1195
1196
1197           temp = constraintExpr_copy (temp);
1198
1199           c = constraintExpr_subtractExpr (c, temp);
1200
1201           DPRINTF ( (message ("Done fancy simplification:%s", constraintExpr_unparse (c) ) ) );
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 (/*@temp@*/ /*@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 /*@only@*/ constraintExpr constraintExpr_doFixResult (/*@only@*/  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 /*@only@*/ constraintExpr
1535 doFixResultTerm (/*@only@*/ constraintExpr e, /*@exposed@*/ 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           constraintExpr_free(e);
1565           e = NULL;
1566         }
1567       else
1568         {
1569           e = NULL;
1570         }
1571       break;
1572     default:
1573       BADEXIT;
1574     }
1575
1576   return ret;
1577
1578 }
1579
1580 /*drl moved from constriantTerm.c 5/20/001*/
1581 /*@only@*/ static constraintExpr
1582 doSRefFixConstraintParamTerm (/*@only@*/ constraintExpr e, /*@observer@*/ /*@temp@*/ exprNodeList arglist)
1583 {
1584   constraintTerm t;
1585
1586   constraintExprData data = e->data;
1587
1588   constraintExprKind kind = e->kind;
1589
1590   constraintExpr ret;
1591
1592   llassert(kind == term);
1593
1594   t = constraintExprData_termGetTerm (data);
1595   llassert (t != NULL);
1596
1597   ret = e;
1598   /*@i1*/ switch (t->kind)
1599     {
1600     case EXPRNODE:
1601       DPRINTF((message ("%q @ %q ", constraintTerm_print(t),
1602                         fileloc_unparse (constraintTerm_getFileloc(t) ) ) ));
1603       break;
1604     case INTLITERAL:
1605       DPRINTF((message (" %q ", constraintTerm_print (t)) ));
1606       break;
1607
1608     case SREF:
1609       DPRINTF (( message("Doing sRef_fixConstraintParam for %q ",
1610                          constraintTerm_print (t) ) ));
1611       ret = sRef_fixConstraintParam (t->value.sref, arglist);
1612
1613       constraintExpr_free(e);
1614
1615       DPRINTF (( message("After Doing sRef_fixConstraintParam constraintExpr is %q ",
1616                          constraintExpr_print (ret) ) ));
1617       break;
1618     default:
1619       BADEXIT;
1620     }
1621   return ret;
1622
1623 }
1624
1625
1626 /* bool constraintExpr_includesTerm (constraintExpr expr, constraintTerm term) */
1627 /* { */
1628 /*   if (constraintTerm_hasTerm (expr->term, term) ) */
1629 /*     return TRUE; */
1630
1631 /*   if ( (expr->expr) != NULL) */
1632 /*     { */
1633 /*       return ( constraintExpr_includesTerm (expr->expr, term) ); */
1634 /*     } */
1635 /*   return FALSE; */
1636
1637 /* } */
1638
1639 /*drl added 6/11/01 */
1640 bool constraintExpr_isBinaryExpr (/*@observer@*/ constraintExpr c)
1641 {
1642   if (c->kind == binaryexpr)
1643     return TRUE;
1644
1645   else
1646     return FALSE;
1647 }
1648
1649