From 4d01d7420be4da58e941ff1966dd2163dd5ec8ce Mon Sep 17 00:00:00 2001
From: spikeuci <spikeuci>
Date: Tue, 25 Oct 2011 00:01:10 +0000
Subject: [PATCH] As discussed with Prof. Demsky/Jim, the constructor of inner
 class now by default takes the surrounding class arg based on the scope and
 the block statement for initializing is also set up. TODO: redirect inner
 class references to surrounding class. the test case substituting
 thisbash.outerclass works in the current build

---
 Robust/src/IR/Tree/BuildIR.java          | 114 +++++++++++++----------
 Robust/src/IR/Tree/CreateObjectNode.java |  23 +++++
 Robust/src/IR/Tree/SemanticCheck.java    |  38 +++++++-
 Robust/src/Parse/java14.cup              |  12 ++-
 4 files changed, 132 insertions(+), 55 deletions(-)

diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 661d264c..99f1291a 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -603,16 +603,28 @@ public class BuildIR {
     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( false )
+   if( true )
    {
    	this.isRunningRecursiveInnerClass = true; //fOR dEBUGGING PURPOSES IN ORDER TO DUMP STRINGS WHILE IN THIS CODE PATH
-    	addOuterClassReferences( cn, new Vector< String >() );
+    	addOuterClassReferences( cn, 0 );
+	addOuterClassParam( cn, 0 );
     	this.isRunningRecursiveInnerClass = false;
     }
     return cn;
   }
 
-//called recursively with the parent class whose reference is to be passed
+private void initializeOuterMember( MethodDescriptor md, String fieldName, String formalParameter ) {
+	 BlockNode obn = state.getMethodBody(md);
+         NameNode nn=new NameNode( new NameDescriptor( fieldName ) );
+	 NameNode fn = new NameNode ( new NameDescriptor( formalParameter ) );
+          //nn.setNumLine(en.getNumLine())
+         AssignmentNode an=new AssignmentNode(nn,fn,new AssignOperation(1));
+         //an.setNumLine(pn.getLine());
+         obn.addFirstBlockStatement(new BlockExpressionNode(an));
+	// System.out.print( "The code inserted is : " + obn.printNode( 0 ) + "\n" );
+         state.addTreeCode(md, obn);
+}
+
 private void addOuterClassParam( ClassDescriptor cn, int depth )
 {
 	Iterator nullCheckItr = cn.getInnerClasses();
@@ -629,7 +641,9 @@ 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) );			
+				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" );		
 			}
    		}
 		addOuterClassParam( icd, depth + 1 );
@@ -637,58 +651,41 @@ private void addOuterClassParam( ClassDescriptor cn, int depth )
     	}
 	
 }
