Repair/RepairCompiler/MCC/IR/SemanticChecker.java

   1 package MCC.IR;
   2
   3 import java.util.*;
   4 import java.math.BigInteger;
   5 import MCC.State;
   6
   7 public class SemanticChecker {
   8
   9     private static final boolean CREATE_MISSING = true;
  10
  11     public State state;
  12
  13     Vector vConstraints;
  14     Vector vRules;
  15
  16     SymbolTableStack sts;
  17
  18     SymbolTable stSets;
  19     SymbolTable stRelations;
  20     SymbolTable stTypes;
  21     SymbolTable stGlobals;
  22
  23     StructureTypeDescriptor dCurrentType;
  24
  25     IRErrorReporter er;
  26
  27     public SemanticChecker () {
  28         dCurrentType = null;
  29         stTypes = null;
  30         er = null;
  31     }
  32
  33     public boolean check(State state, IRErrorReporter er) {
  34
  35         this.state = state;
  36         State.currentState = state;
  37
  38         if (er == null) {
  39             throw new IRException("IRBuilder.build: Received null ErrorReporter");
  40         } else {
  41             this.er = er;
  42         }
  43
  44         if (state.ptStructures == null) {
  45             throw new IRException("IRBuilder.build: Received null ParseNode");
  46         }
  47
  48         state.vConstraints = new Vector();
  49         vConstraints = state.vConstraints;
  50
  51         state.vRules = new Vector();
  52         vRules = state.vRules;
  53
  54         state.stTypes = new SymbolTable();
  55         stTypes = state.stTypes;
  56
  57         state.stSets = new SymbolTable();
  58         stSets = state.stSets;
  59
  60         state.stRelations = new SymbolTable();
  61         stRelations = state.stRelations;
  62
  63         state.stGlobals = new SymbolTable();
  64         stGlobals = state.stGlobals;
  65
  66         sts = new SymbolTableStack();
  67
  68         // add int and bool to the types list
  69         stTypes.add(ReservedTypeDescriptor.BIT);
  70         stTypes.add(ReservedTypeDescriptor.BYTE);
  71         stTypes.add(ReservedTypeDescriptor.SHORT);
  72         stTypes.add(ReservedTypeDescriptor.INT);
  73
  74         stSets.add(new ReservedSetDescriptor("int", ReservedTypeDescriptor.INT));
  75         stSets.add(new ReservedSetDescriptor("token", ReservedTypeDescriptor.INT));
  76
  77         boolean ok = true;
  78
  79         er.setFilename(state.infile + ".struct");
  80         if (!parse_structures(state.ptStructures)) {
  81             ok = false;
  82         }
  83
  84         er.setFilename(state.infile + ".space");
  85         if (!parse_space(state.ptSpace)) {
  86             ok = false;
  87         }
  88
  89         er.setFilename(state.infile + ".constraints");
  90         if (!parse_constraints(state.ptConstraints)) {
  91             ok = false;
  92         }
  93
  94         er.setFilename(state.infile + ".model");
  95         if (!parse_rules(state.ptModel)) {
  96             ok = false;
  97         }
  98
  99         return ok;
 100     }
 101
 102     /********************** HELPER FUNCTIONS ************************/
 103
 104     /**
 105      * special case lookup that returns null if no such type exists
 106      */
 107     private TypeDescriptor lookupType(String typename) {
 108         return lookupType(typename, false);
 109     }
 110
 111     /**
 112      * does a look up in the types symbol table. if the type is
 113      * not found than a missing type descriptor is returned
 114      */
 115     private TypeDescriptor lookupType(String typename, boolean createmissing) {
 116         if (stTypes.get(typename) != null) {
 117             // the type exists, so plug in the descriptor directly
 118             return (TypeDescriptor) stTypes.get(typename);
 119         } else if (createmissing) {
 120             return new MissingTypeDescriptor(typename);
 121         } else {
 122             return null;
 123         }
 124     }
 125
 126     /**
 127      * reserve a name
 128      */
 129     private VarDescriptor reserveName(ParseNode pn) {
 130         assert pn != null;
 131         String varname = pn.getTerminal();
 132         assert varname != null;
 133
 134         /* do semantic check and if valid, add it to symbol table
 135            and add it to the quantifier as well */
 136         if (sts.peek().contains(varname)) {
 137             /* Semantic Error: redefinition */
 138             er.report(pn, "Redefinition of '" + varname + "'");
 139             return null;
 140         } else {
 141             VarDescriptor vd = new VarDescriptor(varname);
 142             sts.peek().add(vd);
 143             return vd;
 144         }
 145     }
 146
 147     /**
 148      * special case lookup that returns null if no such set exists
 149      */
 150     private SetDescriptor lookupSet(String setname) {
 151         return lookupSet(setname, false);
 152     }
 153
 154     /**
 155      * does a look up in the set's symbol table. if the set is
 156      * not found than a missing set descriptor is returned
 157      */
 158     private SetDescriptor lookupSet(String setname, boolean createmissing) {
 159         if (stSets.get(setname) != null) {
 160             // the set exists, so plug in the descriptor directly
 161             return (SetDescriptor) stSets.get(setname);
 162         } else if (createmissing) {
 163             return new MissingSetDescriptor(setname);
 164         } else {
 165             return null;
 166         }
 167     }
 168
 169     /**
 170      * does a look up in the set's symbol table. if the set is
 171      * not found than a missing set descriptor is returned
 172      */
 173     private RelationDescriptor lookupRelation(String relname) {
 174         if (stRelations.get(relname) != null) {
 175             // the relation exists, so plug in the descriptor directly
 176             return (RelationDescriptor) stRelations.get(relname);
 177         } else {
 178             return null;
 179         }
 180     }
 181
 182
 183     private static int count = 0;
 184     private boolean precheck(ParseNode pn, String label) {
 185         if (pn == null) {
 186             er.report(pn, "IE: Expected '" + label + "', got null");
 187             assert false;
 188             return false;
 189         }
 190
 191         if (! pn.getLabel().equals(label)) {
 192             er.report(pn, "IE: Expected '" + label + "', got '" + pn.getLabel() + "'");
 193             assert false;
 194             return false;
 195         }
 196
 197         if (state.verbose >= 2) {
 198             System.err.println("visiting*" + (count++) + ": " + label);
 199         }
 200
 201         return true;
 202     }
 203
 204     /********************* PARSING FUNCTIONS ************************/
 205
 206     private boolean parse_rules(ParseNode pn) {
 207         if (!precheck(pn, "rules")) {
 208             return false;
 209         }
 210
 211         boolean ok = true;
 212         ParseNodeVector rules = pn.getChildren();
 213
 214         for (int i = 0; i < rules.size(); i++) {
 215             ParseNode rule = rules.elementAt(i);
 216             if (!parse_rule(rule)) {
 217                 ok = false;
 218             }
 219         }
 220
 221         /* type check */
 222         Iterator ruleiterator = state.vRules.iterator();
 223
 224         while (ruleiterator.hasNext()) {
 225             Rule rule = (Rule) ruleiterator.next();
 226             Expr guard = rule.getGuardExpr();
 227             final SymbolTable rulest = rule.getSymbolTable();
 228             SemanticAnalyzer sa = new SemanticAnalyzer() {
 229                     public IRErrorReporter getErrorReporter() { return er; }
 230                     public SymbolTable getSymbolTable() { return rulest; }
 231                 };
 232             TypeDescriptor guardtype = guard.typecheck(sa);
 233
 234             if (guardtype == null) {
 235                 ok = false;
 236             } else if (guardtype != ReservedTypeDescriptor.INT) {
 237                 er.report(null, "Type of guard must be 'int' not '" + guardtype.getSymbol() + "'");
 238                 ok = false;
 239             }
 240
 241             if (!rule.getInclusion().typecheck(sa)) {
 242                 ok = false;
 243             }
 244
 245             Iterator quantifiers = rule.quantifiers();
 246
 247             while (quantifiers.hasNext()) {
 248                 Quantifier q = (Quantifier) quantifiers.next();
 249
 250                 if (q instanceof ForQuantifier && !((ForQuantifier)q).typecheck(sa)) {
 251                     ok = false;
 252                 }
 253             }
 254         }
 255
 256         /* do any post checks ?? */
 257
 258         return ok;
 259     }
 260
 261     private boolean parse_rule(ParseNode pn) {
 262         if (!precheck(pn, "rule")) {
 263             return false;
 264         }
 265
 266         boolean ok = true;
 267         Rule rule = new Rule();
 268
 269         /* get rule type */
 270         boolean isstatic = pn.getChild("static") != null;
 271         boolean isdelay = pn.getChild("delay") != null;
 272         rule.setStatic(isstatic);
 273         rule.setDelay(isdelay);
 274
 275         /* set up symbol table for constraint */
 276         assert sts.empty();
 277         sts.push(stGlobals);
 278         sts.push(rule.getSymbolTable());
 279
 280         /* optional quantifiers */
 281         if (pn.getChild("quantifiers") != null) {
 282             ParseNodeVector quantifiers = pn.getChild("quantifiers").getChildren();
 283
 284             for (int i = 0; i < quantifiers.size(); i++) {
 285                 ParseNode qn = quantifiers.elementAt(i);
 286                 Quantifier quantifier = parse_quantifier(qn);
 287
 288                 if (quantifier == null) {
 289                     ok = false;
 290                 } else {
 291                     rule.addQuantifier(quantifier);
 292                 }
 293             }
 294         }
 295
 296         /* get guard expr */
 297         Expr guard = parse_expr(pn.getChild("expr"));
 298
 299         if (guard == null) {
 300             ok = false;
 301         } else {
 302             rule.setGuardExpr(guard);
 303         }
 304
 305         /* inclusion constraint */
 306         Inclusion inclusion = parse_inclusion(pn.getChild("inclusion"));
 307
 308         if (inclusion == null) {
 309             ok = false;
 310         } else {
 311             rule.setInclusion(inclusion);
 312         }
 313
 314         /* pop symbol table stack */
 315         SymbolTable st = sts.pop();
 316         sts.pop(); /* pop off globals */
 317
 318         /* make sure the stack we pop is our rule s.t. */
 319         assert st == rule.getSymbolTable();
 320         assert sts.empty();
 321
 322         /* add rule to global set */
 323         vRules.addElement(rule);
 324
 325         return ok;
 326     }
 327
 328     private Inclusion parse_inclusion(ParseNode pn) {
 329         if (!precheck(pn, "inclusion")) {
 330             return null;
 331         }
 332
 333         if (pn.getChild("set") != null) {
 334             ParseNode set = pn.getChild("set");
 335             Expr expr = parse_expr(set.getChild("expr"));
 336
 337             if (expr == null) {
 338                 return null;
 339             }
 340
 341             String setname = set.getChild("name").getTerminal();
 342             assert setname != null;
 343             SetDescriptor sd = lookupSet(setname);
 344
 345             if (sd == null) {
 346                 er.report(set.getChild("name"), "Undefined set '" + setname + "'");
 347                 return null;
 348             }
 349
 350             return new SetInclusion(expr, sd);
 351         } else if (pn.getChild("relation") != null) {
 352             ParseNode relation = pn.getChild("relation");
 353             Expr leftexpr = parse_expr(relation.getChild("left").getChild("expr"));
 354             Expr rightexpr = parse_expr(relation.getChild("right").getChild("expr"));
 355
 356             if ((leftexpr == null) || (rightexpr == null)) {
 357                 return null;
 358             }
 359
 360             String relname = relation.getChild("name").getTerminal();
 361             assert relname != null;
 362             RelationDescriptor rd = lookupRelation(relname);
 363
 364             if (rd == null) {
 365                 er.report(relation.getChild("name"), "Undefined relation '" + relname + "'");
 366                 return null;
 367             }
 368
 369             return new RelationInclusion(leftexpr, rightexpr, rd);
 370         } else {
 371             throw new IRException();
 372         }
 373     }
 374
 375     private boolean parse_constraints(ParseNode pn) {
 376         if (!precheck(pn, "constraints")) {
 377             return false;
 378         }
 379
 380         boolean ok = true;
 381         ParseNodeVector constraints = pn.getChildren();
 382
 383         for (int i = 0; i < constraints.size(); i++) {
 384             ParseNode constraint = constraints.elementAt(i);
 385             assert constraint.getLabel().equals("constraint");
 386             if (!parse_constraint(constraint)) {
 387                 ok = false;
 388             }
 389         }
 390
 391         /* do any post checks... (type constraints, etc?) */
 392
 393         Iterator consiterator = state.vConstraints.iterator();
 394
 395         while (consiterator.hasNext()) {
 396             Constraint cons = (Constraint) consiterator.next();
 397
 398             final SymbolTable consst = cons.getSymbolTable();
 399             SemanticAnalyzer sa = new SemanticAnalyzer() {
 400                     public IRErrorReporter getErrorReporter() { return er; }
 401                     public SymbolTable getSymbolTable() { return consst; }
 402                 };
 403
 404             TypeDescriptor constype = cons.getLogicStatement().typecheck(sa);
 405
 406             if (constype == null) {
 407                 System.out.println("Failed attempting to type constraint");
 408                 ok = false;
 409             } else if (constype != ReservedTypeDescriptor.INT) {
 410                 er.report(null, "Type of guard must be 'int' not '" + constype.getSymbol() + "'");
 411                 ok = false;
 412             }
 413         }
 414
 415         return ok;
 416     }
 417
 418     private boolean parse_constraint(ParseNode pn) {
 419         if (!precheck(pn, "constraint")) {
 420             return false;
 421         }
 422
 423         boolean ok = true;
 424         Constraint constraint = new Constraint();
 425
 426         /* test crash */
 427         boolean crash = pn.getChild("crash") != null;
 428         constraint.setCrash(crash);
 429
 430         /* set up symbol table for constraint */
 431         assert sts.empty();
 432         sts.push(constraint.getSymbolTable());
 433
 434         /* get quantifiers */
 435         if (pn.getChild("quantifiers") != null) {
 436             ParseNodeVector quantifiers = pn.getChild("quantifiers").getChildren();
 437
 438             for (int i = 0; i < quantifiers.size(); i++) {
 439                 ParseNode qn = quantifiers.elementAt(i);
 440                 assert qn.getLabel().equals("quantifier");
 441                 Quantifier quantifier = parse_quantifier(qn);
 442                 if (quantifier == null) {
 443                     System.out.println("Failed parsing quantifier");
 444                     ok = false;
 445                 } else {
 446                     constraint.addQuantifier(quantifier);
 447                 }
 448             }
 449         }
 450
 451         /* get body */
 452         LogicStatement logicexpr = parse_body(pn.getChild("body"));
 453
 454         if (logicexpr == null) {
 455             System.out.println("Failed parsing logical expression");
 456             ok = false;
 457         } else {
 458             constraint.setLogicStatement(logicexpr);
 459         }
 460
 461         /* pop symbol table stack */
 462         SymbolTable st = sts.pop();
 463
 464         /* make sure the stack we pop is our constraint s.t. */
 465         assert st == constraint.getSymbolTable();
 466         assert sts.empty();
 467
 468         /* add to vConstraints */
 469         vConstraints.addElement(constraint);
 470
 471         return ok;
 472     }
 473
 474     private Quantifier parse_quantifier(ParseNode pn) {
 475         if (!precheck(pn, "quantifier")) {
 476             return null;
 477         }
 478
 479         if (pn.getChild("forall") != null) { /* forall element in Set */
 480             SetQuantifier sq = new SetQuantifier();
 481
 482             /* get var */
 483             VarDescriptor vd = reserveName(pn.getChild("var"));
 484
 485             if (vd == null) {
 486                 return null;
 487             }
 488
 489             sq.setVar(vd);
 490
 491             /* parse the set */
 492             SetDescriptor set = parse_set(pn.getChild("set"));
 493             assert set != null;
 494             sq.setSet(set);
 495             vd.setSet(set);
 496
 497             vd.setType(set.getType());
 498
 499             /* return to caller */
 500             return sq;
 501
 502         } else if (pn.getChild("relation") != null) { /* for < v1, v2 > in Relation */
 503             RelationQuantifier rq = new RelationQuantifier();
 504
 505             /* get vars */
 506             VarDescriptor vd1 = reserveName(pn.getChild("left"));
 507             VarDescriptor vd2 = reserveName(pn.getChild("right"));
 508
 509             if ((vd1 == null) || (vd2 == null)) {
 510                 return null;
 511             }
 512
 513             rq.setTuple(vd1, vd2);
 514
 515             /* get relation */
 516             String relationname = pn.getChild("relation").getTerminal();
 517             assert relationname != null;
 518             RelationDescriptor rd = lookupRelation(relationname);
 519
 520             if (rd == null) {
 521                 return null;
 522             }
 523
 524             rq.setRelation(rd);
 525             vd1.setType(rd.getDomain().getType());
 526             vd1.setSet(rd.getDomain());
 527             vd2.setType(rd.getRange().getType());
 528             vd2.setSet(rd.getRange());
 529             return rq;
 530         } else if (pn.getChild("for") != null) { /* for j = x to y */
 531             ForQuantifier fq = new ForQuantifier();
 532
 533             /* grab var */
 534             VarDescriptor vd = reserveName(pn.getChild("var"));
 535
 536             if (vd == null) {
 537                 return null;
 538             }
 539
 540             vd.setSet(lookupSet("int", false));
 541             vd.setType(ReservedTypeDescriptor.INT);
 542             fq.setVar(vd);
 543
 544             /* grab lower/upper bounds */
 545             Expr lower = parse_expr(pn.getChild("lower").getChild("expr"));
 546             Expr upper = parse_expr(pn.getChild("upper").getChild("expr"));
 547
 548
 549             if ((lower == null) || (upper == null)) {
 550                 return null;
 551             }
 552             vd.setBounds(lower,upper);
 553             fq.setBounds(lower, upper);
 554
 555             return fq;
 556         } else {
 557             throw new IRException("not supported yet");
 558         }
 559     }
 560
 561     private LogicStatement parse_body(ParseNode pn) {
 562         if (!precheck(pn, "body")) {
 563             return null;
 564         }
 565
 566         if (pn.getChild("and") != null) {
 567             /* body AND body */
 568             LogicStatement left, right;
 569             left = parse_body(pn.getChild("and").getChild("left").getChild("body"));
 570             right = parse_body(pn.getChild("and").getChild("right").getChild("body"));
 571
 572             if ((left == null) || (right == null)) {
 573                 return null;
 574             }
 575
 576             // what do we want to call the and/or/not body classes?
 577             return new LogicStatement(LogicStatement.AND, left, right);
 578         } else if (pn.getChild("or") != null) {
 579             /* body OR body */
 580             LogicStatement left, right;
 581             left = parse_body(pn.getChild("or").getChild("left").getChild("body"));
 582             right = parse_body(pn.getChild("or").getChild("right").getChild("body"));
 583
 584             if ((left == null) || (right == null)) {
 585                 return null;
 586             }
 587
 588             return new LogicStatement(LogicStatement.OR, left, right);
 589         } else if (pn.getChild("not") != null) {
 590             /* NOT body */
 591             LogicStatement left = parse_body(pn.getChild("not").getChild("body"));
 592
 593             if (left == null) {
 594                 return null;
 595             }
 596
 597             return new LogicStatement(LogicStatement.NOT, left);
 598         } else if (pn.getChild("predicate") != null) {
 599             return parse_predicate(pn.getChild("predicate"));
 600         } else {
 601             throw new IRException();
 602         }
 603     }
 604
 605     private Predicate parse_predicate(ParseNode pn) {
 606         if (!precheck(pn, "predicate")) {
 607             return null;
 608         }
 609
 610         if (pn.getChild("inclusion") != null) {
 611             ParseNode in = pn.getChild("inclusion");
 612
 613             /* Expr */
 614             Expr expr = parse_expr(in.getChild("expr"));
 615
 616             if (expr == null) {
 617                 return null;
 618             }
 619
 620             /* get set expr */
 621             SetExpr setexpr = parse_setexpr(in.getChild("setexpr"));
 622
 623             if (setexpr == null) {
 624                 return null;
 625             }
 626
 627             return new InclusionPredicate(expr, setexpr);
 628         } else if (pn.getChild("expr") != null) {
 629             Expr expr = parse_expr(pn.getChild("expr"));
 630
 631             if (expr == null) {
 632                 return null;
 633             }
 634
 635             return new ExprPredicate(expr);
 636         } else {
 637             throw new IRException();
 638         }
 639     }
 640
 641     private SetDescriptor parse_set(ParseNode pn) {
 642         if (!precheck(pn, "set")) {
 643             return null;
 644         }
 645
 646         if (pn.getChild("name") != null) {
 647             String setname = pn.getChild("name").getTerminal();
 648             assert setname != null;
 649
 650             if (!stSets.contains(setname)) {
 651                 /* Semantic Error: unknown set */
 652                 er.report(pn, "Unknown set '" + setname + "' referenced in quantifier");
 653                 return null;
 654             } else {
 655                 /* all good, get setdescriptor */
 656                 SetDescriptor sd = (SetDescriptor) stSets.get(setname);
 657                 assert sd != null;
 658                 return sd;
 659             }
 660         } else if (pn.getChild("listofliterals") != null) {
 661             TokenSetDescriptor tokenset = new TokenSetDescriptor();
 662             ParseNodeVector token_literals = pn.getChild("listofliterals").getChildren();
 663             assert token_literals.size() > 0;
 664
 665             for (int i = 0; i < token_literals.size(); i++) {
 666                 ParseNode literal = token_literals.elementAt(i);
 667                 assert literal.getLabel().equals("literal");
 668                 LiteralExpr litexpr = parse_literal(literal);
 669
 670                 if (litexpr == null) {
 671                     return null;
 672                 }
 673
 674                 if (litexpr instanceof TokenLiteralExpr || litexpr instanceof IntegerLiteralExpr) {
 675                     tokenset.addLiteral(litexpr);
 676                 } else {
 677                     er.report(literal, "Elements of a user-defined set must be of type token or integer");
 678                     // return null; /* don't think we need to return null */
 679                 }
 680             }
 681
 682             return tokenset;
 683         } else {
 684             throw new IRException(pn.getTerminal());
 685         }
 686     }
 687
 688     private boolean parse_space(ParseNode pn) {
 689         if (!precheck(pn, "space")) {
 690             return false;
 691         }
 692
 693         boolean ok = true;
 694         ParseNodeVector sets = pn.getChildren("setdefinition");
 695         ParseNodeVector relations = pn.getChildren("relationdefinition");
 696
 697         assert pn.getChildren().size() == (sets.size() + relations.size());
 698
 699         /* parse sets */
 700         for (int i = 0; i < sets.size(); i++) {
 701             if (!parse_setdefinition(sets.elementAt(i))) {
 702                 ok = false;
 703             }
 704         }
 705
 706         /* parse relations */
 707         for (int i = 0; i < relations.size(); i++) {
 708             if (!parse_relationdefinition(relations.elementAt(i))) {
 709                 ok = false;
 710             }
 711         }
 712
 713         // ok, all the spaces have been parsed, now we should typecheck and check
 714         // for cycles etc.
 715
 716         // #TBD#: typecheck and check for cycles
 717
 718         /* replace missing with actual */
 719         Iterator allsets = state.stSets.descriptors();
 720
 721         while (allsets.hasNext()) {
 722             SetDescriptor sd = (SetDescriptor) allsets.next();
 723             Vector subsets = sd.getSubsets();
 724
 725             for (int i = 0; i < subsets.size(); i++) {
 726                 SetDescriptor subset = (SetDescriptor) subsets.elementAt(i);
 727
 728                 if (subset instanceof MissingSetDescriptor) {
 729                     SetDescriptor newsubset = lookupSet(subset.getSymbol());
 730
 731                     if (newsubset == null) {
 732                         er.report(null, "Unknown subset '" + subset.getSymbol() + "'");
 733                     } else {
 734                         subsets.setElementAt(newsubset, i);
 735                     }
 736                 }
 737             }
 738         }
 739
 740         return ok;
 741     }
 742
 743     private boolean parse_setdefinition(ParseNode pn) {
 744         if (!precheck(pn, "setdefinition")) {
 745             return false;
 746         }
 747
 748         boolean ok = true;
 749
 750         /* get set name */
 751         String setname = pn.getChild("name").getTerminal();
 752         assert (setname != null);
 753
 754         SetDescriptor sd = new SetDescriptor(setname);
 755
 756         /* get set type */
 757         String settype = pn.getChild("type").getTerminal();
 758         TypeDescriptor type = lookupType(settype);
 759         if (type == null) {
 760             er.report(pn, "Undefined type '" + settype + "'");
 761             ok = false;
 762         } else {
 763             sd.setType(type);
 764         }
 765
 766         /* is this a partition? */
 767         boolean partition = pn.getChild("partition") != null;
 768         sd.isPartition(partition);
 769
 770         /* if set has subsets, add them to set descriptor */
 771         if (pn.getChild("setlist") != null) {
 772             ParseNodeVector setlist = pn.getChild("setlist").getChildren();
 773
 774             for (int i = 0; i < setlist.size(); i++) {
 775                 String subsetname = setlist.elementAt(i).getLabel();
 776                 sd.addSubset(lookupSet(subsetname, CREATE_MISSING));
 777             }
 778         }
 779
 780         /* add set to symbol table */
 781         if (stSets.contains(setname)) {
 782             // Semantic Check: redefinition
 783             er.report(pn, "Redefinition of set: " + setname);
 784             ok = false;
 785         } else {
 786             stSets.add(sd);
 787         }
 788
 789         return ok;
 790     }
 791
 792     private boolean parse_relationdefinition(ParseNode pn) {
 793         if (!precheck(pn, "relationdefinition")) {
 794             return false;
 795         }
 796
 797         boolean ok = true;
 798
 799         /* get relation name */
 800         String relname = pn.getChild("name").getTerminal();
 801         assert relname != null;
 802
 803         RelationDescriptor rd = new RelationDescriptor(relname);
 804
 805         /* check if static */
 806         boolean bStatic = pn.getChild("static") != null;
 807         rd.isStatic(bStatic);
 808
 809         /* get domain */
 810         String domainsetname = pn.getChild("domain").getChild("type").getTerminal();
 811         assert domainsetname != null;
 812
 813         /* get range */
 814         String rangesetname = pn.getChild("range").getChild("type").getTerminal();
 815         assert rangesetname != null;
 816
 817         /* get domain multiplicity */
 818         String domainmult;
 819         if (pn.getChild("domain").getChild("domainmult") != null)
 820             domainmult = pn.getChild("domain").getChild("domainmult").getChild("mult").getTerminal();
 821         //assert domainmult != null;
 822
 823         /* get range multiplicity */
 824         String rangemult;
 825         if (pn.getChild("range").getChild("domainrange") != null)
 826             rangemult = pn.getChild("range").getChild("domainrange").getChild("mult").getTerminal();
 827         //assert rangemult != null;
 828
 829         /* NOTE: it is assumed that the sets have been parsed already so that the
 830            set namespace is fully populated. any missing setdescriptors for the set
 831            symbol table will be assumed to be errors and reported. */
 832
 833         SetDescriptor domainset = lookupSet(domainsetname);
 834         if (domainset == null) {
 835             er.report(pn, "Undefined set '" + domainsetname + "' referenced in relation '" + relname + "'");
 836             ok = false;
 837         } else {
 838             rd.setDomain(domainset);
 839         }
 840
 841         SetDescriptor rangeset = lookupSet(rangesetname);
 842         if (rangeset == null) {
 843             er.report(pn, "Undefined set '" + rangesetname + "' referenced in relation '" + relname + "'");
 844             ok = false;
 845         } else {
 846             rd.setRange(rangeset);
 847         }
 848
 849         // #TBD#: eventually we'll use the multiplicities but now we don't... oh well
 850
 851         /* lets add the relation to the global symbol table */
 852         if (!stRelations.contains(relname)) {
 853             stRelations.add(rd);
 854         } else {
 855             er.report(pn, "Redefinition of relation '" + relname + "'");
 856             ok = false;
 857         }
 858
 859         return ok;
 860     }
 861
 862     private boolean parse_structures(ParseNode pn) {
 863         if (!precheck(pn, "structures")) {
 864             return false;
 865         }
 866
 867         boolean ok = true;
 868         ParseNodeVector structures = pn.getChildren("structure");
 869
 870         for (int i = 0; i < structures.size(); i++) {
 871             if (!parse_structure(structures.elementAt(i))) {
 872                 ok = false;
 873             }
 874         }
 875
 876         ParseNodeVector globals = pn.getChildren("global");
 877
 878         for (int i = 0; i < globals.size(); i++) {
 879             if (!parse_global(globals.elementAt(i))) {
 880                 ok = false;
 881             }
 882         }
 883
 884         // ok, all the structures have been parsed, now we gotta type check
 885
 886         Enumeration types = stTypes.getDescriptors();
 887         while (types.hasMoreElements()) {
 888             TypeDescriptor t = (TypeDescriptor) types.nextElement();
 889
 890             if (t instanceof ReservedTypeDescriptor) {
 891                 // we don't need to check reserved types
 892             } else if (t instanceof StructureTypeDescriptor) {
 893
 894                 StructureTypeDescriptor type = (StructureTypeDescriptor) t;
 895                 TypeDescriptor subtype = type.getSuperType();
 896
 897                 // check that the subtype is valid
 898                 if (subtype instanceof MissingTypeDescriptor) {
 899                     TypeDescriptor newtype = lookupType(subtype.getSymbol());
 900                     if (newtype == null) {
 901                         // subtype not defined anywheere
 902                         // #TBD#: somehow determine how we can get the original parsenode (global function?)
 903                         er.report(null, "Undefined subtype '" + subtype.getSymbol() + "'");
 904                         ok = false;
 905                     } else {
 906                         type.setSuperType(newtype);
 907                     }
 908                 }
 909
 910                 Iterator fields = type.getFields();
 911
 912                 while (fields.hasNext()) {
 913                     FieldDescriptor field = (FieldDescriptor) fields.next();
 914                     TypeDescriptor fieldtype = field.getType();
 915
 916                     assert fieldtype != null;
 917
 918                     // check that the type is valid
 919                     if (fieldtype instanceof MissingTypeDescriptor) {
 920                         TypeDescriptor newtype = lookupType(fieldtype.getSymbol());
 921                         if (newtype == null) {
 922                             // type never defined
 923                             // #TBD#: replace new ParseNode with original parsenode
 924                             er.report(null, "Undefined type '" + fieldtype.getSymbol() + "'");
 925                             ok = false;
 926                         } else {
 927                             assert newtype != null;
 928                             field.setType(newtype);
 929                         }
 930                     }
 931                 }
 932
 933                 Iterator labels = type.getLabels();
 934
 935                 while (labels.hasNext()) {
 936                     LabelDescriptor label = (LabelDescriptor) labels.next();
 937                     TypeDescriptor labeltype = label.getType();
 938
 939                     assert labeltype != null;
 940
 941                     // check that the type is valid
 942                     if (labeltype instanceof MissingTypeDescriptor) {
 943                         TypeDescriptor newtype = lookupType(labeltype.getSymbol());
 944                         if (newtype == null) {
 945                             // type never defined
 946                             // #TBD#: replace new ParseNode with original parsenode
 947                             er.report(null, "Undefined type '" + labeltype.getSymbol() + "'");
 948                             ok = false;
 949                         } else {
 950                             assert newtype != null;
 951                             label.setType(newtype);
 952                         }
 953                     }
 954                 }
 955
 956             } else {
 957                 throw new IRException("shouldn't be any other typedescriptor classes");
 958             }
 959         }
 960
 961         if (!ok) {
 962             return false;
 963         }
 964
 965         types = stTypes.getDescriptors();
 966
 967         while (types.hasMoreElements()) {
 968             TypeDescriptor t = (TypeDescriptor) types.nextElement();
 969
 970             if (t instanceof ReservedTypeDescriptor) {
 971                 // we don't need to check reserved types
 972             } else if (t instanceof StructureTypeDescriptor) {
 973
 974                 StructureTypeDescriptor type = (StructureTypeDescriptor)t;
 975                 TypeDescriptor subtype = type.getSuperType();
 976                 Iterator fields = type.getFields();
 977
 978                 while (fields.hasNext()) {
 979                     FieldDescriptor field = (FieldDescriptor) fields.next();
 980
 981                     if (field instanceof ArrayDescriptor) {
 982                         ArrayDescriptor ad = (ArrayDescriptor) field;
 983                         Expr indexbound = ad.getIndexBound();
 984                         TypeDescriptor indextype = indexbound.typecheck(new SemanticAnalyzer() {
 985                                 public IRErrorReporter getErrorReporter() { return er; }
 986                                 public SymbolTable getSymbolTable() { return stGlobals; }
 987                             });
 988
 989                         if (indextype == null) {
 990                             ok = false;
 991                         } else if (indextype != ReservedTypeDescriptor.INT) {
 992                             er.report(null, "'" + type.getSymbol() + "." + field.getSymbol() + "' index bounds must be type 'int' not '" + indextype.getSymbol() + "'");
 993                             ok = false;
 994                         }
 995                     }
 996                 }
 997
 998                 Iterator labels = type.getLabels();
 999
1000                 while (labels.hasNext()) {
1001                     LabelDescriptor label = (LabelDescriptor) labels.next();
1002                     Expr index = label.getIndex();
1003
1004                     if (index != null) {
1005                         TypeDescriptor indextype = index.typecheck(new SemanticAnalyzer() {
1006                                 public IRErrorReporter getErrorReporter() { return er; }
1007                                 public SymbolTable getSymbolTable() { return stGlobals; }
1008                             });
1009
1010                         if (indextype != ReservedTypeDescriptor.INT) {
1011                             er.report(null, "Label '" + type.getSymbol() + "." + label.getSymbol() + "' index must be type 'int' not '" + indextype.getSymbol() + "'");
1012                             ok = false;
1013                         }
1014                     }
1015                 }
1016             } else {
1017                 throw new IRException("shouldn't be any other typedescriptor classes");
1018             }
1019         }
1020
1021         // #TBD#: need to make sure that no cycles exist in any of the declarations or subtypes
1022         // subtypes, of course, are not real subtypes, they are merely a way to validate a
1023         // cast, i believe
1024
1025         return ok;
1026     }
1027
1028     private boolean parse_global(ParseNode pn) {
1029         if (!precheck(pn, "global")) {
1030             return false;
1031         }
1032
1033         String name = pn.getChild("name").getTerminal();
1034         assert name != null;
1035
1036         String type = pn.getChild("type").getTerminal();
1037         assert type != null;
1038         TypeDescriptor td = lookupType(type);
1039         assert td != null;
1040         assert !(td instanceof ReservedTypeDescriptor);
1041
1042         if (stGlobals.contains(name)) {
1043             /* redefinition of global */
1044             er.report(pn, "Redefinition of global '" + name + "'");
1045             return false;
1046         }
1047
1048         stGlobals.add(new VarDescriptor(name, name, td,true));
1049         return true;
1050     }
1051
1052     private boolean parse_structure(ParseNode pn) {
1053         if (!precheck(pn, "structure")) {
1054             return false;
1055         }
1056
1057         boolean ok = true;
1058         String typename = pn.getChild("name").getTerminal();
1059         StructureTypeDescriptor type = new StructureTypeDescriptor(typename);
1060
1061         if (pn.getChild("subtype") != null) {
1062             // has a subtype, lets try to resolve it
1063             String subtype = pn.getChild("subtype").getTerminal();
1064
1065             if (subtype.equals(typename)) {
1066                 // Semantic Error: cyclic inheritance
1067                 er.report(pn, "Cyclic inheritance prohibited");
1068                 ok = false;
1069             }
1070
1071             /* lookup the type to get the type descriptor */
1072             type.setSuperType(lookupType(subtype, CREATE_MISSING));
1073         } else if (pn.getChild("subclass") != null) {
1074             // has a subtype, lets try to resolve it
1075             String subclass = pn.getChild("subclass").getTerminal();
1076
1077             if (subclass.equals(typename)) {
1078                 // Semantic Error: cyclic inheritance
1079                 er.report(pn, "Cyclic inheritance prohibited");
1080                 ok = false;
1081             }
1082
1083             /* lookup the type to get the type descriptor */
1084             type.setSuperType(lookupType(subclass, CREATE_MISSING));
1085             type.setSubClass(true);
1086         }
1087
1088         // set the current type so that the recursive parses on the labels
1089         // and fields can add themselves automatically to the current type
1090         dCurrentType = type;
1091
1092         // parse the labels and fields
1093         if (!parse_labelsandfields(pn.getChild("lf"))) {
1094             ok = false;
1095         }
1096
1097         if (stTypes.contains(typename)) {
1098             er.report(pn, "Redefinition of type '" + typename + "'");
1099             ok = false;
1100         } else {
1101             stTypes.add(type);
1102         }
1103
1104         return ok;
1105     }
1106
1107     private boolean parse_labelsandfields(ParseNode pn) {
1108         if (!precheck(pn, "lf")) {
1109             return false;
1110         }
1111
1112         boolean ok = true;
1113
1114         // check the fields first (need the field names
1115         // to type check the labels)
1116         if (!parse_fields(pn.getChild("fields"))) {
1117             ok = false;
1118         }
1119
1120         // check the labels now that all the fields are sorted
1121         if (!parse_labels(pn.getChild("labels"))) {
1122             ok = false;
1123         }
1124
1125         return ok;
1126     }
1127
1128     private boolean parse_fields(ParseNode pn) {
1129         if (!precheck(pn, "fields")) {
1130             return false;
1131         }
1132
1133         boolean ok = true;
1134
1135         /* NOTE: because the order of the fields is important when defining a data structure,
1136            and because the order is defined by the order of the fields defined in the field
1137            vector, its important that the parser returns the fields in the correct order */
1138
1139         ParseNodeVector fields = pn.getChildren();
1140
1141         for (int i = 0; i < fields.size(); i++) {
1142             ParseNode field = fields.elementAt(i);
1143             FieldDescriptor fd;
1144             boolean reserved;
1145             String name = null;
1146
1147             if (field.getChild("reserved") != null) {
1148                 // reserved field
1149                 // #TBD#: it will be necessary for reserved field descriptors to generate
1150                 // a unique symbol for the type descriptor requires it for its hashtable
1151                 fd = new ReservedFieldDescriptor();
1152                 reserved = true;
1153             } else {
1154                 name = field.getChild("name").getTerminal();
1155                 fd = new FieldDescriptor(name);
1156                 reserved = false;
1157             }
1158
1159             String type = field.getChild("type").getTerminal();
1160             boolean ptr = field.getChild("*") != null;
1161             fd.setPtr(ptr);
1162
1163             fd.setType(lookupType(type, CREATE_MISSING));
1164
1165             if (field.getChild("index") != null) {
1166                 // field is an array, so create an array descriptor to wrap the
1167                 // field descriptor and then replace the top level field descriptor with
1168                 // this array descriptor
1169                 Expr expr = parse_expr(field.getChild("index").getChild("expr"));
1170                 if (expr == null) {
1171                     // #ATTN#: do we really want to return an exception here?
1172                     throw new IRException("invalid index expression");
1173                 }
1174                 ArrayDescriptor ad = new ArrayDescriptor(fd, expr);
1175                 fd = ad;
1176             }
1177
1178             // add the current field to the current type
1179             if (reserved == false) {
1180                 // lets double check that we are redefining a field
1181                 if (dCurrentType.getField(name) != null) {
1182                     // Semantic Error: field redefinition
1183                     er.report(pn, "Redefinition of field '" + name + "'");
1184                     ok = false;
1185                 } else {
1186                     dCurrentType.addField(fd);
1187                 }
1188             } else {
1189                 dCurrentType.addField(fd);
1190             }
1191         }
1192
1193         return ok;
1194     }
1195
1196     private boolean parse_labels(ParseNode pn) {
1197         if (!precheck(pn, "labels")) {
1198             return false;
1199         }
1200
1201         boolean ok = true;
1202
1203         /* NOTE: parse_labels should be called after the fields have been parsed because any
1204            labels not found in the field set of the current type will be flagged as errors */
1205
1206         ParseNodeVector labels = pn.getChildren();
1207
1208         for (int i = 0; i < labels.size(); i++) {
1209             ParseNode label = labels.elementAt(i);
1210             String name = label.getChild("name").getTerminal();
1211             LabelDescriptor ld = new LabelDescriptor(name);
1212
1213             if (label.getChild("index") != null) {
1214                 Expr expr = parse_expr(label.getChild("index").getChild("expr"));
1215                 if (expr == null) {
1216                     /* #ATTN#: do we really want to return an exception here? */
1217                     throw new IRException("Invalid expression");
1218                 }
1219                 ld.setIndex(expr);
1220             }
1221
1222             String type = label.getChild("type").getTerminal();
1223
1224             ld.setType(lookupType(type, CREATE_MISSING));
1225
1226             String field = label.getChild("field").getTerminal();
1227             FieldDescriptor fd = dCurrentType.getField(field);
1228
1229             if (fd == null) {
1230                 /* Semantic Error: Undefined field in label */
1231                 er.report(label, "Undefined field '" + field + "' in label");
1232                 ok = false;
1233             } else {
1234                 ld.setField(fd);
1235             }
1236
1237             /* add label to current type */
1238             if (dCurrentType.getLabel(name) != null) {
1239                 /* semantic error: label redefinition */
1240                 er.report(pn, "Redefinition of label '" + name + "'");
1241                 ok = false;
1242             } else {
1243                 dCurrentType.addLabel(ld);
1244             }
1245         }
1246
1247         return ok;
1248     }
1249
1250     private Expr parse_expr(ParseNode pn) {
1251         if (!precheck(pn, "expr")) {
1252             return null;
1253         }
1254
1255         if (pn.getChild("var") != null) {
1256             // we've got a variable reference... we'll have to scope check it later
1257             // when we are completely done... there are also some issues of cyclic definitions
1258             return new VarExpr(pn.getChild("var").getTerminal());
1259         } else if (pn.getChild("literal") != null) {
1260             return parse_literal(pn.getChild("literal"));
1261         } else if (pn.getChild("operator") != null) {
1262             return parse_operator(pn.getChild("operator"));
1263         } else if (pn.getChild("relation") != null) {
1264             return parse_relation(pn.getChild("relation"));
1265         } else if (pn.getChild("sizeof") != null) {
1266             return parse_sizeof(pn.getChild("sizeof"));
1267         } else if (pn.getChild("simple_expr") != null) {
1268             return parse_simple_expr(pn.getChild("simple_expr"));
1269         } else if (pn.getChild("elementof") != null) {
1270             return parse_elementof(pn.getChild("elementof"));
1271         } else if (pn.getChild("tupleof") != null) {
1272             return parse_tupleof(pn.getChild("tupleof"));
1273         } else if (pn.getChild("isvalid") != null) {
1274             er.report(pn, "Operation 'isvalid' is currently unsupported.");
1275             return null;
1276         } else {
1277             er.report(pn, "Unknown or invalid expression type '" + pn.getTerminal() + "'");
1278             return null;
1279         }
1280     }
1281
1282     private Expr parse_elementof(ParseNode pn) {
1283         if (!precheck(pn, "elementof")) {
1284             return null;
1285         }
1286
1287         /* get setname */
1288         String setname = pn.getChild("name").getTerminal();
1289         assert setname != null;
1290         SetDescriptor sd = lookupSet(setname);
1291
1292         if (sd == null) {
1293             er.report(pn, "Undefined set '" + setname + "'");
1294             return null;
1295         }
1296
1297         /* get left side expr */
1298         Expr expr = parse_expr(pn.getChild("expr"));
1299
1300         if (expr == null) {
1301             return null;
1302         }
1303
1304         return new ElementOfExpr(expr, sd);
1305     }
1306
1307     private Expr parse_tupleof(ParseNode pn) {
1308         if (!precheck(pn, "tupleof")) {
1309             return null;
1310         }
1311
1312         /* get relation */
1313         String relname = pn.getChild("name").getTerminal();
1314         assert relname != null;
1315         RelationDescriptor rd = lookupRelation(relname);
1316
1317         if (rd == null) {
1318             er.report(pn, "Undefined relation '" + relname + "'");
1319             return null;
1320         }
1321
1322         Expr left = parse_expr(pn.getChild("left").getChild("expr"));
1323         Expr right = parse_expr(pn.getChild("right").getChild("expr"));
1324
1325         if ((left == null) || (right == null)) {
1326             return null;
1327         }
1328
1329         return new TupleOfExpr(left, right, rd);
1330     }
1331
1332     private Expr parse_simple_expr(ParseNode pn) {
1333         if (!precheck(pn, "simple_expr")) {
1334             return null;
1335         }
1336
1337         // only locations so far
1338         return parse_location(pn.getChild("location"));
1339     }
1340
1341     private Expr parse_location(ParseNode pn) {
1342         if (!precheck(pn, "location")) {
1343             return null;
1344         }
1345
1346         if (pn.getChild("var") != null) {
1347             // should be changed into a namespace check */
1348             return new VarExpr(pn.getChild("var").getTerminal());
1349         } else if (pn.getChild("cast") != null) {
1350             return parse_cast(pn.getChild("cast"));
1351         } else if (pn.getChild("dot") != null) {
1352             return parse_dot(pn.getChild("dot"));
1353         } else {
1354             throw new IRException();
1355         }
1356     }
1357
1358     private RelationExpr parse_relation(ParseNode pn) {
1359         if (!precheck(pn, "relation")) {
1360             return null;
1361         }
1362
1363         String relname = pn.getChild("name").getTerminal();
1364         boolean inverse = pn.getChild("inv") != null;
1365         Expr expr = parse_expr(pn.getChild("expr"));
1366
1367         if (expr == null) {
1368             return null;
1369         }
1370
1371         RelationDescriptor relation = lookupRelation(relname);
1372
1373         if (relation == null) {
1374             /* Semantic Error: relation not definied" */
1375             er.report(pn, "Undefined relation '" + relname + "'");
1376             return null;
1377         }
1378
1379         /* add usage so correct sets are created */
1380         relation.addUsage(inverse ? RelationDescriptor.INVIMAGE : RelationDescriptor.IMAGE);
1381
1382         return new RelationExpr(expr, relation, inverse);
1383     }
1384
1385     private SizeofExpr parse_sizeof(ParseNode pn) {
1386         if (!precheck(pn, "sizeof")) {
1387             return null;
1388         }
1389
1390         /* get setexpr */
1391         SetExpr setexpr = parse_setexpr(pn.getChild("setexpr"));
1392
1393         if (setexpr == null) {
1394             return null;
1395         }
1396
1397         return new SizeofExpr(setexpr);
1398     }
1399
1400     private CastExpr parse_cast(ParseNode pn) {
1401         if (!precheck(pn, "cast")) {
1402             return null;
1403         }
1404
1405         /* get type */
1406         String typename = pn.getChild("type").getTerminal();
1407         assert typename != null;
1408         TypeDescriptor type = lookupType(typename);
1409
1410         if (type == null) {
1411             /* semantic error: undefined type in cast */
1412             er.report(pn, "Undefined type '" + typename + "' in cast operator");
1413             return null;
1414         }
1415
1416         /* get expr */
1417         Expr expr = parse_simple_expr(pn.getChild("simple_expr"));
1418
1419         if (expr == null) {
1420             return null;
1421         }
1422
1423         return new CastExpr(type, expr);
1424     }
1425
1426     private SetExpr parse_setexpr(ParseNode pn) {
1427         if (!precheck(pn, "setexpr")) {
1428             return null;
1429         }
1430
1431         // #TBD#: setexpr and parse_relation seem to be cousins... is there a reduction/refactor possible?
1432
1433         if (pn.getChild("set") != null) {
1434             String setname = pn.getChild("set").getTerminal();
1435             assert setname != null;
1436             SetDescriptor sd = lookupSet(setname);
1437
1438             if (sd == null) {
1439                 er.report(pn, "Unknown or undefined set '" + setname + "'");
1440                 return null;
1441             } else {
1442                 return new SetExpr(sd);
1443             }
1444         } else if (pn.getChild("dot") != null) {
1445             VarDescriptor vd = parse_quantifiervar(pn.getChild("dot").getChild("quantifiervar"));
1446             RelationDescriptor relation = lookupRelation(pn.getChild("dot").getChild("relation").getTerminal());
1447             relation.addUsage(RelationDescriptor.IMAGE);
1448             return new ImageSetExpr(vd, relation);
1449         } else if (pn.getChild("dotinv") != null) {
1450             VarDescriptor vd = parse_quantifiervar(pn.getChild("dotinv").getChild("quantifiervar"));
1451             RelationDescriptor relation = lookupRelation(pn.getChild("dotinv").getChild("relation").getTerminal());
1452             relation.addUsage(RelationDescriptor.INVIMAGE);
1453             return new ImageSetExpr(ImageSetExpr.INVERSE, vd, relation);
1454         } else {
1455             throw new IRException();
1456         }
1457     }
1458
1459     private VarDescriptor parse_quantifiervar(ParseNode pn) {
1460         if (!precheck(pn, "quantifiervar")) {
1461             return null;
1462         }
1463
1464         /* get var */
1465         String varname = pn.getTerminal();
1466         assert varname != null;
1467
1468         /* NOTE: quantifier var's are only found in the constraints and
1469            model definitions... therefore we can do a semantic check here
1470            to make sure that the variables exist in the symbol table */
1471
1472         /* NOTE: its assumed that the symbol table stack is appropriately
1473            set up with the parent quantifier symbol table */
1474         assert !sts.empty();
1475
1476         /* do semantic check and if valid, add it to symbol table
1477            and add it to the quantifier as well */
1478         if (sts.peek().contains(varname)) {
1479             VarDescriptor vdold=(VarDescriptor)sts.peek().get(varname);
1480             return vdold;
1481             /*     Dan was creating a new VarDescriptor...This seems
1482                    like the wrong thing to do.  We'll just lookup the
1483                    other one.
1484                    --------------------------------------------------
1485                    VarDescriptor vd=new VarDescriptor(varname);
1486                    vd.setSet(vdold.getSet()); return vd;*/
1487         } else {
1488             /* Semantic Error: undefined variable */
1489             er.report(pn, "Undefined variable '" + varname + "'");
1490             return null;
1491         }
1492     }
1493
1494     private LiteralExpr parse_literal(ParseNode pn) {
1495         if (!precheck(pn, "literal")) {
1496             return null;
1497         }
1498
1499         if (pn.getChild("boolean") != null) {
1500             if (pn.getChild("boolean").getChild("true") != null) {
1501                 return new BooleanLiteralExpr(true);
1502             } else {
1503                 return new BooleanLiteralExpr(false);
1504             }
1505         } else if (pn.getChild("decimal") != null) {
1506             String integer = pn.getChild("decimal").getTerminal();
1507
1508             /* Check for integer literal overflow */
1509             BigInteger intLitBI = new BigInteger(integer);
1510             BigInteger intMax = new BigInteger("" + Integer.MAX_VALUE);
1511             BigInteger intMin = new BigInteger("" + Integer.MIN_VALUE);
1512             int value;
1513
1514             if (intLitBI.compareTo(intMin) < 0) {
1515                 value = Integer.MIN_VALUE;
1516                 er.warn(pn, "Integer literal overflow");
1517             } else if (intLitBI.compareTo(intMax) > 0) {
1518                 value = Integer.MAX_VALUE;
1519                 er.warn(pn, "Integer literal overflow");
1520             } else {
1521                 /* no truncation needed */
1522                 value = Integer.parseInt(integer);
1523             }
1524
1525             return new IntegerLiteralExpr(value);
1526         } else if (pn.getChild("token") != null) {
1527             return new TokenLiteralExpr(pn.getChild("token").getTerminal());
1528         } else if (pn.getChild("string") != null) {
1529             throw new IRException("string unsupported");
1530         } else if (pn.getChild("char") != null) {
1531             throw new IRException("char unsupported");
1532         } else {
1533             throw new IRException("unknown literal expression type.");
1534         }
1535     }
1536
1537     private OpExpr parse_operator(ParseNode pn) {
1538         if (!precheck(pn, "operator")) {
1539             return null;
1540         }
1541
1542         String opname = pn.getChild("op").getTerminal();
1543         Opcode opcode = Opcode.decodeFromString(opname);
1544
1545         if (opcode == null) {
1546             er.report(pn, "Unsupported operation: " + opname);
1547             return null;
1548         }
1549
1550         Expr left = parse_expr(pn.getChild("left").getChild("expr"));
1551         Expr right = null;
1552
1553         if (pn.getChild("right") != null) {
1554             right = parse_expr(pn.getChild("right").getChild("expr"));
1555         }
1556
1557         if (left == null) {
1558             return null;
1559         }
1560
1561         if (right == null && opcode != Opcode.NOT) {
1562             er.report(pn, "Two arguments required.");
1563             return null;
1564         }
1565
1566         return new OpExpr(opcode, left, right);
1567     }
1568
1569     private DotExpr parse_dot(ParseNode pn) {
1570         if (!precheck(pn, "dot")) {
1571             return null;
1572         }
1573
1574         Expr left = parse_simple_expr(pn.getChild("simple_expr"));
1575
1576         if (left == null) {
1577             return null;
1578         }
1579
1580         String field = pn.getChild("field").getTerminal();
1581
1582         Expr index = null;
1583
1584         if (pn.getChild("index") != null) {
1585             index = parse_expr(pn.getChild("index").getChild("expr"));
1586
1587             if (index == null) {
1588                 return null;
1589             }
1590         }
1591
1592         return new DotExpr(left, field, index);
1593     }
1594
1595 }
1596