/ - Diff - Application: gvSIG desktop - gvSIG

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/function/programming/PrintFunction.java
32	32	Object value = null;
33	33	for (Object arg : args) {
34	34	value = arg;
35		System.err.print(Objects.toString(arg, ""));
	35	System.out.print(Objects.toString(arg, ""));
36	36	}
37		System.err.println();
	37	System.out.println();
38	38	return value;
39	39	}
40	40	}

             return other;
+        }
         private void skipcomments() {
             if (isEOF()) {
                 return;
+            }
             char ch = getch();
             while( ch == '-' ) {
                 ch = lookch();
                 if( ch == '-' ) {
                     while( ch != EOF && ch != '\n' ) {
                         ch = getch();
+                    }
                     ungetch();
                     skipblanks();
                     ch = getch();
+                }
+            }
             ungetch();
+        }
         @Override
         protected Token getToken() {
             skipblanks();
             skipcomments();
             char ch = getch();
             switch( ch ) {
             case EOF:

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/DefaultInterpreter.java
287	287	} catch(Exception ex2) {
288	288	// Ignore.
289	289	}
290		throw new ExpressionRuntimeException(code, I18N.Problems_calling_function_XIdentifierX_with_args_XargsX(function.name(),argsstr));
	290	throw new ExpressionRuntimeException(code, I18N.Problems_calling_function_XIdentifierX_with_args_XargsX(function.name(),argsstr), ex);
291	291	}
292	292	break;
293	293

     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.gvsig.expressionevaluator.Code;
