Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import org.gvsig.expressionevaluator.spi.BaseExpressionEvaluator;

import java.io.StringWriter;

import java.net.URI;

import java.util.ArrayList;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.GrammarFactory;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.SymbolTableFactory;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.ExpressionEvaluator;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GrammarSet;

import org.gvsig.expressionevaluator.ReprMethod;

import org.gvsig.expressionevaluator.impl.function.programming.$HostExpressionFunction;

import org.gvsig.expressionevaluator.impl.repr.ReprNull;

import org.gvsig.expressionevaluator.impl.repr.ReprObject;

import org.gvsig.expressionevaluator.spi.formatter.value.BaseFormatter;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultExpressionEvaluatorManager.class);

    private Double accuracy;

    private final Map<String,SymbolTableFactory>symbolTableFactories;

    private final Map<String,GrammarFactory> grammarFactories;

    private Bookmarks<Expression> bookmarks;

    private static final String BOOKMARKSANDHISTORY_NAME = "ExpressionManager";

    private History<Expression> history;

    private SymbolTable inmutableSymbolTable;

    private ResourcesStorage scriptsResourcesStorage;

    private final List<ClassLoader> loaders;

    private Formatter<ExpressionBuilder.Value> expressionBuilderFormatter;

    public DefaultExpressionEvaluatorManager() {

        this.symbolTableFactories = new HashMap<>();

        this.grammarFactories = new HashMap<>();

        this.loaders = new ArrayList<>();

        this.scriptsResourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

        this.loaders.add(this.getClass().getClassLoader());

        this.expressionBuilderFormatter = new BaseFormatter();

    }

    @Override

    public SymbolTable getSymbolTable(String name) {

        if( name == null ) {

            return null;

        }

        SymbolTableFactory factory = this.symbolTableFactories.get(name.toUpperCase());

        if( factory == null ) {

            return null;

        }

        return factory.create();

    }

    @Override

    public Collection<SymbolTableFactory> getSymbolTableFactories() {

        return this.symbolTableFactories.values();

    }

    @Override

    public final void registerSymbolTable(SymbolTableFactory factory) {

        if( factory == null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.symbolTableFactories.put(factory.getName().toUpperCase(),factory);

        this.inmutableSymbolTable = null;

    }

    @Override

    public SymbolTable getInmutableSymbolTable() {

        if( this.inmutableSymbolTable==null ) {

            this.inmutableSymbolTable = new InmutableSymbolTable();

        }

        return this.inmutableSymbolTable;

    }

    @Override

    public Object evaluate(String source) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        DefaultCompiler compiler = new DefaultCompiler(this);

        Code code = compiler.compileExpression(source);

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, String source) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        DefaultCompiler compiler = new DefaultCompiler(this);

        Code code = compiler.compileExpression(source);

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, Code code) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        return interpreter.run(code);

    }

    @Override

    public String evaluateDynamicText(String source) {

        return evaluateDynamicText(null, source);

    }

    @Override

    public boolean isDynamicText(String source) {

        String[] sources = StringUtils.substringsBetween(source, DYNAMICTEXT_STARTTAG, DYNAMICTEXT_ENDTAG);

        if( ArrayUtils.isEmpty(sources) ) {

            return false;

        }

        return true;

    }

    @Override

    public String evaluateDynamicText(SymbolTable symbolTable, String source) {

        String[] sources = StringUtils.substringsBetween(source, DYNAMICTEXT_STARTTAG, DYNAMICTEXT_ENDTAG);

        if( ArrayUtils.isEmpty(sources) ) {

            return source;

        }

        String[] values = new String[sources.length];

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        StringWriter writer = new StringWriter();

        interpreter.setWriter(writer);

        DefaultCompiler compiler = new DefaultCompiler(this);

        for (int i = 0; i < sources.length; i++) {

            String theSource = sources[i];

            if( StringUtils.startsWith(theSource, "=") ) {

                Code code = compiler.compileExpression(theSource.substring(1));

                Object value = interpreter.run(code);

                values[i] = Objects.toString(value, "");

            } else {

                Code code = compiler.compileExpression(theSource.substring(0));

                writer.getBuffer().setLength(0);

                interpreter.run(code);

                values[i] = writer.toString();

            }

            sources[i] = DYNAMICTEXT_STARTTAG+sources[i]+DYNAMICTEXT_ENDTAG;

        }

        String output = StringUtils.replaceEach(source, sources, values);

        return output;

    }

    @Override

    public Code compile(String source) {

        Compiler compiler = this.createCompiler();

        return compiler.compileExpression(source);

    }

    @Override

    public Code compile(LexicalAnalyzer lex, String source) {

        Compiler compiler = this.createCompiler();

        compiler.setLexicalAnalyzer(lex);

        return compiler.compileExpression(source);

    }

    @Override

    public Code optimize(SymbolTable symbolTable, Code code) {

        Optimizer optimizer = this.createOptimizer();

        return optimizer.optimize(symbolTable, code);

    }

    @Override

    public MutableSymbolTable createSymbolTable() {

        DefaultSymbolTable theSymbolTable = new DefaultSymbolTable();

        return theSymbolTable;

    }

    @Override

    public void populateSymbolTable(SymbolTable aSymbolTable) {

        for (SymbolTableFactory factory : this.getSymbolTableFactories() ) {

            try {

                if( factory.isAutoload() ) {

                    SymbolTable symbolTable = factory.create();

                    aSymbolTable.addSymbolTable(symbolTable);

                }

            } catch(Throwable th) {

                String factoryName = "Unknown";

                try {

                    factoryName = factory.getName();

                } catch(Throwable th2) {

                    // Do nothing

                }

                LOGGER.warn("Can't create symbol table '"+factoryName+"', ignore this symbol table.");

                LOGGER.debug("Error creating symbol table.",th);

            }

        }

    }

    @Override

    public LexicalAnalyzer createLexicalAnalyzer() {

        return new SQLLexicalAnalyzer();

    }

    @Override

    public CodeBuilder createCodeBuilder() {

        return new DefaultCodeBuilder(this);

    }

    @Override

    public Compiler createCompiler() {

        DefaultCompiler compiler = new DefaultCompiler(this);

        this.populateGrammars(compiler);

        return  compiler;

    }

    @Override

    public Interpreter createInterpreter() {

        Interpreter interpreter = new DefaultInterpreter();

        interpreter.setResourcesStorage(this.scriptsResourcesStorage);

        return interpreter;

    }

    @Override

    public Double getAccuracy() {

        return this.accuracy;

    }

    @Override

    public void setAccuracy(Double accuracy) {

        this.accuracy = accuracy;

    }

    @Override

    public Expression createExpression() {

        DefaultExpression e = new DefaultExpression(this);

        return e;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        ExpressionBuilder x = new DefaultExpressionBuilder(this);

        return x;

    }

    @Override

    public Optimizer createOptimizer() {

        Optimizer x = new DefaultOptimizer(this);

        return x;

    }

    @Override

    public void registerGrammar(GrammarFactory factory) {

        if( factory==null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.grammarFactories.put(factory.getName(), factory);

    }

    @Override

    public Collection<GrammarFactory> getGrammarFactories() {

        return this.grammarFactories.values();

    }

    public void populateGrammars(Compiler compiler) {

        GrammarSet grammarSet = compiler.getGrammars();

        for (GrammarFactory factory : this.getGrammarFactories() ) {

            if( factory.isAutoload() ) {

                Grammar grammar = factory.create();

                grammarSet.add(grammar);

            }

        }

    }

    @Override

    public Grammar createGrammar(String name) {

        DefaultGrammar grammar = new DefaultGrammar(name);

        return grammar;

    }

    @Override

    public Bookmarks<Expression> getBookmarks() {

        if( this.bookmarks==null ) {

             this.bookmarks = ToolsLocator.getBookmarksAndHistoryManager().getBookmarksGroup(BOOKMARKSANDHISTORY_NAME); 

        }

        return this.bookmarks;

    }

    @Override

    public History<Expression> getHistory() {

        if( this.history==null ) {

            this.history = ToolsLocator.getBookmarksAndHistoryManager().getHistoryGroup(BOOKMARKSANDHISTORY_NAME);

        }

        return this.history;

    }

    @Override

    public Script createScript(String name, String code, String languaje) {

        SimpleScript sc = new SimpleScript(this.createInterpreter(), name, code);

        return sc;

    }

    @Override

    public Script locateScript(String name) {

        return loadScript(this.scriptsResourcesStorage, name);

    }

    @Override

    public Script loadScript(final URI location) {

        ResourcesStorage.Resource res = null;

        try {

            if( location==null ) {

                return null;

            }

            String resourceName = FilenameUtils.getBaseName(location.getPath());

            res = ResourcesStorage.createResource(resourceName, location);

            if( res == null || !res.exists() ) {

                return null;

            }

            Script script = loadScript(res, resourceName);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from URI.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public Script loadScript(ResourcesStorage storage, String name) {

        ResourcesStorage.Resource res = null;

        try {

            if( storage==null ) {

                return null;

            }

            res = storage.getResource(name);

            if( res == null || !res.exists() ) {

                return null;

            }

            Script script = loadScript(res, name);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from resources storage.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    private static final Pattern RE_LANG = Pattern.compile(".*lang[:]\\s*([a-zA-Z_][a-zA-Z_0-9_]*).*");

    private static final Pattern RE_ENCODING = Pattern.compile(".*encoding[:]\\s*([a-zA-Z_][a-zA-Z0-9_-]*).*");

    private Script loadScript(ResourcesStorage.Resource res, String name) {

        try {

            if( res == null || !res.exists() ) {

                return null;

            }

            String head = EncodingUtils.getFirstLine(res.asInputStream());

            IOUtils.closeQuietly(res); // Eliminar con org.gvsig.tools > 3.0.230

            if( StringUtils.isEmpty(head) ) {

                return null;

            }

            String encoding = EncodingUtils.getEncoding(head);

            String lang = "cosa";

            Matcher m = RE_LANG.matcher(head);

            if( m!=null && m.matches() && m.groupCount()==1 ) {

                String s = m.group(1);

                if( !StringUtils.isBlank(s) ) {

                    lang = s;

                }

            }

            String source;

            if( StringUtils.isBlank(encoding) ) {

                source = IOUtils.toString(res.asInputStream());

            } else {

                source = IOUtils.toString(res.asInputStream(), encoding);

            }

            Script script = this.createScript(name, source, lang);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from resource.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public ResourcesStorage getScriptsResourcesStorage() {

        return this.scriptsResourcesStorage;

    }

    @Override

    public void setScriptsResourcesStorage(ResourcesStorage scriptsResourcesStorage) {

        if(this.scriptsResourcesStorage != null){

            DisposeUtils.disposeQuietly(this.scriptsResourcesStorage);

        }

        DisposeUtils.bind(scriptsResourcesStorage);

        this.scriptsResourcesStorage = scriptsResourcesStorage;

    }

    private final List<ReprMethod> reprMethods = new ArrayList<>();

    private final Map<Class,ReprMethod> reprMethodsCache = new HashMap<>();

    private final ReprMethod reprNull = new ReprNull();

    private final ReprMethod reprObject = new ReprObject();

    @Override

    public void addReprMethod(ReprMethod method) {

        this.reprMethods.add(method);

        this.reprMethodsCache.clear();

    }

    @Override

    public ReprMethod getReprMethod(Object value) {

        if( value == null ) {

            return this.reprNull;

        }

        ReprMethod method = this.reprMethodsCache.get(value.getClass());

        if( method!=null ) {

            return method;

        }

        for (ReprMethod theMethod : reprMethods) {

            if( theMethod.isApplicable(value) ) {

                this.reprMethodsCache.put(value.getClass(), theMethod);

                return theMethod;

            }

        }

        return this.reprObject;

    }

    @Override

    public void registerClassLoader(ClassLoader loader) {

      this.loaders.add(loader);

    }

    @Override

    public List<ClassLoader> getClassLoaders() {

      return Collections.unmodifiableList(loaders);

    }

    @Override

    public Formatter<ExpressionBuilder.Value> getExpressionBuilderFormatter() {

      return expressionBuilderFormatter;

    }

    @Override

    public void registerExpressionBuilderFormatter(Formatter<ExpressionBuilder.Value> formatter) {

      this.expressionBuilderFormatter = formatter;

    }

    @Override

    public ExpressionEvaluator createExpressionEvaluator(Expression expression) {

        return new BaseExpressionEvaluator(expression);

    }

    @Override

    public ExpressionEvaluator createEvaluator(String expression) {

        Expression exp = this.createExpression();

        exp.setPhrase(expression);

        return new BaseExpressionEvaluator(exp);

    }

    @Override

    public boolean hasHostExpressions(Code statement) {

        try {

            List<Code> hostExpressions = new ArrayList<>();

            statement.accept(

                    (Object code) -> {

                        if( !(code instanceof Code.Callable) ) {

                            return;

                        }

                        Code.Callable callable = (Code.Callable) code;

                        if( StringUtils.equalsIgnoreCase(callable.name(), ExpressionBuilder.FUNCTION_$HOSTEXPRESSION) ) {

                            hostExpressions.add(callable);

                        }

                    }, null

            );

            return !hostExpressions.isEmpty();

        } catch (BaseException ex) {

            throw new RuntimeException("Can't check host expressions", ex);

        }

    }

    @Override

    public boolean hasHostExpressions(ExpressionBuilder.Value statement) {

        List<ExpressionBuilder.Function> hostExpressions = new ArrayList<>();

        statement.accept((ExpressionBuilder.Visitable value) -> {

                if( !(value instanceof ExpressionBuilder.Function) ) {

                    return;

                }

                ExpressionBuilder.Function function = (ExpressionBuilder.Function) value;

                if( StringUtils.equalsIgnoreCase(function.name(), ExpressionBuilder.FUNCTION_$HOSTEXPRESSION) ) {

                    hostExpressions.add(function);

                }

        }, null);

        return !hostExpressions.isEmpty();

    }

    public boolean hasHostExpressions(String statement) {

        Compiler compiler = this.createCompiler();

        Code code = compiler.compileExpression(statement);

        return this.hasHostExpressions(code);

    }

    public List<Code> getHostExpressions(Code statement) throws Exception {

        List<Code> hostExpressions = new ArrayList<>();

        Code newstatement = (Code) statement.clone();

        newstatement.accept(

                (Object code) -> {

                    if( !(code instanceof Code.Callable) ) {

                        return;

                    }

                    Code.Callable callable = (Code.Callable) code;

                    if( StringUtils.equalsIgnoreCase(callable.name(), ExpressionBuilder.FUNCTION_$HOSTEXPRESSION) ) {

                        hostExpressions.add(callable);

                    }

                }, null 

        );

        return hostExpressions;

    }

    public List<ExpressionBuilder.Value> getHostExpressions(ExpressionBuilder.Value statement) throws Exception {

        List<ExpressionBuilder.Value> hostExpressions = new ArrayList<>();

        ExpressionBuilder.Value newstatement = (ExpressionBuilder.Value) statement.clone();

        newstatement.accept((ExpressionBuilder.Visitable value) -> {

                if( !(value instanceof ExpressionBuilder.Function) ) {

                    return;

                }

                ExpressionBuilder.Function function = (ExpressionBuilder.Function) value;

                if( StringUtils.equalsIgnoreCase(function.name(), ExpressionBuilder.FUNCTION_$HOSTEXPRESSION) ) {

                    hostExpressions.add(function);

                }

        }, null);

        return hostExpressions;

    }

    public ExpressionBuilder.Value getHostExpressionValue(ExpressionBuilder.Function hostExpression, ExpressionBuilder expbuilder) {

        return this.getHostExpressionValue(hostExpression, expbuilder, null, null);        

    }

    public ExpressionBuilder.Value getHostExpressionValue(ExpressionBuilder.Function hostExpression, ExpressionBuilder expbuilder, SymbolTable symbolTable) {

        Interpreter interpreter = this.createInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        return this.getHostExpressionValue(hostExpression, expbuilder, null, interpreter);        

    }

    public ExpressionBuilder.Value getHostExpressionValue(ExpressionBuilder.Function hostExpression, ExpressionBuilder expbuilder, Compiler compiler, Interpreter interpreter) {

        if( expbuilder == null ) {

            expbuilder = this.createExpressionBuilder();

        }

        if( compiler == null ) {

            compiler = this.createCompiler();

        }

        if( interpreter == null ) {

            interpreter = this.createInterpreter();

        }

        List<ExpressionBuilder.Value> params = hostExpression.parameters();

        String mode_specifier;

        ExpressionBuilder.Value exp;

        switch(params.size()) {

            case 1:

            default:

                exp = params.get(0);

                mode_specifier = $HostExpressionFunction.MODE_SPECIFIER_IN;

                break;

            case 2:

                exp = params.get(0);

                mode_specifier = Objects.toString(((ExpressionBuilder.Constant)params.get(1)).value(),"IN").toUpperCase();

                break;

        }

        Code code = compiler.compileExpression(exp.toString());

        Object v = interpreter.run(code);

        ExpressionBuilder.Value value;

        switch(mode_specifier) {

            case $HostExpressionFunction.MODE_SPECIFIER_IN:

            default:

                value = expbuilder.constant(v);

                break;

            case $HostExpressionFunction.MODE_SPECIFIER_OUT:

            case $HostExpressionFunction.MODE_SPECIFIER_INOUT:

                throw new UnsupportedOperationException("Mode OUT/INOUT not implemented");

            case $HostExpressionFunction.MODE_SPECIFIER_ID:

                value = expbuilder.variable(Objects.toString(v, null));

                break;

        }

        return value;

    }

    public List<ExpressionBuilder.Value> getHostExpressionsValuesFromValues(Interpreter interpreter, List<ExpressionBuilder.Value> hostExpressions) throws Exception {

        ExpressionBuilder expbuilder = this.createExpressionBuilder();

        Compiler compiler = this.createCompiler();

        List<ExpressionBuilder.Value> values = new ArrayList<>();        

        for (ExpressionBuilder.Value value : hostExpressions) {            

            ExpressionBuilder.Function hostExpression = (ExpressionBuilder.Function)value;

            values.add(this.getHostExpressionValue(hostExpression, expbuilder, compiler, interpreter));

        }

        return values;

    }

    public List<Code> getHostExpressionsValuesFromCodes(Interpreter interpreter, List<Code> hostExpressions) throws Exception {

        CodeBuilder codeBuilder = ((DefaultInterpreter)interpreter).getCodeBuilder();

        List<Code> values = new ArrayList<>();

        for (Code code : hostExpressions) {

            Code.Callable hostExpression = (Code.Callable)code;

            Codes params = hostExpression.parameters();

            String mode_specifier;

            Code exp;

            switch(params.size()) {

                case 1:

                default:

                    exp = params.get(0);

                    mode_specifier = $HostExpressionFunction.MODE_SPECIFIER_IN;

                    break;

                case 2:

                    exp = params.get(0);

                    mode_specifier = Objects.toString(((Code.Constant)params.get(1)).value(),"IN").toUpperCase();

                    break;

            }

            Object v = interpreter.run(exp);

            Code replacement;

            switch(mode_specifier) {

                case $HostExpressionFunction.MODE_SPECIFIER_IN:

                default:

                    replacement = codeBuilder.constant(v);

                    break;

                case $HostExpressionFunction.MODE_SPECIFIER_OUT:

                case $HostExpressionFunction.MODE_SPECIFIER_INOUT:

                    throw new UnsupportedOperationException("Mode OUT/INOUT not implemented");

                case $HostExpressionFunction.MODE_SPECIFIER_ID:

                    replacement = codeBuilder.identifier(Objects.toString(v, null));

                    break;

            }

            values.add(replacement);

        }

        return values;

    }

    @Override

    public Code resolveHostExpressions(Code statement, Interpreter interpreter) {

        try {

            if( !hasHostExpressions(statement) ) {

                return statement;

            }

            Code newstatement = (Code) statement.clone();

            List<Code> hostExpressions = getHostExpressions(newstatement);

            if (hostExpressions.isEmpty()) {

                return statement;

            }

            List<Code> replacements = getHostExpressionsValuesFromCodes(interpreter, hostExpressions);

            for (int i = 0; i < hostExpressions.size(); i++) {

                Code hostExpression = hostExpressions.get(i);

                Code value = replacements.get(i);

                newstatement.replace(hostExpression, value);

            }

            return newstatement;

        } catch (Exception ex) {

            throw new RuntimeException("Can't resolve host expressions", ex);

        }

    }

    @Override

    public ExpressionBuilder.Value resolveHostExpressions(ExpressionBuilder.Value statement, SymbolTable symbolTable) {

        try {

            if( !hasHostExpressions(statement) ) {

                return statement;

            }

            ExpressionBuilder.Value newstatement = (ExpressionBuilder.Value) statement.clone();

            List<ExpressionBuilder.Value> hostExpressions = getHostExpressions(newstatement);

            if (hostExpressions.isEmpty()) {

                return statement;

            }

            Interpreter interpreter = this.createInterpreter();

            if( symbolTable!=null ) {

                interpreter.setSymbolTable(symbolTable);

            }

            List<ExpressionBuilder.Value> replacements = this.getHostExpressionsValuesFromValues(interpreter, hostExpressions);

            for (int i = 0; i < hostExpressions.size(); i++) {

                ExpressionBuilder.Value hostExpression = hostExpressions.get(i);

                ExpressionBuilder.Value value = replacements.get(i);

                newstatement.replace(hostExpression, value);

            }

            return newstatement;

        } catch (Exception ex) {

            throw new RuntimeException("Can't resolve host expressions", ex);

        }

    }

    @Override

    public Code resolveHostExpressions(Code statement, SymbolTable symbolTable) {

        try {

            if( !hasHostExpressions(statement) ) {

                return statement;

            }

            Code newstatement = (Code) statement.clone();

            List<Code> hostExpressions = getHostExpressions(newstatement);

            if (hostExpressions.isEmpty()) {

                return statement;

            }

            Interpreter interpreter = this.createInterpreter();

            if( symbolTable!=null ) {

                interpreter.setSymbolTable(symbolTable);

            }

            List<Code> replacements = this.getHostExpressionsValuesFromCodes(interpreter, hostExpressions);

            for (int i = 0; i < hostExpressions.size(); i++) {

                Code hostExpression = hostExpressions.get(i);

                Code value = replacements.get(i);

                newstatement.replace(hostExpression, value);

            }

            return newstatement;

        } catch (Exception ex) {

            throw new RuntimeException("Can't resolve host expressions", ex);

        }

    }

    @Override

    public Expression resolveHostExpressions(Expression expression, SymbolTable symbolTable) {

            Code newcode = this.resolveHostExpressions(expression.getCode(), symbolTable);

            if( newcode == expression.getCode() ) {

                // No hay "hosts expressions", devolvemos la expresion original.

                return expression;

            }

            DefaultExpression exp = new DefaultExpression(this);

            exp.setPhrase(newcode.toValue().toString());

            return exp;

    }

}