Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Code.Caller.Arguments;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.impl.function.operator.BinaryOperator;

import org.gvsig.expressionevaluator.impl.function.operator.UnaryOperator;

public class DefaultInterpreter implements Interpreter {

    private SymbolTable symbolTable = null;

    private Double accuracy;

    private Code currentCode;

    public DefaultInterpreter() {

        this.symbolTable = SQLSymbolTable.getInstance();

    }

    @Override

    public void setSymbolTable(SymbolTable symbolTable) {

        this.symbolTable = symbolTable;

    }

    @Override

    public SymbolTable getSymbolTable() {

        return this.symbolTable;

    }

    @Override

    public Double getAccuracy() {

        return this.accuracy;

    }

    @Override

    public void setAccuracy(Double accuracy) {

        this.accuracy = accuracy;

    }

    @Override

    public Object run(Code code) {

        try {

            return this.runCode(code);

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public void link(Code code) {

        linkCode(code);

    }

    private void linkCode(Code code) {

        if( code instanceof Caller ) {

            Caller caller = (Caller) code;

            if( caller.function() == null ) {

                caller.function(this.symbolTable.function(caller.name()));

            }

            if( caller.args() != null ) {

                for( Code arg : caller.args() ) {

                    linkCode(arg);

                }

            }

        }

    }

    private Object runCode(Code code) throws Exception {

        this.currentCode = code;

        Object value = null;

        switch( code.code() ) {

        case Code.CONSTANT:

            value = ((Constant) code).value();

            break;

        case Code.IDENTIFIER:

            String name = ((Identifier) code).name();

            if( !symbolTable.exists(name) ) {

                throw new RuntimeException("Variable '" + name + "' not found.");

            }

            value = symbolTable.value(name);

            break;

        case Code.CALLER:

            Caller caller = (Caller) code;

            Function function = caller.function();

            if( function == null ) {

                function = this.symbolTable.function(caller.name());

                if( function == null ) {

                    throw new RuntimeException("Function '" + caller.name() + "' not found.");

                }

                caller.function(function);

            }

            Arguments args = caller.args();

            try {

                switch( caller.type() ) {

                case Caller.UNARY_OPERATOR:

                    if( args == null || args.count() != 1 ) {

                        throw new RuntimeException("Number of argument mistmatch, expected 1 got " + args.count() + ".");

                    }

                    value = ((UnaryOperator) function).call(this, runCode(args.get(0)));

                    break;

                case Caller.BINARY_OPERATOR:

                    if( args == null || args.count() != 2 ) {

                        throw new RuntimeException("Number of argument mistmatch, expected 2 got " + args.count() + ".");

                    }

                    value = ((BinaryOperator) function).call(this, runCode(args.get(0)), runCode(args.get(1)));

                    break;

                case Caller.FUNCTION:

                    int argc = (args == null) ? 0 : args.count();

                    if( !function.argc().contains(argc) ) {

                        throw new RuntimeException("Number of argument mistmatch, expected " + function.argc() + " got " + argc + ".");

                    }

                    Object[] argvalues = new Object[argc];

                    if( args != null ) {

                        int i = 0;

                        for( Code arg : args ) {

                            argvalues[i++] = runCode(arg);

                        }

                    }

                    value = function.call(this, argvalues);

                }

            } catch (Exception ex) {

                String argsstr = "???";

                try {

                    argsstr = args.toString();

                } catch(Exception ex2) {

                    // Ignore.

                }

                throw new RuntimeException("Problems calling function '"+function.name()+"' with args ("+argsstr+").", ex);

            }

        }

        this.currentCode = null;

        return value;

    }

    @Override

    public Code getCurrentCode() {

        return this.currentCode;

    }

}