/* SCCS - @(#)ClassNode.java	1.21 - 09/17/99 - 23:15:00 */

/*
 * Copyright (c) 1997 USC Brain Project. email nsl@java.usc.edu.
*/
package npp.src.util;

import java.util.Vector;
import java.util.Enumeration;
import pp.src.jbf.*;

public class ClassNode extends YYtoken{
private static boolean use_parameter_passing = true;
  public ClassNode(YYtoken node,String extends_str,String interface_str) {
    super(node.tokentype, node.text, node.lineno, node.charno, node.charno0);
    name = node.text;
    extendsname = extends_str;
    interfacename = interface_str;

    cur_tmp_number = MIN_TEMP_NUMBER;
    tmp_vars_run = new Vector(10,10);
    tmp_vars_train = new Vector(10,10);
    tmp_vars_mod = new Vector(10,10);
    methods = new Vector(5,5);
    nsldecls = new Vector(5,5);
    unresolved_vars = new Vector(10,10);
    make_inst_decl_stmts = new Vector(5,5);
    constructors = new Vector();
    nslpars_str=""; // regular class definition
    nslpars=null;
    decl_methods = new MethodNode[MethodNode.MAX_METHOD_TYPE+1];
    for (int i=0; i<=MethodNode.MAX_METHOD_TYPE; i++) {
      decl_methods[i]=null;
    }
  }

  public ClassNode(YYtoken node,ParamsNode pars,String extends_str,String interface_str) {
    this(node,extends_str,interface_str);
    if (pars==null) nslpars_str="";
    else  nslpars_str=pars.code0; //nslModule
    nslpars=pars;
   }
  public ClassNode(YYtoken node,YYtoken extends_node,YYtoken interface_node) {
    super(node.tokentype, node.text, node.lineno, node.charno, node.charno0);
    name = node.text;
    if (extendsname == null)
      extendsname = extends_node.text;
    else
      extendsname = null;
    if (interfacename == null)
      interfacename = interface_node.text;
    else
      interfacename = null;

    cur_tmp_number = MIN_TEMP_NUMBER;
    tmp_vars_run = new Vector(10,10);
    tmp_vars_train = new Vector(10,10);
    tmp_vars_mod = new Vector(10,10);
    methods = new Vector(5,5);
    nsldecls = new Vector(5,5);
    unresolved_vars = new Vector(10,10);
    make_inst_decl_stmts = new Vector(5,5);
    constructors = new Vector();
    nslpars_str=""; //regular class definitio
    decl_methods = new MethodNode[MethodNode.MAX_METHOD_TYPE+1];
    for (int i=0; i<=MethodNode.MAX_METHOD_TYPE; i++) {
      decl_methods[i]=null;
    }
  }
  /** 
    To create temporary variable,
    for BinaryExprNode */
  public int getNextTempNumber() {
    if (cur_tmp_number>=MAX_TEMP_NUMBER)
      System.err.println("ClassNode:Number of temporary number exists limit.");
    return cur_tmp_number++;
  }

  public void registerRunTempVar(int num, String decl, String inst, String init) {
    tmp_vars_run.addElement(new TempVar(num, decl, inst, init));

  }
  
  public void registerTrainTempVar(int num, String decl, String inst, String init) {
    tmp_vars_train.addElement(new TempVar(num, decl, inst, init));

  }
  
  public void registerModTempVar(int num, String decl, String inst, String init) {
    tmp_vars_mod.addElement(new TempVar(num, decl, inst, init));

  }

  public void listTempVar() {
    java.util.Enumeration E = tmp_vars.elements();
    TempVar tv;

    System.out.println("Temporary Variable List");
    while(E.hasMoreElements()) {
      tv = (TempVar)(E.nextElement());
      System.out.println("Tmp#:"+tv.tmp_num+"\n\tDecl:\t"+tv.decl_stmt+"\n\tInst:\t"+tv.inst_stmt);
    }
    
    //tmp_vars.removeAllElements();
  }

  void addConstructor(ConstructorNode cn) {
    constructors.addElement(cn);
  }

public void add_nsldecl(String dc)
{
 //System.err.println(" ===========  Adding "+dc);
 nsldecls.addElement(dc);
}

  /** Add a method into this Class */
  int addMethod(MethodNode mn) {
    int method_type = mn.method_type;
    methods.addElement(mn);
    if (method_type>=MethodNode.MIN_METHOD_TYPE &&
	method_type<=MethodNode.MAX_METHOD_TYPE) {
      if (decl_methods[method_type]!=null) {
	// duplicate method declaration? 
	// check the parameter lists 
      }
      else {
	decl_methods[method_type] = mn;
      }
    }
    return method_type;
  }

