package nl.bluering;
import java.util.Vector;

/**
* Expressions are simple trees. It can be used for anything. 
* An expression consists of an object o and zero or more
* subexpressions (children). It is common that the object is a string, but depending
* on your needs it can be something different. (it better be printable if 
* you intend to print it. I can also disrecommend null pointers, 
* but it is not forbidden:-) the problems are yours though).
*/

public class Expression
{
	Expression[] e;
	Object function = "";
	int childs = 0;

/**
* create an Expression with the object s and
* room for the given number of children.
* @param s the object in this expression. Often a string
* @param ch the estimated number of children. You can give any value,
* regardless what number of children you will really add, but memory use
* is more efficient if it is correct. Note that -1 is allowed: it indicates
* that it came in in a notation that does not allow arguments: for instance
* "123" and "a" do not allow children, but "f()" does.
*/	
	
	public Expression(Object s,int ch)
	{
		if(ch==-1)
		 childs = -1;
		else
		{
		 ch=0;
		 e = new Expression [ch];
		}
		function=s;
	}

   Expression(String fname,Vector v)
   {this(fname,v.size());
    for(int i=0;i<v.size();i++)
	 add((Expression)v.elementAt(i));   
   }
   
   
   public Expression Eclone()
   {Expression r=new Expression(getfunctionstring(),childs);
    for(int i=0;i<childs;i++)
	 r.add(get(i).Eclone());
	return r;   
   }
   
   /**
   * returns true if the primary object of this Expression is a string that
   * is equal to f.
   */
   public boolean isfunction(String f)
   {return f.equals(function);
   }
   /**
   * returns true if the primary object of this Expression is a string that
   * is equal to f,and the number of children is correct. You can make children
   * -1 to test for basicness.
   */
   public boolean isfunction(String f,int children)
   {return f.equals(function)&&this.childs==children;
   }
   
   /**
   * return the primary object if it is a string. Otherwise it 
   * returns the cryptic string "__undisplayable__object__" 
   * (mostly useful for debugging purposes).
   */
   public String getfunctionstring()
   	{
	 if(function instanceof String)
	  return (String)function;
	 return function.toString();  
	}
	
   /**
   * returns the primary string concatenated with the number of children.
   * this is used to look up functions in hashtables.
   */
   public String getprototype()
   	{return functionpointer.makeprototype(getfunctionstring(),childs);
   }

   public static String exampletype(String s,int a)
   {Expression e=new Expression(s,a);
    for(int i=0;i<a;i++)
	 e.add("a"+i);
	return e.toString();
   }
   boolean matches(String fname,int childs)
   {return childs==this.childs&&getfunctionstring().equals(fname);
   }
   
   /**
   * Returns if this is a basic function. A basic function does not allow 
   * arguments: for instance "123" and "a" do not allow children, but "f()" does.
   */
   public boolean isbasic()
   {return childs==-1;
   }
   
   public boolean hasstringobject()
   {return function instanceof String;
   }
   
   /**
   * Adds an basic Expression with name s as a child to this Expression
   */
   Expression add(String s)
   {return add(new Expression(s,-1));
   }
   
   /**
   * Adds an Expression to this class as a child.
   */
   public Expression add(Expression exp)
	{
		if (childs==e.length)
		{Expression[] largerArray=new Expression[e.length+2];
	     for(int i=0;i<e.length;i++)
		  largerArray[i]=e[i];
		 e=largerArray; 	
		}
		e[childs++] = exp;
		return this;
	}
    /**
	* Returns the number of children.
	*/
	public int getc() { return (childs==-1)?0:childs;}
    public Object getobject()
    {return function;
    }
    public void setobject(Object o)
    {function=o;
    }
	/**
	* Returns the child at the given index. returns null when the index is invalid
	*/
	Expression get(int child)
	{
		if ((child<childs) && (child>=0))
		{
			return e[child];
		}
		else
		{
			return null;
		}
	}
    /**
	* Converts the complete expression to a one-line string, including it's childs.
	*/
	public String toString() {
	 String r=function.toString();
	 if (childs==0)
	 {
	 	return r+"()";
	 }
	 if(childs>0){
	  r+="("+e[0];
	  for(int i=1;i<childs;i++)
	   r+=","+e[i];
	  r+=")";
     }
	 return r;
	}
 Expression wrap(String s)
 {return new Expression(s,1).add(this);
 }

}