Application: gvSIG desktop

package org.gvsig.expressionevaluator;

import org.gvsig.tools.util.UnmodifiableBasicList;

import org.gvsig.tools.visitor.Visitable;

 *

 * @author jjdelcerro

 */

}

        public boolean isReservedWord(String s);

    }

    public interface Rule {

        public ConditionalRule addRuleOnFalse(Rule rule);

    }

    public interface ArgsBuilder {

    public CompoundRule repeat_until_any_tokens(String... token);

    public Rule require_identifier(String id);

    public Rule require_literal_string(String id);

    public Rule require_expressions(String id, String separator);

    public ConditionalRule optional_any_token(String... id);

    public ConditionalRule optional_identifiers(String id, String separator);

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return false;

    }

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

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

        return value;

    }

    protected Date getDate(Object[] args, int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException(I18N.Required_argument_XargnX_and_only_found_XargcX_in_call_to_XIdentifierX(name(), args.length, n));

    abstract protected Token getToken();

        this.states.push(position);

    }

        position = this.states.pop();

    }

    public boolean getUseBracketsForIdentifiers() {

        return this.useBracketsForIdentifiers;

    }

}

    public boolean isOperator();

    public boolean useArgumentsInsteadObjects();

    public boolean isSQLCompatible();

     * @return true if this function allow constant folding optimization.

     */

    public boolean allowConstantFolding();

}

    public void setUseBracketsForIdentifiers(boolean useBracketsForIdentifiers);

    public boolean getUseBracketsForIdentifiers();

}

    @Override

    public Statement getApplicableStatement(StatementContext context) {

        for (Statement statement : statements) {

            if( statement.isApplicable(context) ) {

                return statement;

            }

        }

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

                "List",

                false

        );

    }

    @Override

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    }

    @Override

    public boolean allowConstantFolding() {

        return false;

    }

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

    public boolean allowConstantFolding() {

        return false;

    }

    @Override

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

    @Override

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

        if( !(interpreter.getSymbolTable() instanceof MutableSymbolTable) ) {

            throw new ExpressionRuntimeException("The use of user functions require a mutable symbol table.");

        }

        MutableSymbolTable symbolTable = (MutableSymbolTable) interpreter.getSymbolTable();

        Function fn;

        if( body!=null ) {

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

            this.argNames = argNames;

            this.body = body;

        }

        @Override

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

            Object value;

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

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

import org.apache.commons.lang3.Range;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_TUPLE;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

public class TupleFunction extends AbstractFunction {

                "TUPLE",

                false

        );

    }

    @Override

    }

    @Override

    public boolean useArgumentsInsteadObjects() {

        return true;

    }

import java.util.Objects;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Statement.StatementContext;

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

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;

/**

 *

//    private String codeId;

//    private ArgsBuilder argsBuilder;

    public interface RepeatRule extends CompoundRule {

        public String getClassifier();

    }

        private final String[] required_token;

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (!token.is(this.required_token)) {

                throw new ExpressionSyntaxException(

            context.next_token();

        }

        }

        @Override

    }

        private final String id;

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() != Token.IDENTIFIER) {

                throw new ExpressionSyntaxException(

        }

        @Override

        public String toString() {

            return "require_identifier('" + this.id + "')";

        }

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() != Token.STRING_LITERAL) {

                throw new ExpressionSyntaxException(

        @Override

        public void parse(StatementContext context) {

            Code code = context.parse_expression();

            if (code == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

        @Override

        public void parse(StatementContext context) {

            if( this.value instanceof Code ) {

                context.setCode(id, (Code) this.value);

            } else {

        @Override

        public void parse(StatementContext context) {

            Codes codes = context.parse_expressions(this.separator);

            if (codes == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.is(this.optional_token)) {

                context.next_token();

        @Override

        public String toString() {

        }

    }

    public class RuleRepeatUntilAnyTokens implements RepeatRule {

        private final String[] exit_tokens;

        @Override

        public void parse(StatementContext context) {

            String save = context.getCodeClassifier();

            try {

                this.counter = 1;

        }

    }

    public class RuleOptionalIdentifiers extends AbstractConditionalRule implements ConditionalRule {

        private final String id;

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

            while (token.getType() == Token.IDENTIFIER) {

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() == Token.STRING_LITERAL) {

                String s = (String) token.getValue();

    public static class ArgsBuilderFromNames implements ArgsBuilder {

        public ArgsBuilderFromNames(String... argNames) {

            this.argNames = argNames;

        }

        @Override

        public Codes build(StatementContext context) {

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

            for (String argName : argNames) {

                if (argName.contains("#")) {

                        if (code == null) {

                            break;

                        }

                        n++;

                    }

                } else {

//                    if( code == null) {

//                        code = context.getCodeBuilder().constant(null);

//                    }

                }

            }

            return args;

        }

        @Override

        public Codes build(StatementContext context) {

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

        if (this.rules.isEmpty()) {

            return false;

        }

        }

    }

    @Override

        this.builder(new StatementBuilderBase(id, argsBuilder));

    }

    public void builder(StatementBuilder builder) {

        this.stmtBuilder = builder;

    }

    @Override

    public Code parse(StatementContext context) {

        for (Rule rule : rules) {

            rule.parse(context);

        }

        Code code = this.stmtBuilder.build(context);

        return code;

    }

        return this.getName() + " " + StringUtils.join(this.rules, ";");

    }

}

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseConstant;

import org.gvsig.expressionevaluator.impl.function.operator.NegOperator;

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

public class DefaultCompiler implements Compiler {

    class DefaultStatementContext implements StatementContext {

        private String codeClassifier;

            return DefaultCompiler.this.parse_expressions(separator);

        }

        public boolean isReservedWord(String s) {

            return grammars.isReservedWord(s);

        }

    }

    private boolean objectAccessSupported;

                Token next = lexer.look();

                if( next.getType() == Token.PARENTHESIS_OPEN ) {

                    lexer.next();

                    next = lexer.next();

                    switch(next.getType()) {

                        case Token.PARENTHESIS_CLOSE:

        }

    }

    private Code parse_grammars() {

        StatementContext context = new DefaultStatementContext();

        Code code;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import static org.gvsig.expressionevaluator.Code.CALLER;

import static org.gvsig.expressionevaluator.Code.CONSTANT;

                }

                if( caller.parameters() != null ) {

                    for( Code arg : caller.parameters() ) {

                    }

                }

            }

    public class BaseCodes implements Codes {

        public BaseCodes() {

            this.codes = new ArrayList<>();

        }

        @Override

        public int code() {

            return CODES;

        }

            return this.codes.size();

        }

        public void add(Code arg) {

        }

        public void insert(int pos, Code arg) {

        }

        @Override

        public Iterator<Code> iterator() {

        }

        @Override

        public Code get(int n) {

        }

        @Override

        public boolean isEmpty() {

            return this.codes.isEmpty();

        }

        @Override

        public List<Code> toList() {

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            }

        }

            if( codes != null ) {

                StringBuilder builder = new StringBuilder();

                boolean skipcoma = true;

                    if( code == null ) {

                        continue;

                    }

                    } else {

                        builder.append(", ");

                    }

                }

                return builder.toString();

            }

        @Override

        public void link(SymbolTable symbolTable) {

            }

        }

        @Override

        public Function function(Function function) {

            this.function = function;

            return this.function;

        }

                    break;

                case FUNCTION:

                default:

                    }

            }

            return builder.toString();

        }

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

                            boolean canOptimize = true;

                            if (caller.parameters() != null) {

                                newArgs = (BaseCodes) this.getCodeBuilder().args();

                                    Code newArg = this.doOptimize(arg);

                                    if (newArg.code() != Code.CONSTANT) {

                                        canOptimize = false;

                                    }

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

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

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

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

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

import org.gvsig.expressionevaluator.spi.AbstractGrammarFactory;

            theGrammar.addStatement(stmt);

//            stmt = theGrammar.createStatement("FOR");

//            stmt.addRule(stmt.require_expression("INIT"));

//            stmt.addRule(stmt.require_expression("CONDITION"));

//            stmt.addRule(stmt.require_expression("STEP"));

//            stmt.addRule(stmt.require_expression("BODY"));

//            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("FOREACH");

            stmt.addRule(stmt.optional_any_token("FUNCTION", "PROCEDURE"));

            stmt.addRule(stmt.require_identifier("FUNCTION_NAME"));

            stmt.addRule(stmt.optional_any_token("("));

            stmt.addRule(stmt.optional_any_token(")"));

            stmt.addRule(stmt.require_any_token("AS"));

            stmt.addRule(stmt.optional_any_token("$$","BEGIN")

//            stmt.addRule(stmt.optional_any_token("FUNCTION", "PROCEDURE"));

            stmt.code(

                    CreateFnFunction.NAME,

            ); 

            theGrammar.addStatement(stmt);

        interpreter.setSymbolTable(symbolTable);

        return interpreter;

    }

    public void testLet() {

        String source = "LET V1 = 23";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("BLOCK(LET('V1', 11), LET('V2', 22))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("BLOCK_EXCEPT(LET('V1', 11), LET('V2', 22), -1)", code.toString());

    }

        String source = "BEGIN LET V1 = 11; LET V2 = 22;  END";

        Code code = compiler.compileExpression(source);

        assertEquals("BLOCK(LET('V1', 11), LET('V2', 22))", code.toString());

        source = "BEGIN LET V1 = 11;; LET V2 = 22;;;  END";

        code = compiler.compileExpression(source);

        assertEquals("BLOCK(LET('V1', 11), LET('V2', 22))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("IFF((\"V1\" = 11), LET('V2', 11), LET('V2', 22))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("IFF((\"V1\" = 11), BLOCK(LET('V2', 22), LET('V1', 10)))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("WHILE((\"n\" < 10), LET('n', (\"n\" + 1)))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("WHILE((\"n\" < 10), BLOCK(LET('n', (\"n\" + 1)), print(\"n\")))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CAST(\"V1\", 'INTEGER')", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CAST(\"V1\", 'INTEGER')", code.toString());

    }

        source = "MATCH 'Hola', '[Hh]ola'";

        code = compiler.compileExpression(source);

        assertEquals("~('Hola', '[Hh]ola')", code.toString());

        source = "MATCH 'Hola' '[Hh]ola'";

        code = compiler.compileExpression(source);

        assertEquals("~('Hola', '[Hh]ola')", code.toString());

        source = "MATCH('Hola', '[Hh]ola')";

        code = compiler.compileExpression(source);

        assertEquals("~('Hola', '[Hh]ola')", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("FOREACH('n', RANGE(10), print(\"n\"))", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CASE((\"software\" LIKE '%gvSIG%'), 'gvSIG', 'Other')", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CASE((\"software\" LIKE '%gvSIG%'), 'gvSIG', 'Other')", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CASE(((\"Field_1\" >= 75) AND (\"Field_1\" <= 79)), ((\"Field_1\" >= 80) AND (\"Field_1\" <= 84)), 100, 110)", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CASE(((\"Field_1\" >= 75) AND (\"Field_1\" <= 79)), ((\"Field_1\" >= 80) AND (\"Field_1\" <= 84)), 100, 110, 120)", code.toString());

    }

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

    }

    public void testDef2() {

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

    }

    public void testDef3() {

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

    }

    public void testCreateFunctionExtern1() {

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);