mathcmds.java

Hecl编程语言是一个高层次的脚本语言的Java实现。其用意是要小

		return IntThing.create(a.intValue()%b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    return DoubleThing.create(a.doubleValue()%b.doubleValue());
//#endif
	  case AND:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue() & b.longValue());
		}
		return IntThing.create(a.intValue() & b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    throw new HeclException("Integral argument required.");
//#endif
	  case OR:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue() | b.longValue());
		}
		return IntThing.create(a.intValue() | b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    throw new HeclException("Integral argument required.");
//#endif

//#ifdef ant:j2se
	  case POW:
	    return DoubleThing.create(Math.pow(a.doubleValue(), b.doubleValue()));
//#if javaversion >= 1.5
	  case HYPOT:
	    return DoubleThing.create(Math.hypot(a.doubleValue(), b.doubleValue()));
//#endif
//#endif
	  case EQ:
	    return boolres(compare(a,b) == 0);
	  case NEQ:
	    return boolres(compare(a,b) != 0);
	  case LT:
	    return boolres(compare(a,b) < 0);
	  case LE:
	    return boolres(compare(a,b) <= 0);
	  case GT:
	    return boolres(compare(a,b) > 0);
	  case GE:
	    return boolres(compare(a,b) >= 0);
	}
	throw new HeclException("Unknown binary mathcmdcode '"+cmdcode+"'.");
    }

    private static Thing boolres(boolean res) {
	return new Thing(res ? IntThing.ONE : IntThing.ZERO);
    }
    
    public Thing operate(int cmdcode,Interp ip,Thing[] argv)
	throws HeclException {
	NumberThing num = null;

	if(1 == minargs && 1 == maxargs)
	    return unary(cmdcode,ip,NumberThing.asNumber(argv[1]));
	if(2 == minargs && 2 == maxargs)
	    return binary(cmdcode,ip,
			  NumberThing.asNumber(argv[1]),
			  NumberThing.asNumber(argv[2]));

	switch(cmdcode) {
	  case PLUS:
	    num = IntThing.ZERO;
	    for(int i=1; i<argv.length; ++i) {
		num = (NumberThing)binary(BINADD, ip, num,
					  NumberThing.asNumber(argv[i])).getVal();
	    }
	    return new Thing(num);
	  case MINUS:
	    switch(argv.length) {
	      case 1:
		return new Thing(IntThing.ZERO);
	      case 2:
		return binary(BINSUB,ip,IntThing.ZERO,NumberThing.asNumber(argv[1]));
	      default:
		num = NumberThing.asNumber(argv[1]);
		for(int i=2; i<argv.length; ++i) {
		    num = (NumberThing)binary(BINSUB,ip, num,
					      NumberThing.asNumber(argv[i])).getVal();
		}
		return new Thing(num);
	    }
	  case MUL:
	    num = IntThing.ONE;
	    for(int i=1; i<argv.length; ++i) {
		num = (NumberThing)binary(BINMUL,ip,num,
					  NumberThing.asNumber(argv[i])).getVal();
	    }
	    return new Thing(num);
//#ifdef j2se
	  case RANDOM:
	    return DoubleThing.create(Math.random());
//#endif
	  case TRUE:
	    return new Thing(IntThing.ONE);
	  case FALSE:
	    return new Thing(IntThing.ZERO);
	  case AND:
	    num = NumberThing.asNumber(argv[1]);
	    for(int i=2; i<argv.length; ++i) {
		num = (NumberThing)binary(AND,ip,num,
					  NumberThing.asNumber(argv[i])).getVal();
	    }
	    return new Thing(num);
	  case OR:
	    num = NumberThing.asNumber(argv[1]);
	    for(int i=2; i<argv.length; ++i) {
		num = (NumberThing)binary(OR,ip,num,
					  NumberThing.asNumber(argv[i])).getVal();
	    }
	    return new Thing(num);
	  case INCR:
	      num = NumberThing.asNumber(argv[1]);
	      if(!num.isIntegral()) {
		  throw new HeclException("Argument '" + argv[1].toString()
					  + "' not an integer.");
	      }
	      NumberThing offset = argv.length > 2 ?
		  NumberThing.asNumber(argv[2]) : IntThing.ONE;
	      if(((IntegralThing)num).isLong()) {
		  num = new LongThing(num.longValue() + offset.longValue());
	      } else {
		  num = new IntThing(num.intValue() + offset.intValue());
	      }
	      argv[1].setCopyVal(num);
	      return new Thing(num);
	  default:
	    /*
	    Command c = extensions.get(cmdcode);
	    if(c != null) {
		c.
	    }

	    if(extensions.get(cmdcode)) {
	    }
	    */
	}
	throw new HeclException("Unknown math operator '"
				+ argv[0].toString() + "' with code '"
				+ cmdcode + "'.");
    }


    public static void load(Interp ip) throws HeclException {
	Enumeration e = vars.keys();
	while(e.hasMoreElements()) {
	    String k = (String)e.nextElement();
	    ip.setVar(k,(Thing)vars.get(k));
	}
	Operator.load(ip,cmdtable);
    }


    public static void unload(Interp ip) throws HeclException {
	Operator.unload(ip,cmdtable);
 	Enumeration e = vars.keys();
	while(e.hasMoreElements()) {
	    ip.unSetVar((String)e.nextElement());
	}
   }


    protected MathCmds(int cmdcode,int minargs,int maxargs) {
	super(cmdcode,minargs,maxargs);
    }


    protected static int compare(int v1,int v2) {
	return v1 < v2 ? -1 : (v1 == v2) ? 0 : 1;
    }


    protected static int compare(long v1,long v2) {
	return v1 < v2 ? -1 : (v1 == v2) ? 0 : 1;
    }


    protected static int compare(double v1,double v2) {
	return v1 < v2 ? -1 : (v1 == v2) ? 0 : 1;
    }


    private static int nextop = 1000;
    private static Hashtable vars = new Hashtable();
    private static Hashtable extensions = new Hashtable();

    private static Hashtable cmdtable = new Hashtable();

    static {

	cmdtable.put("true",new MathCmds(TRUE,0,0));
	cmdtable.put("false",new MathCmds(FALSE,0,0));
	cmdtable.put("and",new MathCmds(AND,1,-1));
	cmdtable.put("or",new MathCmds(OR,1,-1));

	cmdtable.put("1+",new MathCmds(INCR,1,2));
	cmdtable.put("1-",new MathCmds(DECR,1,2));
	cmdtable.put("incr",new MathCmds(INCR,1,2));

	// cast operators
	cmdtable.put("int",new MathCmds(CASTINT,1,1));
	cmdtable.put("long",new MathCmds(CASTLONG,1,1));

	// unary operators
	cmdtable.put("abs",new MathCmds(ABS,1,1));
	cmdtable.put("not",new MathCmds(NOT,1,1));

	// binary operators
	cmdtable.put("+",new MathCmds(PLUS,-1,-1));
	cmdtable.put("-",new MathCmds(MINUS,-1,-1));
	cmdtable.put("*",new MathCmds(MUL,-1,-1));
	cmdtable.put("/", new MathCmds(BINDIV,2,2));
	cmdtable.put("%", new MathCmds(MOD,2,2));

	// comparison
	cmdtable.put("=",new MathCmds(EQ,2,2));
	cmdtable.put("!=",new MathCmds(NEQ,2,2));
	cmdtable.put("<",new MathCmds(LT,2,2));
	cmdtable.put("<=",new MathCmds(LE,2,2));
	cmdtable.put(">",new MathCmds(GT,2,2));
	cmdtable.put(">=",new MathCmds(GE,2,2));

	// stuff not available in cldc 1.0
//#if javaversion >= 1.5 || cldc > 1.0
	vars.put("pi",PI);
	vars.put("e",E);
	cmdtable.put("sqrt",new MathCmds(SQRT,1,1));
	cmdtable.put("sin",new MathCmds(SIN,1,1));
	cmdtable.put("cos",new MathCmds(COS,1,1));
	cmdtable.put("tan",new MathCmds(TAN,1,1));
	cmdtable.put("floor",new MathCmds(FLOOR,1,1));
	cmdtable.put("ceil",new MathCmds(CEIL,1,1));
	cmdtable.put("float",new MathCmds(CASTFLOAT,1,1));
	cmdtable.put("double",new MathCmds(CASTDOUBLE,1,1));
	cmdtable.put("toDegrees",new MathCmds(TODEGREES,1,1));
	cmdtable.put("toRadians",new MathCmds(TORADIANS,1,1));
//#endif

	// Stuff available only in j2se
//#if javaversion >= 1.5
	cmdtable.put("random",new MathCmds(RANDOM,0,0));
	cmdtable.put("pow", new MathCmds(POW,2,2));
	cmdtable.put("log",new MathCmds(LOG,1,1));
	cmdtable.put("asin",new MathCmds(ASIN,1,1));
	cmdtable.put("acos",new MathCmds(ACOS,1,1));
	cmdtable.put("atan",new MathCmds(ATAN,1,1));
	cmdtable.put("exp",new MathCmds(EXP,1,1));
	cmdtable.put("round",new MathCmds(ROUND,1,1));

//#if javaversion > 1.5
	cmdtable.put("signum",new MathCmds(SIGNUM,1,1));
	cmdtable.put("cbrt",new MathCmds(CBRT,1,1));
	cmdtable.put("log10",new MathCmds(LOG10,1,1));
	cmdtable.put("log1p",new MathCmds(LOG1P,1,1));
	cmdtable.put("sinh",new MathCmds(SINH,1,1));
	cmdtable.put("cosh",new MathCmds(COSH,1,1));
	cmdtable.put("tanh",new MathCmds(TANH,1,1));
	cmdtable.put("expm1",new MathCmds(EXPM1,1,1));
	cmdtable.put("hypot", new MathCmds(HYPOT,2,2));
//#endif

//#endif
    }
}