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

    }

    @Override

    public SymbolTable getSymbolTable() {

        return this.symbolTable;

    }

    @Override

    public Interpreter getInterpreter() {

        if (this.interpreter == null) {

            this.interpreter = new DefaultInterpreter();

            this.interpreter.setSymbolTable(this.symbolTable);

        }

        return this.interpreter;

    }

    @Override

    public CodeBuilder getCodeBuilder() {

        if (this.codeBuilder == null) {

            this.codeBuilder = new DefaultCodeBuilder();

        }

        return this.codeBuilder;

    }

    @Override

    public Code optimize(Code code) {

        code = this.doOptimize(code);

        return code;

    }

    private Code doOptimize(Code code) {

        switch (code.code()) {

            case Code.CALLER:

                Caller caller = (Caller) code;

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

                    // resolve and link function

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

                }

                if (caller.function() instanceof FunctionOptimizer) {

                    return ((FunctionOptimizer) caller.function()).optimize(this, caller);

                } else {

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

                                if (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;

                        }

                    }

                }

//                break;

            case Code.CONSTANT:

            case Code.IDENTIFIER:

            case Code.METHOD:

            default:

                return code;

        }

    }

}