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