X-Git-Url: http://plrg.eecs.uci.edu/git/?p=IRC.git;a=blobdiff_plain;f=Robust%2Fsrc%2FIR%2FTree%2FBuildIR.java;h=9785ebbbab5d46b5cfe372f4a9a7523f8aad984d;hp=e31d6d14f50b06db2bb234f4bc5e30d5aa99a7de;hb=eb17be02c22191b3fc7bdc335d9434ada68278de;hpb=c94e3d181dec110fc0bd7071a555631cd2a3863d

diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index e31d6d14..9785ebbb 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -17,23 +17,23 @@ public class BuildIR {
 
   public void buildtree(ParseNode pn, Set toanalyze, String sourcefile) {
     parseFile(pn, toanalyze, sourcefile);
-    
+
     // numering the interfaces
     int if_num = 0;
     Iterator it_classes = state.getClassSymbolTable().getValueSet().iterator();
     while(it_classes.hasNext()) {
       ClassDescriptor cd = (ClassDescriptor)it_classes.next();
       if(cd.isInterface()) {
-        cd.setInterfaceId(if_num++);
+	cd.setInterfaceId(if_num++);
       }
     }
   }
 
   //This is all single imports and a subset of the
-  //multi imports that have been resolved. 
+  //multi imports that have been resolved.
   Hashtable mandatoryImports;
   //maps class names in file to full name
-  //Note may map a name to an ERROR. 
+  //Note may map a name to an ERROR.
   Hashtable multiimports;
   NameDescriptor packages;
 
@@ -41,145 +41,144 @@ public class BuildIR {
   public void parseFile(ParseNode pn, Set toanalyze, String sourcefile) {
     mandatoryImports = new Hashtable();
     multiimports = new Hashtable();
-    
+
     if(state.JNI) {
       //add java.lang as our default multi-import
       this.addMultiImport(sourcefile, "java.lang", false);
     }
-    
+
     ParseNode ipn = pn.getChild("imports").getChild("import_decls_list");
     if (ipn != null) {
       ParseNodeVector pnv = ipn.getChildren();
       for (int i = 0; i < pnv.size(); i++) {
-        ParseNode pnimport = pnv.elementAt(i);
-        NameDescriptor nd = parseName(pnimport.getChild("name"));
-        if (isNode(pnimport, "import_single")) {
-          if (!mandatoryImports.containsKey(nd.getIdentifier())) {
-            // map name to full name (includes package/directory
-            mandatoryImports.put(nd.getIdentifier(), nd.getPathFromRootToHere());
-          } else {
-            throw new Error("An ambiguous class "+ nd.getIdentifier() +" has been found. It is included for " +
-            		((String)mandatoryImports.get(nd.getIdentifier())) + " and " +
-            		nd.getPathFromRootToHere());
-          }
-        }
-        else {
-          addMultiImport(sourcefile, nd.getPathFromRootToHere(), false);
-        }
+	ParseNode pnimport = pnv.elementAt(i);
+	NameDescriptor nd = parseName(pnimport.getChild("name"));
+	if (isNode(pnimport, "import_single")) {
+	  if (!mandatoryImports.containsKey(nd.getIdentifier())) {
+	    // map name to full name (includes package/directory
+	    mandatoryImports.put(nd.getIdentifier(), nd.getPathFromRootToHere());
+	  } else {
+	    throw new Error("An ambiguous class "+ nd.getIdentifier() +" has been found. It is included for " +
+	                    ((String)mandatoryImports.get(nd.getIdentifier())) + " and " +
+	                    nd.getPathFromRootToHere());
+	  }
+	} else {
+	  addMultiImport(sourcefile, nd.getPathFromRootToHere(), false);
+	}
       }
     }
-    
+
     ParseNode ppn=pn.getChild("packages").getChild("package");
     String packageName = null;
     if (ppn!=null) {
       NameDescriptor nd = parseClassName(ppn.getChild("name"));
-      packageName = nd.getPathFromRootToHere();      
-      //Trick -> import the package directory as a multi-import and it'll 
+      packageName = nd.getPathFromRootToHere();
+      //Trick -> import the package directory as a multi-import and it'll
       //automatically recognize files in the same directory.
       addMultiImport(sourcefile, packageName, true);
     }
-    
+
     ParseNode tpn=pn.getChild("type_declaration_list");
     if (tpn != null) {
       ParseNodeVector pnv = tpn.getChildren();
       for (int i = 0; i < pnv.size(); i++) {
-        ParseNode type_pn = pnv.elementAt(i);
-        if (isEmpty(type_pn)) /* Skip the semicolon */
-          continue;
-        if (isNode(type_pn, "class_declaration")) {
-          ClassDescriptor cn = parseTypeDecl(type_pn, packageName);
-          cn.setSourceFileName(sourcefile);
-          parseInitializers(cn);
-          if (toanalyze != null)
-            toanalyze.add(cn);
-          state.addClass(cn);
-          // for inner classes/enum
-          HashSet tovisit = new HashSet();
-          Iterator it_icds = cn.getInnerClasses();
-          while (it_icds.hasNext()) {
-            tovisit.add(it_icds.next());
-          }
-
-          while (!tovisit.isEmpty()) {
-            ClassDescriptor cd = (ClassDescriptor) tovisit.iterator().next();
-            tovisit.remove(cd);
-            parseInitializers(cd);
-            if (toanalyze != null) {
-              toanalyze.add(cd);
-            }
-            cd.setSourceFileName(sourcefile);
-            state.addClass(cd);
-
-            Iterator it_ics = cd.getInnerClasses();
-            while (it_ics.hasNext()) {
-              tovisit.add(it_ics.next());
-            }
-
-            Iterator it_ienums = cd.getEnum();
-            while (it_ienums.hasNext()) {
-              ClassDescriptor iecd = (ClassDescriptor) it_ienums.next();
-              if (toanalyze != null) {
-                toanalyze.add(iecd);
-              }
-              iecd.setSourceFileName(sourcefile);
-              state.addClass(iecd);
-            }
-          }
-
-          Iterator it_enums = cn.getEnum();
-          while (it_enums.hasNext()) {
-            ClassDescriptor ecd = (ClassDescriptor) it_enums.next();
-            if (toanalyze != null) {
-              toanalyze.add(ecd);
-            }
-            ecd.setSourceFileName(sourcefile);
-            state.addClass(ecd);
-          }
-        } else if (isNode(type_pn, "task_declaration")) {
-          TaskDescriptor td = parseTaskDecl(type_pn);
-          if (toanalyze != null)
-            toanalyze.add(td);
-          state.addTask(td);
-        } else if (isNode(type_pn, "interface_declaration")) {
-          // TODO add version for normal Java later
-          ClassDescriptor cn = parseInterfaceDecl(type_pn, packageName);
-          if (toanalyze != null)
-            toanalyze.add(cn);
-          cn.setSourceFileName(sourcefile);
-          state.addClass(cn);
-
-          // for enum
-          Iterator it_enums = cn.getEnum();
-          while (it_enums.hasNext()) {
-            ClassDescriptor ecd = (ClassDescriptor) it_enums.next();
-            if (toanalyze != null) {
-              toanalyze.add(ecd);
-            }
-            ecd.setSourceFileName(sourcefile);
-            state.addClass(ecd);
-          }
-        } else if (isNode(type_pn, "enum_declaration")) {
-          // TODO add version for normal Java later
-          ClassDescriptor cn = parseEnumDecl(null, type_pn);
-          if (toanalyze != null)
-            toanalyze.add(cn);
-          cn.setSourceFileName(sourcefile);
-          state.addClass(cn);
-        } else if(isNode(type_pn,"annotation_type_declaration")){
-          ClassDescriptor cn=parseAnnotationTypeDecl(type_pn);
-          if (toanalyze != null)
-            toanalyze.add(cn);
-          cn.setSourceFileName(sourcefile);
-          state.addClass(cn);
-        } else {
-          throw new Error(type_pn.getLabel());
-        }
+	ParseNode type_pn = pnv.elementAt(i);
+	if (isEmpty(type_pn)) /* Skip the semicolon */
+	  continue;
+	if (isNode(type_pn, "class_declaration")) {
+	  ClassDescriptor cn = parseTypeDecl(type_pn, packageName);
+	  cn.setSourceFileName(sourcefile);
+	  parseInitializers(cn);
+	  if (toanalyze != null)
+	    toanalyze.add(cn);
+	  state.addClass(cn);
+	  // for inner classes/enum
+	  HashSet tovisit = new HashSet();
+	  Iterator it_icds = cn.getInnerClasses();
+	  while (it_icds.hasNext()) {
+	    tovisit.add(it_icds.next());
+	  }
+
+	  while (!tovisit.isEmpty()) {
+	    ClassDescriptor cd = (ClassDescriptor) tovisit.iterator().next();
+	    tovisit.remove(cd);
+	    parseInitializers(cd);
+	    if (toanalyze != null) {
+	      toanalyze.add(cd);
+	    }
+	    cd.setSourceFileName(sourcefile);
+	    state.addClass(cd);
+
+	    Iterator it_ics = cd.getInnerClasses();
+	    while (it_ics.hasNext()) {
+	      tovisit.add(it_ics.next());
+	    }
+
+	    Iterator it_ienums = cd.getEnum();
+	    while (it_ienums.hasNext()) {
+	      ClassDescriptor iecd = (ClassDescriptor) it_ienums.next();
+	      if (toanalyze != null) {
+		toanalyze.add(iecd);
+	      }
+	      iecd.setSourceFileName(sourcefile);
+	      state.addClass(iecd);
+	    }
+	  }
+
+	  Iterator it_enums = cn.getEnum();
+	  while (it_enums.hasNext()) {
+	    ClassDescriptor ecd = (ClassDescriptor) it_enums.next();
+	    if (toanalyze != null) {
+	      toanalyze.add(ecd);
+	    }
+	    ecd.setSourceFileName(sourcefile);
+	    state.addClass(ecd);
+	  }
+	} else if (isNode(type_pn, "task_declaration")) {
+	  TaskDescriptor td = parseTaskDecl(type_pn);
+	  if (toanalyze != null)
+	    toanalyze.add(td);
+	  state.addTask(td);
+	} else if (isNode(type_pn, "interface_declaration")) {
+	  // TODO add version for normal Java later
+	  ClassDescriptor cn = parseInterfaceDecl(type_pn, packageName);
+	  if (toanalyze != null)
+	    toanalyze.add(cn);
+	  cn.setSourceFileName(sourcefile);
+	  state.addClass(cn);
+
+	  // for enum
+	  Iterator it_enums = cn.getEnum();
+	  while (it_enums.hasNext()) {
+	    ClassDescriptor ecd = (ClassDescriptor) it_enums.next();
+	    if (toanalyze != null) {
+	      toanalyze.add(ecd);
+	    }
+	    ecd.setSourceFileName(sourcefile);
+	    state.addClass(ecd);
+	  }
+	} else if (isNode(type_pn, "enum_declaration")) {
+	  // TODO add version for normal Java later
+	  ClassDescriptor cn = parseEnumDecl(null, type_pn);
+	  if (toanalyze != null)
+	    toanalyze.add(cn);
+	  cn.setSourceFileName(sourcefile);
+	  state.addClass(cn);
+	} else if(isNode(type_pn,"annotation_type_declaration")) {
+	  ClassDescriptor cn=parseAnnotationTypeDecl(type_pn);
+	  if (toanalyze != null)
+	    toanalyze.add(cn);
+	  cn.setSourceFileName(sourcefile);
+	  state.addClass(cn);
+	} else {
+	  throw new Error(type_pn.getLabel());
+	}
       }
     }
   }
-  
-  
-  
+
+
+
   //This kind of breaks away from tradition a little bit by doing the file checks here
   // instead of in Semantic check, but doing it here is easier because we have a mapping early on
   // if I wait until semantic check, I have to change ALL the type descriptors to match the new
@@ -190,43 +189,43 @@ public class BuildIR {
       String path = (String) state.classpath.get(j);
       File folder = new File(path, importPath.replace('.', '/'));
       if (folder.exists()) {
-        found = true;
-        for (String file : folder.list()) {
-          // if the file is of type *.java add to multiImport list.
-          if (file.lastIndexOf('.') != -1 && file.substring(file.lastIndexOf('.')).equalsIgnoreCase(".java")) {
-            String classname = file.substring(0, file.length() - 5);
-            // single imports have precedence over multi-imports
-            if (!mandatoryImports.containsKey(classname)) {
-              //package files have precedence over multi-imports. 
-              if (multiimports.containsKey(classname)  && !isPackageDirectory) {
-                // put error in for later, in case we try to import
-                multiimports.put(classname, new Error("Error: class " + classname + " is defined more than once in a multi-import in " + currentSource));
-              } else {
-                multiimports.put(classname, importPath + "." + classname);
-              }
-            }
-          }
-        }
+	found = true;
+	for (String file : folder.list()) {
+	  // if the file is of type *.java add to multiImport list.
+	  if (file.lastIndexOf('.') != -1 && file.substring(file.lastIndexOf('.')).equalsIgnoreCase(".java")) {
+	    String classname = file.substring(0, file.length() - 5);
+	    // single imports have precedence over multi-imports
+	    if (!mandatoryImports.containsKey(classname)) {
+	      //package files have precedence over multi-imports.
+	      if (multiimports.containsKey(classname)  && !isPackageDirectory) {
+		// put error in for later, in case we try to import
+		multiimports.put(classname, new Error("Error: class " + classname + " is defined more than once in a multi-import in " + currentSource));
+	      } else {
+		multiimports.put(classname, importPath + "." + classname);
+	      }
+	    }
+	  }
+	}
       }
     }
-    
-    
+
+
     if(!found) {
       throw new Error("Import package " + importPath + " in  " + currentSource
-          + " cannot be resolved.");
+                      + " cannot be resolved.");
     }
   }
 
