parser.java

technical manual which is very helpful for the j2me development,may it help you.

                        }
                    } 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.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 String || rVal instanceof String){
            return new String(lVal.toString()+rVal.toString());
        } 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 {
            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 {
            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 new Integer(1);
            }else{
                return new Integer(0);
            }
        } 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 new Integer(1);
            }else{
                return new Integer(0);
            }
        } 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 {
            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 new Integer(1);
            } else {
                return new Integer(0);
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (lVal.equals(rVal)){
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } 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 new Integer(1);
            } else {
                return new Integer(0);
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)<0) {
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } 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 new Integer(1);
            } else {
                return new Integer(0);
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)<=0) {
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } 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 new Integer(1);
            } else {
                return new Integer(0);
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)>0) {
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } 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 new Integer(1);
            } else {
                return new Integer(0);
            }
        }  else if (lVal instanceof String && rVal instanceof String){
            if (((String)lVal).compareTo((String)rVal)>=0) {
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } else {
            parseError("Type Mismatch for operator >=");
        }
        return null;
    }
    
    //logical inequallity
    private Object evalNEq(Object lVal,Object rVal) throws FSException{
        if (lVal instanceof Integer && rVal instanceof Integer){
            if (!lVal.equals(rVal)){
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } else if (lVal instanceof String && rVal instanceof String){
            if (!lVal.equals(rVal)){
                return new Integer(1);
            } else {
                return new Integer(0);
            }
        } else {
            parseError("Type Mismatch for operator !=");
        }
        return null;
    }
    
    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");
            printETree(node.right);
        }
    }
    
    private void parseIf() throws FSException,RetException {
        Integer val;
        int depth;
        boolean then=false;
        
        
        getNextToken();
        try {
            val=(Integer)parseExpr();
        } catch (ClassCastException cce) {
            parseError("If condition needs to be Integer");
            return; // just to make sure the compiler doesn't complain
            // as we know parseError throws an exception (stupid compiler)
        }
        
        //handle the one line if-then construct
        if (tok.ttype==LexAnn.TT_THEN){
            getNextToken();
            //is this a single line then (or just a optional then)
            if (tok.ttype!=LexAnn.TT_EOL){
                //single line if then construct - run separately
                //tok.pushBack();
                if (val.intValue()!=0){
                    parseStmt();
                } else {
                    //consume to EOL
                    while(tok.ttype!=LexAnn.TT_EOL){
                        getNextToken();
                    }
                }
                then=true;
            }
        }