/ - Diff - Application: gvSIG desktop - gvSIG

Revision 35713

tags/v1_11_0_Build_1306/libraries/libGDBMS/.cvsignore
	1	target
	2	drivers
	3	bin-test
	4	bin
0	5

     <?xml version="1.0" encoding="UTF-8"?>
     <projectDescription>
     	<name>libGDBMS</name>
     	<comment>GDBMS is a library that allows to make queries to data sets hosted in different formats and hosts. It follows the SQL92 syntax and extends it in several poins. Allows extensions to data sets types, queries, functions and data types.</comment>
     	<projects>
     	</projects>
     	<buildSpec>
     		<buildCommand>
     			<name>org.eclipse.jdt.core.javabuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     		<buildCommand>
     			<name>de.loskutov.FileSync.FSBuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     	</buildSpec>
     	<natures>
     		<nature>org.eclipse.jdt.core.javanature</nature>
     	</natures>
     </projectDescription>

     Pasos para generar la gram?tica
     	(1) borrar del paquete parser todo menos SimpleNode y
     TokenSupport
     	(2) arrancar el compilegrammar
     	(3) mover lo que genera en el defaultpackage al paquete
     	parser con el men? refactor de eclipse

     /* adder.jj Adding up numbers */
     options {
     	STATIC = false ;
+    }
     PARSER_BEGIN(SQLEngine)
     import java.io.FileInputStream;
     import java.io.FileNotFoundException;
     	public class SQLEngine {
     		public static void main( String[] args )
     		throws ParseException, TokenMgrError, FileNotFoundException {
     			SQLEngine parser = new SQLEngine( new FileInputStream(args[0] )) ;
     			parser.SQLStatement() ; }
       private void jjtreeOpenNodeScope( Node node )
+      {
         ((SimpleNode)node).first_token = getToken(1);
+      }
       private void jjtreeCloseNodeScope( Node node )
+      {
         ((SimpleNode)node).last_token = getToken(0);
+      }
     	public Node getRootNode(){
     		return jjtree.rootNode();
+    	}
+    		}
     PARSER_END(SQLEngine)
     /***********************************************************************
      * Token definitions
      ***********************************************************************/
     /* There may be tokens here which don't relate to SQL, but we needed for
        the rest of our project [Kevin] */
     SKIP:
+    {
         " "
       | "\n"
       | "\r"
       | "\t"
+    }
     SKIP:
+    {
       <COMMENT_LINE: "--" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >
+    }
     SKIP:
+    {
       <COMMENT_BLOCK: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
+    }
     TOKEN:  /* Keywords */
+    {
         < ALL: "all" >
       | < AND: "and" >
       | < AS: "as" >
       | < ASC: "asc" >
       | < BEGIN: "begin" >
       | < BETWEEN: "between" >
       | < BY: "by" >
       | < CUSTOM: "custom" >
       | < DESC: "desc" >
       | < DISTINCT: "distinct" >
       | < FROM: "from" >
       | < GROUP: "group" >
       | < HAVING: "having" >
       | < IN: "in" >
       | < IS: "is" >
       | < LIKE: "like" >
       | < NOT: "not" >
       | < NULL: "null" >
       | < OR: "or" >
       | < ORDER: "order" >
       | < SELECT: "select" >
       | < UNION: "union" >
       | < SPACES: "spaces" >
       | < TABLES: "tables" >
       | < WHERE: "where" >
     //***************************************************************************************
       | < DELETE: "delete" >
       | < EXISTS: "exists" >
       | < INSERT: "insert" >
       | < INTO: "into" >
       | < SET: "set" >
       | < UPDATE: "update" >
       | < VALUES: "values" >
+    }
     TOKEN:  /* Literals */