-  public void parseInitializers(ClassDescriptor cn){
+  public void parseInitializers(ClassDescriptor cn) {
     Vector fv=cn.getFieldVec();
     int pos = 0;
-    for(int i=0;i<fv.size();i++) {
+    for(int i=0; i<fv.size(); i++) {
       FieldDescriptor fd=(FieldDescriptor)fv.get(i);
       if(fd.getExpressionNode()!=null) {
 	Iterator methodit = cn.getMethods();
-	while(methodit.hasNext()){
+	while(methodit.hasNext()) {
 	  MethodDescriptor currmd=(MethodDescriptor)methodit.next();
-	  if(currmd.isConstructor()){
+	  if(currmd.isConstructor()) {
 	    BlockNode bn=state.getMethodBody(currmd);
 	    NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
 	    AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
@@ -236,8 +235,8 @@ public class BuildIR {
 	pos++;
       }
     }
-  }  
-  
+  }
+
   private ClassDescriptor parseEnumDecl(ClassDescriptor cn, ParseNode pn) {
     ClassDescriptor ecd=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
     ecd.setImports(mandatoryImports);
@@ -248,78 +247,78 @@ public class BuildIR {
       cn.addEnum(ecd);
     }
     if (!(ecd.getSymbol().equals(TypeUtil.ObjectClass)||
-        ecd.getSymbol().equals(TypeUtil.TagClass))) {
+          ecd.getSymbol().equals(TypeUtil.TagClass))) {
       ecd.setSuper(TypeUtil.ObjectClass);
     }
     ecd.setModifiers(parseModifiersList(pn.getChild("modifiers")));
     parseEnumBody(ecd, pn.getChild("enumbody"));
     return ecd;
   }
-  
+
   private void parseEnumBody(ClassDescriptor cn, ParseNode pn) {
     ParseNode decls=pn.getChild("enum_constants_list");
     if (decls!=null) {
       ParseNodeVector pnv=decls.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-        ParseNode decl=pnv.elementAt(i);
-        if (isNode(decl,"enum_constant")) {
-          parseEnumConstant(cn,decl);
-        } else throw new Error();
+	ParseNode decl=pnv.elementAt(i);
+	if (isNode(decl,"enum_constant")) {
+	  parseEnumConstant(cn,decl);
+	} else throw new Error();
       }
     }
   }
-  
+
   private void parseEnumConstant(ClassDescriptor cn, ParseNode pn) {
     cn.addEnumConstant(pn.getChild("name").getTerminal());
   }
-  
-  private ClassDescriptor parseAnnotationTypeDecl(ParseNode pn){
+
+  private ClassDescriptor parseAnnotationTypeDecl(ParseNode pn) {
     ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal(), true);
     cn.setImports(mandatoryImports);
     ParseNode modifiers=pn.getChild("modifiers");
-    if(modifiers!=null){
+    if(modifiers!=null) {
       cn.setModifiers(parseModifiersList(modifiers));
     }
     parseAnnotationTypeBody(cn,pn.getChild("body"));
     return cn;
   }
-  
-  private void parseAnnotationTypeBody(ClassDescriptor cn, ParseNode pn){
+
+  private void parseAnnotationTypeBody(ClassDescriptor cn, ParseNode pn) {
     ParseNode list_node=pn.getChild("annotation_type_element_list");
-    if(list_node!=null){
+    if(list_node!=null) {
       ParseNodeVector pnv = list_node.getChildren();
       for (int i = 0; i < pnv.size(); i++) {
-        ParseNode element_node = pnv.elementAt(i);
-        if (isNode(element_node, "annotation_type_element_declaration")) {
-          ParseNodeVector elementProps = element_node.getChildren();
-          String identifier=null;
-          TypeDescriptor type=null;
-          Modifiers modifiers=new Modifiers();
-          for(int eidx=0; eidx<elementProps.size(); eidx++) {
-            ParseNode prop_node=elementProps.elementAt(eidx);
-            if(isNode(prop_node,"name")){
-              identifier=prop_node.getTerminal();
-            }else if(isNode(prop_node,"type")){
-              type=parseTypeDescriptor(prop_node);
-            }else if(isNode(prop_node,"modifier")){
-              modifiers=parseModifiersList(prop_node);
-            }
-          }
-          cn.addField(new FieldDescriptor(modifiers, type, identifier, null, false));
-        }
+	ParseNode element_node = pnv.elementAt(i);
+	if (isNode(element_node, "annotation_type_element_declaration")) {
+	  ParseNodeVector elementProps = element_node.getChildren();
+	  String identifier=null;
+	  TypeDescriptor type=null;
+	  Modifiers modifiers=new Modifiers();
+	  for(int eidx=0; eidx<elementProps.size(); eidx++) {
+	    ParseNode prop_node=elementProps.elementAt(eidx);
+	    if(isNode(prop_node,"name")) {
+	      identifier=prop_node.getTerminal();
+	    } else if(isNode(prop_node,"type")) {
+	      type=parseTypeDescriptor(prop_node);
+	    } else if(isNode(prop_node,"modifier")) {
+	      modifiers=parseModifiersList(prop_node);
+	    }
+	  }
+	  cn.addField(new FieldDescriptor(modifiers, type, identifier, null, false));
+	}
       }
     }
   }
-  
+
   public ClassDescriptor parseInterfaceDecl(ParseNode pn, String packageName) {
     ClassDescriptor cn;
     if(packageName == null) {
-      cn=new ClassDescriptor(pn.getChild("name").getTerminal(), true); 
+      cn=new ClassDescriptor(pn.getChild("name").getTerminal(), true);
     } else  {
       String newClassname = packageName + "." + pn.getChild("name").getTerminal();
       cn= new ClassDescriptor(packageName, newClassname, true);
     }
-    
+
     cn.setImports(mandatoryImports);
     //cn.setAsInterface();
     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
@@ -327,36 +326,36 @@ public class BuildIR {
       ParseNode snlist=pn.getChild("superIF").getChild("extend_interface_list");
       ParseNodeVector pnv=snlist.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-        ParseNode decl=pnv.elementAt(i);
-        if (isNode(decl,"type")) {
-          NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
-          cn.addSuperInterface(nd.toString());
-        }
+	ParseNode decl=pnv.elementAt(i);
+	if (isNode(decl,"type")) {
+	  NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
+	  cn.addSuperInterface(nd.toString());
+	}
       }
     }
     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
     parseInterfaceBody(cn, pn.getChild("interfacebody"));
     return cn;
   }
-  
+
   private void parseInterfaceBody(ClassDescriptor cn, ParseNode pn) {
     assert(cn.isInterface());
     ParseNode decls=pn.getChild("interface_member_declaration_list");
     if (decls!=null) {
       ParseNodeVector pnv=decls.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-        ParseNode decl=pnv.elementAt(i);
-        if (isNode(decl,"constant")) {
-          parseInterfaceConstant(cn,decl);
-        } else if (isNode(decl,"method")) {
-          parseInterfaceMethod(cn,decl.getChild("method_declaration"));
-        } else throw new Error();
+	ParseNode decl=pnv.elementAt(i);
+	if (isNode(decl,"constant")) {
+	  parseInterfaceConstant(cn,decl);
+	} else if (isNode(decl,"method")) {
+	  parseInterfaceMethod(cn,decl.getChild("method_declaration"));
+	} else throw new Error();
       }
     }
   }
-  
-  
-  
+
+
+
   private void parseInterfaceConstant(ClassDescriptor cn, ParseNode pn) {
     if (pn!=null) {
       parseFieldDecl(cn,pn.getChild("field_declaration"));
@@ -364,7 +363,7 @@ public class BuildIR {
     }
     throw new Error();
   }
-  
+
   private void parseInterfaceMethod(ClassDescriptor cn, ParseNode pn) {
     ParseNode headern=pn.getChild("header");
     ParseNode bodyn=pn.getChild("body");
@@ -380,7 +379,7 @@ public class BuildIR {
       // at the AST level, someday should evolve into a nice compiler
       // option *wink*
       //if( cn.getSymbol().equals( ***put a class in here like:     "Test" ) &&
-      //    md.getSymbol().equals( ***put your method in here like: "main" ) 
+      //    md.getSymbol().equals( ***put your method in here like: "main" )
       //) {
       //  bn.setStyle( BlockNode.NORMAL );
       //  System.out.println( bn.printNode( 0 ) );
@@ -520,8 +519,8 @@ public class BuildIR {
 	paramn = paramn.getChild("optional").getFirstChild();
 	System.out.println("OPTIONAL FOUND!!!!!!!");
       } else { optional = false;
-	       System.out.println("NOT OPTIONAL");}
-      
+	       System.out.println("NOT OPTIONAL"); }
+
       TypeDescriptor type=parseTypeDescriptor(paramn);
 
       String paramname=paramn.getChild("single").getTerminal();
@@ -581,25 +580,25 @@ public class BuildIR {
       ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
       ParseNodeVector pnv=snlist.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-        ParseNode decl=pnv.elementAt(i);
-        if (isNode(decl,"type")) {
-          NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
-          cn.addSuperInterface(nd.toString());
-        }
+	ParseNode decl=pnv.elementAt(i);
+	if (isNode(decl,"type")) {
+	  NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
+	  cn.addSuperInterface(nd.toString());
+	}
       }
     }
     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
     parseClassBody(cn, pn.getChild("classbody"));
-    
+
     boolean hasConstructor = false;
-    for(Iterator method_it=cn.getMethods(); method_it.hasNext();) {
+    for(Iterator method_it=cn.getMethods(); method_it.hasNext(); ) {
       MethodDescriptor md=(MethodDescriptor)method_it.next();
       hasConstructor |= md.isConstructor();
     }
     if((!hasConstructor) && (!cn.isEnum())) {
       // add a default constructor for this class
       MethodDescriptor md = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC),
-          cn.getSymbol(), false);
+                                                 cn.getSymbol(), false);
       BlockNode bn=new BlockNode();
       state.addTreeCode(md,bn);
       md.setDefaultConstructor();
@@ -627,41 +626,41 @@ public class BuildIR {
       }
     }
   }
-  
+
   private void parseLocationOrder(ClassDescriptor cd, ParseNode pn) {
     ParseNodeVector pnv = pn.getChildren();
     Lattice<String> locOrder =
-        new Lattice<String>("_top_","_bottom_");            
+      new Lattice<String>("_top_","_bottom_");
     Set<String> spinLocSet=new HashSet<String>();
     for (int i = 0; i < pnv.size(); i++) {
       ParseNode loc = pnv.elementAt(i);
-      if(isNode(loc,"location_property")){
-        String spinLoc=loc.getChildren().elementAt(0).getLabel();
-        spinLocSet.add(spinLoc);
+      if(isNode(loc,"location_property")) {
+	String spinLoc=loc.getChildren().elementAt(0).getLabel();
+	spinLocSet.add(spinLoc);
       } else {
-        String lowerLoc=loc.getChildren().elementAt(0).getLabel();
-        String higherLoc= loc.getChildren().elementAt(1).getLabel();
-        locOrder.put(higherLoc, lowerLoc);
-        if (locOrder.isIntroducingCycle(higherLoc)) {
-          throw new Error("Error: the order relation " + lowerLoc + " < " + higherLoc
-              + " introduces a cycle.");
-        }
+	String lowerLoc=loc.getChildren().elementAt(0).getLabel();
+	String higherLoc= loc.getChildren().elementAt(1).getLabel();
+	locOrder.put(higherLoc, lowerLoc);
+	if (locOrder.isIntroducingCycle(higherLoc)) {
+	  throw new Error("Error: the order relation " + lowerLoc + " < " + higherLoc
+	                  + " introduces a cycle.");
+	}
       }
     }
-    if(spinLocSet.size()>0){
+    if(spinLocSet.size()>0) {
       //checking if location is actually defined in the hierarchy
-      for (Iterator iterator = spinLocSet.iterator(); iterator.hasNext();) {
-        String locID = (String) iterator.next();
-        if(!locOrder.containsKey(locID)){
-          throw new Error("Error: The spinning location '"+
-              locID + "' is not defined in the hierarchy of the class '"+cd +"'.");
-        }
+      for (Iterator iterator = spinLocSet.iterator(); iterator.hasNext(); ) {
+	String locID = (String) iterator.next();
+	if(!locOrder.containsKey(locID)) {
+	  throw new Error("Error: The spinning location '"+
+	                  locID + "' is not defined in the hierarchy of the class '"+cd +"'.");
+	}
       }
       state.addLocationPropertySet(cd, spinLocSet);
     }
     state.addLocationOrder(cd, locOrder);
   }
-  
+
   private void parseClassMember(ClassDescriptor cn, ParseNode pn) {
     ParseNode fieldnode=pn.getChild("field");
     if (fieldnode!=null) {
@@ -695,7 +694,7 @@ public class BuildIR {
     }
     throw new Error();
   }
-  
+
   private ClassDescriptor parseInnerClassDecl(ClassDescriptor cn, ParseNode pn) {
     ClassDescriptor icn=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
     icn.setImports(mandatoryImports);
@@ -710,8 +709,8 @@ public class BuildIR {
       icn.setSuper(nd.toString());
     } else {
       if (!(icn.getSymbol().equals(TypeUtil.ObjectClass)||
-          icn.getSymbol().equals(TypeUtil.TagClass)))
-        icn.setSuper(TypeUtil.ObjectClass);
+            icn.getSymbol().equals(TypeUtil.TagClass)))
+	icn.setSuper(TypeUtil.ObjectClass);
     }
     // check inherited interfaces
     if (!isEmpty(pn.getChild("superIF").getTerminal())) {
@@ -719,17 +718,17 @@ public class BuildIR {
       ParseNode snlist=pn.getChild("superIF").getChild("interface_type_list");
       ParseNodeVector pnv=snlist.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-        ParseNode decl=pnv.elementAt(i);
-        if (isNode(decl,"type")) {
-          NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
-          icn.addSuperInterface(nd.toString());
-        }
+	ParseNode decl=pnv.elementAt(i);
+	if (isNode(decl,"type")) {
+	  NameDescriptor nd=parseClassName(decl.getChild("class").getChild("name"));
+	  icn.addSuperInterface(nd.toString());
+	}
       }
     }
     icn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
     if(!icn.isStatic()) {
-      throw new Error("Error: inner class " + icn.getSymbol() + " in Class " + 
-          cn.getSymbol() + " is not a nested class and is not supported yet!");
+      throw new Error("Error: inner class " + icn.getSymbol() + " in Class " +
+                      cn.getSymbol() + " is not a nested class and is not supported yet!");
     }
     parseClassBody(icn, pn.getChild("classbody"));
     return icn;
@@ -770,9 +769,9 @@ public class BuildIR {
     }
   }
 
-  //Needed to separate out top level call since if a base exists, 
+  //Needed to separate out top level call since if a base exists,
   //we do not want to apply our resolveName function (i.e. deal with imports)
-  //otherwise, if base == null, we do just want to resolve name. 
+  //otherwise, if base == null, we do just want to resolve name.
   private NameDescriptor parseClassName(ParseNode nn) {
     ParseNode base=nn.getChild("base");
     ParseNode id=nn.getChild("identifier");
@@ -782,7 +781,7 @@ public class BuildIR {
     }
     return new NameDescriptor(parseClassNameRecursive(base.getChild("name")),classname);
   }
-  
+
   private NameDescriptor parseClassNameRecursive(ParseNode nn) {
     ParseNode base=nn.getChild("base");
     ParseNode id=nn.getChild("identifier");
@@ -792,32 +791,32 @@ public class BuildIR {
     }
     return new NameDescriptor(parseClassNameRecursive(base.getChild("name")),classname);
   }
-  
+
   //This will get the mapping of a terminal class name
   //to a canonical classname (with imports/package locations in them)
   private String resolveName(String terminal) {
     if(mandatoryImports.containsKey(terminal)) {
-      return  (String) mandatoryImports.get(terminal);
+      return (String) mandatoryImports.get(terminal);
     } else {
       if(multiimports.containsKey(terminal)) {
-        //Test for error
-        Object o = multiimports.get(terminal);
-        if(o instanceof Error) {
-          throw new Error("Class " + terminal + " is ambiguous. Cause: more than 1 package import contain the same class.");
-        } else {
-          //At this point, if we found a unique class
-          //we can treat it as a single, mandatory import.
-          mandatoryImports.put(terminal, o);
-          return (String) o;
-        }
+	//Test for error
+	Object o = multiimports.get(terminal);
+	if(o instanceof Error) {
+	  throw new Error("Class " + terminal + " is ambiguous. Cause: more than 1 package import contain the same class.");
+	} else {
+	  //At this point, if we found a unique class
+	  //we can treat it as a single, mandatory import.
+	  mandatoryImports.put(terminal, o);
+	  return (String) o;
+	}
       }
     }
-    
+
     return terminal;
   }
-  
+
   //only function difference between this and parseName() is that this
-  //does not look for a import mapping. 
+  //does not look for a import mapping.
   private NameDescriptor parseName(ParseNode nn) {
     ParseNode base=nn.getChild("base");
     ParseNode id=nn.getChild("identifier");
@@ -841,9 +840,9 @@ public class BuildIR {
     if(cn.isInterface()) {
       // TODO add version for normal Java later
       // Can only be PUBLIC or STATIC or FINAL
-      if((m.isAbstract()) || (m.isAtomic()) || (m.isNative()) 
-          || (m.isSynchronized())) {
-        throw new Error("Error: field in Interface " + cn.getSymbol() + "can only be PUBLIC or STATIC or FINAL");
+      if((m.isAbstract()) || (m.isAtomic()) || (m.isNative())
+         || (m.isSynchronized())) {
+	throw new Error("Error: field in Interface " + cn.getSymbol() + "can only be PUBLIC or STATIC or FINAL");
       }
       m.addModifier(Modifiers.PUBLIC);
       m.addModifier(Modifiers.STATIC);
@@ -870,57 +869,57 @@ public class BuildIR {
 
       ExpressionNode en=null;
       if (epn!=null) {
-        en=parseExpression(epn.getFirstChild());
-        en.setNumLine(epn.getFirstChild().getLine());
-        if(m.isStatic()) {
-          // for static field, the initializer should be considered as a 
-          // static block
-          boolean isfirst = false;
-          MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
-          if(md == null) {
-            // the first static block for this class
-            Modifiers m_i=new Modifiers();
-            m_i.addModifier(Modifiers.STATIC);
-            md = new MethodDescriptor(m_i, "staticblocks", false);
-            md.setAsStaticBlock();
-            isfirst = true;
-          }
-          if(isfirst) {
-            cn.addMethod(md);
-          }
-          cn.incStaticBlocks();
-          BlockNode bn=new BlockNode();
-          NameNode nn=new NameNode(new NameDescriptor(identifier));
-          nn.setNumLine(en.getNumLine());
-          AssignmentNode an=new AssignmentNode(nn,en,new AssignOperation(1));
-          an.setNumLine(pn.getLine());
-          bn.addBlockStatement(new BlockExpressionNode(an));
-          if(isfirst) {
-            state.addTreeCode(md,bn);
-          } else {
-            BlockNode obn = state.getMethodBody(md);
-            for(int ii = 0; ii < bn.size(); ii++) {
-              BlockStatementNode bsn = bn.get(ii);
-              obn.addBlockStatement(bsn);
-            }
-            state.addTreeCode(md, obn);
-            bn = null;
-          }
-          en = null;
-        }
+	en=parseExpression(epn.getFirstChild());
+	en.setNumLine(epn.getFirstChild().getLine());
+	if(m.isStatic()) {
+	  // for static field, the initializer should be considered as a
+	  // static block
+	  boolean isfirst = false;
+	  MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
+	  if(md == null) {
+	    // the first static block for this class
+	    Modifiers m_i=new Modifiers();
+	    m_i.addModifier(Modifiers.STATIC);
+	    md = new MethodDescriptor(m_i, "staticblocks", false);
+	    md.setAsStaticBlock();
+	    isfirst = true;
+	  }
+	  if(isfirst) {
+	    cn.addMethod(md);
+	  }
+	  cn.incStaticBlocks();
+	  BlockNode bn=new BlockNode();
+	  NameNode nn=new NameNode(new NameDescriptor(identifier));
+	  nn.setNumLine(en.getNumLine());
+	  AssignmentNode an=new AssignmentNode(nn,en,new AssignOperation(1));
+	  an.setNumLine(pn.getLine());
+	  bn.addBlockStatement(new BlockExpressionNode(an));
+	  if(isfirst) {
+	    state.addTreeCode(md,bn);
+	  } else {
+	    BlockNode obn = state.getMethodBody(md);
+	    for(int ii = 0; ii < bn.size(); ii++) {
+	      BlockStatementNode bsn = bn.get(ii);
+	      obn.addBlockStatement(bsn);
+	    }
+	    state.addTreeCode(md, obn);
+	    bn = null;
+	  }
+	  en = null;
+	}
       }
 
       cn.addField(new FieldDescriptor(m, arrayt, identifier, en, isglobal));
     }
   }
-  
-  private void assignAnnotationsToType(Modifiers modifiers, TypeDescriptor type){
+
+  private void assignAnnotationsToType(Modifiers modifiers, TypeDescriptor type) {
     Vector<AnnotationDescriptor> annotations=modifiers.getAnnotations();
     for(int i=0; i<annotations.size(); i++) {
       // it only supports a marker annotation
       AnnotationDescriptor an=annotations.elementAt(i);
-      type.addAnnotationMarker(an);           
-    }    
+      type.addAnnotationMarker(an);
+    }
   }
 
   int innerCount=0;
@@ -965,15 +964,15 @@ public class BuildIR {
     } else if (isNode(pn,"preinc")||
                isNode(pn,"predec")) {
       ParseNode left=pn.getFirstChild();
-      AssignOperation op=isNode(pn,"preinc") ? new AssignOperation(AssignOperation.PLUSEQ) : new AssignOperation(AssignOperation.MINUSEQ);
+      AssignOperation op=isNode(pn,"preinc")?new AssignOperation(AssignOperation.PLUSEQ):new AssignOperation(AssignOperation.MINUSEQ);
       AssignmentNode an=new AssignmentNode(parseExpression(left),
-          new LiteralNode("integer",new Integer(1)),op);
+                                           new LiteralNode("integer",new Integer(1)),op);
       an.setNumLine(pn.getLine());
       return an;
     } else if (isNode(pn,"literal")) {
       String literaltype=pn.getTerminal();
       ParseNode literalnode=pn.getChild(literaltype);
-      Object literal_obj=literalnode.getLiteral();      
+      Object literal_obj=literalnode.getLiteral();
       LiteralNode ln=new LiteralNode(literaltype, literal_obj);
       ln.setNumLine(pn.getLine());
       return ln;
@@ -984,22 +983,22 @@ public class BuildIR {
       boolean isglobal = pn.getChild("global") != null || pn.getChild("scratch") != null;
       String disjointId = null;
       if (pn.getChild("disjoint") != null) {
-        disjointId = pn.getChild("disjoint").getTerminal();
+	disjointId = pn.getChild("disjoint").getTerminal();
       }
       CreateObjectNode con = new CreateObjectNode(td, isglobal, disjointId);
       con.setNumLine(pn.getLine());
       for (int i = 0; i < args.size(); i++) {
-        con.addArgument((ExpressionNode) args.get(i));
+	con.addArgument((ExpressionNode) args.get(i));
       }
       /* Could have flag set or tag added here */
       if (pn.getChild("flag_list") != null || pn.getChild("tag_list") != null) {
-        FlagEffects fe = new FlagEffects(null);
-        if (pn.getChild("flag_list") != null)
-          parseFlagEffect(fe, pn.getChild("flag_list"));
+	FlagEffects fe = new FlagEffects(null);
+	if (pn.getChild("flag_list") != null)
+	  parseFlagEffect(fe, pn.getChild("flag_list"));
 
-        if (pn.getChild("tag_list") != null)
-          parseTagEffect(fe, pn.getChild("tag_list"));
-        con.addFlagEffects(fe);
+	if (pn.getChild("tag_list") != null)
+	  parseTagEffect(fe, pn.getChild("tag_list"));
+	con.addFlagEffects(fe);
       }
 
       return con;
@@ -1023,7 +1022,7 @@ public class BuildIR {
     } else if (isNode(pn,"createarray")) {
       //System.out.println(pn.PPrint(3,true));
       boolean isglobal=pn.getChild("global")!=null||
-	pn.getChild("scratch")!=null;
+                        pn.getChild("scratch")!=null;
       String disjointId=null;
       if( pn.getChild("disjoint") != null) {
 	disjointId = pn.getChild("disjoint").getTerminal();
@@ -1041,16 +1040,17 @@ public class BuildIR {
 	con.addArgument((ExpressionNode)args.get(i));
       }
       return con;
-    } if (isNode(pn,"createarray2")) {
+    }
+    if (isNode(pn,"createarray2")) {
       TypeDescriptor td=parseTypeDescriptor(pn);
       int num=0;
       if (pn.getChild("dims_opt").getLiteral()!=null)
-    num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
+	num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
       for(int i=0; i<num; i++)
-    td=td.makeArray(state);
+	td=td.makeArray(state);
       CreateObjectNode con=new CreateObjectNode(td, false, null);
       con.setNumLine(pn.getLine());
-      ParseNode ipn = pn.getChild("initializer");     
+      ParseNode ipn = pn.getChild("initializer");
       Vector initializers=parseVariableInitializerList(ipn);
       ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
       ain.setNumLine(pn.getLine());
@@ -1093,7 +1093,7 @@ public class BuildIR {
     } else if (isNode(pn,"fieldaccess")) {
       ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
       String fieldname=pn.getChild("field").getTerminal();
-      
+
       FieldAccessNode fan=new FieldAccessNode(en,fieldname);
       fan.setNumLine(pn.getLine());
       return fan;
@@ -1106,7 +1106,7 @@ public class BuildIR {
     } else if (isNode(pn,"cast1")) {
       try {
 	CastNode cn=new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
-	cn.setNumLine(pn.getLine());      
+	cn.setNumLine(pn.getLine());
 	return cn;
       } catch (Exception e) {
 	System.out.println(pn.PPrint(1,true));
@@ -1123,12 +1123,12 @@ public class BuildIR {
       //System.out.println("Checking the values of: "+ " td.toString()= " + td.toString()+ "  fieldname= " + fieldname);
       return new OffsetNode(td, fieldname);
     } else if (isNode(pn, "tert")) {
-      
+
       TertiaryNode tn=new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
-          parseExpression(pn.getChild("trueexpr").getFirstChild()),
-          parseExpression(pn.getChild("falseexpr").getFirstChild()) );
+                                       parseExpression(pn.getChild("trueexpr").getFirstChild()),
+                                       parseExpression(pn.getChild("falseexpr").getFirstChild()) );
       tn.setNumLine(pn.getLine());
-      
+
       return tn;
     } else if (isNode(pn, "instanceof")) {
       ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
@@ -1136,7 +1136,7 @@ public class BuildIR {
       InstanceOfNode ion=new InstanceOfNode(exp,t);
       ion.setNumLine(pn.getLine());
       return ion;
-    } else if (isNode(pn, "array_initializer")) {  
+    } else if (isNode(pn, "array_initializer")) {
       Vector initializers=parseVariableInitializerList(pn);
       return new ArrayInitializerNode(initializers);
     } else if (isNode(pn, "class_type")) {
@@ -1230,7 +1230,7 @@ public class BuildIR {
       // at the AST level, someday should evolve into a nice compiler
       // option *wink*
       //if( cn.getSymbol().equals( ***put a class in here like:     "Test" ) &&
-      //    md.getSymbol().equals( ***put your method in here like: "main" ) 
+      //    md.getSymbol().equals( ***put your method in here like: "main" )
       //) {
       //  bn.setStyle( BlockNode.NORMAL );
       //  System.out.println( bn.printNode( 0 ) );
@@ -1291,9 +1291,9 @@ public class BuildIR {
     }
     state.addTreeCode(md,bn);
   }
-  
+
   private void parseStaticBlockDecl(ClassDescriptor cn, ParseNode pn) {
-    // Each class maintains one MethodDecscriptor which combines all its 
+    // Each class maintains one MethodDecscriptor which combines all its
     // static blocks in their declaration order
     boolean isfirst = false;
     MethodDescriptor md = (MethodDescriptor)cn.getMethodTable().getFromSameScope("staticblocks");
@@ -1320,8 +1320,8 @@ public class BuildIR {
     } else {
       BlockNode obn = state.getMethodBody(md);
       for(int i = 0; i < bn.size(); i++) {
-        BlockStatementNode bsn = bn.get(i);
-        obn.addBlockStatement(bsn);
+	BlockStatementNode bsn = bn.get(i);
+	obn.addBlockStatement(bsn);
       }
       state.addTreeCode(md, obn);
       bn = null;
@@ -1375,16 +1375,16 @@ public class BuildIR {
 
       TagDeclarationNode tdn=new TagDeclarationNode(name, type);
       tdn.setNumLine(pn.getLine());
-      
+
       blockstatements.add(tdn);
     } else if (isNode(pn,"local_variable_declaration")) {
-      
-      ParseNode mn=pn.getChild("modifiers");         
+
+      ParseNode mn=pn.getChild("modifiers");
       TypeDescriptor t=parseTypeDescriptor(pn);
-      if(mn!=null){
-        Modifiers m=parseModifiersList(mn);
-        assignAnnotationsToType(m, t);        
-      }   
+      if(mn!=null) {
+	Modifiers m=parseModifiersList(mn);
+	assignAnnotationsToType(m, t);
+      }
       ParseNode vn=pn.getChild("variable_declarators_list");
       ParseNodeVector pnv=vn.getChildren();
       for(int i=0; i<pnv.size(); i++) {
@@ -1406,7 +1406,7 @@ public class BuildIR {
 	ExpressionNode en=null;
 	if (epn!=null)
 	  en=parseExpression(epn.getFirstChild());
-	
+
 	DeclarationNode dn=new DeclarationNode(new VarDescriptor(arrayt, identifier),en);
 	dn.setNumLine(tmp.getLine());
 
@@ -1420,47 +1420,47 @@ public class BuildIR {
       blockstatements.add(ben);
     } else if (isNode(pn,"ifstatement")) {
       IfStatementNode isn=new IfStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
-          parseSingleBlock(pn.getChild("statement").getFirstChild()),
-          pn.getChild("else_statement")!=null ? parseSingleBlock(pn.getChild("else_statement").getFirstChild()) : null);
+                                              parseSingleBlock(pn.getChild("statement").getFirstChild()),
+                                              pn.getChild("else_statement")!=null?parseSingleBlock(pn.getChild("else_statement").getFirstChild()):null);
       isn.setNumLine(pn.getLine());
-      
+
       blockstatements.add(isn);
     } else if (isNode(pn,"switch_statement")) {
       // TODO add version for normal Java later
       SwitchStatementNode ssn=new SwitchStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
-          parseSingleBlock(pn.getChild("statement").getFirstChild()));
+                                                      parseSingleBlock(pn.getChild("statement").getFirstChild()));
       ssn.setNumLine(pn.getLine());
       blockstatements.add(ssn);
     } else if (isNode(pn,"switch_block_list")) {
       // TODO add version for normal Java later
       ParseNodeVector pnv=pn.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-        ParseNode sblockdecl=pnv.elementAt(i);
-        
-        if(isNode(sblockdecl, "switch_block")) {
-          ParseNode lpn=sblockdecl.getChild("switch_labels").getChild("switch_label_list");
-          ParseNodeVector labelv=lpn.getChildren();
-          Vector<SwitchLabelNode> slv = new Vector<SwitchLabelNode>();
-          for(int j=0; j<labelv.size(); j++) {
-            ParseNode labeldecl=labelv.elementAt(j);
-            if(isNode(labeldecl, "switch_label")) {
-              SwitchLabelNode sln=new SwitchLabelNode(parseExpression(labeldecl.getChild("constant_expression").getFirstChild()), false);
-              sln.setNumLine(labeldecl.getLine());
-              slv.addElement(sln);
-            } else if(isNode(labeldecl, "default_switch_label")) {
-              SwitchLabelNode sln=new SwitchLabelNode(null, true);
-              sln.setNumLine(labeldecl.getLine());
-              slv.addElement(sln);
-            }
-          }
-          
-          SwitchBlockNode sbn=new SwitchBlockNode(slv, 
-              parseSingleBlock(sblockdecl.getChild("switch_statements").getFirstChild()));
-          sbn.setNumLine(sblockdecl.getLine());
-          
-          blockstatements.add(sbn);
-          
-        }
+	ParseNode sblockdecl=pnv.elementAt(i);
+
+	if(isNode(sblockdecl, "switch_block")) {
+	  ParseNode lpn=sblockdecl.getChild("switch_labels").getChild("switch_label_list");
+	  ParseNodeVector labelv=lpn.getChildren();
+	  Vector<SwitchLabelNode> slv = new Vector<SwitchLabelNode>();
+	  for(int j=0; j<labelv.size(); j++) {
+	    ParseNode labeldecl=labelv.elementAt(j);
+	    if(isNode(labeldecl, "switch_label")) {
+	      SwitchLabelNode sln=new SwitchLabelNode(parseExpression(labeldecl.getChild("constant_expression").getFirstChild()), false);
+	      sln.setNumLine(labeldecl.getLine());
+	      slv.addElement(sln);
+	    } else if(isNode(labeldecl, "default_switch_label")) {
+	      SwitchLabelNode sln=new SwitchLabelNode(null, true);
+	      sln.setNumLine(labeldecl.getLine());
+	      slv.addElement(sln);
+	    }
+	  }
+
+	  SwitchBlockNode sbn=new SwitchBlockNode(slv,
+	                                          parseSingleBlock(sblockdecl.getChild("switch_statements").getFirstChild()));
+	  sbn.setNumLine(sblockdecl.getLine());
+
+	  blockstatements.add(sbn);
+
+	}
       }
     } else if (isNode(pn, "trycatchstatement")) {
       // TODO add version for normal Java later
@@ -1469,12 +1469,12 @@ public class BuildIR {
       ParseNode tpn = pn.getChild("tryblock").getFirstChild();
       BlockNode bn=parseBlockHelper(tpn);
       blockstatements.add(new SubBlockNode(bn));
-      
+
       ParseNode fbk = pn.getChild("finallyblock");
       if(fbk != null) {
-        ParseNode fpn = fbk.getFirstChild();
-        BlockNode fbn=parseBlockHelper(fpn);
-        blockstatements.add(new SubBlockNode(fbn));
+	ParseNode fpn = fbk.getFirstChild();
+	BlockNode fbn=parseBlockHelper(fpn);
+	blockstatements.add(new SubBlockNode(fbn));
       }
     } else if (isNode(pn, "throwstatement")) {
       // TODO Simply return here
@@ -1528,8 +1528,8 @@ public class BuildIR {
       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
       if(condition == null) {
-        // no condition clause, make a 'true' expression as the condition
-        condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
+	// no condition clause, make a 'true' expression as the condition
+	condition = (ExpressionNode) new LiteralNode("boolean", new Boolean(true));
       }
       LoopNode ln=new LoopNode(init,condition,update,body);
       ln.setNumLine(pn.getLine());
@@ -1538,27 +1538,29 @@ public class BuildIR {
       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
       if(condition == null) {
-        // no condition clause, make a 'true' expression as the condition
-        condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
+	// no condition clause, make a 'true' expression as the condition
+	condition = (ExpressionNode) new LiteralNode("boolean", new Boolean(true));
       }
       blockstatements.add(new LoopNode(condition,body,LoopNode.WHILELOOP));
     } else if (isNode(pn,"dowhilestatement")) {
       ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
       BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
       if(condition == null) {
-        // no condition clause, make a 'true' expression as the condition
-        condition = (ExpressionNode)new LiteralNode("boolean", new Boolean(true));
+	// no condition clause, make a 'true' expression as the condition
+	condition = (ExpressionNode) new LiteralNode("boolean", new Boolean(true));
       }
       blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP));
     } else if (isNode(pn,"sese")) {
       ParseNode pnID=pn.getChild("identifier");
       String stID=null;
-      if( pnID != null ) { stID=pnID.getFirstChild().getTerminal(); }
+      if( pnID != null ) {
+	stID=pnID.getFirstChild().getTerminal();
+      }
       SESENode start=new SESENode(stID);
       start.setNumLine(pn.getLine());
       SESENode end  =new SESENode(stID);
-      start.setEnd( end   );
-      end.setStart( start );
+      start.setEnd(end);
+      end.setStart(start);
       blockstatements.add(start);
       blockstatements.addAll(parseSESEBlock(blockstatements,pn.getChild("body").getFirstChild()));
       blockstatements.add(end);
@@ -1575,13 +1577,13 @@ public class BuildIR {
       // name_pn.getTerminal() gives you the label
     } else if (isNode(pn,"genreach")) {
       String graphName = pn.getChild("graphName").getTerminal();
-      blockstatements.add( new GenReachNode( graphName ) );
+      blockstatements.add(new GenReachNode(graphName) );
 
-    } else if(isNode(pn,"labeledstatement")){
+    } else if(isNode(pn,"labeledstatement")) {
       String label = pn.getChild("name").getTerminal();
       BlockNode bn=parseSingleBlock(pn.getChild("statement").getFirstChild());
       bn.setLabel(label);
-      blockstatements.add(new SubBlockNode(bn));  
+      blockstatements.add(new SubBlockNode(bn));
     } else {
       System.out.println("---------------");
       System.out.println(pn.PPrint(3,true));
@@ -1623,7 +1625,7 @@ public class BuildIR {
 	TypeDescriptor type=new TypeDescriptor(TypeDescriptor.TAG);
 	md.addTagParameter(type, paramname);
       } else  {
-        
+
 	TypeDescriptor type=parseTypeDescriptor(paramn);
 
 	ParseNode tmp=paramn;
@@ -1634,11 +1636,11 @@ public class BuildIR {
 	String paramname=tmp.getChild("single").getTerminal();
 
 	md.addParameter(type, paramname);
-  if(isNode(paramn, "annotation_parameter")){
-    ParseNode bodynode=paramn.getChild("annotation_body");
-    parseParameterAnnotation(bodynode,type);
-  }
-  
+	if(isNode(paramn, "annotation_parameter")) {
+	  ParseNode bodynode=paramn.getChild("annotation_body");
+	  parseParameterAnnotation(bodynode,type);
+	}
+
       }
     }
   }
@@ -1649,7 +1651,7 @@ public class BuildIR {
     if (modlist!=null) {
       ParseNodeVector pnv=modlist.getChildren();
       for(int i=0; i<pnv.size(); i++) {
-	ParseNode modn=pnv.elementAt(i);	
+	ParseNode modn=pnv.elementAt(i);
 	if (isNode(modn,"public"))
 	  m.addModifier(Modifiers.PUBLIC);
 	else if (isNode(modn,"protected"))
@@ -1666,51 +1668,52 @@ public class BuildIR {
 	  m.addModifier(Modifiers.SYNCHRONIZED);
 	else if (isNode(modn,"atomic"))
 	  m.addModifier(Modifiers.ATOMIC);
-    else if (isNode(modn,"abstract"))
-      m.addModifier(Modifiers.ABSTRACT);
-    else if (isNode(modn,"volatile"))
-      m.addModifier(Modifiers.VOLATILE);
-    else if (isNode(modn,"transient"))
-      m.addModifier(Modifiers.TRANSIENT);
-    else if(isNode(modn,"annotation_list"))
-      parseAnnotationList(modn,m);    
-	else{	  
-	  throw new Error("Unrecognized Modifier:"+modn.getLabel());}
+	else if (isNode(modn,"abstract"))
+	  m.addModifier(Modifiers.ABSTRACT);
+	else if (isNode(modn,"volatile"))
+	  m.addModifier(Modifiers.VOLATILE);
+	else if (isNode(modn,"transient"))
+	  m.addModifier(Modifiers.TRANSIENT);
+	else if(isNode(modn,"annotation_list"))
+	  parseAnnotationList(modn,m);
+	else {
+	  throw new Error("Unrecognized Modifier:"+modn.getLabel());
+	}
       }
     }
     return m;
   }
-  
+
   private void parseAnnotationList(ParseNode pn, Modifiers m) {
     ParseNodeVector pnv = pn.getChildren();
     for (int i = 0; i < pnv.size(); i++) {
       ParseNode body_list = pnv.elementAt(i);
       if (isNode(body_list, "annotation_body")) {
-        ParseNode body_node = body_list.getFirstChild();
-        if (isNode(body_node, "marker_annotation")) {
-          m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
-        } else if (isNode(body_node, "single_annotation")) {
-          m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
-              body_node.getChild("element_value").getTerminal()));
-        } else if (isNode(body_node, "normal_annotation")) {
-          throw new Error("Annotation with multiple data members is not supported yet.");
-        }
+	ParseNode body_node = body_list.getFirstChild();
+	if (isNode(body_node, "marker_annotation")) {
+	  m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
+	} else if (isNode(body_node, "single_annotation")) {
+	  m.addAnnotation(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
+	                                           body_node.getChild("element_value").getTerminal()));
+	} else if (isNode(body_node, "normal_annotation")) {
+	  throw new Error("Annotation with multiple data members is not supported yet.");
+	}
       }
     }
   }
-  
-  private void parseParameterAnnotation(ParseNode body_list,TypeDescriptor type){
+
+  private void parseParameterAnnotation(ParseNode body_list,TypeDescriptor type) {
     ParseNode body_node = body_list.getFirstChild();
     if (isNode(body_node, "marker_annotation")) {
       type.addAnnotationMarker(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
     } else if (isNode(body_node, "single_annotation")) {
       type.addAnnotationMarker(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
-          body_node.getChild("element_value").getTerminal()));
+                                                        body_node.getChild("element_value").getTerminal()));
     } else if (isNode(body_node, "normal_annotation")) {
       throw new Error("Annotation with multiple data members is not supported yet.");
     }
   }
-  
+
   private boolean isNode(ParseNode pn, String label) {
     if (pn.getLabel().equals(label))
       return true;