Application: gvSIG desktop

import org.gvsig.expressionevaluator.impl.javascripting.CosaScriptEngineFactory;

            sc = manager.createScript("test1", source, CosaScriptEngineFactory.LANGUAGE_NAME);

        } catch (Exception ex) {

            sc = manager.createScript("test2", source, CosaScriptEngineFactory.LANGUAGE_NAME);

        } catch (Exception ex) {

    }

    public void testScript3() throws Exception {

        InputStream is = this.getClass().getResource("/org/gvsig/expressionevaluator/impl/TestScript1_2.txt").openStream();

        String source = StringUtils.join(IOUtils.readLines(is), "\n");

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Object r;

        Script sc;

        try {

            sc = manager.createScript("test3", source, CosaScriptEngineFactory.LANGUAGE_NAME);

        } catch (Exception ex) {

            System.err.println(ex.getMessage());

            throw ex;

        r = sc.invokeFunction("test3", null);

        assertEquals("Hola amigos", r);

        r = sc.invokeFunction("saluda", new Object[] { "pato" });

        assertEquals("Hola pato", r);

    }

package org.gvsig.expresionevaluator.impl;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineFactory;

import javax.script.ScriptEngineManager;

import junit.framework.TestCase;

import org.gvsig.expressionevaluator.impl.javascripting.CosaScriptEngineFactory;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

/**

 *

 * @author jjdelcerro

 */

public class TestScriptEngine extends TestCase {

    public TestScriptEngine(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    public void test1() {

        ScriptEngineManager engineManager = new ScriptEngineManager();

        ScriptEngine engine = engineManager.getEngineByName(CosaScriptEngineFactory.ENGINE_NAME);

        assertNotNull("Can't locate '"+CosaScriptEngineFactory.ENGINE_NAME+" engine,", engine);

        assertEquals(CosaScriptEngineFactory.ENGINE_NAME, engine.getFactory().getEngineName());

    }

}

    END 

    END FOR;

CREATE FUNCTION saluda AS

    IF LEN($ARGS) > 0 THEN

        SET s TO 'Hola ' || $ARGS[0];

    ELSE

        SET s = 'Hola.';

    END;

    PRINT(s);

    RETURN s;

END

CREATE FUNCTION test3 AS

    RETURN saluda('amigos');

END

-- encoding: utf-8; language: cosa

CREATE FUNCTION main AS

    PRINT('Hello world!');

END

org.gvsig.expressionevaluator.impl.javascripting.CosaScriptEngineFactory

import org.apache.commons.lang3.ObjectUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

import org.gvsig.tools.script.Script;

            if( theInstance instanceof SimpleScript ) {

                try {

                    return ((SimpleScript)theInstance).invokeFunction(methodname, args);

                } catch(NoSuchMethodException ex) {

                    // Ignore... continue calling instance method

                }                

            } else if( theInstance instanceof DynObject ) {

                DynObject dynobj = (DynObject) theInstance;

                try {

                    return dynobj.invokeDynMethod(methodname, args);

                } catch(DynMethodNotSupportedException ex) {

                    // Ignore... continue calling instance method

                }

            }

    public Grammar create(Object... parameters) {

import org.gvsig.expressionevaluator.impl.symboltable.FoldersSymbolTableFactory;

        manager.registerSymbolTable(new FoldersSymbolTableFactory());

    public SymbolTable create(Object... args) {

package org.gvsig.expressionevaluator.impl.symboltable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTableFactory;

/**

 *

 * @author jjdelcerro

 */

public class FoldersSymbolTableFactory extends AbstractSymbolTableFactory {

    private SymbolTable symbolTable;

    public FoldersSymbolTableFactory() {

        super(FoldersSymbolTable.NAME, true);

    }

    @Override

    public SymbolTable create(Object... args) {

        if( this.symbolTable==null ) {

            this.symbolTable = new FoldersSymbolTable();

        }

        return this.symbolTable;

    }

}

    public SymbolTable create(Object... args) {

    public SymbolTable create(Object... args) {

    public SymbolTable create(Object... args) {

    public SymbolTable create(Object... args) {

package org.gvsig.expressionevaluator.impl.symboltable;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.GetFolderFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.HomeFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.LastPathFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.SetFolderFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.SetLastPathFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.SetTemporaryFolderFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.TemporaryFileFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.TemporaryFolderFunction;

import org.gvsig.expressionevaluator.impl.function.foldersmanager.UniqueTemporaryFileFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

/**

 *

 * @author jjdelcerro

 */

public class FoldersSymbolTable extends AbstractSymbolTable {

    static final String NAME = "Folders";

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public FoldersSymbolTable() {

        super(NAME);

        this.addFunction(new GetFolderFunction());

        this.addFunction(new HomeFunction());

        this.addFunction(new LastPathFunction());

        this.addFunction(new SetFolderFunction());

        this.addFunction(new SetLastPathFunction());

        this.addFunction(new SetTemporaryFolderFunction());

        this.addFunction(new TemporaryFileFunction());

        this.addFunction(new TemporaryFolderFunction());

        this.addFunction(new UniqueTemporaryFileFunction());

    }

    private void addOperator(Function operator) {

        this.addFunction(operator);

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class SetFolderFunction extends AbstractFunction {

    public static final String NAME = "SETFOLDER";

    public SetFolderFunction() {

        super(

            "Folders", 

            NAME, 

            Range.is(2),

            "Set the folder associated to the id. Return the new value set to the folder.", 

            NAME+"({{folderid}}, value)", 

            new String[] {

                "folderid - Identifier of the folder to set",

                "value - value set to the folder."

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String id = getStr(args, 0);

        File value = getFile(args,1);

        folderManager.set(id, value);

        return value;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class HomeFunction extends AbstractFunction {

    public static final String NAME = "HOME";

    public HomeFunction() {

        super(

            "Folders", 

            NAME, 

            Range.is(0),

            "Return the folder user home", 

            NAME+"()", 

            null,

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        File f = folderManager.getHome();

        return f;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class UniqueTemporaryFileFunction extends AbstractFunction {

    public static final String NAME = "UNIQUETEMPORARYFILE";

    public UniqueTemporaryFileFunction() {

        super(

            "Folders", 

            NAME, 

            Range.between(1,1000),

            "Return a unique file with the specified relative path to the temporary folder.\n" +

            "The base name of the file is modified to be unique.\n" +

            "The file will be deleted when the application exits.\n" +

            "  "+NAME+"('folder','name.txt')\n",

            "For this call, the return value will have the form:\n" +

            "   <PATH>/folder/name-<HEX1>-<HEX2>.txt" +

            NAME+"({{pathComponents...}})", 

            new String[] {

                "pathComponents - relative pathname"

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String[] pathComponents = new String[args.length];

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

            pathComponents[i] = getStr(args,i);

        }

        File f = folderManager.getUniqueTemporaryFile(pathComponents);

        return f;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class SetTemporaryFolderFunction extends AbstractFunction {

    public static final String NAME = "SETTEMPORARYFOLDER";

    public SetTemporaryFolderFunction() {

        super(

            "Folders", 

            NAME, 

            Range.is(1),

            "Assign the folder to use as a temporary folder for the application. Be careful, it can affect other parts of it. Return the new value set.", 

            NAME+"({{folder}})", 

            new String[] {

                "folder - Folder to set as temporary folder"

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        File value = getFile(args,0);

        folderManager.setTemporaryFolder(value);

        return value;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class GetFolderFunction extends AbstractFunction {

    public static final String NAME = "GETFOLDER";

    public GetFolderFunction() {

        super(

            "Folders", 

            NAME, 

            Range.between(1,2),

            "Get a folder by id", 

            NAME+"({{folderid}}, defaultValue)", 

            new String[] {

                "folderid - Identifier of the folder to retrieve",

                "defaultValue - Optional. value to get if the folder with id 'folderid' is not defined."

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String id = getStr(args, 0);

        File defaultValue = null;

        if( args.length==2 ) {

            defaultValue = getFile(args,1);

        }

        File f = folderManager.get(id, defaultValue);

        return f;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class SetLastPathFunction extends AbstractFunction {

    public static final String NAME = "SETLASTPATH";

    public SetLastPathFunction() {

        super(

            "Folders", 

            NAME, 

            Range.is(2),

            "Assigns the last value used to the indicated folder. Return the new value set to the folder.", 

            NAME+"({{folderid}}, value)", 

            new String[] {

                "folderid - Identifier of the folder to set",

                "value - Value to be assigned as the last used folder associated with the indicated identifier.."

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String id = getStr(args, 0);

        File value = getFile(args,1);

        folderManager.setLastPath(id, value);

        return value;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class TemporaryFolderFunction extends AbstractFunction {

    public static final String NAME = "TEMPORARYFOLDER";

    public TemporaryFolderFunction() {

        super(

            "Folders", 

            NAME, 

            Range.is(0),

            "Return the file associated to the temporary folder of the application.\n" +

            "The file can't exits.", 

            NAME+"()", 

            null, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        File f = folderManager.getTemporaryFolder();

        return f;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class LastPathFunction extends AbstractFunction {

    public static final String NAME = "LASTPATH";

    public LastPathFunction() {

        super(

            "Folders", 

            NAME, 

            Range.between(1,2),

            "Retrieve the last value used to the indicated folder.", 

            NAME+"({{folderid}}, defaultValue)", 

            new String[] {

                "folderid - Identifier of the folder to retrieve",

                "defaultValue - Optional. value to get if the folder with id 'folderid' is not defined."

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String id = getStr(args, 0);

        File defaultValue = getFile(args,1);

        File f = folderManager.getLastPath(id, defaultValue);

        return f;

    }

}

package org.gvsig.expressionevaluator.impl.function.foldersmanager;

import java.io.File;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

public class TemporaryFileFunction extends AbstractFunction {

    public static final String NAME = "TEMPORARYFILE";

    public TemporaryFileFunction() {

        super(

            "Folders", 

            NAME, 

            Range.between(1, 1000),

            "Return a file with the specified relative path to the temporary folder.\n" +

            "The file will be deleted when the application exits.\n" +

            "  "+NAME+"('folder','name.txt')", 

            NAME+"({{pathComponents...}})", 

            new String[] {

                "pathComponents - relative pathname"

            }, 

            "File", 

            false

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) {

        FoldersManager folderManager = ToolsLocator.getFoldersManager();

        String[] pathComponents = new String[args.length];

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

            pathComponents[i] = getStr(args,i);

        }

        File f = folderManager.getTemporaryFile(pathComponents);

        return f;

    }

}

import java.io.Writer;

        Writer writer = interpreter.getWriter();

            writer.append(Objects.toString(arg, ""));

        writer.append("\n");

        writer.flush();

import java.util.ArrayList;

import java.util.Arrays;

            List $args = new ArrayList();

            if( args != null ) {

                $args.addAll(Arrays.asList(args));

            }

            localSymbolTable.setVar("$ARGS", $args);

import java.io.OutputStreamWriter;

import java.io.Writer;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

    private Writer writer ;

    private ResourcesStorage resourcesStorage;

        this.writer = new OutputStreamWriter(System.out);

        this.resourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

    @Override

    public ResourcesStorage getResourcesStorage() {

        return resourcesStorage;

    }

    @Override

    public void setResourcesStorage(ResourcesStorage resourcesStorage) {

        if( resourcesStorage==null ) {

            this.resourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

        } else {

            this.resourcesStorage = resourcesStorage;

        }

    }

    public Writer getWriter() {

        return this.writer;

    }

    @Override

    public void setWriter(Writer writer) {

        if( writer == null ) {

            writer = new OutputStreamWriter(System.out);

        }

        this.writer = writer;

    }

    @Override

    public Object call(SymbolTable symbolTable, String funcname, Object... args) throws Exception {

        SymbolTable savedSymbolTable = this.symbolTable;

        try {

            symbolTable.addSymbolTable(this.symbolTable);

            this.symbolTable = symbolTable;

            return this.call(funcname, args);

        } finally {

            this.symbolTable = savedSymbolTable;

            symbolTable.removeSymbolTable(this.symbolTable);

        }

    }

    @Override

        Function fn = this.getSymbolTable().function(function);

    public void run(MutableSymbolTable symbolTable, Code code) {

        SymbolTable savedSymbolTable = this.symbolTable;

        try {

            symbolTable.addSymbolTable(this.symbolTable);

            this.symbolTable = symbolTable;

            this.run(code);

        } finally {

            this.symbolTable = savedSymbolTable;

            symbolTable.removeSymbolTable(this.symbolTable);

        }

    }

    @Override

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.MutableSymbolTable;

    private Interpreter interpreter;

    private final MutableSymbolTable symbolTable;

    public SimpleScript(Interpreter interpreter, String name, String source) {

        this.interpreter = interpreter;

        this.symbolTable = ExpressionEvaluatorLocator.getManager().createSymbolTable();

        this.setCode(source);        

    public MutableSymbolTable getSymbolTable() {

        return this.symbolTable;

    }

        this.symbolTable.setVar(name, value);

        if( this.symbolTable.function(funcname)==null ) {

            if( !this.interpreter.hasFunction(funcname) ) {

                throw new NoSuchMethodException(funcname);

            }

            return this.interpreter.call(this.symbolTable, funcname, args);

        this.interpreter.run(this.symbolTable, code);

            Collection<Function> funcs = this.symbolTable.localfunctions();

import java.io.StringWriter;

import java.util.Objects;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.impl.javascripting.CosaScriptEngineFactory;

        return factory.create();

    public String evaluatePage(String source) {

        return evaluatePage(null, source);

    }

    @Override

    public String evaluatePage(SymbolTable symbolTable, String source) {

        String[] sources = StringUtils.substringsBetween(source, "<%", "%>");

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

        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(1));

                writer.getBuffer().setLength(0);

                interpreter.run(code);

                values[i] = writer.toString();

            }

        }

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

        return output;

    }

    @Override

                SymbolTable symbolTable = factory.create();

                Grammar grammar = factory.create();

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

        return this.createScript(name, code, CosaScriptEngineFactory.LANGUAGE_NAME);

package org.gvsig.expressionevaluator.impl.javascripting;

import java.util.Collection;

import javax.script.Bindings;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.impl.DefaultSymbolTable;

/**

 *

 * @author jjdelcerro

 */

public class BindingsToSymbolTableAdapter 

        extends DefaultSymbolTable

        implements MutableSymbolTable 

    {

    private final Bindings bindings;

    public BindingsToSymbolTableAdapter(Bindings bindings) {

        this.bindings = bindings;

    }

    @Override

    public void setVar(String name, Object value) {

        this.bindings.put(name, value);

    }

    @Override

    public void removeVar(String name) {

        this.bindings.remove(name);

    }

    @Override

    @SuppressWarnings("CloneDoesntCallSuperClone")

    public MutableSymbolTable clone() throws CloneNotSupportedException {

        throw new CloneNotSupportedException();

    }

    @Override

    public String getName() {

        return "Anonimous";

    }

    @Override

    public boolean exists(String name) {

        return this.bindings.containsKey(name);

    }

    @Override

    public Object value(String name) {

        return this.bindings.get(name);

    }

    @Override

    public Collection<String> variables() {

        return this.bindings.keySet();

    }

    @Override

    public Collection<String> localvariables() {

        return this.bindings.keySet();

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.expressionevaluator.impl.javascripting;

import java.util.Collection;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import javax.script.Bindings;

import org.gvsig.expressionevaluator.MutableSymbolTable;

/**

 *

 * @author jjdelcerro

 */

public class SymbolTableToBindingsAdapter implements Bindings

{

    private MutableSymbolTable symbolTable;

    public SymbolTableToBindingsAdapter(MutableSymbolTable symbolTable) {

        this.symbolTable = symbolTable;

    }

    public MutableSymbolTable getSymbolTable() {

        return symbolTable;

    }

    @Override

    public Object put(String name, Object value) {

        Object previous = this.symbolTable.value(name);

        this.symbolTable.setVar(name, value);

        return previous;

    }

    @Override

    public void putAll(Map<? extends String, ? extends Object> toMerge) {

        for (Entry<? extends String, ? extends Object> entry : toMerge.entrySet()) {

            String key = entry.getKey();

            Object value = entry.getValue();

            this.symbolTable.setVar(key, value);

        }

    }

    @Override

    public boolean containsKey(Object key) {

        return this.symbolTable.exists(key.toString());

    }

    @Override

    public Object get(Object key) {

        return this.symbolTable.value(key.toString());

    }

    @Override

    public Object remove(Object key) {

        Object previous = this.symbolTable.value(key.toString());

        this.symbolTable.removeVar(key.toString());

       return previous;

    }

    @Override

    public int size() {

        return this.symbolTable.variables().size();

    }

    @Override

    public boolean isEmpty() {

        return this.symbolTable.variables().isEmpty();

    }

    @Override

    public boolean containsValue(Object value) {

        return false; // FIXME

    }

    @Override

    public void clear() {

        // FIXME

    }

    @Override

    public Set<String> keySet() {

        Collection<String> vars = this.symbolTable.variables();

        return new HashSet<>(vars);

    }

    @Override

    public Collection<Object> values() {

        return null; // FIXME

    }

    @Override

    public Set<Entry<String, Object>> entrySet() {

        return null; // FIXME

    }

}

package org.gvsig.expressionevaluator.impl.javascripting;

import java.io.IOException;

import java.io.Reader;

import java.io.Writer;

import java.util.List;

import javax.script.AbstractScriptEngine;

import javax.script.Bindings;

import javax.script.Compilable;

import javax.script.CompiledScript;

import javax.script.Invocable;

import javax.script.ScriptContext;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineFactory;

import javax.script.ScriptException;

import javax.script.SimpleScriptContext;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.MutableSymbolTable;

/**

 *

 * @author jjdelcerro

 */

public class CosaScriptEngine 

        extends AbstractScriptEngine

        implements ScriptEngine, Compilable, Invocable

    {

    private class MyContextScript extends SimpleScriptContext {

        public MyContextScript() {

            engineScope = new SymbolTableToBindingsAdapter(symbolTable);

        }

        @Override

        public void setWriter(Writer writer) {

            super.setWriter(writer);

            interpreter.setWriter(writer);

        }

        @Override

        public void setErrorWriter(Writer writer) {

            super.setErrorWriter(writer); 

        }

    }

    private final ScriptEngineFactory factory;

    private final MutableSymbolTable symbolTable;

    private final Interpreter interpreter;

    private final ExpressionEvaluatorManager manager;

    public CosaScriptEngine(ScriptEngineFactory factory) {

        this.factory = factory;

        this.manager = ExpressionEvaluatorLocator.getManager();

        this.symbolTable = manager.createSymbolTable();

        this.interpreter = manager.createInterpreter();

        this.interpreter.setSymbolTable(this.symbolTable);

        this.context = new MyContextScript();        

    }

    @Override

    public ScriptEngineFactory getFactory() {

       return this.factory;

    }

    @Override

    public Object eval(String source, ScriptContext context) throws ScriptException {

        CompiledScript script = this.compile(source); 

        Object x = script.eval(context);

        return x;

    }

    @Override

    public Object eval(Reader source, ScriptContext context) throws ScriptException {

        CompiledScript script = this.compile(source); 

        Object x = script.eval(context);

        return x;

    }