jackrabbit-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ju...@apache.org
Subject svn commit: r1210476 [4/7] - in /jackrabbit/trunk/jackrabbit-spi-commons: ./ src/main/java/org/apache/jackrabbit/spi/commons/query/sql/ src/main/java/org/apache/jackrabbit/spi/commons/query/xpath/
Date Mon, 05 Dec 2011 14:36:48 GMT
Added: jackrabbit/trunk/jackrabbit-spi-commons/src/main/java/org/apache/jackrabbit/spi/commons/query/xpath/XPath.java
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/jackrabbit-spi-commons/src/main/java/org/apache/jackrabbit/spi/commons/query/xpath/XPath.java?rev=1210476&view=auto
==============================================================================
--- jackrabbit/trunk/jackrabbit-spi-commons/src/main/java/org/apache/jackrabbit/spi/commons/query/xpath/XPath.java (added)
+++ jackrabbit/trunk/jackrabbit-spi-commons/src/main/java/org/apache/jackrabbit/spi/commons/query/xpath/XPath.java Mon Dec  5 14:36:46 2011
@@ -0,0 +1,9259 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. XPath.java */
+        package org.apache.jackrabbit.spi.commons.query.xpath;
+
+import java.io.*;
+import java.util.Stack;
+import java.util.Vector;
+
+public class XPath/*@bgen(jjtree)*/implements XPathTreeConstants, XPathConstants {/*@bgen(jjtree)*/
+  protected JJTXPathState jjtree = new JJTXPathState();
+
+      boolean m_isMatchPattern = false;
+      boolean isStep = false;
+
+                  Stack binaryTokenStack = new Stack();
+
+                  public Node createNode(int id) {
+                          return null;
+                  }
+
+
+
+                  public static void main(String args[])
+                     throws Exception
+                  {
+         int numberArgsLeft = args.length;
+         int argsStart = 0;
+         boolean isMatchParser = false;
+         if(numberArgsLeft > 0)
+         {
+           if(args[argsStart].equals("-match"))
+           {
+             isMatchParser = true;
+             System.out.println("Match Pattern Parser");
+             argsStart++;
+             numberArgsLeft--;
+           }
+         }
+                     if(numberArgsLeft > 0)
+                    {
+                        try
+                        {
+        final boolean dumpTree = true;
+        if(args[0].endsWith(".xquery"))
+        {
+          System.out.println("Running test for: "+args[0]);
+          File file = new File(args[0]);
+          FileInputStream fis = new FileInputStream(file);
+          XPath parser = new XPath(fis);
+          SimpleNode tree = parser.XPath2();
+          if(dumpTree)
+            tree.dump("|") ;
+        }
+        else
+        {
+                                for(int i = argsStart; i < args.length; i++)
+                                {
+                                        System.out.println();
+                                        System.out.println("Test["+i+"]: "+args[i]);
+                                        XPath parser = new XPath(new java.io.StringBufferInputStream(args[i]));
+          SimpleNode tree;
+          if(isMatchParser)
+          {
+                                        tree = parser.XPath2();
+          }
+          else
+          {
+                                        tree = parser.XPath2();
+          }
+                                        ((SimpleNode)tree.jjtGetChild(0)).dump("|") ;
+                                }
+                                System.out.println("Success!!!!");
+        }
+                        }
+                        catch(ParseException pe)
+                        {
+                                System.err.println(pe.getMessage());
+                        }
+                        return;
+                   }
+                    java.io.DataInputStream dinput = new java.io.DataInputStream(System.in);
+                    while(true)
+                    {
+                          try
+                          {
+                              System.err.println("Type Expression: ");
+                              String input =  dinput.readLine();
+                              if(null == input || input.trim().length() == 0)
+                                break;
+                              XPath parser = new XPath(new java.io.StringBufferInputStream(input));
+          SimpleNode tree;
+          if(isMatchParser)
+          {
+                                        tree = parser.XPath2();
+          }
+          else
+          {
+                                        tree = parser.XPath2();
+          }
+                              ((SimpleNode)tree.jjtGetChild(0)).dump("|") ;
+                          }
+                          catch(ParseException pe)
+                          {
+                                System.err.println(pe.getMessage());
+                          }
+                          catch(Exception e)
+                          {
+                                System.err.println(e.getMessage());
+                          }
+                    }
+                  }
+
+  final public SimpleNode XPath2() throws ParseException {
+                 /*@bgen(jjtree) XPath2 */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTXPATH2);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      QueryList();
+      jj_consume_token(0);
+                    jjtree.closeNodeScope(jjtn000, true);
+                    jjtc000 = false;
+                    {if (true) return jjtn000 ;}
+    } catch (Throwable jjte000) {
+                    if (jjtc000) {
+                      jjtree.clearNodeScope(jjtn000);
+                      jjtc000 = false;
+                    } else {
+                      jjtree.popNode();
+                    }
+                    if (jjte000 instanceof RuntimeException) {
+                      {if (true) throw (RuntimeException)jjte000;}
+                    }
+                    if (jjte000 instanceof ParseException) {
+                      {if (true) throw (ParseException)jjte000;}
+                    }
+                    {if (true) throw (Error)jjte000;}
+    } finally {
+                    if (jjtc000) {
+                      jjtree.closeNodeScope(jjtn000, true);
+                    }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void QueryList() throws ParseException {
+ /*@bgen(jjtree) QueryList */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTQUERYLIST);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      Module();
+      label_1:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case QuerySeparator:
+          ;
+          break;
+        default:
+          jj_la1[0] = jj_gen;
+          break label_1;
+        }
+        jj_consume_token(QuerySeparator);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IntegerLiteral:
+        case DecimalLiteral:
+        case DoubleLiteral:
+        case StringLiteral:
+        case XQueryVersion:
+        case ModuleNamespace:
+        case ProcessingInstructionStart:
+        case ProcessingInstructionStartForElementContent:
+        case AxisChild:
+        case AxisDescendant:
+        case AxisParent:
+        case AxisAttribute:
+        case AxisSelf:
+        case AxisDescendantOrSelf:
+        case AxisAncestor:
+        case AxisFollowingSibling:
+        case AxisPrecedingSibling:
+        case AxisFollowing:
+        case AxisPreceding:
+        case AxisAncestorOrSelf:
+        case DefineFunction:
+        case DeclareOrdering:
+        case DeclareDefaultOrderingEmpty:
+        case DeclareInheritNamespaces:
+        case VariableIndicator:
+        case DeclareConstruction:
+        case DeclareXMLSpace:
+        case DeclareBaseURI:
+        case DeclareNamespace:
+        case ElementType:
+        case AttributeType:
+        case SchemaElementType:
+        case SchemaAttributeType:
+        case OrderedOpen:
+        case UnorderedOpen:
+        case ElementQNameLbrace:
+        case AttributeQNameLbrace:
+        case PINCNameLbrace:
+        case PILbrace:
+        case CommentLbrace:
+        case ElementLbrace:
+        case AttributeLbrace:
+        case TextLbrace:
+        case DeclareCollation:
+        case DeclareDefaultElement:
+        case DeclareDefaultFunction:
+        case ImportSchemaToken:
+        case ImportModuleToken:
+        case Star:
+        case NCNameColonStar:
+        case StarColonNCName:
+        case Root:
+        case RootDescendants:
+        case UnaryMinus:
+        case UnaryPlus:
+        case Lpar:
+        case At:
+        case Some:
+        case Every:
+        case ForVariable:
+        case LetVariable:
+        case ValidateLbrace:
+        case ValidateSchemaMode:
+        case DocumentLpar:
+        case DocumentLparForKindTest:
+        case DocumentLbrace:
+        case NodeLpar:
+        case CommentLpar:
+        case TextLpar:
+        case ProcessingInstructionLpar:
+        case ElementTypeForKindTest:
+        case ElementTypeForDocumentTest:
+        case AttributeTypeForKindTest:
+        case SchemaElementTypeForKindTest:
+        case SchemaElementTypeForDocumentTest:
+        case SchemaAttributeTypeForKindTest:
+        case ProcessingInstructionLparForKindTest:
+        case TextLparForKindTest:
+        case CommentLparForKindTest:
+        case NodeLparForKindTest:
+        case IfLpar:
+        case TypeswitchLpar:
+        case Dot:
+        case DotDot:
+        case DefineVariable:
+        case QNameLpar:
+        case StartTagOpen:
+        case StartTagOpenRoot:
+        case XmlCommentStart:
+        case XmlCommentStartForElementContent:
+        case QName:
+          Module();
+          break;
+        default:
+          jj_la1[1] = jj_gen;
+          ;
+        }
+      }
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void Module() throws ParseException {
+ /*@bgen(jjtree) Module */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTMODULE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case XQueryVersion:
+        VersionDecl();
+        break;
+      default:
+        jj_la1[2] = jj_gen;
+        ;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IntegerLiteral:
+      case DecimalLiteral:
+      case DoubleLiteral:
+      case StringLiteral:
+      case ProcessingInstructionStart:
+      case ProcessingInstructionStartForElementContent:
+      case AxisChild:
+      case AxisDescendant:
+      case AxisParent:
+      case AxisAttribute:
+      case AxisSelf:
+      case AxisDescendantOrSelf:
+      case AxisAncestor:
+      case AxisFollowingSibling:
+      case AxisPrecedingSibling:
+      case AxisFollowing:
+      case AxisPreceding:
+      case AxisAncestorOrSelf:
+      case DefineFunction:
+      case DeclareOrdering:
+      case DeclareDefaultOrderingEmpty:
+      case DeclareInheritNamespaces:
+      case VariableIndicator:
+      case DeclareConstruction:
+      case DeclareXMLSpace:
+      case DeclareBaseURI:
+      case DeclareNamespace:
+      case ElementType:
+      case AttributeType:
+      case SchemaElementType:
+      case SchemaAttributeType:
+      case OrderedOpen:
+      case UnorderedOpen:
+      case ElementQNameLbrace:
+      case AttributeQNameLbrace:
+      case PINCNameLbrace:
+      case PILbrace:
+      case CommentLbrace:
+      case ElementLbrace:
+      case AttributeLbrace:
+      case TextLbrace:
+      case DeclareCollation:
+      case DeclareDefaultElement:
+      case DeclareDefaultFunction:
+      case ImportSchemaToken:
+      case ImportModuleToken:
+      case Star:
+      case NCNameColonStar:
+      case StarColonNCName:
+      case Root:
+      case RootDescendants:
+      case UnaryMinus:
+      case UnaryPlus:
+      case Lpar:
+      case At:
+      case Some:
+      case Every:
+      case ForVariable:
+      case LetVariable:
+      case ValidateLbrace:
+      case ValidateSchemaMode:
+      case DocumentLpar:
+      case DocumentLparForKindTest:
+      case DocumentLbrace:
+      case NodeLpar:
+      case CommentLpar:
+      case TextLpar:
+      case ProcessingInstructionLpar:
+      case ElementTypeForKindTest:
+      case ElementTypeForDocumentTest:
+      case AttributeTypeForKindTest:
+      case SchemaElementTypeForKindTest:
+      case SchemaElementTypeForDocumentTest:
+      case SchemaAttributeTypeForKindTest:
+      case ProcessingInstructionLparForKindTest:
+      case TextLparForKindTest:
+      case CommentLparForKindTest:
+      case NodeLparForKindTest:
+      case IfLpar:
+      case TypeswitchLpar:
+      case Dot:
+      case DotDot:
+      case DefineVariable:
+      case QNameLpar:
+      case StartTagOpen:
+      case StartTagOpenRoot:
+      case XmlCommentStart:
+      case XmlCommentStartForElementContent:
+      case QName:
+        MainModule();
+        break;
+      case ModuleNamespace:
+        LibraryModule();
+        break;
+      default:
+        jj_la1[3] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void VersionDecl() throws ParseException {
+ /*@bgen(jjtree) VersionDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTVERSIONDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(XQueryVersion);
+                   SimpleNode jjtn001 = new SimpleNode(this, JJTXQUERYVERSION);
+                   boolean jjtc001 = true;
+                   jjtree.openNodeScope(jjtn001);
+      try {
+                   jjtree.closeNodeScope(jjtn001,  true);
+                   jjtc001 = false;
+                  jjtn001.processToken(token);
+      } finally {
+                   if (jjtc001) {
+                     jjtree.closeNodeScope(jjtn001,  true);
+                   }
+      }
+      jj_consume_token(StringLiteralForVersion);
+                                                                                                SimpleNode jjtn002 = new SimpleNode(this, JJTSTRINGLITERALFORVERSION);
+                                                                                                boolean jjtc002 = true;
+                                                                                                jjtree.openNodeScope(jjtn002);
+      try {
+                                                                                                jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                jjtc002 = false;
+                                                                          jjtn002.processToken(token);
+      } finally {
+                                                                                                if (jjtc002) {
+                                                                                                  jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case XQueryEncoding:
+        jj_consume_token(XQueryEncoding);
+                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTXQUERYENCODING);
+                                                                                                                                                                               boolean jjtc003 = true;
+                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                               jjtc003 = false;
+                                                                                                                          jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                                               if (jjtc003) {
+                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                               }
+        }
+        jj_consume_token(StringLiteralForVersion);
+                                                                                                                                                                                                                                                             SimpleNode jjtn004 = new SimpleNode(this, JJTSTRINGLITERALFORVERSION);
+                                                                                                                                                                                                                                                             boolean jjtc004 = true;
+                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn004);
+        try {
+                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                                             jjtc004 = false;
+                                                                                                                                                                                  jjtn004.processToken(token);
+        } finally {
+                                                                                                                                                                                                                                                             if (jjtc004) {
+                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                                             }
+        }
+        break;
+      default:
+        jj_la1[4] = jj_gen;
+        ;
+      }
+      Separator();
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void MainModule() throws ParseException {
+ /*@bgen(jjtree) MainModule */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTMAINMODULE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      Prolog();
+      QueryBody();
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void LibraryModule() throws ParseException {
+ /*@bgen(jjtree) LibraryModule */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTLIBRARYMODULE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      ModuleDecl();
+      Prolog();
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void ModuleDecl() throws ParseException {
+ /*@bgen(jjtree) ModuleDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTMODULEDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(ModuleNamespace);
+                     SimpleNode jjtn001 = new SimpleNode(this, JJTMODULENAMESPACE);
+                     boolean jjtc001 = true;
+                     jjtree.openNodeScope(jjtn001);
+      try {
+                     jjtree.closeNodeScope(jjtn001,  true);
+                     jjtc001 = false;
+                    jjtn001.processToken(token);
+      } finally {
+                     if (jjtc001) {
+                       jjtree.closeNodeScope(jjtn001,  true);
+                     }
+      }
+      jj_consume_token(NCNameForPrefix);
+                                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
+                                                                                            boolean jjtc002 = true;
+                                                                                            jjtree.openNodeScope(jjtn002);
+      try {
+                                                                                            jjtree.closeNodeScope(jjtn002,  true);
+                                                                                            jjtc002 = false;
+                                                                    jjtn002.processToken(token);
+      } finally {
+                                                                                            if (jjtc002) {
+                                                                                              jjtree.closeNodeScope(jjtn002,  true);
+                                                                                            }
+      }
+      jj_consume_token(AssignEquals);
+                                                                                                                                                                SimpleNode jjtn003 = new SimpleNode(this, JJTASSIGNEQUALS);
+                                                                                                                                                                boolean jjtc003 = true;
+                                                                                                                                                                jjtree.openNodeScope(jjtn003);
+      try {
+                                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                jjtc003 = false;
+                                                                                                                 jjtn003.processToken(token);
+      } finally {
+                                                                                                                                                                if (jjtc003) {
+                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                }
+      }
+      jj_consume_token(URLLiteral);
+                                                                                                                                                                                                                               SimpleNode jjtn004 = new SimpleNode(this, JJTURLLITERAL);
+                                                                                                                                                                                                                               boolean jjtc004 = true;
+                                                                                                                                                                                                                               jjtree.openNodeScope(jjtn004);
+      try {
+                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                               jjtc004 = false;
+                                                                                                                                                            jjtn004.processToken(token);
+      } finally {
+                                                                                                                                                                                                                               if (jjtc004) {
+                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                               }
+      }
+      Separator();
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void Prolog() throws ParseException {
+ /*@bgen(jjtree) Prolog */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTPROLOG);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      label_2:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case DeclareOrdering:
+        case DeclareDefaultOrderingEmpty:
+        case DeclareInheritNamespaces:
+        case DeclareConstruction:
+        case DeclareXMLSpace:
+        case DeclareBaseURI:
+        case DeclareCollation:
+          ;
+          break;
+        default:
+          jj_la1[5] = jj_gen;
+          break label_2;
+        }
+        Setter();
+        Separator();
+      }
+      label_3:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case DeclareNamespace:
+        case DeclareDefaultElement:
+        case DeclareDefaultFunction:
+        case ImportSchemaToken:
+        case ImportModuleToken:
+          ;
+          break;
+        default:
+          jj_la1[6] = jj_gen;
+          break label_3;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case ImportSchemaToken:
+        case ImportModuleToken:
+          Import();
+          break;
+        case DeclareNamespace:
+          NamespaceDecl();
+          break;
+        case DeclareDefaultElement:
+        case DeclareDefaultFunction:
+          DefaultNamespaceDecl();
+          break;
+        default:
+          jj_la1[7] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        Separator();
+      }
+      label_4:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case DefineFunction:
+        case DefineVariable:
+          ;
+          break;
+        default:
+          jj_la1[8] = jj_gen;
+          break label_4;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case DefineVariable:
+          VarDecl();
+          break;
+        case DefineFunction:
+          FunctionDecl();
+          break;
+        default:
+          jj_la1[9] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        Separator();
+      }
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void Setter() throws ParseException {
+ /*@bgen(jjtree) Setter */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTSETTER);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case DeclareXMLSpace:
+        XMLSpaceDecl();
+        break;
+      case DeclareCollation:
+        DefaultCollationDecl();
+        break;
+      case DeclareBaseURI:
+        BaseURIDecl();
+        break;
+      case DeclareConstruction:
+        ConstructionDecl();
+        break;
+      case DeclareOrdering:
+        OrderingModeDecl();
+        break;
+      case DeclareDefaultOrderingEmpty:
+        EmptyOrderingDecl();
+        break;
+      case DeclareInheritNamespaces:
+        InheritNamespacesDecl();
+        break;
+      default:
+        jj_la1[10] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void Import() throws ParseException {
+ /*@bgen(jjtree) Import */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTIMPORT);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case ImportSchemaToken:
+        SchemaImport();
+        break;
+      case ImportModuleToken:
+        ModuleImport();
+        break;
+      default:
+        jj_la1[11] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void Separator() throws ParseException {
+ /*@bgen(jjtree) Separator */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTSEPARATOR);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(SemiColon);
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void NamespaceDecl() throws ParseException {
+ /*@bgen(jjtree) NamespaceDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTNAMESPACEDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareNamespace);
+                      SimpleNode jjtn001 = new SimpleNode(this, JJTDECLARENAMESPACE);
+                      boolean jjtc001 = true;
+                      jjtree.openNodeScope(jjtn001);
+      try {
+                      jjtree.closeNodeScope(jjtn001,  true);
+                      jjtc001 = false;
+                     jjtn001.processToken(token);
+      } finally {
+                      if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001,  true);
+                      }
+      }
+      jj_consume_token(NCNameForPrefix);
+                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
+                                                                                              boolean jjtc002 = true;
+                                                                                              jjtree.openNodeScope(jjtn002);
+      try {
+                                                                                              jjtree.closeNodeScope(jjtn002,  true);
+                                                                                              jjtc002 = false;
+                                                                     jjtn002.processToken(token);
+      } finally {
+                                                                                              if (jjtc002) {
+                                                                                                jjtree.closeNodeScope(jjtn002,  true);
+                                                                                              }
+      }
+      jj_consume_token(AssignEquals);
+                                                                                                                                                                  SimpleNode jjtn003 = new SimpleNode(this, JJTASSIGNEQUALS);
+                                                                                                                                                                  boolean jjtc003 = true;
+                                                                                                                                                                  jjtree.openNodeScope(jjtn003);
+      try {
+                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                  jjtc003 = false;
+                                                                                                                  jjtn003.processToken(token);
+      } finally {
+                                                                                                                                                                  if (jjtc003) {
+                                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                  }
+      }
+      jj_consume_token(URLLiteral);
+                                                                                                                                                                                                                                 SimpleNode jjtn004 = new SimpleNode(this, JJTURLLITERAL);
+                                                                                                                                                                                                                                 boolean jjtc004 = true;
+                                                                                                                                                                                                                                 jjtree.openNodeScope(jjtn004);
+      try {
+                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                 jjtc004 = false;
+                                                                                                                                                             jjtn004.processToken(token);
+      } finally {
+                                                                                                                                                                                                                                 if (jjtc004) {
+                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                 }
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void XMLSpaceDecl() throws ParseException {
+ /*@bgen(jjtree) XMLSpaceDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTXMLSPACEDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareXMLSpace);
+                     SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREXMLSPACE);
+                     boolean jjtc001 = true;
+                     jjtree.openNodeScope(jjtn001);
+      try {
+                     jjtree.closeNodeScope(jjtn001,  true);
+                     jjtc001 = false;
+                    jjtn001.processToken(token);
+      } finally {
+                     if (jjtc001) {
+                       jjtree.closeNodeScope(jjtn001,  true);
+                     }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case XMLSpacePreserve:
+        jj_consume_token(XMLSpacePreserve);
+                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTXMLSPACEPRESERVE);
+                                                                                              boolean jjtc002 = true;
+                                                                                              jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                              jjtree.closeNodeScope(jjtn002,  true);
+                                                                                              jjtc002 = false;
+                                                                      jjtn002.processToken(token);
+        } finally {
+                                                                                              if (jjtc002) {
+                                                                                                jjtree.closeNodeScope(jjtn002,  true);
+                                                                                              }
+        }
+        break;
+      case XMLSpaceStrip:
+        jj_consume_token(XMLSpaceStrip);
+                                                                                                                                                                      SimpleNode jjtn003 = new SimpleNode(this, JJTXMLSPACESTRIP);
+                                                                                                                                                                      boolean jjtc003 = true;
+                                                                                                                                                                      jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                                      jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                      jjtc003 = false;
+                                                                                                                      jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                                      if (jjtc003) {
+                                                                                                                                                                        jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                      }
+        }
+        break;
+      default:
+        jj_la1[12] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void DefaultNamespaceDecl() throws ParseException {
+ /*@bgen(jjtree) DefaultNamespaceDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTDEFAULTNAMESPACEDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case DeclareDefaultElement:
+        jj_consume_token(DeclareDefaultElement);
+                            SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREDEFAULTELEMENT);
+                            boolean jjtc001 = true;
+                            jjtree.openNodeScope(jjtn001);
+        try {
+                            jjtree.closeNodeScope(jjtn001,  true);
+                            jjtc001 = false;
+                           jjtn001.processToken(token);
+        } finally {
+                            if (jjtc001) {
+                              jjtree.closeNodeScope(jjtn001,  true);
+                            }
+        }
+        break;
+      case DeclareDefaultFunction:
+        jj_consume_token(DeclareDefaultFunction);
+                                                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTDECLAREDEFAULTFUNCTION);
+                                                                                                                  boolean jjtc002 = true;
+                                                                                                                  jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                                                  jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                                  jjtc002 = false;
+                                                                                    jjtn002.processToken(token);
+        } finally {
+                                                                                                                  if (jjtc002) {
+                                                                                                                    jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                                  }
+        }
+        break;
+      default:
+        jj_la1[13] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      jj_consume_token(Namespace);
+                                                                                                                                                                                           SimpleNode jjtn003 = new SimpleNode(this, JJTNAMESPACE);
+                                                                                                                                                                                           boolean jjtc003 = true;
+                                                                                                                                                                                           jjtree.openNodeScope(jjtn003);
+      try {
+                                                                                                                                                                                           jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                                           jjtc003 = false;
+                                                                                                                               jjtn003.processToken(token);
+      } finally {
+                                                                                                                                                                                           if (jjtc003) {
+                                                                                                                                                                                             jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                                           }
+      }
+      jj_consume_token(URLLiteral);
+                                                                                                                                                                                                                                                       SimpleNode jjtn004 = new SimpleNode(this, JJTURLLITERAL);
+                                                                                                                                                                                                                                                       boolean jjtc004 = true;
+                                                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn004);
+      try {
+                                                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                                       jjtc004 = false;
+                                                                                                                                                                          jjtn004.processToken(token);
+      } finally {
+                                                                                                                                                                                                                                                       if (jjtc004) {
+                                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                                       }
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void OrderingModeDecl() throws ParseException {
+ /*@bgen(jjtree) OrderingModeDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTORDERINGMODEDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareOrdering);
+                     SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREORDERING);
+                     boolean jjtc001 = true;
+                     jjtree.openNodeScope(jjtn001);
+      try {
+                     jjtree.closeNodeScope(jjtn001,  true);
+                     jjtc001 = false;
+                    jjtn001.processToken(token);
+      } finally {
+                     if (jjtc001) {
+                       jjtree.closeNodeScope(jjtn001,  true);
+                     }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case Ordered:
+        jj_consume_token(Ordered);
+                                                                                     SimpleNode jjtn002 = new SimpleNode(this, JJTORDERED);
+                                                                                     boolean jjtc002 = true;
+                                                                                     jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                     jjtree.closeNodeScope(jjtn002,  true);
+                                                                                     jjtc002 = false;
+                                                             jjtn002.processToken(token);
+        } finally {
+                                                                                     if (jjtc002) {
+                                                                                       jjtree.closeNodeScope(jjtn002,  true);
+                                                                                     }
+        }
+        break;
+      case Unordered:
+        jj_consume_token(Unordered);
+                                                                                                                                                SimpleNode jjtn003 = new SimpleNode(this, JJTUNORDERED);
+                                                                                                                                                boolean jjtc003 = true;
+                                                                                                                                                jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                jjtc003 = false;
+                                                                                                         jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                if (jjtc003) {
+                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                }
+        }
+        break;
+      default:
+        jj_la1[14] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void EmptyOrderingDecl() throws ParseException {
+ /*@bgen(jjtree) EmptyOrderingDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTEMPTYORDERINGDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareDefaultOrderingEmpty);
+                                 SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREDEFAULTORDERINGEMPTY);
+                                 boolean jjtc001 = true;
+                                 jjtree.openNodeScope(jjtn001);
+      try {
+                                 jjtree.closeNodeScope(jjtn001,  true);
+                                 jjtc001 = false;
+                                jjtn001.processToken(token);
+      } finally {
+                                 if (jjtc001) {
+                                   jjtree.closeNodeScope(jjtn001,  true);
+                                 }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case EmptyGreatest:
+        jj_consume_token(EmptyGreatest);
+                                                                                                                   SimpleNode jjtn002 = new SimpleNode(this, JJTEMPTYGREATEST);
+                                                                                                                   boolean jjtc002 = true;
+                                                                                                                   jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                                   jjtc002 = false;
+                                                                               jjtn002.processToken(token);
+        } finally {
+                                                                                                                   if (jjtc002) {
+                                                                                                                     jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                                   }
+        }
+        break;
+      case EmptyLeast:
+        jj_consume_token(EmptyLeast);
+                                                                                                                                                                                     SimpleNode jjtn003 = new SimpleNode(this, JJTEMPTYLEAST);
+                                                                                                                                                                                     boolean jjtc003 = true;
+                                                                                                                                                                                     jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                                     jjtc003 = false;
+                                                                                                                            jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                                                     if (jjtc003) {
+                                                                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                                     }
+        }
+        break;
+      default:
+        jj_la1[15] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void InheritNamespacesDecl() throws ParseException {
+ /*@bgen(jjtree) InheritNamespacesDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTINHERITNAMESPACESDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareInheritNamespaces);
+                              SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREINHERITNAMESPACES);
+                              boolean jjtc001 = true;
+                              jjtree.openNodeScope(jjtn001);
+      try {
+                              jjtree.closeNodeScope(jjtn001,  true);
+                              jjtc001 = false;
+                             jjtn001.processToken(token);
+      } finally {
+                              if (jjtc001) {
+                                jjtree.closeNodeScope(jjtn001,  true);
+                              }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case Yes:
+        jj_consume_token(Yes);
+                                                                                                   SimpleNode jjtn002 = new SimpleNode(this, JJTYES);
+                                                                                                   boolean jjtc002 = true;
+                                                                                                   jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                   jjtc002 = false;
+                                                                  jjtn002.processToken(token);
+        } finally {
+                                                                                                   if (jjtc002) {
+                                                                                                     jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                   }
+        }
+        break;
+      case No:
+        jj_consume_token(No);
+                                                                                                                                                   SimpleNode jjtn003 = new SimpleNode(this, JJTNO);
+                                                                                                                                                   boolean jjtc003 = true;
+                                                                                                                                                   jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                   jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                   jjtc003 = false;
+                                                                                                       jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                   if (jjtc003) {
+                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                   }
+        }
+        break;
+      default:
+        jj_la1[16] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void DefaultCollationDecl() throws ParseException {
+ /*@bgen(jjtree) DefaultCollationDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTDEFAULTCOLLATIONDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareCollation);
+                      SimpleNode jjtn001 = new SimpleNode(this, JJTDECLARECOLLATION);
+                      boolean jjtc001 = true;
+                      jjtree.openNodeScope(jjtn001);
+      try {
+                      jjtree.closeNodeScope(jjtn001,  true);
+                      jjtc001 = false;
+                     jjtn001.processToken(token);
+      } finally {
+                      if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001,  true);
+                      }
+      }
+      jj_consume_token(URLLiteral);
+                                                                                         SimpleNode jjtn002 = new SimpleNode(this, JJTURLLITERAL);
+                                                                                         boolean jjtc002 = true;
+                                                                                         jjtree.openNodeScope(jjtn002);
+      try {
+                                                                                         jjtree.closeNodeScope(jjtn002,  true);
+                                                                                         jjtc002 = false;
+                                                                jjtn002.processToken(token);
+      } finally {
+                                                                                         if (jjtc002) {
+                                                                                           jjtree.closeNodeScope(jjtn002,  true);
+                                                                                         }
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void BaseURIDecl() throws ParseException {
+ /*@bgen(jjtree) BaseURIDecl */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTBASEURIDECL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(DeclareBaseURI);
+                    SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREBASEURI);
+                    boolean jjtc001 = true;
+                    jjtree.openNodeScope(jjtn001);
+      try {
+                    jjtree.closeNodeScope(jjtn001,  true);
+                    jjtc001 = false;
+                   jjtn001.processToken(token);
+      } finally {
+                    if (jjtc001) {
+                      jjtree.closeNodeScope(jjtn001,  true);
+                    }
+      }
+      jj_consume_token(URLLiteral);
+                                                                                     SimpleNode jjtn002 = new SimpleNode(this, JJTURLLITERAL);
+                                                                                     boolean jjtc002 = true;
+                                                                                     jjtree.openNodeScope(jjtn002);
+      try {
+                                                                                     jjtree.closeNodeScope(jjtn002,  true);
+                                                                                     jjtc002 = false;
+                                                              jjtn002.processToken(token);
+      } finally {
+                                                                                     if (jjtc002) {
+                                                                                       jjtree.closeNodeScope(jjtn002,  true);
+                                                                                     }
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void SchemaImport() throws ParseException {
+ /*@bgen(jjtree) SchemaImport */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTSCHEMAIMPORT);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(ImportSchemaToken);
+                       SimpleNode jjtn001 = new SimpleNode(this, JJTIMPORTSCHEMATOKEN);
+                       boolean jjtc001 = true;
+                       jjtree.openNodeScope(jjtn001);
+      try {
+                       jjtree.closeNodeScope(jjtn001,  true);
+                       jjtc001 = false;
+                      jjtn001.processToken(token);
+      } finally {
+                       if (jjtc001) {
+                         jjtree.closeNodeScope(jjtn001,  true);
+                       }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case Namespace:
+      case DefaultElement:
+        SchemaPrefix();
+        break;
+      default:
+        jj_la1[17] = jj_gen;
+        ;
+      }
+      jj_consume_token(URLLiteral);
+                                                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTURLLITERAL);
+                                                                                                            boolean jjtc002 = true;
+                                                                                                            jjtree.openNodeScope(jjtn002);
+      try {
+                                                                                                            jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                            jjtc002 = false;
+                                                                                  jjtn002.processToken(token);
+      } finally {
+                                                                                                            if (jjtc002) {
+                                                                                                              jjtree.closeNodeScope(jjtn002,  true);
+                                                                                                            }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case AtStringLiteral:
+        jj_consume_token(AtStringLiteral);
+                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTATSTRINGLITERAL);
+                                                                                                                                                                               boolean jjtc003 = true;
+                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                               jjtc003 = false;
+                                                                                                                                   jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                                               if (jjtc003) {
+                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                                               }
+        }
+        label_5:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case Comma:
+            ;
+            break;
+          default:
+            jj_la1[18] = jj_gen;
+            break label_5;
+          }
+          jj_consume_token(Comma);
+          jj_consume_token(StringLiteral);
+                                                                                                                                                                                                                                                             SimpleNode jjtn004 = new SimpleNode(this, JJTSTRINGLITERAL);
+                                                                                                                                                                                                                                                             boolean jjtc004 = true;
+                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn004);
+          try {
+                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                                             jjtc004 = false;
+                                                                                                                                                                                          jjtn004.processToken(token);
+          } finally {
+                                                                                                                                                                                                                                                             if (jjtc004) {
+                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                                                             }
+          }
+        }
+        break;
+      default:
+        jj_la1[19] = jj_gen;
+        ;
+      }
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void SchemaPrefix() throws ParseException {
+ /*@bgen(jjtree) SchemaPrefix */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTSCHEMAPREFIX);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case Namespace:
+        jj_consume_token(Namespace);
+                 SimpleNode jjtn001 = new SimpleNode(this, JJTNAMESPACE);
+                 boolean jjtc001 = true;
+                 jjtree.openNodeScope(jjtn001);
+        try {
+                 jjtree.closeNodeScope(jjtn001,  true);
+                 jjtc001 = false;
+                jjtn001.processToken(token);
+        } finally {
+                 if (jjtc001) {
+                   jjtree.closeNodeScope(jjtn001,  true);
+                 }
+        }
+        jj_consume_token(NCNameForPrefix);
+                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
+                                                                                  boolean jjtc002 = true;
+                                                                                  jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                  jjtree.closeNodeScope(jjtn002,  true);
+                                                                                  jjtc002 = false;
+                                                                jjtn002.processToken(token);
+        } finally {
+                                                                                  if (jjtc002) {
+                                                                                    jjtree.closeNodeScope(jjtn002,  true);
+                                                                                  }
+        }
+        jj_consume_token(AssignEquals);
+                                                                                                                                                      SimpleNode jjtn003 = new SimpleNode(this, JJTASSIGNEQUALS);
+                                                                                                                                                      boolean jjtc003 = true;
+                                                                                                                                                      jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                      jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                      jjtc003 = false;
+                                                                                                             jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                      if (jjtc003) {
+                                                                                                                                                        jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                      }
+        }
+        break;
+      case DefaultElement:
+        jj_consume_token(DefaultElement);
+                                                                                                                                                                                                                             SimpleNode jjtn004 = new SimpleNode(this, JJTDEFAULTELEMENT);
+                                                                                                                                                                                                                             boolean jjtc004 = true;
+                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn004);
+        try {
+                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                             jjtc004 = false;
+                                                                                                                                                                jjtn004.processToken(token);
+        } finally {
+                                                                                                                                                                                                                             if (jjtc004) {
+                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
+                                                                                                                                                                                                                             }
+        }
+        jj_consume_token(Namespace);
+                                                                                                                                                                                                                                                                                             SimpleNode jjtn005 = new SimpleNode(this, JJTNAMESPACE);
+                                                                                                                                                                                                                                                                                             boolean jjtc005 = true;
+                                                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn005);
+        try {
+                                                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn005,  true);
+                                                                                                                                                                                                                                                                                             jjtc005 = false;
+                                                                                                                                                                                                          jjtn005.processToken(token);
+        } finally {
+                                                                                                                                                                                                                                                                                             if (jjtc005) {
+                                                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn005,  true);
+                                                                                                                                                                                                                                                                                             }
+        }
+        break;
+      default:
+        jj_la1[20] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+  }
+
+  final public void ModuleImport() throws ParseException {
+ /*@bgen(jjtree) ModuleImport */
+  SimpleNode jjtn000 = new SimpleNode(this, JJTMODULEIMPORT);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(ImportModuleToken);
+                       SimpleNode jjtn001 = new SimpleNode(this, JJTIMPORTMODULETOKEN);
+                       boolean jjtc001 = true;
+                       jjtree.openNodeScope(jjtn001);
+      try {
+                       jjtree.closeNodeScope(jjtn001,  true);
+                       jjtc001 = false;
+                      jjtn001.processToken(token);
+      } finally {
+                       if (jjtc001) {
+                         jjtree.closeNodeScope(jjtn001,  true);
+                       }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case Namespace:
+        jj_consume_token(Namespace);
+                                                                                           SimpleNode jjtn002 = new SimpleNode(this, JJTNAMESPACE);
+                                                                                           boolean jjtc002 = true;
+                                                                                           jjtree.openNodeScope(jjtn002);
+        try {
+                                                                                           jjtree.closeNodeScope(jjtn002,  true);
+                                                                                           jjtc002 = false;
+                                                                 jjtn002.processToken(token);
+        } finally {
+                                                                                           if (jjtc002) {
+                                                                                             jjtree.closeNodeScope(jjtn002,  true);
+                                                                                           }
+        }
+        jj_consume_token(NCNameForPrefix);
+                                                                                                                                                            SimpleNode jjtn003 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
+                                                                                                                                                            boolean jjtc003 = true;
+                                                                                                                                                            jjtree.openNodeScope(jjtn003);
+        try {
+                                                                                                                                                            jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                            jjtc003 = false;
+                                                                                                                 jjtn003.processToken(token);
+        } finally {
+                                                                                                                                                            if (jjtc003) {
+                                                                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
+                                                                                                                                                            }
+        }
+        jj_consume_token(AssignEquals);
+                                                                                                                                                                                                                                SimpleNode jjtn004 = new SimpleNode(this, JJTASSIGNEQUALS);
+                                                                                                                                                                                                                                boolean jjtc004 = true;
+                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn004);
+        try {
+                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn004,  true);

[... 7693 lines stripped ...]


Mime
View raw message