src/constraintList.bak.c

   1 /*
   2 ** constraintList.c
   3 */
   4
   5 # include <ctype.h> /* for isdigit */
   6 # include "lclintMacros.nf"
   7 # include "basic.h"
   8 # include "cgrammar.h"
   9 # include "cgrammar_tokens.h"
  10
  11 # include "exprChecks.h"
  12 # include "aliasChecks.h"
  13 # include "exprNodeSList.h"
  14 # include "exprData.i"
  15
  16
  17 /*@notnull@*/ constraintList constraintList_new () {
  18 constraintList ret;
  19
  20 ret = dmalloc ( sizeof (constraintList_) );
  21 llassert ( ret != NULL);
  22 ret->numconstraints = 0;
  23 return ret;
  24 }
  25 bool checkrestriction (int value, arithType at, exprNode expr2)
  26 {
  27   switch (at)
  28     {
  29     case LT:  return (value < multiVal_forceInt ( expr2->val)  );
  30     case LTE: return (value <= multiVal_forceInt ( expr2->val)  );
  31     case GT:  return (value > multiVal_forceInt ( expr2->val)  );
  32     case GTE: return (value >= multiVal_forceInt ( expr2->val)  );
  33     case EQ:  return (value == multiVal_forceInt ( expr2->val)  );
  34     case NONNEGATIVE: return (value >= 0);
  35     case POSITIVE:  return (value > 0);
  36     default:      llassert (FALSE);
  37     }
  38 }
  39 bool numericalResolve (constraint c)
  40 {
  41   llassert (c.expr1);
  42 switch (c.kind)
  43   {
  44   case BUFFSIZE:
  45     if (c.expr1 && c.expr1->sref)
  46       return checkrestriction (c.expr1->sref->bufinfo.size, c.restriction, c.expr2);
  47     else
  48       return FALSE;
  49   case STRINGLEN:
  50     if (c.expr1 && c.expr1->sref)
  51       return checkrestriction (c.expr1->sref->bufinfo.len, c.restriction, c.expr2);
  52     else
  53       return FALSE;
  54   case VALUE:   return checkrestriction (multiVal_forceInt (c.expr1->val), c.restriction, c.expr2);
  55   case CALLSAFE:  printf("NOt IMplemented !!!");
  56   default:        llassert(FALSE);
  57     return FALSE;
  58   }
  59 }
  60
  61 cstring parse_restriction (arithType at)
  62 {
  63   switch (at)
  64     {
  65     case LT:  return "<";
  66     case LTE: return "<=";
  67     case GT:  return ">";
  68     case GTE:  return ">=";
  69     case EQ:  return "=";
  70     case NONNEGATIVE: return " >= 0";
  71     case POSITIVE:  return " > 0";
  72     default:      return "unknown";
  73     }
  74 }
  75 cstring constraint_parseKind (constraintType kind)
  76 {
  77   switch (kind)
  78     {
  79     case BUFFSIZE: return "BufferSize";
  80     case STRINGLEN: return "StringLength";
  81     case VALUE:     return "value";
  82     case CALLSAFE:     return "call safe";
  83     default:        return "unknown";
  84     }
  85 }
  86
  87 void constraintList_debugPrint ( char * s )
  88 {
  89   TPRINTF((s) );
  90 }
  91
  92 void constraint_print (constraint c)
  93 {
  94   char temp [100];
  95   char temp2 [200];
  96
  97   snprintf (temp, sizeof(temp),"Location:%s  \n Constraint: %s of %s %s %s\n",
  98             fileloc_unparse(exprNode_getfileloc (c.expr1 ) ),
  99             constraint_parseKind (c.kind),
 100           exprNode_unparse(c.expr1), parse_restriction(c.restriction), exprNode_unparse(c.expr2) );
 101
 102   constraintList_debugPrint (temp);
 103
 104 }
 105 void constraintList_print (constraintList cl)
 106 {
 107
 108   int i;
 109   if (constraintList_isUndefined (cl) )
 110     {
 111       constraintList_debugPrint("Constraint List undefined\n");
 112       return;
 113     }
 114   for (i = 0; i < cl->numconstraints; i++)
 115     {
 116       constraint_print (cl->constraints[i]);
 117     }
 118
 119 }
 120
 121 bool constraint_resolve (constraint c)
 122 {
 123   if (c.kind == CALLSAFE)
 124     {
 125       /* */
 126       constraintList_debugPrint("can't resolve\n");
 127       return FALSE;
 128     }
 129   else
 130     {
 131       return numericalResolve (c);
 132     }
 133 }
 134 void constraintList_resolve (constraintList cl)
 135 {
 136   int i;
 137   if (constraintList_isUndefined (cl) )
 138     {
 139        constraintList_debugPrint("Constraint List empty \n");
 140       return;
 141     }
 142    for (i = 0; i < cl->numconstraints; i++)
 143     {
 144        constraintList_debugPrint("Trying to resolve:\n");
 145       constraint_print (cl->constraints[i]);
 146       if ( constraint_resolve (cl->constraints[i] ) )
 147          constraintList_debugPrint ("resolve sucessfully\n");
 148       else
 149          constraintList_debugPrint ("not resolved sucessfully\n");
 150
 151     }
 152 }
 153 constraint constraint_create (exprNode e1, exprNode e2,  arithType restriction, constraintType kind)
 154 {
 155   constraint ret;
 156   ret.expr1 = e1;
 157   ret.expr2 = e2;
 158   ret.restriction = restriction;
 159   ret.kind = kind;
 160   return ret;
 161 }
 162
 163 constraintList  constraintList_get (exprNode e1 )
 164 {
 165   return e1->constraints;
 166 }
 167
 168 constraintList constraintList_exprNodemerge (exprNode e1, exprNode e2)
 169 {
 170   constraintList ret;
 171   if ( (e1 != NULL) && (e2 != NULL) )
 172     {
 173       ret = constraintList_merge (e1->constraints, e2->constraints);
 174     }
 175   else if ( (e1 == NULL) && (e2 == NULL) )
 176     ret = constraintList_merge ( (constraintList)NULL,  (constraintList)NULL );
 177   else if (e1 == NULL)
 178     ret = constraintList_merge ( (constraintList)NULL, e2->constraints);
 179   else
 180     ret = constraintList_merge (e1->constraints, (constraintList)NULL );
 181   return ret;
 182 }
 183
 184
 185 constraintList constraintList_merge (constraintList cl1, constraintList cl2)
 186 {
 187   constraintList ret;
 188   int i;
 189   ret = constraintList_undefined;
 190   if  (constraintList_isDefined (cl1) )
 191     {
 192       for (i = 0; i < cl1->numconstraints; i++)
 193         {
 194           ret = constraintList_add (ret, cl1->constraints[i]);
 195         }
 196     }
 197   if  (constraintList_isDefined (cl2) )
 198     {
 199       for (i = 0; i < cl2->numconstraints; i++)
 200         {
 201           ret = constraintList_add (ret, cl2->constraints[i]);
 202         }
 203     }
 204   return ret;
 205
 206
 207 }
 208
 209 constraintList constraintList_add (constraintList constraints, constraint newconstr)
 210 {
 211   constraintList ret;
 212
 213   if (  constraintList_isUndefined(constraints) )
 214     {
 215       ret = constraintList_new ();
 216     }
 217   else
 218     {
 219       ret = constraints;
 220     }
 221   llassert (constraintList_isDefined (ret) );
 222   llassert (ret->numconstraints < max_constraints);
 223   ret->constraints[ret->numconstraints] = newconstr;
 224   ret->numconstraints++;
 225   return ret;
 226 }
 227
 228 cstring exprNode_generateConstraints (exprNode e)
 229 {
 230
 231    cstring ret;
 232
 233    ret = exprNode_findConstraints(e);
 234    if (ret == NULL)
 235      {
 236        ret = exprNode_justUnparse (e);
 237      }
 238    llassert(ret != NULL);
 239
 240    exprNode_constraintPropagateUp(e);
 241 }
 242
 243 /* handels multiple statements */
 244
 245
 246
 247 static cstring exprNode_findConstraints ( exprNode e)
 248 {
 249   cstring ret;
 250   exprData data;
 251
 252   if (exprNode_isError (e))
 253     {
 254       static /*@only@*/ cstring error = cstring_undefined;
 255
 256       if (!cstring_isDefined (error))
 257         {
 258           error = cstring_makeLiteral ("<error>");
 259         }
 260
 261       return error;
 262     }
 263
 264   data = e->edata;
 265
 266   switch (e->kind)
 267     {
 268     case XPR_CALL:
 269       ret = message ("%s(%q)",
 270                      exprNode_generateConstraints (exprData_getFcn (data)),
 271                      exprNodeList_unparse (exprData_getArgs (data)));
 272        constraintList_debugPrint(ret);
 273       e->constraints = constraintList_add (e->constraints, constraint_create (e,exprNode_undefined, GT,  CALLSAFE ) );
 274       break;
 275     case XPR_FETCH:
 276       ret = message ("%s[%s]", exprNode_generateConstraints (exprData_getPairA (data)),
 277                      exprNode_generateConstraints (exprData_getPairB (data)));
 278
 279       e->constraints = constraintList_add (e->constraints, constraint_create (exprData_getPairA (data),exprData_getPairB (data) , GT, BUFFSIZE  ) );
 280       e->constraints = constraintList_add (e->constraints, constraint_create (exprData_getPairB (data), exprNode_undefined, NONNEGATIVE, VALUE) );
 281       /* crude test to see if this is an lvalue */
 282       if ( sRefSet_isEmpty(e->sets) )
 283            {
 284              /* if its not an lvalue we assume it's an rvalue*/
 285              /* of course if its am lvalue we assume its not an rvalue
 286                 should put in a more accurate test sometime...*/
 287
 288              //       printf("Making constraint that length %s > %s\n",exprNode_generateConstraints (exprData_getPairA (data)),
 289              //      exprNode_generateConstraints (exprData_getPairB (data)));
 290       e->constraints = constraintList_add (e->constraints, constraint_create (exprData_getPairA (data),exprData_getPairB (data) , GT, STRINGLEN  ) );
 291            }
 292       break;
 293     case XPR_PREOP:
 294       ret = message ("%s%s",
 295                      lltok_unparse (exprData_getUopTok (data)),
 296                      exprNode_generateConstraints (exprData_getUopNode (data)));
 297       /* store old constraints */
 298        e->constraints = constraintList_exprNodemerge (exprData_getUopNode (e->edata), exprNode_undefined);
 299       /*handle * pointer access */
 300       if (lltok_isMult( exprData_getUopTok (data) ) )
 301         {
 302           e->constraints = constraintList_add (e->constraints, constraint_create (exprData_getUopNode (data), exprNode_undefined, POSITIVE, BUFFSIZE  ) );
 303       /* crude test to see if this is an lvalue */
 304           if ( sRefSet_isEmpty(e->sets) )
 305             {
 306               /* if its not an lvalue we assume it's an rvalue*/
 307               /* of course if its am lvalue we assume its not an rvalue
 308                  should put in a more accurate test sometime...*/
 309                   e->constraints = constraintList_add (e->constraints, constraint_create (exprData_getUopNode (data), exprNode_undefined, POSITIVE, STRINGLEN  ) );
 310            }
 311         }
 312       break;
 313
 314     case XPR_POSTOP:
 315       ret = message ("%s%s",
 316                      exprNode_generateConstraints (exprData_getUopNode (data)),
 317                      lltok_unparse (exprData_getUopTok (data)));
 318           e->constraints = constraintList_exprNodemerge (exprData_getUopNode (e->edata), exprNode_undefined);
 319           if (lltok_isInc_Op (exprData_getUopTok (data) ) )
 320             {
 321               TPRINTF(("++  -- will be implemented later"));
 322               // e->constraints = constraintList_add( e->constraints,
 323               // constraint_makeInc_Op (exprData_getUopNode (data) ) );
 324             }
 325       break;
 326     default:
 327       TPRINTF(("no special constraint generation"));
 328       ret = NULL;
 329     }
 330
 331   return ret;
 332 }
 333
 334 cstring exprNode_handleError( exprNode e)
 335 {
 336    if (exprNode_isError (e))
 337     {
 338       static /*@only@*/ cstring error = cstring_undefined;
 339
 340       if (!cstring_isDefined (error))
 341         {
 342           error = cstring_makeLiteral ("<error>");
 343         }
 344
 345       return error;
 346     }
 347
 348 }
 349
 350 cstring exprNode_multiStatement (exprNode e)
 351 {
 352
 353    cstring ret;
 354   exprData data;
 355
 356   if (exprNode_handleError (e))
 357     {
 358       return exprNode_handleError(e);
 359     }
 360
 361   data = e->edata;
 362
 363   switch (e->kind)
 364     {
 365
 366     case XPR_FOR:
 367       ret = message ("%s %s",
 368                      exprNode_generateConstraints (exprData_getPairA (data)),
 369                      exprNode_generateConstraints (exprData_getPairB (data)));
 370       break;
 371
 372     case XPR_FORPRED:
 373             ret = message ("for (%s; %s; %s)",
 374                      exprNode_generateConstraints (exprData_getTripleInit (data)),
 375                      exprNode_generateConstraints (exprData_getTripleTest (data)),
 376                      exprNode_generateConstraints (exprData_getTripleInc (data)));
 377       break;
 378
 379     }
 380 }
 381
 382 cstring exprNode_exprParse (exprNode e)
 383 {
 384
 385    cstring ret;
 386   exprData data;
 387
 388   if (exprNode_handleError (e))
 389     {
 390       return exprNode_handleError(e);
 391     }
 392
 393   data = e->edata;
 394
 395   switch (e->kind)
 396     {
 397        case XPR_PARENS:
 398       ret = message ("(%s)", exprNode_generateConstraints (exprData_getUopNode (e->edata)));
 399       e->constraints = constraintList_exprNodemerge (exprData_getUopNode (e->edata), exprNode_undefined);
 400       break;
 401           case XPR_ASSIGN:
 402       ret = message ("%s %s %s",
 403                      exprNode_generateConstraints (exprData_getOpA (data)),
 404                      lltok_unparse (exprData_getOpTok (data)),
 405                      exprNode_generateConstraints (exprData_getOpB (data)));
 406       e->constraints = constraintList_exprNodemerge (exprData_getOpA (data), exprData_getOpB (data) );
 407       break;
 408       case XPR_PARENS:
 409       ret = message ("(%s)", exprNode_generateConstraints (exprData_getUopNode (e->edata)));
 410       e->constraints = constraintList_exprNodemerge (exprData_getUopNode (e->edata), exprNode_undefined);
 411       break;
 412     case XPR_OP:
 413       ret = message ("%s %s %s",
 414                      exprNode_generateConstraints (exprData_getOpA (data)),
 415                      lltok_unparse (exprData_getOpTok (data)),
 416                      exprNode_generateConstraints (exprData_getOpB (data)));
 417       e->constraints  = constraintList_exprNodemerge (exprData_getOpA (data), exprData_getOpB (data));
 418       break;
 419     case XPR_SIZEOFT:
 420       ret = message ("sizeof(%s)", ctype_unparse (qtype_getType (exprData_getType (data))));
 421       break;
 422
 423     case XPR_SIZEOF:
 424       ret = message ("sizeof(%s)", exprNode_generateConstraints (exprData_getSingle (data)));
 425       e->constraints = constraintList_exprNodemerge (exprData_getSingle (e->edata), exprNode_undefined);
 426       break;
 427
 428
 429     }
 430 }
 431 cstring exprNode_justUnparse (exprNode e)
 432 {
 433
 434    cstring ret;
 435   exprData data;
 436
 437   if (exprNode_isError (e))
 438     {
 439       static /*@only@*/ cstring error = cstring_undefined;
 440
 441       if (!cstring_isDefined (error))
 442         {
 443           error = cstring_makeLiteral ("<error>");
 444         }
 445
 446       return error;
 447     }
 448
 449   data = e->edata;
 450
 451   switch (e->kind)
 452     {
 453   case XPR_CALL:
 454       ret = message ("%s(%q)",
 455                      exprNode_generateConstraints (exprData_getFcn (data)),
 456                      exprNodeList_unparse (exprData_getArgs (data)));
 457        constraintList_debugPrint(ret);
 458       e->constraints = constraintList_add (e->constraints, constraint_create (e,exprNode_undefined, GT,  CALLSAFE ) );
 459       break;
 460     case XPR_INITBLOCK:
 461       ret = message ("Not Handled");
 462        break;
 463     case XPR_EMPTY:
 464       ret = message ("Not Handled");
 465       break;
 466     case XPR_LABEL:
 467       ret = message ("%s:", exprData_getId (data));
 468       break;
 469     case XPR_CONST:
 470     case XPR_VAR:
 471       ret = cstring_copy (exprData_getId (data));
 472       break;
 473      case XPR_BODY:
 474       ret = message ("Not handled");
 475       break;
 476
 477
 478     case XPR_OFFSETOF:
 479       break;
 480
 481
 482     case XPR_ALIGNOFT:
 483       break;
 484
 485     case XPR_ALIGNOF:
 486       break;
 487
 488     case XPR_VAARG:
 489       break;
 490     case XPR_ITERCALL:
 491       break;
 492     case XPR_ITER:
 493       break;
 494     case XPR_CAST:
 495       break;
 496
 497     case XPR_GOTO:
 498       ret = message ("goto %s", exprData_getLiteral (data));
 499       break;
 500
 501     case XPR_CONTINUE:
 502       ret = cstring_makeLiteral ("continue");
 503       break;
 504
 505     case XPR_BREAK:
 506       ret = cstring_makeLiteral ("break");
 507       break;
 508
 509     case XPR_RETURN:
 510       ret = message ("return %s", exprNode_generateConstraints (exprData_getSingle (data)));
 511       break;
 512
 513     case XPR_NULLRETURN:
 514       ret = cstring_makeLiteral ("return");
 515       break;
 516
 517     case XPR_COMMA:
 518       ret = message ("%s, %s",
 519                      exprNode_generateConstraints (exprData_getPairA (data)),
 520                      exprNode_generateConstraints (exprData_getPairB (data)));
 521       break;
 522
 523     case XPR_COND:
 524       ret = message ("%s ? %s : %s",
 525                      exprNode_generateConstraints (exprData_getTriplePred (data)),
 526                      exprNode_generateConstraints (exprData_getTripleTrue (data)),
 527                      exprNode_generateConstraints (exprData_getTripleFalse (data)));
 528       break;
 529     case XPR_IF:
 530       ret = message ("if (%s) %s",
 531                      exprNode_generateConstraints (exprData_getPairA (data)),
 532                      exprNode_generateConstraints (exprData_getPairB (data)));
 533       e->constraints = constraintList_exprNodemerge (exprData_getPairA (data),exprData_getPairB(data));
 534       break;
 535
 536     case XPR_IFELSE:
 537       ret = message ("if (%s) %s else %s",
 538                      exprNode_generateConstraints (exprData_getTriplePred (data)),
 539                      exprNode_generateConstraints (exprData_getTripleTrue (data)),
 540                      exprNode_generateConstraints (exprData_getTripleFalse (data)));
 541       break;
 542     case XPR_WHILE:
 543       ret = message ("while (%s) %s",
 544                      exprNode_generateConstraints (exprData_getPairA (data)),
 545                      exprNode_generateConstraints (exprData_getPairB (data)));
 546       e->constraints = constraintList_exprNodemerge (exprData_getPairA (data), exprData_getPairB (data) );
 547       break;
 548
 549     case XPR_WHILEPRED:
 550       ret = cstring_copy (exprNode_generateConstraints (exprData_getSingle (data)));
 551       break;
 552
 553     case XPR_TOK:
 554       ret = cstring_copy (lltok_unparse (exprData_getTok (data)));
 555       break;
 556
 557     case XPR_DOWHILE:
 558       ret = message ("do { %s } while (%s)",
 559                      exprNode_generateConstraints (exprData_getPairB (data)),
 560                      exprNode_generateConstraints (exprData_getPairA (data)));
 561       break;
 562
 563     case XPR_BLOCK:
 564       ret = message ("{ %s }", exprNode_generateConstraints (exprData_getSingle (data)));
 565       e->constraints = (exprData_getSingle (data))->constraints;
 566       break;
 567
 568     case XPR_STMT:
 569       ret = cstring_copy (exprNode_generateConstraints (exprData_getSingle (data)));
 570       e->constraints = (exprData_getSingle (data))->constraints;
 571       break;
 572
 573     case XPR_STMTLIST:
 574       ret = message ("%s; %s",
 575                      exprNode_generateConstraints (exprData_getPairA (data)),
 576                      exprNode_generateConstraints (exprData_getPairB (data)));
 577       e->constraints = constraintList_exprNodemerge (exprData_getPairA (data), exprData_getPairB (data) );
 578       break;
 579
 580     case XPR_FTDEFAULT:
 581     case XPR_DEFAULT:
 582       ret = cstring_makeLiteral ("default:");
 583       break;
 584
 585     case XPR_SWITCH:
 586       ret = message ("switch (%s) %s",
 587                      exprNode_generateConstraints (exprData_getPairA (data)),
 588                      exprNode_generateConstraints (exprData_getPairB (data)));
 589       break;
 590
 591     case XPR_FTCASE:
 592     case XPR_CASE:
 593       ret = message ("case %s:",
 594                      exprNode_generateConstraints (exprData_getSingle (data)));
 595       break;
 596
 597     case XPR_INIT:
 598       ret = message ("%s = %s",
 599                      idDecl_getName (exprData_getInitId (data)),
 600                      exprNode_generateConstraints (exprData_getInitNode (data)));
 601       break;
 602
 603     case XPR_FACCESS:
 604       ret = message ("%s.%s",
 605                      exprNode_generateConstraints (exprData_getFieldNode (data)),
 606                      exprData_getFieldName (data));
 607       break;
 608
 609     case XPR_ARROW:
 610             ret = message ("%s->%s",
 611                      exprNode_generateConstraints (exprData_getFieldNode (data)),
 612                      exprData_getFieldName (data));
 613       break;
 614
 615     case XPR_STRINGLITERAL:
 616       ret = cstring_copy (exprData_getLiteral (data));
 617       break;
 618
 619     case XPR_NUMLIT:
 620       ret = cstring_copy (exprData_getLiteral (data));
 621       break;
 622
 623     case XPR_NODE:
 624       ret = cstring_makeLiteral ("<node>");
 625       break;
 626     }
 627
 628   return ret;
 629 }
 630
 631 void exprNode_constraintPropagateUp (exprNode e)
 632 {
 633
 634    cstring ret;
 635   exprData data;
 636
 637   if (exprNode_isError (e))
 638     {
 639       static /*@only@*/ cstring error = cstring_undefined;
 640
 641       if (!cstring_isDefined (error))
 642         {
 643           error = cstring_makeLiteral ("<error>");
 644         }
 645
 646       return error;
 647     }
 648
 649   data = e->edata;
 650
 651   switch (e->kind)
 652     {
 653        case XPR_PARENS:
 654       e->constraints = constraintList_exprNodemerge (exprData_getUopNode (e->edata), exprNode_undefined);
 655       break;
 656     case XPR_ASSIGN:
 657       e->constraints = constraintList_exprNodemerge (exprData_getOpA (data), exprData_getOpB (data) );
 658       break;
 659     case XPR_CALL:
 660       e->constraints = constraintList_add (e->constraints, constraint_create (e,exprNode_undefined, GT,  CALLSAFE ) );
 661       break;
 662     case XPR_INITBLOCK:
 663       //ret = message ("{ %q }", exprNodeList_unparse (exprData_getArgs (data)));
 664    //       e->constraints = constraintList_exprNodemerge (exprData_getArgs (data), exprData_getOpB (data) );
 665       break;
 666
 667     case XPR_OP:
 668       ret = message ("%s %s %s",
 669                      exprNode_generateConstraints (exprData_getOpA (data)),
 670                      lltok_unparse (exprData_getOpTok (data)),
 671                      exprNode_generateConstraints (exprData_getOpB (data)));
 672       e->constraints  = constraintList_exprNodemerge (exprData_getOpA (data), exprData_getOpB (data));
 673       break;
 674
 675     case XPR_ALIGNOF:
 676          e->constraints = constraintList_exprNodemerge (exprData_getSingle (e->edata), exprNode_undefined);
 677       break;
 678
 679     case XPR_VAARG:
 680           e->constraints = constraintList_exprNodemerge (exprData_getCastNode (data), exprNode_undefined);
 681       break;
 682
 683     case XPR_ITERCALL:
 684       //    ret = message ("%q(%q)",
 685       //             uentry_getName (exprData_getIterCallIter (data)),
 686       //             exprNodeList_unparse (exprData_getIterCallArgs (data)));
 687       ////      e->constraints = constraintList_exprNodemerge (exprData_getIterCallArgs (data), exprNode_undefined);
 688       break;
 689     case XPR_ITER:
 690       TPRINTF(("XPR_ITER NOT IMPLEMENTED" ));
 691      /*  ret = message ("%q(%q) %s %q", */
 692 /*                   uentry_getName (exprData_getIterSname (data)), */
 693 /*                   exprNodeList_unparse (exprData_getIterAlist (data)), */
 694 /*                   exprNode_generateConstraints (exprData_getIterBody (data)), */
 695 /*                   uentry_getName (exprData_getIterEname (data))); */
 696       break;
 697     case XPR_CAST:
 698       e->constraints = constraintList_exprNodemerge (exprData_getCastNode (data), exprNode_undefined);
 699       break;
 700
 701     default:
 702       TPRINTF(("NOT Currently IMplemented"));
 703     }
 704 }
 705
 706
 707 /*     case XPR_FOR: */
 708 /*       ret = message ("%s %s",  */
 709 /*                   exprNode_generateConstraints (exprData_getPairA (data)),  */
 710 /*                   exprNode_generateConstraints (exprData_getPairB (data))); */
 711 /*       break; */
 712
 713 /*     case XPR_FORPRED: */
 714 /*             ret = message ("for (%s; %s; %s)", */
 715 /*                   exprNode_generateConstraints (exprData_getTripleInit (data)), */
 716 /*                   exprNode_generateConstraints (exprData_getTripleTest (data)), */
 717 /*                   exprNode_generateConstraints (exprData_getTripleInc (data))); */
 718 /*       break; */
 719
 720 /*     case XPR_GOTO: */
 721 /*       ret = message ("goto %s", exprData_getLiteral (data)); */
 722 /*       break; */
 723
 724 /*     case XPR_CONTINUE: */
 725 /*       ret = cstring_makeLiteral ("continue"); */
 726 /*       break; */
 727
 728 /*     case XPR_BREAK: */
 729 /*       ret = cstring_makeLiteral ("break"); */
 730 /*       break; */
 731
 732 /*     case XPR_RETURN: */
 733 /*       ret = message ("return %s", exprNode_generateConstraints (exprData_getSingle (data))); */
 734 /*       break; */
 735
 736 /*     case XPR_NULLRETURN: */
 737 /*       ret = cstring_makeLiteral ("return"); */
 738 /*       break; */
 739
 740 /*     case XPR_COMMA: */
 741 /*       ret = message ("%s, %s",  */
 742 /*                   exprNode_generateConstraints (exprData_getPairA (data)), */
 743 /*                   exprNode_generateConstraints (exprData_getPairB (data))); */
 744 /*       break; */
 745
 746 /*     case XPR_COND: */
 747 /*       ret = message ("%s ? %s : %s", */
 748 /*                   exprNode_generateConstraints (exprData_getTriplePred (data)), */
 749 /*                   exprNode_generateConstraints (exprData_getTripleTrue (data)), */
 750 /*                   exprNode_generateConstraints (exprData_getTripleFalse (data))); */
 751 /*       break; */
 752 /*     case XPR_IF: */
 753 /*       ret = message ("if (%s) %s",  */
 754 /*                   exprNode_generateConstraints (exprData_getPairA (data)), */
 755 /*                   exprNode_generateConstraints (exprData_getPairB (data))); */
 756 /*       e->constraints = constraintList_exprNodemerge (exprData_getPairA (data),exprData_getPairB(data)); */
 757 /*       break; */
 758
 759 /*     case XPR_IFELSE: */
 760 /*       ret = message ("if (%s) %s else %s", */
 761 /*                   exprNode_generateConstraints (exprData_getTriplePred (data)), */
 762 /*                   exprNode_generateConstraints (exprData_getTripleTrue (data)), */
 763 /*                   exprNode_generateConstraints (exprData_getTripleFalse (data))); */
 764 /*       break; */
 765 /*     case XPR_WHILE: */
 766 /*       ret = message ("while (%s) %s", */
 767 /*                   exprNode_generateConstraints (exprData_getPairA (data)), */
 768 /*                   exprNode_generateConstraints (exprData_getPairB (data))); */
 769 /*       e->constraints = constraintList_exprNodemerge (exprData_getPairA (data), exprData_getPairB (data) ); */
 770 /*       break; */
 771
 772 /*     case XPR_WHILEPRED: */
 773 /*       ret = cstring_copy (exprNode_generateConstraints (exprData_getSingle (data))); */
 774 /*       break; */
 775
 776 /*     case XPR_TOK: */
 777 /*       ret = cstring_copy (lltok_unparse (exprData_getTok (data))); */
 778 /*       break; */
 779
 780 /*     case XPR_DOWHILE: */
 781 /*       ret = message ("do { %s } while (%s)", */
 782 /*                   exprNode_generateConstraints (exprData_getPairB (data)), */
 783 /*                   exprNode_generateConstraints (exprData_getPairA (data))); */
 784 /*       break; */
 785
 786 /*     case XPR_BLOCK: */
 787 /*       ret = message ("{ %s }", exprNode_generateConstraints (exprData_getSingle (data))); */
 788 /*       e->constraints = (exprData_getSingle (data))->constraints; */
 789 /*       break; */
 790
 791 /*     case XPR_STMT: */
 792 /*       ret = cstring_copy (exprNode_generateConstraints (exprData_getSingle (data))); */
 793 /*       e->constraints = (exprData_getSingle (data))->constraints; */
 794 /*       break; */
 795
 796 /*     case XPR_STMTLIST: */
 797 /*       ret = message ("%s; %s",  */
 798 /*                   exprNode_generateConstraints (exprData_getPairA (data)), */
 799 /*                   exprNode_generateConstraints (exprData_getPairB (data))); */
 800 /*       e->constraints = constraintList_exprNodemerge (exprData_getPairA (data), exprData_getPairB (data) ); */
 801 /*       break; */
 802
 803 /*     case XPR_FTDEFAULT: */
 804 /*     case XPR_DEFAULT: */
 805 /*       ret = cstring_makeLiteral ("default:"); */
 806 /*       break; */
 807
 808 /*     case XPR_SWITCH: */
 809 /*       ret = message ("switch (%s) %s",  */
 810 /*                   exprNode_generateConstraints (exprData_getPairA (data)), */
 811 /*                   exprNode_generateConstraints (exprData_getPairB (data))); */
 812 /*       break; */
 813
 814 /*     case XPR_FTCASE: */
 815 /*     case XPR_CASE: */
 816 /*       ret = message ("case %s:",  */
 817 /*                   exprNode_generateConstraints (exprData_getSingle (data))); */
 818 /*       break; */
 819
 820 /*     case XPR_INIT: */
 821 /*       ret = message ("%s = %s", */
 822 /*                   idDecl_getName (exprData_getInitId (data)), */
 823 /*                   exprNode_generateConstraints (exprData_getInitNode (data))); */
 824 /*       break; */
 825
 826 /*     case XPR_FACCESS: */
 827 /*       ret = message ("%s.%s", */
 828 /*                   exprNode_generateConstraints (exprData_getFieldNode (data)), */
 829 /*                   exprData_getFieldName (data)); */
 830 /*       break; */
 831
 832 /*     case XPR_ARROW: */
 833 /*             ret = message ("%s->%s", */
 834 /*                   exprNode_generateConstraints (exprData_getFieldNode (data)), */
 835 /*                   exprData_getFieldName (data)); */
 836 /*       break; */
 837
 838 /*     case XPR_STRINGLITERAL: */
 839 /*       ret = cstring_copy (exprData_getLiteral (data)); */
 840 /*       break; */
 841
 842 /*     case XPR_NUMLIT: */
 843 /*       ret = cstring_copy (exprData_getLiteral (data)); */
 844 /*       break; */
 845
 846 /*     case XPR_NODE: */
 847 /*       ret = cstring_makeLiteral ("<node>"); */
 848 /*       break; */
 849 /*     } */
 850
 851 /*   return ret;  */
 852 /* } */