-...
     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.impl.function.programming.ListFunction;
     /**
+     *
-...
                 this.required_token = required_token;
+            }
             @Override
             public void parse(StatementContext context) {
                 Token token = context.look_token();
                 if (!token.is(this.required_token)) {
-...
                 this.id = id;
+            }
             @Override
             public void parse(StatementContext context) {
                 Token token = context.look_token();
                 if (token.getType() != Token.IDENTIFIER) {
-...
                 this.id = id;
+            }
             @Override
             public void parse(StatementContext context) {
                 Code code = context.parse_expression();
                 if (code == null) {
-...
+            }
+        }
         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 void parse(StatementContext context) {
                 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 final String id;
-...
                 this.separator = separator;
+            }
             @Override
             public void parse(StatementContext context) {
                 Codes codes = context.parse_expressions(this.separator);
                 if (codes == null) {
                     throw new ExpressionSyntaxException(context.getLexicalAnalyzer());
+                }
                 Code code = context.getCodeBuilder().function(CodeBlockFunction.NAME, codes);
                 Code code;
                 if( codes.size()==1 ) {
                     code = codes.get(0);
                 } else {
                     code = context.getCodeBuilder().function(CodeBlockFunction.NAME, codes);
+                }
                 context.setCode(id, code);
+            }
-...
                 this.onFalseRules = new ArrayList<>();
+            }
             @Override
             public void parse(StatementContext context) {
                 Token token = context.look_token();
                 if (token.is(this.optional_token)) {
-...
+                }
+            }
             @Override
             public RuleOptionalAnyToken addRuleOnTrue(Rule rule) {
                 this.onTrueRules.add(rule);
                 return this;
+            }
             @Override
             public RuleOptionalAnyToken addRuleOnFalse(Rule rule) {
                 this.onFalseRules.add(rule);
                 return this;
-...
                 this.rules = new ArrayList<>();
+            }
             @Override
             public void parse(StatementContext context) {
                 String save = context.getCodeClassifier();
                 try {
-...
+                }
+            }
             @Override
             public RuleRepeatUntilAnyTokens addRule(Rule rule) {
                 this.rules.add(rule);
                 return this;
-...
                 this.separator = separator;
+            }
             @Override
             public void parse(StatementContext context) {
                 BaseCodes args = (BaseCodes) context.getCodeBuilder().args();
                 Token token = context.look_token();
-...
                 this.argNames = argNames;
+            }
             @Override
             public Codes build(StatementContext context) {
                 BaseCodes args = (BaseCodes) context.getCodeBuilder().args();
                 for (String argName : argNames) {
-...
                 super(argNames);
+            }
             @Override
             public Codes build(StatementContext context) {
                 BaseCodes args = (BaseCodes) context.getCodeBuilder().args();
-...
             this.name = name;
+        }
         @Override
         public String getName() {
             return name;
+        }
-...
+        }
         @Override
         public Rule set_expression(String id, Object value) {
             return new RuleSetExpression(id, value);
+        }
         @Override
         public Rule require_expression(String id) {
             return new RuleRequireExpression(id);
+        }
-...
         @Override
         public Code parse(StatementContext context) {
     //        System.err.println("start parse "+this.getName());
             for (Rule rule : rules) {
                 rule.parse(context);
+            }
             Codes args = this.argsBuilder.build(context);
     //        System.err.println("end parse "+this.getName()+ ": "+ args.toString());
             Code code;
             if (codeId == null) {

     import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;
     import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseConstant;
     import org.gvsig.expressionevaluator.impl.function.operator.NegOperator;
     import org.gvsig.expressionevaluator.impl.function.programming.CodeBlockFunction;
     public class DefaultCompiler implements Compiler {
-...
                 this.codes.put(id, code);
+            }
             @Override
             public Code getCode(String id) {
                 return this.codes.get(id);
+            }
-...
                                 lexer
                             );
+                        }
                         return codeBuilder.method(op1, id, args);
                         op1 = codeBuilder.method(op1, id, args);
                     } else {
                         return codeBuilder.getattr(op1, id);
                         op1 = codeBuilder.getattr(op1, id);
+                    }
                     break;
                 default:
                     return op1;
+                }
-...
+                        }
                         return codeBuilder.function(id, args);
                     } else {
                         if( StringUtils.equalsIgnoreCase(id, "TRUE") ) {
                             return codeBuilder.constant(true);
+                        }
                         if( StringUtils.equalsIgnoreCase(id, "FALSE") ) {
                             return codeBuilder.constant(false);
+                        }
                         return codeBuilder.identifier(id);
+                    }
+                }
-...
         private Code parse_grammars() {
             StatementContext context = new DefaultStatementContext();
             Code code;
             BaseCodes args = (BaseCodes) this.codeBuilder.args();
             Statement stmt = this.grammars.getApplicableStatement(context);
             if( stmt!=null ) {
                 Code code1 = stmt.parse(context);
                 return code1;
             while( stmt!=null ) {
                 code = stmt.parse(context);
                 args.add(code);
                 stmt = this.grammars.getApplicableStatement(context);
+            }
             return null;
             switch(args.size()) {
                 case 0 :
                     code = null;
                     break;
                 case 1 :
                     code = args.get(0);
                     break;
                 default:
                     code = this.codeBuilder.function(CodeBlockFunction.NAME, args);
                     break;
+            }
             return code;
+        }
+    }

                 if( formatter.canApply(this) ) {
                     return formatter.format(this);
+                }
                 Code code;
                 StringBuilder builder = new StringBuilder();
                 switch(this.type) {
                     case UNARY_OPERATOR:
-...
                         break;
                     case BINARY_OPERATOR:
                         builder.append("(");
                         builder.append(this.parameters().get(0).toString(formatter));
                         code = this.parameters().get(0);
                         if( code == null ) {
                             builder.append("?NULL?");
                         } else {
                             builder.append(code.toString(formatter));
+                        }
                         builder.append(" ");
                         builder.append(this.name());
                         builder.append(" ");
                         builder.append(this.parameters().get(1).toString(formatter));
                         code = this.parameters().get(1);
                         if( code == null ) {
                             builder.append("?NULL?");
                         } else {
                             builder.append(code.toString(formatter));
+                        }
                         builder.append(")");
                         break;
                     case FUNCTION:

                 theGrammar.addReservedWord("TRY");
                 theGrammar.addReservedWord("EXCEPT");
                 stmt = theGrammar.createStatement("LET");
                 stmt.addRule(stmt.require_any_token("LET", "SET"));
                 stmt.addRule(stmt.require_identifier("NAME"));
                 stmt.addRule(stmt.require_any_token("="));
                 stmt.addRule(stmt.require_expression("VALUE"));
                 stmt.code(
                         LetFunction.NAME,
                         stmt.args_names("NAME", "VALUE")
                 );
                 theGrammar.addStatement(stmt);
     /*
     BEGIN
-...
                 stmt = theGrammar.createStatement("IF");
                 stmt.addRule(stmt.require_any_token("IF"));
                 stmt.addRule(stmt.require_expression("CONDITION"));
                 stmt.addRule(stmt.optional_any_token("THEN"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 stmt.addRule(stmt.require_expression("ONTRUE"));
                 stmt.addRule(stmt.require_any_token("THEN", ":"));
                 stmt.addRule(stmt.require_expressions("ONTRUE", ";"));
                 stmt.addRule(stmt.optional_any_token("ELSE")
                         .addRuleOnTrue(stmt.optional_any_token(":"))
                         .addRuleOnTrue(stmt.require_expression("ONFALSE"))
                         .addRuleOnTrue(stmt.require_expressions("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")
-...
                 stmt = theGrammar.createStatement("WHILE");
                 stmt.addRule(stmt.require_any_token("WHILE"));
                 stmt.addRule(stmt.require_expression("CONDITION"));
                 stmt.addRule(stmt.optional_any_token("DO"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 stmt.addRule(stmt.require_expression("BODY"));
                 stmt.addRule(stmt.optional_any_token("DONE"));
                 stmt.addRule(stmt.require_any_token("BEGIN", ":"));
                 stmt.addRule(stmt.require_expressions("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("CAST");
                 stmt.addRule(stmt.require_any_token("CAST"));
                 stmt.addRule(stmt.optional_any_token("(")
                     .addRuleOnTrue(stmt.require_expression("VALUE"))
                     .addRuleOnTrue(stmt.require_any_token("AS"))
                     .addRuleOnTrue(stmt.require_identifier("TYPE"))
                     .addRuleOnTrue(stmt.require_any_token(")"))
                     .addRuleOnFalse(stmt.require_expression("VALUE"))
                     .addRuleOnFalse(stmt.require_any_token("AS"))
                     .addRuleOnFalse(stmt.require_identifier("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("VALUE"))
                     .addRuleOnTrue(stmt.require_any_token(","))
                     .addRuleOnTrue(stmt.require_expression("PATTERN"))
                     .addRuleOnTrue(stmt.require_any_token(")"))
                     .addRuleOnFalse(stmt.require_expression("VALUE"))
                     .addRuleOnFalse(stmt.optional_any_token(","))
                     .addRuleOnFalse(stmt.require_expression("PATTERN"))
                 );
                 stmt.code(
                         OPERATOR_REGEXP,
                         stmt.args_names("VALUE","PATTERN")
                 );
                 theGrammar.addStatement(stmt);
     //            stmt = theGrammar.createStatement("FOR");
     //            stmt.addRule(stmt.require_token("FOR"));
     //            stmt.addRule(stmt.require_expression("INIT"));
-...
                 stmt.addRule(stmt.require_identifier("VAR"));
                 stmt.addRule(stmt.require_any_token("IN"));
                 stmt.addRule(stmt.require_expression("ITERABLE"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 stmt.addRule(stmt.require_expression("BODY"));
                 stmt.addRule(stmt.require_any_token("BEGIN", ":"));
                 stmt.addRule(stmt.require_expressions("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")
-...
                 stmt.addRule(
                     stmt.repeat_until_any_tokens("END","ELSE")
                         .addRule(stmt.require_any_token("WHEN"))
                         .addRule(stmt.require_expression("CONDITION#"))
                         .addRule(stmt.optional_any_token("THEN"))
                         .addRule(stmt.optional_any_token(":"))
                         .addRule(stmt.require_expression("ONTRUE#"))
                         .addRule(stmt.require_expressions("CONDITION#",";"))
                         .addRule(stmt.require_any_token("THEN",":"))
                         .addRule(stmt.require_expressions("ONTRUE#", ";"))
                 );
                 stmt.addRule(stmt.optional_any_token("ELSE")
                         .addRuleOnTrue(stmt.optional_any_token(":"))
                         .addRuleOnTrue(stmt.require_expression("ELSE"))
                         .addRuleOnTrue(stmt.require_expressions("ELSE",";"))
                 );
                 stmt.addRule(stmt.optional_any_token("END"));
                 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("DEF"));
                 stmt.addRule(stmt.require_any_token("DEF", "CREATE"));
                 stmt.addRule(stmt.optional_any_token("FUNCTION"));
                 stmt.addRule(stmt.require_identifier("FUNCTION_NAME"));
                 stmt.addRule(stmt.require_any_token("("));
                 stmt.addRule(stmt.optional_identifiers("PARAM_NAMES", ","));
                 stmt.addRule(stmt.require_any_token(")"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 stmt.addRule(stmt.require_expression("BODY"));
                 stmt.addRule(stmt.require_expressions("BODY", ";"));
                 stmt.addRule(stmt.require_any_token("END"));
                 stmt.addRule(stmt.optional_any_token("FUNCTION"));
                 stmt.code(
                         CreateFnFunction.NAME,
                         stmt.args_names("FUNCTION_NAME","PARAM_NAMES","BODY")
-...
                 stmt = theGrammar.createStatement("RETURN");
                 stmt.addRule(stmt.require_any_token("RETURN"));
                 stmt.addRule(stmt.require_expressions("VALUES", ","));
                 stmt.addRule(stmt.optional_any_token(";")
                         .addRuleOnTrue(stmt.set_expression("VALUES", null))
                         .addRuleOnFalse(stmt.require_expression("VALUES"))
                         .addRuleOnFalse(stmt.require_any_token(";"))
                 );
                 stmt.code(
                         ReturnFunction.NAME,
                         stmt.args_expand("VALUES")
-...
                 stmt = theGrammar.createStatement("TRY");
                 stmt.addRule(stmt.require_any_token("TRY"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 stmt.addRule(stmt.require_expression("VALUE"));
                 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_expression("ONERROR"));
                 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("NAME"));
                 stmt.addRule(stmt.require_any_token("="));
                 stmt.addRule(stmt.require_expression("VALUE"));
                 stmt.code(
                         LetFunction.NAME,
                         stmt.args_names("NAME", "VALUE")
                 );
                 theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("CAST");
                 stmt.addRule(stmt.require_any_token("CAST"));
                 stmt.addRule(stmt.optional_any_token("(")
                     .addRuleOnTrue(stmt.require_expression("VALUE"))
                     .addRuleOnTrue(stmt.require_any_token("AS"))
                     .addRuleOnTrue(stmt.require_identifier("TYPE"))
                     .addRuleOnTrue(stmt.require_any_token(")"))
                     .addRuleOnFalse(stmt.require_expression("VALUE"))
                     .addRuleOnFalse(stmt.require_any_token("AS"))
                     .addRuleOnFalse(stmt.require_identifier("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("VALUE"))
                     .addRuleOnTrue(stmt.require_any_token(","))
                     .addRuleOnTrue(stmt.require_expression("PATTERN"))
                     .addRuleOnTrue(stmt.require_any_token(")"))
                     .addRuleOnFalse(stmt.require_expression("VALUE"))
                     .addRuleOnFalse(stmt.optional_any_token(","))
                     .addRuleOnFalse(stmt.require_expression("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"));

     create function form_onSetvalues(form, values)
       return;
     end function
     create function form_onFieldEnter(form, field)
       return;
     end function
     create function form_onFieldExit(form, field)
       return;
     end function
     create function form_onFieldChanged(form, field)
       return;
     end function
     create function form_validate(form)
       return true;
     end function
     create function form_onLoad(form)
       return false;
     end function
     create function form_clear(form)
       return;
     end function
     create function form_isReadOnly(form)
         if not user().isAuthenticated() then
           return true;
         end if
         return false;
         -- set fecha_accidente = form.getField('FECHA_ACCIDENTE').getValue();
         -- if fecha_accidente = null then
         --   return false;
         -- end if
         -- set fecha_de_cierre = application().getProperty('CEGESEV.accidentes.fecha_de_cierre');
         -- if fecha_de_cierre = null then
         --   return true;
         -- end if
         -- return Date(fecha_de_cierre) > Date(fecha_accidente);
     end function

     CREATE FUNCTION test1()
         SET x = '';
         FOR n IN LIST('hola','adios','fin'):
             SET x = x || ' ' || n;
         END FOR
         RETURN x;
     END FUNCTION
     CREATE FUNCTION test2()
         SET s = '';
         SET x = LIST('hola','adios','fin');
         FOR n IN RANGE(3):
             SET s = s || ' ' || x[n];
         END FOR
         RETURN s;
     END FUNCTION

     package org.gvsig.expresionevaluator.impl;
     import java.io.InputStream;
     import junit.framework.TestCase;
     import org.apache.commons.io.IOUtils;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;
     import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;
     import org.gvsig.tools.script.Script;
     public class TestScript1 extends TestCase {
         public TestScript1(String testName) {
             super(testName);
+        }
         @Override
         protected void setUp() throws Exception {
             super.setUp();
             new DefaultLibrariesInitializer().fullInitialize();
+        }
         @Override
         protected void tearDown() throws Exception {
             super.tearDown();
+        }
         // TODO add test methods here. The name must begin with 'test'. For example:
         // public void testHello() {}
         public void testScript1() throws Exception {
             InputStream is = this.getClass().getResource("/org/gvsig/expressionevaluator/impl/TestScript1_1.txt").openStream();
             String source = StringUtils.join(IOUtils.readLines(is), "\n");
             ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
             Object r;
             Script sc;
             try {
                 sc = manager.createScript("test1", source, "COSA");
             } catch(Exception ex) {
                 System.err.println(ex.getMessage());
                 throw ex;
+            }
             r = sc.invokeFunction("form_validate", new Object[]{"form"});
             assertEquals(true, r);
             r = sc.invokeFunction("form_isReadOnly", new Object[]{"form"});
             assertEquals(false, r);
+        }
         public void testScript2() throws Exception {
             InputStream is = this.getClass().getResource("/org/gvsig/expressionevaluator/impl/TestScript1_2.txt").openStream();
             String source = StringUtils.join(IOUtils.readLines(is), "\n");
             ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();
             Object r;
             Script sc;
             try {
                 sc = manager.createScript("test2", source, "COSA");
             } catch(Exception ex) {
                 System.err.println(ex.getMessage());
                 throw ex;
+            }
             r = sc.invokeFunction("test1", null);
             assertEquals(" hola adios fin", r);
             r = sc.invokeFunction("test2", null);
             assertEquals(" hola adios fin", r);
+            }
+    }

             Interpreter interpreter = createInterpreter(symbolTable);
             symbolTable.setVar("V1", 10);
             String source = "IF V1 = 11 THEN SET V2 = 22";
             String source = "IF V1 = 11 THEN SET V2 = 22; END IF";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             assertEquals(null, symbolTable.value("V2"));
             symbolTable.setVar("V1", 11);
             source = "IF V1 = 11 THEN SET V2 = 22";
             source = "IF V1 = 11 THEN SET V2 = 22; END IF";
             code = compiler.compileExpression(source);
             v = interpreter.run(code);
-...
             Interpreter interpreter = createInterpreter(symbolTable);
             symbolTable.setVar("V1", 10);
             String source = "IF V1 = 11 THEN SET V2 = 11 ELSE SET V2 = 22";
             String source = "IF V1 = 11 THEN SET V2 = 11; ELSE SET V2 = 22; END IF";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Interpreter interpreter = createInterpreter(symbolTable);
             symbolTable.setVar("V1", 11);
             String source = "IF V1 = 11 THEN BEGIN LET V2 = 22; LET V1 = 10 END";
             String source = "IF V1 = 11 THEN LET V2 = 22; LET V1 = 10; END IF";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Interpreter interpreter = createInterpreter(symbolTable);
             symbolTable.setVar("n",0);
             String source = "WHILE n < 10 SET n = n + 1";
             String source = "WHILE n < 10 BEGIN SET n = n + 1; END WHILE";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "FOR n in RANGE(10) print(n)";
             String source = "FOR n in RANGE(10) BEGIN print(n); END FOR";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "DEF test1() 'Hola'";
             String source = "CREATE FUNCTION test1() RETURN 'Hola'; END FUNCTION";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "DEF test1(nombre) 'Hola ' || nombre";
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola ' || nombre; END FUNCTION";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "DEF test1(nombre) BEGIN RETURN 'Hola ' || nombre END";
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola ' || nombre; END FUNCTION";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "DEF test1(nombre) BEGIN RETURN 'Hola ' || nombre; 'Oh!...'; END";
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola ' || nombre; END FUNCTION";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "begin set x = ''; for n in list('hola','adios','fin'): let x = x || ' ' || n end";
             String source = "begin set x = ''; for n in list('hola','adios','fin'): let x = x || ' ' || n; end for; end";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "begin set s = ''; set x = LIST('hola','adios','fin'); FOR n in RANGE(3): set s = s || ' ' || x[n] end";
             String source = "begin set s = ''; set x = LIST('hola','adios','fin'); FOR n in RANGE(3): set s = s || ' ' || x[n]; end for; end";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);

     package org.gvsig.expresionevaluator.impl;
     import static junit.framework.Assert.assertEquals;
     import junit.framework.TestCase;
     import org.gvsig.expressionevaluator.Code;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
-...
+        }
         public void testBlock() {
             String source = "BEGIN LET V1 = 23 END";
             String source = "BEGIN LET V1 = 23; END";
             Compiler compiler = createCompiler();
-...
+        }
         public void testBlock2() {
             String source = "BEGIN LET V1 = 11; LET V2 = 22  END";
             String source = "BEGIN LET V1 = 11; LET V2 = 22;  END";
             Compiler compiler = createCompiler();
-...
+        }
         public void testIfThen() {
             String source = "IF V1 = 11 THEN LET V2 = 22";
             String source = "IF V1 = 11 THEN LET V2 = 22; END IF";
             Compiler compiler = createCompiler();
-...
             assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());
+        }
         public void testIfThen2() {
             String source = "IF V1 = 11 LET V2 = 22";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());
+        }
         public void testIfThen3() {
             String source = "IF V1 = 11: LET V2 = 22";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());
+        }
         public void testIfThenElse() {
             String source = "IF V1 = 11 THEN LET V2 = 11 ELSE LET V2 = 22";
             String source = "IF V1 = 11 THEN LET V2 = 11; ELSE LET V2 = 22; END IF";
             Compiler compiler = createCompiler();
-...
+        }
         public void testIfThenBlock() {
             String source = "IF V1 = 11 THEN BEGIN LET V2 = 22; LET V1 = 10 END";
             String source = "IF V1 = 11 THEN LET V2 = 22; LET V1 = 10; END IF";
             Compiler compiler = createCompiler();
-...
+        }
         public void testWhile() {
             String source = "WHILE n < 10 LET n = n + 1";
             String source = "WHILE n < 10 BEGIN LET n = n + 1; END WHILE";
             Compiler compiler = createCompiler();
-...
+        }
         public void testWhileBlock() {
             String source = "WHILE n < 10 BEGIN LET n = n + 1; print(n) END";
             String source = "WHILE n < 10 BEGIN LET n = n + 1; print(n); END WHILE";
             Compiler compiler = createCompiler();
-...
+        }
         public void testForEach() {
             String source = "FOR n in RANGE(10) print(n)";
             String source = "FOR n in RANGE(10): print(n); END FOR";
             Compiler compiler = createCompiler();
-...
     //    }
         public void testCase() {
             String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG' ELSE 'Other' END"; // ;)
             String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG'; ELSE 'Other'; END CASE"; // ;)
             Compiler compiler = createCompiler();
-...
+        }
         public void testCase1() {
             String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG' ELSE 'Other'"; // ;)
             String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG'; ELSE 'Other'; END CASE"; // ;)
             Compiler compiler = createCompiler();
-...
+        }
         public void testCase2() {
             String source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100 WHEN Field_1 >=80 AND Field_1 <=84 THEN 110 END"; // ;)
             String source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100; WHEN Field_1 >=80 AND Field_1 <=84 THEN 110; END CASE"; // ;)
             Compiler compiler = createCompiler();
-...
+        }
         public void testCase3() {
             String source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100 WHEN Field_1 >=80 AND Field_1 <=84 THEN 110 ELSE 120 END"; // ;)
             String source = "CASE WHEN Field_1 >= 75 AND Field_1 <=79 THEN 100; WHEN Field_1 >=80 AND Field_1 <=84 THEN 110; ELSE 120; END CASE"; // ;)
             Compiler compiler = createCompiler();
-...
+        }
         public void testDef1() {
             String source = "DEF test1() print('Hola')";
             String source = "CREATE FUNCTION test1() print('Hola'); END FUNCTION";
             Compiler compiler = createCompiler();
-...
+        }
         public void testDef2() {
             String source = "DEF test1(nombre) print('Hola '+nombre)";
             String source = "CREATE FUNCTION test1(nombre) print('Hola '+nombre); END FUNCTION";
             Compiler compiler = createCompiler();
-...
+        }
         public void testDef3() {
             String source = "DEF test1(nombre) BEGIN RETURN 'Hola '||nombre END";
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola '||nombre; END FUNCTION";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), BLOCK(RETURN(('Hola ' || \"nombre\"))))", code.toString());
             assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), RETURN(('Hola ' || \"nombre\")))", code.toString());
+        }
         public void testUseCase1() {
             String source = "begin set x = ''; for n in list('hola','adios','fin'): let x = x || ' ' || n end";
             String source = "begin set x = ''; for n in list('hola','adios','fin'): let x = x || ' ' || n; end for; end";
             Compiler compiler = createCompiler();
-...
+        }
         public void testUseCase2() {
             String source = "begin set s = ''; set x = LIST('hola','adios','fin'); FOR n in RANGE(3): set s = s || ' ' || x[n] end";
             String source = "begin set s = ''; set x = LIST('hola','adios','fin'); FOR n in RANGE(3): set s = s || ' ' || x[n]; end for; end";
             Compiler compiler = createCompiler();

                 return literal;
+            }
             @Override
             public void setLiteral(String literal) {
                 this.literal = literal;
+            }
-...
         private Stack<Integer> states;
         private String source;
         private int position;
         private int lineno;
         private int column;
         protected Buffer buffer;
         protected Token token;
-...
         public int getPosition() {
             return position;
+        }
         private void calcualteLineAndColumn() {
             final String s = this.source;
             int max = s.length();
             if( max > this.position ) {
                 max = this.position;
+            }
             int line = 1;
             int col = 0;
             for (int i = 0; i < max ; i++) {
                 if( s.charAt(i)=='\n' ) {
                     line++;
                     col = 0;
+                }
                 col++;
+            }
             this.lineno = line;
             this.column = col;
+        }
         @Override
         public int getLine() {
             this.calcualteLineAndColumn();
             return lineno;
+        }
         @Override
         public int getColumn() {
             this.calcualteLineAndColumn();
             return column;
+        }
         @Override
         public boolean isEOF() {
             return this.position >= this.source.length();
+        }
-...
             if (this.position >= this.source.length()) {
                 return EOF;
+            }
             this.column++;
             return this.source.charAt(this.position++);
+        }
-...
             if (this.position < 0) {
                 this.position = 0;
+            }
             this.column--;
             if (this.column < 0) {
                 this.column = 0;
+            }
+        }
         protected void parseString() {
-...
+            }
+        }
         @Override
         public void setUseBracketsForIdentifiers(boolean useBracketsForIdentifiers) {
             this.useBracketsForIdentifiers = useBracketsForIdentifiers;
+        }
         @Override
         public boolean getUseBracketsForIdentifiers() {
             return this.useBracketsForIdentifiers;
+        }

     package org.gvsig.expressionevaluator;
     import org.apache.commons.lang3.StringUtils;
     /**
+     *
      * @author jjdelcerro
-...
     public class ExpressionSyntaxException extends RuntimeException {
         private final int position;
         private final int line;
         private final int column;
         private final String phrase;
         private final String description;
         private String tip;
-...
             super("Syntax error in expression.");
             this.phrase = null;
             this.position = -1;
             this.line = -1;
             this.column = -1;
             this.description = I18N.Syntax_error_in_expression();
             this.tip = null;
+        }
         public ExpressionSyntaxException(LexicalAnalyzer lexer) {
             super("Syntax error in '"+lexer.getSource()+"' near character "+ lexer.getPosition()+".");
             super("Syntax error in '"+getSource(lexer.getSource(), lexer.getPosition())+"' near character "+ lexer.getPosition()+" ("+lexer.getLine()+":"+lexer.getColumn()+").");
             this.phrase = lexer.getSource();
             this.position = lexer.getPosition();
             this.line = lexer.getLine();
             this.column = lexer.getColumn();
             this.description = I18N.Syntax_error_near_character_XPositionX(position);
+        }
         public ExpressionSyntaxException(String msg, LexicalAnalyzer lexer) {
             super("Syntax error in '"+lexer.getSource()+"' near character "+ lexer.getPosition()+". "+msg);
             super("Syntax error in '"+getSource(lexer.getSource(), lexer.getPosition()) +"' near character "+ lexer.getPosition()+" ("+lexer.getLine()+":"+lexer.getColumn()+"). "+msg);
             this.phrase = lexer.getSource();
             this.position = lexer.getPosition();
             this.line = lexer.getLine();
             this.column = lexer.getColumn();
             this.description = I18N.Syntax_error_near_character_XPositionX(position)+ " "+msg;
+        }
-...
+        }
         public ExpressionSyntaxException(String phrase, int position) {
             super("Syntax error in '"+phrase+"' near character "+ position+".");
             super("Syntax error in '"+getSource(phrase, position) +"' near character "+ position+".");
             this.phrase = phrase;
             this.position = position;
             this.line = -1;
             this.column = -1;
             this.description = I18N.Syntax_error_near_character_XPositionX(position);
+        }
         public ExpressionSyntaxException(String msg, String phrase, int position) {
             super("Syntax error in '"+phrase+"' near character "+ position+". "+msg);
             super("Syntax error in '"+ getSource(phrase, position) +"' near character "+ position+". "+msg);
             this.phrase = phrase;
             this.position = position;
             this.line = -1;
             this.column = -1;
             this.description = I18N.Syntax_error_near_character_XPositionX(position)+" "+msg;
+        }
         private static String getSource(String source, int position) {
             String s = StringUtils.left(source, position) + "[*]" + StringUtils.mid(source, position, 200);
             if( s.length()>200 ) {
                 s = "..."+StringUtils.mid(s, position-100, 200)+"...";
+            }
             return s;
+        }
         public String getPhrase() {
             return this.phrase;
+        }
-...
             return this.position;
+        }
         public int getLine() {
             return this.line;
+        }
         public int getColumn() {
             return this.column;
+        }
         public String getDescription() {
             return this.description;
+        }

         public int getPosition();
         public int getLine();
         public int getColumn();
         public String getSource();
         public void setUseBracketsForIdentifiers(boolean useBracketsForIdentifiers);

         public Rule require_identifier(String id);
         public Rule set_expression(String id, Object value);
         public Rule require_expression(String id);
         public Rule require_expressions(String id, String separator);

Application: gvSIG desktop

Revision 44379