Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl.grammars;

import org.gvsig.expressionevaluator.Code;

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

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

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

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

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

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

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

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.Statement;

import org.gvsig.expressionevaluator.Statement.StatementContext;

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

import org.gvsig.expressionevaluator.impl.DefaultStatement.StatementBuilderBase;

import org.gvsig.expressionevaluator.impl.DefaultStatement.ArgsBuilderFromNames;

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.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;

import org.gvsig.expressionevaluator.Code.Callable;

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

/**

 *

 * @author jjdelcerro

 */

public class BasicGrammarFactory extends AbstractGrammarFactory {

    private Grammar grammar;

    private class BeginStatementBuilder extends StatementBuilderBase {

        private final String blockID;

        private final String exceptID;

        public BeginStatementBuilder(String blockID, String exceptID) {

            super(CodeBlockFunction.NAME, new ArgsBuilderFromNames(blockID));

            this.blockID = blockID;

            this.exceptID = exceptID;

        }

        @Override

        public Code build(StatementContext context) {

            Callable code = (Callable) super.build(context);

            Code exceptCode = context.getCode(this.exceptID);

            if( exceptCode==null ) {

                return code;

            }

            BaseCodes args = (BaseCodes) code.parameters();

            args.add(exceptCode);

            code = context.getCodeBuilder().function(CodeBlockWithExceptFunction.NAME, args);

            return code;

        }

    }

    public BasicGrammarFactory() {

        super("Basic", true);

    }

    @Override

