Application: gvSIG desktop

    public void testVar() {

        SymbolTable symbolTable = createSymbolTable();

        Compiler compiler = createCompiler();

        Interpreter interpreter = createInterpreter(symbolTable);

        String source = "(VAR V1 DEFAULT 23)+2";

        Code code = compiler.compileExpression(source);

        Object v = interpreter.run(code);

        assertEquals(23, symbolTable.value("V1"));

        assertEquals((Integer)25, v);

    }

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.MutableSymbolTable;

    public void testVar() {

        String source = "VAR V1 DEFAULT 23";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("VAR(\"V1\", 23)", code.toString());

    }

    public static class VarArgsBuilder implements Statement.ArgsBuilder {

        protected final String varName;

        protected final String valueName;

        public VarArgsBuilder(String varName, String valueName) {

            this.varName = varName;

            this.valueName = valueName;

        }

        @Override

        public String toString() {

          return "var_args("+varName+","+valueName+")";

        }

        @Override

        public Codes build(StatementContext context) {

            context.trace(this.toString()+".build");

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            args.add(context.getCodeBuilder().identifier((String) ((Code.Constant)context.getCode(varName)).value()));

            args.add(context.getCode(valueName));

            return args;

        }

    }

                new VarArgsBuilder("NAME", "VALUE")

import org.gvsig.expressionevaluator.impl.function.programming.VarFunction;

                            if (((Code) o).code() == Code.CALLABLE) {

                                Code.Callable c = (Code.Callable) o;

                                if(StringUtils.equalsIgnoreCase(c.name(), VarFunction.NAME)){

                                    argNames.add(((Code.Identifier) c.parameters().get(0)).name());

                                }

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Codes;

    public static final String NAME="VAR";

                NAME, 

            NAME+" {{identifier}} = default_value",

//        String name = getStr(args,0);

//        if( name == null ) {

//            throw new NullPointerException("A string with a variable name was expected and a null was received");

//        }

//        Object value = null;

//        if( args.length==2 ) {

//            value = getObject(args, 1);

//        }

//        SymbolTable symbolTable = interpreter.getSymbolTable();

//        if( symbolTable instanceof MutableSymbolTable ) {

//            if( !symbolTable.exists(name)) {

//                ((MutableSymbolTable)symbolTable).setVar(name, value);

//            }

//        } else {

//            throw new RuntimeException("A MutableSymbolTable is required for use VAR function.");

//        }

        return null;

    }

    @Override

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

        Code varNameCode = args.get(0);

        if(varNameCode.code() != Code.IDENTIFIER){

            throw new RuntimeException("First argument must be a identifier.");

        String name = ((Code.Identifier)varNameCode).name();

        if(args.size() == 2){

            value = interpreter.run(args.get(1));

            if( symbolTable.exists(name)) {

                value = symbolTable.value(name);

            } else {

        return value;

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }