Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

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

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;

import org.gvsig.expressionevaluator.Statement;

import org.gvsig.expressionevaluator.Statement.CompoundRule;

import org.gvsig.expressionevaluator.Statement.ConditionalRule;

import org.gvsig.expressionevaluator.Statement.Rule;

import org.gvsig.expressionevaluator.Statement.StatementContext;

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

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

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultStatement implements Statement {

    private final List<Rule> rules;

    private final String name;

    private StatementBuilder stmtBuilder;

//    private String codeId;

//    private ArgsBuilder argsBuilder;

    public interface IsApplicableRule extends Rule {

      public boolean isApplicable(StatementContext context);

    }

    public interface RepeatRule extends CompoundRule {

        public String getClassifier();

    }

    public class RuleRequireAnyToken implements IsApplicableRule {

        private final String[] required_token;

        private String id;

        public RuleRequireAnyToken(String... required_token) {

            this.required_token = required_token;

        }

        @Override

        public RuleRequireAnyToken capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

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

                throw new ExpressionSyntaxException(

                        I18N.A_XTokenX_was_expected_and_XliteralX_was_found(

                                StringUtils.join(this.required_token,", "),

                                token.getLiteral()

                        ),

                        context.getLexicalAnalyzer()

                );

            }

            if( this.id != null ) {

              Code code = context.getCodeBuilder().constant(token.getValue());

              context.setCode(id, code);

            }

            context.next_token();

        }

        @Override

        public boolean isApplicable(StatementContext context) {

            Token token = context.next_token();

            boolean r = token.is(this.required_token);

            context.trace(this.toString()+".isApplicable return "+r);

            return r;

        }

        @Override

        public String toString() {

            return "require_token(" + StringUtils.join(this.required_token) + ")";

        }

    }

    public class RuleRequireIdentifier implements IsApplicableRule {

        private String id;

        public RuleRequireIdentifier() {

        }

        @Override

        public Rule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

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

                throw new ExpressionSyntaxException(

                        I18N.An_identifier_was_expected_and_XliteralX_was_found(token.getLiteral()),

                        context.getLexicalAnalyzer()

                );

            }

            if( this.id!=null ) {

              String identifier = (String) token.getLiteral();

              Code code = context.getCodeBuilder().constant(identifier);

              context.setCode(id, code);

            }

            context.next_token();

        }

        @Override

        public boolean isApplicable(StatementContext context) {

            Token token = context.next_token();

            boolean r = token.getType() == Token.IDENTIFIER;

            context.trace(this.toString()+".isApplicable return "+r);

            return r;

        }

        @Override

        public String toString() {

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

        }

    }

    public class RuleRequireLiteralString implements Rule {

        private String id;

        public RuleRequireLiteralString() {

        }

        @Override

        public Rule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

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

                throw new ExpressionSyntaxException(

                        I18N.A_string_literal_was_expected(),

                        context.getLexicalAnalyzer()

                );

            }

            if( this.id!=null ) {

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

              Code code = context.getCodeBuilder().constant(identifier);

              context.setCode(id, code);

              context.next_token();

            }

        }

        @Override

        public String toString() {

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

        }

    }

    public class RuleRequireExpression implements Rule {

        private String id;

        boolean allow_assignement;

        public RuleRequireExpression(boolean allow_assignement) {

            this.allow_assignement = allow_assignement;

        }

        @Override

        public Rule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

            Code code = context.parse_expression(allow_assignement);

            if (code == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

            }

            if( this.id!=null ) {

              context.setCode(id, code);

            }

        }

        @Override

        public String toString() {

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

        }

    }

    public class RuleSetExpression implements Rule {

        private final String id;

        private final Object value;

        public RuleSetExpression(String id, Object value) {

            this.id = id;

            this.value = value;

        }

        @Override

        public Rule capture_as(String... ids) {

          throw new UnsupportedOperationException("Unsupported operation.");

        }

        @Override

        public void parse(StatementContext context) {

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

            if( this.value instanceof Code ) {

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

            } else {

                context.setCode(id, context.getCodeBuilder().constant(value));

            }

        }

        @Override

        public String toString() {

            return "set_expression('" + this.id + "', "+Objects.toString(value)+")";

        }

    }

    public class RuleRequiereExpressions implements Rule {

        private String id;

        private final String separator;

        public RuleRequiereExpressions(String separator) {

            this.separator = separator;

        }

        @Override

        public Rule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

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

            if (codes == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

            }

            if( this.id!=null ) {

              Code code;

              if( codes.size()==1 ) {

                  code = codes.get(0);

              } else {

                  code = context.getCodeBuilder().function(CodeBlockFunction.NAME, codes);

              }

              context.setCode(id, code);

            }

        }

        @Override

        public String toString() {

            return "require_expressions('" + this.id + "', '" + this.separator + "')";

        }

    }

    public abstract class AbstractConditionalRule implements ConditionalRule {

        protected final List<Rule> onTrueRules;

        protected final List<Rule> onFalseRules;

        public AbstractConditionalRule() {

            this.onTrueRules = new ArrayList<>();

            this.onFalseRules = new ArrayList<>();

        }

        @Override

        public ConditionalRule capture_as(String... ids) {

          throw new UnsupportedOperationException("Operation not suppted.");

        }

        protected void parseOnTrueRules(StatementContext context) {

            for (Rule rule : this.onTrueRules) {

                rule.parse(context);

            }

        }

        protected void parseOnFalseRules(StatementContext context) {

            for (Rule rule : this.onFalseRules) {

                rule.parse(context);

            }

        }

        @Override

        public ConditionalRule addRuleOnTrue(Rule rule) {

            this.onTrueRules.add(rule);

            return this;

        }

        @Override

        public ConditionalRule addRuleOnFalse(Rule rule) {

            this.onFalseRules.add(rule);

            return this;

        }

    }

    public class RuleOptionalAnyToken implements ConditionalRule {

        private final String[] optional_token;

        private final List<Rule> onTrueRules;

        private final List<Rule> onFalseRules;

        private String id;

        public RuleOptionalAnyToken(String... optional_token) {

            this.optional_token = optional_token;

            this.onTrueRules = new ArrayList<>();

            this.onFalseRules = new ArrayList<>();

        }

        @Override

        public ConditionalRule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

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

                if( this.id!=null ) {

                  Code code = context.getCodeBuilder().constant(token.getValue());

                  context.setCode(id, code);

                }

                context.next_token();

                for (Rule rule : this.onTrueRules) {

                    rule.parse(context);

                }

            } else {

                for (Rule rule : this.onFalseRules) {

                    rule.parse(context);

                }

            }

        }

        @Override

        public RuleOptionalAnyToken addRuleOnTrue(Rule rule) {

            this.onTrueRules.add(rule);

            return this;

        }

        @Override

        public RuleOptionalAnyToken addRuleOnFalse(Rule rule) {

            this.onFalseRules.add(rule);

            return this;

        }

        @Override

        public String toString() {

            return "optional_token(" + StringUtils.join(this.optional_token) + ") onTrue:" + StringUtils.join(onTrueRules, ",")+", onFalse:" + StringUtils.join(onFalseRules, ",");

        }

    }

    public class RuleSwitchToken implements SwichTokenRule {

        private final List<Pair<String,Rule[]>> caseRules;

        private Rule[] defaultRule;

        public RuleSwitchToken() {

            this.caseRules = new ArrayList<>();

        }

        @Override

        public Rule capture_as(String... ids) {

          throw new UnsupportedOperationException("Unsupported operation.");

        }

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

            for (Pair<String, Rule[]> caseRule : caseRules) {

              if( token.is(caseRule.getKey()) ) {

                context.next_token();

                for (Rule rule : caseRule.getValue()) {

                  rule.parse(context);

                }

                return;

              }

            }

            if( defaultRule!=null ) {

              for (Rule rule : defaultRule) {

                rule.parse(context);

              }

            }

        }

        @Override

        public SwichTokenRule addCase(String token, Rule... rules) {

            this.caseRules.add(new ImmutablePair(token,rules));

            return this;

        }

        @Override

        public SwichTokenRule addDefault(Rule... rules) {

            this.defaultRule = rules;

            return this;

        }

        @Override

        public String toString() {

            return "switch_token() rules:" + StringUtils.join(this.caseRules,",") + " default: " + defaultRule;

        }

    }

    public class RuleRepeatUntilAnyTokens implements RepeatRule {

        private final String[] exit_tokens;

        private final List<Rule> rules;

        private int counter;

        public RuleRepeatUntilAnyTokens(String[] exit_tokens) {

            this.exit_tokens = exit_tokens;

            this.rules = new ArrayList<>();

        }

        @Override

        public Rule capture_as(String... ids) {

          throw new UnsupportedOperationException("Operation not suppted.");

        }

        @Override

        public void parse(StatementContext context) {

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

            String save = context.getCodeClassifier();

            try {

                this.counter = 1;

                while (true) {

                    Token token = context.look_token();

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

                        break;

                    }

                    context.setCodeClassifier(String.valueOf(counter).trim());

                    for (Rule rule : rules) {

                        rule.parse(context);

                    }

                    this.counter = this.counter + 1;

                }

            } finally {

                context.setCodeClassifier(save);

            }

        }

        @Override

        public RuleRepeatUntilAnyTokens addRule(Rule rule) {

            this.rules.add(rule);

            return this;

        }

        @Override

        public String getClassifier() {

            String s = String.valueOf(counter).trim();

            return s;

        }

        @Override

        public String toString() {

            return "repeat_until_tokens('" + ArrayUtils.toString(this.exit_tokens) + "') rules:" + StringUtils.join(rules, ",");

        }

    }

    public class RuleRepeat implements RepeatRule {

        private final List<Rule> rules;

        private int counter;

        public RuleRepeat() {

            this.rules = new ArrayList<>();

        }

        @Override

        public Rule capture_as(String... ids) {

          throw new UnsupportedOperationException("Operation not suppted.");

        }

        @Override

        public void parse(StatementContext context) {

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

            String save = context.getCodeClassifier();

            try {

                this.counter = 1;

                boolean breakloop = false;

                while (!breakloop) {

                    context.setCodeClassifier(String.valueOf(counter).trim());

                    for (Rule rule : rules) {

                      try {

                        rule.parse(context);

                      } catch(BreakLoopException ex) {

                        breakloop = true;

                        break;

                      }

                    }

                    this.counter = this.counter + 1;

                }

            } finally {

                context.setCodeClassifier(save);

            }

        }

        @Override

        public RuleRepeat addRule(Rule rule) {

            this.rules.add(rule);

            return this;

        }

        @Override

        public String getClassifier() {

            String s = String.valueOf(counter).trim();

            return s;

        }

        @Override

        public String toString() {

            return "repeat() rules:" + StringUtils.join(rules, ",");

        }

    }

    public static class BreakLoopException extends RuntimeException {

    }

    public static class RuleBreakLoop implements Rule {

        public RuleBreakLoop() {

        }

        @Override

        public Rule capture_as(String... ids) {

          throw new UnsupportedOperationException("Operation not suppted.");

        }

        @Override

        public void parse(StatementContext context) {

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

          throw new BreakLoopException();

        }

        @Override

        public String toString() {

            return "break_loop()";

        }

    }

        public static class RuleFail implements Rule {

        public RuleFail() {

        }

        @Override

        public Rule capture_as(String... ids) {

          throw new UnsupportedOperationException("Operation not suppted.");

        }

        @Override

        public void parse(StatementContext context) {

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

          throw new ExpressionSyntaxException();

        }

        @Override

        public String toString() {

            return "fail()";

        }

    }

    public class RuleOptionalIdentifiers extends AbstractConditionalRule implements ConditionalRule {

        private String id;

        private final String separator;

        public RuleOptionalIdentifiers(String separator) {

            super();

            this.separator = separator;

        }

        @Override

        public ConditionalRule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

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

            Token token = context.look_token();

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

                String identifier = (String) token.getLiteral();

                if( context.isReservedWord(identifier) ) {

                    break;

                }

                Code code = context.getCodeBuilder().constant(identifier);

                args.add(code);

                context.next_token();

                token = context.look_token();

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

                    break;

                }

                context.next_token();

                token = context.look_token();

            }

            if (args.size() != 0) {

              if( this.id!=null ) {

                Code code = context.getCodeBuilder().function(FUNCTION_LIST, args);

                context.setCode(id, code);

              }

              this.parseOnTrueRules(context);

            } else {

                this.parseOnFalseRules(context);

            }

        }

        @Override

        public String toString() {

            return "optional_identifiers('" + id + "', '" + this.separator + "')";

        }

    }

    public class RuleRequireIdentifiers implements Rule {

        private String id;

        private final String separator;

        public RuleRequireIdentifiers(String separator) {

            super();

            this.separator = separator;

        }

        @Override

        public Rule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

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

            Token token = context.look_token();

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

                String identifier = (String) token.getLiteral();

                if( context.isReservedWord(identifier) ) {

                    break;

                }

                Code code = context.getCodeBuilder().identifier(identifier);

                args.add(code);

                context.next_token();

                token = context.look_token();

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

                    break;

                }

                context.next_token();

                token = context.look_token();

            }

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

                throw new ExpressionSyntaxException(

                        I18N.An_identifier_was_expected_and_XliteralX_was_found(token.getLiteral()),

                        context.getLexicalAnalyzer()

                );

            }

            if( this.id!=null ) {

              Code code = context.getCodeBuilder().function(FUNCTION_TUPLE, args);

              context.setCode(id, code);

            }

        }

        @Override

        public String toString() {

            return "require_identifiers('" + id + "', '" + this.separator + "')";

        }

    }

    public class RuleOptionalLiteralString extends AbstractConditionalRule implements ConditionalRule {

        private String id;

        public RuleOptionalLiteralString() {

            super();

        }

        @Override

        public ConditionalRule capture_as(String... ids) {

          this.id = ids[0];

          return this;

        }

        @Override

        public void parse(StatementContext context) {

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

            Token token = context.look_token();

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

                if( this.id!=null ) {

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

                  Code code = context.getCodeBuilder().constant(s);

                  context.setCode(id, code);

                  context.next_token();

                }

                this.parseOnTrueRules(context);

            } else {

                this.parseOnFalseRules(context);

            }

        }

        @Override

        public String toString() {

            return "optional_literal_string('" + id + "')";

        }

    }

    public static class ArgsBuilderFromNames implements ArgsBuilder {

        protected final String[] argNames;

        public ArgsBuilderFromNames(String... argNames) {

            this.argNames = argNames;

        }

        @Override

        public String toString() {

          return "args_names("+StringUtils.join(argNames,",")+")";

        }

        @Override

        public Codes build(StatementContext context) {

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

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

            for (String argName : argNames) {

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

                    Code code = context.getCode(argName);

                    if (code == null) {

                        int n = 1;

                        while (true) {

                            String argNameX = StringUtils.replace(argName, "#", String.valueOf(n).trim(), 1);

                            code = context.getCode(argNameX);

                            if (code == null) {

                                break;

                            }

                            args.add(code);

                            n++;

                        }

                    } else {

                        args.add(code);

                    }

                } else {

                    Code code = context.getCode(argName);

//                    if( code == null) {

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

//                    }

                    args.add(code);

                }

            }

            return args;

        }

    }

    public static class FixedArgsBuilderFromNames implements ArgsBuilder {

        protected final String[] argNames;

        public FixedArgsBuilderFromNames(String... argNames) {

            this.argNames = argNames;

        }

        @Override

        public String toString() {

          return "fixed_args_names("+StringUtils.join(argNames,",")+")";

        }

        @Override

        public Codes build(StatementContext context) {

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

            CodeBuilder codeBuilder = context.getCodeBuilder();

            BaseCodes args = (BaseCodes) codeBuilder.args();

            for (String argName : argNames) {

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

                    int n = 1;

                    BaseCodes argsX = (BaseCodes) codeBuilder.args();

                    while (true) {

                        String argNameX = StringUtils.replace(argName, "#", String.valueOf(n).trim(), 1);

                        Code code = context.getCode(argNameX);

                        if (code == null) {

                            break;

                        }

                        argsX.add(code);

                        n++;

                    }

                    args.add(codeBuilder.tuple(argsX));

                } else {

                    Code code = context.getCode(argName);

                    if( code == null) {

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

                    }

                    args.add(code);

                }

            }

            return args;

        }

    }

    public static class ArgsBuilderExpand extends ArgsBuilderFromNames {

        public ArgsBuilderExpand(String... argNames) {

            super(argNames);

        }

        @Override

        public String toString() {

          return "args_expand("+StringUtils.join(argNames,",")+")";

        }

        @Override

        public Codes build(StatementContext context) {

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

            Codes base_args = super.build(context);

            for (Code arg : base_args) {

                if( arg.code() == Code.CALLABLE && 

                    ((Callable)arg).name().equals(CodeBlockFunction.NAME) ) {

                    Codes block_args = ((Callable)arg).parameters();

                    for (Code block_arg : block_args) {

                        args.add(block_arg);

                    }

                } else {

                    args.add(arg);

                }

            }

            return args;

        }

    }

    public static class StatementBuilderBase implements StatementBuilder {

        protected ArgsBuilder argsBuilder;

        protected String codeID;

        public StatementBuilderBase(String codeID, ArgsBuilder argsBuilder) {

            this.codeID = codeID;

            this.argsBuilder = argsBuilder;

        }

        @Override

        public String getCodeID() {

            return this.codeID;

        }

        @Override

        public ArgsBuilder getArgsBuilder() {

            return this.argsBuilder;

        }

        @Override

        public Code build(StatementContext context) {

            Codes args = this.getArgsBuilder().build(context);

            Code code = null;

            if (this.getCodeID() == null) {

                code = args.get(0);

            } else {

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

                    code = context.getCodeBuilder().function(this.getCodeID(), null);

                } else {

                    // Si es un bloque dentro de otro, dejamos solo uno.

                    if( args.size()==1 && 

                        StringUtils.equalsIgnoreCase(CodeBlockFunction.NAME,this.getCodeID()) ) {

                        Code code0 = args.get(0);

                        if( code0.code() == Code.CALLABLE && 

                                StringUtils.equalsIgnoreCase(CodeBlockFunction.NAME,((Callable)code0).name())

                                ) {

                            code = code0;

                        }

                    }

                    if( code == null ) {

                        code = context.getCodeBuilder().function(this.getCodeID(), args);

                    }

                }

            }

            return code;

        }

    }

    public DefaultStatement(String name) {

        this.rules = new ArrayList<>();

        this.stmtBuilder = null;

        this.name = name;

    }

    @Override

    public String getName() {

        return name;

    }

    @Override

    public Rule require_any_token(String... token) {

        return new RuleRequireAnyToken(token);

    }

    @Override

    public Rule require_identifier() {

        return new RuleRequireIdentifier();

    }

    @Override

    public Rule require_identifiers(String sep) {

        return new RuleRequireIdentifiers(sep);

    }

    @Override

    public Rule require_literal_string() {

        return new RuleRequireLiteralString();

    }

    @Override

    public Rule set_expression(String id, Object value) {

        return new RuleSetExpression(id, value);

    }

    @Override

    public Rule require_expression() {

        return this.require_expression(true);

    }

    @Override

    public Rule require_expression(boolean allow_assignement) {

        return new RuleRequireExpression(allow_assignement);

    }

    @Override

    public Rule require_expressions(String separator) {

        return new RuleRequiereExpressions(separator);

    }

    @Override

    public ConditionalRule optional_any_token(String... id) {

        return new RuleOptionalAnyToken(id);

    }

    @Override

    public ConditionalRule optional_identifiers(String separator) {

        return new RuleOptionalIdentifiers(separator);

    }

    @Override

    public ConditionalRule optional_literal_string() {

        return new RuleOptionalLiteralString();

    }

    @Override

    public CompoundRule repeat_until_any_tokens(String... tokens) {

        return new RuleRepeatUntilAnyTokens(tokens);

    }

    @Override

    public Statement addRule(Rule rule) {

        this.rules.add(rule);

        return this;

    }

    @Override

    public boolean isApplicable(StatementContext context) {

        if (this.rules.isEmpty()) {

            return false;

        }

        context.trace(this.getName()+".isApplicable");

        context.save_state();

        try {

          for (Rule rule : rules) {

            if( rule == null ) {

              continue;

            }

            if (rule instanceof IsApplicableRule) {

              if( !((IsApplicableRule) rule).isApplicable(context) ) {

                context.trace(this.getName()+".isApplicable return false");

                return false;

              }

            } else {

              rule.parse(context);

            }

          }

          context.trace(this.getName()+".isApplicable return true");

          return true;

        } catch(Exception ex) {

          context.trace(this.getName()+".isApplicable return false (error)");

          return false;

        } finally {

          context.restore_state();

        }

    }

    @Override

    public ArgsBuilder args_names(String... args) {

        ArgsBuilder x = new ArgsBuilderFromNames(args);

        return x;

    }

    @Override

    public ArgsBuilder fixed_args_names(String... args) {

        ArgsBuilder x = new FixedArgsBuilderFromNames(args);

        return x;

    }

    @Override

    public ArgsBuilder args_expand(String... args) {

        ArgsBuilder x = new ArgsBuilderExpand(args);

        return x;

    }

    @Override

    public void code(final String id, final ArgsBuilder argsBuilder) {

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

    }

    @Override

    public void builder(StatementBuilder builder) {

        this.stmtBuilder = builder;

    }

    @Override

    public Code parse(StatementContext context) {

        context.trace(this.getName()+".parse");

        for (Rule rule : rules) {

            rule.parse(context);

        }

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

        context.trace(this.getName()+".return "+code);

        return code;

    }

    @Override

    public String toString() {

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

    }

    @Override

    public CompoundRule repeat() {

      return new RuleRepeat();

    }

    @Override

    public Rule fail() {

      return new RuleFail();

    }

    @Override

    public Rule break_loop() {

      return new RuleBreakLoop();

    }

    @Override

    public SwichTokenRule switch_token() {

      return new RuleSwitchToken();

    }

}