-private void addOuterClassReferences( ClassDescriptor cn, Vector< String > runningClassNames )
+private void addOuterClassReferences( ClassDescriptor cn, 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;
-      //logic: for each inner class present in current cn add this$runningIndex and recursively invoke this method on that inner class
-      
-      //JAVA might be passing it by reference , so creating a copy for myself. 
-	
-	Vector tempCopy = new Vector< String >( runningClassNames );
-	tempCopy.add( cn.getClassName() );
 
-	Vector< ParseNode > vecParses = new Vector< ParseNode >();
+	String tempCopy = cn.getClassName();
 	//MESSY HACK FOLLOWS
 	int i = 0;
-	for( Iterator itr = tempCopy.listIterator(); itr.hasNext() ; ++i ) {
-		ParseNode theNode = new ParseNode( "field_declaration" );
-		theNode.addChild("modifier").addChild( new ParseNode( "modifier_list" ) ).addChild("final");
-		ParseNode theTypeNode = new ParseNode("type");
-		ParseNode tempChildNode = theTypeNode.addChild("class").addChild( "name" );
+
+	ParseNode theNode = new ParseNode( "field_declaration" );
+	theNode.addChild("modifier").addChild( new ParseNode( "modifier_list" ) ).addChild("final");
+	ParseNode theTypeNode = new ParseNode("type");
+	ParseNode tempChildNode = theTypeNode.addChild("class").addChild( "name" );
 		//tempChildNode.addChild("base").addChild( new ParseNode("empty") );
-		tempChildNode.addChild("identifier").addChild ( ( String ) itr.next() );
-		theNode.addChild("type").addChild( theTypeNode );
-		ParseNode variableDeclaratorID = new ParseNode("single");
-		String theStr = "this$" + String.valueOf( i );
-		variableDeclaratorID.addChild( theStr );
-		ParseNode variableDeclarator = new ParseNode( "variable_declarator" );
-		variableDeclarator.addChild( variableDeclaratorID );
-		ParseNode variableDeclaratorList = new ParseNode("variable_declarators_list");
-		variableDeclaratorList.addChild( variableDeclarator );
-		theNode.addChild("variables").addChild( variableDeclaratorList );
-		//finally
-		
-		vecParses.add( theNode );
-		
-		
-	}
-	
+	tempChildNode.addChild("identifier").addChild ( tempCopy );
+	theNode.addChild("type").addChild( theTypeNode );
+	ParseNode variableDeclaratorID = new ParseNode("single");
+	String theStr = "this$" + String.valueOf( depth );
+	variableDeclaratorID.addChild( theStr );
+	ParseNode variableDeclarator = new ParseNode( "variable_declarator" );
+	variableDeclarator.addChild( variableDeclaratorID );
+	ParseNode variableDeclaratorList = new ParseNode("variable_declarators_list");
+	variableDeclaratorList.addChild( variableDeclarator );
+	theNode.addChild("variables").addChild( variableDeclaratorList );
+
 	for(Iterator it=cn.getInnerClasses(); it.hasNext(); ) {
       		ClassDescriptor icd=(ClassDescriptor)it.next();
-		for( Iterator vecParsesItr = vecParses.listIterator(); vecParsesItr.hasNext(); ) {
-			ParseNode theDummy = ( ParseNode ) vecParsesItr.next();
-			//System.out.println( ( theDummy ).PPrint( 0, true ) );
-			parseFieldDecl( icd, theDummy );		
-		}
-		if( true ) {
+		parseFieldDecl( icd, theNode );		
+		/*if( true ) {
 			SymbolTable fieldTable = icd.getFieldTable();
-			System.out.println( fieldTable.toString() );
-		}
-		addOuterClassReferences( icd, tempCopy );
-		
+			//System.out.println( fieldTable.toString() );
+		}*/
+		addOuterClassReferences( icd, depth + 1 );	
     	}
 }
 
@@ -823,10 +820,6 @@ private void addOuterClassReferences( ClassDescriptor cn, Vector< String > runni
     return icn;
   }
 
-private void AddSurroundingClassParamToCtor( ClassDescriptor icn, ParseNode pn )
-{
-	
-}
   private TypeDescriptor parseTypeDescriptor(ParseNode pn) {
     ParseNode tn=pn.getChild("type");
     String type_st=tn.getTerminal();
@@ -1090,7 +1083,24 @@ private void AddSurroundingClassParamToCtor( ClassDescriptor icn, ParseNode pn )
       if (pn.getChild("disjoint") != null) {
         disjointId = pn.getChild("disjoint").getTerminal();
       }
+      ParseNode idChild = (pn.getChild( "id" ));
+      ParseNode baseChild = (pn.getChild( "base" ));
+      
       CreateObjectNode con = new CreateObjectNode(td, isglobal, disjointId);
+      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( 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( baseChild ); 
+	//System.out.println( "\nThe object passed has this expression " + en.printNode( 0 ) );
+	con.setSurroundingExpression( en );     
+      }
       con.setNumLine(pn.getLine());
       for (int i = 0; i < args.size(); i++) {
         con.addArgument((ExpressionNode) args.get(i));
@@ -1121,7 +1131,13 @@ private void AddSurroundingClassParamToCtor( ClassDescriptor icn, ParseNode pn )
       TypeDescriptor tdnew=state.getTypeDescriptor(cnnew.getSymbol());
 
       Vector args=parseArgumentList(pn);
-
+      ParseNode idChild = pn.getChild( "id" );
+      ParseNode baseChild = pn.getChild( "base" );
+      //System.out.println("\n to print idchild and basechild for ");
+      /*if( null != idChild )
+	System.out.println( "\n trying to create an inner class and the id child passed is "  + idChild.PPrint( 0, true ) );
+      if( null != baseChild )
+	System.out.println( "\n trying to create an inner class and the base child passed is "  + baseChild.PPrint( 0, true ) );*/
       CreateObjectNode con=new CreateObjectNode(tdnew, false, null);
       con.setNumLine(pn.getLine());
       for(int i=0; i<args.size(); i++) {
diff --git a/Robust/src/IR/Tree/CreateObjectNode.java b/Robust/src/IR/Tree/CreateObjectNode.java
index bae15edf..b6c77729 100644
--- a/Robust/src/IR/Tree/CreateObjectNode.java
+++ b/Robust/src/IR/Tree/CreateObjectNode.java
@@ -2,6 +2,7 @@ package IR.Tree;
 import java.util.Vector;
 import IR.TypeDescriptor;
 import IR.MethodDescriptor;
+import IR.Tree.ExpressionNode;
 
 public class CreateObjectNode extends ExpressionNode {
   TypeDescriptor td;
@@ -11,13 +12,21 @@ public class CreateObjectNode extends ExpressionNode {
   boolean isglobal;
   String disjointId;
   ArrayInitializerNode ain;
+//The next 2 are unused but i will delete them once i am fully done with inner classes.
+  TypeDescriptor surroundingClass;
+  boolean isCreatedFromSurroundingClassName;
+  
+  ExpressionNode surroundingClassObject;
+  boolean isSurroundingClassExpSet;
 
   public CreateObjectNode(TypeDescriptor type, boolean isglobal, String disjointId) {
     td=type;
+   // surroundingClass = new TypeDescriptor("becauseTDdoesnthavedefaultconstructor");
     argumentlist=new Vector();
     this.isglobal=isglobal;
     this.disjointId=disjointId;
     this.ain = null;
+    isSurroundingClassExpSet = false;
   }
 
   public boolean isGlobal() {
@@ -105,4 +114,18 @@ public class CreateObjectNode extends ExpressionNode {
     eval = null;
     return eval; //null;
   }
+
+  public void setSurroundingExpression( ExpressionNode en ) {
+	
+	//System.out.println( "The expression node is : " + en );
+  	surroundingClassObject = en ;
+	//System.out.println( "The expression node is : " + surroundingClassObject );
+	isSurroundingClassExpSet = true;
+  }
+  
+  public ExpressionNode getSurroundingClassExpression() {
+  	if( false == isSurroundingClassExpSet )
+		return null;
+	return surroundingClassObject;
+  }
 }
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index f82fe80c..d13a7650 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -1049,7 +1049,33 @@ public class SemanticCheck {
     loopstack.pop();
   }
 
-
+  void InnerClassAddParamToCtor( MethodDescriptor md, ClassDescriptor cd, SymbolTable nametable, 
+				 CreateObjectNode con, TypeDescriptor td ) {
+	
+	TypeDescriptor cdsType = new TypeDescriptor( cd );
+	ExpressionNode conExp = con.getSurroundingClassExpression();
+	//System.out.println( "The surrounding class expression si " + con );
+	if( null == conExp ) {
+		if( md.isStatic() ) {
+			throw new Error("trying to instantiate inner class: " +  con.getType() + " in a static scope" );
+		}
+		VarDescriptor thisVD = md.getThis();
+		if( null == thisVD ) {
+			throw new Error( "this pointer is not defined in a non static scope" );	
+		}			
+		if( cdsType.equals( thisVD.getType() ) == false ) {
+			throw new Error( "the type of this pointer is different than the type expected for inner class constructor. Initializing the inner class: " 				+  con.getType() + " in the wrong scope" );		
+		}	
+		//make this into an expression node.
+		NameNode nThis=new NameNode( new NameDescriptor( "this" ) );
+		con.addArgument( nThis );
+	}
+	else {
+		//REVISIT : here i am storing the expression as an expressionNode which does not implement type, there is no way for me to semantic check this argument.
+		con.addArgument( conExp );
+	}
+	//System.out.println( " the modified createObjectNode is " + con.printNode( 0 ) + "\n" );
+}
   void checkCreateObjectNode(Descriptor md, SymbolTable nametable, CreateObjectNode con,
                              TypeDescriptor td) {
     TypeDescriptor[] tdarray = new TypeDescriptor[con.numArgs()];
@@ -1106,7 +1132,15 @@ public class SemanticCheck {
       // Array's don't need constructor calls
       ClassDescriptor classtolookin = typetolookin.getClassDesc();
       checkClass(classtolookin, INIT);
-
+      if( classtolookin.isInnerClass() ) {
+      	InnerClassAddParamToCtor( (MethodDescriptor)md, ((MethodDescriptor)md).getClassDesc() , nametable, con, td );
+	tdarray = new TypeDescriptor[con.numArgs()];
+    	for (int i = 0; i < con.numArgs(); i++) {
+      		ExpressionNode en = con.getArg(i);
+     		checkExpressionNode(md, nametable, en, null);
+     		tdarray[i] = en.getType();
+   	 }
+      }
       Set methoddescriptorset = classtolookin.getMethodTable().getSet(classtolookin.getSymbol());
       MethodDescriptor bestmd = null;
 NextMethod: for (Iterator methodit = methoddescriptorset.iterator(); methodit.hasNext(); ) {
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index 8e7784f6..6dde3b9d 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -2020,35 +2020,39 @@ class_instance_creation_expression ::=
 		pn.addChild("decl").addChild("classbody").addChild(body);
 		RESULT=pn;
 	:}
-	|	primary DOT NEW class_or_interface_type:type
+	|	primary: base DOT NEW class_or_interface_type:type
 			LPAREN argument_list_opt:args RPAREN {: 
 		ParseNode pn=new ParseNode("createobject",parser.lexer.line_num);
 		pn.addChild(type);
 		pn.addChild(args);
+		pn.addChild( "base" ).addChild( base );
 		RESULT=pn;
 		
 	:}
-	|	primary DOT NEW class_or_interface_type:type
+	|	primary: base DOT NEW class_or_interface_type:type
 			LPAREN argument_list_opt:args RPAREN class_body:body {:
 		ParseNode pn=new ParseNode("createobjectcls",parser.lexer.line_num);	      
 		pn.addChild(type);
 		pn.addChild(args);
+		pn.addChild( "base" ).addChild( base );
 		pn.addChild("decl").addChild("classbody").addChild(body);
 		RESULT=pn;
 	:}
-	|	name DOT NEW class_or_interface_type:type
+	|	name:id DOT NEW class_or_interface_type:type
 			LPAREN argument_list_opt:args RPAREN {:
 		ParseNode pn=new ParseNode("createobject",parser.lexer.line_num);
 		pn.addChild(type);
 		pn.addChild(args);
+		pn.addChild( "id" ).addChild( id );
 		RESULT=pn;
 	:}
-	|	name DOT NEW class_or_interface_type:type
+	|	name:id DOT NEW class_or_interface_type:type
 			LPAREN argument_list_opt:args RPAREN class_body:body {:
 		ParseNode pn=new ParseNode("createobjectcls",parser.lexer.line_num);	      
 		pn.addChild(type);
 		pn.addChild(args);
 		pn.addChild("decl").addChild("classbody").addChild(body);
+		pn.addChild( "id" ).addChild( id );
 		RESULT=pn;
 	:}
 	;
-- 
2.34.1