+    {
         < INTEGER_LITERAL: (["0"-"9"])+ >
       | < FLOATING_POINT_LITERAL:
               (["0"-"9"])+ "." (["0"-"9"])+ (<EXPONENT>)?
             | "." (["0"-"9"])+ (<EXPONENT>)?
             | (["0"-"9"])+ <EXPONENT>
             | (["0"-"9"])+ (<EXPONENT>)?
+        >
       | < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
       | < STRING_LITERAL: "'" (~["'"])* ( "''" (~["'"])* )* "'" >
+    }
     TOKEN:  /* Identifiers */
+    {
         < ID: ( <LETTER> )+ ( "_" | "$" | "#" | <DIGIT> | <LETTER> )* >
       | < #LETTER: ["A"-"Z", "a"-"z"] >
       | < #DIGIT: ["0"-"9"] >
+    }
     TOKEN:  /* Separators and operators */
+    {
         < ASSIGN: ":=" >
       | < CONCAT: "||" >
       | < SEMICOLON: ";" >
       | < DOT: "." >
       | < TILDE: "~" >
       | < LESS: "<" >
       | < LESSEQUAL: "<=" >
       | < GREATER: ">" >
       | < GREATEREQUAL: ">=" >
       | < EQUAL: "=" >
       | < NOTEQUAL: "!=" >
       | < NOTEQUAL2: "<>" >
       | < JOINPLUS: "(+)" >
       | < OPENPAREN: "(" >
       | < CLOSEPAREN: ")" >
       | < ASTERISK: "*" >
       | < SLASH: "/" >
       | < PLUS: "+" >
       | < MINUS: "-" >
       | < QUESTIONMARK: "?" >
       | <COMPARISON: <LESS>
            | <LESSEQUAL>
            | <GREATER>
            | <GREATEREQUAL>
            | <EQUAL>
            | <NOTEQUAL>
            | <NOTEQUAL2>
+        >
+    }
     void SQLAndExpr() :
     {}
+    {
       SQLNotExpr()
       ( <AND>
     	 SQLNotExpr() )*
+    }
     void SQLBetweenClause() :
     {}
+    {
       [ <NOT> ]
       <BETWEEN>
       SQLSumExpr()
       <AND>
       SQLSumExpr()
+    }
     void SQLColRef() :
+    {
+    }
+    {
       SQLLvalue()
+    }
     void SQLCompareExpr() :
+    {
+    }
+    {
+      (
         LOOKAHEAD (SQLSelect()) SQLSelect()
       | LOOKAHEAD (SQLColRef() <IS>) SQLIsClause()
       | LOOKAHEAD (<EXISTS>) SQLExistsClause()
       | SQLSumExpr() [ SQLCompareExprRight() ]
+      )
+    }
     void SQLCompareExprRight() :
     {}
+    {
+      (
         LOOKAHEAD(2) SQLLikeClause()
       | LOOKAHEAD(2) SQLInClause()
       | SQLLeftJoinClause()
       | LOOKAHEAD(SQLCompareOp() SQLSumExpr() "(+)") SQLRightJoinClause()
       | LOOKAHEAD(2) SQLBetweenClause()
       | SQLCompareOp()
         SQLSumExpr()
+      )
+    }
     void SQLCompareOp() :
     {}
+    {
+      (
         <EQUAL>
       | <NOTEQUAL>
       | <NOTEQUAL2>
       | <GREATER>
       | <GREATEREQUAL>
       | <LESS>
       | <LESSEQUAL>
+      )
+    }
     void SQLCustom() :
     {}
+    {
     	<CUSTOM> <ID>
     	<TABLES> SQLTableList()
     	<VALUES> SQLFunctionArgs()
+    }
     void SQLDelete() :
     {}
+    {
       <DELETE> <FROM>
       SQLTableList()
       [ SQLWhere() ]
+    }
     void SQLExistsClause() :
     {}
+    {
       <EXISTS>
       "(" SQLSelect() ")"
+    }
     void SQLFunction() :
     {}
+    {
       <ID>
         SQLFunctionArgs()
+    }
     void SQLFunctionArgs() :
     {}
