Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl.grammars;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.Statement;

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

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

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

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

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

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.impl.function.typeconversion.CastFunction;

import org.gvsig.expressionevaluator.spi.AbstractGrammarFactory;

/**

 *

 * @author jjdelcerro

 */

public class BasicGrammarFactory extends AbstractGrammarFactory {

    private Grammar grammar;

    public BasicGrammarFactory() {

        super("Basic", true);

    }

    @Override

    public Grammar createGrammar() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        if( this.grammar==null ) {

            Grammar theGrammar = manager.createGrammar(this.getName());

            Statement stmt;

            theGrammar.addReservedWord("BEGIN");

            theGrammar.addReservedWord("END");

            theGrammar.addReservedWord("IF");

            theGrammar.addReservedWord("THEN");

            theGrammar.addReservedWord("ELSE");

            theGrammar.addReservedWord("WHILE");

            theGrammar.addReservedWord("CASE");

            theGrammar.addReservedWord("WHEN");

            theGrammar.addReservedWord("DEF");

            theGrammar.addReservedWord("MATCH");

            theGrammar.addReservedWord("CAST");

            stmt = theGrammar.createStatement("LET");

            stmt.addRule(stmt.require_token("LET", "SET"));

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

            stmt.addRule(stmt.require_token("="));

            stmt.addRule(stmt.require_expression("VALUE"));

            stmt.code(

                    LetFunction.NAME, 

                    stmt.args_names("NAME", "VALUE")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("BLOCK");

            stmt.addRule(stmt.require_token("BEGIN"));

            stmt.addRule(stmt.require_expressions("VALUES", ";"));

            stmt.addRule(stmt.require_token("END"));

            stmt.code(

                    CodeBlockFunction.NAME, 

                    stmt.args_expand("VALUES")

            );

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("IF");

            stmt.addRule(stmt.require_token("IF"));

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

            stmt.addRule(stmt.optional_token("THEN"));

            stmt.addRule(stmt.optional_token(":"));

            stmt.addRule(stmt.require_expression("ONTRUE"));

            stmt.addRule(stmt.optional_token("ELSE")

                    .addRuleOnTrue(stmt.optional_token(":"))

                    .addRuleOnTrue(stmt.require_expression("ONFALSE"))

            );

            stmt.code(

                    IIFFunction.NAME,

                    stmt.args_names("CONDITION","ONTRUE","ONFALSE")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("WHILE");

            stmt.addRule(stmt.require_token("WHILE"));

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

            stmt.addRule(stmt.optional_token("DO"));

            stmt.addRule(stmt.optional_token(":"));

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

            stmt.addRule(stmt.optional_token("DONE"));

            stmt.code(

                    WhileFunction.NAME,

                    stmt.args_names("CONDITION","BODY")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("CAST");

            stmt.addRule(stmt.require_token("CAST"));

            stmt.addRule(stmt.optional_token("(")

                .addRuleOnTrue(stmt.require_expression("VALUE"))

                .addRuleOnTrue(stmt.require_token("AS"))

                .addRuleOnTrue(stmt.require_identifier("TYPE"))

                .addRuleOnTrue(stmt.require_token(")"))                    

                .addRuleOnFalse(stmt.require_expression("VALUE"))

                .addRuleOnFalse(stmt.require_token("AS"))

                .addRuleOnFalse(stmt.require_identifier("TYPE"))

            );

            stmt.code(

                    CastFunction.NAME,

                    stmt.args_names("VALUE","TYPE")

            );

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("MATCH");

            stmt.addRule(stmt.require_token("MATCH"));

            stmt.addRule(stmt.optional_token("(")

                .addRuleOnTrue(stmt.require_expression("VALUE"))

                .addRuleOnTrue(stmt.require_token(","))

                .addRuleOnTrue(stmt.require_expression("PATTERN"))

                .addRuleOnTrue(stmt.require_token(")"))                    

                .addRuleOnFalse(stmt.require_expression("VALUE"))

                .addRuleOnFalse(stmt.optional_token(","))

                .addRuleOnFalse(stmt.require_expression("PATTERN"))

            );

            stmt.code(

                    RegExpOperator.NAME,

                    stmt.args_names("VALUE","PATTERN")

            );

            theGrammar.addStatement(stmt);

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

//            stmt.addRule(stmt.require_token("FOR"));

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

//            stmt.addRule(stmt.require_token(";"));

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

//            stmt.addRule(stmt.require_token(";"));

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

//            stmt.addRule(stmt.optional_token(":"));

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

//            stmt.addRule(stmt.optional_token("END"));

//            stmt.code(ForFunction.NAME,"INIT","CONDITION","STEP","BODY"); 

//            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("FOREACH");

            stmt.addRule(stmt.require_token("FOR"));

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

            stmt.addRule(stmt.require_token("IN"));

            stmt.addRule(stmt.require_expression("ITERABLE"));

            stmt.addRule(stmt.optional_token(":"));

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

            stmt.code(

                    ForEachFunction.NAME,

                    stmt.args_names("VAR","ITERABLE","BODY")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("CASE");

            stmt.addRule(stmt.require_token("CASE"));

            stmt.addRule(

                stmt.repeat_until_tokens("END","ELSE")

                    .addRule(stmt.require_token("WHEN"))

                    .addRule(stmt.require_expression("CONDITION#"))

                    .addRule(stmt.optional_token("THEN"))

                    .addRule(stmt.optional_token(":"))

                    .addRule(stmt.require_expression("ONTRUE#"))

            );

            stmt.addRule(stmt.optional_token("ELSE")

                    .addRuleOnTrue(stmt.optional_token(":"))

                    .addRuleOnTrue(stmt.require_expression("ELSE"))

            );

            stmt.addRule(stmt.optional_token("END"));

            stmt.code(

                    CaseFunction.NAME,

                    stmt.args_names("CONDITION#","ONTRUE#","ELSE")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("USERFUNCTION");

            stmt.addRule(stmt.require_token("DEF"));

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

            stmt.addRule(stmt.require_token("("));

            stmt.addRule(stmt.optional_identifiers("PARAM_NAMES", ","));

            stmt.addRule(stmt.require_token(")"));

            stmt.addRule(stmt.optional_token(":"));

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

            stmt.code(

                    CreateFnFunction.NAME,

                    stmt.args_names("FUNCTION_NAME","PARAM_NAMES","BODY")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("RETURN");

            stmt.addRule(stmt.require_token("RETURN"));

            stmt.addRule(stmt.require_expressions("VALUES", ","));

            stmt.code(

                    ReturnFunction.NAME,

                    stmt.args_expand("VALUES")

            ); 

            theGrammar.addStatement(stmt);

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

//            stmt.addRule(stmt.require_token("FETCH"));

//            stmt.addRule(stmt.require_token("FIRST"));

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

//            stmt.addRule(stmt.optional_token("FROM"));

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

//            stmt.addRule(stmt.optional_token("WHERE").addRuleOnTrue(stmt.require_expression("WHERE")));

//            stmt.addRule(stmt.optional_token("ORDER","BY").addRuleOnTrue(stmt.require_expression("ORDER")));

//            stmt.code("FETCH_FIRST","VALUE","FROM","WHERE");

//            theGrammar.addStatement(stmt);

            this.grammar = theGrammar;

        }

        return grammar;

    }

}