  void addUnresolvedVar(YYtoken t) {
    unresolved_vars.addElement(t);
  }

  void addMakeInstDeclStmt(String stmt) {
    make_inst_decl_stmts.addElement(stmt);
  }

  void listMakeInstDeclStmt() {
    java.util.Enumeration E = make_inst_decl_stmts.elements();
    String stmt;
    int i =0;
    System.out.println("MakeInst Declared Variable List");
    while(E.hasMoreElements()) {
      stmt = (String)(E.nextElement());
      i++;
      System.out.println("#"+i+":\t"+stmt);     
    }
   
  }

  public NPPGenCode genDeclStmt() { //(NslPreProcessor npp) {
  
    java.util.Enumeration E;
    TempVar tv;
    String stmt;
    StringBuffer strbuf = new StringBuffer();

        
        
    if (extendsname.equals("NslModule") || extendsname.equals("NslModel")) {
      
        strbuf.append("\t/* nslInitTempModule inserted by NPP */\n"); 
    	strbuf.append("public void nslInitTempModule() {\n");
    	// Temporaries instantiated in this method only if its nslModule or 
    	// nslModel, otherwise they are instantiated in makeInst
    	strbuf.append(genTempInstStmt()); 
    	strbuf.append(genModInitStmt());
    	strbuf.append("}\n\n");
    
        strbuf.append("\t/* nslInitTempRun inserted by NPP */\n"); 
        strbuf.append("public void nslInitTempRun() {\n");
        strbuf.append(genRunInitStmt());
        strbuf.append("}\n\n");
        
        strbuf.append("\t/* nslInitTempTrain inserted by NPP */\n"); 
        strbuf.append("public void nslInitTempTrain() {\n");
        strbuf.append(genTrainInitStmt());
        strbuf.append("}\n\n");
      
    }
    else if (extendsname.equals("NslClass")) {
      
        strbuf.append("\t/* nslInitTempClass inserted by NPP */\n"); 
    	strbuf.append("public void nslInitTempClass() {\n");
    	strbuf.append(genModInitStmt());
    	strbuf.append("}\n\n");
    }
     
    if (extendsname.equals("NslModule") || extendsname.equals("NslModel") || extendsname.equals("NslClass"))
    {
    strbuf.append("\t/* Declaration statements generated by NslPreProcessor */\n");
    strbuf.append("\t/* makeinst() declared variables */\n"); 
    E = make_inst_decl_stmts.elements();
    while(E.hasMoreElements()) {
      strbuf.append("\tpublic"+(String)(E.nextElement())+ " \n");
    }
    }
    strbuf.append("\t/* temporary variables */\n");
    E = tmp_vars_mod.elements();
    while(E.hasMoreElements()) {
      tv = (TempVar)(E.nextElement());
      strbuf.append("\t"+tv.decl_stmt+"\n");
    }
    E = tmp_vars_run.elements();
    while(E.hasMoreElements()) {
      tv = (TempVar)(E.nextElement());
      strbuf.append("\t"+tv.decl_stmt+"\n");
    }
    E = tmp_vars_train.elements();
    while(E.hasMoreElements()) {
      tv = (TempVar)(E.nextElement());
      strbuf.append("\t"+tv.decl_stmt+"\n");
    }
 
    // constructor with parameter input
 /* 
   if(decl_methods[MethodNode.MAKEINST]!= null &&
       constructors.size() == 0)
      strbuf.append(decl_methods[MethodNode.MAKEINST].genConstructor(name)); //, npp));
  */
      //System.err.println("@@@@@@@@@@@@@@ MY NAME IS with pars:"+name+" "+nslpars);
     strbuf.append(genConstructor(name,nslpars));   
     strbuf.append("\t/* end of automatic declaration statements */\n");

    
// return strbuf.toString();

    return new NPPGenCode(strbuf.toString(), end_token.lineno, end_token.charno, 
			  end_token.lineno, -1);
	
  }

String genModInitStmt() { //NslPreProcessor npp) { 
// public NPPGenCode genInitStmt() { //NslPreProcessor npp) {
  java.util.Enumeration E = tmp_vars_mod.elements();   
  TempVar tv; 
  StringBuffer strbuf = new StringBuffer();
  strbuf.append("\t/* Intialisation statements generated by NslPreProcessor */\n"); 
  strbuf.append("\t/* temporary variables */\n");

  while(E.hasMoreElements()) { 
    tv = (TempVar)(E.nextElement());
    strbuf.append("\t"+tv.init_stmt+"\n");
  } 
  strbuf.append("\t/* end of automatic intialisation statements */\n"); 
  return strbuf.toString();
// Commented out to return a String to be put in method nslInitTemp()
/*  
  if(decl_methods[MethodNode.INITMODULE] == null ||
     decl_methods[MethodNode.INITMODULE].end_token == null) 
    return null; 
  // else
  return new NPPGenCode(strbuf.toString(),
  		decl_methods[MethodNode.INITMODULE].end_token.lineno,
	  	decl_methods[MethodNode.INITMODULE].end_token.charno,
          	decl_methods[MethodNode.INITMODULE].end_token.lineno, -1);
*/
  }
  