+    {
       "("
       [ SQLSumExpr()
         ( ","
           SQLSumExpr() )*
+      ]
       ")"
+    }
     void SQLGroupBy() :
     {}
+    {
       <GROUP> <BY>
       SQLOrderByList()
+    }
     void SQLInClause() :
     {}
+    {
       [ <NOT> ]
       <IN>
       "("
       SQLLValueList()
       ")"
+    }
     void SQLInsert() :
     {}
+    {
       <INSERT> <INTO>
       SQLTableList()
+      [
         "("
         SQLSelectCols()
         ")"
         <VALUES>
+      ]
       "("
       SQLSelectCols()
       ")"
+    }
     void SQLIsClause() :
     {}
+    {
       SQLColRef()
       <IS>
       [ <NOT>  ]
       <NULL>
+    }
     void SQLLeftJoinClause() :
+    {
+    }
+    {
       "(+)" SQLCompareOp()
       SQLSumExpr()
+    }
     void SQLLikeClause() :
     {}
+    {
       [ <NOT>  ]
       <LIKE>
       SQLPattern()
+    }
     void SQLLiteral() :
+    {
+    }
+    {
       ( <STRING_LITERAL>
       | <INTEGER_LITERAL>
       | <FLOATING_POINT_LITERAL>
       | <SPACES>
       | <ASTERISK>
+      )
+    }
     void SQLLvalue() :
+    {
+    }
+    {
+      (
         SQLLvalueTerm()
+      )
+    }
     void SQLLvalueTerm() :
+    {
+    }
+    {
       <ID>
       ( <DOT> <ID> )*
+    }
     void SQLNotExpr() :
     {}
+    {
       [ <NOT> ]
       SQLCompareExpr()
+    }
     void SQLOrderBy() :
     {}
+    {
       <ORDER> <BY>
       SQLOrderByList()
+    }
     void SQLOrderByElem() :
     {}
+    {
       SQLColRef()
       [ SQLOrderDirection()]
+    }
     void SQLOrderByList() :
     {}
+    {
       SQLOrderByElem()
       ( LOOKAHEAD(2)
         ","
         SQLOrderByElem() )*
+    }
     void SQLOrderDirection() :
     {}
+    {
+      (
         <ASC>
       | <DESC>
+      )
+    }
     void SQLOrExpr() :
     {}
+    {
       SQLAndExpr()
       ( <OR>
     	SQLAndExpr() )*
+    }
     void SQLPattern() :
+    {
+    }
+    {
       ( <STRING_LITERAL>
       | "?"
       | SQLLvalue()
+      )
+    }
     void SQLProductExpr() :
     {}
+    {
       SQLUnaryExpr()
       ( ( "*"
         | "/"
         ) SQLUnaryExpr())*
+    }
     void SQLRightJoinClause() :
+    {
+    }
+    {
       SQLCompareOp()
       SQLSumExpr()
       "(+)"
+    }
     void SQLUnion() :
     {}
+    {
+    	(
     	SQLTableRef()
+    	|
     	<OPENPAREN>
     	SQLSelect()
     	<CLOSEPAREN>
+    	)
     	<UNION>
+    	(
     	SQLTableRef()
+    	|
     	<OPENPAREN>
     	SQLSelect()
     	<CLOSEPAREN>
+    	)
+    }
     void SQLSelect() :
     {}
+    {
       <SELECT>
       SQLSelectCols()
       [ <INTO>
         SQLSelectCols()
+      ]
       <FROM>
       SQLTableList()
       [ SQLWhere()]
       [ SQLGroupBy()]
       [ SQLOrderBy()]
+    }
     void SQLSelectCols() :
     {}
+    {
       [ <ALL>
       | <DISTINCT>
       ] ( "*" | SQLSelectList())
+    }
     void SQLSelectList() :
     {}
+    {
       SQLSumExpr() [<AS> <ID>]
       ( "," SQLSumExpr() [<AS> <ID>])*
+    }
     void SQLStatement() :
     {}
