Repair/RepairInterpreter/amodel.cc

   1 // Defines the Model Definition Language (MDL)
   2
   3 #include <stdio.h>
   4 #include "amodel.h"
   5 #include "omodel.h"
   6
   7
   8 // class Field
   9
  10 Field::Field(char *s) {
  11   str=s;
  12 }
  13
  14 void Field::print() {
  15   printf("%s",str);
  16 }
  17
  18 char * Field::field() {
  19   return str;
  20 }
  21
  22 // class AElementexpr
  23
  24 AElementexpr::AElementexpr(AElementexpr *l, AElementexpr *r, int op) {
  25   left=l;right=r;type=op;
  26 }
  27
  28 AElementexpr::AElementexpr(char *ctype, AElementexpr *l) {
  29   type=AELEMENTEXPR_CAST;
  30   left=l;
  31   casttype=ctype;
  32 }
  33
  34 AElementexpr::AElementexpr(Literal *lit) {
  35   literal=lit;
  36   type=AELEMENTEXPR_LIT;
  37 }
  38
  39 AElementexpr::AElementexpr(Label *lab) {
  40   label=lab;
  41   type=AELEMENTEXPR_LABEL;
  42 }
  43
  44 AElementexpr::AElementexpr(AElementexpr *l,Field *f) {
  45   field=f;
  46   left=l;
  47   type=AELEMENTEXPR_FIELD;
  48 }
  49
  50 AElementexpr::AElementexpr() {
  51   type=AELEMENTEXPR_NULL;
  52 }
  53
  54 AElementexpr::AElementexpr(AElementexpr *l,Field *f, AElementexpr * i) {
  55   field=f;
  56   left=l;
  57   right=i;
  58   type=AELEMENTEXPR_FIELDARRAY;
  59 }
  60
  61 AElementexpr * AElementexpr::getleft() {
  62   return left;
  63 }
  64
  65 char * AElementexpr::getcasttype() {
  66   return casttype;
  67 }
  68
  69 AElementexpr * AElementexpr::getright() {
  70   return right;
  71 }
  72
  73 int AElementexpr::gettype() {
  74   return type;
  75 }
  76
  77 Label * AElementexpr::getlabel() {
  78   return label;
  79 }
  80
  81 Literal * AElementexpr::getliteral() {
  82   return literal;
  83 }
  84
  85 Field * AElementexpr::getfield() {
  86   return field;
  87 }
  88
  89 void AElementexpr::print() {
  90   switch(type) {
  91   case AELEMENTEXPR_LABEL:
  92     label->print();
  93     break;
  94   case AELEMENTEXPR_SUB:
  95     printf("(");
  96     left->print();
  97     printf("-");
  98     right->print();
  99     printf(")");
 100     break;
 101   case AELEMENTEXPR_ADD:
 102     printf("(");
 103     left->print();
 104     printf("+");
 105     right->print();
 106     printf(")");
 107     break;
 108   case AELEMENTEXPR_MULT:
 109     printf("(");
 110     left->print();
 111     printf("*");
 112     right->print();
 113     printf(")");
 114     break;
 115   case AELEMENTEXPR_DIV:
 116     printf("(");
 117     left->print();
 118     printf("/");
 119     right->print();
 120     printf(")");
 121     break;
 122   case AELEMENTEXPR_LIT:
 123     literal->print();
 124     break;
 125   case AELEMENTEXPR_FIELD:
 126     left->print();
 127     printf(".");
 128     field->print();
 129     break;
 130   case AELEMENTEXPR_FIELDARRAY:
 131     left->print();
 132     printf(".");
 133     field->print();
 134     printf("[");
 135     right->print();
 136     printf("]");
 137     break;
 138   case AELEMENTEXPR_CAST:
 139     printf("cast(%s,",casttype);
 140     left->print();
 141     printf(")");
 142     break;
 143   case AELEMENTEXPR_NULL:
 144     printf("NULL");
 145     break;
 146   }
 147 }
 148
 149 // class Type
 150
 151 Type::Type(char *s, int n, Label** l) {
 152   str=s;numlabels=n;labels=l;
 153 }
 154
 155 void Type::print() {
 156   printf("(%s(",str);
 157   for(int i=0;i>numlabels;i++) {
 158     labels[i]->print();
 159   }
 160   printf("))");
 161 }
 162
 163 int Type::getnumlabels() {
 164   return numlabels;
 165 }
 166
 167 Label * Type::getlabel(int i) {
 168   return labels[i];
 169 }
 170
 171 // class TypeEle
 172
 173 TypeEle::TypeEle(char *s, int n, AElementexpr** e) {
 174   str=s;numexpr=n;exprs=e;
 175 }
 176
 177 void TypeEle::print() {
 178   printf("(%s(",str);
 179   for(int i=0;i<numexpr;i++) {
 180     exprs[i]->print();
 181   }
 182   printf("))");
 183 }
 184
 185 int TypeEle::getnumexpr() {
 186   return numexpr;
 187 }
 188
 189 AElementexpr * TypeEle::getexpr(int i) {
 190   return exprs[i];
 191 }
 192
 193 // class AQuantifier
 194
 195 AQuantifier::AQuantifier(Label *l,Type *t, Set *s) {
 196   left=l;
 197   tleft=t;
 198   set=s;
 199   type=AQUANTIFIER_SING;
 200 }
 201
 202 AQuantifier::AQuantifier(Label *l,Type *tl, Label *r, Type *tr, Set *s) {
 203   left=l;
 204   tleft=tl;
 205   right=r;
 206   tright=tr;
 207   set=s;
 208   type=AQUANTIFIER_TUPLE;
 209 }
 210
 211 AQuantifier::AQuantifier(Label *l,AElementexpr *e1, AElementexpr *e2) {
 212   left=l;
 213   lower=e1;upper=e2;
 214   type=AQUANTIFIER_RANGE;
 215 }
 216
 217 Label * AQuantifier::getleft() {
 218   return left;
 219 }
 220
 221 Type * AQuantifier::gettleft() {
 222   return tleft;
 223 }
 224
 225 Type * AQuantifier::gettright() {
 226   return tright;
 227 }
 228
 229 Label * AQuantifier::getright() {
 230   return right;
 231 }
 232
 233 Set * AQuantifier::getset() {
 234   return set;
 235 }
 236
 237 AElementexpr * AQuantifier::getlower() {
 238   return lower;
 239 }
 240
 241 AElementexpr * AQuantifier::getupper() {
 242   return upper;
 243 }
 244
 245 int AQuantifier::gettype() {
 246   return type;
 247 }
 248
 249 void AQuantifier::print() {
 250   switch(type) {
 251   case AQUANTIFIER_SING:
 252     printf("forall ");
 253     if (tleft!=NULL)
 254       tleft->print();
 255     left->print();
 256     printf(" in ");
 257     set->print();
 258     break;
 259   case AQUANTIFIER_TUPLE:
 260     printf("forall <");
 261     if (tleft!=NULL)
 262       tleft->print();
 263     left->print();
 264     if (tright!=NULL)
 265       tright->print();
 266     right->print();
 267     printf("> in ");
 268     set->print();
 269     break;
 270   case AQUANTIFIER_RANGE:
 271     printf("for ");
 272     left->print();
 273     printf("=");
 274     lower->print();
 275     printf(" to ");
 276     upper->print();
 277     break;
 278   }
 279 }
 280
 281 // class Statementa
 282
 283 Statementa::Statementa(AElementexpr *l, char *vt) {
 284   leftee=l;
 285   validtype=vt;
 286   type=STATEMENTA_VALID;
 287 }
 288
 289 char * Statementa::getvalidtype() {
 290   return validtype;
 291 }
 292
 293 Statementa::Statementa(AElementexpr *l, Set *s) {
 294   leftee=l;
 295   set=s;
 296   type=STATEMENTA_SET;
 297 }
 298
 299 Statementa::Statementa(Statementa *l, Statementa *r, int t) {
 300   left=l;
 301   right=r;
 302   type=t;
 303 }
 304
 305 int Statementa::gettype() {
 306   return type;
 307 }
 308
 309 Statementa * Statementa::getleft() {
 310   return left;
 311 }
 312
 313 Statementa * Statementa::getright() {
 314   return right;
 315 }
 316
 317 AElementexpr * Statementa::getleftee() {
 318   return leftee;
 319 }
 320
 321 AElementexpr * Statementa::getrightee() {
 322   return rightee;
 323 }
 324
 325 Statementa::Statementa(Statementa *l) {
 326   type=STATEMENTA_NOT;
 327   left=l;
 328 }
 329
 330 Statementa::Statementa() {
 331   type=STATEMENTA_TRUE;
 332 }
 333
 334 Statementa::Statementa(AElementexpr *l, AElementexpr *r, int t) {
 335   leftee=l;
 336   rightee=r;
 337   type=t;
 338 }
 339
 340 Set * Statementa::getset() {
 341   return set;
 342 }
 343
 344 void Statementa::print() {
 345   printf("(");
 346   switch(type) {
 347   case STATEMENTA_SET:
 348     leftee->print();
 349     printf(" in ");
 350     set->print();
 351     break;
 352   case STATEMENTA_OR:
 353     left->print();
 354     printf(" OR ");
 355     right->print();
 356     break;
 357   case STATEMENTA_AND:
 358     left->print();
 359     printf(" AND ");
 360     right->print();
 361     break;
 362   case STATEMENTA_NOT:
 363     printf("!");
 364     left->print();
 365     break;
 366   case STATEMENTA_EQUALS:
 367     leftee->print();
 368     printf("=");
 369     rightee->print();
 370     break;
 371   case STATEMENTA_LT:
 372     leftee->print();
 373     printf("<");
 374     rightee->print();
 375     break;
 376   case STATEMENTA_TRUE:
 377     printf("true");
 378     break;
 379   }
 380   printf(")");
 381 }
 382
 383 // class Statementb
 384
 385 TypeEle * Statementb::gettleft() {
 386   return tleft;
 387 }
 388
 389 TypeEle * Statementb::gettright() {
 390   return tright;
 391 }
 392
 393 AElementexpr * Statementb::getleft() {
 394   return left;
 395 }
 396
 397 AElementexpr * Statementb::getright() {
 398   return right;
 399 }
 400
 401 Setlabel * Statementb::getsetlabel() {
 402   return setlabel;
 403 }
 404
 405 Statementb::Statementb(TypeEle *tl,AElementexpr *l, Setlabel *sl) {
 406   left=l;setlabel=sl;tleft=tl;
 407   type=STATEMENTB_SING;
 408 }
 409
 410 int Statementb::gettype() {
 411   return type;
 412 }
 413
 414 Statementb::Statementb(TypeEle *tl,AElementexpr *l, TypeEle *tr,AElementexpr *r, Setlabel *sl) {
 415   left=l;right=r;
 416   tleft=tl;tright=tr;
 417   setlabel=sl;
 418   type=STATEMENTB_TUPLE;
 419 }
 420
 421 void Statementb::print() {
 422   switch(type) {
 423   case STATEMENTB_SING:
 424     left->print();
 425     printf(" in ");
 426     setlabel->print();
 427     break;
 428   case STATEMENTB_TUPLE:
 429     printf("<");
 430     left->print();
 431     printf(",");
 432     right->print();
 433     printf("> in ");
 434     setlabel->print();
 435     break;
 436   }
 437 }
 438
 439 // class Rule
 440
 441 Rule::Rule() {
 442   quantifiers=NULL;
 443   numquantifiers=0;
 444   statementa=NULL;
 445   statementb=NULL;
 446   delay=false;
 447   staticrule=false;
 448 }
 449
 450 Rule::Rule(AQuantifier **q, int nq) {
 451   quantifiers=q;
 452   numquantifiers=nq;
 453   statementa=NULL;
 454   statementb=NULL;
 455   delay=false;
 456   staticrule=false;
 457 }
 458
 459 void Rule::setdelay() {
 460   delay=true;
 461 }
 462
 463 bool Rule::isdelayed() {
 464   return delay;
 465 }
 466
 467 bool Rule::isstatic() {
 468   return staticrule;
 469 }
 470 void Rule::setstatic() {
 471   staticrule=true;
 472 }
 473
 474 void Rule::setstatementa(Statementa *sa) {
 475   statementa=sa;
 476 }
 477
 478 void Rule::setstatementb(Statementb *sb) {
 479   statementb=sb;
 480 }
 481
 482 Statementa * Rule::getstatementa() {
 483   return statementa;
 484 }
 485
 486 Statementb * Rule::getstatementb() {
 487   return statementb;
 488 }
 489
 490 int Rule::numquants() {
 491   return numquantifiers;
 492 }
 493
 494 AQuantifier* Rule::getquant(int i) {
 495   return quantifiers[i];
 496 }
 497
 498 void Rule::print() {
 499   printf("[");
 500   for(int i=0;i<numquantifiers;i++) {
 501     if (i!=0)
 502       printf(",");
 503     quantifiers[i]->print();
 504   }
 505   printf("],");
 506   statementa->print();
 507   printf(" => ");
 508   statementb->print();
 509   printf("\n");
 510 }