  String genRunInitStmt() { 
  java.util.Enumeration E = tmp_vars_run.elements();   
  TempVar tv; 
  StringBuffer strbuf = new StringBuffer();
  strbuf.append("\t/* Intialisation statements generated by NslPreProcessor */\n"); 
  strbuf.append("\t/* temporary variables */\n");

  while(E.hasMoreElements()) { 
    tv = (TempVar)(E.nextElement());
    strbuf.append("\t"+tv.init_stmt+"\n"); 
  } 
  strbuf.append("\t/* end of automatic intialisation statements */\n"); 
  return strbuf.toString();
  }
  
  String genTrainInitStmt() { 
  java.util.Enumeration E = tmp_vars_train.elements();   
  TempVar tv; 
  StringBuffer strbuf = new StringBuffer();
  strbuf.append("\t/* Initialisation statements generated by NslPreProcessor */\n"); 
  strbuf.append("\t/* temporary variables */\n");

  while(E.hasMoreElements()) { 
    tv = (TempVar)(E.nextElement());
    strbuf.append("\t"+tv.init_stmt+"\n"); 
  } 
  strbuf.append("\t/* end of automatic intialisation statements */\n"); 
  return strbuf.toString();
  }
  
  // New Method added to instantiate all temporaries in makeInst();
  String genTempInstStmt() {
    java.util.Enumeration E;   
    TempVar tv; 
    StringBuffer strbuf = new StringBuffer();
    strbuf.append("\t/* Instantiation statements generated by NslPreProcessor */\n"); 
    strbuf.append("\t/* temporary variables */\n");

    E = tmp_vars_mod.elements();   	// Temp corresponding to initModule()
    while(E.hasMoreElements()) { 
      tv = (TempVar)(E.nextElement());
      strbuf.append("\t"+tv.inst_stmt+"\n");
    }
    
    E = tmp_vars_run.elements();	// Temp corresponding to initRun()
    while(E.hasMoreElements()) { 
      tv = (TempVar)(E.nextElement());
      strbuf.append("\t"+tv.inst_stmt+"\n");
    }
    
    E = tmp_vars_train.elements();	// Temp corresponding to initTrain()
    while(E.hasMoreElements()) { 
      tv = (TempVar)(E.nextElement());
      strbuf.append("\t"+tv.inst_stmt+"\n");
    }
     
    strbuf.append("\t/* end of automatic instantiation statements */\n"); 
    return strbuf.toString();
  }
  
  
  StringBuffer plist;
  StringBuffer plistM;
  StringBuffer pdecl; //SM
  StringBuffer ptype;
  StringBuffer pinit;
  public void constructorSetup(ParamsNode params) {

      plist = new StringBuffer(1024);
      plistM = new StringBuffer(1024);
      ptype = new StringBuffer(1024);
      pinit = new StringBuffer(2048);
      pdecl = new StringBuffer(2048);

      if (params==null) return;
      Enumeration E = params.list.elements();
      FormalNode fn;
      int  i=0;
      while(E.hasMoreElements()) {
	fn = (FormalNode)E.nextElement();
	plist.append(", "+fn.text);
	
// ERH: if you wan't to have makeInst calls without name,parent change 0s to 2.
//      in the next twol lines
	if (i==0) plistM.append(fn.text); //for makeInst
	if (i>0) plistM.append(", "+fn.text); //for makeInst

	if (i!=0) ptype.append(", ");
	ptype.append(fn.type.text+" "+fn.text);

 	pdecl.append("\t"+fn.type.text+" "+fn.text+";\n");
 
	pinit.append("\t\tthis."+fn.text+" = "+fn.text+";\n");
//	npp.addMakeInstDeclStmt("\t"+fn.type.text+" "+fn.text+" ;"+"/* for makeinst() args */ ", fn);
    i++; 
    }
  }

