Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl.grammars;

import org.apache.commons.lang3.StringUtils;

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.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 org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

/**

 *

 * @author jjdelcerro

 */

public class BasicGrammarFactory extends AbstractGrammarFactory {

    private Grammar grammar;

    public static class DictArgsBuilder implements Statement.ArgsBuilder {

        protected final String keyName;

        protected final String valueName;

        public DictArgsBuilder(String keyName, String valueName) {

            this.keyName = keyName;

            this.valueName = valueName;

        }

        @Override

        public String toString() {

            return "dict_args(" + this.keyName + "," + this.valueName + ")";

        }

        @Override

        public Codes build(StatementContext context) {

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

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

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

                int n = 1;

                while (true) {

                    String keyNameX = StringUtils.replace(keyName, "#", String.valueOf(n).trim(), 1);

                    String valueNameX = StringUtils.replace(valueName, "#", String.valueOf(n).trim(), 1);

                    Code keyCodeX = context.getCode(keyNameX);

                    if (keyCodeX == null) {

                        break;

                    }

                    Code valueCodeX = context.getCode(valueNameX);

                    args.add(keyCodeX);

                    args.add(valueCodeX);

                    n++;

                }

            } else {

                args.add(context.getCodeBuilder().constant(keyName));

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

            }

            return args;

        }

    }

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

        }

    }

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

            theGrammar.addStatement(this.createArrayStatement(theGrammar));

            theGrammar.addStatement(this.createBlockStatement(theGrammar));

            theGrammar.addStatement(this.createCallStatement(theGrammar));

            theGrammar.addStatement(this.createCaseStatement(theGrammar));

            theGrammar.addStatement(this.createCastStatement(theGrammar));

            theGrammar.addStatement(this.createDateStatement(theGrammar));

            theGrammar.addStatement(this.createDictStatement(theGrammar));

            theGrammar.addStatement(this.createExtractStatement(theGrammar));

            theGrammar.addStatement(this.createForeachStatement(theGrammar));

            theGrammar.addStatement(this.createFunctionStatement(theGrammar));

            theGrammar.addStatement(this.createIfStatement(theGrammar));

            theGrammar.addStatement(this.createLambdaStatement(theGrammar));

            theGrammar.addStatement(this.createLet1Statement(theGrammar));

            theGrammar.addStatement(this.createLet2Statement(theGrammar));

            theGrammar.addStatement(this.createSetattr1Statement(theGrammar));

            theGrammar.addStatement(this.createSetattr2Statement(theGrammar));

            theGrammar.addStatement(this.createVarStatement(theGrammar));

            theGrammar.addStatement(this.createListStatement(theGrammar));

            theGrammar.addStatement(this.createMatchStatement(theGrammar));

            theGrammar.addStatement(this.createPassStatement(theGrammar));

            theGrammar.addStatement(this.createReturnStatement(theGrammar));

            theGrammar.addStatement(this.createTimeStatement(theGrammar));

            theGrammar.addStatement(this.createTimestampStatement(theGrammar));

            theGrammar.addStatement(this.createWhileStatement(theGrammar));

            theGrammar.addStatement(this.create$ConstantStatement(theGrammar));

            this.grammar = theGrammar;

        }

        return grammar;

    }

    private Statement createBlockStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("BEGIN");

        theGrammar.addReservedWord("EXCEPT");

        theGrammar.addReservedWord("END");

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

        return stmt;

    }

    private Statement create$ConstantStatement(Grammar theGrammar) {

        Statement stmt;

        stmt = theGrammar.createStatement("$Constant");

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

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

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

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

                stmt.code(

                                  ExpressionBuilder.FUNCTION_$HOSTEXPRESSION,

                                  stmt.args_names("VALUE")

                          );

        return stmt;

    }

    private Statement createIfStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("IF");

        theGrammar.addReservedWord("THEN");

        theGrammar.addReservedWord("ELSE");

        theGrammar.addReservedWord("END");

        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(

                ExpressionBuilder.FUNCTION_IF,

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

        );

        return stmt;

    }

    private Statement createWhileStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("WHILE");

        theGrammar.addReservedWord("BEGIN");

        theGrammar.addReservedWord("END");

        theGrammar.addReservedWord("LOOP");

        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", ":", "LOOP"));

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

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

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

        stmt.code(

                WhileFunction.NAME,

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

        );

        return stmt;

    }

    private Statement createForeachStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("FOR");

        theGrammar.addReservedWord("IN");

