X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FIR%2FTree%2FBuildIR.java;h=c8efb8e7bc29898770e26fdbb7b1bb8a90733140;hb=d396c42d2a86460c7e220d21e5219049c177c5cf;hp=5d2b689beed7e233939c2140afae36d1b6ba5eb0;hpb=d56ced93c269c5840dc396bc4d9faa02ffb3280b;p=IRC.git

diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 5d2b689b..c8efb8e7 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -184,18 +184,41 @@ public class BuildIR {
 
   public void parseInitializers(ClassDescriptor cn) {
     Vector fv=cn.getFieldVec();
+    Iterator methodit = cn.getMethods();
+    HashMap<MethodDescriptor, Integer> md2pos = new HashMap<MethodDescriptor, Integer>();
+    while(methodit.hasNext()) {
+      MethodDescriptor currmd=(MethodDescriptor)methodit.next();
+      if(currmd.isConstructor()) {
+        BlockNode bn=state.getMethodBody(currmd);
+        // if there are super(...) invokation, the initializers should be invoked after that
+        int i = 0;
+        for(; i < bn.size(); i++) {
+          if(Kind.BlockExpressionNode==bn.get(i).kind()
+        	  &&(((BlockExpressionNode)bn.get(i)).getExpression() instanceof MethodInvokeNode)
+        	  &&((MethodInvokeNode)(((BlockExpressionNode)bn.get(i)).getExpression())).getMethodName().equals("super")) {
+            break;
+          }
+        }
+        if(i==bn.size()) {
+          md2pos.put(currmd, 0);
+        } else {
+          md2pos.put(currmd, i+1);
+        }
+      }
+    }
     int pos = 0;
     for(int i=0; i<fv.size(); i++) {
       FieldDescriptor fd=(FieldDescriptor)fv.get(i);
       if(fd.getExpressionNode()!=null) {
-        Iterator methodit = cn.getMethods();
+        methodit = cn.getMethods();
         while(methodit.hasNext()) {
           MethodDescriptor currmd=(MethodDescriptor)methodit.next();
           if(currmd.isConstructor()) {
+            int offset = md2pos.get(currmd);
             BlockNode bn=state.getMethodBody(currmd);
             NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
             AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
-            bn.addBlockStatementAt(new BlockExpressionNode(an), pos);
+            bn.addBlockStatementAt(new BlockExpressionNode(an), pos+offset);
           }
         }
         pos++;
@@ -230,10 +253,7 @@ public class BuildIR {
     ecd.setModifiers(parseModifiersList(pn.getChild("modifiers")));
     parseEnumBody(ecd, pn.getChild("enumbody"));
 
-    if (analyzeset != null)
-      analyzeset.add(ecd);
-    ecd.setSourceFileName(currsourcefile);
-    state.addClass(ecd);
+    addClass2State(ecd);
 
     popChainMaps();
     return ecd;
@@ -267,10 +287,7 @@ public class BuildIR {
     parseAnnotationTypeBody(cn,pn.getChild("body"));
     popChainMaps();
 
-    if (analyzeset != null)
-      analyzeset.add(cn);
-    cn.setSourceFileName(currsourcefile);
-    state.addClass(cn);
+    addClass2State(cn);
 
     return cn;
   }
@@ -332,10 +349,7 @@ public class BuildIR {
     }
     cn.setModifiers(parseModifiersList(pn.getChild("modifiers")));
     parseInterfaceBody(cn, pn.getChild("interfacebody"));
-    if (analyzeset != null)
-      analyzeset.add(cn);
-    cn.setSourceFileName(currsourcefile);
-    state.addClass(cn);
+    addClass2State(cn);
     popChainMaps();
     return cn;
   }
@@ -375,7 +389,7 @@ public class BuildIR {
     md.getModifiers().addModifier(Modifiers.PUBLIC);
     md.getModifiers().addModifier(Modifiers.ABSTRACT);
     try {
-      BlockNode bn=parseBlock(cn, bodyn);
+      BlockNode bn=parseBlock(cn, md, md.isStatic()||md.isStaticBlock(), bodyn);
       cn.addMethod(md);
       state.addTreeCode(md,bn);
     } catch (Exception e) {
@@ -392,7 +406,7 @@ public class BuildIR {
   public TaskDescriptor parseTaskDecl(ParseNode pn) {
     TaskDescriptor td=new TaskDescriptor(pn.getChild("name").getTerminal());
     ParseNode bodyn=pn.getChild("body");
-    BlockNode bn=parseBlock(null, bodyn);
+    BlockNode bn=parseBlock(null, null, false, bodyn);
     parseParameterList(td, pn);
     state.addTreeCode(td,bn);
     if (pn.getChild("flag_effects_list")!=null)
@@ -546,6 +560,22 @@ public class BuildIR {
     return tel;
   }
 
+  private void addClass2State(ClassDescriptor cn) {
+    if (analyzeset != null)
+      analyzeset.add(cn);
+    cn.setSourceFileName(currsourcefile);
+    state.addClass(cn);
+    // create this$n representing a final reference to the next surrounding class. each inner class should have whatever inner class
+    // pointers the surrounding class has + a pointer to the surrounding class.
+    if( true )
+    {
+      this.isRunningRecursiveInnerClass = true; //fOR dEBUGGING PURPOSES IN ORDER TO DUMP STRINGS WHILE IN THIS CODE PATH
+      addOuterClassReferences( cn, cn, 0 );
+      addOuterClassParam( cn, cn, 0 );
+      this.isRunningRecursiveInnerClass = false;
+    }
+  }
+  
   public ClassDescriptor parseTypeDecl(ParseNode pn) {
     ClassDescriptor cn=new ClassDescriptor(packageName, pn.getChild("name").getTerminal(), false);
     pushChainMaps();
@@ -595,21 +625,9 @@ public class BuildIR {
     popChainMaps();
 
     cn.setSourceFileName(currsourcefile);
-
-
     
-    if (analyzeset != null)
-      analyzeset.add(cn);
-    state.addClass(cn);
-//create this$n representing a final reference to the next surrounding class. each inner class should have whatever inner class
-//pointers the surrounding class has + a pointer to the surrounding class.
-   if( true )
-   {
-   	this.isRunningRecursiveInnerClass = true; //fOR dEBUGGING PURPOSES IN ORDER TO DUMP STRINGS WHILE IN THIS CODE PATH
-    	addOuterClassReferences( cn, 0 );
-	addOuterClassParam( cn, 0 );
-    	this.isRunningRecursiveInnerClass = false;
-    }
+    addClass2State(cn);
+
     return cn;
   }
 
@@ -625,18 +643,18 @@ private void initializeOuterMember( MethodDescriptor md, String fieldName, Strin
          state.addTreeCode(md, obn);
 }
 
-private void addOuterClassParam( ClassDescriptor cn, int depth )
+private void addOuterClassParam( ClassDescriptor cn, ClassDescriptor ocn, int depth )
 {
 	Iterator nullCheckItr = cn.getInnerClasses();
 	if( false == nullCheckItr.hasNext() )
 		return;
 
 	//create a typedescriptor of type cn
-	TypeDescriptor theTypeDesc = new TypeDescriptor( cn );
+	TypeDescriptor theTypeDesc = new TypeDescriptor( ocn );
 	
 	for(Iterator it=cn.getInnerClasses(); it.hasNext(); ) {
       		ClassDescriptor icd=(ClassDescriptor)it.next();
-      		if(icd.isStatic()) {
+      		if(icd.isStatic()||icd.getInStaticContext()) {
       		    continue;
       		}
 		
@@ -644,24 +662,24 @@ private void addOuterClassParam( ClassDescriptor cn, int depth )
 		for(Iterator method_it=icd.getMethods(); method_it.hasNext(); ) {
      			 MethodDescriptor md=(MethodDescriptor)method_it.next();
       			 if( md.isConstructor() ){
-				md.addParameter( theTypeDesc, "surrounding$" + String.valueOf(depth) );	
-				initializeOuterMember( md, "this$" + String.valueOf( depth ), "surrounding$" + String.valueOf(depth) );
-				//System.out.println( "The added param is " + md.toString() + "\n" );		
+				md.addParameter( theTypeDesc, "surrounding___DOLLAR___" + String.valueOf(depth) );	
+				initializeOuterMember( md, "this___DOLLAR___" + String.valueOf( depth ), "surrounding___DOLLAR___" + String.valueOf(depth) );
+				//System.out.println( "The added param is " + md.toString() + "\n" );
 			}
    		}
-		addOuterClassParam( icd, depth + 1 );
+		addOuterClassParam( icd, ocn, depth + 1 );
 		
     	}
 	
 }
-private void addOuterClassReferences( ClassDescriptor cn, int depth )
+private void addOuterClassReferences( ClassDescriptor cn, ClassDescriptor ocn, int depth )
 {
 	//SYMBOLTABLE does not have a length or empty method, hence could not define a hasInnerClasses method in classDescriptor
 	Iterator nullCheckItr = cn.getInnerClasses();
 	if( false == nullCheckItr.hasNext() )
 		return;
 
-	String tempCopy = cn.getClassName();
+	String tempCopy = ocn.getClassName();
 	//MESSY HACK FOLLOWS
 	int i = 0;
 
@@ -673,7 +691,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 	tempChildNode.addChild("identifier").addChild ( tempCopy );
 	theNode.addChild("type").addChild( theTypeNode );
 	ParseNode variableDeclaratorID = new ParseNode("single");
-	String theStr = "this$" + String.valueOf( depth );
+	String theStr = "this___DOLLAR___" + String.valueOf( depth );
 	variableDeclaratorID.addChild( theStr );
 	ParseNode variableDeclarator = new ParseNode( "variable_declarator" );
 	variableDeclarator.addChild( variableDeclaratorID );
@@ -683,13 +701,16 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 
 	for(Iterator it=cn.getInnerClasses(); it.hasNext(); ) {
       		ClassDescriptor icd=(ClassDescriptor)it.next();
+      		if(icd.isStatic() || icd.getInStaticContext()) {
+      		  continue;
+      		}
 		parseFieldDecl( icd, theNode );		
 		/*if( true ) {
 			SymbolTable fieldTable = icd.getFieldTable();
 			//System.out.println( fieldTable.toString() );
 		}*/
 		icd.setInnerDepth( depth + 1 );
-		addOuterClassReferences( icd, depth + 1 );	
+		addOuterClassReferences( icd, ocn, depth + 1 );	
     	}
 }
 
@@ -818,10 +839,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
    }
     popChainMaps();
 
-     if (analyzeset != null)
-      analyzeset.add(icn);
-    icn.setSourceFileName(currsourcefile);
-    state.addClass(icn);
+    addClass2State(icn);
 
     return icn;
   }
@@ -969,7 +987,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       ExpressionNode en=null;
       
       if (epn!=null) {
-        en=parseExpression(cn, epn.getFirstChild());
+        en=parseExpression(cn, null, m.isStatic(), epn.getFirstChild());
         en.setNumLine(epn.getFirstChild().getLine());
         if(m.isStatic()) {
           // for static field, the initializer should be considered as a
@@ -1025,11 +1043,11 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 
   int innerCount=0;
 
-  private ExpressionNode parseExpression(ClassDescriptor cn, ParseNode pn) {
+  private ExpressionNode parseExpression(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     if (isNode(pn,"assignment"))
 	{
           //System.out.println( "parsing a field decl in my class that has assignment in initialization " + pn.PPrint( 0, true ) + "\n");
-      return parseAssignmentExpression(cn, pn);
+      return parseAssignmentExpression(cn, md, isStaticContext, pn);
 	}
     else if (isNode(pn,"logical_or")||isNode(pn,"logical_and")||
              isNode(pn,"bitwise_or")||isNode(pn,"bitwise_xor")||
@@ -1045,7 +1063,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       ParseNode left=pnv.elementAt(0);
       ParseNode right=pnv.elementAt(1);
       Operation op=new Operation(pn.getLabel());
-      OpNode on=new OpNode(parseExpression(cn, left),parseExpression(cn, right),op);
+      OpNode on=new OpNode(parseExpression(cn, md, isStaticContext, left),parseExpression(cn, md, isStaticContext,  right),op);
       on.setNumLine(pn.getLine());
       return on;
     } else if (isNode(pn,"unaryplus")||
@@ -1054,14 +1072,14 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
                isNode(pn,"comp")) {
       ParseNode left=pn.getFirstChild();
       Operation op=new Operation(pn.getLabel());
-      OpNode on=new OpNode(parseExpression(cn, left),op);
+      OpNode on=new OpNode(parseExpression(cn, md, isStaticContext, left),op);
       on.setNumLine(pn.getLine());
       return on;
     } else if (isNode(pn,"postinc")||
                isNode(pn,"postdec")) {
       ParseNode left=pn.getFirstChild();
       AssignOperation op=new AssignOperation(pn.getLabel());
-      AssignmentNode an=new AssignmentNode(parseExpression(cn, left),null,op);
+      AssignmentNode an=new AssignmentNode(parseExpression(cn, md, isStaticContext, left),null,op);
       an.setNumLine(pn.getLine());
       return an;
 
@@ -1069,7 +1087,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
                isNode(pn,"predec")) {
       ParseNode left=pn.getFirstChild();
       AssignOperation op=isNode(pn,"preinc")?new AssignOperation(AssignOperation.PLUSEQ):new AssignOperation(AssignOperation.MINUSEQ);
-      AssignmentNode an=new AssignmentNode(parseExpression(cn, left),
+      AssignmentNode an=new AssignmentNode(parseExpression(cn, md, isStaticContext, left),
                                            new LiteralNode("integer",new Integer(1)),op);
       an.setNumLine(pn.getLine());
       return an;
@@ -1083,7 +1101,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     } else if (isNode(pn, "createobject")) {
       TypeDescriptor td = parseTypeDescriptor(pn);
 
-      Vector args = parseArgumentList(cn, pn);
+      Vector args = parseArgumentList(cn, md, isStaticContext, pn);
       boolean isglobal = pn.getChild("global") != null || pn.getChild("scratch") != null;
       String disjointId = null;
       if (pn.getChild("disjoint") != null) {
@@ -1096,14 +1114,14 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       if( null != idChild && null != idChild.getFirstChild() ) {
 	idChild = idChild.getFirstChild();
 	//System.out.println( "\nThe object passed has this expression " + idChild.PPrint( 0, true ) );
-	ExpressionNode en = parseExpression(cn, idChild ); 
+	ExpressionNode en = parseExpression(cn, md, isStaticContext, idChild ); 
 	//System.out.println( "\nThe object passed has this expression " + en.printNode( 0 ) );
 	con.setSurroundingExpression( en );
       }
       else if( null != baseChild  && null != baseChild.getFirstChild()  ) {
 	baseChild = baseChild.getFirstChild();
 	//System.out.println( "\nThe object passed has this expression " + baseChild.PPrint( 0, true ) );
-	ExpressionNode en = parseExpression(cn, baseChild ); 
+	ExpressionNode en = parseExpression(cn, md, isStaticContext, baseChild ); 
 	//System.out.println( "\nThe object passed has this expression " + en.printNode( 0 ) );
 	con.setSurroundingExpression( en );     
       }
@@ -1132,29 +1150,40 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       cnnew.setSuper(td.getSymbol());
       cnnew.setInline();
       // the inline anonymous class does not have modifiers, it cannot be static 
-      // TODO: need to check the Java specification
-      cnnew.setModifiers(new Modifiers(Modifiers.PUBLIC));
+      // it is always implicit final
+      cnnew.setModifiers(new Modifiers(Modifiers.FINAL));
       cnnew.setAsInnerClass();
       cnnew.setSurroundingClass(cn.getSymbol());
       cnnew.setSurrounding(cn);
       cn.addInnerClass(cnnew);
+      // Note that if the inner class is declared in a static context, it does NOT 
+      // have lexically enclosing instances.
+      if((null!=md)&&(md.isStatic()||md.isStaticBlock())) {
+	cnnew.setSurroundingBlock(md);
+	cnnew.setInStaticContext();
+      } else if (isStaticContext) {
+	cnnew.setInStaticContext();
+      }
       parseClassBody(cnnew, pn.getChild("decl").getChild("classbody"));
       boolean hasConstructor = false;
       for(Iterator method_it=cnnew.getMethods(); method_it.hasNext(); ) {
-	  MethodDescriptor md=(MethodDescriptor)method_it.next();
-	  hasConstructor |= md.isConstructor();
+	  MethodDescriptor cmd=(MethodDescriptor)method_it.next();
+	  hasConstructor |= cmd.isConstructor();
       }
-      if((!hasConstructor) && (!cnnew.isEnum())) {
+      if(hasConstructor) {
+	  // anonymous class should not have explicit constructors
+	  throw new Error("Error! Anonymous class " + cnnew.getSymbol() + " in " + cn.getSymbol() + " has explicit constructors!");
+      } else if(!cnnew.isEnum()) {
 	  // add a default constructor for this class
-	  MethodDescriptor md = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC),cnnew.getSymbol(), false);
+	  MethodDescriptor cmd = new MethodDescriptor(new Modifiers(Modifiers.PUBLIC|Modifiers.FINAL),cnnew.getSymbol(), false);
 	  BlockNode bn=new BlockNode();
-	  state.addTreeCode(md,bn);
-	  md.setDefaultConstructor();
-	  cnnew.addMethod(md);
+	  state.addTreeCode(cmd,bn);
+	  cmd.setDefaultConstructor();
+	  cnnew.addMethod(cmd);
       }
       TypeDescriptor tdnew=state.getTypeDescriptor(cnnew.getSymbol());
 
-      Vector args=parseArgumentList(cn, pn);
+      Vector args=parseArgumentList(cn, md, isStaticContext, pn);
       ParseNode idChild = pn.getChild( "id" );
       ParseNode baseChild = pn.getChild( "base" );
       //System.out.println("\n to print idchild and basechild for ");
@@ -1169,10 +1198,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       }
       popChainMaps();
 
-      if (analyzeset != null)
-	analyzeset.add(cnnew);
-      cnnew.setSourceFileName(currsourcefile);
-      state.addClass(cnnew);
+      addClass2State(cnnew);
 
       return con;
     } else if (isNode(pn,"createarray")) {
@@ -1184,7 +1210,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
         disjointId = pn.getChild("disjoint").getTerminal();
       }
       TypeDescriptor td=parseTypeDescriptor(pn);
-      Vector args=parseDimExprs(cn, pn);
+      Vector args=parseDimExprs(cn, md, isStaticContext, pn);
       int num=0;
       if (pn.getChild("dims_opt").getLiteral()!=null)
         num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
@@ -1207,7 +1233,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       CreateObjectNode con=new CreateObjectNode(td, false, null);
       con.setNumLine(pn.getLine());
       ParseNode ipn = pn.getChild("initializer");
-      Vector initializers=parseVariableInitializerList(cn, ipn);
+      Vector initializers=parseVariableInitializerList(cn, md, isStaticContext, ipn);
       ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
       ain.setNumLine(pn.getLine());
       con.addArrayInitializer(ain);
@@ -1237,7 +1263,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       return new OpNode(nn,null,new Operation(Operation.ISAVAILABLE));
     } else if (isNode(pn,"methodinvoke1")) {
       NameDescriptor nd=parseName(pn.getChild("name"));
-      Vector args=parseArgumentList(cn, pn);
+      Vector args=parseArgumentList(cn, md, isStaticContext, pn);
       MethodInvokeNode min=new MethodInvokeNode(nd);
       min.setNumLine(pn.getLine());
       for(int i=0; i<args.size(); i++) {
@@ -1246,8 +1272,8 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       return min;
     } else if (isNode(pn,"methodinvoke2")) {
       String methodid=pn.getChild("id").getTerminal();
-      ExpressionNode exp=parseExpression(cn, pn.getChild("base").getFirstChild());
-      Vector args=parseArgumentList(cn, pn);
+      ExpressionNode exp=parseExpression(cn, md, isStaticContext, pn.getChild("base").getFirstChild());
+      Vector args=parseArgumentList(cn, md, isStaticContext, pn);
       MethodInvokeNode min=new MethodInvokeNode(methodid,exp);
       min.setNumLine(pn.getLine());
       for(int i=0; i<args.size(); i++) {
@@ -1255,7 +1281,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       }
       return min;
     } else if (isNode(pn,"fieldaccess")) {
-      ExpressionNode en=parseExpression(cn, pn.getChild("base").getFirstChild());
+      ExpressionNode en=parseExpression(cn, md, isStaticContext, pn.getChild("base").getFirstChild());
       String fieldname=pn.getChild("field").getTerminal();
 
       FieldAccessNode fan=new FieldAccessNode(en,fieldname);
@@ -1269,7 +1295,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 	fan.setNumLine(pn.getLine());
 	return fan;
     } else if (isNode(pn,"supernamefieldaccess")) {
-	ExpressionNode en=parseExpression(cn, pn.getChild("base").getFirstChild());
+	ExpressionNode en=parseExpression(cn, md, isStaticContext, pn.getChild("base").getFirstChild());
 	ExpressionNode exp = new FieldAccessNode(en, "super");
 	exp.setNumLine(pn.getLine());
 	String fieldname=pn.getChild("field").getTerminal();
@@ -1278,14 +1304,14 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 	fan.setNumLine(pn.getLine());
 	return fan;
     } else if (isNode(pn,"arrayaccess")) {
-      ExpressionNode en=parseExpression(cn, pn.getChild("base").getFirstChild());
-      ExpressionNode index=parseExpression(cn, pn.getChild("index").getFirstChild());
+      ExpressionNode en=parseExpression(cn, md, isStaticContext, pn.getChild("base").getFirstChild());
+      ExpressionNode index=parseExpression(cn, md, isStaticContext, pn.getChild("index").getFirstChild());
       ArrayAccessNode aan=new ArrayAccessNode(en,index);
       aan.setNumLine(pn.getLine());
       return aan;
     } else if (isNode(pn,"cast1")) {
       try {
-        CastNode castn=new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(cn, pn.getChild("exp").getFirstChild()));
+        CastNode castn=new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(cn, md, isStaticContext, pn.getChild("exp").getFirstChild()));
         castn.setNumLine(pn.getLine());
         return castn;
       } catch (Exception e) {
@@ -1294,7 +1320,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
         throw new Error();
       }
     } else if (isNode(pn,"cast2")) {
-      CastNode castn=new CastNode(parseExpression(cn, pn.getChild("type").getFirstChild()),parseExpression(cn, pn.getChild("exp").getFirstChild()));
+      CastNode castn=new CastNode(parseExpression(cn, md, isStaticContext, pn.getChild("type").getFirstChild()),parseExpression(cn, md, isStaticContext, pn.getChild("exp").getFirstChild()));
       castn.setNumLine(pn.getLine());
       return castn;
     } else if (isNode(pn, "getoffset")) {
@@ -1304,20 +1330,20 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       return new OffsetNode(td, fieldname);
     } else if (isNode(pn, "tert")) {
 
-      TertiaryNode tn=new TertiaryNode(parseExpression(cn, pn.getChild("cond").getFirstChild()),
-                                       parseExpression(cn, pn.getChild("trueexpr").getFirstChild()),
-                                       parseExpression(cn, pn.getChild("falseexpr").getFirstChild()) );
+      TertiaryNode tn=new TertiaryNode(parseExpression(cn, md, isStaticContext, pn.getChild("cond").getFirstChild()),
+                                       parseExpression(cn, md, isStaticContext, pn.getChild("trueexpr").getFirstChild()),
+                                       parseExpression(cn, md, isStaticContext, pn.getChild("falseexpr").getFirstChild()) );
       tn.setNumLine(pn.getLine());
 
       return tn;
     } else if (isNode(pn, "instanceof")) {
-      ExpressionNode exp=parseExpression(cn, pn.getChild("exp").getFirstChild());
+      ExpressionNode exp=parseExpression(cn, md, isStaticContext, pn.getChild("exp").getFirstChild());
       TypeDescriptor t=parseTypeDescriptor(pn);
       InstanceOfNode ion=new InstanceOfNode(exp,t);
       ion.setNumLine(pn.getLine());
       return ion;
     } else if (isNode(pn, "array_initializer")) {
-      Vector initializers=parseVariableInitializerList(cn, pn);
+      Vector initializers=parseVariableInitializerList(cn, md, isStaticContext, pn);
       return new ArrayInitializerNode(initializers);
     } else if (isNode(pn, "class_type")) {
       TypeDescriptor td=parseTypeDescriptor(pn);
@@ -1333,26 +1359,26 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     }
   }
 
-  private Vector parseDimExprs(ClassDescriptor cn, ParseNode pn) {
+  private Vector parseDimExprs(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     Vector arglist=new Vector();
     ParseNode an=pn.getChild("dim_exprs");
     if (an==null)       /* No argument list */
       return arglist;
     ParseNodeVector anv=an.getChildren();
     for(int i=0; i<anv.size(); i++) {
-      arglist.add(parseExpression(cn, anv.elementAt(i)));
+      arglist.add(parseExpression(cn, md, isStaticContext, anv.elementAt(i)));
     }
     return arglist;
   }
 
-  private Vector parseArgumentList(ClassDescriptor cn, ParseNode pn) {
+  private Vector parseArgumentList(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     Vector arglist=new Vector();
     ParseNode an=pn.getChild("argument_list");
     if (an==null)       /* No argument list */
       return arglist;
     ParseNodeVector anv=an.getChildren();
     for(int i=0; i<anv.size(); i++) {
-      arglist.add(parseExpression(cn, anv.elementAt(i)));
+      arglist.add(parseExpression(cn, md, isStaticContext, anv.elementAt(i)));
     }
     return arglist;
   }
@@ -1369,28 +1395,28 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       ParseNode var=cpn.getChild("var");
       ParseNode exp=cpn.getChild("exp").getFirstChild();
       varlist.add(var.getTerminal());
-      arglist.add(parseExpression(null, exp));
+      arglist.add(parseExpression(null, null, false, exp));
     }
     return new Vector[] {varlist, arglist};
   }
 
-  private Vector parseVariableInitializerList(ClassDescriptor cn, ParseNode pn) {
+  private Vector parseVariableInitializerList(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     Vector varInitList=new Vector();
     ParseNode vin=pn.getChild("var_init_list");
     if (vin==null)       /* No argument list */
       return varInitList;
     ParseNodeVector vinv=vin.getChildren();
     for(int i=0; i<vinv.size(); i++) {
-      varInitList.add(parseExpression(cn, vinv.elementAt(i)));
+      varInitList.add(parseExpression(cn, md, isStaticContext, vinv.elementAt(i)));
     }
     return varInitList;
   }
 
-  private ExpressionNode parseAssignmentExpression(ClassDescriptor cn, ParseNode pn) {
+  private ExpressionNode parseAssignmentExpression(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
     ParseNodeVector pnv=pn.getChild("args").getChildren();
 
-    AssignmentNode an=new AssignmentNode(parseExpression(cn, pnv.elementAt(0)),parseExpression(cn, pnv.elementAt(1)),ao);
+    AssignmentNode an=new AssignmentNode(parseExpression(cn, md, isStaticContext, pnv.elementAt(0)),parseExpression(cn, md, isStaticContext, pnv.elementAt(1)),ao);
     an.setNumLine(pn.getLine());
     return an;
   }
@@ -1401,7 +1427,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     ParseNode bodyn=pn.getChild("body");
     MethodDescriptor md=parseMethodHeader(headern);
     try {
-      BlockNode bn=parseBlock(cn, bodyn);
+      BlockNode bn=parseBlock(cn, md, md.isStatic()||md.isStaticBlock(), bodyn);
       bn.setNumLine(pn.getLine()); // assume that method header is located at the beginning of method body
       cn.addMethod(md);
       state.addTreeCode(md,bn);
@@ -1441,13 +1467,13 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     cn.addMethod(md);
     BlockNode bn=null;
     if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
-      bn=parseBlock(cn, bodyn);
+      bn=parseBlock(cn, md, md.isStatic()||md.isStaticBlock(), bodyn);
     else
       bn=new BlockNode();
     if (bodyn!=null&&bodyn.getChild("superinvoke")!=null) {
       ParseNode sin=bodyn.getChild("superinvoke");
       NameDescriptor nd=new NameDescriptor("super");
-      Vector args=parseArgumentList(cn, sin);
+      Vector args=parseArgumentList(cn, md, true, sin);
       MethodInvokeNode min=new MethodInvokeNode(nd);
       min.setNumLine(sin.getLine());
       for(int i=0; i<args.size(); i++) {
@@ -1459,7 +1485,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     } else if (bodyn!=null&&bodyn.getChild("explconstrinv")!=null) {
       ParseNode eci=bodyn.getChild("explconstrinv");
       NameDescriptor nd=new NameDescriptor(cn.getSymbol());
-      Vector args=parseArgumentList(cn, eci);
+      Vector args=parseArgumentList(cn, md, true, eci);
       MethodInvokeNode min=new MethodInvokeNode(nd);
       min.setNumLine(eci.getLine());
       for(int i=0; i<args.size(); i++) {
@@ -1492,7 +1518,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     cn.incStaticBlocks();
     BlockNode bn=null;
     if (bodyn!=null&&bodyn.getChild("block_statement_list")!=null)
-      bn=parseBlock(cn, bodyn);
+      bn=parseBlock(cn, md, true, bodyn);
     else
       bn=new BlockNode();
     if(isfirst) {
@@ -1508,19 +1534,19 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     }
   }
 
-  public BlockNode parseBlock(ClassDescriptor cn, ParseNode pn) {
+  public BlockNode parseBlock(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     this.m_taskexitnum = 0;
     if (pn==null||isEmpty(pn.getTerminal()))
       return new BlockNode();
     ParseNode bsn=pn.getChild("block_statement_list");
-    return parseBlockHelper(cn, bsn);
+    return parseBlockHelper(cn, md, isStaticContext, bsn);
   }
 
-  private BlockNode parseBlockHelper(ClassDescriptor cn, ParseNode pn) {
+  private BlockNode parseBlockHelper(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
     ParseNodeVector pnv=pn.getChildren();
     BlockNode bn=new BlockNode();
     for(int i=0; i<pnv.size(); i++) {
-      Vector bsv=parseBlockStatement(cn, pnv.elementAt(i));
+      Vector bsv=parseBlockStatement(cn, md, isStaticContext, pnv.elementAt(i));
       for(int j=0; j<bsv.size(); j++) {
         bn.addBlockStatement((BlockStatementNode)bsv.get(j));
       }
@@ -1528,9 +1554,9 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     return bn;
   }
 
-  public BlockNode parseSingleBlock(ClassDescriptor cn, ParseNode pn, String label){
+  public BlockNode parseSingleBlock(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn, String label){
     BlockNode bn=new BlockNode();
-    Vector bsv=parseBlockStatement(cn, pn,label);
+    Vector bsv=parseBlockStatement(cn, md, isStaticContext, pn,label);
     for(int j=0; j<bsv.size(); j++) {
       bn.addBlockStatement((BlockStatementNode)bsv.get(j));
     }
@@ -1538,24 +1564,24 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     return bn;
   }
   
-  public BlockNode parseSingleBlock(ClassDescriptor cn, ParseNode pn) {
-    return parseSingleBlock(cn, pn,null);
+  public BlockNode parseSingleBlock(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn) {
+    return parseSingleBlock(cn, md, isStaticContext, pn, null);
   }
 
-  public Vector parseSESEBlock(ClassDescriptor cn, Vector parentbs, ParseNode pn) {
+  public Vector parseSESEBlock(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, Vector parentbs, ParseNode pn) {
     ParseNodeVector pnv=pn.getChildren();
     Vector bv=new Vector();
     for(int i=0; i<pnv.size(); i++) {
-      bv.addAll(parseBlockStatement(cn, pnv.elementAt(i)));
+      bv.addAll(parseBlockStatement(cn, md, isStaticContext, pnv.elementAt(i)));
     }
     return bv;
   }
   
-  public Vector parseBlockStatement(ClassDescriptor cn, ParseNode pn){
-    return parseBlockStatement(cn, pn,null);
+  public Vector parseBlockStatement(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn){
+    return parseBlockStatement(cn, md, isStaticContext, pn,null);
   }
 
-  public Vector parseBlockStatement(ClassDescriptor cn, ParseNode pn, String label) {
+  public Vector parseBlockStatement(ClassDescriptor cn, MethodDescriptor md, boolean isStaticContext, ParseNode pn, String label) {
     Vector blockstatements=new Vector();
     if (isNode(pn,"tag_declaration")) {
       String name=pn.getChild("single").getTerminal();
@@ -1588,7 +1614,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 
         ExpressionNode en=null;
         if (epn!=null)
-          en=parseExpression(cn, epn.getFirstChild());
+          en=parseExpression(cn, md, isStaticContext, epn.getFirstChild());
 
         DeclarationNode dn=new DeclarationNode(new VarDescriptor(arrayt, identifier),en);
         dn.setNumLine(tmp.getLine());
@@ -1605,20 +1631,20 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
     } else if (isNode(pn,"nop")) {
       /* Do Nothing */
     } else if (isNode(pn,"expression")) {
-      BlockExpressionNode ben=new BlockExpressionNode(parseExpression(cn, pn.getFirstChild()));
+      BlockExpressionNode ben=new BlockExpressionNode(parseExpression(cn, md, isStaticContext, pn.getFirstChild()));
       ben.setNumLine(pn.getLine());
       blockstatements.add(ben);
     } else if (isNode(pn,"ifstatement")) {
-      IfStatementNode isn=new IfStatementNode(parseExpression(cn, pn.getChild("condition").getFirstChild()),
-                                              parseSingleBlock(cn, pn.getChild("statement").getFirstChild()),
-                                              pn.getChild("else_statement")!=null?parseSingleBlock(cn, pn.getChild("else_statement").getFirstChild()):null);
+      IfStatementNode isn=new IfStatementNode(parseExpression(cn, md, isStaticContext, pn.getChild("condition").getFirstChild()),
+                                              parseSingleBlock(cn, md, isStaticContext, pn.getChild("statement").getFirstChild()),
+                                              pn.getChild("else_statement")!=null?parseSingleBlock(cn, md, isStaticContext, 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(cn, pn.getChild("condition").getFirstChild()),
-                                                      parseSingleBlock(cn, pn.getChild("statement").getFirstChild()));
+      SwitchStatementNode ssn=new SwitchStatementNode(parseExpression(cn, md, isStaticContext, pn.getChild("condition").getFirstChild()),
+                                                      parseSingleBlock(cn, md, isStaticContext, pn.getChild("statement").getFirstChild()));
       ssn.setNumLine(pn.getLine());
       blockstatements.add(ssn);
     } else if (isNode(pn,"switch_block_list")) {
@@ -1634,7 +1660,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
           for(int j=0; j<labelv.size(); j++) {
             ParseNode labeldecl=labelv.elementAt(j);
             if(isNode(labeldecl, "switch_label")) {
-              SwitchLabelNode sln=new SwitchLabelNode(parseExpression(cn, labeldecl.getChild("constant_expression").getFirstChild()), false);
+              SwitchLabelNode sln=new SwitchLabelNode(parseExpression(cn, md, isStaticContext, labeldecl.getChild("constant_expression").getFirstChild()), false);
               sln.setNumLine(labeldecl.getLine());
               slv.addElement(sln);
             } else if(isNode(labeldecl, "default_switch_label")) {
@@ -1645,7 +1671,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
           }
 
           SwitchBlockNode sbn=new SwitchBlockNode(slv,
-                                                  parseSingleBlock(cn, sblockdecl.getChild("switch_statements").getFirstChild()));
+                                                  parseSingleBlock(cn, md, isStaticContext, sblockdecl.getChild("switch_statements").getFirstChild()));
           sbn.setNumLine(sblockdecl.getLine());
 
           blockstatements.add(sbn);
@@ -1657,13 +1683,13 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       // Do not fully support exceptions now. Only make sure that if there are no
       // exceptions thrown, the execution is right
       ParseNode tpn = pn.getChild("tryblock").getFirstChild();
-      BlockNode bn=parseBlockHelper(cn, tpn);
+      BlockNode bn=parseBlockHelper(cn, md, isStaticContext, tpn);
       blockstatements.add(new SubBlockNode(bn));
 
       ParseNode fbk = pn.getChild("finallyblock");
       if(fbk != null) {
         ParseNode fpn = fbk.getFirstChild();
-        BlockNode fbn=parseBlockHelper(cn, fpn);
+        BlockNode fbn=parseBlockHelper(cn, md, isStaticContext, fpn);
         blockstatements.add(new SubBlockNode(fbn));
       }
     } else if (isNode(pn, "throwstatement")) {
@@ -1680,13 +1706,13 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       ten.setNumLine(pn.getLine());
       blockstatements.add(ten);
     } else if (isNode(pn,"atomic")) {
-      BlockNode bn=parseBlockHelper(cn, pn);
+      BlockNode bn=parseBlockHelper(cn, md, isStaticContext, pn);
       AtomicNode an=new AtomicNode(bn);
       an.setNumLine(pn.getLine());
       blockstatements.add(an);
     } else if (isNode(pn,"synchronized")) {
-      BlockNode bn=parseBlockHelper(cn, pn.getChild("block"));
-      ExpressionNode en=parseExpression(cn, pn.getChild("expr").getFirstChild());
+      BlockNode bn=parseBlockHelper(cn, md, isStaticContext, pn.getChild("block"));
+      ExpressionNode en=parseExpression(cn, md, isStaticContext, pn.getChild("expr").getFirstChild());
       SynchronizedNode sn=new SynchronizedNode(en, bn);
       sn.setNumLine(pn.getLine());
       blockstatements.add(sn);
@@ -1694,13 +1720,13 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       if (isEmpty(pn.getTerminal()))
         blockstatements.add(new ReturnNode());
       else {
-        ExpressionNode en=parseExpression(cn, pn.getFirstChild());
+        ExpressionNode en=parseExpression(cn, md, isStaticContext, pn.getFirstChild());
         ReturnNode rn=new ReturnNode(en);
         rn.setNumLine(pn.getLine());
         blockstatements.add(rn);
       }
     } else if (isNode(pn,"block_statement_list")) {
-      BlockNode bn=parseBlockHelper(cn, pn);
+      BlockNode bn=parseBlockHelper(cn, md, isStaticContext, pn);
       blockstatements.add(new SubBlockNode(bn));
     } else if (isNode(pn,"empty")) {
       /* nop */
@@ -1708,15 +1734,15 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       ParseNodeVector pnv=pn.getChildren();
       BlockNode bn=new BlockNode();
       for(int i=0; i<pnv.size(); i++) {
-        ExpressionNode en=parseExpression(cn, pnv.elementAt(i));
+        ExpressionNode en=parseExpression(cn, md, isStaticContext, pnv.elementAt(i));
         blockstatements.add(new BlockExpressionNode(en));
       }
       bn.setStyle(BlockNode.EXPRLIST);
     } else if (isNode(pn,"forstatement")) {
-      BlockNode init=parseSingleBlock(cn, pn.getChild("initializer").getFirstChild());
-      BlockNode update=parseSingleBlock(cn, pn.getChild("update").getFirstChild());
-      ExpressionNode condition=parseExpression(cn, pn.getChild("condition").getFirstChild());
-      BlockNode body=parseSingleBlock(cn, pn.getChild("statement").getFirstChild());
+      BlockNode init=parseSingleBlock(cn, md, isStaticContext, pn.getChild("initializer").getFirstChild());
+      BlockNode update=parseSingleBlock(cn, md, isStaticContext, pn.getChild("update").getFirstChild());
+      ExpressionNode condition=parseExpression(cn, md, isStaticContext, pn.getChild("condition").getFirstChild());
+      BlockNode body=parseSingleBlock(cn, md, isStaticContext, 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));
@@ -1725,16 +1751,16 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       ln.setNumLine(pn.getLine());
       blockstatements.add(ln);
     } else if (isNode(pn,"whilestatement")) {
-      ExpressionNode condition=parseExpression(cn, pn.getChild("condition").getFirstChild());
-      BlockNode body=parseSingleBlock(cn, pn.getChild("statement").getFirstChild());
+      ExpressionNode condition=parseExpression(cn, md, isStaticContext, pn.getChild("condition").getFirstChild());
+      BlockNode body=parseSingleBlock(cn, md, isStaticContext, 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));
       }
       blockstatements.add(new LoopNode(condition,body,LoopNode.WHILELOOP,label));
     } else if (isNode(pn,"dowhilestatement")) {
-      ExpressionNode condition=parseExpression(cn, pn.getChild("condition").getFirstChild());
-      BlockNode body=parseSingleBlock(cn, pn.getChild("statement").getFirstChild());
+      ExpressionNode condition=parseExpression(cn, md, isStaticContext, pn.getChild("condition").getFirstChild());
+      BlockNode body=parseSingleBlock(cn, md, isStaticContext, 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));
@@ -1752,7 +1778,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
       start.setEnd(end);
       end.setStart(start);
       blockstatements.add(start);
-      blockstatements.addAll(parseSESEBlock(cn, blockstatements,pn.getChild("body").getFirstChild()));
+      blockstatements.addAll(parseSESEBlock(cn, md, isStaticContext, blockstatements,pn.getChild("body").getFirstChild()));
       blockstatements.add(end);
     } else if (isNode(pn,"continue")) {
       ContinueBreakNode cbn=new ContinueBreakNode(false);
@@ -1776,7 +1802,7 @@ private void addOuterClassReferences( ClassDescriptor cn, int depth )
 
     } else if(isNode(pn,"labeledstatement")) {
       String labeledstatement = pn.getChild("name").getTerminal();
-      BlockNode bn=parseSingleBlock(cn, pn.getChild("statement").getFirstChild(),labeledstatement);
+      BlockNode bn=parseSingleBlock(cn, md, isStaticContext, pn.getChild("statement").getFirstChild(),labeledstatement);
       blockstatements.add(new SubBlockNode(bn));
     } else {
       System.out.println("---------------");