package nl.bluering;

public class Variable
{
 int status;
 public final static int UNDEF=0,INT=1,DBL=2,EXP=3,OBJ=4,STR=5;
 double dv;
 Object ov;
 int iv;
 String name;
 
 
 Variable(String name)
 {status=UNDEF;
  this.name=name; 
 }
 double set(double d)
 {status=DBL;
  dv=d;
  return d; 
 }
 void set(Variable v)
 {
  status=v.status;
  switch(status)
  {case INT:iv=v.iv;break;
   case DBL:dv=v.dv;break;
   default:ov=v.ov;break;
  }
 }
 boolean set(boolean b)
 {set(b?1:0);
  return b;  
 }

 
 int set(int d)
 {status=INT;
  iv=d; 
  return d;
 }
 Expression set(Expression e)
 {status=EXP;
  ov=e;
  return e;
 }
 String set(String e)
 {status=STR;
  ov=e;
  return e;
 }
 Object set(Object e)
 {
  if(e instanceof Variable)
  	new Exception("var").printStackTrace();
  status=OBJ;
  ov=e;
  return e;
 }

 Object getobject()
 {if(status!=OBJ)
   set(conv2object());
  return ov;	
 }
 int getint()
 {if(status!=INT)
   set(conv2int());
  return iv;	
 }
 boolean getboolean()
 {if(status!=INT)
   set(conv2int());
  return iv!=0;	
 }
 double getdouble()
 {if(status!=DBL)
   set(conv2double());
  return dv;	
 }
 String getstring()
 {if(status!=STR)
   set(conv2string());
  return (String)ov;	
 }
 Expression getexp()
 {if(status!=EXP&&status!=UNDEF)
   set(conv2exp());
  return (Expression)ov;	
 }
 
 Object conv2object()
 {switch(status)
  {case UNDEF:return new Exception("not defined");
   case INT:return i2o(iv);
   case DBL:return d2o(dv);
   case EXP: return e2o((Expression)ov);
   case OBJ: return ov;
   case STR: return ov;
  }
  new Exception("fallthrough").printStackTrace();
  return null;
 }
 int conv2int()
 {switch(status)
  {case UNDEF:return 0;
   case INT:return iv;
   case DBL:return d2i(dv);
   case EXP: return e2i((Expression)ov);
   case OBJ: return o2i(ov);
   case STR: return s2i((String)ov);
  }
  new Exception("fallthrough").printStackTrace();
  return 0;
 }
 double conv2double()
 {switch(status)
  {case UNDEF:return 0;
   case INT:return iv;
   case DBL:return dv;
   case EXP: return e2d((Expression)ov);
   case OBJ: return o2d(ov);
   case STR: return s2d((String)ov);
  }
  new Exception("fallthrough").printStackTrace();
  return 0;
 }
 
 String conv2string()
 {switch(status)
  {case UNDEF:return "";
   case INT:return i2s(iv);
   case DBL:return d2s(dv);
   case EXP: return e2s((Expression)ov);
   case OBJ: return o2s(ov);
   case STR: return (String)ov;
  }
  new Exception("fallthrough").printStackTrace();
  return "";
 }
 Expression conv2exp()
 {switch(status)
  {case UNDEF:return null;
   case INT:return i2e(iv);
   case DBL:return d2e(dv);
   case EXP: return (Expression)ov;
   case OBJ: return o2e(ov);
   case STR: return s2e((String)ov);
  }
  new Exception("fallthrough").printStackTrace();
  return null;
 }

 /**
 * conversion functions between all basic return values.
 */
 static int b2i(boolean b)
 {return b?1:0;
 }
 
 
 static Object i2o(int i)
 {return i2s(i);}
 int o2i(Object o)
 {return 0;}

 static Object d2o(double d)
 {return d2s(d);}
 double o2d(Object o)
 {return 0;}
 
 
 static int d2i(double d)
 {return (int)Math.round(d);
 }
 static double d2i(int i)
 {return i;
 }
 
 static Expression i2e(int i)
 {return s2e(i2s(i));}
 static int e2i(Expression e)
 {return s2i(e2s(e));
 }
 
 static int s2i(String s)
 {try
  {return Integer.parseInt(s);
  }catch(Exception e){}
  return 0;
 }
 static String i2s(int i)
 {return ""+i;
 }

 static Expression d2e(double d)
 {return s2e(d2s(d));
 } 
 static double e2d(Expression e)
 {return s2d(e2s(e));
 }
 
 static double s2d(String s)
 {try
  {return new Double(s).doubleValue();
  }catch(Exception e){}
  return Double.NaN;
 }
 
 static String d2s(double d)
 {String r=""+d;
  if(r.endsWith(".0"))
   return r.substring(0,r.length()-2);
  return r; 
 }
 static String o2s(Object o)
 {if(o instanceof String)
 	return (String)o;
  return o.toString();	
 }
 
 
 static Object e2o(Expression e)
 {if(!e.isbasic())
 	return e;
  return e.getobject();	
 }
 static Expression o2e(Object o)
 {return new Expression(o,-1);}

 static String e2s(Expression e)
 {if(e.isbasic())
 	return e.getfunctionstring();
  return e.getprototype();	
 }
 static Expression s2e(String s)
 {return new Expression(s,-1);
 }


 public String toString()
 {return name;
 }


 Class getvalueclass()
 {
  switch (status)
  {
   case UNDEF:return null;
   case INT:
   case DBL:return Interpreter.numberclass;
   case EXP: 
   	if(((Expression)ov).isbasic())
   	  return ((Expression)ov).getobject().getClass();
    return ((Expression)ov).getClass();
   case OBJ: 
   case STR: 
    return ov.getClass();
  }
  return null;
 }
 
 public static Class getsuperclass(Class c)
 {if(c==Interpreter.numberclass)
 	return null;
  return c.getSuperclass();	
 }
}