/trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/main/java/org/gvsig/expressionevaluator/impl/DefaultStatement.java - Diff - Application: gvSIG desktop - gvSIG

Revision 44738 trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/main/java/org/gvsig/expressionevaluator/impl/DefaultStatement.java

     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.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;
     import org.gvsig.expressionevaluator.spi.AbstractLexicalAnalyzer;
     /**
+     *
-...
     //    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 Rule {
         public class RuleRequireAnyToken implements IsApplicableRule {
             private final String[] required_token;
-...
             @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(
-...
                 context.next_token();
+            }
             private boolean isApplicable(StatementContext context) {
                 Token token = context.look_token();
                 return token.is(this.required_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 class RuleRequireIdentifier implements Rule {
         public class RuleRequireIdentifier implements IsApplicableRule {
             private final String id;
-...
             @Override
             public void parse(StatementContext context) {
                 context.trace(this.toString()+".parse");
                 Token token = context.look_token();
                 if (token.getType() != Token.IDENTIFIER) {
                     throw new ExpressionSyntaxException(
-...
+            }
             @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 + "')";
+            }
-...
             @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(
-...
             @Override
             public void parse(StatementContext context) {
                 context.trace(this.toString()+".parse");
                 Code code = context.parse_expression();
                 if (code == null) {
                     throw new ExpressionSyntaxException(context.getLexicalAnalyzer());
-...
             @Override
             public void parse(StatementContext context) {
                 context.trace(this.toString()+".parse");
                 if( this.value instanceof Code ) {
                     context.setCode(id, (Code) this.value);
                 } else {
-...
             @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());
-...
             @Override
             public void parse(StatementContext context) {
                 context.trace(this.toString()+".parse");
                 Token token = context.look_token();
                 if (token.is(this.optional_token)) {
                     context.next_token();
-...
             @Override
             public String toString() {
                 return "optional_token(" + StringUtils.join(this.optional_token) + ") rules:" + StringUtils.join(onTrueRules, ",");
                 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 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;
-...
             @Override
             public void parse(StatementContext context) {
                 context.trace(this.toString()+".parse");
                 String save = context.getCodeClassifier();
                 try {
                     this.counter = 1;
-...
+            }
+        }
         public class RuleRepeat implements RepeatRule {
             private final List<Rule> rules;
             private int counter;
             public RuleRepeat() {
                 this.rules = new ArrayList<>();
+            }
             @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 void parse(StatementContext context) {
               context.trace(this.toString()+".parse");
               throw new BreakLoopException();
+            }
             @Override
             public String toString() {
                 return "break_loop()";
+            }
+        }
         public class RuleOptionalIdentifiers extends AbstractConditionalRule implements ConditionalRule {
             private final String id;
-...
             @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) {
-...
             @Override
             public void parse(StatementContext context) {
                 context.trace(this.toString()+".parse");
                 Token token = context.look_token();
                 if (token.getType() == Token.STRING_LITERAL) {
                     String s = (String) token.getValue();
-...
         public static class ArgsBuilderFromNames implements ArgsBuilder {
             private final String[] argNames;
             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("#")) {
-...
                             if (code == null) {
                                 break;
+                            }
                             args.add(code);
                             args.add(argNameX, code);
                             n++;
+                        }
                     } else {
-...
     //                    if( code == null) {
     //                        code = context.getCodeBuilder().constant(null);
     //                    }
                         args.add(code);
                         args.add(argName,code);
+                    }
+                }
                 return args;
-...
+            }
             @Override
             public String toString() {
               return "args_expand("+StringUtils.join(argNames,",")+")";
+            }
             @Override
             public Codes build(StatementContext context) {
                 BaseCodes args = (BaseCodes) context.getCodeBuilder().args();
-...
             if (this.rules.isEmpty()) {
                 return false;
+            }
             Rule rule = this.rules.get(0);
             if (!(rule instanceof RuleRequireAnyToken)) {
                 return false;
             context.trace(this.getName()+".isApplicable");
             AbstractLexicalAnalyzer lexer = (AbstractLexicalAnalyzer) context.getLexicalAnalyzer();
             lexer.push_state();
             try {
               boolean applicable = false;
               for (Rule rule : rules) {
                 if (!(rule instanceof IsApplicableRule)) {
                     break;
+                }
                 if( !((IsApplicableRule) rule).isApplicable(context) ) {
                   return false;
+                }
                 applicable = true;
+              }
               context.trace(this.getName()+".isApplicable return "+applicable);
               return applicable;
             } finally {
               lexer.pop_state();
+            }
             return ((RuleRequireAnyToken) rule).isApplicable(context);
+        }
         @Override
-...
             this.builder(new StatementBuilderBase(id, argsBuilder));
+        }
         @Override
         public void builder(StatementBuilder builder) {
             this.stmtBuilder = builder;
+        }
         @Override
         public Code parse(StatementContext context) {
     //        System.err.println("start parse "+this.getName());
             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;
+        }
-...
             return this.getName() + " " + StringUtils.join(this.rules, ";");
+        }
         @Override
         public CompoundRule repeat() {
           return new RuleRepeat();
+        }
         @Override
         public Rule break_loop() {
           return new RuleBreakLoop();
+        }
         @Override
         public SwichTokenRule switch_token() {
           return new RuleSwitchToken();
+        }
+    }

Also available in: Unified diff