Robust/src/IR/Tree/BuildIR.java

   1 package IR.Tree;
   2 import IR.*;
   3 import Util.Lattice;
   4
   5 import java.util.*;
   6
   7
   8
   9 public class BuildIR {
  10   State state;
  11
  12   private int m_taskexitnum;
  13
  14   public BuildIR(State state) {
  15     this.state=state;
  16     this.m_taskexitnum = 0;
  17   }
  18
  19   public void buildtree(ParseNode pn, Set toanalyze) {
  20     parseFile(pn, toanalyze);
  21
  22     // numering the interfaces
  23     int if_num = 0;
  24     Iterator it_classes = state.getClassSymbolTable().getValueSet().iterator();
  25     while(it_classes.hasNext()) {
  26       ClassDescriptor cd = (ClassDescriptor)it_classes.next();
  27       if(cd.isInterface()) {
  28         cd.setInterfaceId(if_num++);
  29       }
  30     }
  31   }
  32
  33   Vector singleimports;
  34   Vector multiimports;
  35   NameDescriptor packages;
  36
  37   /** Parse the classes in this file */
  38   public void parseFile(ParseNode pn, Set toanalyze) {
  39     singleimports=new Vector();
  40     multiimports=new Vector();
  41
  42     ParseNode ipn=pn.getChild("imports").getChild("import_decls_list");
  43     if (ipn!=null) {
  44       ParseNodeVector pnv=ipn.getChildren();
  45       for(int i=0; i<pnv.size(); i++) {
  46         ParseNode pnimport=pnv.elementAt(i);
  47         NameDescriptor nd=parseName(pnimport.getChild("name"));
  48         if (isNode(pnimport,"import_single"))
  49           singleimports.add(nd);
  50         else
  51           multiimports.add(nd);
  52       }
  53     }
  54     ParseNode ppn=pn.getChild("packages").getChild("package");
  55     if (ppn!=null) {
  56       packages=parseName(ppn.getChild("name"));
  57     }
  58     ParseNode tpn=pn.getChild("type_declaration_list");
  59     if (tpn!=null) {
  60       ParseNodeVector pnv=tpn.getChildren();
  61       for(int i=0; i<pnv.size(); i++) {
  62         ParseNode type_pn=pnv.elementAt(i);
  63         if (isEmpty(type_pn))         /* Skip the semicolon */
  64           continue;
  65         if (isNode(type_pn,"class_declaration")) {
  66           ClassDescriptor cn=parseTypeDecl(type_pn);
  67           parseInitializers(cn);
  68           if (toanalyze!=null)
  69             toanalyze.add(cn);
  70           state.addClass(cn);
  71           // for inner classes/enum
  72           HashSet tovisit = new HashSet();
  73           Iterator it_icds = cn.getInnerClasses();
  74           while(it_icds.hasNext()) {
  75             tovisit.add(it_icds.next());
  76           }
  77
  78           while(!tovisit.isEmpty()) {
  79             ClassDescriptor cd = (ClassDescriptor)tovisit.iterator().next();
  80             tovisit.remove(cd);
  81             parseInitializers(cd);
  82             if(toanalyze != null) {
  83               toanalyze.add(cd);
  84             }
  85             state.addClass(cd);
  86
  87             Iterator it_ics = cd.getInnerClasses();
  88             while(it_ics.hasNext()) {
  89               tovisit.add(it_ics.next());
  90             }
  91
  92             Iterator it_ienums = cd.getEnum();
  93             while(it_ienums.hasNext()) {
  94               ClassDescriptor iecd = (ClassDescriptor)it_ienums.next();
  95               if(toanalyze != null) {
  96                 toanalyze.add(iecd);
  97               }
  98               state.addClass(iecd);
  99             }
 100           }
 101
 102           Iterator it_enums = cn.getEnum();
 103           while(it_enums.hasNext()) {
 104             ClassDescriptor ecd = (ClassDescriptor)it_enums.next();
 105             if(toanalyze != null) {
 106               toanalyze.add(ecd);
 107             }
 108             state.addClass(ecd);
 109           }
 110         } else if (isNode(type_pn,"task_declaration")) {
 111           TaskDescriptor td=parseTaskDecl(type_pn);
 112           if (toanalyze!=null)
 113             toanalyze.add(td);
 114           state.addTask(td);
 115         } else if (isNode(type_pn,"interface_declaration")) {
 116           // TODO add version for normal Java later
 117           ClassDescriptor cn = parseInterfaceDecl(type_pn);
 118           if (toanalyze!=null)
 119             toanalyze.add(cn);
 120           state.addClass(cn);
 121
 122           // for enum
 123           Iterator it_enums = cn.getEnum();
 124           while(it_enums.hasNext()) {
 125             ClassDescriptor ecd = (ClassDescriptor)it_enums.next();
 126             if(toanalyze != null) {
 127               toanalyze.add(ecd);
 128             }
 129             state.addClass(ecd);
 130           }
 131         } else if (isNode(type_pn,"enum_declaration")) {
 132           // TODO add version for normal Java later
 133           ClassDescriptor cn = parseEnumDecl(null, type_pn);
 134           if (toanalyze!=null)
 135             toanalyze.add(cn);
 136           state.addClass(cn);
 137         } else {
 138           throw new Error(type_pn.getLabel());
 139         }
 140       }
 141     }
 142   }
 143
 144 public void parseInitializers(ClassDescriptor cn){
 145   Vector fv=cn.getFieldVec();
 146     int pos = 0;
 147   for(int i=0;i<fv.size();i++) {
 148       FieldDescriptor fd=(FieldDescriptor)fv.get(i);
 149       if(fd.getExpressionNode()!=null) {
 150          Iterator methodit = cn.getMethods();
 151           while(methodit.hasNext()){
 152             MethodDescriptor currmd=(MethodDescriptor)methodit.next();
 153             if(currmd.isConstructor()){
 154               BlockNode bn=state.getMethodBody(currmd);
 155           NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
 156           AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
 157           bn.addBlockStatementAt(new BlockExpressionNode(an), pos);
 158             }
 159           }
 160           pos++;
 161       }
 162   }
 163     }
 164
 165   private ClassDescriptor parseEnumDecl(ClassDescriptor cn, ParseNode pn) {
 166     ClassDescriptor ecd=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
 167     ecd.setAsEnum();
 168     if(cn != null) {
 169       ecd.setSurroundingClass(cn.getSymbol());
 170       ecd.setSurrounding(cn);
 171       cn.addEnum(ecd);
 172     }
 173     if (!(ecd.getSymbol().equals(TypeUtil.ObjectClass)||
 174         ecd.getSymbol().equals(TypeUtil.TagClass))) {
 175       ecd.setSuper(TypeUtil.ObjectClass);
 176     }
 177     ecd.setModifiers(parseModifiersList(pn.getChild("modifiers")));
 178     parseEnumBody(ecd, pn.getChild("enumbody"));
 179     return ecd;
 180   }
 181
 182   private void parseEnumBody(ClassDescriptor cn, ParseNode pn) {
 183     ParseNode decls=pn.getChild("enum_constants_list");
 184     if (decls!=null) {
 185       ParseNodeVector pnv=decls.getChildren();
 186       for(int i=0; i<pnv.size(); i++) {
 187         ParseNode decl=pnv.elementAt(i);
 188         if (isNode(decl,"enum_constant")) {
 189           parseEnumConstant(cn,decl);
 190         } else throw new Error();
 191       }
 192     }
 193   }
 194
 195   private void parseEnumConstant(ClassDescriptor cn, ParseNode pn) {
 196     cn.addEnumConstant(pn.getChild("name").getTerminal());
 197   }
 198
 199   public ClassDescriptor parseInterfaceDecl(ParseNode pn) {
 200     ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal(), true);
 201     //cn.setAsInterface();
 202     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
 203       /* parse inherited interface name */
 204       ParseNode snlist=pn.getChild("superIF").getChild("extend_interface_list");
 205       ParseNodeVector pnv=snlist.getChildren();
 206       for(int i=0; i<pnv.size(); i++) {
 207         ParseNode decl=pnv.elementAt(i);
 208         if (isNode(decl,"type")) {
 209           NameDescriptor nd=parseName(decl.getChild("class").getChild("name"));
 210           cn.addSuperInterface(nd.toString());
 211         }
 212       }
 213     }
 214     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
 215     parseInterfaceBody(cn, pn.getChild("interfacebody"));
 216     return cn;
 217   }
 218
 219   private void parseInterfaceBody(ClassDescriptor cn, ParseNode pn) {
 220     assert(cn.isInterface());
 221     ParseNode decls=pn.getChild("interface_member_declaration_list");
 222     if (decls!=null) {
 223       ParseNodeVector pnv=decls.getChildren();
 224       for(int i=0; i<pnv.size(); i++) {
 225         ParseNode decl=pnv.elementAt(i);
 226         if (isNode(decl,"constant")) {
 227           parseInterfaceConstant(cn,decl);
 228         } else if (isNode(decl,"method")) {
 229           parseInterfaceMethod(cn,decl.getChild("method_declaration"));
 230         } else throw new Error();
 231       }
 232     }
 233   }
 234
 235   private void parseInterfaceConstant(ClassDescriptor cn, ParseNode pn) {
 236     if (pn!=null) {
 237       parseFieldDecl(cn,pn.getChild("field_declaration"));
 238       return;
 239     }
 240     throw new Error();
 241   }
 242
 243   private void parseInterfaceMethod(ClassDescriptor cn, ParseNode pn) {
 244     ParseNode headern=pn.getChild("header");
 245     ParseNode bodyn=pn.getChild("body");
 246     MethodDescriptor md=parseMethodHeader(headern.getChild("method_header"));
 247     md.getModifiers().addModifier(Modifiers.PUBLIC);
 248     md.getModifiers().addModifier(Modifiers.ABSTRACT);
 249     try {
 250       BlockNode bn=parseBlock(bodyn);
 251       cn.addMethod(md);
 252       state.addTreeCode(md,bn);
 253
 254       // this is a hack for investigating new language features
 255       // at the AST level, someday should evolve into a nice compiler
 256       // option *wink*
 257       //if( cn.getSymbol().equals( ***put a class in here like:     "Test" ) &&
 258       //    md.getSymbol().equals( ***put your method in here like: "main" )
 259       //) {
 260       //  bn.setStyle( BlockNode.NORMAL );
 261       //  System.out.println( bn.printNode( 0 ) );
 262       //}
 263
 264     } catch (Exception e) {
 265       System.out.println("Error with method:"+md.getSymbol());
 266       e.printStackTrace();
 267       throw new Error();
 268     } catch (Error e) {
 269       System.out.println("Error with method:"+md.getSymbol());
 270       e.printStackTrace();
 271       throw new Error();
 272     }
 273   }
 274
 275   public TaskDescriptor parseTaskDecl(ParseNode pn) {
 276     TaskDescriptor td=new TaskDescriptor(pn.getChild("name").getTerminal());
 277     ParseNode bodyn=pn.getChild("body");
 278     BlockNode bn=parseBlock(bodyn);
 279     parseParameterList(td, pn);
 280     state.addTreeCode(td,bn);
 281     if (pn.getChild("flag_effects_list")!=null)
 282       td.addFlagEffects(parseFlags(pn.getChild("flag_effects_list")));
 283     return td;
 284   }
 285
 286   public Vector parseFlags(ParseNode pn) {
 287     Vector vfe=new Vector();
 288     ParseNodeVector pnv=pn.getChildren();
 289     for(int i=0; i<pnv.size(); i++) {
 290       ParseNode fn=pnv.elementAt(i);
 291       FlagEffects fe=parseFlagEffects(fn);
 292       vfe.add(fe);
 293     }
 294     return vfe;
 295   }
 296
 297   public FlagEffects parseFlagEffects(ParseNode pn) {
 298     if (isNode(pn,"flag_effect")) {
 299       String flagname=pn.getChild("name").getTerminal();
 300       FlagEffects fe=new FlagEffects(flagname);
 301       if (pn.getChild("flag_list")!=null)
 302         parseFlagEffect(fe, pn.getChild("flag_list"));
 303       if (pn.getChild("tag_list")!=null)
 304         parseTagEffect(fe, pn.getChild("tag_list"));
 305       return fe;
 306     } else throw new Error();
 307   }
 308
 309   public void parseTagEffect(FlagEffects fes, ParseNode pn) {
 310     ParseNodeVector pnv=pn.getChildren();
 311     for(int i=0; i<pnv.size(); i++) {
 312       ParseNode pn2=pnv.elementAt(i);
 313       boolean status=true;
 314       if (isNode(pn2,"not")) {
 315         status=false;
 316         pn2=pn2.getChild("name");
 317       }
 318       String name=pn2.getTerminal();
 319       fes.addTagEffect(new TagEffect(name,status));
 320     }
 321   }
 322
 323   public void parseFlagEffect(FlagEffects fes, ParseNode pn) {
 324     ParseNodeVector pnv=pn.getChildren();
 325     for(int i=0; i<pnv.size(); i++) {
 326       ParseNode pn2=pnv.elementAt(i);
 327       boolean status=true;
 328       if (isNode(pn2,"not")) {
 329         status=false;
 330         pn2=pn2.getChild("name");
 331       }
 332       String name=pn2.getTerminal();
 333       fes.addEffect(new FlagEffect(name,status));
 334     }
 335   }
 336
 337   public FlagExpressionNode parseFlagExpression(ParseNode pn) {
 338     if (isNode(pn,"or")) {
 339       ParseNodeVector pnv=pn.getChildren();
 340       ParseNode left=pnv.elementAt(0);
 341       ParseNode right=pnv.elementAt(1);
 342       return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_OR));
 343     } else if (isNode(pn,"and")) {
 344       ParseNodeVector pnv=pn.getChildren();
 345       ParseNode left=pnv.elementAt(0);
 346       ParseNode right=pnv.elementAt(1);
 347       return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_AND));
 348     } else if (isNode(pn, "not")) {
 349       ParseNodeVector pnv=pn.getChildren();
 350       ParseNode left=pnv.elementAt(0);
 351       return new FlagOpNode(parseFlagExpression(left), new Operation(Operation.LOGIC_NOT));
 352
 353     } else if (isNode(pn,"name")) {
 354       return new FlagNode(pn.getTerminal());
 355     } else {
 356       throw new Error();
 357     }
 358   }
 359
 360   public Vector parseChecks(ParseNode pn) {
 361     Vector ccs=new Vector();
 362     ParseNodeVector pnv=pn.getChildren();
 363     for(int i=0; i<pnv.size(); i++) {
 364       ParseNode fn=pnv.elementAt(i);
 365       ConstraintCheck cc=parseConstraintCheck(fn);
 366       ccs.add(cc);
 367     }
 368     return ccs;
 369   }
 370
 371   public ConstraintCheck parseConstraintCheck(ParseNode pn) {
 372     if (isNode(pn,"cons_check")) {
 373       String specname=pn.getChild("name").getChild("identifier").getTerminal();
 374       Vector[] args=parseConsArgumentList(pn);
 375       ConstraintCheck cc=new ConstraintCheck(specname);
 376       for(int i=0; i<args[0].size(); i++) {
 377         cc.addVariable((String)args[0].get(i));
 378         cc.addArgument((ExpressionNode)args[1].get(i));
 379       }
 380       return cc;
 381     } else throw new Error();
 382   }
 383
 384   public void parseParameterList(TaskDescriptor td, ParseNode pn) {
 385
 386     boolean optional;
 387     ParseNode paramlist=pn.getChild("task_parameter_list");
 388     if (paramlist==null)
 389       return;
 390     ParseNodeVector pnv=paramlist.getChildren();
 391     for(int i=0; i<pnv.size(); i++) {
 392       ParseNode paramn=pnv.elementAt(i);
 393       if(paramn.getChild("optional")!=null) {
 394         optional = true;
 395         paramn = paramn.getChild("optional").getFirstChild();
 396         System.out.println("OPTIONAL FOUND!!!!!!!");
 397       } else { optional = false;
 398                System.out.println("NOT OPTIONAL");}
 399
 400       TypeDescriptor type=parseTypeDescriptor(paramn);
 401
 402       String paramname=paramn.getChild("single").getTerminal();
 403       FlagExpressionNode fen=null;
 404       if (paramn.getChild("flag")!=null)
 405         fen=parseFlagExpression(paramn.getChild("flag").getFirstChild());
 406
 407       ParseNode tagnode=paramn.getChild("tag");
 408
 409       TagExpressionList tel=null;
 410       if (tagnode!=null) {
 411         tel=parseTagExpressionList(tagnode);
 412       }
 413
 414       td.addParameter(type,paramname,fen, tel, optional);
 415     }
 416   }
 417
 418   public TagExpressionList parseTagExpressionList(ParseNode pn) {
 419     //BUG FIX: change pn.getChildren() to pn.getChild("tag_expression_list").getChildren()
 420     //To test, feed in any input program that uses tags
 421     ParseNodeVector pnv=pn.getChild("tag_expression_list").getChildren();
 422     TagExpressionList tel=new TagExpressionList();
 423     for(int i=0; i<pnv.size(); i++) {
 424       ParseNode tn=pnv.elementAt(i);
 425       String type=tn.getChild("type").getTerminal();
 426       String name=tn.getChild("single").getTerminal();
 427       tel.addTag(type, name);
 428     }
 429     return tel;
 430   }
 431
 432   public ClassDescriptor parseTypeDecl(ParseNode pn) {
 433     ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
 434     if (!isEmpty(pn.getChild("super").getTerminal())) {
 435       /* parse superclass name */
 436       ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name");
 437       NameDescriptor nd=parseName(snn);
 438       cn.setSuper(nd.toString());
 439     } else {
 440       if (!(cn.getSymbol().equals(TypeUtil.ObjectClass)||
 441             cn.getSymbol().equals(TypeUtil.TagClass)))
 442         cn.setSuper(TypeUtil.ObjectClass);
 443     }
 444     // check inherited interfaces
 445     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
 446       /* parse inherited interface name */
 447       ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
 448       ParseNodeVector pnv=snlist.getChildren();
 449       for(int i=0; i<pnv.size(); i++) {
 450         ParseNode decl=pnv.elementAt(i);
 451         if (isNode(decl,"type")) {
 452           NameDescriptor nd=parseName(decl.getChild("class").getChild("name"));
 453           cn.addSuperInterface(nd.toString());
 454         }
 455       }
 456     }
 457     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
 458     parseClassBody(cn, pn.getChild("classbody"));
 459
 460     boolean hasConstructor = false;
 461     for(Iterator method_it=cn.getMethods(); method_it.hasNext();) {
 462       MethodDescriptor md=(MethodDescriptor)method_it.next();
 463       hasConstructor |= md.isConstructor();
 464     }
 465     if((!hasConstructor) && (!cn.isEnum())) {
 466       // add a default constructor for this class
 467       MethodDescriptor md = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC),
 468           cn.getSymbol(), false);
 469       BlockNode bn=new BlockNode();
 470       state.addTreeCode(md,bn);
 471       md.setDefaultConstructor();
 472       cn.addMethod(md);
 473     }
 474     return cn;
 475   }
 476
 477   private void parseClassBody(ClassDescriptor cn, ParseNode pn) {
 478     ParseNode decls=pn.getChild("class_body_declaration_list");
 479     if (decls!=null) {
 480       ParseNodeVector pnv=decls.getChildren();
 481       for(int i=0; i<pnv.size(); i++) {
 482         ParseNode decl=pnv.elementAt(i);
 483         if (isNode(decl,"member")) {
 484           parseClassMember(cn,decl);
 485         } else if (isNode(decl,"constructor")) {
 486           parseConstructorDecl(cn,decl.getChild("constructor_declaration"));
 487         } else if (isNode(decl, "static_block")) {
 488           parseStaticBlockDecl(cn, decl.getChild("static_block_declaration"));
 489         } else if (isNode(decl,"block")) {
 490         } else if (isNode(decl,"location_order_declaration")) {
 491           parseLocationOrder(cn,decl.getChild("location_order_list"));
 492   } else throw new Error();
 493       }
 494     }
 495   }
 496
 497   private void parseLocationOrder(ClassDescriptor cd, ParseNode pn) {
 498     ParseNodeVector pnv = pn.getChildren();
 499     Lattice<String> locOrder =
 500         new Lattice<String>("_top_","_bottom_");
 501     for (int i = 0; i < pnv.size(); i++) {
 502       ParseNode loc = pnv.elementAt(i);
 503       String lowerLoc=loc.getChildren().elementAt(0).getLabel();
 504       String higherLoc= loc.getChildren().elementAt(1).getLabel();
 505       locOrder.put(higherLoc, lowerLoc);
 506       if (locOrder.isIntroducingCycle(higherLoc)) {
 507         throw new Error("Error: the order relation " + lowerLoc + " < " + higherLoc
 508             + " introduces a cycle.");
 509       }
 510     }
 511     state.addLocationOrder(cd, locOrder);
 512   }
 513
 514   private void parseClassMember(ClassDescriptor cn, ParseNode pn) {
 515     ParseNode fieldnode=pn.getChild("field");
 516     if (fieldnode!=null) {
 517       parseFieldDecl(cn,fieldnode.getChild("field_declaration"));
 518       return;
 519     }
 520     ParseNode methodnode=pn.getChild("method");
 521     if (methodnode!=null) {
 522       parseMethodDecl(cn,methodnode.getChild("method_declaration"));
 523       return;
 524     }
 525     ParseNode innerclassnode=pn.getChild("inner_class_declaration");
 526     if (innerclassnode!=null) {
 527       parseInnerClassDecl(cn,innerclassnode);
 528       return;
 529     }
 530     ParseNode enumnode=pn.getChild("enum_declaration");
 531     if (enumnode!=null) {
 532       parseEnumDecl(cn,enumnode);
 533       return;
 534     }
 535     ParseNode flagnode=pn.getChild("flag");
 536     if (flagnode!=null) {
 537       parseFlagDecl(cn, flagnode.getChild("flag_declaration"));
 538       return;
 539     }
 540     // in case there are empty node
 541     ParseNode emptynode=pn.getChild("empty");
 542     if(emptynode != null) {
 543       return;
 544     }
 545     throw new Error();
 546   }
 547
 548   private ClassDescriptor parseInnerClassDecl(ClassDescriptor cn, ParseNode pn) {
 549     ClassDescriptor icn=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
 550     icn.setAsInnerClass();
 551     icn.setSurroundingClass(cn.getSymbol());
 552     icn.setSurrounding(cn);
 553     cn.addInnerClass(icn);
 554     if (!isEmpty(pn.getChild("super").getTerminal())) {
 555       /* parse superclass name */
 556       ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name");
 557       NameDescriptor nd=parseName(snn);
 558       icn.setSuper(nd.toString());
 559     } else {
 560       if (!(icn.getSymbol().equals(TypeUtil.ObjectClass)||
 561           icn.getSymbol().equals(TypeUtil.TagClass)))
 562         icn.setSuper(TypeUtil.ObjectClass);
 563     }
 564     // check inherited interfaces
 565     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
 566       /* parse inherited interface name */
 567       ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
 568       ParseNodeVector pnv=snlist.getChildren();
 569       for(int i=0; i<pnv.size(); i++) {
 570         ParseNode decl=pnv.elementAt(i);
 571         if (isNode(decl,"type")) {
 572           NameDescriptor nd=parseName(decl.getChild("class").getChild("name"));
 573           icn.addSuperInterface(nd.toString());
 574         }
 575       }
 576     }
 577     icn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
 578     if(!icn.isStatic()) {
 579       throw new Error("Error: inner class " + icn.getSymbol() + " in Class " +
 580           cn.getSymbol() + " is not a nested class and is not supported yet!");
 581     }
 582     parseClassBody(icn, pn.getChild("classbody"));
 583     return icn;
 584   }
 585
 586   private TypeDescriptor parseTypeDescriptor(ParseNode pn) {
 587     ParseNode tn=pn.getChild("type");
 588     String type_st=tn.getTerminal();
 589     if(type_st.equals("byte")) {
 590       return state.getTypeDescriptor(TypeDescriptor.BYTE);
 591     } else if(type_st.equals("short")) {
 592       return state.getTypeDescriptor(TypeDescriptor.SHORT);
 593     } else if(type_st.equals("boolean")) {
 594       return state.getTypeDescriptor(TypeDescriptor.BOOLEAN);
 595     } else if(type_st.equals("int")) {
 596       return state.getTypeDescriptor(TypeDescriptor.INT);
 597     } else if(type_st.equals("long")) {
 598       return state.getTypeDescriptor(TypeDescriptor.LONG);
 599     } else if(type_st.equals("char")) {
 600       return state.getTypeDescriptor(TypeDescriptor.CHAR);
 601     } else if(type_st.equals("float")) {
 602       return state.getTypeDescriptor(TypeDescriptor.FLOAT);
 603     } else if(type_st.equals("double")) {
 604       return state.getTypeDescriptor(TypeDescriptor.DOUBLE);
 605     } else if(type_st.equals("class")) {
 606       ParseNode nn=tn.getChild("class");
 607       return state.getTypeDescriptor(parseName(nn.getChild("name")));
 608     } else if(type_st.equals("array")) {
 609       ParseNode nn=tn.getChild("array");
 610       TypeDescriptor td=parseTypeDescriptor(nn.getChild("basetype"));
 611       Integer numdims=(Integer)nn.getChild("dims").getLiteral();
 612       for(int i=0; i<numdims.intValue(); i++)
 613         td=td.makeArray(state);
 614       return td;
 615     } else {
 616       System.out.println(pn.PPrint(2, true));
 617       throw new Error();
 618     }
 619   }
 620
 621   private NameDescriptor parseName(ParseNode nn) {
 622     ParseNode base=nn.getChild("base");
 623     ParseNode id=nn.getChild("identifier");
 624     if (base==null)
 625       return new NameDescriptor(id.getTerminal());
 626     return new NameDescriptor(parseName(base.getChild("name")),id.getTerminal());
 627
 628   }
 629
 630   private void parseFlagDecl(ClassDescriptor cn,ParseNode pn) {
 631     String name=pn.getChild("name").getTerminal();
 632     FlagDescriptor flag=new FlagDescriptor(name);
 633     if (pn.getChild("external")!=null)
 634       flag.makeExternal();
 635     cn.addFlag(flag);
 636   }
 637
 638   private void parseFieldDecl(ClassDescriptor cn,ParseNode pn) {
 639     ParseNode mn=pn.getChild("modifier");
 640     Modifiers m=parseModifiersList(mn);
 641     if(cn.isInterface()) {
 642       // TODO add version for normal Java later
 643       // Can only be PUBLIC or STATIC or FINAL
 644       if((m.isAbstract()) || (m.isAtomic()) || (m.isNative())
 645           || (m.isSynchronized())) {
 646         throw new Error("Error: field in Interface " + cn.getSymbol() + "can only be PUBLIC or STATIC or FINAL");
 647       }
 648       m.addModifier(Modifiers.PUBLIC);
 649       m.addModifier(Modifiers.STATIC);
 650       m.addModifier(Modifiers.FINAL);
 651     }
 652
 653     ParseNode tn=pn.getChild("type");
 654     TypeDescriptor t=parseTypeDescriptor(tn);
 655     assignAnnotationsToType(m,t);
 656     ParseNode vn=pn.getChild("variables").getChild("variable_declarators_list");
 657     ParseNodeVector pnv=vn.getChildren();
 658     boolean isglobal=pn.getChild("global")!=null;
 659
 660     for(int i=0; i<pnv.size(); i++) {
 661       ParseNode vardecl=pnv.elementAt(i);
 662       ParseNode tmp=vardecl;
 663       TypeDescriptor arrayt=t;
 664       while (tmp.getChild("single")==null) {
 665         arrayt=arrayt.makeArray(state);
 666         tmp=tmp.getChild("array");
 667       }
 668       String identifier=tmp.getChild("single").getTerminal();
 669       ParseNode epn=vardecl.getChild("initializer");
 670
 671       ExpressionNode en=null;
 672       if (epn!=null) {
 673         en=parseExpression(epn.getFirstChild());
 674         if(m.isStatic()) {
 675           // for static field, the initializer should be considered as a
 676           // static block
 677           boolean isfirst = false;
 678           MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
 679           if(md == null) {
 680             // the first static block for this class
 681             Modifiers m_i=new Modifiers();
 682             m_i.addModifier(Modifiers.STATIC);
 683             md = new MethodDescriptor(m_i, "staticblocks", false);
 684             md.setAsStaticBlock();
 685             isfirst = true;
 686           }
 687           if(isfirst) {
 688             cn.addMethod(md);
 689           }
 690           cn.incStaticBlocks();
 691           BlockNode bn=new BlockNode();
 692           NameNode nn=new NameNode(new NameDescriptor(identifier));
 693           AssignmentNode an=new AssignmentNode(nn,en,new AssignOperation(1));
 694           bn.addBlockStatement(new BlockExpressionNode(an));
 695           if(isfirst) {
 696             state.addTreeCode(md,bn);
 697           } else {
 698             BlockNode obn = state.getMethodBody(md);
 699             for(int ii = 0; ii < bn.size(); ii++) {
 700               BlockStatementNode bsn = bn.get(ii);
 701               obn.addBlockStatement(bsn);
 702             }
 703             state.addTreeCode(md, obn);
 704             bn = null;
 705           }
 706           en = null;
 707         }
 708       }
 709
 710       cn.addField(new FieldDescriptor(m, arrayt, identifier, en, isglobal));
 711     }
 712   }
 713
 714   private void assignAnnotationsToType(Modifiers modifiers, TypeDescriptor type){
 715     Vector<AnnotationDescriptor> annotations=modifiers.getAnnotations();
 716     for(int i=0; i<annotations.size(); i++) {
 717       // it only supports a marker annotation
 718       AnnotationDescriptor an=annotations.elementAt(i);
 719       type.addAnnotationMarker(an);
 720     }
 721   }
 722
 723   private ExpressionNode parseExpression(ParseNode pn) {
 724     if (isNode(pn,"assignment"))
 725       return parseAssignmentExpression(pn);
 726     else if (isNode(pn,"logical_or")||isNode(pn,"logical_and")||
 727              isNode(pn,"bitwise_or")||isNode(pn,"bitwise_xor")||
 728              isNode(pn,"bitwise_and")||isNode(pn,"equal")||
 729              isNode(pn,"not_equal")||isNode(pn,"comp_lt")||
 730              isNode(pn,"comp_lte")||isNode(pn,"comp_gt")||
 731              isNode(pn,"comp_gte")||isNode(pn,"leftshift")||
 732              isNode(pn,"rightshift")||isNode(pn,"sub")||
 733              isNode(pn,"urightshift")||isNode(pn,"sub")||
 734              isNode(pn,"add")||isNode(pn,"mult")||
 735              isNode(pn,"div")||isNode(pn,"mod")) {
 736       ParseNodeVector pnv=pn.getChildren();
 737       ParseNode left=pnv.elementAt(0);
 738       ParseNode right=pnv.elementAt(1);
 739       Operation op=new Operation(pn.getLabel());
 740       return new OpNode(parseExpression(left),parseExpression(right),op);
 741     } else if (isNode(pn,"unaryplus")||
 742                isNode(pn,"unaryminus")||
 743                isNode(pn,"not")||
 744                isNode(pn,"comp")) {
 745       ParseNode left=pn.getFirstChild();
 746       Operation op=new Operation(pn.getLabel());
 747       return new OpNode(parseExpression(left),op);
 748     } else if (isNode(pn,"postinc")||
 749                isNode(pn,"postdec")) {
 750       ParseNode left=pn.getFirstChild();
 751       AssignOperation op=new AssignOperation(pn.getLabel());
 752       return new AssignmentNode(parseExpression(left),null,op);
 753
 754     } else if (isNode(pn,"preinc")||
 755                isNode(pn,"predec")) {
 756       ParseNode left=pn.getFirstChild();
 757       AssignOperation op=isNode(pn,"preinc") ? new AssignOperation(AssignOperation.PLUSEQ) : new AssignOperation(AssignOperation.MINUSEQ);
 758       return new AssignmentNode(parseExpression(left),
 759                                 new LiteralNode("integer",new Integer(1)),op);
 760     } else if (isNode(pn,"literal")) {
 761       String literaltype=pn.getTerminal();
 762       ParseNode literalnode=pn.getChild(literaltype);
 763       Object literal_obj=literalnode.getLiteral();
 764       return new LiteralNode(literaltype, literal_obj);
 765     } else if (isNode(pn,"createobject")) {
 766       TypeDescriptor td=parseTypeDescriptor(pn);
 767
 768       Vector args=parseArgumentList(pn);
 769       boolean isglobal=pn.getChild("global")!=null||
 770         pn.getChild("scratch")!=null;
 771       String disjointId=null;
 772       if( pn.getChild("disjoint") != null) {
 773         disjointId = pn.getChild("disjoint").getTerminal();
 774       }
 775       CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
 776       for(int i=0; i<args.size(); i++) {
 777         con.addArgument((ExpressionNode)args.get(i));
 778       }
 779       /* Could have flag set or tag added here */
 780       if (pn.getChild("flag_list")!=null||pn.getChild("tag_list")!=null) {
 781         FlagEffects fe=new FlagEffects(null);
 782         if (pn.getChild("flag_list")!=null)
 783           parseFlagEffect(fe, pn.getChild("flag_list"));
 784
 785         if (pn.getChild("tag_list")!=null)
 786           parseTagEffect(fe, pn.getChild("tag_list"));
 787         con.addFlagEffects(fe);
 788       }
 789
 790       return con;
 791     } else if (isNode(pn,"createarray")) {
 792       //System.out.println(pn.PPrint(3,true));
 793       boolean isglobal=pn.getChild("global")!=null||
 794         pn.getChild("scratch")!=null;
 795       String disjointId=null;
 796       if( pn.getChild("disjoint") != null) {
 797         disjointId = pn.getChild("disjoint").getTerminal();
 798       }
 799       TypeDescriptor td=parseTypeDescriptor(pn);
 800       Vector args=parseDimExprs(pn);
 801       int num=0;
 802       if (pn.getChild("dims_opt").getLiteral()!=null)
 803         num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
 804       for(int i=0; i<(args.size()+num); i++)
 805         td=td.makeArray(state);
 806       CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
 807       for(int i=0; i<args.size(); i++) {
 808         con.addArgument((ExpressionNode)args.get(i));
 809       }
 810       return con;
 811     } if (isNode(pn,"createarray2")) {
 812       TypeDescriptor td=parseTypeDescriptor(pn);
 813       int num=0;
 814       if (pn.getChild("dims_opt").getLiteral()!=null)
 815     num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
 816       for(int i=0; i<num; i++)
 817     td=td.makeArray(state);
 818       CreateObjectNode con=new CreateObjectNode(td, false, null);
 819       ParseNode ipn = pn.getChild("initializer");
 820       Vector initializers=parseVariableInitializerList(ipn);
 821       ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
 822       con.addArrayInitializer(ain);
 823       return con;
 824     } else if (isNode(pn,"name")) {
 825       NameDescriptor nd=parseName(pn);
 826       return new NameNode(nd);
 827     } else if (isNode(pn,"this")) {
 828       NameDescriptor nd=new NameDescriptor("this");
 829       return new NameNode(nd);
 830     } else if (isNode(pn,"isavailable")) {
 831       NameDescriptor nd=new NameDescriptor(pn.getTerminal());
 832       return new OpNode(new NameNode(nd),null,new Operation(Operation.ISAVAILABLE));
 833     } else if (isNode(pn,"methodinvoke1")) {
 834       NameDescriptor nd=parseName(pn.getChild("name"));
 835       Vector args=parseArgumentList(pn);
 836       MethodInvokeNode min=new MethodInvokeNode(nd);
 837       for(int i=0; i<args.size(); i++) {
 838         min.addArgument((ExpressionNode)args.get(i));
 839       }
 840       return min;
 841     } else if (isNode(pn,"methodinvoke2")) {
 842       String methodid=pn.getChild("id").getTerminal();
 843       ExpressionNode exp=parseExpression(pn.getChild("base").getFirstChild());
 844       Vector args=parseArgumentList(pn);
 845       MethodInvokeNode min=new MethodInvokeNode(methodid,exp);
 846       for(int i=0; i<args.size(); i++) {
 847         min.addArgument((ExpressionNode)args.get(i));
 848       }
 849       return min;
 850     } else if (isNode(pn,"fieldaccess")) {
 851       ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
 852       String fieldname=pn.getChild("field").getTerminal();
 853       return new FieldAccessNode(en,fieldname);
 854     } else if (isNode(pn,"arrayaccess")) {
 855       ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
 856       ExpressionNode index=parseExpression(pn.getChild("index").getFirstChild());
 857       return new ArrayAccessNode(en,index);
 858     } else if (isNode(pn,"cast1")) {
 859       try {
 860         return new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
 861       } catch (Exception e) {
 862         System.out.println(pn.PPrint(1,true));
 863         e.printStackTrace();
 864         throw new Error();
 865       }
 866     } else if (isNode(pn,"cast2")) {
 867       return new CastNode(parseExpression(pn.getChild("type").getFirstChild()),parseExpression(pn.getChild("exp").getFirstChild()));
 868     } else if (isNode(pn, "getoffset")) {
 869       TypeDescriptor td=parseTypeDescriptor(pn);
 870       String fieldname = pn.getChild("field").getTerminal();
 871       //System.out.println("Checking the values of: "+ " td.toString()= " + td.toString()+ "  fieldname= " + fieldname);
 872       return new OffsetNode(td, fieldname);
 873     } else if (isNode(pn, "tert")) {
 874       return new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
 875                               parseExpression(pn.getChild("trueexpr").getFirstChild()),
 876                               parseExpression(pn.getChild("falseexpr").getFirstChild()) );
 877     } else if (isNode(pn, "instanceof")) {
 878       ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
 879       TypeDescriptor t=parseTypeDescriptor(pn);
 880       return new InstanceOfNode(exp,t);
 881     } else if (isNode(pn, "array_initializer")) {
 882       Vector initializers=parseVariableInitializerList(pn);
 883       return new ArrayInitializerNode(initializers);
 884     } else if (isNode(pn, "class_type")) {
 885       TypeDescriptor td=parseTypeDescriptor(pn);
 886       return new ClassTypeNode(td);
 887     } else if (isNode(pn, "empty")) {
 888       return null;
 889     } else {
 890       System.out.println("---------------------");
 891       System.out.println(pn.PPrint(3,true));
 892       throw new Error();
 893     }
 894   }
 895
 896   private Vector parseDimExprs(ParseNode pn) {
 897     Vector arglist=new Vector();
 898     ParseNode an=pn.getChild("dim_exprs");
 899     if (an==null)       /* No argument list */
 900       return arglist;
 901     ParseNodeVector anv=an.getChildren();
 902     for(int i=0; i<anv.size(); i++) {
 903       arglist.add(parseExpression(anv.elementAt(i)));
 904     }
 905     return arglist;
 906   }
 907
 908   private Vector parseArgumentList(ParseNode pn) {
 909     Vector arglist=new Vector();
 910     ParseNode an=pn.getChild("argument_list");
 911     if (an==null)       /* No argument list */
 912       return arglist;
 913     ParseNodeVector anv=an.getChildren();
 914     for(int i=0; i<anv.size(); i++) {
 915       arglist.add(parseExpression(anv.elementAt(i)));
 916     }
 917     return arglist;
 918   }
 919
 920   private Vector[] parseConsArgumentList(ParseNode pn) {
 921     Vector arglist=new Vector();
 922     Vector varlist=new Vector();
 923     ParseNode an=pn.getChild("cons_argument_list");
 924     if (an==null)       /* No argument list */
 925       return new Vector[] {varlist, arglist};
 926     ParseNodeVector anv=an.getChildren();
 927     for(int i=0; i<anv.size(); i++) {
 928       ParseNode cpn=anv.elementAt(i);
 929       ParseNode var=cpn.getChild("var");
 930       ParseNode exp=cpn.getChild("exp").getFirstChild();
 931       varlist.add(var.getTerminal());
 932       arglist.add(parseExpression(exp));
 933     }
 934     return new Vector[] {varlist, arglist};
 935   }
 936
 937   private Vector parseVariableInitializerList(ParseNode pn) {
 938     Vector varInitList=new Vector();
 939     ParseNode vin=pn.getChild("var_init_list");
 940     if (vin==null)       /* No argument list */
 941       return varInitList;
 942     ParseNodeVector vinv=vin.getChildren();
 943     for(int i=0; i<vinv.size(); i++) {
 944       varInitList.add(parseExpression(vinv.elementAt(i)));
 945     }
 946     return varInitList;
 947   }
 948
 949   private ExpressionNode parseAssignmentExpression(ParseNode pn) {
 950     AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
 951     ParseNodeVector pnv=pn.getChild("args").getChildren();
 952
 953     AssignmentNode an=new AssignmentNode(parseExpression(pnv.elementAt(0)),parseExpression(pnv.elementAt(1)),ao);
 954     return an;
 955   }
 956
 957
 958   private void parseMethodDecl(ClassDescriptor cn, ParseNode pn) {
 959     ParseNode headern=pn.getChild("method_header");
 960     ParseNode bodyn=pn.getChild("body");
 961     MethodDescriptor md=parseMethodHeader(headern);
 962     try {
 963       BlockNode bn=parseBlock(bodyn);
 964       cn.addMethod(md);
 965       state.addTreeCode(md,bn);
 966
 967       // this is a hack for investigating new language features
 968       // at the AST level, someday should evolve into a nice compiler
 969       // option *wink*
 970       //if( cn.getSymbol().equals( ***put a class in here like:     "Test" ) &&
 971       //    md.getSymbol().equals( ***put your method in here like: "main" )
 972       //) {
 973       //  bn.setStyle( BlockNode.NORMAL );
 974       //  System.out.println( bn.printNode( 0 ) );
 975       //}
 976
 977     } catch (Exception e) {
 978       System.out.println("Error with method:"+md.getSymbol());
 979       e.printStackTrace();
 980       throw new Error();
 981     } catch (Error e) {
 982       System.out.println("Error with method:"+md.getSymbol());
 983       e.printStackTrace();
 984       throw new Error();
 985     }
 986   }
 987
 988   private void parseConstructorDecl(ClassDescriptor cn, ParseNode pn) {
 989     ParseNode mn=pn.getChild("modifiers");
 990     Modifiers m=parseModifiersList(mn);
 991     ParseNode cdecl=pn.getChild("constructor_declarator");
 992     boolean isglobal=cdecl.getChild("global")!=null;
 993     String name=cdecl.getChild("name").getChild("identifier").getTerminal();
 994     MethodDescriptor md=new MethodDescriptor(m, name, isglobal);
 995     ParseNode paramnode=cdecl.getChild("parameters");
 996     parseParameterList(md,paramnode);
 997     ParseNode bodyn0=pn.getChild("body");
 998     ParseNode bodyn=bodyn0.getChild("constructor_body");
 999     cn.addMethod(md);
1000     BlockNode bn=null;
1001     if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
1002       bn=parseBlock(bodyn);
1003     else
1004       bn=new BlockNode();
1005     if (bodyn!=null&&bodyn.getChild("superinvoke")!=null) {
1006       ParseNode sin=bodyn.getChild("superinvoke");
1007       NameDescriptor nd=new NameDescriptor("super");
1008       Vector args=parseArgumentList(sin);
1009       MethodInvokeNode min=new MethodInvokeNode(nd);
1010       for(int i=0; i<args.size(); i++) {
1011         min.addArgument((ExpressionNode)args.get(i));
1012       }
1013       BlockExpressionNode ben=new BlockExpressionNode(min);
1014       bn.addFirstBlockStatement(ben);
1015
1016     } else if (bodyn!=null&&bodyn.getChild("explconstrinv")!=null) {
1017       ParseNode eci=bodyn.getChild("explconstrinv");
1018       NameDescriptor nd=new NameDescriptor(cn.getSymbol());
1019       Vector args=parseArgumentList(eci);
1020       MethodInvokeNode min=new MethodInvokeNode(nd);
1021       for(int i=0; i<args.size(); i++) {
1022         min.addArgument((ExpressionNode)args.get(i));
1023       }
1024       BlockExpressionNode ben=new BlockExpressionNode(min);
1025       bn.addFirstBlockStatement(ben);
1026     }
1027     state.addTreeCode(md,bn);
1028   }
1029
1030   private void parseStaticBlockDecl(ClassDescriptor cn, ParseNode pn) {
1031     // Each class maintains one MethodDecscriptor which combines all its
1032     // static blocks in their declaration order
1033     boolean isfirst = false;
1034     MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
1035     if(md == null) {
1036       // the first static block for this class
1037       Modifiers m_i=new Modifiers();
1038       m_i.addModifier(Modifiers.STATIC);
1039       md = new MethodDescriptor(m_i, "staticblocks", false);
1040       md.setAsStaticBlock();
1041       isfirst = true;
1042     }
1043     ParseNode bodyn=pn.getChild("body");
1044     if(isfirst) {
1045       cn.addMethod(md);
1046     }
1047     cn.incStaticBlocks();
1048     BlockNode bn=null;
1049     if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
1050       bn=parseBlock(bodyn);
1051     else
1052       bn=new BlockNode();
1053     if(isfirst) {
1054       state.addTreeCode(md,bn);
1055     } else {
1056       BlockNode obn = state.getMethodBody(md);
1057       for(int i = 0; i < bn.size(); i++) {
1058         BlockStatementNode bsn = bn.get(i);
1059         obn.addBlockStatement(bsn);
1060       }
1061       state.addTreeCode(md, obn);
1062       bn = null;
1063     }
1064   }
1065
1066   public BlockNode parseBlock(ParseNode pn) {
1067     this.m_taskexitnum = 0;
1068     if (pn==null||isEmpty(pn.getTerminal()))
1069       return new BlockNode();
1070     ParseNode bsn=pn.getChild("block_statement_list");
1071     return parseBlockHelper(bsn);
1072   }
1073
1074   private BlockNode parseBlockHelper(ParseNode pn) {
1075     ParseNodeVector pnv=pn.getChildren();
1076     BlockNode bn=new BlockNode();
1077     for(int i=0; i<pnv.size(); i++) {
1078       Vector bsv=parseBlockStatement(pnv.elementAt(i));
1079       for(int j=0; j<bsv.size(); j++) {
1080         bn.addBlockStatement((BlockStatementNode)bsv.get(j));
1081       }
1082     }
1083     return bn;
1084   }
1085
1086   public BlockNode parseSingleBlock(ParseNode pn) {
1087     BlockNode bn=new BlockNode();
1088     Vector bsv=parseBlockStatement(pn);
1089     for(int j=0; j<bsv.size(); j++) {
1090       bn.addBlockStatement((BlockStatementNode)bsv.get(j));
1091     }
1092     bn.setStyle(BlockNode.NOBRACES);
1093     return bn;
1094   }
1095
1096   public Vector parseSESEBlock(Vector parentbs, ParseNode pn) {
1097     ParseNodeVector pnv=pn.getChildren();
1098     Vector bv=new Vector();
1099     for(int i=0; i<pnv.size(); i++) {
1100       bv.addAll(parseBlockStatement(pnv.elementAt(i)));
1101     }
1102     return bv;
1103   }
1104
1105   public Vector parseBlockStatement(ParseNode pn) {
1106     Vector blockstatements=new Vector();
1107     if (isNode(pn,"tag_declaration")) {
1108       String name=pn.getChild("single").getTerminal();
1109       String type=pn.getChild("type").getTerminal();
1110
1111       blockstatements.add(new TagDeclarationNode(name, type));
1112     } else if (isNode(pn,"local_variable_declaration")) {
1113
1114       ParseNode mn=pn.getChild("modifiers");
1115       TypeDescriptor t=parseTypeDescriptor(pn);
1116       if(mn!=null){
1117         Modifiers m=parseModifiersList(mn);
1118         assignAnnotationsToType(m, t);
1119       }
1120       ParseNode vn=pn.getChild("variable_declarators_list");
1121       ParseNodeVector pnv=vn.getChildren();
1122       for(int i=0; i<pnv.size(); i++) {
1123         ParseNode vardecl=pnv.elementAt(i);
1124
1125
1126         ParseNode tmp=vardecl;
1127         TypeDescriptor arrayt=t;
1128
1129         while (tmp.getChild("single")==null) {
1130           arrayt=arrayt.makeArray(state);
1131           tmp=tmp.getChild("array");
1132         }
1133         String identifier=tmp.getChild("single").getTerminal();
1134
1135         ParseNode epn=vardecl.getChild("initializer");
1136
1137
1138         ExpressionNode en=null;
1139         if (epn!=null)
1140           en=parseExpression(epn.getFirstChild());
1141
1142         blockstatements.add(new DeclarationNode(new VarDescriptor(arrayt, identifier),en));
1143       }
1144     } else if (isNode(pn,"nop")) {
1145       /* Do Nothing */
1146     } else if (isNode(pn,"expression")) {
1147       blockstatements.add(new BlockExpressionNode(parseExpression(pn.getFirstChild())));
1148     } else if (isNode(pn,"ifstatement")) {
1149       blockstatements.add(new IfStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
1150                                               parseSingleBlock(pn.getChild("statement").getFirstChild()),
1151                                               pn.getChild("else_statement")!=null ? parseSingleBlock(pn.getChild("else_statement").getFirstChild()) : null));
1152     } else if (isNode(pn,"switch_statement")) {
1153       // TODO add version for normal Java later
1154       blockstatements.add(new SwitchStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
1155           parseSingleBlock(pn.getChild("statement").getFirstChild())));
1156     } else if (isNode(pn,"switch_block_list")) {
1157       // TODO add version for normal Java later
1158       ParseNodeVector pnv=pn.getChildren();
1159       for(int i=0; i<pnv.size(); i++) {
1160         ParseNode sblockdecl=pnv.elementAt(i);
1161
1162         if(isNode(sblockdecl, "switch_block")) {
1163           ParseNode lpn=sblockdecl.getChild("switch_labels").getChild("switch_label_list");
1164           ParseNodeVector labelv=lpn.getChildren();
1165           Vector<SwitchLabelNode> slv = new Vector<SwitchLabelNode>();
1166           for(int j=0; j<labelv.size(); j++) {
1167             ParseNode labeldecl=labelv.elementAt(j);
1168             if(isNode(labeldecl, "switch_label")) {
1169               slv.addElement(new SwitchLabelNode(parseExpression(labeldecl.getChild("constant_expression").getFirstChild()), false));
1170             } else if(isNode(labeldecl, "default_switch_label")) {
1171               slv.addElement(new SwitchLabelNode(null, true));
1172             }
1173           }
1174
1175           blockstatements.add(new SwitchBlockNode(slv,
1176               parseSingleBlock(sblockdecl.getChild("switch_statements").getFirstChild())));
1177
1178         }
1179       }
1180     } else if (isNode(pn, "trycatchstatement")) {
1181       // TODO add version for normal Java later
1182       // Do not fully support exceptions now. Only make sure that if there are no
1183       // exceptions thrown, the execution is right
1184       ParseNode tpn = pn.getChild("tryblock").getFirstChild();
1185       BlockNode bn=parseBlockHelper(tpn);
1186       blockstatements.add(new SubBlockNode(bn));
1187
1188       ParseNode fbk = pn.getChild("finallyblock");
1189       if(fbk != null) {
1190         ParseNode fpn = fbk.getFirstChild();
1191         BlockNode fbn=parseBlockHelper(fpn);
1192         blockstatements.add(new SubBlockNode(fbn));
1193       }
1194     } else if (isNode(pn, "throwstatement")) {
1195       // TODO Simply return here
1196       //blockstatements.add(new ReturnNode());
1197     } else if (isNode(pn,"taskexit")) {
1198       Vector vfe=null;
1199       if (pn.getChild("flag_effects_list")!=null)
1200         vfe=parseFlags(pn.getChild("flag_effects_list"));
1201       Vector ccs=null;
1202       if (pn.getChild("cons_checks")!=null)
1203         ccs=parseChecks(pn.getChild("cons_checks"));
1204
1205       blockstatements.add(new TaskExitNode(vfe, ccs, this.m_taskexitnum++));
1206     } else if (isNode(pn,"atomic")) {
1207       BlockNode bn=parseBlockHelper(pn);
1208       blockstatements.add(new AtomicNode(bn));
1209     } else if (isNode(pn,"synchronized")) {
1210       BlockNode bn=parseBlockHelper(pn.getChild("block"));
1211       ExpressionNode en=parseExpression(pn.getChild("expr").getFirstChild());
1212       blockstatements.add(new SynchronizedNode(en, bn));
1213     } else if (isNode(pn,"return")) {
1214       if (isEmpty(pn.getTerminal()))
1215         blockstatements.add(new ReturnNode());
1216       else {
1217         ExpressionNode en=parseExpression(pn.getFirstChild());
1218         blockstatements.add(new ReturnNode(en));
1219       }
1220     } else if (isNode(pn,"block_statement_list")) {
1221       BlockNode bn=parseBlockHelper(pn);
1222       blockstatements.add(new SubBlockNode(bn));
1223     } else if (isNode(pn,"empty")) {
1224       /* nop */
1225     } else if (isNode(pn,"statement_expression_list")) {
1226       ParseNodeVector pnv=pn.getChildren();
1227       BlockNode bn=new BlockNode();
1228       for(int i=0; i<pnv.size(); i++) {
1229         ExpressionNode en=parseExpression(pnv.elementAt(i));
1230         blockstatements.add(new BlockExpressionNode(en));
1231       }
1232       bn.setStyle(BlockNode.EXPRLIST);
1233     } else if (isNode(pn,"forstatement")) {
1234       BlockNode init=parseSingleBlock(pn.getChild("initializer").getFirstChild());
1235       BlockNode update=parseSingleBlock(pn.getChild("update").getFirstChild());
1236       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1237       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1238       if(condition == null) {
1239         // no condition clause, make a 'true' expression as the condition
1240         condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
1241       }
1242       blockstatements.add(new LoopNode(init,condition,update,body));
1243     } else if (isNode(pn,"whilestatement")) {
1244       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1245       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1246       if(condition == null) {
1247         // no condition clause, make a 'true' expression as the condition
1248         condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
1249       }
1250       blockstatements.add(new LoopNode(condition,body,LoopNode.WHILELOOP));
1251     } else if (isNode(pn,"dowhilestatement")) {
1252       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1253       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1254       if(condition == null) {
1255         // no condition clause, make a 'true' expression as the condition
1256         condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
1257       }
1258       blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP));
1259     } else if (isNode(pn,"sese")) {
1260       ParseNode pnID=pn.getChild("identifier");
1261       String stID=null;
1262       if( pnID != null ) { stID=pnID.getFirstChild().getTerminal(); }
1263       SESENode start=new SESENode(stID);
1264       SESENode end  =new SESENode(stID);
1265       start.setEnd( end   );
1266       end.setStart( start );
1267       blockstatements.add(start);
1268       blockstatements.addAll(parseSESEBlock(blockstatements,pn.getChild("body").getFirstChild()));
1269       blockstatements.add(end);
1270     } else if (isNode(pn,"continue")) {
1271       blockstatements.add(new ContinueBreakNode(false));
1272     } else if (isNode(pn,"break")) {
1273       blockstatements.add(new ContinueBreakNode(true));
1274
1275     } else if (isNode(pn,"genreach")) {
1276       String graphName = pn.getChild("graphName").getTerminal();
1277       blockstatements.add( new GenReachNode( graphName ) );
1278
1279     } else {
1280       System.out.println("---------------");
1281       System.out.println(pn.PPrint(3,true));
1282       throw new Error();
1283     }
1284     return blockstatements;
1285   }
1286
1287   public MethodDescriptor parseMethodHeader(ParseNode pn) {
1288     ParseNode mn=pn.getChild("modifiers");
1289     Modifiers m=parseModifiersList(mn);
1290
1291     ParseNode tn=pn.getChild("returntype");
1292     TypeDescriptor returntype;
1293     if (tn!=null)
1294       returntype=parseTypeDescriptor(tn);
1295     else
1296       returntype=new TypeDescriptor(TypeDescriptor.VOID);
1297
1298     ParseNode pmd=pn.getChild("method_declarator");
1299     String name=pmd.getChild("name").getTerminal();
1300     MethodDescriptor md=new MethodDescriptor(m, returntype, name);
1301
1302     ParseNode paramnode=pmd.getChild("parameters");
1303     parseParameterList(md,paramnode);
1304     return md;
1305   }
1306
1307   public void parseParameterList(MethodDescriptor md, ParseNode pn) {
1308     ParseNode paramlist=pn.getChild("formal_parameter_list");
1309     if (paramlist==null)
1310       return;
1311     ParseNodeVector pnv=paramlist.getChildren();
1312     for(int i=0; i<pnv.size(); i++) {
1313       ParseNode paramn=pnv.elementAt(i);
1314
1315       if (isNode(paramn, "tag_parameter")) {
1316         String paramname=paramn.getChild("single").getTerminal();
1317         TypeDescriptor type=new TypeDescriptor(TypeDescriptor.TAG);
1318         md.addTagParameter(type, paramname);
1319       } else {
1320         TypeDescriptor type=parseTypeDescriptor(paramn);
1321
1322         ParseNode tmp=paramn;
1323         while (tmp.getChild("single")==null) {
1324           type=type.makeArray(state);
1325           tmp=tmp.getChild("array");
1326         }
1327         String paramname=tmp.getChild("single").getTerminal();
1328
1329         md.addParameter(type, paramname);
1330       }
1331     }
1332   }
1333
1334   public Modifiers parseModifiersList(ParseNode pn) {
1335     Modifiers m=new Modifiers();
1336     ParseNode modlist=pn.getChild("modifier_list");
1337     if (modlist!=null) {
1338       ParseNodeVector pnv=modlist.getChildren();
1339       for(int i=0; i<pnv.size(); i++) {
1340         ParseNode modn=pnv.elementAt(i);
1341         if (isNode(modn,"public"))
1342           m.addModifier(Modifiers.PUBLIC);
1343         else if (isNode(modn,"protected"))
1344           m.addModifier(Modifiers.PROTECTED);
1345         else if (isNode(modn,"private"))
1346           m.addModifier(Modifiers.PRIVATE);
1347         else if (isNode(modn,"static"))
1348           m.addModifier(Modifiers.STATIC);
1349         else if (isNode(modn,"final"))
1350           m.addModifier(Modifiers.FINAL);
1351         else if (isNode(modn,"native"))
1352           m.addModifier(Modifiers.NATIVE);
1353         else if (isNode(modn,"synchronized"))
1354           m.addModifier(Modifiers.SYNCHRONIZED);
1355         else if (isNode(modn,"atomic"))
1356           m.addModifier(Modifiers.ATOMIC);
1357     else if (isNode(modn,"abstract"))
1358       m.addModifier(Modifiers.ABSTRACT);
1359     else if (isNode(modn,"volatile"))
1360       m.addModifier(Modifiers.VOLATILE);
1361     else if (isNode(modn,"transient"))
1362       m.addModifier(Modifiers.TRANSIENT);
1363     else if(isNode(modn,"annotation_list"))
1364       parseAnnotationList(modn,m);
1365         else{
1366           throw new Error("Unrecognized Modifier:"+modn.getLabel());}
1367       }
1368     }
1369     return m;
1370   }
1371
1372   private void parseAnnotationList(ParseNode pn, Modifiers m) {
1373     ParseNodeVector pnv = pn.getChildren();
1374     for (int i = 0; i < pnv.size(); i++) {
1375       ParseNode body_list = pnv.elementAt(i);
1376       if (isNode(body_list, "annotation_body")) {
1377         ParseNode body_node = body_list.getFirstChild();
1378         if (isNode(body_node, "marker_annotation")) {
1379           m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
1380         } else if (isNode(body_node, "single_annotation")) {
1381           m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
1382               body_node.getChild("element_value").getTerminal()));
1383         } else if (isNode(body_node, "normal_annotation")) {
1384           throw new Error("Annotation with multiple data members is not supported yet.");
1385         }
1386       }
1387     }
1388   }
1389
1390   private boolean isNode(ParseNode pn, String label) {
1391     if (pn.getLabel().equals(label))
1392       return true;
1393     else return false;
1394   }
1395
1396   private static boolean isEmpty(ParseNode pn) {
1397     if (pn.getLabel().equals("empty"))
1398       return true;
1399     else
1400       return false;
1401   }
1402
1403   private static boolean isEmpty(String s) {
1404     if (s.equals("empty"))
1405       return true;
1406     else
1407       return false;
1408   }
1409
1410   /** Throw an exception if something is unexpected */
1411   private void check(ParseNode pn, String label) {
1412     if (pn == null) {
1413       throw new Error(pn+ "IE: Expected '" + label + "', got null");
1414     }
1415     if (!pn.getLabel().equals(label)) {
1416       throw new Error(pn+ "IE: Expected '" + label + "', got '"+pn.getLabel()+"'");
1417     }
1418   }
1419 }