/ - Diff - Application: gvSIG desktop - gvSIG

             public Code parse_expression();
             public Codes parse_expressions(String separator);
             public boolean isReservedWord(String s);
+        }
         public interface Rule {
-...
             public Codes build(StatementContext context);
+        }
         public interface StatementBuilder {
             public String getCodeID();
             public ArgsBuilder getArgsBuilder();
             public Code build(StatementContext context);
+        }
         public String getName();
         public Statement addRule(Rule rule);
-...
         public void code(String id, ArgsBuilder argsBuilder);
         public void builder(StatementBuilder stmtBuilder);
         public Code parse(StatementContext context);
         public boolean isApplicable(StatementContext context);

             assertEquals("NULL", code.toString());
+        }
         public void testIsNull() {
             String source = "10 is null";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("(10 IS NULL)", code.toString());
+        }
         public void testIsNotNull() {
             String source = "10 is not null";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("NOT((10 IS NULL))", code.toString());
+        }
         public void testNotTrue() {
             String source = "not true";

             assertEquals("gvSIG", v);
+        }
         public void testCaseUnWhenSolo() {
             MutableSymbolTable symbolTable = createSymbolTable();
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             symbolTable.setVar("software","unknown");
             String source = "CASE WHEN software LIKE '%gvSIG%' THEN 'gvSIG' END"; // ;)
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
             assertEquals(null, v);
+        }
         public void testCase2() {
             MutableSymbolTable symbolTable = createSymbolTable();
             Compiler compiler = createCompiler();
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "CREATE FUNCTION test1() RETURN 'Hola'; END FUNCTION";
             String source = "CREATE PROCEDURE test1 AS RETURN 'Hola'; END PROCEDURE";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola ' || nombre; END FUNCTION";
             String source = "CREATE PROCEDURE test1 nombre AS RETURN 'Hola ' || nombre; END PROCEDURE";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola ' || nombre; END FUNCTION";
             String source = "CREATE PROCEDURE test1 nombre AS RETURN 'Hola ' || nombre; END PROCEDURE";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
-...
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola ' || nombre; END FUNCTION";
             String source = "CREATE PROCEDURE test1 nombre AS RETURN 'Hola ' || nombre; END PROCEDURE";
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);

             assertEquals("BLOCK(LET('V1', 23))", code.toString());
+        }
         public void testBlockExcept() {
             String source = "BEGIN LET V1 = 23; EXCEPT NULL; END";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("BLOCK_EXCEPT(LET('V1', 23), NULL)", code.toString());
+        }
         public void testBlock2() {
             String source = "BEGIN LET V1 = 11; LET V2 = 22;  END";
-...
             assertEquals("BLOCK(LET('V1', 11), LET('V2', 22))", code.toString());
+        }
         public void testBlockExcept2() {
             String source = "BEGIN LET V1 = 11; LET V2 = 22; EXCEPT -1; END";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("BLOCK_EXCEPT(LET('V1', 11), LET('V2', 22), -1)", code.toString());
+        }
         public void testBlock3() {
             Compiler compiler = createCompiler();
-...
+        }
         public void testDef1() {
             String source = "CREATE FUNCTION test1() print('Hola'); END FUNCTION";
             String source = "CREATE PROCEDURE test1 AS print('Hola'); END PROCEDURE";
             Compiler compiler = createCompiler();
-...
+        }
         public void testDef2() {
             String source = "CREATE FUNCTION test1(nombre) print('Hola '+nombre); END FUNCTION";
             String source = "CREATE PROCEDURE test1 nombre AS print('Hola '+nombre); END PROCEDURE";
             Compiler compiler = createCompiler();
-...
+        }
         public void testDef3() {
             String source = "CREATE FUNCTION test1(nombre) RETURN 'Hola '||nombre; END FUNCTION";
             String source = "CREATE PROCEDURE test1 nombre AS RETURN 'Hola '||nombre; END PROCEDURE";
             Compiler compiler = createCompiler();
-...
             assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), RETURN(('Hola ' || \"nombre\")))", code.toString());
+        }
         public void testList() {
             String source = "set x TO LIST('hola','adios','fin')";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("LET('x', LIST('hola', 'adios', 'fin'))", code.toString());
+        }
         public void testArray() {
             String source = "set x TO ARRAY['hola','adios','fin']";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("LET('x', LIST('hola', 'adios', 'fin'))", code.toString());
+        }
         public void testUseCase1() {
             String source = "begin set x = ''; for n in list('hola','adios','fin'): let x = x || ' ' || n; end for; end";

             assertEquals(null, interpreter.run(code));
+        }
         public void testIsNull() {
             SymbolTable symbolTable = createSymbolTable();
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "10 is null";
             Code code = compiler.compileExpression(source);
             assertEquals(false, interpreter.run(code));
+        }
         public void testIsNotNull() {
             SymbolTable symbolTable = createSymbolTable();
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             String source = "10 is not null";
             Code code = compiler.compileExpression(source);
             assertEquals(true, interpreter.run(code));
+        }
         public void testAdd1() {
             SymbolTable symbolTable = createSymbolTable();
             Compiler compiler = createCompiler();

     create function form_onSetvalues(form, values)
       return;
     end function
     create procedure form_onSetvalues form, values as
     begin
       print("form_onSetvalues");
     end
     create function form_onFieldEnter(form, field)
       return;
     end function
     create procedure form_onFieldEnter form, field as
     begin
       print("form_onFieldEnter");
     end
     create function form_onFieldExit(form, field)
       return;
     end function
     create procedure form_onFieldExit form, field as
     begin
       print("form_onFieldExit");
     end
     create function form_onFieldChanged(form, field)
       return;
     end function
     create procedure form_onFieldChanged form, field as
     begin
       print("form_onFieldChanged");
     end
     create function form_validate(form)
     create function form_validate form as
     $$
       return true;
     end function
     $$
     create function form_onLoad(form)
       return false;
     end function
     create procedure form_onLoad form as
     $$
       print("form_onLoad");
     $$
     create function form_clear(form)
       return;
     end function
     create procedure form_clear form as
     $$
       print("form_clear");
     $$
     create function form_isReadOnly(form)
     create function form_isReadOnly form as
     begin
         if not user().isAuthenticated() then
           return true;
         end if
-...
         --   return true;
         -- end if
         -- return Date(fecha_de_cierre) > Date(fecha_accidente);
     end function
     end

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

     import org.gvsig.expressionevaluator.impl.function.programming.ForEachFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.ForFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CallStaticMethodFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CodeBlockWithExceptFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CreateFnFunction;
     //import org.gvsig.expressionevaluator.impl.function.programming.EvalFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.FileFunction;
-...
             this.addFunction(new CaseFunction());
             this.addFunction(new CodeBlockFunction());
             this.addFunction(new CodeBlockWithExceptFunction());
             this.addFunction(new ForEachFunction());
             this.addFunction(new ForFunction());
             this.addFunction(new LetFunction());

             // FIXME: https://stackoverflow.com/questions/9822154/standard-sql-boolean-operator-is-vs-equals-operator
             if( op1==null && op2 == null) {
                 return true;
+            }
             if( op1==null || op2 == null ) {
                 return false;
+            }
             int type = this.getType(op1, op2);
             if( (type & TYPE_DOUBLE) == TYPE_DOUBLE ) {
                 boolean value = MathUtils.compareTo(

     package org.gvsig.expressionevaluator.impl.function.programming;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Code;
     import org.gvsig.expressionevaluator.Codes;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.impl.DefaultInterpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class CodeBlockWithExceptFunction extends AbstractFunction {
         public static final String NAME = "BLOCK_EXCEPT";
         public CodeBlockWithExceptFunction() {
             super(Function.GROUP_PROGRAMMING,
                     NAME,
                     Range.between(1,Integer.MAX_VALUE),
                     "Evaluate each of the arguments sequentially.",
                     NAME+"( {{arguments...}} )",
                     null,
                     "Object",
                     false
             );
+        }
         @Override
         public boolean useArgumentsInsteadObjects() {
             return true;
+        }
         @Override
         public boolean allowConstantFolding() {
             return false;
+        }
         @Override
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             throw new UnsupportedOperationException("Not supported yet.");
+        }
         @Override
         public Object call(Interpreter interpreter, Codes args) throws Exception {
             Object value = null;
             Code exceptionCode = args.get(args.size()-1);
             if( exceptionCode==null ) {
                 for (int i = 0; i < args.size()-1; i++) {
                     Code arg = args.get(i);
                     // LLamamos a runCode para que no atrape los returns.
                     value = ((DefaultInterpreter)interpreter).runCode(arg);
+                }
             } else {
                 for (int i = 0; i < args.size()-1; i++) {
                     Code arg = args.get(i);
                     try {
                         // LLamamos a runCode para que no atrape los returns.
                         value = ((DefaultInterpreter)interpreter).runCode(arg);
                     } catch(Exception ex) {
                         value = ((DefaultInterpreter)interpreter).runCode(exceptionCode);
                         break;
+                    }
+                }
+            }
             return value;
+        }
+    }

                 parseNumber();
                 return token;
+            }
             if( Character.isAlphabetic(ch) ) {
             if( Character.isAlphabetic(ch) || ch =='$' ) {
                 buffer.clear();
                 while( Character.isLetterOrDigit(ch) || ch == '_' ) {
                 while( Character.isLetterOrDigit(ch) || ch =='$' || ch == '_' ) {
                     buffer.add(ch);
                     ch = getch();
+                }

     public class DefaultStatement implements Statement {
         private final List<Rule> rules;
         private String codeId;
         private ArgsBuilder argsBuilder;
         private final String name;
         private StatementBuilder stmtBuilder;
     //    private String codeId;
     //    private ArgsBuilder argsBuilder;
         public interface RepeatRule extends CompoundRule {
-...
                 if (!token.is(this.required_token)) {
                     throw new ExpressionSyntaxException(
                             I18N.A_XTokenX_was_expected_and_XliteralX_was_found(
                                     StringUtils.join(this.required_token),
                                     StringUtils.join(this.required_token,", "),
                                     token.getLiteral()
                             ),
                             context.getLexicalAnalyzer()
-...
                 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();
-...
+            }
+        }
         private static class ArgsBuilderFromNames implements ArgsBuilder {
         public static class ArgsBuilderFromNames implements ArgsBuilder {
             private final String[] argNames;
             public ArgsBuilderFromNames(String[] argNames) {
             public ArgsBuilderFromNames(String... argNames) {
                 this.argNames = argNames;
+            }
-...
+                        }
                     } else {
                         Code code = context.getCode(argName);
                         args.add(code);
                         if( code != null) {
                             args.add(code);
+                        }
+                    }
+                }
                 return args;
+            }
+        }
         private static class ArgsBuilderExpand extends ArgsBuilderFromNames {
         public static class ArgsBuilderExpand extends ArgsBuilderFromNames {
             public ArgsBuilderExpand(String[] argNames) {
             public ArgsBuilderExpand(String... argNames) {
                 super(argNames);
+            }
-...
+            }
+        }
         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.CALLER &&
                                     StringUtils.equalsIgnoreCase(CodeBlockFunction.NAME,((Caller)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.codeId = null;
             this.argsBuilder = null;
             this.stmtBuilder = null;
             this.name = name;
+        }
-...
+        }
         @Override
         public void code(String id, ArgsBuilder argsBuilder) {
             this.codeId = id;
             this.argsBuilder = argsBuilder;
         public void code(final String id, final ArgsBuilder argsBuilder) {
             this.builder(new StatementBuilderBase(id, argsBuilder));
+        }
         public void builder(StatementBuilder builder) {
             this.stmtBuilder = builder;
+        }
         @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) {
                 code = args.get(0);
             } else {
                 if (args.size() == 0) {
                     code = context.getCodeBuilder().function(codeId, null);
                 } else {
                     code = context.getCodeBuilder().function(codeId, args);
+                }
+            }
             Code code = this.stmtBuilder.build(context);
             return code;
+        }

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/DefaultCompiler.java
88	88	return DefaultCompiler.this.parse_expressions(separator);
89	89	}
90	90
	91	public boolean isReservedWord(String s) {
	92	return grammars.isReservedWord(s);
	93	}
91	94	}
92	95
93	96	private boolean objectAccessSupported;

     package org.gvsig.expressionevaluator.impl.grammars;
     import org.gvsig.expressionevaluator.Code;
     import org.gvsig.expressionevaluator.Code.Caller;
     import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_CAST;
     import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_LIST;
     import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_REGEXP;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;
     import org.gvsig.expressionevaluator.Grammar;
     import org.gvsig.expressionevaluator.Statement;
     import org.gvsig.expressionevaluator.impl.function.operator.RegExpOperator;
     import org.gvsig.expressionevaluator.Statement.StatementContext;
     import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;
     import org.gvsig.expressionevaluator.impl.DefaultStatement.StatementBuilderBase;
     import org.gvsig.expressionevaluator.impl.DefaultStatement.ArgsBuilderFromNames;
     import org.gvsig.expressionevaluator.impl.function.programming.IIFFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.LetFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CaseFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CodeBlockFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CodeBlockWithExceptFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.CreateFnFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.ForEachFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.ListFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.ReturnFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.TryFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.WhileFunction;
     import org.gvsig.expressionevaluator.spi.AbstractGrammarFactory;
-...
         private Grammar grammar;
         private class BeginStatementBuilder extends StatementBuilderBase {
             private final String blockID;
             private final String exceptID;
             public BeginStatementBuilder(String blockID, String exceptID) {
                 super(CodeBlockFunction.NAME, new ArgsBuilderFromNames(blockID));
                 this.blockID = blockID;
                 this.exceptID = exceptID;
+            }
             @Override
             public Code build(StatementContext context) {
                 Caller code = (Caller) super.build(context);
                 Code exceptCode = context.getCode(this.exceptID);
                 if( exceptCode==null ) {
                     return code;
+                }
                 BaseCodes args = (BaseCodes) code.parameters();
                 args.add(exceptCode);
                 code = context.getCodeBuilder().function(CodeBlockWithExceptFunction.NAME, args);
                 return code;
+            }
+        }
         public BasicGrammarFactory() {
             super("Basic", true);
+        }
-...
                 Statement stmt;
                 theGrammar.addReservedWord("BEGIN");
                 theGrammar.addReservedWord("EXCEPT");
                 theGrammar.addReservedWord("END");
                 theGrammar.addReservedWord("IF");
                 theGrammar.addReservedWord("THEN");
-...
                 theGrammar.addReservedWord("WHILE");
                 theGrammar.addReservedWord("CASE");
                 theGrammar.addReservedWord("WHEN");
                 theGrammar.addReservedWord("DEF");
                 theGrammar.addReservedWord("FOR");
                 theGrammar.addReservedWord("CREATE");
                 theGrammar.addReservedWord("FUNCTION");
                 theGrammar.addReservedWord("PROCEDURE");
                 theGrammar.addReservedWord("AS");
                 theGrammar.addReservedWord("MATCH");
                 theGrammar.addReservedWord("CAST");
                 theGrammar.addReservedWord("TRY");
                 theGrammar.addReservedWord("EXCEPT");
                 theGrammar.addReservedWord("SET");
                 theGrammar.addReservedWord("TO");
                 theGrammar.addReservedWord("$$"); // ???? Asi van las funciones
     /*
     BEGIN
       SET x = 0;
       FOR n in FETCH GEOMETRY FROM STORE 'view','points':
         IF ST_Intersects(n,GEOMETRY) THEN
           SET x = x+1
     EXCEPT
         SET x = -1
     END WITH VALUE x
     */
                 stmt = theGrammar.createStatement("BLOCK");
                 stmt.addRule(stmt.require_any_token("BEGIN"));
                 stmt.addRule(stmt.require_expressions("VALUES", ";"));
     //            stmt.addRule(stmt.optional_any_token("EXCEPT")
     //                    .addRuleOnTrue(stmt.require_expression("EXCEPT"))
     //            );
                 stmt.addRule(stmt.optional_any_token("EXCEPT")
                         .addRuleOnTrue(stmt.require_expressions("EXCEPT", ";"))
                 );
                 stmt.addRule(stmt.require_any_token("END"));
     //            stmt.addRule(stmt.optional_any_token("WITH")
     //                    .addRuleOnTrue(stmt.require_any_token("VALUE"))
     //                    .addRuleOnTrue(stmt.require_expression("VALUE"))
     //            );
                 stmt.code(
                         CodeBlockFunction.NAME,
     //                    stmt.args_names("EXCEPT","VALUE"),
                         stmt.args_expand("VALUES")
                 );
                 stmt.builder(new BeginStatementBuilder("VALUES","EXCEPT"));
                 theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("IF");
-...
                 theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("USERFUNCTION");
                 stmt.addRule(stmt.require_any_token("DEF", "CREATE"));
                 stmt.addRule(stmt.optional_any_token("FUNCTION"));
                 stmt.addRule(stmt.require_any_token("CREATE"));
                 stmt.addRule(stmt.optional_any_token("FUNCTION", "PROCEDURE"));
                 stmt.addRule(stmt.require_identifier("FUNCTION_NAME"));
                 stmt.addRule(stmt.require_any_token("("));
                 stmt.addRule(stmt.optional_any_token("("));
                 stmt.addRule(stmt.optional_identifiers("PARAM_NAMES", ","));
                 stmt.addRule(stmt.require_any_token(")"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 stmt.addRule(stmt.optional_any_token(")"));
                 stmt.addRule(stmt.require_any_token("AS"));
                 stmt.addRule(stmt.optional_any_token("$$","BEGIN"));
                 stmt.addRule(stmt.require_expressions("BODY", ";"));
                 stmt.addRule(stmt.require_any_token("END"));
                 stmt.addRule(stmt.optional_any_token("FUNCTION"));
                 stmt.addRule(stmt.require_any_token("$$", "END"));
                 stmt.addRule(stmt.optional_any_token("FUNCTION", "PROCEDURE"));
                 stmt.code(
                         CreateFnFunction.NAME,
                         stmt.args_names("FUNCTION_NAME","PARAM_NAMES","BODY")
-...
                 );
                 theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("TRY");
                 stmt.addRule(stmt.require_any_token("TRY"));
                 stmt.addRule(stmt.optional_any_token(":"));
                 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_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("TRY");
     //            stmt.addRule(stmt.require_any_token("TRY"));
     //            stmt.addRule(stmt.optional_any_token(":"));
     //            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_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.optional_any_token("=","TO"));
                 stmt.addRule(stmt.require_expression("VALUE"));
                 stmt.code(
                         LetFunction.NAME,
-...
                 );
                 theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("ARRAY");
                 stmt.addRule(stmt.require_any_token("ARRAY"));
                 stmt.addRule(stmt.require_any_token("["));
                 stmt.addRule(stmt.require_expressions("VALUES",","));
                 stmt.addRule(stmt.require_any_token("]"));
                 stmt.code(
                         FUNCTION_LIST,
                         stmt.args_expand("VALUES")
                 );
                 theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("CAST");
                 stmt.addRule(stmt.require_any_token("CAST"));
                 stmt.addRule(stmt.optional_any_token("(")

Application: gvSIG desktop

Revision 44384