Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.tuple.Pair;

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.Method;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.RecursionControlSupport;

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

import org.gvsig.expressionevaluator.impl.function.programming.CallMethodFunction;

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

import org.gvsig.expressionevaluator.impl.function.programming.ReturnFunction.ReturnException;

public class DefaultInterpreter implements Interpreter {

    public static int DEFAULT_MAX_RECURSION_LIMIT = 20;

    private class DefaultCache implements Cache {

        private Map<Pair<Object,Object>,Pair<Object,Long>> data;

        public DefaultCache() {

            this.data = new  HashMap<>();

        }

        @Override

        public Object get(Object context, Object key) {

            Pair<Object, Long> v = this.data.get( Pair.of(context, key) );

            if( v == null ) {

                return null;

            }

            return v.getLeft();

        }

        @Override

        public void put(Object context, Object key, Object value) {

            if( this.data.size()>this.getMaxElements() ) {

                this.reduce();

            }

            this.data.put(Pair.of(context, key), Pair.of(value, new Date().getTime()));

        }

        @Override

        public void remove(Object context, Object key) {

            this.data.remove(Pair.of(context, key));

        }

        @Override

        public void removeAll() {

            this.data = new  HashMap<>();

        }

        private int getMaxElements() {

            return 100;

        }

        private void reduce() {

            List<Map.Entry<Pair<Object, Object>, Pair<Object, Long>>> entries = 

                new ArrayList<>(this.data.entrySet());

            entries.sort(new Comparator<Map.Entry<Pair<Object, Object>, Pair<Object, Long>>>() {

                @Override

                public int compare(Map.Entry<Pair<Object, Object>, Pair<Object, Long>> o1, Map.Entry<Pair<Object, Object>, Pair<Object, Long>> o2) {

                    return o1.getValue().getRight().compareTo(o2.getValue().getRight());

                }

            });

            for( int i=0; i<this.getMaxElements()/2; i++ ) {

                this.data.remove(entries.get(i).getKey());

            }

        }

    }

    private SymbolTable symbolTable = null;

    private Double accuracy;

    private Code currentCode;

    private Cache cache;

    private int maxRecursionLimit;

    public DefaultInterpreter() {

        this.cache = new DefaultCache();

        this.maxRecursionLimit = DEFAULT_MAX_RECURSION_LIMIT;

    }

    @Override

    public Interpreter clone() throws CloneNotSupportedException {

        DefaultInterpreter other = (DefaultInterpreter) super.clone();

        other.cache = new DefaultCache();

        if( this.symbolTable!=null ) {

            other.symbolTable = this.symbolTable.clone();

        }

        return other;

    }

    public int getMaxRecursionLimit() {

        return this.maxRecursionLimit;

    }

    public void setMaxRecursionLimit(int limit) {

        this.maxRecursionLimit = limit;

    }

    @Override

    public Cache getCache() {

        return this.cache;

    }

    @Override

    public void setSymbolTable(SymbolTable symbolTable) {

        this.symbolTable = symbolTable;

    }

    @Override

    public SymbolTable getSymbolTable() {

        if( this.symbolTable==null ) {

            this.symbolTable = new DefaultSymbolTable();

        }

        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(ReturnException ex) {

            return ex.getValue();

        } catch(RuntimeException ex) {

            throw ex;

        } catch(Exception ex) {

            throw new ExpressionRuntimeException(code, "", ex);

        }

    }

    @Override

    public void link(Code code) {

        linkCode(code);

    }

    private void linkCode(Code code) {

        if( code.code() == Code.CALLER ) {

            Caller caller = (Caller) code;

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

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

            }

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

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

                    linkCode(arg);

                }

            }

        }

    }

    public Object runCode(Code code) throws Exception {

        RecursionControlSupport recursionControl = null;

        if( code instanceof RecursionControlSupport ) {

            recursionControl = (RecursionControlSupport) code;

            if( !recursionControl.enterCode(this.maxRecursionLimit) ) {

                recursionControl.resetRecursionState();

                throw new ExpressionRuntimeException(code, I18N.Maximum_recursion_limit_exceeded());

            }

        }

        Object value = null;

        this.currentCode = code;

        try {

            switch( code.code() ) {

            case Code.CONSTANT:

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

                break;

            case Code.IDENTIFIER:

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

                if( !this.getSymbolTable().exists(name) ) {

                    throw new ExpressionRuntimeException(

                            code, 

                            I18N.Undefined_variable_XIdentifierX(name),

                            I18N.Use_single_quotes_to_enter_literal_strings()

                    );

                }

                value = this.getSymbolTable().value(name);

                break;

            case Code.METHOD: {

                    Method method = (Method) code;

                    Function function = method.function();

                    if( function == null ) {

                        Object obj = this.runCode(method.obj());

                        if( obj == null ) {

                            throw new NullPointerException("An object pointer was expected to invoke method "+method.methodname()+" and a null was received");

                        }

                        method.function(new CallMethodFunction(obj, method.methodname()));

                    }

                }

            case Code.CALLER:

                Caller caller = (Caller) code;

                Function function = caller.function();

                if( function == null ) {

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

                    if( function == null ) {

                        throw new ExpressionRuntimeException(code, I18N.Undefined_function_XIdentifierX(caller.name()));

                    }

                    caller.function(function);

                }

                Codes args = caller.args();

                try {

                    switch( caller.type() ) {

                    case Caller.UNARY_OPERATOR:

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

                            throw new ExpressionRuntimeException(code, I18N.Number_of_argument_mistmatch_in_operator_XIdentifierX_expected_1_got_XargcX(function.name(),args==null?0:args.size()));

                        }

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

                        break;

                    case Caller.BINARY_OPERATOR:

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

                            throw new ExpressionRuntimeException(code, I18N.Number_of_argument_mistmatch_in_operator_XIdentifierX_expected_2_got_XargcX(function.name(),args==null?0:args.size()));

                        }

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

                        break;

                    case Caller.FUNCTION:

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

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

                            throw new ExpressionRuntimeException(code, I18N.Number_of_argument_mistmatch_in_function_XIdentifierX_expected_XexpectedX_got_XfoundX(function.name(),function.argc(),argc));

                        }

                        if( function.useArgumentsInsteadObjects() ) {

                            value = function.call(this, args);

                        } else {

                            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 (RuntimeException ex) {

                    throw ex;

                } catch (Exception ex) {

                    String argsstr = "???";

                    try {

                        argsstr = args.toString();

                    } catch(Exception ex2) {

                        // Ignore.

                    }

                    throw new ExpressionRuntimeException(code, I18N.Problems_calling_function_XIdentifierX_with_args_XargsX(function.name(),argsstr));

                }

                break;

            }

        } finally {

            this.currentCode = null;

            if( recursionControl!=null ) {

                recursionControl.exitCode();

            }

        }

        return value;

    }

    @Override

    public Code getCurrentCode() {

        return this.currentCode;

    }

}