//        theGrammar.addReservedWord("BEGIN");

        theGrammar.addReservedWord("END");

        theGrammar.addReservedWord("LOOP");

        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("LOOP"));

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

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

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

        stmt.code(

                ForEachFunction.NAME,

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

        );

        return stmt;

    }

    private Statement createCaseStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("CASE");

        theGrammar.addReservedWord("WHEN");

        theGrammar.addReservedWord("THEN");

        theGrammar.addReservedWord("ELSE");

        theGrammar.addReservedWord("END");

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

        );

        return stmt;

    }

    private Statement createFunctionStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("CREATE");

        theGrammar.addReservedWord("FUNCTION");

        theGrammar.addReservedWord("PROCEDURE");

        theGrammar.addReservedWord("AS");

        theGrammar.addReservedWord("BEGIN");

        theGrammar.addReservedWord("END");

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

        stmt = theGrammar.createStatement("USERFUNCTION");

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

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

                .addRuleOnTrue(stmt.optional_any_token("REPLACE"))

        );

        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.code(

                CreateFnFunction.NAME,

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

        );

        return stmt;

    }

    private Statement createLambdaStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("LAMBDA");

        stmt = theGrammar.createStatement("LAMBDA");

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

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

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

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

        stmt.code(

                CreateFnFunction.NAME,

                stmt.fixed_args_names("PARAMETERS", "BODY")

        );

        return stmt;

    }

    private Statement createReturnStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("RETURN");

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

        );

        return stmt;

    }

    private Statement createVarStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("VAR");

        stmt = theGrammar.createStatement("VAR");

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

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

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

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

            .addRuleOnFalse(stmt.set_expression("VALUE", null))

        );

        stmt.code(

                "VAR",

                new VarArgsBuilder("NAME", "VALUE")

        );

        return stmt;

    }

    private Statement createLet1Statement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("LET");

        theGrammar.addReservedWord("SET");

        theGrammar.addReservedWord("TO");

        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(

                ExpressionBuilder.FUNCTION_LET,

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

        );

        return stmt;

    }

    private Statement createLet2Statement(Grammar theGrammar) {

        Statement stmt;

        stmt = theGrammar.createStatement("LET2");

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

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

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

        stmt.code(

                ExpressionBuilder.FUNCTION_LET,

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

        );

        return stmt;

    }

    private Statement createSetattr1Statement(Grammar theGrammar) {

        Statement stmt;

        stmt = theGrammar.createStatement("SETATTR");

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

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

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

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

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

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

        stmt.code(

                ExpressionBuilder.FUNCTION_SETATTR,

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

        );

        return stmt;

    }

    private Statement createSetattr2Statement(Grammar theGrammar) {

        Statement stmt;

        stmt = theGrammar.createStatement("SETATTR");

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

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

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

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

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

        stmt.code(

                ExpressionBuilder.FUNCTION_SETATTR,

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

        );

        return stmt;

    }

    private Statement createArrayStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("ARRAY");

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

        );

        return stmt;

    }

    private Statement createCastStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("CAST");

        theGrammar.addReservedWord("AS");

        stmt = theGrammar.createStatement("CAST");

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

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

                .addRuleOnTrue(stmt.require_expression(false).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(false).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")

        );

        return stmt;

    }

    private Statement createMatchStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("MATCH");

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

        );

        return stmt;

    }

    private Statement createDateStatement(Grammar theGrammar) {

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

        return stmt;

    }

    private Statement createTimeStatement(Grammar theGrammar) {

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

        return stmt;

    }

    private Statement createTimestampStatement(Grammar theGrammar) {

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

        return stmt;

    }

    private Statement createExtractStatement(Grammar theGrammar) {

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

        return stmt;

    }

    private Statement createDictStatement(Grammar theGrammar) {

        Statement stmt;

        stmt = theGrammar.createStatement("DICT");

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

        stmt.addRule(stmt.repeat()

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

                        .addRuleOnFalse(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_DICT, new DictArgsBuilder("NAME#", "VALUE#"));

        return stmt;

    }

    private Statement createListStatement(Grammar theGrammar) {

        Statement stmt;

        stmt = theGrammar.createStatement("LIST");

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

        stmt.addRule(stmt.repeat()

                .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_LIST, stmt.args_names("VALUE#"));

        return stmt;

    }

    private Statement createPassStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("PASS");

        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#")

        );

        return stmt;

    }

    private Statement createCallStatement(Grammar theGrammar) {

        Statement stmt;

        theGrammar.addReservedWord("CALL");

        stmt = theGrammar.createStatement("CALL");

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

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

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

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

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

        );

        stmt.code(

                "CALL",

                stmt.args_names("CALLABLE", "ARGS#")

        );

        return stmt;

    }

}