/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 44533 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

+            }
+        }
         public class RuleRequireLiteralString implements Rule {
             private final String id;
             public RuleRequireLiteralString(String id) {
                 this.id = id;
+            }
             @Override
             public void parse(StatementContext context) {
                 Token token = context.look_token();
                 if (token.getType() != Token.STRING_LITERAL) {
                     throw new ExpressionSyntaxException(
                             I18N.A_string_literal_was_expected(),
                             context.getLexicalAnalyzer()
                     );
+                }
                 String identifier = (String) token.getLiteral();
                 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 final String id;
-...
+            }
+        }
         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<>();
+            }
             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;
-...
+            }
+        }
         public class RuleOptionalIdentifiers implements Rule {
         public class RuleOptionalIdentifiers extends AbstractConditionalRule implements ConditionalRule {
             private final String id;
             private final String separator;
             public RuleOptionalIdentifiers(String id, String separator) {
                 super();
                 this.id = id;
                 this.separator = separator;
+            }
-...
                     context.next_token();
                     token = context.look_token();
+                }
                 Code code = null;
                 if (args.size() != 0) {
                     code = context.getCodeBuilder().function(FUNCTION_LIST, args);
                     Code code = context.getCodeBuilder().function(FUNCTION_LIST, args);
                     context.setCode(id, code);
                     this.parseOnTrueRules(context);
                 } else {
                     this.parseOnFalseRules(context);
+                }
                 context.setCode(id, code);
+            }
             @Override
-...
+            }
+        }
         public class RuleOptionalLiteralString extends AbstractConditionalRule implements ConditionalRule {
             private final String id;
             public RuleOptionalLiteralString(String id) {
                 super();
                 this.id = id;
+            }
             @Override
             public void parse(StatementContext context) {
                 Token token = context.look_token();
                 if (token.getType() == Token.STRING_LITERAL) {
                     String s = (String) token.getLiteral();
                     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 {
             private final String[] argNames;
-...
+                        }
                     } else {
                         Code code = context.getCode(argName);
                         if( code != null) {
                             args.add(code);
                         if( code == null) {
                             code = context.getCodeBuilder().constant(null);
+                        }
                         args.add(code);
+                    }
+                }
                 return args;
-...
+        }
         @Override
         public Rule require_literal_string(String id) {
             return new RuleRequireLiteralString(id);
+        }
         @Override
         public Rule set_expression(String id, Object value) {
             return new RuleSetExpression(id, value);
+        }
-...
+        }
         @Override
         public Rule optional_identifiers(String id, String separator) {
         public ConditionalRule optional_identifiers(String id, String separator) {
             return new RuleOptionalIdentifiers(id, separator);
+        }
         @Override
         public ConditionalRule optional_literal_string(String id) {
             return new RuleOptionalLiteralString(id);
+        }
         @Override
         public CompoundRule repeat_until_any_tokens(String... tokens) {
             return new RuleRepeatUntilAnyTokens(tokens);
+        }

Also available in: Unified diff