12 private int m_taskexitnum;
14 public BuildIR(State state) {
16 this.m_taskexitnum = 0;
19 public void buildtree(ParseNode pn, Set toanalyze, String sourcefile) {
20 parseFile(pn, toanalyze,sourcefile);
22 // numering the interfaces
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++);
35 NameDescriptor packages;
37 /** Parse the classes in this file */
38 public void parseFile(ParseNode pn, Set toanalyze,String sourcefile) {
39 singleimports=new Vector();
40 multiimports=new Vector();
42 ParseNode ipn=pn.getChild("imports").getChild("import_decls_list");
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);
54 ParseNode ppn=pn.getChild("packages").getChild("package");
56 packages=parseName(ppn.getChild("name"));
58 ParseNode tpn=pn.getChild("type_declaration_list");
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 */
65 if (isNode(type_pn,"class_declaration")) {
66 ClassDescriptor cn=parseTypeDecl(type_pn);
67 cn.setSourceFileName(sourcefile);
68 parseInitializers(cn);
72 // for inner classes/enum
73 HashSet tovisit = new HashSet();
74 Iterator it_icds = cn.getInnerClasses();
75 while(it_icds.hasNext()) {
76 tovisit.add(it_icds.next());
79 while(!tovisit.isEmpty()) {
80 ClassDescriptor cd = (ClassDescriptor)tovisit.iterator().next();
82 parseInitializers(cd);
83 if(toanalyze != null) {
86 cd.setSourceFileName(sourcefile);
89 Iterator it_ics = cd.getInnerClasses();
90 while(it_ics.hasNext()) {
91 tovisit.add(it_ics.next());
94 Iterator it_ienums = cd.getEnum();
95 while(it_ienums.hasNext()) {
96 ClassDescriptor iecd = (ClassDescriptor)it_ienums.next();
97 if(toanalyze != null) {
100 iecd.setSourceFileName(sourcefile);
101 state.addClass(iecd);
105 Iterator it_enums = cn.getEnum();
106 while(it_enums.hasNext()) {
107 ClassDescriptor ecd = (ClassDescriptor)it_enums.next();
108 if(toanalyze != null) {
111 ecd.setSourceFileName(sourcefile);
114 } else if (isNode(type_pn,"task_declaration")) {
115 TaskDescriptor td=parseTaskDecl(type_pn);
119 } else if (isNode(type_pn,"interface_declaration")) {
120 // TODO add version for normal Java later
121 ClassDescriptor cn = parseInterfaceDecl(type_pn);
124 cn.setSourceFileName(sourcefile);
128 Iterator it_enums = cn.getEnum();
129 while(it_enums.hasNext()) {
130 ClassDescriptor ecd = (ClassDescriptor)it_enums.next();
131 if(toanalyze != null) {
134 ecd.setSourceFileName(sourcefile);
137 } else if (isNode(type_pn,"enum_declaration")) {
138 // TODO add version for normal Java later
139 ClassDescriptor cn = parseEnumDecl(null, type_pn);
142 cn.setSourceFileName(sourcefile);
145 throw new Error(type_pn.getLabel());
151 public void parseInitializers(ClassDescriptor cn){
152 Vector fv=cn.getFieldVec();
154 for(int i=0;i<fv.size();i++) {
155 FieldDescriptor fd=(FieldDescriptor)fv.get(i);
156 if(fd.getExpressionNode()!=null) {
157 Iterator methodit = cn.getMethods();
158 while(methodit.hasNext()){
159 MethodDescriptor currmd=(MethodDescriptor)methodit.next();
160 if(currmd.isConstructor()){
161 BlockNode bn=state.getMethodBody(currmd);
162 NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
163 AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
164 bn.addBlockStatementAt(new BlockExpressionNode(an), pos);
172 private ClassDescriptor parseEnumDecl(ClassDescriptor cn, ParseNode pn) {
173 ClassDescriptor ecd=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
176 ecd.setSurroundingClass(cn.getSymbol());
177 ecd.setSurrounding(cn);
180 if (!(ecd.getSymbol().equals(TypeUtil.ObjectClass)||
181 ecd.getSymbol().equals(TypeUtil.TagClass))) {
182 ecd.setSuper(TypeUtil.ObjectClass);
184 ecd.setModifiers(parseModifiersList(pn.getChild("modifiers")));
185 parseEnumBody(ecd, pn.getChild("enumbody"));
189 private void parseEnumBody(ClassDescriptor cn, ParseNode pn) {
190 ParseNode decls=pn.getChild("enum_constants_list");
192 ParseNodeVector pnv=decls.getChildren();
193 for(int i=0; i<pnv.size(); i++) {
194 ParseNode decl=pnv.elementAt(i);
195 if (isNode(decl,"enum_constant")) {
196 parseEnumConstant(cn,decl);
197 } else throw new Error();
202 private void parseEnumConstant(ClassDescriptor cn, ParseNode pn) {
203 cn.addEnumConstant(pn.getChild("name").getTerminal());
206 public ClassDescriptor parseInterfaceDecl(ParseNode pn) {
207 ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal(), true);
208 //cn.setAsInterface();
209 if (!isEmpty(pn.getChild("superIF").getTerminal())) {
210 /* parse inherited interface name */
211 ParseNode snlist=pn.getChild("superIF").getChild("extend_interface_list");
212 ParseNodeVector pnv=snlist.getChildren();
213 for(int i=0; i<pnv.size(); i++) {
214 ParseNode decl=pnv.elementAt(i);
215 if (isNode(decl,"type")) {
216 NameDescriptor nd=parseName(decl.getChild("class").getChild("name"));
217 cn.addSuperInterface(nd.toString());
221 cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
222 parseInterfaceBody(cn, pn.getChild("interfacebody"));
226 private void parseInterfaceBody(ClassDescriptor cn, ParseNode pn) {
227 assert(cn.isInterface());
228 ParseNode decls=pn.getChild("interface_member_declaration_list");
230 ParseNodeVector pnv=decls.getChildren();
231 for(int i=0; i<pnv.size(); i++) {
232 ParseNode decl=pnv.elementAt(i);
233 if (isNode(decl,"constant")) {
234 parseInterfaceConstant(cn,decl);
235 } else if (isNode(decl,"method")) {
236 parseInterfaceMethod(cn,decl.getChild("method_declaration"));
237 } else throw new Error();
242 private void parseInterfaceConstant(ClassDescriptor cn, ParseNode pn) {
244 parseFieldDecl(cn,pn.getChild("field_declaration"));
250 private void parseInterfaceMethod(ClassDescriptor cn, ParseNode pn) {
251 ParseNode headern=pn.getChild("header");
252 ParseNode bodyn=pn.getChild("body");
253 MethodDescriptor md=parseMethodHeader(headern.getChild("method_header"));
254 md.getModifiers().addModifier(Modifiers.PUBLIC);
255 md.getModifiers().addModifier(Modifiers.ABSTRACT);
257 BlockNode bn=parseBlock(bodyn);
259 state.addTreeCode(md,bn);
261 // this is a hack for investigating new language features
262 // at the AST level, someday should evolve into a nice compiler
264 //if( cn.getSymbol().equals( ***put a class in here like: "Test" ) &&
265 // md.getSymbol().equals( ***put your method in here like: "main" )
267 // bn.setStyle( BlockNode.NORMAL );
268 // System.out.println( bn.printNode( 0 ) );
271 } catch (Exception e) {
272 System.out.println("Error with method:"+md.getSymbol());
276 System.out.println("Error with method:"+md.getSymbol());
282 public TaskDescriptor parseTaskDecl(ParseNode pn) {
283 TaskDescriptor td=new TaskDescriptor(pn.getChild("name").getTerminal());
284 ParseNode bodyn=pn.getChild("body");
285 BlockNode bn=parseBlock(bodyn);
286 parseParameterList(td, pn);
287 state.addTreeCode(td,bn);
288 if (pn.getChild("flag_effects_list")!=null)
289 td.addFlagEffects(parseFlags(pn.getChild("flag_effects_list")));
293 public Vector parseFlags(ParseNode pn) {
294 Vector vfe=new Vector();
295 ParseNodeVector pnv=pn.getChildren();
296 for(int i=0; i<pnv.size(); i++) {
297 ParseNode fn=pnv.elementAt(i);
298 FlagEffects fe=parseFlagEffects(fn);
304 public FlagEffects parseFlagEffects(ParseNode pn) {
305 if (isNode(pn,"flag_effect")) {
306 String flagname=pn.getChild("name").getTerminal();
307 FlagEffects fe=new FlagEffects(flagname);
308 if (pn.getChild("flag_list")!=null)
309 parseFlagEffect(fe, pn.getChild("flag_list"));
310 if (pn.getChild("tag_list")!=null)
311 parseTagEffect(fe, pn.getChild("tag_list"));
313 } else throw new Error();
316 public void parseTagEffect(FlagEffects fes, ParseNode pn) {
317 ParseNodeVector pnv=pn.getChildren();
318 for(int i=0; i<pnv.size(); i++) {
319 ParseNode pn2=pnv.elementAt(i);
321 if (isNode(pn2,"not")) {
323 pn2=pn2.getChild("name");
325 String name=pn2.getTerminal();
326 fes.addTagEffect(new TagEffect(name,status));
330 public void parseFlagEffect(FlagEffects fes, ParseNode pn) {
331 ParseNodeVector pnv=pn.getChildren();
332 for(int i=0; i<pnv.size(); i++) {
333 ParseNode pn2=pnv.elementAt(i);
335 if (isNode(pn2,"not")) {
337 pn2=pn2.getChild("name");
339 String name=pn2.getTerminal();
340 fes.addEffect(new FlagEffect(name,status));
344 public FlagExpressionNode parseFlagExpression(ParseNode pn) {
345 if (isNode(pn,"or")) {
346 ParseNodeVector pnv=pn.getChildren();
347 ParseNode left=pnv.elementAt(0);
348 ParseNode right=pnv.elementAt(1);
349 return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_OR));
350 } else if (isNode(pn,"and")) {
351 ParseNodeVector pnv=pn.getChildren();
352 ParseNode left=pnv.elementAt(0);
353 ParseNode right=pnv.elementAt(1);
354 return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_AND));
355 } else if (isNode(pn, "not")) {
356 ParseNodeVector pnv=pn.getChildren();
357 ParseNode left=pnv.elementAt(0);
358 return new FlagOpNode(parseFlagExpression(left), new Operation(Operation.LOGIC_NOT));
360 } else if (isNode(pn,"name")) {
361 return new FlagNode(pn.getTerminal());
367 public Vector parseChecks(ParseNode pn) {
368 Vector ccs=new Vector();
369 ParseNodeVector pnv=pn.getChildren();
370 for(int i=0; i<pnv.size(); i++) {
371 ParseNode fn=pnv.elementAt(i);
372 ConstraintCheck cc=parseConstraintCheck(fn);
378 public ConstraintCheck parseConstraintCheck(ParseNode pn) {
379 if (isNode(pn,"cons_check")) {
380 String specname=pn.getChild("name").getChild("identifier").getTerminal();
381 Vector[] args=parseConsArgumentList(pn);
382 ConstraintCheck cc=new ConstraintCheck(specname);
383 for(int i=0; i<args[0].size(); i++) {
384 cc.addVariable((String)args[0].get(i));
385 cc.addArgument((ExpressionNode)args[1].get(i));
388 } else throw new Error();
391 public void parseParameterList(TaskDescriptor td, ParseNode pn) {
394 ParseNode paramlist=pn.getChild("task_parameter_list");
397 ParseNodeVector pnv=paramlist.getChildren();
398 for(int i=0; i<pnv.size(); i++) {
399 ParseNode paramn=pnv.elementAt(i);
400 if(paramn.getChild("optional")!=null) {
402 paramn = paramn.getChild("optional").getFirstChild();
403 System.out.println("OPTIONAL FOUND!!!!!!!");
404 } else { optional = false;
405 System.out.println("NOT OPTIONAL");}
407 TypeDescriptor type=parseTypeDescriptor(paramn);
409 String paramname=paramn.getChild("single").getTerminal();
410 FlagExpressionNode fen=null;
411 if (paramn.getChild("flag")!=null)
412 fen=parseFlagExpression(paramn.getChild("flag").getFirstChild());
414 ParseNode tagnode=paramn.getChild("tag");
416 TagExpressionList tel=null;
418 tel=parseTagExpressionList(tagnode);
421 td.addParameter(type,paramname,fen, tel, optional);
425 public TagExpressionList parseTagExpressionList(ParseNode pn) {
426 //BUG FIX: change pn.getChildren() to pn.getChild("tag_expression_list").getChildren()
427 //To test, feed in any input program that uses tags
428 ParseNodeVector pnv=pn.getChild("tag_expression_list").getChildren();
429 TagExpressionList tel=new TagExpressionList();
430 for(int i=0; i<pnv.size(); i++) {
431 ParseNode tn=pnv.elementAt(i);
432 String type=tn.getChild("type").getTerminal();
433 String name=tn.getChild("single").getTerminal();
434 tel.addTag(type, name);
439 public ClassDescriptor parseTypeDecl(ParseNode pn) {
440 ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
441 if (!isEmpty(pn.getChild("super").getTerminal())) {
442 /* parse superclass name */
443 ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name");
444 NameDescriptor nd=parseName(snn);
445 cn.setSuper(nd.toString());
447 if (!(cn.getSymbol().equals(TypeUtil.ObjectClass)||
448 cn.getSymbol().equals(TypeUtil.TagClass)))
449 cn.setSuper(TypeUtil.ObjectClass);
451 // check inherited interfaces
452 if (!isEmpty(pn.getChild("superIF").getTerminal())) {
453 /* parse inherited interface name */
454 ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
455 ParseNodeVector pnv=snlist.getChildren();
456 for(int i=0; i<pnv.size(); i++) {
457 ParseNode decl=pnv.elementAt(i);
458 if (isNode(decl,"type")) {
459 NameDescriptor nd=parseName(decl.getChild("class").getChild("name"));
460 cn.addSuperInterface(nd.toString());
464 cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
465 parseClassBody(cn, pn.getChild("classbody"));
467 boolean hasConstructor = false;
468 for(Iterator method_it=cn.getMethods(); method_it.hasNext();) {
469 MethodDescriptor md=(MethodDescriptor)method_it.next();
470 hasConstructor |= md.isConstructor();
472 if((!hasConstructor) && (!cn.isEnum())) {
473 // add a default constructor for this class
474 MethodDescriptor md = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC),
475 cn.getSymbol(), false);
476 BlockNode bn=new BlockNode();
477 state.addTreeCode(md,bn);
478 md.setDefaultConstructor();
484 private void parseClassBody(ClassDescriptor cn, ParseNode pn) {
485 ParseNode decls=pn.getChild("class_body_declaration_list");
487 ParseNodeVector pnv=decls.getChildren();
488 for(int i=0; i<pnv.size(); i++) {
489 ParseNode decl=pnv.elementAt(i);
490 if (isNode(decl,"member")) {
491 parseClassMember(cn,decl);
492 } else if (isNode(decl,"constructor")) {
493 parseConstructorDecl(cn,decl.getChild("constructor_declaration"));
494 } else if (isNode(decl, "static_block")) {
495 parseStaticBlockDecl(cn, decl.getChild("static_block_declaration"));
496 } else if (isNode(decl,"block")) {
497 } else if (isNode(decl,"location_order_declaration")) {
498 parseLocationOrder(cn,decl.getChild("location_order_list"));
499 } else throw new Error();
504 private void parseLocationOrder(ClassDescriptor cd, ParseNode pn) {
505 ParseNodeVector pnv = pn.getChildren();
506 Lattice<String> locOrder =
507 new Lattice<String>("_top_","_bottom_");
508 Set<String> spinLocSet=new HashSet<String>();
509 for (int i = 0; i < pnv.size(); i++) {
510 ParseNode loc = pnv.elementAt(i);
511 if(isNode(loc,"location_property")){
512 String spinLoc=loc.getChildren().elementAt(0).getLabel();
513 spinLocSet.add(spinLoc);
515 String lowerLoc=loc.getChildren().elementAt(0).getLabel();
516 String higherLoc= loc.getChildren().elementAt(1).getLabel();
517 locOrder.put(higherLoc, lowerLoc);
518 if (locOrder.isIntroducingCycle(higherLoc)) {
519 throw new Error("Error: the order relation " + lowerLoc + " < " + higherLoc
520 + " introduces a cycle.");
524 if(spinLocSet.size()>0){
525 state.addLocationPropertySet(cd, spinLocSet);
527 state.addLocationOrder(cd, locOrder);
530 private void parseClassMember(ClassDescriptor cn, ParseNode pn) {
531 ParseNode fieldnode=pn.getChild("field");
532 if (fieldnode!=null) {
533 parseFieldDecl(cn,fieldnode.getChild("field_declaration"));
536 ParseNode methodnode=pn.getChild("method");
537 if (methodnode!=null) {
538 parseMethodDecl(cn,methodnode.getChild("method_declaration"));
541 ParseNode innerclassnode=pn.getChild("inner_class_declaration");
542 if (innerclassnode!=null) {
543 parseInnerClassDecl(cn,innerclassnode);
546 ParseNode enumnode=pn.getChild("enum_declaration");
547 if (enumnode!=null) {
548 parseEnumDecl(cn,enumnode);
551 ParseNode flagnode=pn.getChild("flag");
552 if (flagnode!=null) {
553 parseFlagDecl(cn, flagnode.getChild("flag_declaration"));
556 // in case there are empty node
557 ParseNode emptynode=pn.getChild("empty");
558 if(emptynode != null) {
564 private ClassDescriptor parseInnerClassDecl(ClassDescriptor cn, ParseNode pn) {
565 ClassDescriptor icn=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
566 icn.setAsInnerClass();
567 icn.setSurroundingClass(cn.getSymbol());
568 icn.setSurrounding(cn);
569 cn.addInnerClass(icn);
570 if (!isEmpty(pn.getChild("super").getTerminal())) {
571 /* parse superclass name */
572 ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name");
573 NameDescriptor nd=parseName(snn);
574 icn.setSuper(nd.toString());
576 if (!(icn.getSymbol().equals(TypeUtil.ObjectClass)||
577 icn.getSymbol().equals(TypeUtil.TagClass)))
578 icn.setSuper(TypeUtil.ObjectClass);
580 // check inherited interfaces
581 if (!isEmpty(pn.getChild("superIF").getTerminal())) {
582 /* parse inherited interface name */
583 ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
584 ParseNodeVector pnv=snlist.getChildren();
585 for(int i=0; i<pnv.size(); i++) {
586 ParseNode decl=pnv.elementAt(i);
587 if (isNode(decl,"type")) {
588 NameDescriptor nd=parseName(decl.getChild("class").getChild("name"));
589 icn.addSuperInterface(nd.toString());
593 icn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
594 if(!icn.isStatic()) {
595 throw new Error("Error: inner class " + icn.getSymbol() + " in Class " +
596 cn.getSymbol() + " is not a nested class and is not supported yet!");
598 parseClassBody(icn, pn.getChild("classbody"));
602 private TypeDescriptor parseTypeDescriptor(ParseNode pn) {
603 ParseNode tn=pn.getChild("type");
604 String type_st=tn.getTerminal();
605 if(type_st.equals("byte")) {
606 return state.getTypeDescriptor(TypeDescriptor.BYTE);
607 } else if(type_st.equals("short")) {
608 return state.getTypeDescriptor(TypeDescriptor.SHORT);
609 } else if(type_st.equals("boolean")) {
610 return state.getTypeDescriptor(TypeDescriptor.BOOLEAN);
611 } else if(type_st.equals("int")) {
612 return state.getTypeDescriptor(TypeDescriptor.INT);
613 } else if(type_st.equals("long")) {
614 return state.getTypeDescriptor(TypeDescriptor.LONG);
615 } else if(type_st.equals("char")) {
616 return state.getTypeDescriptor(TypeDescriptor.CHAR);
617 } else if(type_st.equals("float")) {
618 return state.getTypeDescriptor(TypeDescriptor.FLOAT);
619 } else if(type_st.equals("double")) {
620 return state.getTypeDescriptor(TypeDescriptor.DOUBLE);
621 } else if(type_st.equals("class")) {
622 ParseNode nn=tn.getChild("class");
623 return state.getTypeDescriptor(parseName(nn.getChild("name")));
624 } else if(type_st.equals("array")) {
625 ParseNode nn=tn.getChild("array");
626 TypeDescriptor td=parseTypeDescriptor(nn.getChild("basetype"));
627 Integer numdims=(Integer)nn.getChild("dims").getLiteral();
628 for(int i=0; i<numdims.intValue(); i++)
629 td=td.makeArray(state);
632 System.out.println(pn.PPrint(2, true));
637 private NameDescriptor parseName(ParseNode nn) {
638 ParseNode base=nn.getChild("base");
639 ParseNode id=nn.getChild("identifier");
641 return new NameDescriptor(id.getTerminal());
642 return new NameDescriptor(parseName(base.getChild("name")),id.getTerminal());
646 private void parseFlagDecl(ClassDescriptor cn,ParseNode pn) {
647 String name=pn.getChild("name").getTerminal();
648 FlagDescriptor flag=new FlagDescriptor(name);
649 if (pn.getChild("external")!=null)
654 private void parseFieldDecl(ClassDescriptor cn,ParseNode pn) {
655 ParseNode mn=pn.getChild("modifier");
656 Modifiers m=parseModifiersList(mn);
657 if(cn.isInterface()) {
658 // TODO add version for normal Java later
659 // Can only be PUBLIC or STATIC or FINAL
660 if((m.isAbstract()) || (m.isAtomic()) || (m.isNative())
661 || (m.isSynchronized())) {
662 throw new Error("Error: field in Interface " + cn.getSymbol() + "can only be PUBLIC or STATIC or FINAL");
664 m.addModifier(Modifiers.PUBLIC);
665 m.addModifier(Modifiers.STATIC);
666 m.addModifier(Modifiers.FINAL);
669 ParseNode tn=pn.getChild("type");
670 TypeDescriptor t=parseTypeDescriptor(tn);
671 assignAnnotationsToType(m,t);
672 ParseNode vn=pn.getChild("variables").getChild("variable_declarators_list");
673 ParseNodeVector pnv=vn.getChildren();
674 boolean isglobal=pn.getChild("global")!=null;
676 for(int i=0; i<pnv.size(); i++) {
677 ParseNode vardecl=pnv.elementAt(i);
678 ParseNode tmp=vardecl;
679 TypeDescriptor arrayt=t;
680 while (tmp.getChild("single")==null) {
681 arrayt=arrayt.makeArray(state);
682 tmp=tmp.getChild("array");
684 String identifier=tmp.getChild("single").getTerminal();
685 ParseNode epn=vardecl.getChild("initializer");
687 ExpressionNode en=null;
689 en=parseExpression(epn.getFirstChild());
690 en.setNumLine(epn.getFirstChild().getLine());
692 // for static field, the initializer should be considered as a
694 boolean isfirst = false;
695 MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
697 // the first static block for this class
698 Modifiers m_i=new Modifiers();
699 m_i.addModifier(Modifiers.STATIC);
700 md = new MethodDescriptor(m_i, "staticblocks", false);
701 md.setAsStaticBlock();
707 cn.incStaticBlocks();
708 BlockNode bn=new BlockNode();
709 NameNode nn=new NameNode(new NameDescriptor(identifier));
710 nn.setNumLine(en.getNumLine());
711 AssignmentNode an=new AssignmentNode(nn,en,new AssignOperation(1));
712 an.setNumLine(pn.getLine());
713 bn.addBlockStatement(new BlockExpressionNode(an));
715 state.addTreeCode(md,bn);
717 BlockNode obn = state.getMethodBody(md);
718 for(int ii = 0; ii < bn.size(); ii++) {
719 BlockStatementNode bsn = bn.get(ii);
720 obn.addBlockStatement(bsn);
722 state.addTreeCode(md, obn);
729 cn.addField(new FieldDescriptor(m, arrayt, identifier, en, isglobal));
733 private void assignAnnotationsToType(Modifiers modifiers, TypeDescriptor type){
734 Vector<AnnotationDescriptor> annotations=modifiers.getAnnotations();
735 for(int i=0; i<annotations.size(); i++) {
736 // it only supports a marker annotation
737 AnnotationDescriptor an=annotations.elementAt(i);
738 type.addAnnotationMarker(an);
742 private ExpressionNode parseExpression(ParseNode pn) {
743 if (isNode(pn,"assignment"))
744 return parseAssignmentExpression(pn);
745 else if (isNode(pn,"logical_or")||isNode(pn,"logical_and")||
746 isNode(pn,"bitwise_or")||isNode(pn,"bitwise_xor")||
747 isNode(pn,"bitwise_and")||isNode(pn,"equal")||
748 isNode(pn,"not_equal")||isNode(pn,"comp_lt")||
749 isNode(pn,"comp_lte")||isNode(pn,"comp_gt")||
750 isNode(pn,"comp_gte")||isNode(pn,"leftshift")||
751 isNode(pn,"rightshift")||isNode(pn,"sub")||
752 isNode(pn,"urightshift")||isNode(pn,"sub")||
753 isNode(pn,"add")||isNode(pn,"mult")||
754 isNode(pn,"div")||isNode(pn,"mod")) {
755 ParseNodeVector pnv=pn.getChildren();
756 ParseNode left=pnv.elementAt(0);
757 ParseNode right=pnv.elementAt(1);
758 Operation op=new Operation(pn.getLabel());
759 OpNode on=new OpNode(parseExpression(left),parseExpression(right),op);
760 on.setNumLine(pn.getLine());
762 } else if (isNode(pn,"unaryplus")||
763 isNode(pn,"unaryminus")||
766 ParseNode left=pn.getFirstChild();
767 Operation op=new Operation(pn.getLabel());
768 OpNode on=new OpNode(parseExpression(left),op);
769 on.setNumLine(pn.getLine());
771 } else if (isNode(pn,"postinc")||
772 isNode(pn,"postdec")) {
773 ParseNode left=pn.getFirstChild();
774 AssignOperation op=new AssignOperation(pn.getLabel());
775 AssignmentNode an=new AssignmentNode(parseExpression(left),null,op);
776 an.setNumLine(pn.getLine());
779 } else if (isNode(pn,"preinc")||
780 isNode(pn,"predec")) {
781 ParseNode left=pn.getFirstChild();
782 AssignOperation op=isNode(pn,"preinc") ? new AssignOperation(AssignOperation.PLUSEQ) : new AssignOperation(AssignOperation.MINUSEQ);
783 AssignmentNode an=new AssignmentNode(parseExpression(left),
784 new LiteralNode("integer",new Integer(1)),op);
785 an.setNumLine(pn.getLine());
787 } else if (isNode(pn,"literal")) {
788 String literaltype=pn.getTerminal();
789 ParseNode literalnode=pn.getChild(literaltype);
790 Object literal_obj=literalnode.getLiteral();
791 LiteralNode ln=new LiteralNode(literaltype, literal_obj);
792 ln.setNumLine(pn.getLine());
794 } else if (isNode(pn,"createobject")) {
795 TypeDescriptor td=parseTypeDescriptor(pn);
797 Vector args=parseArgumentList(pn);
798 boolean isglobal=pn.getChild("global")!=null||
799 pn.getChild("scratch")!=null;
800 String disjointId=null;
801 if( pn.getChild("disjoint") != null) {
802 disjointId = pn.getChild("disjoint").getTerminal();
804 CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
805 con.setNumLine(pn.getLine());
806 for(int i=0; i<args.size(); i++) {
807 con.addArgument((ExpressionNode)args.get(i));
809 /* Could have flag set or tag added here */
810 if (pn.getChild("flag_list")!=null||pn.getChild("tag_list")!=null) {
811 FlagEffects fe=new FlagEffects(null);
812 if (pn.getChild("flag_list")!=null)
813 parseFlagEffect(fe, pn.getChild("flag_list"));
815 if (pn.getChild("tag_list")!=null)
816 parseTagEffect(fe, pn.getChild("tag_list"));
817 con.addFlagEffects(fe);
821 } else if (isNode(pn,"createarray")) {
822 //System.out.println(pn.PPrint(3,true));
823 boolean isglobal=pn.getChild("global")!=null||
824 pn.getChild("scratch")!=null;
825 String disjointId=null;
826 if( pn.getChild("disjoint") != null) {
827 disjointId = pn.getChild("disjoint").getTerminal();
829 TypeDescriptor td=parseTypeDescriptor(pn);
830 Vector args=parseDimExprs(pn);
832 if (pn.getChild("dims_opt").getLiteral()!=null)
833 num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
834 for(int i=0; i<(args.size()+num); i++)
835 td=td.makeArray(state);
836 CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
837 con.setNumLine(pn.getLine());
838 for(int i=0; i<args.size(); i++) {
839 con.addArgument((ExpressionNode)args.get(i));
842 } if (isNode(pn,"createarray2")) {
843 TypeDescriptor td=parseTypeDescriptor(pn);
845 if (pn.getChild("dims_opt").getLiteral()!=null)
846 num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
847 for(int i=0; i<num; i++)
848 td=td.makeArray(state);
849 CreateObjectNode con=new CreateObjectNode(td, false, null);
850 con.setNumLine(pn.getLine());
851 ParseNode ipn = pn.getChild("initializer");
852 Vector initializers=parseVariableInitializerList(ipn);
853 ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
854 ain.setNumLine(pn.getLine());
855 con.addArrayInitializer(ain);
857 } else if (isNode(pn,"name")) {
858 NameDescriptor nd=parseName(pn);
859 NameNode nn=new NameNode(nd);
860 nn.setNumLine(pn.getLine());
862 } else if (isNode(pn,"this")) {
863 NameDescriptor nd=new NameDescriptor("this");
864 NameNode nn=new NameNode(nd);
865 nn.setNumLine(pn.getLine());
867 } else if (isNode(pn,"isavailable")) {
868 NameDescriptor nd=new NameDescriptor(pn.getTerminal());
869 NameNode nn=new NameNode(nd);
870 nn.setNumLine(pn.getLine());
871 return new OpNode(nn,null,new Operation(Operation.ISAVAILABLE));
872 } else if (isNode(pn,"methodinvoke1")) {
873 NameDescriptor nd=parseName(pn.getChild("name"));
874 Vector args=parseArgumentList(pn);
875 MethodInvokeNode min=new MethodInvokeNode(nd);
876 min.setNumLine(pn.getLine());
877 for(int i=0; i<args.size(); i++) {
878 min.addArgument((ExpressionNode)args.get(i));
881 } else if (isNode(pn,"methodinvoke2")) {
882 String methodid=pn.getChild("id").getTerminal();
883 ExpressionNode exp=parseExpression(pn.getChild("base").getFirstChild());
884 Vector args=parseArgumentList(pn);
885 MethodInvokeNode min=new MethodInvokeNode(methodid,exp);
886 min.setNumLine(pn.getLine());
887 for(int i=0; i<args.size(); i++) {
888 min.addArgument((ExpressionNode)args.get(i));
891 } else if (isNode(pn,"fieldaccess")) {
892 ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
893 String fieldname=pn.getChild("field").getTerminal();
895 FieldAccessNode fan=new FieldAccessNode(en,fieldname);
896 fan.setNumLine(pn.getLine());
898 } else if (isNode(pn,"arrayaccess")) {
899 ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
900 ExpressionNode index=parseExpression(pn.getChild("index").getFirstChild());
901 ArrayAccessNode aan=new ArrayAccessNode(en,index);
902 aan.setNumLine(pn.getLine());
904 } else if (isNode(pn,"cast1")) {
906 CastNode cn=new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
907 cn.setNumLine(pn.getLine());
909 } catch (Exception e) {
910 System.out.println(pn.PPrint(1,true));
914 } else if (isNode(pn,"cast2")) {
915 CastNode cn=new CastNode(parseExpression(pn.getChild("type").getFirstChild()),parseExpression(pn.getChild("exp").getFirstChild()));
916 cn.setNumLine(pn.getLine());
918 } else if (isNode(pn, "getoffset")) {
919 TypeDescriptor td=parseTypeDescriptor(pn);
920 String fieldname = pn.getChild("field").getTerminal();
921 //System.out.println("Checking the values of: "+ " td.toString()= " + td.toString()+ " fieldname= " + fieldname);
922 return new OffsetNode(td, fieldname);
923 } else if (isNode(pn, "tert")) {
925 TertiaryNode tn=new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
926 parseExpression(pn.getChild("trueexpr").getFirstChild()),
927 parseExpression(pn.getChild("falseexpr").getFirstChild()) );
928 tn.setNumLine(pn.getLine());
931 } else if (isNode(pn, "instanceof")) {
932 ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
933 TypeDescriptor t=parseTypeDescriptor(pn);
934 InstanceOfNode ion=new InstanceOfNode(exp,t);
935 ion.setNumLine(pn.getLine());
937 } else if (isNode(pn, "array_initializer")) {
938 Vector initializers=parseVariableInitializerList(pn);
939 return new ArrayInitializerNode(initializers);
940 } else if (isNode(pn, "class_type")) {
941 TypeDescriptor td=parseTypeDescriptor(pn);
942 ClassTypeNode ctn=new ClassTypeNode(td);
943 ctn.setNumLine(pn.getLine());
945 } else if (isNode(pn, "empty")) {
948 System.out.println("---------------------");
949 System.out.println(pn.PPrint(3,true));
954 private Vector parseDimExprs(ParseNode pn) {
955 Vector arglist=new Vector();
956 ParseNode an=pn.getChild("dim_exprs");
957 if (an==null) /* No argument list */
959 ParseNodeVector anv=an.getChildren();
960 for(int i=0; i<anv.size(); i++) {
961 arglist.add(parseExpression(anv.elementAt(i)));
966 private Vector parseArgumentList(ParseNode pn) {
967 Vector arglist=new Vector();
968 ParseNode an=pn.getChild("argument_list");
969 if (an==null) /* No argument list */
971 ParseNodeVector anv=an.getChildren();
972 for(int i=0; i<anv.size(); i++) {
973 arglist.add(parseExpression(anv.elementAt(i)));
978 private Vector[] parseConsArgumentList(ParseNode pn) {
979 Vector arglist=new Vector();
980 Vector varlist=new Vector();
981 ParseNode an=pn.getChild("cons_argument_list");
982 if (an==null) /* No argument list */
983 return new Vector[] {varlist, arglist};
984 ParseNodeVector anv=an.getChildren();
985 for(int i=0; i<anv.size(); i++) {
986 ParseNode cpn=anv.elementAt(i);
987 ParseNode var=cpn.getChild("var");
988 ParseNode exp=cpn.getChild("exp").getFirstChild();
989 varlist.add(var.getTerminal());
990 arglist.add(parseExpression(exp));
992 return new Vector[] {varlist, arglist};
995 private Vector parseVariableInitializerList(ParseNode pn) {
996 Vector varInitList=new Vector();
997 ParseNode vin=pn.getChild("var_init_list");
998 if (vin==null) /* No argument list */
1000 ParseNodeVector vinv=vin.getChildren();
1001 for(int i=0; i<vinv.size(); i++) {
1002 varInitList.add(parseExpression(vinv.elementAt(i)));
1007 private ExpressionNode parseAssignmentExpression(ParseNode pn) {
1008 AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
1009 ParseNodeVector pnv=pn.getChild("args").getChildren();
1011 AssignmentNode an=new AssignmentNode(parseExpression(pnv.elementAt(0)),parseExpression(pnv.elementAt(1)),ao);
1012 an.setNumLine(pn.getLine());
1017 private void parseMethodDecl(ClassDescriptor cn, ParseNode pn) {
1018 ParseNode headern=pn.getChild("method_header");
1019 ParseNode bodyn=pn.getChild("body");
1020 MethodDescriptor md=parseMethodHeader(headern);
1022 BlockNode bn=parseBlock(bodyn);
1023 bn.setNumLine(pn.getLine()); // assume that method header is located at the beginning of method body
1025 state.addTreeCode(md,bn);
1027 // this is a hack for investigating new language features
1028 // at the AST level, someday should evolve into a nice compiler
1030 //if( cn.getSymbol().equals( ***put a class in here like: "Test" ) &&
1031 // md.getSymbol().equals( ***put your method in here like: "main" )
1033 // bn.setStyle( BlockNode.NORMAL );
1034 // System.out.println( bn.printNode( 0 ) );
1037 } catch (Exception e) {
1038 System.out.println("Error with method:"+md.getSymbol());
1039 e.printStackTrace();
1042 System.out.println("Error with method:"+md.getSymbol());
1043 e.printStackTrace();
1048 private void parseConstructorDecl(ClassDescriptor cn, ParseNode pn) {
1049 ParseNode mn=pn.getChild("modifiers");
1050 Modifiers m=parseModifiersList(mn);
1051 ParseNode cdecl=pn.getChild("constructor_declarator");
1052 boolean isglobal=cdecl.getChild("global")!=null;
1053 String name=cdecl.getChild("name").getChild("identifier").getTerminal();
1054 MethodDescriptor md=new MethodDescriptor(m, name, isglobal);
1055 ParseNode paramnode=cdecl.getChild("parameters");
1056 parseParameterList(md,paramnode);
1057 ParseNode bodyn0=pn.getChild("body");
1058 ParseNode bodyn=bodyn0.getChild("constructor_body");
1061 if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
1062 bn=parseBlock(bodyn);
1065 if (bodyn!=null&&bodyn.getChild("superinvoke")!=null) {
1066 ParseNode sin=bodyn.getChild("superinvoke");
1067 NameDescriptor nd=new NameDescriptor("super");
1068 Vector args=parseArgumentList(sin);
1069 MethodInvokeNode min=new MethodInvokeNode(nd);
1070 min.setNumLine(sin.getLine());
1071 for(int i=0; i<args.size(); i++) {
1072 min.addArgument((ExpressionNode)args.get(i));
1074 BlockExpressionNode ben=new BlockExpressionNode(min);
1075 bn.addFirstBlockStatement(ben);
1077 } else if (bodyn!=null&&bodyn.getChild("explconstrinv")!=null) {
1078 ParseNode eci=bodyn.getChild("explconstrinv");
1079 NameDescriptor nd=new NameDescriptor(cn.getSymbol());
1080 Vector args=parseArgumentList(eci);
1081 MethodInvokeNode min=new MethodInvokeNode(nd);
1082 min.setNumLine(eci.getLine());
1083 for(int i=0; i<args.size(); i++) {
1084 min.addArgument((ExpressionNode)args.get(i));
1086 BlockExpressionNode ben=new BlockExpressionNode(min);
1087 ben.setNumLine(eci.getLine());
1088 bn.addFirstBlockStatement(ben);
1090 state.addTreeCode(md,bn);
1093 private void parseStaticBlockDecl(ClassDescriptor cn, ParseNode pn) {
1094 // Each class maintains one MethodDecscriptor which combines all its
1095 // static blocks in their declaration order
1096 boolean isfirst = false;
1097 MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
1099 // the first static block for this class
1100 Modifiers m_i=new Modifiers();
1101 m_i.addModifier(Modifiers.STATIC);
1102 md = new MethodDescriptor(m_i, "staticblocks", false);
1103 md.setAsStaticBlock();
1106 ParseNode bodyn=pn.getChild("body");
1110 cn.incStaticBlocks();
1112 if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
1113 bn=parseBlock(bodyn);
1117 state.addTreeCode(md,bn);
1119 BlockNode obn = state.getMethodBody(md);
1120 for(int i = 0; i < bn.size(); i++) {
1121 BlockStatementNode bsn = bn.get(i);
1122 obn.addBlockStatement(bsn);
1124 state.addTreeCode(md, obn);
1129 public BlockNode parseBlock(ParseNode pn) {
1130 this.m_taskexitnum = 0;
1131 if (pn==null||isEmpty(pn.getTerminal()))
1132 return new BlockNode();
1133 ParseNode bsn=pn.getChild("block_statement_list");
1134 return parseBlockHelper(bsn);
1137 private BlockNode parseBlockHelper(ParseNode pn) {
1138 ParseNodeVector pnv=pn.getChildren();
1139 BlockNode bn=new BlockNode();
1140 for(int i=0; i<pnv.size(); i++) {
1141 Vector bsv=parseBlockStatement(pnv.elementAt(i));
1142 for(int j=0; j<bsv.size(); j++) {
1143 bn.addBlockStatement((BlockStatementNode)bsv.get(j));
1149 public BlockNode parseSingleBlock(ParseNode pn) {
1150 BlockNode bn=new BlockNode();
1151 Vector bsv=parseBlockStatement(pn);
1152 for(int j=0; j<bsv.size(); j++) {
1153 bn.addBlockStatement((BlockStatementNode)bsv.get(j));
1155 bn.setStyle(BlockNode.NOBRACES);
1159 public Vector parseSESEBlock(Vector parentbs, ParseNode pn) {
1160 ParseNodeVector pnv=pn.getChildren();
1161 Vector bv=new Vector();
1162 for(int i=0; i<pnv.size(); i++) {
1163 bv.addAll(parseBlockStatement(pnv.elementAt(i)));
1168 public Vector parseBlockStatement(ParseNode pn) {
1169 Vector blockstatements=new Vector();
1170 if (isNode(pn,"tag_declaration")) {
1171 String name=pn.getChild("single").getTerminal();
1172 String type=pn.getChild("type").getTerminal();
1174 TagDeclarationNode tdn=new TagDeclarationNode(name, type);
1175 tdn.setNumLine(pn.getLine());
1177 blockstatements.add(tdn);
1178 } else if (isNode(pn,"local_variable_declaration")) {
1180 ParseNode mn=pn.getChild("modifiers");
1181 TypeDescriptor t=parseTypeDescriptor(pn);
1183 Modifiers m=parseModifiersList(mn);
1184 assignAnnotationsToType(m, t);
1186 ParseNode vn=pn.getChild("variable_declarators_list");
1187 ParseNodeVector pnv=vn.getChildren();
1188 for(int i=0; i<pnv.size(); i++) {
1189 ParseNode vardecl=pnv.elementAt(i);
1192 ParseNode tmp=vardecl;
1193 TypeDescriptor arrayt=t;
1195 while (tmp.getChild("single")==null) {
1196 arrayt=arrayt.makeArray(state);
1197 tmp=tmp.getChild("array");
1199 String identifier=tmp.getChild("single").getTerminal();
1201 ParseNode epn=vardecl.getChild("initializer");
1204 ExpressionNode en=null;
1206 en=parseExpression(epn.getFirstChild());
1208 DeclarationNode dn=new DeclarationNode(new VarDescriptor(arrayt, identifier),en);
1209 dn.setNumLine(tmp.getLine());
1211 blockstatements.add(dn);
1213 } else if (isNode(pn,"nop")) {
1215 } else if (isNode(pn,"expression")) {
1216 BlockExpressionNode ben=new BlockExpressionNode(parseExpression(pn.getFirstChild()));
1217 ben.setNumLine(pn.getLine());
1218 blockstatements.add(ben);
1219 } else if (isNode(pn,"ifstatement")) {
1220 IfStatementNode isn=new IfStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
1221 parseSingleBlock(pn.getChild("statement").getFirstChild()),
1222 pn.getChild("else_statement")!=null ? parseSingleBlock(pn.getChild("else_statement").getFirstChild()) : null);
1223 isn.setNumLine(pn.getLine());
1225 blockstatements.add(isn);
1226 } else if (isNode(pn,"switch_statement")) {
1227 // TODO add version for normal Java later
1228 SwitchStatementNode ssn=new SwitchStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
1229 parseSingleBlock(pn.getChild("statement").getFirstChild()));
1230 ssn.setNumLine(pn.getLine());
1231 blockstatements.add(ssn);
1232 } else if (isNode(pn,"switch_block_list")) {
1233 // TODO add version for normal Java later
1234 ParseNodeVector pnv=pn.getChildren();
1235 for(int i=0; i<pnv.size(); i++) {
1236 ParseNode sblockdecl=pnv.elementAt(i);
1238 if(isNode(sblockdecl, "switch_block")) {
1239 ParseNode lpn=sblockdecl.getChild("switch_labels").getChild("switch_label_list");
1240 ParseNodeVector labelv=lpn.getChildren();
1241 Vector<SwitchLabelNode> slv = new Vector<SwitchLabelNode>();
1242 for(int j=0; j<labelv.size(); j++) {
1243 ParseNode labeldecl=labelv.elementAt(j);
1244 if(isNode(labeldecl, "switch_label")) {
1245 SwitchLabelNode sln=new SwitchLabelNode(parseExpression(labeldecl.getChild("constant_expression").getFirstChild()), false);
1246 sln.setNumLine(labeldecl.getLine());
1247 slv.addElement(sln);
1248 } else if(isNode(labeldecl, "default_switch_label")) {
1249 SwitchLabelNode sln=new SwitchLabelNode(null, true);
1250 sln.setNumLine(labeldecl.getLine());
1251 slv.addElement(sln);
1255 SwitchBlockNode sbn=new SwitchBlockNode(slv,
1256 parseSingleBlock(sblockdecl.getChild("switch_statements").getFirstChild()));
1257 sbn.setNumLine(sblockdecl.getLine());
1259 blockstatements.add(sbn);
1263 } else if (isNode(pn, "trycatchstatement")) {
1264 // TODO add version for normal Java later
1265 // Do not fully support exceptions now. Only make sure that if there are no
1266 // exceptions thrown, the execution is right
1267 ParseNode tpn = pn.getChild("tryblock").getFirstChild();
1268 BlockNode bn=parseBlockHelper(tpn);
1269 blockstatements.add(new SubBlockNode(bn));
1271 ParseNode fbk = pn.getChild("finallyblock");
1273 ParseNode fpn = fbk.getFirstChild();
1274 BlockNode fbn=parseBlockHelper(fpn);
1275 blockstatements.add(new SubBlockNode(fbn));
1277 } else if (isNode(pn, "throwstatement")) {
1278 // TODO Simply return here
1279 //blockstatements.add(new ReturnNode());
1280 } else if (isNode(pn,"taskexit")) {
1282 if (pn.getChild("flag_effects_list")!=null)
1283 vfe=parseFlags(pn.getChild("flag_effects_list"));
1285 if (pn.getChild("cons_checks")!=null)
1286 ccs=parseChecks(pn.getChild("cons_checks"));
1287 TaskExitNode ten=new TaskExitNode(vfe, ccs, this.m_taskexitnum++);
1288 ten.setNumLine(pn.getLine());
1289 blockstatements.add(ten);
1290 } else if (isNode(pn,"atomic")) {
1291 BlockNode bn=parseBlockHelper(pn);
1292 AtomicNode an=new AtomicNode(bn);
1293 an.setNumLine(pn.getLine());
1294 blockstatements.add(an);
1295 } else if (isNode(pn,"synchronized")) {
1296 BlockNode bn=parseBlockHelper(pn.getChild("block"));
1297 ExpressionNode en=parseExpression(pn.getChild("expr").getFirstChild());
1298 SynchronizedNode sn=new SynchronizedNode(en, bn);
1299 sn.setNumLine(pn.getLine());
1300 blockstatements.add(sn);
1301 } else if (isNode(pn,"return")) {
1302 if (isEmpty(pn.getTerminal()))
1303 blockstatements.add(new ReturnNode());
1305 ExpressionNode en=parseExpression(pn.getFirstChild());
1306 ReturnNode rn=new ReturnNode(en);
1307 rn.setNumLine(pn.getLine());
1308 blockstatements.add(rn);
1310 } else if (isNode(pn,"block_statement_list")) {
1311 BlockNode bn=parseBlockHelper(pn);
1312 blockstatements.add(new SubBlockNode(bn));
1313 } else if (isNode(pn,"empty")) {
1315 } else if (isNode(pn,"statement_expression_list")) {
1316 ParseNodeVector pnv=pn.getChildren();
1317 BlockNode bn=new BlockNode();
1318 for(int i=0; i<pnv.size(); i++) {
1319 ExpressionNode en=parseExpression(pnv.elementAt(i));
1320 blockstatements.add(new BlockExpressionNode(en));
1322 bn.setStyle(BlockNode.EXPRLIST);
1323 } else if (isNode(pn,"forstatement")) {
1324 BlockNode init=parseSingleBlock(pn.getChild("initializer").getFirstChild());
1325 BlockNode update=parseSingleBlock(pn.getChild("update").getFirstChild());
1326 ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1327 BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1328 if(condition == null) {
1329 // no condition clause, make a 'true' expression as the condition
1330 condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
1332 LoopNode ln=new LoopNode(init,condition,update,body);
1333 ln.setNumLine(pn.getLine());
1334 blockstatements.add(ln);
1335 } else if (isNode(pn,"whilestatement")) {
1336 ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1337 BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1338 if(condition == null) {
1339 // no condition clause, make a 'true' expression as the condition
1340 condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
1342 blockstatements.add(new LoopNode(condition,body,LoopNode.WHILELOOP));
1343 } else if (isNode(pn,"dowhilestatement")) {
1344 ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1345 BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1346 if(condition == null) {
1347 // no condition clause, make a 'true' expression as the condition
1348 condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
1350 blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP));
1351 } else if (isNode(pn,"sese")) {
1352 ParseNode pnID=pn.getChild("identifier");
1354 if( pnID != null ) { stID=pnID.getFirstChild().getTerminal(); }
1355 SESENode start=new SESENode(stID);
1356 start.setNumLine(pn.getLine());
1357 SESENode end =new SESENode(stID);
1358 start.setEnd( end );
1359 end.setStart( start );
1360 blockstatements.add(start);
1361 blockstatements.addAll(parseSESEBlock(blockstatements,pn.getChild("body").getFirstChild()));
1362 blockstatements.add(end);
1363 } else if (isNode(pn,"continue")) {
1364 ContinueBreakNode cbn=new ContinueBreakNode(false);
1365 cbn.setNumLine(pn.getLine());
1366 blockstatements.add(cbn);
1367 } else if (isNode(pn,"break")) {
1368 ContinueBreakNode cbn=new ContinueBreakNode(true);
1369 cbn.setNumLine(pn.getLine());
1370 blockstatements.add(cbn);
1372 } else if (isNode(pn,"genreach")) {
1373 String graphName = pn.getChild("graphName").getTerminal();
1374 blockstatements.add( new GenReachNode( graphName ) );
1377 System.out.println("---------------");
1378 System.out.println(pn.PPrint(3,true));
1381 return blockstatements;
1384 public MethodDescriptor parseMethodHeader(ParseNode pn) {
1385 ParseNode mn=pn.getChild("modifiers");
1386 Modifiers m=parseModifiersList(mn);
1388 ParseNode tn=pn.getChild("returntype");
1389 TypeDescriptor returntype;
1391 returntype=parseTypeDescriptor(tn);
1393 returntype=new TypeDescriptor(TypeDescriptor.VOID);
1395 ParseNode pmd=pn.getChild("method_declarator");
1396 String name=pmd.getChild("name").getTerminal();
1397 MethodDescriptor md=new MethodDescriptor(m, returntype, name);
1399 ParseNode paramnode=pmd.getChild("parameters");
1400 parseParameterList(md,paramnode);
1404 public void parseParameterList(MethodDescriptor md, ParseNode pn) {
1405 ParseNode paramlist=pn.getChild("formal_parameter_list");
1406 if (paramlist==null)
1408 ParseNodeVector pnv=paramlist.getChildren();
1409 for(int i=0; i<pnv.size(); i++) {
1410 ParseNode paramn=pnv.elementAt(i);
1412 if (isNode(paramn, "tag_parameter")) {
1413 String paramname=paramn.getChild("single").getTerminal();
1414 TypeDescriptor type=new TypeDescriptor(TypeDescriptor.TAG);
1415 md.addTagParameter(type, paramname);
1417 TypeDescriptor type=parseTypeDescriptor(paramn);
1419 ParseNode tmp=paramn;
1420 while (tmp.getChild("single")==null) {
1421 type=type.makeArray(state);
1422 tmp=tmp.getChild("array");
1424 String paramname=tmp.getChild("single").getTerminal();
1426 md.addParameter(type, paramname);
1431 public Modifiers parseModifiersList(ParseNode pn) {
1432 Modifiers m=new Modifiers();
1433 ParseNode modlist=pn.getChild("modifier_list");
1434 if (modlist!=null) {
1435 ParseNodeVector pnv=modlist.getChildren();
1436 for(int i=0; i<pnv.size(); i++) {
1437 ParseNode modn=pnv.elementAt(i);
1438 if (isNode(modn,"public"))
1439 m.addModifier(Modifiers.PUBLIC);
1440 else if (isNode(modn,"protected"))
1441 m.addModifier(Modifiers.PROTECTED);
1442 else if (isNode(modn,"private"))
1443 m.addModifier(Modifiers.PRIVATE);
1444 else if (isNode(modn,"static"))
1445 m.addModifier(Modifiers.STATIC);
1446 else if (isNode(modn,"final"))
1447 m.addModifier(Modifiers.FINAL);
1448 else if (isNode(modn,"native"))
1449 m.addModifier(Modifiers.NATIVE);
1450 else if (isNode(modn,"synchronized"))
1451 m.addModifier(Modifiers.SYNCHRONIZED);
1452 else if (isNode(modn,"atomic"))
1453 m.addModifier(Modifiers.ATOMIC);
1454 else if (isNode(modn,"abstract"))
1455 m.addModifier(Modifiers.ABSTRACT);
1456 else if (isNode(modn,"volatile"))
1457 m.addModifier(Modifiers.VOLATILE);
1458 else if (isNode(modn,"transient"))
1459 m.addModifier(Modifiers.TRANSIENT);
1460 else if(isNode(modn,"annotation_list"))
1461 parseAnnotationList(modn,m);
1463 throw new Error("Unrecognized Modifier:"+modn.getLabel());}
1469 private void parseAnnotationList(ParseNode pn, Modifiers m) {
1470 ParseNodeVector pnv = pn.getChildren();
1471 for (int i = 0; i < pnv.size(); i++) {
1472 ParseNode body_list = pnv.elementAt(i);
1473 if (isNode(body_list, "annotation_body")) {
1474 ParseNode body_node = body_list.getFirstChild();
1475 if (isNode(body_node, "marker_annotation")) {
1476 m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
1477 } else if (isNode(body_node, "single_annotation")) {
1478 m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
1479 body_node.getChild("element_value").getTerminal()));
1480 } else if (isNode(body_node, "normal_annotation")) {
1481 throw new Error("Annotation with multiple data members is not supported yet.");
1487 private boolean isNode(ParseNode pn, String label) {
1488 if (pn.getLabel().equals(label))
1493 private static boolean isEmpty(ParseNode pn) {
1494 if (pn.getLabel().equals("empty"))
1500 private static boolean isEmpty(String s) {
1501 if (s.equals("empty"))
1507 /** Throw an exception if something is unexpected */
1508 private void check(ParseNode pn, String label) {
1510 throw new Error(pn+ "IE: Expected '" + label + "', got null");
1512 if (!pn.getLabel().equals(label)) {
1513 throw new Error(pn+ "IE: Expected '" + label + "', got '"+pn.getLabel()+"'");