  public void set_superargs(String s)
 { superargs_str=s;
   //System.err.println("Set superargs to "+s);
}


  String genConstructor(String name,ParamsNode params) {


    StringBuffer strbuf = new StringBuffer(4096);
    if (extendsname.equals("NslModule") || extendsname.equals("NslModel") || extendsname.equals("NslClass")) { }
    else { //System.err.println("extendsname:"+extendsname+" no Constructor for "+name); 
      return("");
    }
    constructorSetup(params);
    strbuf.append("\t/* constructor and related methods */\n");
    // default constructor method

    // Empty constructor generated only for NslModel
    if (extendsname.equals("NslModel") ) { 
      strbuf.append("\t/* EMPTY CONSTRUCTOR: Called only for the top level module */\n\t public "+name+"() {\n");
	//if (superargs_str==null) strbuf.append("\t\tsuper();\n");
	//else strbuf.append("\t\tsuper();\n");
      String newName = name.substring(0,1).toLowerCase() + name.substring(1);
      strbuf.append("\t\tsuper(\""+newName+"\",("+extendsname+")null);\n");
      strbuf.append("\t\tif (NslMain.TopLoaded) { System.err.println(\n");
      strbuf.append("\t\t \"ERROR: construction without (name,parent)\");\n");
      strbuf.append("\t\t System.exit(1);} \n");
      strbuf.append("\t\t NslMain.TopLoaded=true; \n");
	//initSys
      strbuf.append("\t\tinitSys();\n");
     	//makeInst
      strbuf.append("\t\tmakeInst(\""+newName+"\",null);\n");
      strbuf.append("\t}\n"); 
    }  // end of Empty Constructor


// if (!superargs_str.equals("")){
    // constructor with parameter input
    // default parameter actions
    strbuf.append("\t/* nsl declarations */\n");
    strbuf.append(pdecl.toString());
    strbuf.append("\n\t /*GENERIC CONSTRUCTOR:   */\n\t public "+name+"(" );
    strbuf.append("String nslName, NslModule nslParent");
    if (params!= null) {
      strbuf.append(",");
      Enumeration E = params.list.elements();
      strbuf.append(ptype);
    }
    strbuf.append(") {\n");
    if (superargs_str=="") strbuf.append("\t\tsuper(nslName, nslParent);\n");
    else strbuf.append("\t\tsuper(nslName, nslParent,"+superargs_str+");\n");
    strbuf.append(pinit.toString());
//initSys
    if (extendsname.equals("NslModule") || extendsname.equals("NslModel")) { 
      strbuf.append("\t\tinitSys();\n");
    }
    if(use_parameter_passing) {
	// new! for local makeinst calling, instead from 
	// parent constructor
      strbuf.append("\t\tmakeInst(");
      strbuf.append("nslName, nslParent");
      if(params!=null) {
        strbuf.append(",");
        strbuf.append(plistM.toString());
      }
    strbuf.append(");\n");
	//ERH: commented out
	// strbuf.append("\tif (parentinst != null)\n\t\tparentinst.addModule((NslModule)this);\n");
    }
    strbuf.append("\t}\n");
	// } /* if (superargs_str!="")... */

	// Another Constructor for NslClasses
    if(extendsname.equals("NslClass")) {
      strbuf.append("\n\t public "+name+"(" );
      strbuf.append("String nslName, NslClass nslParent");
      if (params!= null) {
        strbuf.append(",");
        Enumeration E = params.list.elements();
        strbuf.append(ptype);
      }
      strbuf.append(") {\n");
      if (superargs_str=="") strbuf.append("\t\tsuper(nslName, nslParent);\n");
      else strbuf.append("\t\tsuper(nslName, nslParent,"+superargs_str+");\n");
      strbuf.append(pinit.toString());
      if(use_parameter_passing) {
	// new! for local makeinst calling, instead from 
	// parent constructor
        strbuf.append("\t\tmakeInst(");
        strbuf.append("nslName, nslParent");
        if(params!=null) {
          strbuf.append(",");
          strbuf.append(plistM.toString());
        }
      strbuf.append(");\n");
      }
    strbuf.append("\t}\n");
    } // Another Constructor for NslClasses
    
/* ERH: need to think decide what todo with this.
   One sometimes needs to save the arguments passed to
   constructor. Currently one cannot do that, This may be a
   good candidate
*/
   // strbuf.append(pdecl.toString()); // moved to Generic constructor

   strbuf.append("\tpublic void makeInst(String nslName, NslModule nslParent");
   if (nslpars_str == "") strbuf.append("){ \n");
   else strbuf.append(","+nslpars_str+"){ \n");
   //System.err.println("nsldecls "+nsldecls);
	//strbuf.append(pinit.toString());// moved to Generic constructor
	//callFromConstructor
	//98/7/30 aa: changed const_called to constr_called_method_defined
	//98/7/30 aa: changed again to exists_callFromConstructorTop
   	
   	if (exists_callFromConstructorTop)  {
	    strbuf.append("\tcallFromConstructorTop();\n");
	}
     
     //now for the declared variables: they need to be instantiated
     java.util.Enumeration F=nsldecls.elements();
     while(F.hasMoreElements()) {
      strbuf.append("\t "+F.nextElement()+"; //NSLDECLS \n");
    }
    // Put Instantiation of temporaries in makeInst if its nslClass
    if (extendsname.equals("NslClass")) {
      strbuf.append(genTempInstStmt());
    }
      
   //callFromConstructorBottom
   //98/7/30 aa: changed const_called to constr_called_method_defined
   //98/7/30 aa: changed again to exists_callFromConstructorBottom
   
   if (exists_callFromConstructor){
    strbuf.append("\tcallFromConstructor();\n");
   }

   if (exists_callFromConstructorBottom){
    strbuf.append("\tcallFromConstructorBottom();\n");
   }

   strbuf.append("\t}\n");
   
   if(extendsname.equals("NslClass")) {  // another makeInst for nslClass
     strbuf.append("\tpublic void makeInst(String nslName, NslClass nslParent");
     if (nslpars_str == "") strbuf.append("){ \n");
     else strbuf.append(","+nslpars_str+"){ \n");
     //System.err.println("nsldecls "+nsldecls);
     if (exists_callFromConstructorTop)  {
       strbuf.append("\tcallFromConstructorTop();\n");
     }
     
     //now for the declared variables: they need to be instantiated
     // java.util.Enumeration F=nsldecls.elements();
     F = nsldecls.elements();
     while(F.hasMoreElements()) {
      strbuf.append("\t "+F.nextElement()+"; //NSLDECLS \n");
     }
     // Put Instantiation of temporaries in makeInst if its nslClass
     strbuf.append(genTempInstStmt());
      
     if (exists_callFromConstructor){
       strbuf.append("\tcallFromConstructor();\n");
     }
     if (exists_callFromConstructorBottom){
       strbuf.append("\tcallFromConstructorBottom();\n");
     }

     strbuf.append("\t}\n");
   }
   return strbuf.toString();
 }



