/*  SCCS - @(#)MethodCallNode.java	1.7 - 09/17/99 - 12:19:08 */

/*
 * Copyright (c) 1997 USC Brain Project. email nsl@java.usc.edu.
*/
//
// MethodCallNode
////////////////////////////////////////////////////////////

/**
 * MethodCallNode - <tt>base_expr.method_sym(args)</tt>
 */

package npp.src.util;

import pp.src.jbf.*;

public class MethodCallNode extends ExprNode{
  public MethodCallNode(YYtoken sym, ExprsNode exprs) {
    super(sym);
    lvalue = false;
    base_expr = null;
    method_sym = sym;
    args = exprs;
    makeinst = false;
    expandedname=null;
    type = null;
  }

  public MethodCallNode(ExprNode base, YYtoken sym, ExprsNode exprs) {
    super(base);
    lvalue = false;
    base_expr = base;
    method_sym = sym;
    args = exprs;
    makeinst = false;
    expandedname=null;
    type=null;
      
  }
  
   /**
   * Code generation. 
   * Do some transformation to <tt>diff</tt> method.
   * @param npp Nsl Preprocessor
   * @return error value
   */
 public int genCode(NslPreProcessor npp) {
    if( base_expr != null) {      
      base_expr.genCode(npp);
      if(base_expr.processed) processed = true;
      code = base_expr.code+"."+method_sym.text+"(";
      type = new TypeNode(base_expr);
      type.type = TypeNode.UNKNOWN;
    }
    else {
      if (expandedname!=null) code = (expandedname+"(");
      else code = (method_sym.text+"(");
      type = null;
    }
    if ( args != null) {
      java.util.Enumeration E = args.list.elements();
      ExprNode expr;
      if(E.hasMoreElements()) {
	expr = (ExprNode)E.nextElement();
	expr.genCode(npp);
	code += expr.code;
	if(expr.processed) processed = true;
        if (base_expr == null) type = new TypeNode(expr);
      }
      while(E.hasMoreElements()) {
	expr = (ExprNode)E.nextElement();
	expr.genCode(npp);
	code += (","+expr.code);
	if(expr.processed) processed = true;
      }
    }
   
    code += ")";

    if (base_expr != null) {
      if(base_expr.type != null && base_expr.type.nslNumeric) {
        // NslNumeric types
	
        if (method_sym.text.equals("getSize") || 
	   method_sym.text.equals("getSize1") || 
	   method_sym.text.equals("getSize2") ) {
	  type = new TypeNode(base_expr.type);
	  type.nslNumeric = false;
	  type.numeric = true;
	  type.dim = type.nslDim = 0;
	  type.type = TypeNode.INT; // getSize returns integer
	  lvalue = false;

        } 
        else if (method_sym.text.equals("get")) {
	  type = new TypeNode(base_expr.type);
	  type.nslNumeric = false;
	  type.numeric = true;
	  if ( args != null) {
            type.dim -= args.list.size(); // dim changed after doing get
          }
        }
   
      }
      else 
      // very complex base type, do nothing
      return NO_OP;
    } // if (base_expr != null) 

    else if (base_expr == null && args != null && expandedname != null) { // expandedname if not null, its a nslfunc
       
      java.util.Enumeration E = args.list.elements();
      ExprNode expr;
      if (args.list.size() != 2) 
        expr = (ExprNode)E.nextElement();
      else {
        ExprNode expr1 = (ExprNode)E.nextElement();
        ExprNode expr2 = (ExprNode)E.nextElement();
        expr = expr1.type.dim>expr2.type.dim ? expr1: expr2; 
      }
      type = new TypeNode(expr.type);
      type.nslNumeric = false;
      type.numeric = true;
      if (method_sym.text.equals("nslSum") ||
          method_sym.text.equals("nslDotProd") ||
	  method_sym.text.equals("nslMaxValue") ||
	  method_sym.text.equals("nslMinValue") ) {
	  
	  type.dim = type.nslDim = 0;
	  lvalue = false;
      }
      else if (method_sym.text.equals("nslTrans")) { 
          /*if (expr.code.equals("1") && type.dim == 2) {
            type.dim = type.nslDim = 1; // Transpose of of n*1 is 1d
            code += ", 1";
          }
          else type.dim = type.nslDim = 2;
          */
          type.dim = type.nslDim = 2;
      }
      else if (method_sym.text.equals("nslGetColumn"))
          type.dim -= type.nslDim -= 1;
      else if (method_sym.text.equals("nslGetRow")) {
          if (type.dim > 0) type.dim = type.nslDim = 1;
      }
        
    }
    else if (base_expr == null && args == null && expandedname != null && method_sym.text.equals("nslRandom")) {
      
      type = new TypeNode(method_sym);
      type.nslNumeric = false;
      type.numeric = true;
      type.dim = type.nslDim = 0;
      lvalue = false;
      type.type = TypeNode.DOUBLE;
    }
    // code += ")";
    
    return NO_OP;
  }

  void addInstanceName(String name) {
    if (args.list.firstElement() instanceof NewNode) {
      ((NewNode)(args.list.firstElement())).addInstanceName(name);
    }
  }

  public static int NO_OP = 0; 
  public static int SUCCESS = 1;
  public static int NULL_ARGUMENT_ERROR = 2;
  public static int INVALID_ARGUMENT_ERROR = 3;

  public boolean makeinst;
  public ExprNode base_expr;
  public YYtoken method_sym;
  public ExprsNode args;
  public String expandedname=null;
}