+    {
+      (
         SQLSelect()
       | SQLInsert()
       | SQLUpdate()
       | SQLDelete()
       | SQLUnion()
       | SQLCustom()
       ) ";"
+    }
     void SQLSumExpr() :
     {}
+    {
         SQLProductExpr()
          ( LOOKAHEAD(2) ( "+"
                         | "-"
                         | "||"
                         ) SQLProductExpr()  )*
+    }
     void SQLTableList() :
     {}
+    {
       SQLTableRef()
       ( LOOKAHEAD(2) "," SQLTableRef() )*
+    }
     void SQLTableRef() :
+    {
+    }
+    {
       (<ID>|<STRING_LITERAL>)
       [ <ID>
+      ]
+    }
     void SQLTerm() :
+    {
+    }
+    {
+      (
         "("
         SQLOrExpr()
         ")"
       | SQLFunction()
       | SQLColRef()
       | SQLLiteral()
+      )
+    }
     void SQLUnaryExpr() :
     {}
+    {
       [ ( "+"
         | "-"
+        )
       ] SQLTerm()
+    }
     void SQLUpdate() :
     {}
+    {
       <UPDATE>
       SQLTableList()
       <SET>
+      (
         LOOKAHEAD(SQLLvalue() "=") SQLUpdateAssignment()
+        [
           ","
+        ]
       )+
       [ SQLWhere() ]
+    }
     void SQLUpdateAssignment() :
     {}
+    {
       SQLLvalue() "="
+      (
           LOOKAHEAD(SQLTerm() <CONCAT> )
           SQLTerm()
           ( <CONCAT>
             SQLTerm() )+
           | SQLSumExpr() )
+    }
     void SQLLValueElement() :
     {}
+    {
       ( <NULL>
       | SQLSumExpr()
       | SQLSelect())
+    }
     void SQLLValueList() :
     {}
+    {
       SQLLValueElement()
       ( ","
         SQLLValueElement()
       )*
+    }
     void SQLWhere() :
     {}
+    {
       <WHERE> SQLOrExpr()
+    }

     /*@bgen(jjtree) Generated By:JJTree: Do not edit this line. sql.jj.jj */
     /*@egen*//* adder.jj Adding up numbers */
     options {
     	STATIC = false ;
+    }
     PARSER_BEGIN(SQLEngine)
     import java.io.FileInputStream;
     import java.io.FileNotFoundException;
     	public class SQLEngine/*@bgen(jjtree)*/implements SQLEngineTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
       protected JJTSQLEngineState jjtree = new JJTSQLEngineState();
     /*@egen*/
     		public static void main( String[] args )
     		throws ParseException, TokenMgrError, FileNotFoundException {
     			SQLEngine parser = new SQLEngine( new FileInputStream(args[0] )) ;
     			parser.SQLStatement() ; }
       private void jjtreeOpenNodeScope( Node node )
+      {
         ((SimpleNode)node).first_token = getToken(1);
+      }
       private void jjtreeCloseNodeScope( Node node )
+      {
         ((SimpleNode)node).last_token = getToken(0);
+      }
     	public Node getRootNode(){
     		return jjtree.rootNode();
+    	}
+    		}
     PARSER_END(SQLEngine)
     /***********************************************************************
      * Token definitions
      ***********************************************************************/
     /* There may be tokens here which don't relate to SQL, but we needed for
        the rest of our project [Kevin] */
     SKIP:
+    {
         " "
       | "\n"
       | "\r"
       | "\t"
+    }
     SKIP:
+    {
       <COMMENT_LINE: "--" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >
+    }
     SKIP:
+    {
       <COMMENT_BLOCK: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
+    }
     TOKEN:  /* Keywords */