  void setEndToken(YYtoken end_token) {
    this.end_token = end_token;
  }

  protected void finalize() {
    tmp_vars_mod.removeAllElements();
    tmp_vars_run.removeAllElements();
    tmp_vars_train.removeAllElements();
    methods.removeAllElements();
    unresolved_vars.removeAllElements();
    constructors.removeAllElements();
    for(int i=0; i<decl_methods.length; i++)
      decl_methods = null;
    end_token = null;
  }


  public static final int MAX_TEMP_NUMBER = 255;
  public static final int MIN_TEMP_NUMBER = 101;
  public static final String TEMP_NUMBER_PREFIX = "__nsltmp";
  public static final String TEMP_ACCESS_FLAG = "private ";

  int cur_tmp_number;
  Vector tmp_vars_run;
  Vector tmp_vars_train;
  Vector tmp_vars_mod;
  Vector tmp_vars;
  Vector methods;
  Vector unresolved_vars;
  Vector make_inst_decl_stmts;
  Vector nsldecls;
  Vector constructors;
  String superargs_str="";  // super call args in constructor
  String nslpars_str="";  // main constructor pars at nslModule def.
  ParamsNode nslpars=null;
  YYtoken end_token;
  /* list of methods that is declared inside the class */
  MethodNode[] decl_methods; 

  /* variable declaration list, 
   a list of declaration statement to declare variables
   in makeinst()*/
  //  Vector decl_stmts;

  /* some explicit data memebers */
  public String name;
  public String filename;
  public String extendsname;
  public String interfacename;
  public boolean exists_callFromConstructor=false;
// public boolean exists_createModule=false;
  public boolean exists_callFromConstructorBottom=false;  
//  public boolean exists_createModuleBottom=false;  
  public boolean exists_callFromConstructorTop=false;  
//  public boolean exists_createModuleTop=false;  

}