    public Grammar create(Object... parameters) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        if( this.grammar==null ) {

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

            Statement stmt;

            theGrammar.addReservedWord("BEGIN");

            theGrammar.addReservedWord("EXCEPT");

            theGrammar.addReservedWord("END");

            theGrammar.addReservedWord("IF");

            theGrammar.addReservedWord("THEN");

            theGrammar.addReservedWord("ELSE");

            theGrammar.addReservedWord("WHILE");

            theGrammar.addReservedWord("CASE");

            theGrammar.addReservedWord("WHEN");

            theGrammar.addReservedWord("FOR");

            theGrammar.addReservedWord("FOREACH");

            theGrammar.addReservedWord("CREATE");

            theGrammar.addReservedWord("FUNCTION");

            theGrammar.addReservedWord("PROCEDURE");

            theGrammar.addReservedWord("AS");

            theGrammar.addReservedWord("MATCH");

            theGrammar.addReservedWord("CAST");

            theGrammar.addReservedWord("SET");

            theGrammar.addReservedWord("TO");

            theGrammar.addReservedWord("FROM");

            theGrammar.addReservedWord("$$"); // ???? Asi van las funciones

            theGrammar.addReservedWord("PASS");

            stmt = theGrammar.createStatement("BLOCK");

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

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

            stmt.addRule(stmt.optional_any_token("EXCEPT")

                    .addRuleOnTrue(stmt.require_expressions(";").capture_as("EXCEPT"))

            );

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

            stmt.builder(new BeginStatementBuilder("VALUES","EXCEPT"));

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("IF");

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

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

            stmt.addRule(stmt.require_any_token("THEN", ":"));

            stmt.addRule(stmt.require_expressions(";").capture_as("ONTRUE"));

            stmt.addRule(stmt.optional_any_token("ELSE")

                    .addRuleOnTrue(stmt.optional_any_token(":"))

                    .addRuleOnTrue(stmt.require_expressions(";").capture_as("ONFALSE"))

            );

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

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

            stmt.code(

                    IIFFunction.NAME,

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

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("WHILE");

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

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

            stmt.addRule(stmt.require_any_token("BEGIN", ":"));

            stmt.addRule(stmt.require_expressions(";").capture_as("BODY"));

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

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

            stmt.code(

                    WhileFunction.NAME,

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

            ); 

            theGrammar.addStatement(stmt);

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

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

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

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

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

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

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

//            stmt.addRule(stmt.require_any_token("BEGIN", ":"));

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

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

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

//            stmt.code(

//                    ForFunction.NAME,

//                    stmt.args_names("INIT","CONDITION","STEP","BODY")

//            ); 

//            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("FOREACH");

            stmt.addRule(stmt.require_any_token("FOR","FOREACH"));

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

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

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

            stmt.addRule(stmt.require_any_token("BEGIN", ":"));

            stmt.addRule(stmt.require_expressions(";").capture_as("BODY"));

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

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

            stmt.code(

                    ForEachFunction.NAME,

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

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("CASE");

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

            stmt.addRule(

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

                    .addRule(stmt.require_any_token("WHEN"))

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

                    .addRule(stmt.require_any_token("THEN",":"))

                    .addRule(stmt.require_expressions(";").capture_as("ONTRUE#"))

            );

            stmt.addRule(stmt.optional_any_token("ELSE")

                    .addRuleOnTrue(stmt.optional_any_token(":"))

                    .addRuleOnTrue(stmt.require_expressions(";").capture_as("ELSE"))

            );

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

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

            stmt.code(

                    CaseFunction.NAME,

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

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("USERFUNCTION");

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

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

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

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

            stmt.addRule(stmt.optional_identifiers(",").capture_as("PARAMETERS"));

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

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

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

                    .addRuleOnTrue(stmt.require_expressions(";").capture_as("BODY"))

                    .addRuleOnTrue(stmt.require_any_token("$$", "END"))

                    .addRuleOnTrue(stmt.optional_any_token("FUNCTION", "PROCEDURE"))

                    .addRuleOnFalse(stmt.optional_literal_string().capture_as("SCRIPT_PATH")

                        .addRuleOnTrue(stmt.require_any_token(","))

                        .addRuleOnTrue(stmt.require_literal_string().capture_as("SCRIPT_FUNCTION"))

                        .addRuleOnTrue(stmt.optional_any_token("LANGUAGE")

                                .addRuleOnTrue(stmt.require_literal_string().capture_as("LANGUAGE"))

                        )

                    )

            );

//            stmt.addRule(stmt.require_expressions("BODY", ";"));

//            stmt.addRule(stmt.require_any_token("$$", "END"));

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

            stmt.code(

                    CreateFnFunction.NAME,

                    stmt.fixed_args_names("FUNCTION_NAME","PARAMETERS","BODY", "SCRIPT_PATH", "SCRIPT_FUNCTION", "LANGUAGE")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("RETURN");

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

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

                    .addRuleOnTrue(stmt.set_expression("VALUES", null))

                    .addRuleOnFalse(stmt.require_expression().capture_as("VALUES"))

                    .addRuleOnFalse(stmt.require_any_token(";"))

            );

            stmt.code(

                    ReturnFunction.NAME,

                    stmt.args_expand("VALUES")

            ); 

            theGrammar.addStatement(stmt);

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

//            stmt.addRule(stmt.require_any_token("TRY"));

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

//            stmt.addRule(stmt.require_expressions("VALUE", ";"));

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

//            stmt.addRule(stmt.require_any_token("EXCEPT","CATH"));

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

//            stmt.addRule(stmt.require_expressions("ONERROR", ";"));

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

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

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

//            stmt.code(

//                    TryFunction.NAME,

//                    stmt.args_names("VALUE","ONERROR")

//            ); 

//            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("LET");

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

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

            stmt.addRule(stmt.optional_any_token("=","TO"));

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

            stmt.code(

                    LetFunction.NAME, 

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

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("ARRAY");

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

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

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

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

            stmt.code(

                    FUNCTION_LIST, 

                    stmt.args_expand("VALUES")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("CAST");

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

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

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

                .addRuleOnTrue(stmt.require_any_token("AS"))

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

                .addRuleOnTrue(stmt.require_any_token(")"))                    

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

                .addRuleOnFalse(stmt.require_any_token("AS"))

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

            );

            stmt.code(

                    FUNCTION_CAST,

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

            );

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("MATCH");

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

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

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

                .addRuleOnTrue(stmt.require_any_token(","))

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

                .addRuleOnTrue(stmt.require_any_token(")"))                    

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

                .addRuleOnFalse(stmt.optional_any_token(","))

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

            );

            stmt.code(

                    OPERATOR_REGEXP,

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

            );

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

            stmt = theGrammar.createStatement("DATE");

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

            stmt.addRule(stmt.require_expression().capture_as("EXP"));

            stmt.code(FUNCTION_DATE,stmt.args_names("EXP"));

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("TIME");

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

            stmt.addRule(stmt.require_expression().capture_as("EXP"));

            stmt.code(FUNCTION_TIME,stmt.args_names("EXP"));

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("TIMESTAMP");

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

            stmt.addRule(stmt.require_expression().capture_as("EXP"));

            stmt.code(FUNCTION_TIMESTAMP,stmt.args_names("EXP"));

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("EXTRACT");

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

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

            stmt.addRule(stmt.require_any_token("CENTURY","DAY","DECADE",

                    "DOW","DOY","HOUR","ISODOW","ISOYEAR","MICROSECONDS",

                    "MILLENNIUM","MILLUSECONDS","MINUTE","MONTH","QUARTER",

                    "SECOND","WEEK","YEAR").capture_as("FIELD"));

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

            stmt.addRule(stmt.require_expression().capture_as("EXP"));

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

            stmt.code(FUNCTION_EXTRACT,stmt.args_names("FIELD", "EXP"));

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("MAP");

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

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

            stmt.addRule(stmt.repeat()

                    .addRule(stmt.require_identifier().capture_as("NAME#"))

                    .addRule(stmt.require_any_token("="))

                    .addRule(stmt.require_expression().capture_as("VALUE#"))

                    .addRule(stmt.optional_any_token(",")

                            .addRuleOnFalse(stmt.break_loop())

                    )

            );      

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

            stmt.code(FUNCTION_MAP,stmt.args_names("NAME#", "VALUE#"));

            theGrammar.addStatement(stmt);

            this.grammar = theGrammar;

            stmt = theGrammar.createStatement("PASS");

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

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

                .addRuleOnTrue(stmt.require_expressions(",").capture_as("ARGS#"))

                .addRuleOnTrue(stmt.require_any_token(")"))                    

            );

            stmt.code(

                    "PASS",

                    stmt.args_names("ARGS#")

            );

            theGrammar.addStatement(stmt);

        }

        return grammar;

    }

}