Application: gvSIG desktop

import java.lang.reflect.Method;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.script.ScriptManager;

                Range.between(2, 6),

        Code body = null;

        String script_path = null;

        String script_function = null;

        String language = null;

            case 6:

                name = (String) getObject(interpreter, args, 0);

                if( args.get(1)==null ) {

                    argNames = null;

                } else {

                    argNames = (List<String>) getObject(interpreter, args, 1);

                }

                body = args.get(2);

                script_path = Objects.toString(args.get(2),null);

                script_function = Objects.toString(args.get(3),null);

                language = Objects.toString(args.get(4),null);

                break;

        Function fn;

        if( body!=null ) {

            fn = new UserFunction(name, argNames, body);

            symbolTable.addFunction(fn);

            return fn;

        }

        if( StringUtils.isBlank(script_path) || StringUtils.isBlank(script_function) ) {

            throw new ExpressionRuntimeException("boydy and, script path or script function, are empty.");

        }

        if( StringUtils.isBlank(language) ) {

            language = "script";

        }

        switch(language.toLowerCase()) {

            case "script":

                fn = new ExternalFunction(name, script_path, script_function);

                symbolTable.addFunction(fn);

                return fn;

            case "java":

                fn = new JavaFunction(name, script_path, script_function);

                symbolTable.addFunction(fn);

                return fn;

        }

        throw new ExpressionRuntimeException("Unsupported language '"+language+".");

    private static class ExternalFunction extends AbstractFunction {

        private final String script_path;

        private final String script_function;

        public ExternalFunction(String name, String script_path, String script_function) {

            super(GROUP_OTHER, name, Range.between(0, Integer.MAX_VALUE));

            this.script_path = script_path;

            this.script_function = script_function;

        }

        @Override

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

            ScriptManager scriptManager = ToolsLocator.getScriptManager();

            ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

            ResourcesStorage resourcesStorage = expressionManager.getScriptsResourcesStorage();

            Script sc = scriptManager.loadScript(resourcesStorage, script_path);

            if( sc == null ) {

                throw new ExpressionRuntimeException("Can't locate '"+this.script_path+"'.");

            }

            Object r = sc.invokeFunction(this.script_function, args);

            return r;

        }

    }

    private static class JavaFunction extends AbstractFunction {

        private final String fullClassName;

        private final String methodName;

        public JavaFunction(String name, String fullClassName, String methodName) {

            super(GROUP_OTHER, name, Range.between(0, Integer.MAX_VALUE));

            this.fullClassName = fullClassName;

            this.methodName = methodName;

        }

        @Override

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

            Class[] parameterTypes = new Class[args.length];

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

                if( args[i]==null ) {

                    parameterTypes[i] = null;

                } else {

                    parameterTypes[i] = args[i].getClass();

                }

            }

            Class<?> theClass = Class.forName(this.fullClassName);

            Method method = theClass.getMethod(this.methodName, parameterTypes);

            Object value = method.invoke(null, args);

            return value;

        }

    }