Robust/src/IR/Tree/BuildIR.java

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