parser.java

一个非常简洁的java脚本引擎

                            curNode=node;

                        } else if (curNode.right==null){
                            curNode.right=node;
                            node.parent=curNode;
                            curNode=node;

                        }
                    } else {
                        curNode=node;
                    }
                    prevOp=false;
                    break;
                }

                default: {
                    end=true;
                }

            }
            if (!end){
                tok.nextToken();
            }
        }

        //find the top of the tree we just built.
        if (curNode==null) parseError("Missing Expression");
        while(curNode.parent!=null){
            curNode=curNode.parent;
        }


        return evalETree(curNode);

    }

    //convenience function to get operator priority
    private int getPrio(int op){
        return ((Integer)opPrio.get(new Integer(op))).intValue();
    }

    //evaluates the expression tree recursively
    private Object evalETree(ETreeNode node) throws FSException{
        Object lVal,rVal;

        if ( node == null )
        {
            parseError("Malformed expression");
            // this is never reached, just for readability
            return null;
        }

        if (node.type==ETreeNode.E_VAL){
            return node.value;
        }
        lVal=evalETree(node.left);
        rVal=evalETree(node.right);

        switch (((Integer)node.value).intValue()){
            //call the various eval functions
            case LexAnn.TT_PLUS:{
                return evalPlus(lVal,rVal);
            }
            case LexAnn.TT_MINUS:{
                return evalMinus(lVal,rVal);
            }
            case LexAnn.TT_MULT:{
                return evalMult(lVal,rVal);
            }
            case LexAnn.TT_DIV:{
                return evalDiv(lVal,rVal);
            }
            case LexAnn.TT_LEQ:{
                return evalEq(lVal,rVal);
            }
            case LexAnn.TT_LNEQ:{
                return evalNEq(lVal,rVal);
            }
            case LexAnn.TT_LLS:{
                return evalLs(lVal,rVal);
            }
            case LexAnn.TT_LLSE:{
                return evalLse(lVal,rVal);
            }
            case LexAnn.TT_LGR:{
                return evalGr(lVal,rVal);
            }
            case LexAnn.TT_LGRE:{
                return evalGre(lVal,rVal);
            }
            case LexAnn.TT_MOD:{
                return evalMod(lVal,rVal);
            }
            case LexAnn.TT_LAND:{
                return evalAnd(lVal,rVal);
            }
            case LexAnn.TT_LOR:{
                return evalOr(lVal,rVal);
            }
        }

        return null;
    }

    //addition
    private Object evalPlus(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            return new Integer(((Integer)lVal).intValue()
            +((Integer)rVal).intValue());
        } else if (lVal instanceof Double && rVal instanceof Double){
            return new Double(((Double)lVal).doubleValue()
            +((Double)rVal).doubleValue());
        } else if (lVal instanceof String || rVal instanceof String){
            return new String(lVal.toString()+rVal.toString());
        } else if (lVal instanceof Double && rVal instanceof Integer){
            return new Double(((Double)lVal).doubleValue()
            +((Integer)rVal).intValue());
        } else if (lVal instanceof Integer && rVal instanceof Double){
            return new Double(((Integer)lVal).intValue()
            +((Double)rVal).doubleValue());
        } else {
            parseError("Type Mismatch for operator +");
        }

        return null;
    }

    //subtraction
    private Object evalMinus(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            return new Integer(((Integer)lVal).intValue()
            -((Integer)rVal).intValue());
        } else if (lVal instanceof Double && rVal instanceof Double){
            return new Double(((Double)lVal).doubleValue()
            -((Double)rVal).doubleValue());
        } else if (lVal instanceof Double && rVal instanceof Integer){
            return new Double(((Double)lVal).doubleValue()
            -((Integer)rVal).intValue());
        } else if (lVal instanceof Integer && rVal instanceof Double){
            return new Double(((Integer)lVal).intValue()
            -((Double)rVal).doubleValue());
        } else {
            parseError("Type Mismatch for operator -");
        }

        return null;
    }

    //multiplication
    private Object evalMult(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            return new Integer(((Integer)lVal).intValue()
            *((Integer)rVal).intValue());
        } else if (lVal instanceof Double && rVal instanceof Double){
            return new Double(((Double)lVal).doubleValue()
            *((Double)rVal).doubleValue());
        } else if (lVal instanceof Double && rVal instanceof Integer){
            return new Double(((Double)lVal).doubleValue()
            *((Integer)rVal).intValue());
        } else if (lVal instanceof Integer && rVal instanceof Double){
            return new Double(((Integer)lVal).intValue()
            *((Double)rVal).doubleValue());
        } else {
            parseError("Type Mismatch for operator *");
        }

        return null;
    }

    //modulus
    private Object evalMod(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            return new Integer(((Integer)lVal).intValue()
            %((Integer)rVal).intValue());
        } else {
            parseError("Type Mismatch for operator %");
        }

        return null;
    }

    //Logical AND
    private Object evalAnd(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            boolean b1,b2;
            b1=((Integer)lVal).intValue()!=0;
            b2=((Integer)rVal).intValue()!=0;
            if (b1 && b2){
                return FS_TRUE;
            }else{
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator &&");
        }

        return null;
    }

    //Logical Or
    private Object evalOr(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            boolean b1,b2;
            b1=((Integer)lVal).intValue()!=0;
            b2=((Integer)rVal).intValue()!=0;
            if (b1 || b2){
                return FS_TRUE;
            }else{
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator ||");
        }

        return null;
    }

    //division
    private Object evalDiv(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            return new Integer(((Integer)lVal).intValue()
            /((Integer)rVal).intValue());
        } else if (lVal instanceof Double && rVal instanceof Double){
            return new Double(((Double)lVal).doubleValue()
            /((Double)rVal).doubleValue());
        } else if (lVal instanceof Double && rVal instanceof Integer){
            return new Double(((Double)lVal).doubleValue()
            /((Integer)rVal).intValue());
        } else if (lVal instanceof Integer && rVal instanceof Double){
            return new Double(((Integer)lVal).intValue()
            /((Double)rVal).doubleValue());
        } else {
            parseError("Type Mismatch for operator /");
        }

        return null;
    }

    //logical equal
    private Object evalEq(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            if (lVal.equals(rVal)){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof Double && rVal instanceof Double){
            if (lVal.equals(rVal)){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (lVal.equals(rVal)){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof FSObject){
            if (lVal.equals(rVal)){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (rVal instanceof FSObject){
            if (rVal.equals(lVal)){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator ==");
        }

        return null;
    }

    //<
    private Object evalLs(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            if (((Integer)lVal).intValue()<((Integer)rVal).intValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof Double && rVal instanceof Double){
            if (((Double)lVal).doubleValue()<((Double)rVal).doubleValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)<0) {
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator <");
        }
        return null;
    }

    //<=
    private Object evalLse(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            if (((Integer)lVal).intValue()<=((Integer)rVal).intValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof Double && rVal instanceof Double){
            if (((Double)lVal).doubleValue()<=((Double)rVal).doubleValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)<=0) {
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator <=");
        }
        return null;
    }

    //>
    private Object evalGr(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            if (((Integer)lVal).intValue()>((Integer)rVal).intValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof Double && rVal instanceof Double){
            if (((Double)lVal).doubleValue()>((Double)rVal).doubleValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)>0) {
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator >");
        }
        return null;
    }

    //>=
    private Object evalGre(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            if (((Integer)lVal).intValue()>=((Integer)rVal).intValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof Double && rVal instanceof Double){
            if (((Double)lVal).doubleValue()>=((Double)rVal).doubleValue()){
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)>=0) {
                return FS_TRUE;
            } else {
                return FS_FALSE;
            }
        } else {
            parseError("Type Mismatch for operator >=");
        }
        return null;
    }

    //logical inequallity
    private Object evalNEq(Object lVal,Object rVal) throws FSException{
        if ( evalEq( lVal, rVal ) == FS_TRUE )
        {
            return FS_FALSE;
        } else {
            return FS_TRUE;
        }
    }

/*    private void printWTree(ETreeNode node){
        while(node.parent!=null){
            node=node.parent;
        }
        printETree(node);
    } */

/*    private void printETree(ETreeNode node){

        System.out.println(node);
        if (node.left!=null){
            System.out.print("Left");
            printETree(node.left);
        }
        if (node.right!=null){
            System.out.print("Right");