+    {
         < ALL: "all" >
       | < AND: "and" >
       | < AS: "as" >
       | < ASC: "asc" >
       | < BEGIN: "begin" >
       | < BETWEEN: "between" >
       | < BY: "by" >
       | < CUSTOM: "custom" >
       | < DESC: "desc" >
       | < DISTINCT: "distinct" >
       | < FROM: "from" >
       | < GROUP: "group" >
       | < HAVING: "having" >
       | < IN: "in" >
       | < IS: "is" >
       | < LIKE: "like" >
       | < MAX: "max" >
       | < MIN: "min" >
       | < NOT: "not" >
       | < NULL: "null" >
       | < OR: "or" >
       | < ORDER: "order" >
       | < SELECT: "select" >
       | < UNION: "union" >
       | < SPACES: "spaces" >
       | < SUBSTR: "substr" >
       | < SUM: "sum" >
       | < TABLES: "tables" >
       | < UPPER: "upper" >
       | < WHERE: "where" >
     //***************************************************************************************
       | < COUNT: "count" >
       | < DELETE: "delete" >
       | < EXISTS: "exists" >
       | < INSERT: "insert" >
       | < INTO: "into" >
       | < LENGTH: "length" >
       | < LTRIM: "ltrim" >
       | < REPLACE: "replace" >
       | < RTRIM: "rtrim" >
       | < SET: "set" >
       | < UPDATE: "update" >
       | < VALUES: "values" >
+    }
     TOKEN:  /* Literals */
+    {
         < INTEGER_LITERAL: (["0"-"9"])+ >
       | < FLOATING_POINT_LITERAL:
               (["0"-"9"])+ "." (["0"-"9"])+ (<EXPONENT>)?
             | "." (["0"-"9"])+ (<EXPONENT>)?
             | (["0"-"9"])+ <EXPONENT>
             | (["0"-"9"])+ (<EXPONENT>)?
+        >
       | < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
       | < STRING_LITERAL: "'" (~["'"])* ( "''" (~["'"])* )* "'" >
+    }
     TOKEN:  /* Identifiers */
+    {
         < ID: ( <LETTER> )+ ( "_" | "$" | "#" | <DIGIT> | <LETTER> )* >
       | < #LETTER: ["A"-"Z", "a"-"z"] >
       | < #DIGIT: ["0"-"9"] >
+    }
     TOKEN:  /* Separators and operators */
