Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import org.gvsig.expressionevaluator.Optimizer;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.SymbolTable;

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

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

import org.gvsig.tools.script.Script;

/**

 *

 * @author jjdelcerro

 */

public class DefaultOptimizer implements Optimizer {

    private static class OptimizerSymbolTable implements SymbolTable {

        private SymbolTable symbolTable;

        public OptimizerSymbolTable() {

        }

        public SymbolTable getSymbolTable() {

            return this.symbolTable;

        }

        public void setSymbolTable(SymbolTable symbolTable) {

            this.symbolTable = symbolTable;

        }

        @Override

        public String getName() {

            return "Optimizer";

        }

        @Override

        public void addSymbolTable(SymbolTable symbolTable) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Function function(String name) {

            return this.symbolTable.function(name);

        }

        @Override

        public boolean exists(String name) {

            return false;

        }

        @Override

        public Object value(String name) {

            return null;

        }

        @Override

        public Collection<String> variables() {

            return Collections.EMPTY_LIST;

        }

        @Override

        public Collection<Function> functions() {

            return this.symbolTable.functions();

        }

        @Override

        public Collection<Script> scripts() {

            return this.symbolTable.scripts();

        }

        @Override

        @SuppressWarnings("CloneDoesntCallSuperClone")

        public SymbolTable clone() throws CloneNotSupportedException {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Iterator<Function> iterator() {

            return this.symbolTable.iterator();

        }

    }

    private final OptimizerSymbolTable symbolTable;

    private Interpreter interpreter;

    private CodeBuilder codeBuilder;

    public DefaultOptimizer() {

        this.symbolTable = new OptimizerSymbolTable();

    }

    public DefaultOptimizer(SymbolTable symbolTable) {

        this();

        this.symbolTable.setSymbolTable(symbolTable);

    }

    @Override

    public void setSymbolTable(SymbolTable symbolTable) {

        this.symbolTable.setSymbolTable(symbolTable);

    }

    private Interpreter getInterpreter() {

        if( this.interpreter == null ) {

            this.interpreter = new DefaultInterpreter();

            this.interpreter.setSymbolTable(this.symbolTable);

        }

        return this.interpreter;

    }

    private CodeBuilder getCodeBuilder() {

        if( this.codeBuilder == null ) {

            this.codeBuilder = new DefaultCodeBuilder();

        }

        return this.codeBuilder;

    }

    @Override

    public Code optimize(Code code) {

        this.getInterpreter().link(code);

        code = this.doOptimize(code);

        return code;

    }

    private Code doOptimize(Code code) {

        switch (code.code()) {

            case Code.CALLER:

                Caller caller = (Caller) code;

                switch (caller.type()) {

                    case Caller.BINARY_OPERATOR: {

                        Code op1 = this.doOptimize(caller.args().get(0));

                        Code op2 = this.doOptimize(caller.args().get(1));

                        if ( caller.function().allowConstantFolding() && 

                                op1.code() == Code.CONSTANT && 

                                op2.code() == Code.CONSTANT) {

                            Object value = this.getInterpreter().run(code);

                            Code newCode = this.getCodeBuilder().constant(value);

                            return newCode;

                        }

                        Code newCode = this.getCodeBuilder().operator(caller.name(), op1, op2);

                        return newCode;

                    }

                    case Code.Caller.UNARY_OPERATOR: {

                        Code op1 = this.doOptimize(caller.args().get(0));

                        if ( caller.function().allowConstantFolding() && 

                                op1.code() == Code.CONSTANT ) {

                            Object value = this.getInterpreter().run(code);

                            Code newCode = this.getCodeBuilder().constant(value);

                            return newCode;

                        }

                        return code;

                    }

                    case Code.Caller.FUNCTION:

                    default: {

                        BaseArguments newArgs = null;

                        boolean canOptimize = true;

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

                            newArgs = (BaseArguments) this.getCodeBuilder().args();

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

                                Code newArg = this.doOptimize(arg);

                                newArgs.add(newArg);

                                if( newArg.code() != Code.CONSTANT ) {

                                    canOptimize = false;

                                }

                            }

                        }

                        if( canOptimize && caller.function().allowConstantFolding() ) {

                            Object value = this.getInterpreter().run(code);

                            Code newCode = this.getCodeBuilder().constant(value);

                            return newCode;

                        }

                        Code newCode = this.getCodeBuilder().function(

                                caller.name(),

                                caller.type(),

                                newArgs

                        );

                        return newCode;

                    }

                }

            case Code.CONSTANT:

            case Code.IDENTIFIER:

            case Code.METHOD:

            default:

                return code;

        }

    }

}