This completes the barebones versions of inner class, we are now able to access field...
[IRC.git] / Robust / src / IR / Tree / BuildIR.java
1 package IR.Tree;
2 import IR.*;
3 import Util.Lattice;
4 import Util.Pair;
5
6 import java.io.File;
7 import java.util.*;
8 import java.io.*;
9 import java.lang.Throwable;
10 public class BuildIR {
11   State state;
12   private boolean isRunningRecursiveInnerClass;
13   private int m_taskexitnum;
14
15   public BuildIR(State state) {
16     this.state=state;
17     this.m_taskexitnum = 0;
18     this.isRunningRecursiveInnerClass = false;
19   }
20
21   public void buildtree(ParseNode pn, Set toanalyze, String sourcefile) {
22     parseFile(pn, toanalyze, sourcefile);
23
24     // numering the interfaces
25     int if_num = 0;
26     Iterator it_classes = state.getClassSymbolTable().getValueSet().iterator();
27     while(it_classes.hasNext()) {
28       ClassDescriptor cd = (ClassDescriptor)it_classes.next();
29       if(cd.isInterface()) {
30         cd.setInterfaceId(if_num++);
31       }
32     }
33   }
34
35   //This is all single imports and a subset of the
36   //multi imports that have been resolved.
37   ChainHashMap mandatoryImports;
38   //maps class names in file to full name
39   //Note may map a name to an ERROR.
40   ChainHashMap multiimports;
41   String packageName;
42
43   String currsourcefile;
44   Set analyzeset;
45
46   void pushChainMaps() {
47     mandatoryImports=mandatoryImports.makeChild();
48     multiimports=multiimports.makeChild();
49   }
50   
51   void popChainMaps() {
52     mandatoryImports=mandatoryImports.getParent();
53     multiimports=multiimports.getParent();
54   }
55
56   /** Parse the classes in this file */
57   public void parseFile(ParseNode pn, Set toanalyze, String sourcefile) {
58     mandatoryImports = new ChainHashMap();
59     multiimports = new ChainHashMap();
60     currsourcefile=sourcefile;
61     analyzeset=toanalyze;
62
63     if(state.JNI) {
64       //add java.lang as our default multi-import
65       this.addMultiImport(sourcefile, "java.lang", false);
66     }
67
68     ParseNode ipn = pn.getChild("imports").getChild("import_decls_list");
69     if ((ipn != null) && !state.MGC) {
70       ParseNodeVector pnv = ipn.getChildren();
71       for (int i = 0; i < pnv.size(); i++) {
72         ParseNode pnimport = pnv.elementAt(i);
73         NameDescriptor nd = parseName(pnimport.getChild("name"));
74         if (isNode(pnimport, "import_single")) {
75           if (!mandatoryImports.containsKey(nd.getIdentifier())) {
76             // map name to full name (includes package/directory
77             mandatoryImports.put(nd.getIdentifier(), nd.getPathFromRootToHere());
78           } else {
79             throw new Error("An ambiguous class "+ nd.getIdentifier() +" has been found. It is included for " +
80                             ((String)mandatoryImports.get(nd.getIdentifier())) + " and " +
81                             nd.getPathFromRootToHere());
82           }
83         } else {
84           addMultiImport(sourcefile, nd.getPathFromRootToHere(), false);
85         }
86       }
87     }
88
89     ParseNode ppn=pn.getChild("packages").getChild("package");
90     packageName = null;
91     if ((ppn!=null) && !state.MGC){
92       NameDescriptor nd = parseClassName(ppn.getChild("name"));
93       packageName = nd.getPathFromRootToHere();
94       //Trick -> import the package directory as a multi-import and it'll
95       //automatically recognize files in the same directory.
96       addMultiImport(sourcefile, packageName, true);
97     }
98
99     ParseNode tpn=pn.getChild("type_declaration_list");
100     if (tpn != null) {
101       ParseNodeVector pnv = tpn.getChildren();
102       for (int i = 0; i < pnv.size(); i++) {
103         ParseNode type_pn = pnv.elementAt(i);
104         if (isEmpty(type_pn)) /* Skip the semicolon */
105           continue;
106         if (isNode(type_pn, "class_declaration")) {
107           ClassDescriptor cn = parseTypeDecl(type_pn);
108           parseInitializers(cn);
109
110           // for inner classes/enum
111           HashSet tovisit = new HashSet();
112           Iterator it_icds = cn.getInnerClasses();
113           while (it_icds.hasNext()) {
114             tovisit.add(it_icds.next());
115           }
116
117           while (!tovisit.isEmpty()) {
118             ClassDescriptor cd = (ClassDescriptor) tovisit.iterator().next();
119             tovisit.remove(cd);
120             parseInitializers(cd);
121
122             Iterator it_ics = cd.getInnerClasses();
123             while (it_ics.hasNext()) {
124               tovisit.add(it_ics.next());
125             }
126           }
127         } else if (isNode(type_pn, "task_declaration")) {
128           TaskDescriptor td = parseTaskDecl(type_pn);
129           if (toanalyze != null)
130             toanalyze.add(td);
131           state.addTask(td);
132         } else if (isNode(type_pn, "interface_declaration")) {
133           // TODO add version for normal Java later
134           ClassDescriptor cn = parseInterfaceDecl(type_pn, null);
135         } else if (isNode(type_pn, "enum_declaration")) {
136           // TODO add version for normal Java later
137           ClassDescriptor cn = parseEnumDecl(null, type_pn);
138
139         } else if(isNode(type_pn,"annotation_type_declaration")) {
140           ClassDescriptor cn=parseAnnotationTypeDecl(type_pn);
141         } else {
142           throw new Error(type_pn.getLabel());
143         }
144       }
145     }
146   }
147
148
149   //This kind of breaks away from tradition a little bit by doing the file checks here
150   // instead of in Semantic check, but doing it here is easier because we have a mapping early on
151   // if I wait until semantic check, I have to change ALL the type descriptors to match the new
152   // mapping and that's both ugly and tedious.
153   private void addMultiImport(String currentSource, String importPath, boolean isPackageDirectory) {
154     boolean found = false;
155     for (int j = 0; j < state.classpath.size(); j++) {
156       String path = (String) state.classpath.get(j);
157       File folder = new File(path, importPath.replace('.', '/'));
158       if (folder.exists()) {
159         found = true;
160         for (String file : folder.list()) {
161           // if the file is of type *.java add to multiImport list.
162           if (file.lastIndexOf('.') != -1 && file.substring(file.lastIndexOf('.')).equalsIgnoreCase(".java")) {
163             String classname = file.substring(0, file.length() - 5);
164             // single imports have precedence over multi-imports
165             if (!mandatoryImports.containsKey(classname)) {
166               //package files have precedence over multi-imports.
167               if (multiimports.containsKey(classname)  && !isPackageDirectory) {
168                 // put error in for later, in case we try to import
169                 multiimports.put(classname, new Error("Error: class " + classname + " is defined more than once in a multi-import in " + currentSource));
170               } else {
171                 multiimports.put(classname, importPath + "." + classname);
172               }
173             }
174           }
175         }
176       }
177     }
178
179     if(!found) {
180       throw new Error("Import package " + importPath + " in  " + currentSource
181                       + " cannot be resolved.");
182     }
183   }
184
185   public void parseInitializers(ClassDescriptor cn) {
186     Vector fv=cn.getFieldVec();
187     int pos = 0;
188     for(int i=0; i<fv.size(); i++) {
189       FieldDescriptor fd=(FieldDescriptor)fv.get(i);
190       if(fd.getExpressionNode()!=null) {
191         Iterator methodit = cn.getMethods();
192         while(methodit.hasNext()) {
193           MethodDescriptor currmd=(MethodDescriptor)methodit.next();
194           if(currmd.isConstructor()) {
195             BlockNode bn=state.getMethodBody(currmd);
196             NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
197             AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
198             bn.addBlockStatementAt(new BlockExpressionNode(an), pos);
199           }
200         }
201         pos++;
202       }
203     }
204   }
205   
206   private ClassDescriptor parseEnumDecl(ClassDescriptor cn, ParseNode pn) {    
207     String basename=pn.getChild("name").getTerminal();
208     String classname=(cn!=null)?cn.getClassName()+"$"+basename:basename;
209     ClassDescriptor ecd=new ClassDescriptor(cn!=null?cn.getPackage():null, classname, false);
210     
211     if (cn!=null) {
212       if (packageName==null)
213         cn.getSingleImportMappings().put(basename,classname);
214       else
215         cn.getSingleImportMappings().put(basename,packageName+"."+classname);
216     }
217
218     pushChainMaps();
219     ecd.setImports(mandatoryImports, multiimports);
220     ecd.setAsEnum();
221     if(cn != null) {
222       ecd.setSurroundingClass(cn.getSymbol());
223       ecd.setSurrounding(cn);
224       cn.addEnum(ecd);
225     }
226     if (!(ecd.getSymbol().equals(TypeUtil.ObjectClass)||
227           ecd.getSymbol().equals(TypeUtil.TagClass))) {
228       ecd.setSuper(TypeUtil.ObjectClass);
229     }
230     ecd.setModifiers(parseModifiersList(pn.getChild("modifiers")));
231     parseEnumBody(ecd, pn.getChild("enumbody"));
232
233     if (analyzeset != null)
234       analyzeset.add(ecd);
235     ecd.setSourceFileName(currsourcefile);
236     state.addClass(ecd);
237
238     popChainMaps();
239     return ecd;
240   }
241
242   private void parseEnumBody(ClassDescriptor cn, ParseNode pn) {
243     ParseNode decls=pn.getChild("enum_constants_list");
244     if (decls!=null) {
245       ParseNodeVector pnv=decls.getChildren();
246       for(int i=0; i<pnv.size(); i++) {
247         ParseNode decl=pnv.elementAt(i);
248         if (isNode(decl,"enum_constant")) {
249           parseEnumConstant(cn,decl);
250         } else throw new Error();
251       }
252     }
253   }
254
255   private void parseEnumConstant(ClassDescriptor cn, ParseNode pn) {
256     cn.addEnumConstant(pn.getChild("name").getTerminal());
257   }
258
259   private ClassDescriptor parseAnnotationTypeDecl(ParseNode pn) {
260     ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal(), true);
261     pushChainMaps();
262     cn.setImports(mandatoryImports, multiimports);
263     ParseNode modifiers=pn.getChild("modifiers");
264     if(modifiers!=null) {
265       cn.setModifiers(parseModifiersList(modifiers));
266     }
267     parseAnnotationTypeBody(cn,pn.getChild("body"));
268     popChainMaps();
269
270     if (analyzeset != null)
271       analyzeset.add(cn);
272     cn.setSourceFileName(currsourcefile);
273     state.addClass(cn);
274
275     return cn;
276   }
277
278   private void parseAnnotationTypeBody(ClassDescriptor cn, ParseNode pn) {
279     ParseNode list_node=pn.getChild("annotation_type_element_list");
280     if(list_node!=null) {
281       ParseNodeVector pnv = list_node.getChildren();
282       for (int i = 0; i < pnv.size(); i++) {
283         ParseNode element_node = pnv.elementAt(i);
284         if (isNode(element_node, "annotation_type_element_declaration")) {
285           ParseNodeVector elementProps = element_node.getChildren();
286           String identifier=null;
287           TypeDescriptor type=null;
288           Modifiers modifiers=new Modifiers();
289           for(int eidx=0; eidx<elementProps.size(); eidx++) {
290             ParseNode prop_node=elementProps.elementAt(eidx);
291             if(isNode(prop_node,"name")) {
292               identifier=prop_node.getTerminal();
293             } else if(isNode(prop_node,"type")) {
294               type=parseTypeDescriptor(prop_node);
295             } else if(isNode(prop_node,"modifier")) {
296               modifiers=parseModifiersList(prop_node);
297             }
298           }
299           cn.addField(new FieldDescriptor(modifiers, type, identifier, null, false));
300         }
301       }
302     }
303   }
304
305   public ClassDescriptor parseInterfaceDecl(ParseNode pn, ClassDescriptor outerclass) {
306     String basename=pn.getChild("name").getTerminal();
307     String classname=((outerclass==null)?"":(outerclass.getClassName()+"$"))+basename;
308     if (outerclass!=null) {
309       if (packageName==null)
310         outerclass.getSingleImportMappings().put(basename,classname);
311       else
312         outerclass.getSingleImportMappings().put(basename,packageName+"."+classname);
313     }
314     ClassDescriptor cn= new ClassDescriptor(packageName, classname, true);
315
316     pushChainMaps();
317     cn.setImports(mandatoryImports, multiimports);
318     //cn.setAsInterface();
319     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
320       /* parse inherited interface name */
321       ParseNode snlist=pn.getChild("superIF").getChild("extend_interface_list");
322       ParseNodeVector pnv=snlist.getChildren();
323       for(int i=0; i<pnv.size(); i++) {
324         ParseNode decl=pnv.elementAt(i);
325         if (isNode(decl,"type")) {
326           NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
327           cn.addSuperInterface(nd.toString());
328         } else if (isNode(decl, "interface_declaration")) {
329           ClassDescriptor innercn = parseInterfaceDecl(decl, cn);
330         } else throw new Error();
331       }
332     }
333     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
334     parseInterfaceBody(cn, pn.getChild("interfacebody"));
335     if (analyzeset != null)
336       analyzeset.add(cn);
337     cn.setSourceFileName(currsourcefile);
338     state.addClass(cn);
339     popChainMaps();
340     return cn;
341   }
342
343   private void parseInterfaceBody(ClassDescriptor cn, ParseNode pn) {
344     assert(cn.isInterface());
345     ParseNode decls=pn.getChild("interface_member_declaration_list");
346     if (decls!=null) {
347       ParseNodeVector pnv=decls.getChildren();
348       for(int i=0; i<pnv.size(); i++) {
349         ParseNode decl=pnv.elementAt(i);
350         if (isNode(decl,"constant")) {
351           parseInterfaceConstant(cn,decl);
352         } else if (isNode(decl,"method")) {
353           parseInterfaceMethod(cn,decl.getChild("method_declaration"));
354         } else if (isNode(decl, "interface_declaration")) {
355           parseInterfaceDecl(decl, cn);
356         } else throw new Error(decl.PPrint(2, true));
357       }
358     }
359   }
360
361
362
363   private void parseInterfaceConstant(ClassDescriptor cn, ParseNode pn) {
364     if (pn!=null) {
365       parseFieldDecl(cn,pn.getChild("field_declaration"));
366       return;
367     }
368     throw new Error();
369   }
370
371   private void parseInterfaceMethod(ClassDescriptor cn, ParseNode pn) {
372     ParseNode headern=pn.getChild("header");
373     ParseNode bodyn=pn.getChild("body");
374     MethodDescriptor md=parseMethodHeader(headern.getChild("method_header"));
375     md.getModifiers().addModifier(Modifiers.PUBLIC);
376     md.getModifiers().addModifier(Modifiers.ABSTRACT);
377     try {
378       BlockNode bn=parseBlock(bodyn);
379       cn.addMethod(md);
380       state.addTreeCode(md,bn);
381     } catch (Exception e) {
382       System.out.println("Error with method:"+md.getSymbol());
383       e.printStackTrace();
384       throw new Error();
385     } catch (Error e) {
386       System.out.println("Error with method:"+md.getSymbol());
387       e.printStackTrace();
388       throw new Error();
389     }
390   }
391
392   public TaskDescriptor parseTaskDecl(ParseNode pn) {
393     TaskDescriptor td=new TaskDescriptor(pn.getChild("name").getTerminal());
394     ParseNode bodyn=pn.getChild("body");
395     BlockNode bn=parseBlock(bodyn);
396     parseParameterList(td, pn);
397     state.addTreeCode(td,bn);
398     if (pn.getChild("flag_effects_list")!=null)
399       td.addFlagEffects(parseFlags(pn.getChild("flag_effects_list")));
400     return td;
401   }
402
403   public Vector parseFlags(ParseNode pn) {
404     Vector vfe=new Vector();
405     ParseNodeVector pnv=pn.getChildren();
406     for(int i=0; i<pnv.size(); i++) {
407       ParseNode fn=pnv.elementAt(i);
408       FlagEffects fe=parseFlagEffects(fn);
409       vfe.add(fe);
410     }
411     return vfe;
412   }
413
414   public FlagEffects parseFlagEffects(ParseNode pn) {
415     if (isNode(pn,"flag_effect")) {
416       String flagname=pn.getChild("name").getTerminal();
417       FlagEffects fe=new FlagEffects(flagname);
418       if (pn.getChild("flag_list")!=null)
419         parseFlagEffect(fe, pn.getChild("flag_list"));
420       if (pn.getChild("tag_list")!=null)
421         parseTagEffect(fe, pn.getChild("tag_list"));
422       return fe;
423     } else throw new Error();
424   }
425
426   public void parseTagEffect(FlagEffects fes, ParseNode pn) {
427     ParseNodeVector pnv=pn.getChildren();
428     for(int i=0; i<pnv.size(); i++) {
429       ParseNode pn2=pnv.elementAt(i);
430       boolean status=true;
431       if (isNode(pn2,"not")) {
432         status=false;
433         pn2=pn2.getChild("name");
434       }
435       String name=pn2.getTerminal();
436       fes.addTagEffect(new TagEffect(name,status));
437     }
438   }
439
440   public void parseFlagEffect(FlagEffects fes, ParseNode pn) {
441     ParseNodeVector pnv=pn.getChildren();
442     for(int i=0; i<pnv.size(); i++) {
443       ParseNode pn2=pnv.elementAt(i);
444       boolean status=true;
445       if (isNode(pn2,"not")) {
446         status=false;
447         pn2=pn2.getChild("name");
448       }
449       String name=pn2.getTerminal();
450       fes.addEffect(new FlagEffect(name,status));
451     }
452   }
453
454   public FlagExpressionNode parseFlagExpression(ParseNode pn) {
455     if (isNode(pn,"or")) {
456       ParseNodeVector pnv=pn.getChildren();
457       ParseNode left=pnv.elementAt(0);
458       ParseNode right=pnv.elementAt(1);
459       return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_OR));
460     } else if (isNode(pn,"and")) {
461       ParseNodeVector pnv=pn.getChildren();
462       ParseNode left=pnv.elementAt(0);
463       ParseNode right=pnv.elementAt(1);
464       return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_AND));
465     } else if (isNode(pn, "not")) {
466       ParseNodeVector pnv=pn.getChildren();
467       ParseNode left=pnv.elementAt(0);
468       return new FlagOpNode(parseFlagExpression(left), new Operation(Operation.LOGIC_NOT));
469
470     } else if (isNode(pn,"name")) {
471       return new FlagNode(pn.getTerminal());
472     } else {
473       throw new Error();
474     }
475   }
476
477   public Vector parseChecks(ParseNode pn) {
478     Vector ccs=new Vector();
479     ParseNodeVector pnv=pn.getChildren();
480     for(int i=0; i<pnv.size(); i++) {
481       ParseNode fn=pnv.elementAt(i);
482       ConstraintCheck cc=parseConstraintCheck(fn);
483       ccs.add(cc);
484     }
485     return ccs;
486   }
487
488   public ConstraintCheck parseConstraintCheck(ParseNode pn) {
489     if (isNode(pn,"cons_check")) {
490       String specname=pn.getChild("name").getChild("identifier").getTerminal();
491       Vector[] args=parseConsArgumentList(pn);
492       ConstraintCheck cc=new ConstraintCheck(specname);
493       for(int i=0; i<args[0].size(); i++) {
494         cc.addVariable((String)args[0].get(i));
495         cc.addArgument((ExpressionNode)args[1].get(i));
496       }
497       return cc;
498     } else throw new Error();
499   }
500
501   public void parseParameterList(TaskDescriptor td, ParseNode pn) {
502
503     boolean optional;
504     ParseNode paramlist=pn.getChild("task_parameter_list");
505     if (paramlist==null)
506       return;
507     ParseNodeVector pnv=paramlist.getChildren();
508     for(int i=0; i<pnv.size(); i++) {
509       ParseNode paramn=pnv.elementAt(i);
510       if(paramn.getChild("optional")!=null) {
511         optional = true;
512         paramn = paramn.getChild("optional").getFirstChild();
513         System.out.println("OPTIONAL FOUND!!!!!!!");
514       } else { optional = false;
515                System.out.println("NOT OPTIONAL"); }
516
517       TypeDescriptor type=parseTypeDescriptor(paramn);
518
519       String paramname=paramn.getChild("single").getTerminal();
520       FlagExpressionNode fen=null;
521       if (paramn.getChild("flag")!=null)
522         fen=parseFlagExpression(paramn.getChild("flag").getFirstChild());
523
524       ParseNode tagnode=paramn.getChild("tag");
525
526       TagExpressionList tel=null;
527       if (tagnode!=null) {
528         tel=parseTagExpressionList(tagnode);
529       }
530
531       td.addParameter(type,paramname,fen, tel, optional);
532     }
533   }
534
535   public TagExpressionList parseTagExpressionList(ParseNode pn) {
536     //BUG FIX: change pn.getChildren() to pn.getChild("tag_expression_list").getChildren()
537     //To test, feed in any input program that uses tags
538     ParseNodeVector pnv=pn.getChild("tag_expression_list").getChildren();
539     TagExpressionList tel=new TagExpressionList();
540     for(int i=0; i<pnv.size(); i++) {
541       ParseNode tn=pnv.elementAt(i);
542       String type=tn.getChild("type").getTerminal();
543       String name=tn.getChild("single").getTerminal();
544       tel.addTag(type, name);
545     }
546     return tel;
547   }
548
549   public ClassDescriptor parseTypeDecl(ParseNode pn) {
550     ClassDescriptor cn=new ClassDescriptor(packageName, pn.getChild("name").getTerminal(), false);
551     pushChainMaps();
552     cn.setImports(mandatoryImports, multiimports);
553     if (!isEmpty(pn.getChild("super").getTerminal())) {
554       /* parse superclass name */
555       ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name");
556       NameDescriptor nd=parseClassName(snn);
557       cn.setSuper(nd.toString());
558     } else {
559       if (!(cn.getSymbol().equals(TypeUtil.ObjectClass)||
560             cn.getSymbol().equals(TypeUtil.TagClass)))
561         cn.setSuper(TypeUtil.ObjectClass);
562     }
563     // check inherited interfaces
564     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
565       /* parse inherited interface name */
566       ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
567       ParseNodeVector pnv=snlist.getChildren();
568       for(int i=0; i<pnv.size(); i++) {
569         ParseNode decl=pnv.elementAt(i);
570         if (isNode(decl,"type")) {
571           NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
572           cn.addSuperInterface(nd.toString());
573         }
574       }
575     }
576     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
577     parseClassBody(cn, pn.getChild("classbody"));
578
579     boolean hasConstructor = false;
580     for(Iterator method_it=cn.getMethods(); method_it.hasNext(); ) {
581       MethodDescriptor md=(MethodDescriptor)method_it.next();
582       hasConstructor |= md.isConstructor();
583     }
584     if((!hasConstructor) && (!cn.isEnum())) {
585       // add a default constructor for this class
586       MethodDescriptor md = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC),
587                                                  cn.getSymbol(), false);
588       BlockNode bn=new BlockNode();
589       state.addTreeCode(md,bn);
590       md.setDefaultConstructor();
591       cn.addMethod(md);
592     }
593
594
595     popChainMaps();
596
597     cn.setSourceFileName(currsourcefile);
598
599
600     
601     if (analyzeset != null)
602       analyzeset.add(cn);
603     state.addClass(cn);
604 //create this$n representing a final reference to the next surrounding class. each inner class should have whatever inner class
605 //pointers the surrounding class has + a pointer to the surrounding class.
606    if( true )
607    {
608         this.isRunningRecursiveInnerClass = true; //fOR dEBUGGING PURPOSES IN ORDER TO DUMP STRINGS WHILE IN THIS CODE PATH
609         addOuterClassReferences( cn, 0 );
610         addOuterClassParam( cn, 0 );
611         this.isRunningRecursiveInnerClass = false;
612     }
613     return cn;
614   }
615
616 private void initializeOuterMember( MethodDescriptor md, String fieldName, String formalParameter ) {
617          BlockNode obn = state.getMethodBody(md);
618          NameNode nn=new NameNode( new NameDescriptor( fieldName ) );
619          NameNode fn = new NameNode ( new NameDescriptor( formalParameter ) );
620           //nn.setNumLine(en.getNumLine())
621          AssignmentNode an=new AssignmentNode(nn,fn,new AssignOperation(1));
622          //an.setNumLine(pn.getLine());
623          obn.addFirstBlockStatement(new BlockExpressionNode(an));
624         // System.out.print( "The code inserted is : " + obn.printNode( 0 ) + "\n" );
625          state.addTreeCode(md, obn);
626 }
627
628 private void addOuterClassParam( ClassDescriptor cn, int depth )
629 {
630         Iterator nullCheckItr = cn.getInnerClasses();
631         if( false == nullCheckItr.hasNext() )
632                 return;
633
634         //create a typedescriptor of type cn
635         TypeDescriptor theTypeDesc = new TypeDescriptor( cn );
636         
637         for(Iterator it=cn.getInnerClasses(); it.hasNext(); ) {
638                 ClassDescriptor icd=(ClassDescriptor)it.next();
639                 
640                 //iterate over all ctors of I.Cs and add a new param
641                 for(Iterator method_it=icd.getMethods(); method_it.hasNext(); ) {
642                          MethodDescriptor md=(MethodDescriptor)method_it.next();
643                          if( md.isConstructor() ){
644                                 md.addParameter( theTypeDesc, "surrounding$" + String.valueOf(depth) ); 
645                                 initializeOuterMember( md, "this$" + String.valueOf( depth ), "surrounding$" + String.valueOf(depth) );
646                                 //System.out.println( "The added param is " + md.toString() + "\n" );           
647                         }
648                 }
649                 addOuterClassParam( icd, depth + 1 );
650                 
651         }
652         
653 }
654 private void addOuterClassReferences( ClassDescriptor cn, int depth )
655 {
656         //SYMBOLTABLE does not have a length or empty method, hence could not define a hasInnerClasses method in classDescriptor
657         Iterator nullCheckItr = cn.getInnerClasses();
658         if( false == nullCheckItr.hasNext() )
659                 return;
660
661         String tempCopy = cn.getClassName();
662         //MESSY HACK FOLLOWS
663         int i = 0;
664
665         ParseNode theNode = new ParseNode( "field_declaration" );
666         theNode.addChild("modifier").addChild( new ParseNode( "modifier_list" ) ).addChild("final");
667         ParseNode theTypeNode = new ParseNode("type");
668         ParseNode tempChildNode = theTypeNode.addChild("class").addChild( "name" );
669                 //tempChildNode.addChild("base").addChild( new ParseNode("empty") );
670         tempChildNode.addChild("identifier").addChild ( tempCopy );
671         theNode.addChild("type").addChild( theTypeNode );
672         ParseNode variableDeclaratorID = new ParseNode("single");
673         String theStr = "this$" + String.valueOf( depth );
674         variableDeclaratorID.addChild( theStr );
675         ParseNode variableDeclarator = new ParseNode( "variable_declarator" );
676         variableDeclarator.addChild( variableDeclaratorID );
677         ParseNode variableDeclaratorList = new ParseNode("variable_declarators_list");
678         variableDeclaratorList.addChild( variableDeclarator );
679         theNode.addChild("variables").addChild( variableDeclaratorList );
680
681         for(Iterator it=cn.getInnerClasses(); it.hasNext(); ) {
682                 ClassDescriptor icd=(ClassDescriptor)it.next();
683                 parseFieldDecl( icd, theNode );         
684                 /*if( true ) {
685                         SymbolTable fieldTable = icd.getFieldTable();
686                         //System.out.println( fieldTable.toString() );
687                 }*/
688                 icd.setInnerDepth( depth );
689                 addOuterClassReferences( icd, depth + 1 );      
690         }
691 }
692
693   private void parseClassBody(ClassDescriptor cn, ParseNode pn) {
694     ParseNode decls=pn.getChild("class_body_declaration_list");
695     if (decls!=null) {
696       ParseNodeVector pnv=decls.getChildren();
697       for(int i=0; i<pnv.size(); i++) {
698         ParseNode decl=pnv.elementAt(i);
699         if (isNode(decl,"member")) {
700           parseClassMember(cn,decl);
701         } else if (isNode(decl,"constructor")) {
702           parseConstructorDecl(cn,decl.getChild("constructor_declaration"));
703         } else if (isNode(decl, "static_block")) {
704           parseStaticBlockDecl(cn, decl.getChild("static_block_declaration"));
705         } else if (isNode(decl,"block")) {
706         } else throw new Error();
707       }
708     }
709   }
710
711   private void parseClassMember(ClassDescriptor cn, ParseNode pn) {
712     ParseNode fieldnode=pn.getChild("field");
713     if (fieldnode!=null) {
714       //System.out.println( pn.PPrint( 0, true ) );
715       parseFieldDecl(cn,fieldnode.getChild("field_declaration"));
716       return;
717     }
718     ParseNode methodnode=pn.getChild("method");
719     if (methodnode!=null) {
720       parseMethodDecl(cn,methodnode.getChild("method_declaration"));
721       return;
722     }
723     ParseNode innerclassnode=pn.getChild("inner_class_declaration");
724     if (innerclassnode!=null) {
725       parseInnerClassDecl(cn,innerclassnode);
726       return;
727     }
728      ParseNode innerinterfacenode=pn.getChild("interface_declaration");
729     if (innerinterfacenode!=null) {
730       parseInterfaceDecl(innerinterfacenode, cn);
731       return;
732     }
733
734     ParseNode enumnode=pn.getChild("enum_declaration");
735     if (enumnode!=null) {
736       ClassDescriptor ecn=parseEnumDecl(cn,enumnode);
737       return;
738     }
739     ParseNode flagnode=pn.getChild("flag");
740     if (flagnode!=null) {
741       parseFlagDecl(cn, flagnode.getChild("flag_declaration"));
742       return;
743     }
744     // in case there are empty node
745     ParseNode emptynode=pn.getChild("empty");
746     if(emptynode != null) {
747       return;
748     }
749     System.out.println("Unrecognized node:"+pn.PPrint(2,true));
750     throw new Error();
751   }
752
753 //10/9/2011 changed this function to enable creation of default constructor for inner classes.
754 //the change was refactoring this function with the corresponding version for normal classes. sganapat
755   private ClassDescriptor parseInnerClassDecl(ClassDescriptor cn, ParseNode pn) {
756     String basename=pn.getChild("name").getTerminal();
757     String classname=cn.getClassName()+"$"+basename;
758
759     if (cn.getPackage()==null)
760       cn.getSingleImportMappings().put(basename,classname);
761     else
762       cn.getSingleImportMappings().put(basename,cn.getPackage()+"."+classname);
763     
764     ClassDescriptor icn=new ClassDescriptor(cn.getPackage(), classname, false);
765     pushChainMaps();
766     icn.setImports(mandatoryImports, multiimports);
767     icn.setAsInnerClass();
768     icn.setSurroundingClass(cn.getSymbol());
769     icn.setSurrounding(cn);
770     cn.addInnerClass(icn);
771
772      if (!isEmpty(pn.getChild("super").getTerminal())) {
773       /* parse superclass name */
774       ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name");
775       NameDescriptor nd=parseClassName(snn);
776       icn.setSuper(nd.toString());
777     } else {
778       if (!(icn.getSymbol().equals(TypeUtil.ObjectClass)||
779             icn.getSymbol().equals(TypeUtil.TagClass)))
780         icn.setSuper(TypeUtil.ObjectClass);
781     }
782     // check inherited interfaces
783     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
784       /* parse inherited interface name */
785       ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
786       ParseNodeVector pnv=snlist.getChildren();
787       for(int i=0; i<pnv.size(); i++) {
788         ParseNode decl=pnv.elementAt(i);
789         if (isNode(decl,"type")) {
790           NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
791           icn.addSuperInterface(nd.toString());
792         }
793       }
794     }
795     icn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
796
797     parseClassBody(icn, pn.getChild("classbody"));
798
799     boolean hasConstructor = false;
800     for(Iterator method_it=icn.getMethods(); method_it.hasNext(); ) {
801       MethodDescriptor md=(MethodDescriptor)method_it.next();
802       hasConstructor |= md.isConstructor();
803     }
804 //sganapat adding change to allow proper construction of inner class objects
805     if((!hasConstructor) && (!icn.isEnum())) {
806       // add a default constructor for this class
807       MethodDescriptor md = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC),
808                                                  icn.getSymbol(), false);
809       BlockNode bn=new BlockNode();
810       state.addTreeCode(md,bn);
811       md.setDefaultConstructor();
812       icn.addMethod(md);
813    }
814     popChainMaps();
815
816      if (analyzeset != null)
817       analyzeset.add(icn);
818     icn.setSourceFileName(currsourcefile);
819     state.addClass(icn);
820
821     return icn;
822   }
823
824   private TypeDescriptor parseTypeDescriptor(ParseNode pn) {
825     ParseNode tn=pn.getChild("type");
826     String type_st=tn.getTerminal();
827     if(type_st.equals("byte")) {
828       return state.getTypeDescriptor(TypeDescriptor.BYTE);
829     } else if(type_st.equals("short")) {
830       return state.getTypeDescriptor(TypeDescriptor.SHORT);
831     } else if(type_st.equals("boolean")) {
832       return state.getTypeDescriptor(TypeDescriptor.BOOLEAN);
833     } else if(type_st.equals("int")) {
834       return state.getTypeDescriptor(TypeDescriptor.INT);
835     } else if(type_st.equals("long")) {
836       return state.getTypeDescriptor(TypeDescriptor.LONG);
837     } else if(type_st.equals("char")) {
838       return state.getTypeDescriptor(TypeDescriptor.CHAR);
839     } else if(type_st.equals("float")) {
840       return state.getTypeDescriptor(TypeDescriptor.FLOAT);
841     } else if(type_st.equals("double")) {
842       return state.getTypeDescriptor(TypeDescriptor.DOUBLE);
843     } else if(type_st.equals("class")) {
844       ParseNode nn=tn.getChild("class");
845       return state.getTypeDescriptor(parseClassName(nn.getChild("name")));
846     } else if(type_st.equals("array")) {
847       ParseNode nn=tn.getChild("array");
848       TypeDescriptor td=parseTypeDescriptor(nn.getChild("basetype"));
849       Integer numdims=(Integer)nn.getChild("dims").getLiteral();
850       for(int i=0; i<numdims.intValue(); i++)
851         td=td.makeArray(state);
852       return td;
853     } else {
854       System.out.println(pn.PPrint(2, true));
855       throw new Error();
856     }
857   }
858
859   //Needed to separate out top level call since if a base exists,
860   //we do not want to apply our resolveName function (i.e. deal with imports)
861   //otherwise, if base == null, we do just want to resolve name.
862   private NameDescriptor parseClassName(ParseNode nn) {
863     
864
865     ParseNode base=nn.getChild("base");
866     ParseNode id=nn.getChild("identifier");
867     String classname = id.getTerminal();
868     if (base==null) {
869       return new NameDescriptor(resolveName(classname));
870     }
871     return new NameDescriptor(parseClassNameRecursive(base.getChild("name")),classname);
872   }
873
874   private NameDescriptor parseClassNameRecursive(ParseNode nn) {
875     ParseNode base=nn.getChild("base");
876     ParseNode id=nn.getChild("identifier");
877     String classname = id.getTerminal();
878     if (base==null) {
879       return new NameDescriptor(classname);
880     }
881     return new NameDescriptor(parseClassNameRecursive(base.getChild("name")),classname);
882   }
883
884   //This will get the mapping of a terminal class name
885   //to a canonical classname (with imports/package locations in them)
886   private String resolveName(String terminal) {
887     
888     if(mandatoryImports.containsKey(terminal)) {
889       return (String) mandatoryImports.get(terminal);
890     } else {
891       if(multiimports.containsKey(terminal)) {
892         //Test for error
893         Object o = multiimports.get(terminal);
894         if(o instanceof Error) {
895           throw new Error("Class " + terminal + " is ambiguous. Cause: more than 1 package import contain the same class.");
896         } else {
897           //At this point, if we found a unique class
898           //we can treat it as a single, mandatory import.
899           mandatoryImports.put(terminal, o);
900           return (String) o;
901         }
902       }
903     }
904
905     return terminal;
906   }
907
908   //only function difference between this and parseName() is that this
909   //does not look for a import mapping.
910   private NameDescriptor parseName(ParseNode nn) {
911     ParseNode base=nn.getChild("base");
912     ParseNode id=nn.getChild("identifier");
913     if (base==null) {
914       return new NameDescriptor(id.getTerminal());
915     }
916     return new NameDescriptor(parseName(base.getChild("name")),id.getTerminal());
917   }
918
919   private void parseFlagDecl(ClassDescriptor cn,ParseNode pn) {
920     String name=pn.getChild("name").getTerminal();
921     FlagDescriptor flag=new FlagDescriptor(name);
922     if (pn.getChild("external")!=null)
923       flag.makeExternal();
924     cn.addFlag(flag);
925   }
926
927   private void parseFieldDecl(ClassDescriptor cn,ParseNode pn) {
928     ParseNode mn=pn.getChild("modifier");
929     Modifiers m=parseModifiersList(mn);
930     if(cn.isInterface()) {
931       // TODO add version for normal Java later
932       // Can only be PUBLIC or STATIC or FINAL
933       if((m.isAbstract()) || (m.isAtomic()) || (m.isNative())
934          || (m.isSynchronized())) {
935         throw new Error("Error: field in Interface " + cn.getSymbol() + "can only be PUBLIC or STATIC or FINAL");
936       }
937       m.addModifier(Modifiers.PUBLIC);
938       m.addModifier(Modifiers.STATIC);
939       m.addModifier(Modifiers.FINAL);
940     }
941
942     ParseNode tn=pn.getChild("type");
943     TypeDescriptor t=parseTypeDescriptor(tn);
944     ParseNode vn=pn.getChild("variables").getChild("variable_declarators_list");
945     ParseNodeVector pnv=vn.getChildren();
946     boolean isglobal=pn.getChild("global")!=null;
947
948     for(int i=0; i<pnv.size(); i++) {
949       ParseNode vardecl=pnv.elementAt(i);
950       ParseNode tmp=vardecl;
951       TypeDescriptor arrayt=t;
952        if( this.isRunningRecursiveInnerClass && false )
953         {       
954                 System.out.println( "the length of the list is " + String.valueOf( pnv.size() ) );
955                 System.out.println( "\n the parse node is \n" + tmp.PPrint( 0, true ) );
956         }
957       while (tmp.getChild("single")==null) {
958         arrayt=arrayt.makeArray(state);
959         tmp=tmp.getChild("array");
960       }
961       String identifier=tmp.getChild("single").getTerminal();
962       ParseNode epn=vardecl.getChild("initializer");
963
964       ExpressionNode en=null;
965       
966       if (epn!=null) {
967         en=parseExpression(epn.getFirstChild());
968         en.setNumLine(epn.getFirstChild().getLine());
969         if(m.isStatic()) {
970           // for static field, the initializer should be considered as a
971           // static block
972           boolean isfirst = false;
973           MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
974           if(md == null) {
975             // the first static block for this class
976             Modifiers m_i=new Modifiers();
977             m_i.addModifier(Modifiers.STATIC);
978             md = new MethodDescriptor(m_i, "staticblocks", false);
979             md.setAsStaticBlock();
980             isfirst = true;
981           }
982           if(isfirst) {
983             cn.addMethod(md);
984           }
985           cn.incStaticBlocks();
986           BlockNode bn=new BlockNode();
987           NameNode nn=new NameNode(new NameDescriptor(identifier));
988           nn.setNumLine(en.getNumLine());
989           AssignmentNode an=new AssignmentNode(nn,en,new AssignOperation(1));
990           an.setNumLine(pn.getLine());
991           bn.addBlockStatement(new BlockExpressionNode(an));
992           if(isfirst) {
993             state.addTreeCode(md,bn);
994           } else {
995             BlockNode obn = state.getMethodBody(md);
996             for(int ii = 0; ii < bn.size(); ii++) {
997               BlockStatementNode bsn = bn.get(ii);
998               obn.addBlockStatement(bsn);
999             }
1000             state.addTreeCode(md, obn);
1001             bn = null;
1002           }
1003           en = null;
1004         }
1005       }
1006
1007       cn.addField(new FieldDescriptor(m, arrayt, identifier, en, isglobal));
1008       assignAnnotationsToType(m,arrayt);
1009     }
1010   }
1011
1012   private void assignAnnotationsToType(Modifiers modifiers, TypeDescriptor type) {
1013     Vector<AnnotationDescriptor> annotations=modifiers.getAnnotations();
1014     for(int i=0; i<annotations.size(); i++) {
1015       // it only supports a marker annotation
1016       AnnotationDescriptor an=annotations.elementAt(i);
1017       type.addAnnotationMarker(an);
1018     }
1019   }
1020
1021   int innerCount=0;
1022
1023   private ExpressionNode parseExpression(ParseNode pn) {
1024     if (isNode(pn,"assignment"))
1025         {
1026           //System.out.println( "parsing a field decl in my class that has assignment in initialization " + pn.PPrint( 0, true ) + "\n");
1027       return parseAssignmentExpression(pn);
1028         }
1029     else if (isNode(pn,"logical_or")||isNode(pn,"logical_and")||
1030              isNode(pn,"bitwise_or")||isNode(pn,"bitwise_xor")||
1031              isNode(pn,"bitwise_and")||isNode(pn,"equal")||
1032              isNode(pn,"not_equal")||isNode(pn,"comp_lt")||
1033              isNode(pn,"comp_lte")||isNode(pn,"comp_gt")||
1034              isNode(pn,"comp_gte")||isNode(pn,"leftshift")||
1035              isNode(pn,"rightshift")||isNode(pn,"sub")||
1036              isNode(pn,"urightshift")||isNode(pn,"sub")||
1037              isNode(pn,"add")||isNode(pn,"mult")||
1038              isNode(pn,"div")||isNode(pn,"mod")) {
1039       ParseNodeVector pnv=pn.getChildren();
1040       ParseNode left=pnv.elementAt(0);
1041       ParseNode right=pnv.elementAt(1);
1042       Operation op=new Operation(pn.getLabel());
1043       OpNode on=new OpNode(parseExpression(left),parseExpression(right),op);
1044       on.setNumLine(pn.getLine());
1045       return on;
1046     } else if (isNode(pn,"unaryplus")||
1047                isNode(pn,"unaryminus")||
1048                isNode(pn,"not")||
1049                isNode(pn,"comp")) {
1050       ParseNode left=pn.getFirstChild();
1051       Operation op=new Operation(pn.getLabel());
1052       OpNode on=new OpNode(parseExpression(left),op);
1053       on.setNumLine(pn.getLine());
1054       return on;
1055     } else if (isNode(pn,"postinc")||
1056                isNode(pn,"postdec")) {
1057       ParseNode left=pn.getFirstChild();
1058       AssignOperation op=new AssignOperation(pn.getLabel());
1059       AssignmentNode an=new AssignmentNode(parseExpression(left),null,op);
1060       an.setNumLine(pn.getLine());
1061       return an;
1062
1063     } else if (isNode(pn,"preinc")||
1064                isNode(pn,"predec")) {
1065       ParseNode left=pn.getFirstChild();
1066       AssignOperation op=isNode(pn,"preinc")?new AssignOperation(AssignOperation.PLUSEQ):new AssignOperation(AssignOperation.MINUSEQ);
1067       AssignmentNode an=new AssignmentNode(parseExpression(left),
1068                                            new LiteralNode("integer",new Integer(1)),op);
1069       an.setNumLine(pn.getLine());
1070       return an;
1071     } else if (isNode(pn,"literal")) {
1072       String literaltype=pn.getTerminal();
1073       ParseNode literalnode=pn.getChild(literaltype);
1074       Object literal_obj=literalnode.getLiteral();
1075       LiteralNode ln=new LiteralNode(literaltype, literal_obj);
1076       ln.setNumLine(pn.getLine());
1077       return ln;
1078     } else if (isNode(pn, "createobject")) {
1079       TypeDescriptor td = parseTypeDescriptor(pn);
1080
1081       Vector args = parseArgumentList(pn);
1082       boolean isglobal = pn.getChild("global") != null || pn.getChild("scratch") != null;
1083       String disjointId = null;
1084       if (pn.getChild("disjoint") != null) {
1085         disjointId = pn.getChild("disjoint").getTerminal();
1086       }
1087       ParseNode idChild = (pn.getChild( "id" ));
1088       ParseNode baseChild = (pn.getChild( "base" ));
1089       
1090       CreateObjectNode con = new CreateObjectNode(td, isglobal, disjointId);
1091       if( null != idChild && null != idChild.getFirstChild() ) {
1092         idChild = idChild.getFirstChild();
1093         //System.out.println( "\nThe object passed has this expression " + idChild.PPrint( 0, true ) );
1094         ExpressionNode en = parseExpression( idChild ); 
1095         //System.out.println( "\nThe object passed has this expression " + en.printNode( 0 ) );
1096         con.setSurroundingExpression( en );
1097       }
1098       else if( null != baseChild  && null != baseChild.getFirstChild()  ) {
1099         baseChild = baseChild.getFirstChild();
1100         //System.out.println( "\nThe object passed has this expression " + baseChild.PPrint( 0, true ) );
1101         ExpressionNode en = parseExpression( baseChild ); 
1102         //System.out.println( "\nThe object passed has this expression " + en.printNode( 0 ) );
1103         con.setSurroundingExpression( en );     
1104       }
1105       con.setNumLine(pn.getLine());
1106       for (int i = 0; i < args.size(); i++) {
1107         con.addArgument((ExpressionNode) args.get(i));
1108       }
1109       /* Could have flag set or tag added here */
1110       if (pn.getChild("flag_list") != null || pn.getChild("tag_list") != null) {
1111         FlagEffects fe = new FlagEffects(null);
1112         if (pn.getChild("flag_list") != null)
1113           parseFlagEffect(fe, pn.getChild("flag_list"));
1114
1115         if (pn.getChild("tag_list") != null)
1116           parseTagEffect(fe, pn.getChild("tag_list"));
1117         con.addFlagEffects(fe);
1118       }
1119
1120       return con;
1121     } else if (isNode(pn,"createobjectcls")) {
1122       //TODO:::  FIX BUG!!!  static fields in caller context need to become parameters
1123       //TODO::: caller context need to be passed in here
1124       TypeDescriptor td=parseTypeDescriptor(pn);
1125       innerCount++;
1126       ClassDescriptor cnnew=new ClassDescriptor(packageName,td.getSymbol()+"$"+innerCount, false);
1127       pushChainMaps();
1128       cnnew.setImports(mandatoryImports, multiimports);
1129       cnnew.setSuper(td.getSymbol());
1130       cnnew.setInline();
1131       parseClassBody(cnnew, pn.getChild("decl").getChild("classbody"));
1132       TypeDescriptor tdnew=state.getTypeDescriptor(cnnew.getSymbol());
1133
1134       Vector args=parseArgumentList(pn);
1135       ParseNode idChild = pn.getChild( "id" );
1136       ParseNode baseChild = pn.getChild( "base" );
1137       //System.out.println("\n to print idchild and basechild for ");
1138       /*if( null != idChild )
1139         System.out.println( "\n trying to create an inner class and the id child passed is "  + idChild.PPrint( 0, true ) );
1140       if( null != baseChild )
1141         System.out.println( "\n trying to create an inner class and the base child passed is "  + baseChild.PPrint( 0, true ) );*/
1142       CreateObjectNode con=new CreateObjectNode(tdnew, false, null);
1143       con.setNumLine(pn.getLine());
1144       for(int i=0; i<args.size(); i++) {
1145         con.addArgument((ExpressionNode)args.get(i));
1146       }
1147       popChainMaps();
1148
1149       if (analyzeset != null)
1150         analyzeset.add(cnnew);
1151       cnnew.setSourceFileName(currsourcefile);
1152       state.addClass(cnnew);
1153
1154       return con;
1155     } else if (isNode(pn,"createarray")) {
1156       //System.out.println(pn.PPrint(3,true));
1157       boolean isglobal=pn.getChild("global")!=null||
1158                         pn.getChild("scratch")!=null;
1159       String disjointId=null;
1160       if( pn.getChild("disjoint") != null) {
1161         disjointId = pn.getChild("disjoint").getTerminal();
1162       }
1163       TypeDescriptor td=parseTypeDescriptor(pn);
1164       Vector args=parseDimExprs(pn);
1165       int num=0;
1166       if (pn.getChild("dims_opt").getLiteral()!=null)
1167         num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
1168       for(int i=0; i<(args.size()+num); i++)
1169         td=td.makeArray(state);
1170       CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
1171       con.setNumLine(pn.getLine());
1172       for(int i=0; i<args.size(); i++) {
1173         con.addArgument((ExpressionNode)args.get(i));
1174       }
1175       return con;
1176     }
1177     if (isNode(pn,"createarray2")) {
1178       TypeDescriptor td=parseTypeDescriptor(pn);
1179       int num=0;
1180       if (pn.getChild("dims_opt").getLiteral()!=null)
1181         num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
1182       for(int i=0; i<num; i++)
1183         td=td.makeArray(state);
1184       CreateObjectNode con=new CreateObjectNode(td, false, null);
1185       con.setNumLine(pn.getLine());
1186       ParseNode ipn = pn.getChild("initializer");
1187       Vector initializers=parseVariableInitializerList(ipn);
1188       ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
1189       ain.setNumLine(pn.getLine());
1190       con.addArrayInitializer(ain);
1191       return con;
1192     } else if (isNode(pn,"name")) {
1193       NameDescriptor nd=parseName(pn);
1194       NameNode nn=new NameNode(nd);
1195       nn.setNumLine(pn.getLine());
1196       return nn;
1197     } else if (isNode(pn,"this")) {
1198       NameDescriptor nd=new NameDescriptor("this");
1199       NameNode nn=new NameNode(nd);
1200       nn.setNumLine(pn.getLine());
1201       return nn;
1202     } else if (isNode(pn,"parentclass")) {
1203       NameDescriptor nd=new NameDescriptor("this");
1204       NameNode nn=new NameNode(nd);
1205       nn.setNumLine(pn.getLine());
1206
1207       FieldAccessNode fan=new FieldAccessNode(nn,"this$parent");
1208       fan.setNumLine(pn.getLine());
1209       return fan;
1210     } else if (isNode(pn,"isavailable")) {
1211       NameDescriptor nd=new NameDescriptor(pn.getTerminal());
1212       NameNode nn=new NameNode(nd);
1213       nn.setNumLine(pn.getLine());
1214       return new OpNode(nn,null,new Operation(Operation.ISAVAILABLE));
1215     } else if (isNode(pn,"methodinvoke1")) {
1216       NameDescriptor nd=parseName(pn.getChild("name"));
1217       Vector args=parseArgumentList(pn);
1218       MethodInvokeNode min=new MethodInvokeNode(nd);
1219       min.setNumLine(pn.getLine());
1220       for(int i=0; i<args.size(); i++) {
1221         min.addArgument((ExpressionNode)args.get(i));
1222       }
1223       return min;
1224     } else if (isNode(pn,"methodinvoke2")) {
1225       String methodid=pn.getChild("id").getTerminal();
1226       ExpressionNode exp=parseExpression(pn.getChild("base").getFirstChild());
1227       Vector args=parseArgumentList(pn);
1228       MethodInvokeNode min=new MethodInvokeNode(methodid,exp);
1229       min.setNumLine(pn.getLine());
1230       for(int i=0; i<args.size(); i++) {
1231         min.addArgument((ExpressionNode)args.get(i));
1232       }
1233       return min;
1234     } else if (isNode(pn,"fieldaccess")) {
1235       ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
1236       String fieldname=pn.getChild("field").getTerminal();
1237
1238       FieldAccessNode fan=new FieldAccessNode(en,fieldname);
1239       fan.setNumLine(pn.getLine());
1240       return fan;
1241     } else if (isNode(pn,"arrayaccess")) {
1242       ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
1243       ExpressionNode index=parseExpression(pn.getChild("index").getFirstChild());
1244       ArrayAccessNode aan=new ArrayAccessNode(en,index);
1245       aan.setNumLine(pn.getLine());
1246       return aan;
1247     } else if (isNode(pn,"cast1")) {
1248       try {
1249         CastNode cn=new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
1250         cn.setNumLine(pn.getLine());
1251         return cn;
1252       } catch (Exception e) {
1253         System.out.println(pn.PPrint(1,true));
1254         e.printStackTrace();
1255         throw new Error();
1256       }
1257     } else if (isNode(pn,"cast2")) {
1258       CastNode cn=new CastNode(parseExpression(pn.getChild("type").getFirstChild()),parseExpression(pn.getChild("exp").getFirstChild()));
1259       cn.setNumLine(pn.getLine());
1260       return cn;
1261     } else if (isNode(pn, "getoffset")) {
1262       TypeDescriptor td=parseTypeDescriptor(pn);
1263       String fieldname = pn.getChild("field").getTerminal();
1264       //System.out.println("Checking the values of: "+ " td.toString()= " + td.toString()+ "  fieldname= " + fieldname);
1265       return new OffsetNode(td, fieldname);
1266     } else if (isNode(pn, "tert")) {
1267
1268       TertiaryNode tn=new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
1269                                        parseExpression(pn.getChild("trueexpr").getFirstChild()),
1270                                        parseExpression(pn.getChild("falseexpr").getFirstChild()) );
1271       tn.setNumLine(pn.getLine());
1272
1273       return tn;
1274     } else if (isNode(pn, "instanceof")) {
1275       ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
1276       TypeDescriptor t=parseTypeDescriptor(pn);
1277       InstanceOfNode ion=new InstanceOfNode(exp,t);
1278       ion.setNumLine(pn.getLine());
1279       return ion;
1280     } else if (isNode(pn, "array_initializer")) {
1281       Vector initializers=parseVariableInitializerList(pn);
1282       return new ArrayInitializerNode(initializers);
1283     } else if (isNode(pn, "class_type")) {
1284       TypeDescriptor td=parseTypeDescriptor(pn);
1285       ClassTypeNode ctn=new ClassTypeNode(td);
1286       ctn.setNumLine(pn.getLine());
1287       return ctn;
1288     } else if (isNode(pn, "empty")) {
1289       return null;
1290     } else {
1291       System.out.println("---------------------");
1292       System.out.println(pn.PPrint(3,true));
1293       throw new Error();
1294     }
1295   }
1296
1297   private Vector parseDimExprs(ParseNode pn) {
1298     Vector arglist=new Vector();
1299     ParseNode an=pn.getChild("dim_exprs");
1300     if (an==null)       /* No argument list */
1301       return arglist;
1302     ParseNodeVector anv=an.getChildren();
1303     for(int i=0; i<anv.size(); i++) {
1304       arglist.add(parseExpression(anv.elementAt(i)));
1305     }
1306     return arglist;
1307   }
1308
1309   private Vector parseArgumentList(ParseNode pn) {
1310     Vector arglist=new Vector();
1311     ParseNode an=pn.getChild("argument_list");
1312     if (an==null)       /* No argument list */
1313       return arglist;
1314     ParseNodeVector anv=an.getChildren();
1315     for(int i=0; i<anv.size(); i++) {
1316       arglist.add(parseExpression(anv.elementAt(i)));
1317     }
1318     return arglist;
1319   }
1320
1321   private Vector[] parseConsArgumentList(ParseNode pn) {
1322     Vector arglist=new Vector();
1323     Vector varlist=new Vector();
1324     ParseNode an=pn.getChild("cons_argument_list");
1325     if (an==null)       /* No argument list */
1326       return new Vector[] {varlist, arglist};
1327     ParseNodeVector anv=an.getChildren();
1328     for(int i=0; i<anv.size(); i++) {
1329       ParseNode cpn=anv.elementAt(i);
1330       ParseNode var=cpn.getChild("var");
1331       ParseNode exp=cpn.getChild("exp").getFirstChild();
1332       varlist.add(var.getTerminal());
1333       arglist.add(parseExpression(exp));
1334     }
1335     return new Vector[] {varlist, arglist};
1336   }
1337
1338   private Vector parseVariableInitializerList(ParseNode pn) {
1339     Vector varInitList=new Vector();
1340     ParseNode vin=pn.getChild("var_init_list");
1341     if (vin==null)       /* No argument list */
1342       return varInitList;
1343     ParseNodeVector vinv=vin.getChildren();
1344     for(int i=0; i<vinv.size(); i++) {
1345       varInitList.add(parseExpression(vinv.elementAt(i)));
1346     }
1347     return varInitList;
1348   }
1349
1350   private ExpressionNode parseAssignmentExpression(ParseNode pn) {
1351     AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
1352     ParseNodeVector pnv=pn.getChild("args").getChildren();
1353
1354     AssignmentNode an=new AssignmentNode(parseExpression(pnv.elementAt(0)),parseExpression(pnv.elementAt(1)),ao);
1355     an.setNumLine(pn.getLine());
1356     return an;
1357   }
1358
1359
1360   private void parseMethodDecl(ClassDescriptor cn, ParseNode pn) {
1361     ParseNode headern=pn.getChild("method_header");
1362     ParseNode bodyn=pn.getChild("body");
1363     MethodDescriptor md=parseMethodHeader(headern);
1364     try {
1365       BlockNode bn=parseBlock(bodyn);
1366       bn.setNumLine(pn.getLine()); // assume that method header is located at the beginning of method body
1367       cn.addMethod(md);
1368       state.addTreeCode(md,bn);
1369
1370       // this is a hack for investigating new language features
1371       // at the AST level, someday should evolve into a nice compiler
1372       // option *wink*
1373       //if( cn.getSymbol().equals( ***put a class in here like:     "Test" ) &&
1374       //    md.getSymbol().equals( ***put your method in here like: "main" )
1375       //) {
1376       //  bn.setStyle( BlockNode.NORMAL );
1377       //  System.out.println( bn.printNode( 0 ) );
1378       //}
1379
1380     } catch (Exception e) {
1381       System.out.println("Error with method:"+md.getSymbol());
1382       e.printStackTrace();
1383       throw new Error();
1384     } catch (Error e) {
1385       System.out.println("Error with method:"+md.getSymbol());
1386       e.printStackTrace();
1387       throw new Error();
1388     }
1389   }
1390
1391   private void parseConstructorDecl(ClassDescriptor cn, ParseNode pn) {
1392     ParseNode mn=pn.getChild("modifiers");
1393     Modifiers m=parseModifiersList(mn);
1394     ParseNode cdecl=pn.getChild("constructor_declarator");
1395     boolean isglobal=cdecl.getChild("global")!=null;
1396     String name=resolveName(cn.getSymbol());
1397     MethodDescriptor md=new MethodDescriptor(m, name, isglobal);
1398     ParseNode paramnode=cdecl.getChild("parameters");
1399     parseParameterList(md,paramnode);
1400     ParseNode bodyn0=pn.getChild("body");
1401     ParseNode bodyn=bodyn0.getChild("constructor_body");
1402     cn.addMethod(md);
1403     BlockNode bn=null;
1404     if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
1405       bn=parseBlock(bodyn);
1406     else
1407       bn=new BlockNode();
1408     if (bodyn!=null&&bodyn.getChild("superinvoke")!=null) {
1409       ParseNode sin=bodyn.getChild("superinvoke");
1410       NameDescriptor nd=new NameDescriptor("super");
1411       Vector args=parseArgumentList(sin);
1412       MethodInvokeNode min=new MethodInvokeNode(nd);
1413       min.setNumLine(sin.getLine());
1414       for(int i=0; i<args.size(); i++) {
1415         min.addArgument((ExpressionNode)args.get(i));
1416       }
1417       BlockExpressionNode ben=new BlockExpressionNode(min);
1418       bn.addFirstBlockStatement(ben);
1419
1420     } else if (bodyn!=null&&bodyn.getChild("explconstrinv")!=null) {
1421       ParseNode eci=bodyn.getChild("explconstrinv");
1422       NameDescriptor nd=new NameDescriptor(cn.getSymbol());
1423       Vector args=parseArgumentList(eci);
1424       MethodInvokeNode min=new MethodInvokeNode(nd);
1425       min.setNumLine(eci.getLine());
1426       for(int i=0; i<args.size(); i++) {
1427         min.addArgument((ExpressionNode)args.get(i));
1428       }
1429       BlockExpressionNode ben=new BlockExpressionNode(min);
1430       ben.setNumLine(eci.getLine());
1431       bn.addFirstBlockStatement(ben);
1432     }
1433     state.addTreeCode(md,bn);
1434   }
1435
1436   private void parseStaticBlockDecl(ClassDescriptor cn, ParseNode pn) {
1437     // Each class maintains one MethodDecscriptor which combines all its
1438     // static blocks in their declaration order
1439     boolean isfirst = false;
1440     MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
1441     if(md == null) {
1442       // the first static block for this class
1443       Modifiers m_i=new Modifiers();
1444       m_i.addModifier(Modifiers.STATIC);
1445       md = new MethodDescriptor(m_i, "staticblocks", false);
1446       md.setAsStaticBlock();
1447       isfirst = true;
1448     }
1449     ParseNode bodyn=pn.getChild("body");
1450     if(isfirst) {
1451       cn.addMethod(md);
1452     }
1453     cn.incStaticBlocks();
1454     BlockNode bn=null;
1455     if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
1456       bn=parseBlock(bodyn);
1457     else
1458       bn=new BlockNode();
1459     if(isfirst) {
1460       state.addTreeCode(md,bn);
1461     } else {
1462       BlockNode obn = state.getMethodBody(md);
1463       for(int i = 0; i < bn.size(); i++) {
1464         BlockStatementNode bsn = bn.get(i);
1465         obn.addBlockStatement(bsn);
1466       }
1467       state.addTreeCode(md, obn);
1468       bn = null;
1469     }
1470   }
1471
1472   public BlockNode parseBlock(ParseNode pn) {
1473     this.m_taskexitnum = 0;
1474     if (pn==null||isEmpty(pn.getTerminal()))
1475       return new BlockNode();
1476     ParseNode bsn=pn.getChild("block_statement_list");
1477     return parseBlockHelper(bsn);
1478   }
1479
1480   private BlockNode parseBlockHelper(ParseNode pn) {
1481     ParseNodeVector pnv=pn.getChildren();
1482     BlockNode bn=new BlockNode();
1483     for(int i=0; i<pnv.size(); i++) {
1484       Vector bsv=parseBlockStatement(pnv.elementAt(i));
1485       for(int j=0; j<bsv.size(); j++) {
1486         bn.addBlockStatement((BlockStatementNode)bsv.get(j));
1487       }
1488     }
1489     return bn;
1490   }
1491
1492   public BlockNode parseSingleBlock(ParseNode pn, String label){
1493     BlockNode bn=new BlockNode();
1494     Vector bsv=parseBlockStatement(pn,label);
1495     for(int j=0; j<bsv.size(); j++) {
1496       bn.addBlockStatement((BlockStatementNode)bsv.get(j));
1497     }
1498     bn.setStyle(BlockNode.NOBRACES);
1499     return bn;
1500   }
1501   
1502   public BlockNode parseSingleBlock(ParseNode pn) {
1503     return parseSingleBlock(pn,null);
1504   }
1505
1506   public Vector parseSESEBlock(Vector parentbs, ParseNode pn) {
1507     ParseNodeVector pnv=pn.getChildren();
1508     Vector bv=new Vector();
1509     for(int i=0; i<pnv.size(); i++) {
1510       bv.addAll(parseBlockStatement(pnv.elementAt(i)));
1511     }
1512     return bv;
1513   }
1514   
1515   public Vector parseBlockStatement(ParseNode pn){
1516     return parseBlockStatement(pn,null);
1517   }
1518
1519   public Vector parseBlockStatement(ParseNode pn, String label) {
1520     Vector blockstatements=new Vector();
1521     if (isNode(pn,"tag_declaration")) {
1522       String name=pn.getChild("single").getTerminal();
1523       String type=pn.getChild("type").getTerminal();
1524
1525       TagDeclarationNode tdn=new TagDeclarationNode(name, type);
1526       tdn.setNumLine(pn.getLine());
1527
1528       blockstatements.add(tdn);
1529     } else if (isNode(pn,"local_variable_declaration")) {
1530
1531       TypeDescriptor t=parseTypeDescriptor(pn);
1532       ParseNode vn=pn.getChild("variable_declarators_list");
1533       ParseNodeVector pnv=vn.getChildren();
1534       for(int i=0; i<pnv.size(); i++) {
1535         ParseNode vardecl=pnv.elementAt(i);
1536
1537
1538         ParseNode tmp=vardecl;
1539         TypeDescriptor arrayt=t;
1540
1541         while (tmp.getChild("single")==null) {
1542           arrayt=arrayt.makeArray(state);
1543           tmp=tmp.getChild("array");
1544         }
1545         String identifier=tmp.getChild("single").getTerminal();
1546
1547         ParseNode epn=vardecl.getChild("initializer");
1548
1549
1550         ExpressionNode en=null;
1551         if (epn!=null)
1552           en=parseExpression(epn.getFirstChild());
1553
1554         DeclarationNode dn=new DeclarationNode(new VarDescriptor(arrayt, identifier),en);
1555         dn.setNumLine(tmp.getLine());
1556         
1557         ParseNode mn=pn.getChild("modifiers");
1558         if(mn!=null) {
1559           // here, modifers parse node has the list of annotations
1560           Modifiers m=parseModifiersList(mn);
1561           assignAnnotationsToType(m, arrayt);
1562         }
1563
1564         blockstatements.add(dn);
1565       }
1566     } else if (isNode(pn,"nop")) {
1567       /* Do Nothing */
1568     } else if (isNode(pn,"expression")) {
1569       BlockExpressionNode ben=new BlockExpressionNode(parseExpression(pn.getFirstChild()));
1570       ben.setNumLine(pn.getLine());
1571       blockstatements.add(ben);
1572     } else if (isNode(pn,"ifstatement")) {
1573       IfStatementNode isn=new IfStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
1574                                               parseSingleBlock(pn.getChild("statement").getFirstChild()),
1575                                               pn.getChild("else_statement")!=null?parseSingleBlock(pn.getChild("else_statement").getFirstChild()):null);
1576       isn.setNumLine(pn.getLine());
1577
1578       blockstatements.add(isn);
1579     } else if (isNode(pn,"switch_statement")) {
1580       // TODO add version for normal Java later
1581       SwitchStatementNode ssn=new SwitchStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
1582                                                       parseSingleBlock(pn.getChild("statement").getFirstChild()));
1583       ssn.setNumLine(pn.getLine());
1584       blockstatements.add(ssn);
1585     } else if (isNode(pn,"switch_block_list")) {
1586       // TODO add version for normal Java later
1587       ParseNodeVector pnv=pn.getChildren();
1588       for(int i=0; i<pnv.size(); i++) {
1589         ParseNode sblockdecl=pnv.elementAt(i);
1590
1591         if(isNode(sblockdecl, "switch_block")) {
1592           ParseNode lpn=sblockdecl.getChild("switch_labels").getChild("switch_label_list");
1593           ParseNodeVector labelv=lpn.getChildren();
1594           Vector<SwitchLabelNode> slv = new Vector<SwitchLabelNode>();
1595           for(int j=0; j<labelv.size(); j++) {
1596             ParseNode labeldecl=labelv.elementAt(j);
1597             if(isNode(labeldecl, "switch_label")) {
1598               SwitchLabelNode sln=new SwitchLabelNode(parseExpression(labeldecl.getChild("constant_expression").getFirstChild()), false);
1599               sln.setNumLine(labeldecl.getLine());
1600               slv.addElement(sln);
1601             } else if(isNode(labeldecl, "default_switch_label")) {
1602               SwitchLabelNode sln=new SwitchLabelNode(null, true);
1603               sln.setNumLine(labeldecl.getLine());
1604               slv.addElement(sln);
1605             }
1606           }
1607
1608           SwitchBlockNode sbn=new SwitchBlockNode(slv,
1609                                                   parseSingleBlock(sblockdecl.getChild("switch_statements").getFirstChild()));
1610           sbn.setNumLine(sblockdecl.getLine());
1611
1612           blockstatements.add(sbn);
1613
1614         }
1615       }
1616     } else if (isNode(pn, "trycatchstatement")) {
1617       // TODO add version for normal Java later
1618       // Do not fully support exceptions now. Only make sure that if there are no
1619       // exceptions thrown, the execution is right
1620       ParseNode tpn = pn.getChild("tryblock").getFirstChild();
1621       BlockNode bn=parseBlockHelper(tpn);
1622       blockstatements.add(new SubBlockNode(bn));
1623
1624       ParseNode fbk = pn.getChild("finallyblock");
1625       if(fbk != null) {
1626         ParseNode fpn = fbk.getFirstChild();
1627         BlockNode fbn=parseBlockHelper(fpn);
1628         blockstatements.add(new SubBlockNode(fbn));
1629       }
1630     } else if (isNode(pn, "throwstatement")) {
1631       // TODO Simply return here
1632       //blockstatements.add(new ReturnNode());
1633     } else if (isNode(pn,"taskexit")) {
1634       Vector vfe=null;
1635       if (pn.getChild("flag_effects_list")!=null)
1636         vfe=parseFlags(pn.getChild("flag_effects_list"));
1637       Vector ccs=null;
1638       if (pn.getChild("cons_checks")!=null)
1639         ccs=parseChecks(pn.getChild("cons_checks"));
1640       TaskExitNode ten=new TaskExitNode(vfe, ccs, this.m_taskexitnum++);
1641       ten.setNumLine(pn.getLine());
1642       blockstatements.add(ten);
1643     } else if (isNode(pn,"atomic")) {
1644       BlockNode bn=parseBlockHelper(pn);
1645       AtomicNode an=new AtomicNode(bn);
1646       an.setNumLine(pn.getLine());
1647       blockstatements.add(an);
1648     } else if (isNode(pn,"synchronized")) {
1649       BlockNode bn=parseBlockHelper(pn.getChild("block"));
1650       ExpressionNode en=parseExpression(pn.getChild("expr").getFirstChild());
1651       SynchronizedNode sn=new SynchronizedNode(en, bn);
1652       sn.setNumLine(pn.getLine());
1653       blockstatements.add(sn);
1654     } else if (isNode(pn,"return")) {
1655       if (isEmpty(pn.getTerminal()))
1656         blockstatements.add(new ReturnNode());
1657       else {
1658         ExpressionNode en=parseExpression(pn.getFirstChild());
1659         ReturnNode rn=new ReturnNode(en);
1660         rn.setNumLine(pn.getLine());
1661         blockstatements.add(rn);
1662       }
1663     } else if (isNode(pn,"block_statement_list")) {
1664       BlockNode bn=parseBlockHelper(pn);
1665       blockstatements.add(new SubBlockNode(bn));
1666     } else if (isNode(pn,"empty")) {
1667       /* nop */
1668     } else if (isNode(pn,"statement_expression_list")) {
1669       ParseNodeVector pnv=pn.getChildren();
1670       BlockNode bn=new BlockNode();
1671       for(int i=0; i<pnv.size(); i++) {
1672         ExpressionNode en=parseExpression(pnv.elementAt(i));
1673         blockstatements.add(new BlockExpressionNode(en));
1674       }
1675       bn.setStyle(BlockNode.EXPRLIST);
1676     } else if (isNode(pn,"forstatement")) {
1677       BlockNode init=parseSingleBlock(pn.getChild("initializer").getFirstChild());
1678       BlockNode update=parseSingleBlock(pn.getChild("update").getFirstChild());
1679       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1680       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1681       if(condition == null) {
1682         // no condition clause, make a 'true' expression as the condition
1683         condition = (ExpressionNode) new LiteralNode("boolean", new Boolean(true));
1684       }
1685       LoopNode ln=new LoopNode(init,condition,update,body,label);
1686       ln.setNumLine(pn.getLine());
1687       blockstatements.add(ln);
1688     } else if (isNode(pn,"whilestatement")) {
1689       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1690       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1691       if(condition == null) {
1692         // no condition clause, make a 'true' expression as the condition
1693         condition = (ExpressionNode) new LiteralNode("boolean", new Boolean(true));
1694       }
1695       blockstatements.add(new LoopNode(condition,body,LoopNode.WHILELOOP,label));
1696     } else if (isNode(pn,"dowhilestatement")) {
1697       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
1698       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
1699       if(condition == null) {
1700         // no condition clause, make a 'true' expression as the condition
1701         condition = (ExpressionNode) new LiteralNode("boolean", new Boolean(true));
1702       }
1703       blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP,label));
1704     } else if (isNode(pn,"sese")) {
1705       ParseNode pnID=pn.getChild("identifier");
1706       String stID=null;
1707       if( pnID != null ) {
1708         stID=pnID.getFirstChild().getTerminal();
1709       }
1710       SESENode start=new SESENode(stID);
1711       start.setNumLine(pn.getLine());
1712       SESENode end  =new SESENode(stID);
1713       start.setEnd(end);
1714       end.setStart(start);
1715       blockstatements.add(start);
1716       blockstatements.addAll(parseSESEBlock(blockstatements,pn.getChild("body").getFirstChild()));
1717       blockstatements.add(end);
1718     } else if (isNode(pn,"continue")) {
1719       ContinueBreakNode cbn=new ContinueBreakNode(false);
1720       cbn.setNumLine(pn.getLine());
1721       blockstatements.add(cbn);
1722     } else if (isNode(pn,"break")) {
1723       ContinueBreakNode cbn=new ContinueBreakNode(true);
1724       cbn.setNumLine(pn.getLine());
1725       blockstatements.add(cbn);
1726       ParseNode idopt_pn=pn.getChild("identifier_opt");
1727       ParseNode name_pn=idopt_pn.getChild("name");
1728       // name_pn.getTerminal() gives you the label
1729
1730     } else if (isNode(pn,"genreach")) {
1731       String graphName = pn.getChild("graphName").getTerminal();
1732       blockstatements.add(new GenReachNode(graphName) );
1733
1734     } else if (isNode(pn,"gen_def_reach")) {
1735       String outputName = pn.getChild("outputName").getTerminal();
1736       blockstatements.add(new GenDefReachNode(outputName) );
1737
1738     } else if(isNode(pn,"labeledstatement")) {
1739       String labeledstatement = pn.getChild("name").getTerminal();
1740       BlockNode bn=parseSingleBlock(pn.getChild("statement").getFirstChild(),labeledstatement);
1741       blockstatements.add(new SubBlockNode(bn));
1742     } else {
1743       System.out.println("---------------");
1744       System.out.println(pn.PPrint(3,true));
1745       throw new Error();
1746     }
1747     return blockstatements;
1748   }
1749
1750   public MethodDescriptor parseMethodHeader(ParseNode pn) {
1751     ParseNode mn=pn.getChild("modifiers");
1752     Modifiers m=parseModifiersList(mn);
1753
1754     ParseNode tn=pn.getChild("returntype");
1755     TypeDescriptor returntype;
1756     if (tn!=null)
1757       returntype=parseTypeDescriptor(tn);
1758     else
1759       returntype=new TypeDescriptor(TypeDescriptor.VOID);
1760
1761     ParseNode pmd=pn.getChild("method_declarator");
1762     String name=pmd.getChild("name").getTerminal();
1763     MethodDescriptor md=new MethodDescriptor(m, returntype, name);
1764
1765     ParseNode paramnode=pmd.getChild("parameters");
1766     parseParameterList(md,paramnode);
1767     return md;
1768   }
1769
1770   public void parseParameterList(MethodDescriptor md, ParseNode pn) {
1771     ParseNode paramlist=pn.getChild("formal_parameter_list");
1772     if (paramlist==null)
1773       return;
1774     ParseNodeVector pnv=paramlist.getChildren();
1775     for(int i=0; i<pnv.size(); i++) {
1776       ParseNode paramn=pnv.elementAt(i);
1777
1778       if (isNode(paramn, "tag_parameter")) {
1779         String paramname=paramn.getChild("single").getTerminal();
1780         TypeDescriptor type=new TypeDescriptor(TypeDescriptor.TAG);
1781         md.addTagParameter(type, paramname);
1782       } else  {
1783
1784         TypeDescriptor type=parseTypeDescriptor(paramn);
1785
1786         ParseNode tmp=paramn;
1787         while (tmp.getChild("single")==null) {
1788           type=type.makeArray(state);
1789           tmp=tmp.getChild("array");
1790         }
1791         String paramname=tmp.getChild("single").getTerminal();
1792
1793         md.addParameter(type, paramname);
1794         if(isNode(paramn, "annotation_parameter")) {
1795           ParseNode listnode=paramn.getChild("annotation_list");
1796           parseParameterAnnotation(listnode,type);
1797         }
1798
1799       }
1800     }
1801   }
1802
1803   public Modifiers parseModifiersList(ParseNode pn) {
1804     Modifiers m=new Modifiers();
1805     ParseNode modlist=pn.getChild("modifier_list");
1806     if (modlist!=null) {
1807       ParseNodeVector pnv=modlist.getChildren();
1808       for(int i=0; i<pnv.size(); i++) {
1809         ParseNode modn=pnv.elementAt(i);
1810         if (isNode(modn,"public"))
1811           m.addModifier(Modifiers.PUBLIC);
1812         else if (isNode(modn,"protected"))
1813           m.addModifier(Modifiers.PROTECTED);
1814         else if (isNode(modn,"private"))
1815           m.addModifier(Modifiers.PRIVATE);
1816         else if (isNode(modn,"static"))
1817           m.addModifier(Modifiers.STATIC);
1818         else if (isNode(modn,"final"))
1819           m.addModifier(Modifiers.FINAL);
1820         else if (isNode(modn,"native"))
1821           m.addModifier(Modifiers.NATIVE);
1822         else if (isNode(modn,"synchronized"))
1823           m.addModifier(Modifiers.SYNCHRONIZED);
1824         else if (isNode(modn,"atomic"))
1825           m.addModifier(Modifiers.ATOMIC);
1826         else if (isNode(modn,"abstract"))
1827           m.addModifier(Modifiers.ABSTRACT);
1828         else if (isNode(modn,"volatile"))
1829           m.addModifier(Modifiers.VOLATILE);
1830         else if (isNode(modn,"transient"))
1831           m.addModifier(Modifiers.TRANSIENT);
1832         else if(isNode(modn,"annotation_list"))
1833           parseAnnotationList(modn,m);
1834         else {
1835           throw new Error("Unrecognized Modifier:"+modn.getLabel());
1836         }
1837       }
1838     }
1839     return m;
1840   }
1841
1842   private void parseAnnotationList(ParseNode pn, Modifiers m) {
1843     ParseNodeVector pnv = pn.getChildren();
1844     for (int i = 0; i < pnv.size(); i++) {
1845       ParseNode body_list = pnv.elementAt(i);
1846       if (isNode(body_list, "annotation_body")) {
1847         ParseNode body_node = body_list.getFirstChild();
1848         if (isNode(body_node, "marker_annotation")) {
1849           m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
1850         } else if (isNode(body_node, "single_annotation")) {
1851           m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
1852                                                    body_node.getChild("element_value").getTerminal()));
1853         } else if (isNode(body_node, "normal_annotation")) {
1854           throw new Error("Annotation with multiple data members is not supported yet.");
1855         }
1856       }
1857     }
1858   }
1859
1860   private void parseParameterAnnotation(ParseNode pn,TypeDescriptor type) {
1861     ParseNodeVector pnv = pn.getChildren();
1862     for (int i = 0; i < pnv.size(); i++) {
1863       ParseNode body_list = pnv.elementAt(i);
1864       if (isNode(body_list, "annotation_body")) {
1865         ParseNode body_node = body_list.getFirstChild();
1866         if (isNode(body_node, "marker_annotation")) {
1867           type.addAnnotationMarker(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
1868         } else if (isNode(body_node, "single_annotation")) {
1869           type.addAnnotationMarker(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
1870                                                    body_node.getChild("element_value").getTerminal()));
1871         } else if (isNode(body_node, "normal_annotation")) {
1872           throw new Error("Annotation with multiple data members is not supported yet.");
1873         }
1874       }
1875     }
1876   }
1877
1878   private boolean isNode(ParseNode pn, String label) {
1879     if (pn.getLabel().equals(label))
1880       return true;
1881     else return false;
1882   }
1883
1884   private static boolean isEmpty(ParseNode pn) {
1885     if (pn.getLabel().equals("empty"))
1886       return true;
1887     else
1888       return false;
1889   }
1890
1891   private static boolean isEmpty(String s) {
1892     if (s.equals("empty"))
1893       return true;
1894     else
1895       return false;
1896   }
1897
1898   /** Throw an exception if something is unexpected */
1899   private void check(ParseNode pn, String label) {
1900     if (pn == null) {
1901       throw new Error(pn+ "IE: Expected '" + label + "', got null");
1902     }
1903     if (!pn.getLabel().equals(label)) {
1904       throw new Error(pn+ "IE: Expected '" + label + "', got '"+pn.getLabel()+"'");
1905     }
1906   }
1907 }