+    {
         < ASSIGN: ":=" >
       | < CONCAT: "||" >
       | < SEMICOLON: ";" >
       | < DOT: "." >
       | < TILDE: "~" >
       | < LESS: "<" >
       | < LESSEQUAL: "<=" >
       | < GREATER: ">" >
       | < GREATEREQUAL: ">=" >
       | < EQUAL: "=" >
       | < NOTEQUAL: "!=" >
       | < NOTEQUAL2: "<>" >
       | < JOINPLUS: "(+)" >
       | < OPENPAREN: "(" >
       | < CLOSEPAREN: ")" >
       | < ASTERISK: "*" >
       | < SLASH: "/" >
       | < PLUS: "+" >
       | < MINUS: "-" >
       | < QUESTIONMARK: "?" >
       | <COMPARISON: <LESS>
            | <LESSEQUAL>
            | <GREATER>
            | <GREATEREQUAL>
            | <EQUAL>
            | <NOTEQUAL>
            | <NOTEQUAL2>
+        >
+    }
     void SQLAndExpr() :
     {/*@bgen(jjtree) SQLAndExpr */
       ASTSQLAndExpr jjtn000 = new ASTSQLAndExpr(JJTSQLANDEXPR);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLAndExpr */
       try {
     /*@egen*/
       SQLNotExpr()
       ( <AND>
     	 SQLNotExpr() )*/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLBetweenClause() :
     {/*@bgen(jjtree) SQLBetweenClause */
       ASTSQLBetweenClause jjtn000 = new ASTSQLBetweenClause(JJTSQLBETWEENCLAUSE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLBetweenClause */
       try {
     /*@egen*/
       [ <NOT> ]
       <BETWEEN>
       SQLSumExpr()
       <AND>
       SQLSumExpr()/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLColRef() :
     {/*@bgen(jjtree) SQLColRef */
       ASTSQLColRef jjtn000 = new ASTSQLColRef(JJTSQLCOLREF);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/
+    }
     {/*@bgen(jjtree) SQLColRef */
       try {
     /*@egen*/
       SQLLvalue()/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLCompareExpr() :
     {/*@bgen(jjtree) SQLCompareExpr */
       ASTSQLCompareExpr jjtn000 = new ASTSQLCompareExpr(JJTSQLCOMPAREEXPR);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/
+    }
     {/*@bgen(jjtree) SQLCompareExpr */
       try {
     /*@egen*/
+      (
         LOOKAHEAD (SQLSelect()) SQLSelect()
       | LOOKAHEAD (SQLColRef() <IS>) SQLIsClause()
       | LOOKAHEAD (<EXISTS>) SQLExistsClause()
       | SQLSumExpr() [ SQLCompareExprRight() ]
       )/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLCompareExprRight() :
     {/*@bgen(jjtree) SQLCompareExprRight */
       ASTSQLCompareExprRight jjtn000 = new ASTSQLCompareExprRight(JJTSQLCOMPAREEXPRRIGHT);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLCompareExprRight */
       try {
     /*@egen*/
+      (
         LOOKAHEAD(2) SQLLikeClause()
       | LOOKAHEAD(2) SQLInClause()
       | SQLLeftJoinClause()
       | LOOKAHEAD(SQLCompareOp() SQLSumExpr() "(+)") SQLRightJoinClause()
       | LOOKAHEAD(2) SQLBetweenClause()
       | SQLCompareOp()
         SQLSumExpr()
       )/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLCompareOp() :
     {/*@bgen(jjtree) SQLCompareOp */
       ASTSQLCompareOp jjtn000 = new ASTSQLCompareOp(JJTSQLCOMPAREOP);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLCompareOp */
       try {
     /*@egen*/
+      (
         <EQUAL>
       | <NOTEQUAL>
       | <NOTEQUAL2>
       | <GREATER>
       | <GREATEREQUAL>
       | <LESS>
       | <LESSEQUAL>
       )/*@bgen(jjtree)*/
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLCustom() :
     {/*@bgen(jjtree) SQLCustom */
       ASTSQLCustom jjtn000 = new ASTSQLCustom(JJTSQLCUSTOM);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLCustom */
             try {
     /*@egen*/
     	<CUSTOM> <ID>
     	<TABLES> SQLTableList()
     	<VALUES> SQLFunctionArgs()/*@bgen(jjtree)*/
             } catch (Throwable jjte000) {
               if (jjtc000) {
                 jjtree.clearNodeScope(jjtn000);
                 jjtc000 = false;
               } else {
                 jjtree.popNode();
+              }
               if (jjte000 instanceof RuntimeException) {
                 throw (RuntimeException)jjte000;
+              }
               if (jjte000 instanceof ParseException) {
                 throw (ParseException)jjte000;
+              }
               throw (Error)jjte000;
             } finally {
               if (jjtc000) {
                 jjtree.closeNodeScope(jjtn000, true);
                 jjtreeCloseNodeScope(jjtn000);
+              }
+            }
     /*@egen*/
+    }
     void SQLDelete() :
     {/*@bgen(jjtree) SQLDelete */
       ASTSQLDelete jjtn000 = new ASTSQLDelete(JJTSQLDELETE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLDelete */
       try {
     /*@egen*/
       <DELETE> <FROM>
       SQLTableList()
       [ SQLWhere() ]/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLExistsClause() :
     {/*@bgen(jjtree) SQLExistsClause */
       ASTSQLExistsClause jjtn000 = new ASTSQLExistsClause(JJTSQLEXISTSCLAUSE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLExistsClause */
       try {
     /*@egen*/
       <EXISTS>
       "(" SQLSelect() ")"/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLFunction() :
     {/*@bgen(jjtree) SQLFunction */
       ASTSQLFunction jjtn000 = new ASTSQLFunction(JJTSQLFUNCTION);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLFunction */
       try {
     /*@egen*/
       <ID>
         SQLFunctionArgs()/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLFunctionArgs() :
     {/*@bgen(jjtree) SQLFunctionArgs */
       ASTSQLFunctionArgs jjtn000 = new ASTSQLFunctionArgs(JJTSQLFUNCTIONARGS);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLFunctionArgs */
       try {
     /*@egen*/
       "("
       [ SQLSumExpr()
         ( ","
           SQLSumExpr() )*
+      ]
       ")"/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLGroupBy() :
     {/*@bgen(jjtree) SQLGroupBy */
       ASTSQLGroupBy jjtn000 = new ASTSQLGroupBy(JJTSQLGROUPBY);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLGroupBy */
       try {
     /*@egen*/
       <GROUP> <BY>
       SQLOrderByList()/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLInClause() :
     {/*@bgen(jjtree) SQLInClause */
       ASTSQLInClause jjtn000 = new ASTSQLInClause(JJTSQLINCLAUSE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLInClause */
       try {
     /*@egen*/
       [ <NOT> ]
       <IN>
       "("
       SQLLValueList()
       ")"/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLInsert() :
     {/*@bgen(jjtree) SQLInsert */
       ASTSQLInsert jjtn000 = new ASTSQLInsert(JJTSQLINSERT);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLInsert */
       try {
     /*@egen*/
       <INSERT> <INTO>
       SQLTableList()
+      [
         "("
         SQLSelectCols()
         ")"
         <VALUES>
+      ]
       "("
       SQLSelectCols()
       ")"/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLIsClause() :
     {/*@bgen(jjtree) SQLIsClause */
       ASTSQLIsClause jjtn000 = new ASTSQLIsClause(JJTSQLISCLAUSE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLIsClause */
       try {
     /*@egen*/
       SQLColRef()
       <IS>
       [ <NOT>  ]
       <NULL>/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLLeftJoinClause() :
     {/*@bgen(jjtree) SQLLeftJoinClause */
       ASTSQLLeftJoinClause jjtn000 = new ASTSQLLeftJoinClause(JJTSQLLEFTJOINCLAUSE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/
+    }
     {/*@bgen(jjtree) SQLLeftJoinClause */
       try {
     /*@egen*/
       "(+)" SQLCompareOp()
       SQLSumExpr()/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLLikeClause() :
     {/*@bgen(jjtree) SQLLikeClause */
       ASTSQLLikeClause jjtn000 = new ASTSQLLikeClause(JJTSQLLIKECLAUSE);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/}
     {/*@bgen(jjtree) SQLLikeClause */
       try {
     /*@egen*/
       [ <NOT>  ]
       <LIKE>
       SQLPattern()/*@bgen(jjtree)*/
       } catch (Throwable jjte000) {
         if (jjtc000) {
           jjtree.clearNodeScope(jjtn000);
           jjtc000 = false;
         } else {
           jjtree.popNode();
+        }
         if (jjte000 instanceof RuntimeException) {
           throw (RuntimeException)jjte000;
+        }
         if (jjte000 instanceof ParseException) {
           throw (ParseException)jjte000;
+        }
         throw (Error)jjte000;
       } finally {
         if (jjtc000) {
           jjtree.closeNodeScope(jjtn000, true);
           jjtreeCloseNodeScope(jjtn000);
+        }
+      }
     /*@egen*/
+    }
     void SQLLiteral() :
     {/*@bgen(jjtree) SQLLiteral */
       ASTSQLLiteral jjtn000 = new ASTSQLLiteral(JJTSQLLITERAL);
       boolean jjtc000 = true;
       jjtree.openNodeScope(jjtn000);
       jjtreeOpenNodeScope(jjtn000);
     /*@egen*/
+    }
     {/*@bgen(jjtree) SQLLiteral */
       try {
     /*@egen*/
       ( <STRING_LITERAL>
       | <INTEGER_LITERAL>
       | <FLOATING_POINT_LITERAL>

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff