30883 lines
1.3 MiB
30883 lines
1.3 MiB
/********************************
|
|
* Copyright (c) 2008, 2009 28msec Inc. and others.
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the Eclipse Public License v1.0
|
|
* which accompanies this distribution, and is available at
|
|
* http://www.eclipse.org/legal/epl-v10.html
|
|
*
|
|
* Contributors:
|
|
* Gabriel Petrovay (28msec) - initial API and implementation
|
|
* Sam Neth (Mark Logic)
|
|
*******************************************************************************/
|
|
|
|
|
|
define(function(require, exports, module) {
|
|
var org = require("./antlr3-all").org;
|
|
var XQueryParser = exports.XQueryParser = function(input, state) {
|
|
if (!state) {
|
|
state = new org.antlr.runtime.RecognizerSharedState();
|
|
}
|
|
|
|
(function(){
|
|
}).call(this);
|
|
|
|
XQueryParser.superclass.constructor.call(this, input, state);
|
|
|
|
this.dfa6 = new XQueryParser.DFA6(this);
|
|
this.dfa7 = new XQueryParser.DFA7(this);
|
|
this.dfa8 = new XQueryParser.DFA8(this);
|
|
this.dfa49 = new XQueryParser.DFA49(this);
|
|
this.dfa103 = new XQueryParser.DFA103(this);
|
|
this.dfa110 = new XQueryParser.DFA110(this);
|
|
this.dfa112 = new XQueryParser.DFA112(this);
|
|
this.dfa114 = new XQueryParser.DFA114(this);
|
|
this.dfa119 = new XQueryParser.DFA119(this);
|
|
this.dfa124 = new XQueryParser.DFA124(this);
|
|
this.dfa154 = new XQueryParser.DFA154(this);
|
|
this.dfa156 = new XQueryParser.DFA156(this);
|
|
|
|
|
|
|
|
/* @todo only create adaptor if output=AST */
|
|
this.adaptor = new org.antlr.runtime.tree.CommonTreeAdaptor();
|
|
|
|
};
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
EOF: -1,
|
|
L_QuotAttrContentChar: 4,
|
|
L_AposAttrContentChar: 5,
|
|
L_ElementContentChar: 6,
|
|
L_CDataSection: 7,
|
|
L_PredefinedEntityRef: 8,
|
|
L_CharRef: 9,
|
|
ESCAPE_LBRACKET: 10,
|
|
ESCAPE_RBRACKET: 11,
|
|
ESCAPE_APOS: 12,
|
|
ESCAPE_QUOT: 13,
|
|
CDATA_START: 14,
|
|
CDATA_END: 15,
|
|
ANCESTOR: 16,
|
|
ANCESTOR_OR_SELF: 17,
|
|
AND: 18,
|
|
AS: 19,
|
|
ASCENDING: 20,
|
|
AT: 21,
|
|
ATTRIBUTE: 22,
|
|
BASE_URI: 23,
|
|
BOUNDARY_SPACE: 24,
|
|
BY: 25,
|
|
CASE: 26,
|
|
CAST: 27,
|
|
CASTABLE: 28,
|
|
CHILD: 29,
|
|
COLLATION: 30,
|
|
COMMENT: 31,
|
|
CONSTRUCTION: 32,
|
|
COPY_NAMESPACES: 33,
|
|
DECLARE: 34,
|
|
DEFAULT: 35,
|
|
DESCENDANT: 36,
|
|
DESCENDANT_OR_SELF: 37,
|
|
DESCENDING: 38,
|
|
DIV: 39,
|
|
DOCUMENT: 40,
|
|
DOCUMENT_NODE: 41,
|
|
ELEMENT: 42,
|
|
ELSE: 43,
|
|
EMPTY: 44,
|
|
EMPTY_SEQUENCE: 45,
|
|
ENCODING: 46,
|
|
EQ: 47,
|
|
EVERY: 48,
|
|
EXCEPT: 49,
|
|
EXTERNAL: 50,
|
|
FOLLOWING: 51,
|
|
FOLLOWING_SIBLING: 52,
|
|
FOR: 53,
|
|
FUNCTION: 54,
|
|
GE: 55,
|
|
GREATEST: 56,
|
|
GT: 57,
|
|
IDIV: 58,
|
|
IF: 59,
|
|
IMPORT: 60,
|
|
IN: 61,
|
|
INHERIT: 62,
|
|
INSTANCE: 63,
|
|
INTERSECT: 64,
|
|
IS: 65,
|
|
ITEM: 66,
|
|
LAX: 67,
|
|
LE: 68,
|
|
LEAST: 69,
|
|
LET: 70,
|
|
LT: 71,
|
|
MOD: 72,
|
|
MODULE: 73,
|
|
NAMESPACE: 74,
|
|
NE: 75,
|
|
NO_INHERIT: 76,
|
|
NO_PRESERVE: 77,
|
|
NODE: 78,
|
|
OF: 79,
|
|
OPTION: 80,
|
|
OR: 81,
|
|
ORDER: 82,
|
|
ORDERED: 83,
|
|
ORDERING: 84,
|
|
PARENT: 85,
|
|
PRECEDING: 86,
|
|
PRECEDING_SIBLING: 87,
|
|
PRESERVE: 88,
|
|
PROCESSING_INSTRUCTION: 89,
|
|
RETURN: 90,
|
|
SATISFIES: 91,
|
|
SCHEMA: 92,
|
|
SCHEMA_ATTRIBUTE: 93,
|
|
SCHEMA_ELEMENT: 94,
|
|
SELF: 95,
|
|
SOME: 96,
|
|
STABLE: 97,
|
|
STRICT: 98,
|
|
STRIP: 99,
|
|
TEXT: 100,
|
|
THEN: 101,
|
|
TO: 102,
|
|
TREAT: 103,
|
|
TYPESWITCH: 104,
|
|
UNION: 105,
|
|
UNORDERED: 106,
|
|
VALIDATE: 107,
|
|
VARIABLE: 108,
|
|
VERSION: 109,
|
|
WHERE: 110,
|
|
XQUERY: 111,
|
|
CATCH: 112,
|
|
CONTEXT: 113,
|
|
COUNT: 114,
|
|
DECIMAL_FORMAT: 115,
|
|
DECIMAL_SEPARATOR: 116,
|
|
DIGIT: 117,
|
|
END: 118,
|
|
GROUP: 119,
|
|
GROUPING_SEPARATOR: 120,
|
|
INFINITY: 121,
|
|
MINUS_SIGN: 122,
|
|
NAMESPACE_NODE: 123,
|
|
NAN: 124,
|
|
NEXT: 125,
|
|
ONLY: 126,
|
|
OUTER: 127,
|
|
PATTERN_SEPARATOR: 128,
|
|
PERCENT: 129,
|
|
PER_MILLE: 130,
|
|
PREVIOUS: 131,
|
|
SLIDING: 132,
|
|
START: 133,
|
|
TRY: 134,
|
|
TUMBLING: 135,
|
|
WHEN: 136,
|
|
WINDOW: 137,
|
|
ZERO_DIGIT: 138,
|
|
AFTER: 139,
|
|
BEFORE: 140,
|
|
COPY: 141,
|
|
DELETE: 142,
|
|
FIRST: 143,
|
|
INSERT: 144,
|
|
INTO: 145,
|
|
LAST: 146,
|
|
MODIFY: 147,
|
|
NODES: 148,
|
|
RENAME: 149,
|
|
REPLACE: 150,
|
|
REVALIDATION: 151,
|
|
SKIP: 152,
|
|
UPDATING: 153,
|
|
VALUE: 154,
|
|
WITH: 155,
|
|
BLOCK: 156,
|
|
CONSTANT: 157,
|
|
EXIT: 158,
|
|
RETURNING: 159,
|
|
SEQUENTIAL: 160,
|
|
SET: 161,
|
|
SIMPLE: 162,
|
|
WHILE: 163,
|
|
EVAL: 164,
|
|
USING: 165,
|
|
APPEND_ONLY: 166,
|
|
AUTOMATICALLY: 167,
|
|
CHECK: 168,
|
|
COLLECTION: 169,
|
|
CONSTRAINT: 170,
|
|
CONST: 171,
|
|
EQUALITY: 172,
|
|
FOREACH: 173,
|
|
FOREIGN: 174,
|
|
FROM: 175,
|
|
INDEX: 176,
|
|
INTEGRITY: 177,
|
|
KEY: 178,
|
|
MAINTAINED: 179,
|
|
MANUALLY: 180,
|
|
MUTABLE: 181,
|
|
NON: 182,
|
|
ON: 183,
|
|
QUEUE: 184,
|
|
RANGE: 185,
|
|
READ_ONLY: 186,
|
|
UNIQUE: 187,
|
|
BINARY: 188,
|
|
PRIVATE: 189,
|
|
AMP_ER: 190,
|
|
APOS_ER: 191,
|
|
QUOT_ER: 192,
|
|
LPAREN: 193,
|
|
RPAREN: 194,
|
|
DOLLAR: 195,
|
|
LBRACKET: 196,
|
|
RBRACKET: 197,
|
|
LSQUARE: 198,
|
|
RSQUARE: 199,
|
|
EQUAL: 200,
|
|
BIND: 201,
|
|
NOTEQUAL: 202,
|
|
AMP: 203,
|
|
COMMA: 204,
|
|
QUESTION: 205,
|
|
STAR: 206,
|
|
PLUS: 207,
|
|
MINUS: 208,
|
|
SMALLER: 209,
|
|
GREATER: 210,
|
|
SMALLEREQ: 211,
|
|
GREATEREQ: 212,
|
|
SMALLER_SMALLER: 213,
|
|
GREATER_GREATER: 214,
|
|
SLASH: 215,
|
|
SLASH_SLASH: 216,
|
|
DOT: 217,
|
|
DOT_DOT: 218,
|
|
COLON: 219,
|
|
COLON_COLON: 220,
|
|
EMPTY_CLOSE_TAG: 221,
|
|
CLOSE_TAG: 222,
|
|
SEMICOLON: 223,
|
|
VBAR: 224,
|
|
PRAGMA_START: 225,
|
|
PRAGMA_END: 226,
|
|
XML_COMMENT_START: 227,
|
|
XML_COMMENT_END: 228,
|
|
PI_START: 229,
|
|
PI_END: 230,
|
|
ATTR_SIGN: 231,
|
|
CHARREF_DEC: 232,
|
|
CHARREF_HEX: 233,
|
|
APOS: 234,
|
|
QUOT: 235,
|
|
NCNameStartChar: 236,
|
|
NCNameChar: 237,
|
|
L_NCName: 238,
|
|
Letter: 239,
|
|
HexLetter: 240,
|
|
Digit: 241,
|
|
Digits: 242,
|
|
S: 243,
|
|
SU: 244,
|
|
L_Pragma: 245,
|
|
L_DirCommentConstructor: 246,
|
|
L_DirPIConstructor: 247,
|
|
L_IntegerLiteral: 248,
|
|
L_DecimalLiteral: 249,
|
|
L_DoubleLiteral: 250,
|
|
L_Comment: 251,
|
|
L_AnyChar: 252,
|
|
L_QuotStringLiteralChar: 253,
|
|
L_AposStringLiteralChar: 254,
|
|
LibraryModule: 255,
|
|
MainModule: 256,
|
|
VersionDecl: 257,
|
|
VersionDeclEncoding: 258,
|
|
VersionDeclVersion: 259,
|
|
ModuleDecl: 260,
|
|
Prolog: 261,
|
|
DefaultNamespaceDecls: 262,
|
|
DefaultNamespaceDecl: 263,
|
|
Setters: 264,
|
|
Setter: 265,
|
|
NamespaceDecls: 266,
|
|
NamespaceDecl: 267,
|
|
Imports: 268,
|
|
SchemaImport: 269,
|
|
SchemaPrefix: 270,
|
|
NamespaceName: 271,
|
|
DefaultElementNamespace: 272,
|
|
AtHints: 273,
|
|
ModuleImport: 274,
|
|
BaseURIDecl: 275,
|
|
OrderedDecls: 276,
|
|
VarDecl: 277,
|
|
VarType: 278,
|
|
VarValue: 279,
|
|
VarDefaultValue: 280,
|
|
VarConstantDecl: 281,
|
|
VarVariableDecl: 282,
|
|
FunctionDecl: 283,
|
|
ParamList: 284,
|
|
ReturnType: 285,
|
|
OptionDecl: 286,
|
|
TypeDeclaration: 287,
|
|
Param: 288,
|
|
EnclosedExpr: 289,
|
|
QueryBody: 290,
|
|
UnaryExpr: 291,
|
|
DirElemConstructor: 292,
|
|
DirAttributeList: 293,
|
|
DirAttributeValue: 294,
|
|
DirElemContent: 295,
|
|
CommonContent: 296,
|
|
SequenceType: 297,
|
|
EmptySequenceTest: 298,
|
|
KindTest: 299,
|
|
ItemTest: 300,
|
|
AtomicType: 301,
|
|
StringLiteral: 302,
|
|
ElementContentChar: 303,
|
|
AttributeValueChar: 304,
|
|
QName: 305,
|
|
Block: 306,
|
|
BlockDecls: 307,
|
|
BlockVarDecl: 308,
|
|
BinaryTest: 309,
|
|
LETDOLLAR: 310,
|
|
EXPLICITLY: 311
|
|
});
|
|
|
|
(function(){
|
|
// public class variables
|
|
var EOF= -1,
|
|
L_QuotAttrContentChar= 4,
|
|
L_AposAttrContentChar= 5,
|
|
L_ElementContentChar= 6,
|
|
L_CDataSection= 7,
|
|
L_PredefinedEntityRef= 8,
|
|
L_CharRef= 9,
|
|
ESCAPE_LBRACKET= 10,
|
|
ESCAPE_RBRACKET= 11,
|
|
ESCAPE_APOS= 12,
|
|
ESCAPE_QUOT= 13,
|
|
CDATA_START= 14,
|
|
CDATA_END= 15,
|
|
ANCESTOR= 16,
|
|
ANCESTOR_OR_SELF= 17,
|
|
AND= 18,
|
|
AS= 19,
|
|
ASCENDING= 20,
|
|
AT= 21,
|
|
ATTRIBUTE= 22,
|
|
BASE_URI= 23,
|
|
BOUNDARY_SPACE= 24,
|
|
BY= 25,
|
|
CASE= 26,
|
|
CAST= 27,
|
|
CASTABLE= 28,
|
|
CHILD= 29,
|
|
COLLATION= 30,
|
|
COMMENT= 31,
|
|
CONSTRUCTION= 32,
|
|
COPY_NAMESPACES= 33,
|
|
DECLARE= 34,
|
|
DEFAULT= 35,
|
|
DESCENDANT= 36,
|
|
DESCENDANT_OR_SELF= 37,
|
|
DESCENDING= 38,
|
|
DIV= 39,
|
|
DOCUMENT= 40,
|
|
DOCUMENT_NODE= 41,
|
|
ELEMENT= 42,
|
|
ELSE= 43,
|
|
EMPTY= 44,
|
|
EMPTY_SEQUENCE= 45,
|
|
ENCODING= 46,
|
|
EQ= 47,
|
|
EVERY= 48,
|
|
EXCEPT= 49,
|
|
EXTERNAL= 50,
|
|
FOLLOWING= 51,
|
|
FOLLOWING_SIBLING= 52,
|
|
FOR= 53,
|
|
FUNCTION= 54,
|
|
GE= 55,
|
|
GREATEST= 56,
|
|
GT= 57,
|
|
IDIV= 58,
|
|
IF= 59,
|
|
IMPORT= 60,
|
|
IN= 61,
|
|
INHERIT= 62,
|
|
INSTANCE= 63,
|
|
INTERSECT= 64,
|
|
IS= 65,
|
|
ITEM= 66,
|
|
LAX= 67,
|
|
LE= 68,
|
|
LEAST= 69,
|
|
LET= 70,
|
|
LT= 71,
|
|
MOD= 72,
|
|
MODULE= 73,
|
|
NAMESPACE= 74,
|
|
NE= 75,
|
|
NO_INHERIT= 76,
|
|
NO_PRESERVE= 77,
|
|
NODE= 78,
|
|
OF= 79,
|
|
OPTION= 80,
|
|
OR= 81,
|
|
ORDER= 82,
|
|
ORDERED= 83,
|
|
ORDERING= 84,
|
|
PARENT= 85,
|
|
PRECEDING= 86,
|
|
PRECEDING_SIBLING= 87,
|
|
PRESERVE= 88,
|
|
PROCESSING_INSTRUCTION= 89,
|
|
RETURN= 90,
|
|
SATISFIES= 91,
|
|
SCHEMA= 92,
|
|
SCHEMA_ATTRIBUTE= 93,
|
|
SCHEMA_ELEMENT= 94,
|
|
SELF= 95,
|
|
SOME= 96,
|
|
STABLE= 97,
|
|
STRICT= 98,
|
|
STRIP= 99,
|
|
TEXT= 100,
|
|
THEN= 101,
|
|
TO= 102,
|
|
TREAT= 103,
|
|
TYPESWITCH= 104,
|
|
UNION= 105,
|
|
UNORDERED= 106,
|
|
VALIDATE= 107,
|
|
VARIABLE= 108,
|
|
VERSION= 109,
|
|
WHERE= 110,
|
|
XQUERY= 111,
|
|
CATCH= 112,
|
|
CONTEXT= 113,
|
|
COUNT= 114,
|
|
DECIMAL_FORMAT= 115,
|
|
DECIMAL_SEPARATOR= 116,
|
|
DIGIT= 117,
|
|
END= 118,
|
|
GROUP= 119,
|
|
GROUPING_SEPARATOR= 120,
|
|
INFINITY= 121,
|
|
MINUS_SIGN= 122,
|
|
NAMESPACE_NODE= 123,
|
|
NAN= 124,
|
|
NEXT= 125,
|
|
ONLY= 126,
|
|
OUTER= 127,
|
|
PATTERN_SEPARATOR= 128,
|
|
PERCENT= 129,
|
|
PER_MILLE= 130,
|
|
PREVIOUS= 131,
|
|
SLIDING= 132,
|
|
START= 133,
|
|
TRY= 134,
|
|
TUMBLING= 135,
|
|
WHEN= 136,
|
|
WINDOW= 137,
|
|
ZERO_DIGIT= 138,
|
|
AFTER= 139,
|
|
BEFORE= 140,
|
|
COPY= 141,
|
|
DELETE= 142,
|
|
FIRST= 143,
|
|
INSERT= 144,
|
|
INTO= 145,
|
|
LAST= 146,
|
|
MODIFY= 147,
|
|
NODES= 148,
|
|
RENAME= 149,
|
|
REPLACE= 150,
|
|
REVALIDATION= 151,
|
|
SKIP= 152,
|
|
UPDATING= 153,
|
|
VALUE= 154,
|
|
WITH= 155,
|
|
BLOCK= 156,
|
|
CONSTANT= 157,
|
|
EXIT= 158,
|
|
RETURNING= 159,
|
|
SEQUENTIAL= 160,
|
|
SET= 161,
|
|
SIMPLE= 162,
|
|
WHILE= 163,
|
|
EVAL= 164,
|
|
USING= 165,
|
|
APPEND_ONLY= 166,
|
|
AUTOMATICALLY= 167,
|
|
CHECK= 168,
|
|
COLLECTION= 169,
|
|
CONSTRAINT= 170,
|
|
CONST= 171,
|
|
EQUALITY= 172,
|
|
FOREACH= 173,
|
|
FOREIGN= 174,
|
|
FROM= 175,
|
|
INDEX= 176,
|
|
INTEGRITY= 177,
|
|
KEY= 178,
|
|
MAINTAINED= 179,
|
|
MANUALLY= 180,
|
|
MUTABLE= 181,
|
|
NON= 182,
|
|
ON= 183,
|
|
QUEUE= 184,
|
|
RANGE= 185,
|
|
READ_ONLY= 186,
|
|
UNIQUE= 187,
|
|
BINARY= 188,
|
|
PRIVATE= 189,
|
|
AMP_ER= 190,
|
|
APOS_ER= 191,
|
|
QUOT_ER= 192,
|
|
LPAREN= 193,
|
|
RPAREN= 194,
|
|
DOLLAR= 195,
|
|
LBRACKET= 196,
|
|
RBRACKET= 197,
|
|
LSQUARE= 198,
|
|
RSQUARE= 199,
|
|
EQUAL= 200,
|
|
BIND= 201,
|
|
NOTEQUAL= 202,
|
|
AMP= 203,
|
|
COMMA= 204,
|
|
QUESTION= 205,
|
|
STAR= 206,
|
|
PLUS= 207,
|
|
MINUS= 208,
|
|
SMALLER= 209,
|
|
GREATER= 210,
|
|
SMALLEREQ= 211,
|
|
GREATEREQ= 212,
|
|
SMALLER_SMALLER= 213,
|
|
GREATER_GREATER= 214,
|
|
SLASH= 215,
|
|
SLASH_SLASH= 216,
|
|
DOT= 217,
|
|
DOT_DOT= 218,
|
|
COLON= 219,
|
|
COLON_COLON= 220,
|
|
EMPTY_CLOSE_TAG= 221,
|
|
CLOSE_TAG= 222,
|
|
SEMICOLON= 223,
|
|
VBAR= 224,
|
|
PRAGMA_START= 225,
|
|
PRAGMA_END= 226,
|
|
XML_COMMENT_START= 227,
|
|
XML_COMMENT_END= 228,
|
|
PI_START= 229,
|
|
PI_END= 230,
|
|
ATTR_SIGN= 231,
|
|
CHARREF_DEC= 232,
|
|
CHARREF_HEX= 233,
|
|
APOS= 234,
|
|
QUOT= 235,
|
|
NCNameStartChar= 236,
|
|
NCNameChar= 237,
|
|
L_NCName= 238,
|
|
Letter= 239,
|
|
HexLetter= 240,
|
|
Digit= 241,
|
|
Digits= 242,
|
|
S= 243,
|
|
SU= 244,
|
|
L_Pragma= 245,
|
|
L_DirCommentConstructor= 246,
|
|
L_DirPIConstructor= 247,
|
|
L_IntegerLiteral= 248,
|
|
L_DecimalLiteral= 249,
|
|
L_DoubleLiteral= 250,
|
|
L_Comment= 251,
|
|
L_AnyChar= 252,
|
|
L_QuotStringLiteralChar= 253,
|
|
L_AposStringLiteralChar= 254,
|
|
LibraryModule= 255,
|
|
MainModule= 256,
|
|
VersionDecl= 257,
|
|
VersionDeclEncoding= 258,
|
|
VersionDeclVersion= 259,
|
|
ModuleDecl= 260,
|
|
Prolog= 261,
|
|
DefaultNamespaceDecls= 262,
|
|
DefaultNamespaceDecl= 263,
|
|
Setters= 264,
|
|
Setter= 265,
|
|
NamespaceDecls= 266,
|
|
NamespaceDecl= 267,
|
|
Imports= 268,
|
|
SchemaImport= 269,
|
|
SchemaPrefix= 270,
|
|
NamespaceName= 271,
|
|
DefaultElementNamespace= 272,
|
|
AtHints= 273,
|
|
ModuleImport= 274,
|
|
BaseURIDecl= 275,
|
|
OrderedDecls= 276,
|
|
VarDecl= 277,
|
|
VarType= 278,
|
|
VarValue= 279,
|
|
VarDefaultValue= 280,
|
|
VarConstantDecl= 281,
|
|
VarVariableDecl= 282,
|
|
FunctionDecl= 283,
|
|
ParamList= 284,
|
|
ReturnType= 285,
|
|
OptionDecl= 286,
|
|
TypeDeclaration= 287,
|
|
Param= 288,
|
|
EnclosedExpr= 289,
|
|
QueryBody= 290,
|
|
UnaryExpr= 291,
|
|
DirElemConstructor= 292,
|
|
DirAttributeList= 293,
|
|
DirAttributeValue= 294,
|
|
DirElemContent= 295,
|
|
CommonContent= 296,
|
|
SequenceType= 297,
|
|
EmptySequenceTest= 298,
|
|
KindTest= 299,
|
|
ItemTest= 300,
|
|
AtomicType= 301,
|
|
StringLiteral= 302,
|
|
ElementContentChar= 303,
|
|
AttributeValueChar= 304,
|
|
QName= 305,
|
|
Block= 306,
|
|
BlockDecls= 307,
|
|
BlockVarDecl= 308,
|
|
BinaryTest= 309,
|
|
LETDOLLAR= 310,
|
|
EXPLICITLY= 311;
|
|
|
|
// public instance methods/vars
|
|
org.antlr.lang.extend(XQueryParser, org.antlr.runtime.Parser, {
|
|
|
|
setTreeAdaptor: function(adaptor) {
|
|
this.adaptor = adaptor;
|
|
},
|
|
getTreeAdaptor: function() {
|
|
return this.adaptor;
|
|
},
|
|
|
|
getTokenNames: function() { return XQueryParser.tokenNames; },
|
|
getGrammarFileName: function() { return "XQueryParser.g"; }
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser.prototype, {
|
|
|
|
// inline static return class
|
|
p_Module_return: (function() {
|
|
XQueryParser.p_Module_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Module_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:119:1: p_Module : (vd= p_VersionDecl )? (lm= p_LibraryModule[$vd.tree] -> | mm= p_MainModule[$vd.tree] ->) EOF ;
|
|
// $ANTLR start "p_Module"
|
|
p_Module: function() {
|
|
var retval = new XQueryParser.p_Module_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var EOF1 = null;
|
|
var vd = null;
|
|
var lm = null;
|
|
var mm = null;
|
|
|
|
var EOF1_tree=null;
|
|
var stream_EOF=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EOF");
|
|
var stream_p_VersionDecl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_VersionDecl");
|
|
var stream_p_LibraryModule=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_LibraryModule");
|
|
var stream_p_MainModule=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_MainModule");
|
|
try {
|
|
// XQueryParser.g:120:9: ( (vd= p_VersionDecl )? (lm= p_LibraryModule[$vd.tree] -> | mm= p_MainModule[$vd.tree] ->) EOF )
|
|
// XQueryParser.g:120:11: (vd= p_VersionDecl )? (lm= p_LibraryModule[$vd.tree] -> | mm= p_MainModule[$vd.tree] ->) EOF
|
|
// XQueryParser.g:120:13: (vd= p_VersionDecl )?
|
|
var alt1=2;
|
|
var LA1_0 = this.input.LA(1);
|
|
|
|
if ( (LA1_0==XQUERY) ) {
|
|
var LA1_1 = this.input.LA(2);
|
|
|
|
if ( (LA1_1==ENCODING||LA1_1==VERSION) ) {
|
|
alt1=1;
|
|
}
|
|
}
|
|
switch (alt1) {
|
|
case 1 :
|
|
// XQueryParser.g:120:13: vd= p_VersionDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VersionDecl_in_p_Module523);
|
|
vd=this.p_VersionDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_VersionDecl.add(vd.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:121:13: (lm= p_LibraryModule[$vd.tree] -> | mm= p_MainModule[$vd.tree] ->)
|
|
var alt2=2;
|
|
var LA2_0 = this.input.LA(1);
|
|
|
|
if ( (LA2_0==MODULE) ) {
|
|
var LA2_1 = this.input.LA(2);
|
|
|
|
if ( (LA2_1==NAMESPACE) ) {
|
|
alt2=1;
|
|
}
|
|
else if ( (LA2_1==EOF||LA2_1==AND||(LA2_1>=CAST && LA2_1<=CASTABLE)||LA2_1==DIV||LA2_1==EQ||LA2_1==EXCEPT||LA2_1==GE||(LA2_1>=GT && LA2_1<=IDIV)||(LA2_1>=INSTANCE && LA2_1<=IS)||LA2_1==LE||(LA2_1>=LT && LA2_1<=MOD)||LA2_1==NE||LA2_1==OR||(LA2_1>=TO && LA2_1<=TREAT)||LA2_1==UNION||LA2_1==LPAREN||LA2_1==LSQUARE||LA2_1==EQUAL||LA2_1==NOTEQUAL||LA2_1==COMMA||(LA2_1>=STAR && LA2_1<=SLASH_SLASH)||LA2_1==COLON||(LA2_1>=SEMICOLON && LA2_1<=VBAR)) ) {
|
|
alt2=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 2, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( ((LA2_0>=ANCESTOR && LA2_0<=MOD)||(LA2_0>=NAMESPACE && LA2_0<=EXIT)||(LA2_0>=SEQUENTIAL && LA2_0<=MAINTAINED)||(LA2_0>=MUTABLE && LA2_0<=LPAREN)||LA2_0==DOLLAR||(LA2_0>=STAR && LA2_0<=SMALLER)||(LA2_0>=SLASH && LA2_0<=DOT_DOT)||LA2_0==ATTR_SIGN||(LA2_0>=APOS && LA2_0<=QUOT)||LA2_0==L_NCName||(LA2_0>=L_Pragma && LA2_0<=L_DoubleLiteral)||(LA2_0>=LETDOLLAR && LA2_0<=EXPLICITLY)) ) {
|
|
alt2=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 2, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt2) {
|
|
case 1 :
|
|
// XQueryParser.g:122:17: lm= p_LibraryModule[$vd.tree]
|
|
this.pushFollow(XQueryParser.FOLLOW_p_LibraryModule_in_p_Module558);
|
|
lm=this.p_LibraryModule((vd?vd.tree:null));
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_LibraryModule.add(lm.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements:
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 122:49: ->
|
|
{
|
|
this.adaptor.addChild(root_0, (lm?lm.tree:null));
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:123:15: mm= p_MainModule[$vd.tree]
|
|
this.pushFollow(XQueryParser.FOLLOW_p_MainModule_in_p_Module584);
|
|
mm=this.p_MainModule((vd?vd.tree:null));
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_MainModule.add(mm.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements:
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 123:49: ->
|
|
{
|
|
this.adaptor.addChild(root_0, (mm?mm.tree:null));
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
EOF1=this.match(this.input,EOF,XQueryParser.FOLLOW_EOF_in_p_Module613); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EOF.add(EOF1);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_VersionDecl_return: (function() {
|
|
XQueryParser.p_VersionDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_VersionDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:128:1: p_VersionDecl : k+= XQUERY ( (k+= ENCODING enc= p_StringLiteral ) | (k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )? ) ) SEMICOLON -> ^( VersionDecl ^( VersionDeclVersion ( $ver)? ) ^( VersionDeclEncoding ( $enc)? ) ) ;
|
|
// $ANTLR start "p_VersionDecl"
|
|
p_VersionDecl: function() {
|
|
var retval = new XQueryParser.p_VersionDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON2 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var enc = null;
|
|
var ver = null;
|
|
|
|
var SEMICOLON2_tree=null;
|
|
var k_tree=null;
|
|
var stream_ENCODING=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token ENCODING");
|
|
var stream_VERSION=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token VERSION");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_XQUERY=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token XQUERY");
|
|
var stream_p_StringLiteral=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_StringLiteral");
|
|
try {
|
|
// XQueryParser.g:129:9: (k+= XQUERY ( (k+= ENCODING enc= p_StringLiteral ) | (k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )? ) ) SEMICOLON -> ^( VersionDecl ^( VersionDeclVersion ( $ver)? ) ^( VersionDeclEncoding ( $enc)? ) ) )
|
|
// XQueryParser.g:129:11: k+= XQUERY ( (k+= ENCODING enc= p_StringLiteral ) | (k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )? ) ) SEMICOLON
|
|
k=this.match(this.input,XQUERY,XQueryParser.FOLLOW_XQUERY_in_p_VersionDecl641); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_XQUERY.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:129:21: ( (k+= ENCODING enc= p_StringLiteral ) | (k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )? ) )
|
|
var alt4=2;
|
|
var LA4_0 = this.input.LA(1);
|
|
|
|
if ( (LA4_0==ENCODING) ) {
|
|
alt4=1;
|
|
}
|
|
else if ( (LA4_0==VERSION) ) {
|
|
alt4=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 4, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt4) {
|
|
case 1 :
|
|
// XQueryParser.g:129:22: (k+= ENCODING enc= p_StringLiteral )
|
|
// XQueryParser.g:129:22: (k+= ENCODING enc= p_StringLiteral )
|
|
// XQueryParser.g:129:23: k+= ENCODING enc= p_StringLiteral
|
|
k=this.match(this.input,ENCODING,XQueryParser.FOLLOW_ENCODING_in_p_VersionDecl647); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_ENCODING.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_VersionDecl651);
|
|
enc=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(enc.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:130:13: (k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )? )
|
|
// XQueryParser.g:130:13: (k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )? )
|
|
// XQueryParser.g:130:14: k+= VERSION ver= p_StringLiteral (k+= ENCODING enc= p_StringLiteral )?
|
|
k=this.match(this.input,VERSION,XQueryParser.FOLLOW_VERSION_in_p_VersionDecl672); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_VERSION.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_VersionDecl676);
|
|
ver=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(ver.getTree());
|
|
// XQueryParser.g:130:46: (k+= ENCODING enc= p_StringLiteral )?
|
|
var alt3=2;
|
|
var LA3_0 = this.input.LA(1);
|
|
|
|
if ( (LA3_0==ENCODING) ) {
|
|
alt3=1;
|
|
}
|
|
switch (alt3) {
|
|
case 1 :
|
|
// XQueryParser.g:130:47: k+= ENCODING enc= p_StringLiteral
|
|
k=this.match(this.input,ENCODING,XQueryParser.FOLLOW_ENCODING_in_p_VersionDecl682); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_ENCODING.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_VersionDecl686);
|
|
enc=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(enc.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON2=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_p_VersionDecl692); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON2);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: enc, ver
|
|
// token labels:
|
|
// rule labels: retval, ver, enc
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_ver=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token ver",ver!=null?ver.tree:null);
|
|
var stream_enc=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token enc",enc!=null?enc.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 131:17: -> ^( VersionDecl ^( VersionDeclVersion ( $ver)? ) ^( VersionDeclEncoding ( $enc)? ) )
|
|
{
|
|
// XQueryParser.g:131:20: ^( VersionDecl ^( VersionDeclVersion ( $ver)? ) ^( VersionDeclEncoding ( $enc)? ) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(VersionDecl, "VersionDecl"), root_1);
|
|
|
|
// XQueryParser.g:131:34: ^( VersionDeclVersion ( $ver)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(VersionDeclVersion, "VersionDeclVersion"), root_2);
|
|
|
|
// XQueryParser.g:131:55: ( $ver)?
|
|
if ( stream_ver.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_ver.nextTree());
|
|
|
|
}
|
|
stream_ver.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:131:62: ^( VersionDeclEncoding ( $enc)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(VersionDeclEncoding, "VersionDeclEncoding"), root_2);
|
|
|
|
// XQueryParser.g:131:84: ( $enc)?
|
|
if ( stream_enc.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_enc.nextTree());
|
|
|
|
}
|
|
stream_enc.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_MainModule_return: (function() {
|
|
XQueryParser.p_MainModule_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_MainModule_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:135:1: p_MainModule[vd] : pm_Prolog p_QueryBody -> ^( MainModule pm_Prolog p_QueryBody ) ;
|
|
// $ANTLR start "p_MainModule"
|
|
p_MainModule: function(vd) {
|
|
var retval = new XQueryParser.p_MainModule_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_Prolog3 = null;
|
|
var p_QueryBody4 = null;
|
|
|
|
var stream_p_QueryBody=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QueryBody");
|
|
var stream_pm_Prolog=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_Prolog");
|
|
try {
|
|
// XQueryParser.g:136:9: ( pm_Prolog p_QueryBody -> ^( MainModule pm_Prolog p_QueryBody ) )
|
|
// XQueryParser.g:136:11: pm_Prolog p_QueryBody
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Prolog_in_p_MainModule758);
|
|
pm_Prolog3=this.pm_Prolog();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_Prolog.add(pm_Prolog3.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QueryBody_in_p_MainModule760);
|
|
p_QueryBody4=this.p_QueryBody();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QueryBody.add(p_QueryBody4.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: pm_Prolog, p_QueryBody
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 137:17: -> ^( MainModule pm_Prolog p_QueryBody )
|
|
{
|
|
// XQueryParser.g:137:20: ^( MainModule pm_Prolog p_QueryBody )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(MainModule, "MainModule"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, vd);
|
|
this.adaptor.addChild(root_1, stream_pm_Prolog.nextTree());
|
|
this.adaptor.addChild(root_1, stream_p_QueryBody.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_LibraryModule_return: (function() {
|
|
XQueryParser.p_LibraryModule_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_LibraryModule_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:141:1: p_LibraryModule[vd] : p_ModuleDecl pm_Prolog -> ^( LibraryModule p_ModuleDecl pm_Prolog ) ;
|
|
// $ANTLR start "p_LibraryModule"
|
|
p_LibraryModule: function(vd) {
|
|
var retval = new XQueryParser.p_LibraryModule_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ModuleDecl5 = null;
|
|
var pm_Prolog6 = null;
|
|
|
|
var stream_pm_Prolog=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_Prolog");
|
|
var stream_p_ModuleDecl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_ModuleDecl");
|
|
try {
|
|
// XQueryParser.g:142:9: ( p_ModuleDecl pm_Prolog -> ^( LibraryModule p_ModuleDecl pm_Prolog ) )
|
|
// XQueryParser.g:142:11: p_ModuleDecl pm_Prolog
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ModuleDecl_in_p_LibraryModule816);
|
|
p_ModuleDecl5=this.p_ModuleDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ModuleDecl.add(p_ModuleDecl5.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Prolog_in_p_LibraryModule818);
|
|
pm_Prolog6=this.pm_Prolog();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_Prolog.add(pm_Prolog6.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_ModuleDecl, pm_Prolog
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 143:17: -> ^( LibraryModule p_ModuleDecl pm_Prolog )
|
|
{
|
|
// XQueryParser.g:143:20: ^( LibraryModule p_ModuleDecl pm_Prolog )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(LibraryModule, "LibraryModule"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, vd);
|
|
this.adaptor.addChild(root_1, stream_p_ModuleDecl.nextTree());
|
|
this.adaptor.addChild(root_1, stream_pm_Prolog.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ModuleDecl_return: (function() {
|
|
XQueryParser.p_ModuleDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ModuleDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:147:1: p_ModuleDecl : k+= MODULE k+= NAMESPACE p_NCName EQUAL p_StringLiteral SEMICOLON -> ^( ModuleDecl p_NCName p_StringLiteral ) ;
|
|
// $ANTLR start "p_ModuleDecl"
|
|
p_ModuleDecl: function() {
|
|
var retval = new XQueryParser.p_ModuleDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var EQUAL8 = null;
|
|
var SEMICOLON10 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_NCName7 = null;
|
|
var p_StringLiteral9 = null;
|
|
|
|
var EQUAL8_tree=null;
|
|
var SEMICOLON10_tree=null;
|
|
var k_tree=null;
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_MODULE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token MODULE");
|
|
var stream_NAMESPACE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token NAMESPACE");
|
|
var stream_EQUAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EQUAL");
|
|
var stream_p_NCName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_NCName");
|
|
var stream_p_StringLiteral=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_StringLiteral");
|
|
try {
|
|
// XQueryParser.g:148:9: (k+= MODULE k+= NAMESPACE p_NCName EQUAL p_StringLiteral SEMICOLON -> ^( ModuleDecl p_NCName p_StringLiteral ) )
|
|
// XQueryParser.g:148:11: k+= MODULE k+= NAMESPACE p_NCName EQUAL p_StringLiteral SEMICOLON
|
|
k=this.match(this.input,MODULE,XQueryParser.FOLLOW_MODULE_in_p_ModuleDecl874); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_MODULE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_p_ModuleDecl878); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_NAMESPACE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_ModuleDecl880);
|
|
p_NCName7=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_NCName.add(p_NCName7.getTree());
|
|
EQUAL8=this.match(this.input,EQUAL,XQueryParser.FOLLOW_EQUAL_in_p_ModuleDecl882); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EQUAL.add(EQUAL8);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_ModuleDecl884);
|
|
p_StringLiteral9=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(p_StringLiteral9.getTree());
|
|
SEMICOLON10=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_p_ModuleDecl886); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON10);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_StringLiteral, p_NCName
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 149:17: -> ^( ModuleDecl p_NCName p_StringLiteral )
|
|
{
|
|
// XQueryParser.g:149:21: ^( ModuleDecl p_NCName p_StringLiteral )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(ModuleDecl, "ModuleDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_p_NCName.nextTree());
|
|
this.adaptor.addChild(root_1, stream_p_StringLiteral.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_Prolog_return: (function() {
|
|
XQueryParser.pm_Prolog_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_Prolog_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:155:1: pm_Prolog : ( (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import ) )* od= pg_OrderedDecl -> ^( Prolog ^( DefaultNamespaceDecls ( $dnd)* ) ^( Setters ( $s)* ) ^( NamespaceDecls ( $nd)* ) ^( Imports ( $i)* ) ^( OrderedDecls ( $od)* ) ) ;
|
|
// $ANTLR start "pm_Prolog"
|
|
pm_Prolog: function() {
|
|
var retval = new XQueryParser.pm_Prolog_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var list_dnd=null;
|
|
var list_s=null;
|
|
var list_nd=null;
|
|
var list_i=null;
|
|
var od = null;
|
|
var dnd = null;
|
|
var s = null;
|
|
var nd = null;
|
|
var i = null;
|
|
var stream_pm_NamespaceDecl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_NamespaceDecl");
|
|
var stream_p_Import=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_Import");
|
|
var stream_p_Setter=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_Setter");
|
|
var stream_pm_DefaultNamespaceDecl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_DefaultNamespaceDecl");
|
|
var stream_pg_OrderedDecl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pg_OrderedDecl");
|
|
try {
|
|
// XQueryParser.g:156:9: ( ( (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import ) )* od= pg_OrderedDecl -> ^( Prolog ^( DefaultNamespaceDecls ( $dnd)* ) ^( Setters ( $s)* ) ^( NamespaceDecls ( $nd)* ) ^( Imports ( $i)* ) ^( OrderedDecls ( $od)* ) ) )
|
|
// XQueryParser.g:156:11: ( (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import ) )* od= pg_OrderedDecl
|
|
// XQueryParser.g:156:11: ( (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import ) )*
|
|
loop6:
|
|
do {
|
|
var alt6=2;
|
|
alt6 = this.dfa6.predict(this.input);
|
|
switch (alt6) {
|
|
case 1 :
|
|
// XQueryParser.g:156:12: (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import )
|
|
// XQueryParser.g:156:12: (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import )
|
|
var alt5=4;
|
|
var LA5_0 = this.input.LA(1);
|
|
|
|
if ( (LA5_0==DECLARE) ) {
|
|
var LA5_1 = this.input.LA(2);
|
|
|
|
if ( (LA5_1==DEFAULT) ) {
|
|
var LA5_3 = this.input.LA(3);
|
|
|
|
if ( (LA5_3==COLLATION||LA5_3==ORDER) ) {
|
|
alt5=2;
|
|
}
|
|
else if ( (LA5_3==ELEMENT||LA5_3==FUNCTION) ) {
|
|
alt5=1;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 5, 3, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( ((LA5_1>=BASE_URI && LA5_1<=BOUNDARY_SPACE)||LA5_1==CONSTRUCTION||LA5_1==ORDERING) ) {
|
|
alt5=2;
|
|
}
|
|
else if ( (LA5_1==REVALIDATION) && ((true))) {
|
|
alt5=2;
|
|
}
|
|
else if ( (LA5_1==COPY_NAMESPACES) ) {
|
|
alt5=2;
|
|
}
|
|
else if ( (LA5_1==NAMESPACE) ) {
|
|
alt5=3;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 5, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA5_0==IMPORT) ) {
|
|
alt5=4;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 5, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt5) {
|
|
case 1 :
|
|
// XQueryParser.g:156:13: dnd+= pm_DefaultNamespaceDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_DefaultNamespaceDecl_in_pm_Prolog945);
|
|
dnd=this.pm_DefaultNamespaceDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_DefaultNamespaceDecl.add(dnd.getTree());
|
|
if (org.antlr.lang.isNull(list_dnd)) list_dnd = [];
|
|
list_dnd.push(dnd.getTree());
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:156:44: s+= p_Setter
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Setter_in_pm_Prolog951);
|
|
s=this.p_Setter();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_Setter.add(s.getTree());
|
|
if (org.antlr.lang.isNull(list_s)) list_s = [];
|
|
list_s.push(s.getTree());
|
|
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:156:58: nd+= pm_NamespaceDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_NamespaceDecl_in_pm_Prolog957);
|
|
nd=this.pm_NamespaceDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_NamespaceDecl.add(nd.getTree());
|
|
if (org.antlr.lang.isNull(list_nd)) list_nd = [];
|
|
list_nd.push(nd.getTree());
|
|
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:156:81: i+= p_Import
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Import_in_pm_Prolog963);
|
|
i=this.p_Import();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_Import.add(i.getTree());
|
|
if (org.antlr.lang.isNull(list_i)) list_i = [];
|
|
list_i.push(i.getTree());
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop6;
|
|
}
|
|
} while (true);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_OrderedDecl_in_pm_Prolog970);
|
|
od=this.pg_OrderedDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pg_OrderedDecl.add(od.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: s, i, nd, od, dnd
|
|
// token labels:
|
|
// rule labels: retval, od
|
|
// token list labels:
|
|
// rule list labels: s, nd, dnd, i
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_od=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token od",od!=null?od.tree:null);
|
|
var stream_s=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token s",list_s);
|
|
var stream_nd=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token nd",list_nd);
|
|
var stream_dnd=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token dnd",list_dnd);
|
|
var stream_i=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token i",list_i);
|
|
root_0 = this.adaptor.nil();
|
|
// 157:17: -> ^( Prolog ^( DefaultNamespaceDecls ( $dnd)* ) ^( Setters ( $s)* ) ^( NamespaceDecls ( $nd)* ) ^( Imports ( $i)* ) ^( OrderedDecls ( $od)* ) )
|
|
{
|
|
// XQueryParser.g:157:21: ^( Prolog ^( DefaultNamespaceDecls ( $dnd)* ) ^( Setters ( $s)* ) ^( NamespaceDecls ( $nd)* ) ^( Imports ( $i)* ) ^( OrderedDecls ( $od)* ) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(Prolog, "Prolog"), root_1);
|
|
|
|
// XQueryParser.g:158:33: ^( DefaultNamespaceDecls ( $dnd)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(DefaultNamespaceDecls, "DefaultNamespaceDecls"), root_2);
|
|
|
|
// XQueryParser.g:158:57: ( $dnd)*
|
|
while ( stream_dnd.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_dnd.nextTree());
|
|
|
|
}
|
|
stream_dnd.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:159:33: ^( Setters ( $s)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(Setters, "Setters"), root_2);
|
|
|
|
// XQueryParser.g:159:43: ( $s)*
|
|
while ( stream_s.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_s.nextTree());
|
|
|
|
}
|
|
stream_s.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:160:33: ^( NamespaceDecls ( $nd)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(NamespaceDecls, "NamespaceDecls"), root_2);
|
|
|
|
// XQueryParser.g:160:50: ( $nd)*
|
|
while ( stream_nd.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_nd.nextTree());
|
|
|
|
}
|
|
stream_nd.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:161:33: ^( Imports ( $i)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(Imports, "Imports"), root_2);
|
|
|
|
// XQueryParser.g:161:43: ( $i)*
|
|
while ( stream_i.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_i.nextTree());
|
|
|
|
}
|
|
stream_i.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:162:33: ^( OrderedDecls ( $od)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(OrderedDecls, "OrderedDecls"), root_2);
|
|
|
|
// XQueryParser.g:162:48: ( $od)*
|
|
while ( stream_od.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_od.nextTree());
|
|
|
|
}
|
|
stream_od.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pg_OrderedDecl_return: (function() {
|
|
XQueryParser.pg_OrderedDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pg_OrderedDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:170:1: pg_OrderedDecl : ( pm_VarDecl | pm_ContextItemDecl | pm_FunctionDecl | pm_OptionDecl | {...}? => p_CollectionDecl | {...}? => p_IndexDecl | {...}? => p_ICDecl )* ;
|
|
// $ANTLR start "pg_OrderedDecl"
|
|
pg_OrderedDecl: function() {
|
|
var retval = new XQueryParser.pg_OrderedDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_VarDecl11 = null;
|
|
var pm_ContextItemDecl12 = null;
|
|
var pm_FunctionDecl13 = null;
|
|
var pm_OptionDecl14 = null;
|
|
var p_CollectionDecl15 = null;
|
|
var p_IndexDecl16 = null;
|
|
var p_ICDecl17 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:171:9: ( ( pm_VarDecl | pm_ContextItemDecl | pm_FunctionDecl | pm_OptionDecl | {...}? => p_CollectionDecl | {...}? => p_IndexDecl | {...}? => p_ICDecl )* )
|
|
// XQueryParser.g:171:11: ( pm_VarDecl | pm_ContextItemDecl | pm_FunctionDecl | pm_OptionDecl | {...}? => p_CollectionDecl | {...}? => p_IndexDecl | {...}? => p_ICDecl )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:171:11: ( pm_VarDecl | pm_ContextItemDecl | pm_FunctionDecl | pm_OptionDecl | {...}? => p_CollectionDecl | {...}? => p_IndexDecl | {...}? => p_ICDecl )*
|
|
loop7:
|
|
do {
|
|
var alt7=8;
|
|
alt7 = this.dfa7.predict(this.input);
|
|
switch (alt7) {
|
|
case 1 :
|
|
// XQueryParser.g:171:12: pm_VarDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_VarDecl_in_pg_OrderedDecl1248);
|
|
pm_VarDecl11=this.pm_VarDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_VarDecl11.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:171:25: pm_ContextItemDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_ContextItemDecl_in_pg_OrderedDecl1252);
|
|
pm_ContextItemDecl12=this.pm_ContextItemDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_ContextItemDecl12.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:171:46: pm_FunctionDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_FunctionDecl_in_pg_OrderedDecl1256);
|
|
pm_FunctionDecl13=this.pm_FunctionDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_FunctionDecl13.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:171:64: pm_OptionDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_OptionDecl_in_pg_OrderedDecl1260);
|
|
pm_OptionDecl14=this.pm_OptionDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_OptionDecl14.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:172:11: {...}? => p_CollectionDecl
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pg_OrderedDecl", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CollectionDecl_in_pg_OrderedDecl1275);
|
|
p_CollectionDecl15=this.p_CollectionDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CollectionDecl15.getTree());
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:173:11: {...}? => p_IndexDecl
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pg_OrderedDecl", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexDecl_in_pg_OrderedDecl1290);
|
|
p_IndexDecl16=this.p_IndexDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexDecl16.getTree());
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:174:11: {...}? => p_ICDecl
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pg_OrderedDecl", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICDecl_in_pg_OrderedDecl1305);
|
|
p_ICDecl17=this.p_ICDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICDecl17.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop7;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Setter_return: (function() {
|
|
XQueryParser.p_Setter_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Setter_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:179:1: p_Setter : ( pm_BoundarySpaceDecl | pm_DefaultCollationDecl | pm_BaseURIDecl | pm_ConstructionDecl | pm_OrderingModeDecl | pm_EmptyOrderDecl | {...}? => pm_RevalidationDecl | pm_CopyNamespacesDecl );
|
|
// $ANTLR start "p_Setter"
|
|
p_Setter: function() {
|
|
var retval = new XQueryParser.p_Setter_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_BoundarySpaceDecl18 = null;
|
|
var pm_DefaultCollationDecl19 = null;
|
|
var pm_BaseURIDecl20 = null;
|
|
var pm_ConstructionDecl21 = null;
|
|
var pm_OrderingModeDecl22 = null;
|
|
var pm_EmptyOrderDecl23 = null;
|
|
var pm_RevalidationDecl24 = null;
|
|
var pm_CopyNamespacesDecl25 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:180:9: ( pm_BoundarySpaceDecl | pm_DefaultCollationDecl | pm_BaseURIDecl | pm_ConstructionDecl | pm_OrderingModeDecl | pm_EmptyOrderDecl | {...}? => pm_RevalidationDecl | pm_CopyNamespacesDecl )
|
|
var alt8=8;
|
|
alt8 = this.dfa8.predict(this.input);
|
|
switch (alt8) {
|
|
case 1 :
|
|
// XQueryParser.g:180:11: pm_BoundarySpaceDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_BoundarySpaceDecl_in_p_Setter1334);
|
|
pm_BoundarySpaceDecl18=this.pm_BoundarySpaceDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_BoundarySpaceDecl18.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:181:11: pm_DefaultCollationDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_DefaultCollationDecl_in_p_Setter1346);
|
|
pm_DefaultCollationDecl19=this.pm_DefaultCollationDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_DefaultCollationDecl19.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:182:11: pm_BaseURIDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_BaseURIDecl_in_p_Setter1358);
|
|
pm_BaseURIDecl20=this.pm_BaseURIDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_BaseURIDecl20.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:183:11: pm_ConstructionDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_ConstructionDecl_in_p_Setter1370);
|
|
pm_ConstructionDecl21=this.pm_ConstructionDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_ConstructionDecl21.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:184:11: pm_OrderingModeDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_OrderingModeDecl_in_p_Setter1382);
|
|
pm_OrderingModeDecl22=this.pm_OrderingModeDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_OrderingModeDecl22.getTree());
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:185:11: pm_EmptyOrderDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_EmptyOrderDecl_in_p_Setter1394);
|
|
pm_EmptyOrderDecl23=this.pm_EmptyOrderDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_EmptyOrderDecl23.getTree());
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:186:11: {...}? => pm_RevalidationDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_Setter", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_RevalidationDecl_in_p_Setter1409);
|
|
pm_RevalidationDecl24=this.pm_RevalidationDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_RevalidationDecl24.getTree());
|
|
|
|
|
|
break;
|
|
case 8 :
|
|
// XQueryParser.g:187:11: pm_CopyNamespacesDecl
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_CopyNamespacesDecl_in_p_Setter1421);
|
|
pm_CopyNamespacesDecl25=this.pm_CopyNamespacesDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_CopyNamespacesDecl25.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Import_return: (function() {
|
|
XQueryParser.p_Import_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Import_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:191:1: p_Import : ( pm_SchemaImport | pm_ModuleImport );
|
|
// $ANTLR start "p_Import"
|
|
p_Import: function() {
|
|
var retval = new XQueryParser.p_Import_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_SchemaImport26 = null;
|
|
var pm_ModuleImport27 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:192:9: ( pm_SchemaImport | pm_ModuleImport )
|
|
var alt9=2;
|
|
var LA9_0 = this.input.LA(1);
|
|
|
|
if ( (LA9_0==IMPORT) ) {
|
|
var LA9_1 = this.input.LA(2);
|
|
|
|
if ( (LA9_1==SCHEMA) ) {
|
|
alt9=1;
|
|
}
|
|
else if ( (LA9_1==MODULE) ) {
|
|
alt9=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 9, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 9, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt9) {
|
|
case 1 :
|
|
// XQueryParser.g:192:11: pm_SchemaImport
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_SchemaImport_in_p_Import1447);
|
|
pm_SchemaImport26=this.pm_SchemaImport();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_SchemaImport26.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:192:29: pm_ModuleImport
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_ModuleImport_in_p_Import1451);
|
|
pm_ModuleImport27=this.pm_ModuleImport();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_ModuleImport27.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_NamespaceDecl_return: (function() {
|
|
XQueryParser.pm_NamespaceDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_NamespaceDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:199:1: pm_NamespaceDecl : k+= DECLARE k+= NAMESPACE nn= p_NCName EQUAL us= p_StringLiteral SEMICOLON -> ^( NamespaceDecl $nn $us) ;
|
|
// $ANTLR start "pm_NamespaceDecl"
|
|
pm_NamespaceDecl: function() {
|
|
var retval = new XQueryParser.pm_NamespaceDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var EQUAL28 = null;
|
|
var SEMICOLON29 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var nn = null;
|
|
var us = null;
|
|
|
|
var EQUAL28_tree=null;
|
|
var SEMICOLON29_tree=null;
|
|
var k_tree=null;
|
|
var stream_DECLARE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DECLARE");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_NAMESPACE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token NAMESPACE");
|
|
var stream_EQUAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EQUAL");
|
|
var stream_p_NCName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_NCName");
|
|
var stream_p_StringLiteral=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_StringLiteral");
|
|
try {
|
|
// XQueryParser.g:200:9: (k+= DECLARE k+= NAMESPACE nn= p_NCName EQUAL us= p_StringLiteral SEMICOLON -> ^( NamespaceDecl $nn $us) )
|
|
// XQueryParser.g:200:11: k+= DECLARE k+= NAMESPACE nn= p_NCName EQUAL us= p_StringLiteral SEMICOLON
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_NamespaceDecl1482); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DECLARE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_pm_NamespaceDecl1486); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_NAMESPACE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_pm_NamespaceDecl1490);
|
|
nn=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_NCName.add(nn.getTree());
|
|
EQUAL28=this.match(this.input,EQUAL,XQueryParser.FOLLOW_EQUAL_in_pm_NamespaceDecl1492); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EQUAL.add(EQUAL28);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_NamespaceDecl1496);
|
|
us=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(us.getTree());
|
|
SEMICOLON29=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_NamespaceDecl1498); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON29);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: us, nn
|
|
// token labels:
|
|
// rule labels: retval, nn, us
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_nn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token nn",nn!=null?nn.tree:null);
|
|
var stream_us=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token us",us!=null?us.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 201:17: -> ^( NamespaceDecl $nn $us)
|
|
{
|
|
// XQueryParser.g:201:20: ^( NamespaceDecl $nn $us)
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(NamespaceDecl, "NamespaceDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_nn.nextTree());
|
|
this.adaptor.addChild(root_1, stream_us.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_BoundarySpaceDecl_return: (function() {
|
|
XQueryParser.pm_BoundarySpaceDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_BoundarySpaceDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:205:1: pm_BoundarySpaceDecl : k+= DECLARE k+= BOUNDARY_SPACE (k+= PRESERVE | k+= STRIP ) SEMICOLON ;
|
|
// $ANTLR start "pm_BoundarySpaceDecl"
|
|
pm_BoundarySpaceDecl: function() {
|
|
var retval = new XQueryParser.pm_BoundarySpaceDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON30 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var SEMICOLON30_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:206:9: (k+= DECLARE k+= BOUNDARY_SPACE (k+= PRESERVE | k+= STRIP ) SEMICOLON )
|
|
// XQueryParser.g:206:13: k+= DECLARE k+= BOUNDARY_SPACE (k+= PRESERVE | k+= STRIP ) SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_BoundarySpaceDecl1561); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,BOUNDARY_SPACE,XQueryParser.FOLLOW_BOUNDARY_SPACE_in_pm_BoundarySpaceDecl1565); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:206:42: (k+= PRESERVE | k+= STRIP )
|
|
var alt10=2;
|
|
var LA10_0 = this.input.LA(1);
|
|
|
|
if ( (LA10_0==PRESERVE) ) {
|
|
alt10=1;
|
|
}
|
|
else if ( (LA10_0==STRIP) ) {
|
|
alt10=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 10, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt10) {
|
|
case 1 :
|
|
// XQueryParser.g:206:43: k+= PRESERVE
|
|
k=this.match(this.input,PRESERVE,XQueryParser.FOLLOW_PRESERVE_in_pm_BoundarySpaceDecl1570); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:206:57: k+= STRIP
|
|
k=this.match(this.input,STRIP,XQueryParser.FOLLOW_STRIP_in_pm_BoundarySpaceDecl1576); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON30=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_BoundarySpaceDecl1579); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON30_tree = this.adaptor.create(SEMICOLON30);
|
|
this.adaptor.addChild(root_0, SEMICOLON30_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_DefaultNamespaceDecl_return: (function() {
|
|
XQueryParser.pm_DefaultNamespaceDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_DefaultNamespaceDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:210:1: pm_DefaultNamespaceDecl : k+= DECLARE k+= DEFAULT (k+= ELEMENT | k+= FUNCTION ) k+= NAMESPACE p_StringLiteral SEMICOLON ;
|
|
// $ANTLR start "pm_DefaultNamespaceDecl"
|
|
pm_DefaultNamespaceDecl: function() {
|
|
var retval = new XQueryParser.pm_DefaultNamespaceDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON32 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_StringLiteral31 = null;
|
|
|
|
var SEMICOLON32_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:211:9: (k+= DECLARE k+= DEFAULT (k+= ELEMENT | k+= FUNCTION ) k+= NAMESPACE p_StringLiteral SEMICOLON )
|
|
// XQueryParser.g:211:11: k+= DECLARE k+= DEFAULT (k+= ELEMENT | k+= FUNCTION ) k+= NAMESPACE p_StringLiteral SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_DefaultNamespaceDecl1607); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,DEFAULT,XQueryParser.FOLLOW_DEFAULT_in_pm_DefaultNamespaceDecl1611); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:211:33: (k+= ELEMENT | k+= FUNCTION )
|
|
var alt11=2;
|
|
var LA11_0 = this.input.LA(1);
|
|
|
|
if ( (LA11_0==ELEMENT) ) {
|
|
alt11=1;
|
|
}
|
|
else if ( (LA11_0==FUNCTION) ) {
|
|
alt11=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 11, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt11) {
|
|
case 1 :
|
|
// XQueryParser.g:211:34: k+= ELEMENT
|
|
k=this.match(this.input,ELEMENT,XQueryParser.FOLLOW_ELEMENT_in_pm_DefaultNamespaceDecl1616); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:211:47: k+= FUNCTION
|
|
k=this.match(this.input,FUNCTION,XQueryParser.FOLLOW_FUNCTION_in_pm_DefaultNamespaceDecl1622); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_pm_DefaultNamespaceDecl1627); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_DefaultNamespaceDecl1629);
|
|
p_StringLiteral31=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral31.getTree());
|
|
SEMICOLON32=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_DefaultNamespaceDecl1631); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON32_tree = this.adaptor.create(SEMICOLON32);
|
|
this.adaptor.addChild(root_0, SEMICOLON32_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_OptionDecl_return: (function() {
|
|
XQueryParser.pm_OptionDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_OptionDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:215:1: pm_OptionDecl : k+= DECLARE k+= OPTION p_QName p_StringLiteral SEMICOLON ;
|
|
// $ANTLR start "pm_OptionDecl"
|
|
pm_OptionDecl: function() {
|
|
var retval = new XQueryParser.pm_OptionDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON35 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName33 = null;
|
|
var p_StringLiteral34 = null;
|
|
|
|
var SEMICOLON35_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:216:9: (k+= DECLARE k+= OPTION p_QName p_StringLiteral SEMICOLON )
|
|
// XQueryParser.g:216:13: k+= DECLARE k+= OPTION p_QName p_StringLiteral SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_OptionDecl1662); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,OPTION,XQueryParser.FOLLOW_OPTION_in_pm_OptionDecl1666); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_pm_OptionDecl1668);
|
|
p_QName33=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName33.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_OptionDecl1670);
|
|
p_StringLiteral34=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral34.getTree());
|
|
SEMICOLON35=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_OptionDecl1672); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON35_tree = this.adaptor.create(SEMICOLON35);
|
|
this.adaptor.addChild(root_0, SEMICOLON35_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_OrderingModeDecl_return: (function() {
|
|
XQueryParser.pm_OrderingModeDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_OrderingModeDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:220:1: pm_OrderingModeDecl : k+= DECLARE k+= ORDERING (k+= ORDERED | k+= UNORDERED ) SEMICOLON ;
|
|
// $ANTLR start "pm_OrderingModeDecl"
|
|
pm_OrderingModeDecl: function() {
|
|
var retval = new XQueryParser.pm_OrderingModeDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON36 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var SEMICOLON36_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:221:9: (k+= DECLARE k+= ORDERING (k+= ORDERED | k+= UNORDERED ) SEMICOLON )
|
|
// XQueryParser.g:221:13: k+= DECLARE k+= ORDERING (k+= ORDERED | k+= UNORDERED ) SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_OrderingModeDecl1703); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,ORDERING,XQueryParser.FOLLOW_ORDERING_in_pm_OrderingModeDecl1707); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:221:36: (k+= ORDERED | k+= UNORDERED )
|
|
var alt12=2;
|
|
var LA12_0 = this.input.LA(1);
|
|
|
|
if ( (LA12_0==ORDERED) ) {
|
|
alt12=1;
|
|
}
|
|
else if ( (LA12_0==UNORDERED) ) {
|
|
alt12=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 12, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt12) {
|
|
case 1 :
|
|
// XQueryParser.g:221:37: k+= ORDERED
|
|
k=this.match(this.input,ORDERED,XQueryParser.FOLLOW_ORDERED_in_pm_OrderingModeDecl1712); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:221:50: k+= UNORDERED
|
|
k=this.match(this.input,UNORDERED,XQueryParser.FOLLOW_UNORDERED_in_pm_OrderingModeDecl1718); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON36=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_OrderingModeDecl1721); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON36_tree = this.adaptor.create(SEMICOLON36);
|
|
this.adaptor.addChild(root_0, SEMICOLON36_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_EmptyOrderDecl_return: (function() {
|
|
XQueryParser.pm_EmptyOrderDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_EmptyOrderDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:225:1: pm_EmptyOrderDecl : k+= DECLARE k+= DEFAULT k+= ORDER k+= EMPTY (k+= GREATEST | k+= LEAST ) SEMICOLON ;
|
|
// $ANTLR start "pm_EmptyOrderDecl"
|
|
pm_EmptyOrderDecl: function() {
|
|
var retval = new XQueryParser.pm_EmptyOrderDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON37 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var SEMICOLON37_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:226:9: (k+= DECLARE k+= DEFAULT k+= ORDER k+= EMPTY (k+= GREATEST | k+= LEAST ) SEMICOLON )
|
|
// XQueryParser.g:226:13: k+= DECLARE k+= DEFAULT k+= ORDER k+= EMPTY (k+= GREATEST | k+= LEAST ) SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_EmptyOrderDecl1752); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,DEFAULT,XQueryParser.FOLLOW_DEFAULT_in_pm_EmptyOrderDecl1756); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,ORDER,XQueryParser.FOLLOW_ORDER_in_pm_EmptyOrderDecl1760); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,EMPTY,XQueryParser.FOLLOW_EMPTY_in_pm_EmptyOrderDecl1764); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:226:53: (k+= GREATEST | k+= LEAST )
|
|
var alt13=2;
|
|
var LA13_0 = this.input.LA(1);
|
|
|
|
if ( (LA13_0==GREATEST) ) {
|
|
alt13=1;
|
|
}
|
|
else if ( (LA13_0==LEAST) ) {
|
|
alt13=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 13, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt13) {
|
|
case 1 :
|
|
// XQueryParser.g:226:54: k+= GREATEST
|
|
k=this.match(this.input,GREATEST,XQueryParser.FOLLOW_GREATEST_in_pm_EmptyOrderDecl1769); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:226:68: k+= LEAST
|
|
k=this.match(this.input,LEAST,XQueryParser.FOLLOW_LEAST_in_pm_EmptyOrderDecl1775); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON37=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_EmptyOrderDecl1778); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON37_tree = this.adaptor.create(SEMICOLON37);
|
|
this.adaptor.addChild(root_0, SEMICOLON37_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_CopyNamespacesDecl_return: (function() {
|
|
XQueryParser.pm_CopyNamespacesDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_CopyNamespacesDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:230:1: pm_CopyNamespacesDecl : k+= DECLARE k+= COPY_NAMESPACES p_PreserveMode COMMA p_InheritMode SEMICOLON ;
|
|
// $ANTLR start "pm_CopyNamespacesDecl"
|
|
pm_CopyNamespacesDecl: function() {
|
|
var retval = new XQueryParser.pm_CopyNamespacesDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA39 = null;
|
|
var SEMICOLON41 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_PreserveMode38 = null;
|
|
var p_InheritMode40 = null;
|
|
|
|
var COMMA39_tree=null;
|
|
var SEMICOLON41_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:231:9: (k+= DECLARE k+= COPY_NAMESPACES p_PreserveMode COMMA p_InheritMode SEMICOLON )
|
|
// XQueryParser.g:231:13: k+= DECLARE k+= COPY_NAMESPACES p_PreserveMode COMMA p_InheritMode SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_CopyNamespacesDecl1809); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,COPY_NAMESPACES,XQueryParser.FOLLOW_COPY_NAMESPACES_in_pm_CopyNamespacesDecl1813); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PreserveMode_in_pm_CopyNamespacesDecl1815);
|
|
p_PreserveMode38=this.p_PreserveMode();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PreserveMode38.getTree());
|
|
COMMA39=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_pm_CopyNamespacesDecl1817); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA39_tree = this.adaptor.create(COMMA39);
|
|
this.adaptor.addChild(root_0, COMMA39_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InheritMode_in_pm_CopyNamespacesDecl1819);
|
|
p_InheritMode40=this.p_InheritMode();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InheritMode40.getTree());
|
|
SEMICOLON41=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_CopyNamespacesDecl1821); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON41_tree = this.adaptor.create(SEMICOLON41);
|
|
this.adaptor.addChild(root_0, SEMICOLON41_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DecimalFormatDecl_return: (function() {
|
|
XQueryParser.p_DecimalFormatDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DecimalFormatDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:235:1: p_DecimalFormatDecl : k+= DECLARE ( ( DECIMAL_FORMAT p_QName ) | ( DEFAULT DECIMAL_FORMAT ) ) ( p_DFPropertyName ) EQ p_StringLiteral SEMICOLON ;
|
|
// $ANTLR start "p_DecimalFormatDecl"
|
|
p_DecimalFormatDecl: function() {
|
|
var retval = new XQueryParser.p_DecimalFormatDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DECIMAL_FORMAT42 = null;
|
|
var DEFAULT44 = null;
|
|
var DECIMAL_FORMAT45 = null;
|
|
var EQ47 = null;
|
|
var SEMICOLON49 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName43 = null;
|
|
var p_DFPropertyName46 = null;
|
|
var p_StringLiteral48 = null;
|
|
|
|
var DECIMAL_FORMAT42_tree=null;
|
|
var DEFAULT44_tree=null;
|
|
var DECIMAL_FORMAT45_tree=null;
|
|
var EQ47_tree=null;
|
|
var SEMICOLON49_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:236:9: (k+= DECLARE ( ( DECIMAL_FORMAT p_QName ) | ( DEFAULT DECIMAL_FORMAT ) ) ( p_DFPropertyName ) EQ p_StringLiteral SEMICOLON )
|
|
// XQueryParser.g:236:13: k+= DECLARE ( ( DECIMAL_FORMAT p_QName ) | ( DEFAULT DECIMAL_FORMAT ) ) ( p_DFPropertyName ) EQ p_StringLiteral SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_p_DecimalFormatDecl1852); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:236:24: ( ( DECIMAL_FORMAT p_QName ) | ( DEFAULT DECIMAL_FORMAT ) )
|
|
var alt14=2;
|
|
var LA14_0 = this.input.LA(1);
|
|
|
|
if ( (LA14_0==DECIMAL_FORMAT) ) {
|
|
alt14=1;
|
|
}
|
|
else if ( (LA14_0==DEFAULT) ) {
|
|
alt14=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 14, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt14) {
|
|
case 1 :
|
|
// XQueryParser.g:236:25: ( DECIMAL_FORMAT p_QName )
|
|
// XQueryParser.g:236:25: ( DECIMAL_FORMAT p_QName )
|
|
// XQueryParser.g:236:26: DECIMAL_FORMAT p_QName
|
|
DECIMAL_FORMAT42=this.match(this.input,DECIMAL_FORMAT,XQueryParser.FOLLOW_DECIMAL_FORMAT_in_p_DecimalFormatDecl1856); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DECIMAL_FORMAT42_tree = this.adaptor.create(DECIMAL_FORMAT42);
|
|
this.adaptor.addChild(root_0, DECIMAL_FORMAT42_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_DecimalFormatDecl1858);
|
|
p_QName43=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName43.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:236:52: ( DEFAULT DECIMAL_FORMAT )
|
|
// XQueryParser.g:236:52: ( DEFAULT DECIMAL_FORMAT )
|
|
// XQueryParser.g:236:53: DEFAULT DECIMAL_FORMAT
|
|
DEFAULT44=this.match(this.input,DEFAULT,XQueryParser.FOLLOW_DEFAULT_in_p_DecimalFormatDecl1864); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DEFAULT44_tree = this.adaptor.create(DEFAULT44);
|
|
this.adaptor.addChild(root_0, DEFAULT44_tree);
|
|
}
|
|
DECIMAL_FORMAT45=this.match(this.input,DECIMAL_FORMAT,XQueryParser.FOLLOW_DECIMAL_FORMAT_in_p_DecimalFormatDecl1866); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DECIMAL_FORMAT45_tree = this.adaptor.create(DECIMAL_FORMAT45);
|
|
this.adaptor.addChild(root_0, DECIMAL_FORMAT45_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:236:78: ( p_DFPropertyName )
|
|
// XQueryParser.g:236:79: p_DFPropertyName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DFPropertyName_in_p_DecimalFormatDecl1871);
|
|
p_DFPropertyName46=this.p_DFPropertyName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DFPropertyName46.getTree());
|
|
|
|
|
|
|
|
EQ47=this.match(this.input,EQ,XQueryParser.FOLLOW_EQ_in_p_DecimalFormatDecl1874); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
EQ47_tree = this.adaptor.create(EQ47);
|
|
this.adaptor.addChild(root_0, EQ47_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_DecimalFormatDecl1876);
|
|
p_StringLiteral48=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral48.getTree());
|
|
SEMICOLON49=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_p_DecimalFormatDecl1878); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON49_tree = this.adaptor.create(SEMICOLON49);
|
|
this.adaptor.addChild(root_0, SEMICOLON49_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DFPropertyName_return: (function() {
|
|
XQueryParser.p_DFPropertyName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DFPropertyName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:240:1: p_DFPropertyName : (k= DECIMAL_SEPARATOR | k= GROUPING_SEPARATOR | k= INFINITY | k= MINUS_SIGN | k= NAN | k= PERCENT | k= PER_MILLE | k= ZERO_DIGIT | k= DIGIT | k= PATTERN_SEPARATOR );
|
|
// $ANTLR start "p_DFPropertyName"
|
|
p_DFPropertyName: function() {
|
|
var retval = new XQueryParser.p_DFPropertyName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:241:9: (k= DECIMAL_SEPARATOR | k= GROUPING_SEPARATOR | k= INFINITY | k= MINUS_SIGN | k= NAN | k= PERCENT | k= PER_MILLE | k= ZERO_DIGIT | k= DIGIT | k= PATTERN_SEPARATOR )
|
|
var alt15=10;
|
|
switch ( this.input.LA(1) ) {
|
|
case DECIMAL_SEPARATOR:
|
|
alt15=1;
|
|
break;
|
|
case GROUPING_SEPARATOR:
|
|
alt15=2;
|
|
break;
|
|
case INFINITY:
|
|
alt15=3;
|
|
break;
|
|
case MINUS_SIGN:
|
|
alt15=4;
|
|
break;
|
|
case NAN:
|
|
alt15=5;
|
|
break;
|
|
case PERCENT:
|
|
alt15=6;
|
|
break;
|
|
case PER_MILLE:
|
|
alt15=7;
|
|
break;
|
|
case ZERO_DIGIT:
|
|
alt15=8;
|
|
break;
|
|
case DIGIT:
|
|
alt15=9;
|
|
break;
|
|
case PATTERN_SEPARATOR:
|
|
alt15=10;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 15, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt15) {
|
|
case 1 :
|
|
// XQueryParser.g:241:11: k= DECIMAL_SEPARATOR
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECIMAL_SEPARATOR,XQueryParser.FOLLOW_DECIMAL_SEPARATOR_in_p_DFPropertyName1907); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:241:33: k= GROUPING_SEPARATOR
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,GROUPING_SEPARATOR,XQueryParser.FOLLOW_GROUPING_SEPARATOR_in_p_DFPropertyName1913); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:241:56: k= INFINITY
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,INFINITY,XQueryParser.FOLLOW_INFINITY_in_p_DFPropertyName1919); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:241:69: k= MINUS_SIGN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,MINUS_SIGN,XQueryParser.FOLLOW_MINUS_SIGN_in_p_DFPropertyName1925); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:241:84: k= NAN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,NAN,XQueryParser.FOLLOW_NAN_in_p_DFPropertyName1931); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:241:92: k= PERCENT
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,PERCENT,XQueryParser.FOLLOW_PERCENT_in_p_DFPropertyName1937); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:241:104: k= PER_MILLE
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,PER_MILLE,XQueryParser.FOLLOW_PER_MILLE_in_p_DFPropertyName1943); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 8 :
|
|
// XQueryParser.g:241:118: k= ZERO_DIGIT
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,ZERO_DIGIT,XQueryParser.FOLLOW_ZERO_DIGIT_in_p_DFPropertyName1949); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 9 :
|
|
// XQueryParser.g:241:133: k= DIGIT
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DIGIT,XQueryParser.FOLLOW_DIGIT_in_p_DFPropertyName1955); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 10 :
|
|
// XQueryParser.g:241:143: k= PATTERN_SEPARATOR
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,PATTERN_SEPARATOR,XQueryParser.FOLLOW_PATTERN_SEPARATOR_in_p_DFPropertyName1961); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PreserveMode_return: (function() {
|
|
XQueryParser.p_PreserveMode_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PreserveMode_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:245:1: p_PreserveMode : (k+= PRESERVE | k+= NO_PRESERVE ) ;
|
|
// $ANTLR start "p_PreserveMode"
|
|
p_PreserveMode: function() {
|
|
var retval = new XQueryParser.p_PreserveMode_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:246:9: ( (k+= PRESERVE | k+= NO_PRESERVE ) )
|
|
// XQueryParser.g:246:13: (k+= PRESERVE | k+= NO_PRESERVE )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:246:13: (k+= PRESERVE | k+= NO_PRESERVE )
|
|
var alt16=2;
|
|
var LA16_0 = this.input.LA(1);
|
|
|
|
if ( (LA16_0==PRESERVE) ) {
|
|
alt16=1;
|
|
}
|
|
else if ( (LA16_0==NO_PRESERVE) ) {
|
|
alt16=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 16, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt16) {
|
|
case 1 :
|
|
// XQueryParser.g:246:14: k+= PRESERVE
|
|
k=this.match(this.input,PRESERVE,XQueryParser.FOLLOW_PRESERVE_in_p_PreserveMode1993); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:246:28: k+= NO_PRESERVE
|
|
k=this.match(this.input,NO_PRESERVE,XQueryParser.FOLLOW_NO_PRESERVE_in_p_PreserveMode1999); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_InheritMode_return: (function() {
|
|
XQueryParser.p_InheritMode_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_InheritMode_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:250:1: p_InheritMode : (k+= INHERIT | k+= NO_INHERIT ) ;
|
|
// $ANTLR start "p_InheritMode"
|
|
p_InheritMode: function() {
|
|
var retval = new XQueryParser.p_InheritMode_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:251:9: ( (k+= INHERIT | k+= NO_INHERIT ) )
|
|
// XQueryParser.g:251:13: (k+= INHERIT | k+= NO_INHERIT )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:251:13: (k+= INHERIT | k+= NO_INHERIT )
|
|
var alt17=2;
|
|
var LA17_0 = this.input.LA(1);
|
|
|
|
if ( (LA17_0==INHERIT) ) {
|
|
alt17=1;
|
|
}
|
|
else if ( (LA17_0==NO_INHERIT) ) {
|
|
alt17=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 17, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt17) {
|
|
case 1 :
|
|
// XQueryParser.g:251:14: k+= INHERIT
|
|
k=this.match(this.input,INHERIT,XQueryParser.FOLLOW_INHERIT_in_p_InheritMode2032); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:251:27: k+= NO_INHERIT
|
|
k=this.match(this.input,NO_INHERIT,XQueryParser.FOLLOW_NO_INHERIT_in_p_InheritMode2038); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_DefaultCollationDecl_return: (function() {
|
|
XQueryParser.pm_DefaultCollationDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_DefaultCollationDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:255:1: pm_DefaultCollationDecl : k+= DECLARE k+= DEFAULT k+= COLLATION p_StringLiteral SEMICOLON ;
|
|
// $ANTLR start "pm_DefaultCollationDecl"
|
|
pm_DefaultCollationDecl: function() {
|
|
var retval = new XQueryParser.pm_DefaultCollationDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON51 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_StringLiteral50 = null;
|
|
|
|
var SEMICOLON51_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:256:9: (k+= DECLARE k+= DEFAULT k+= COLLATION p_StringLiteral SEMICOLON )
|
|
// XQueryParser.g:256:13: k+= DECLARE k+= DEFAULT k+= COLLATION p_StringLiteral SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_DefaultCollationDecl2078); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,DEFAULT,XQueryParser.FOLLOW_DEFAULT_in_pm_DefaultCollationDecl2082); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,COLLATION,XQueryParser.FOLLOW_COLLATION_in_pm_DefaultCollationDecl2086); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_DefaultCollationDecl2088);
|
|
p_StringLiteral50=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral50.getTree());
|
|
SEMICOLON51=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_DefaultCollationDecl2090); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON51_tree = this.adaptor.create(SEMICOLON51);
|
|
this.adaptor.addChild(root_0, SEMICOLON51_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_BaseURIDecl_return: (function() {
|
|
XQueryParser.pm_BaseURIDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_BaseURIDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:260:1: pm_BaseURIDecl : k+= DECLARE k+= BASE_URI sl= p_StringLiteral SEMICOLON -> ^( BaseURIDecl $sl) ;
|
|
// $ANTLR start "pm_BaseURIDecl"
|
|
pm_BaseURIDecl: function() {
|
|
var retval = new XQueryParser.pm_BaseURIDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON52 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var sl = null;
|
|
|
|
var SEMICOLON52_tree=null;
|
|
var k_tree=null;
|
|
var stream_DECLARE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DECLARE");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_BASE_URI=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token BASE_URI");
|
|
var stream_p_StringLiteral=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_StringLiteral");
|
|
try {
|
|
// XQueryParser.g:261:9: (k+= DECLARE k+= BASE_URI sl= p_StringLiteral SEMICOLON -> ^( BaseURIDecl $sl) )
|
|
// XQueryParser.g:261:13: k+= DECLARE k+= BASE_URI sl= p_StringLiteral SEMICOLON
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_BaseURIDecl2129); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DECLARE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,BASE_URI,XQueryParser.FOLLOW_BASE_URI_in_pm_BaseURIDecl2133); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_BASE_URI.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_BaseURIDecl2137);
|
|
sl=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(sl.getTree());
|
|
SEMICOLON52=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_BaseURIDecl2139); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON52);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: sl
|
|
// token labels:
|
|
// rule labels: sl, retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_sl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token sl",sl!=null?sl.tree:null);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 262:17: -> ^( BaseURIDecl $sl)
|
|
{
|
|
// XQueryParser.g:262:20: ^( BaseURIDecl $sl)
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(BaseURIDecl, "BaseURIDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_sl.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_SchemaImport_return: (function() {
|
|
XQueryParser.pm_SchemaImport_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_SchemaImport_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:266:1: pm_SchemaImport : k+= IMPORT k+= SCHEMA (sp= p_SchemaPrefix )? us= p_StringLiteral (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )? SEMICOLON -> ^( SchemaImport ^( SchemaPrefix ( $sp)? ) $us ^( AtHints ( $ah)* ) ) ;
|
|
// $ANTLR start "pm_SchemaImport"
|
|
pm_SchemaImport: function() {
|
|
var retval = new XQueryParser.pm_SchemaImport_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA53 = null;
|
|
var SEMICOLON54 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var list_ah=null;
|
|
var sp = null;
|
|
var us = null;
|
|
var ah = null;
|
|
var COMMA53_tree=null;
|
|
var SEMICOLON54_tree=null;
|
|
var k_tree=null;
|
|
var stream_AT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token AT");
|
|
var stream_IMPORT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token IMPORT");
|
|
var stream_SCHEMA=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SCHEMA");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_COMMA=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token COMMA");
|
|
var stream_p_SchemaPrefix=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_SchemaPrefix");
|
|
var stream_p_StringLiteral=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_StringLiteral");
|
|
try {
|
|
// XQueryParser.g:267:9: (k+= IMPORT k+= SCHEMA (sp= p_SchemaPrefix )? us= p_StringLiteral (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )? SEMICOLON -> ^( SchemaImport ^( SchemaPrefix ( $sp)? ) $us ^( AtHints ( $ah)* ) ) )
|
|
// XQueryParser.g:267:11: k+= IMPORT k+= SCHEMA (sp= p_SchemaPrefix )? us= p_StringLiteral (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )? SEMICOLON
|
|
k=this.match(this.input,IMPORT,XQueryParser.FOLLOW_IMPORT_in_pm_SchemaImport2193); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_IMPORT.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,SCHEMA,XQueryParser.FOLLOW_SCHEMA_in_pm_SchemaImport2197); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SCHEMA.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:267:33: (sp= p_SchemaPrefix )?
|
|
var alt18=2;
|
|
var LA18_0 = this.input.LA(1);
|
|
|
|
if ( (LA18_0==DEFAULT||LA18_0==NAMESPACE) ) {
|
|
alt18=1;
|
|
}
|
|
switch (alt18) {
|
|
case 1 :
|
|
// XQueryParser.g:267:33: sp= p_SchemaPrefix
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SchemaPrefix_in_pm_SchemaImport2201);
|
|
sp=this.p_SchemaPrefix();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_SchemaPrefix.add(sp.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_SchemaImport2206);
|
|
us=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(us.getTree());
|
|
// XQueryParser.g:267:69: (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )?
|
|
var alt20=2;
|
|
var LA20_0 = this.input.LA(1);
|
|
|
|
if ( (LA20_0==AT) ) {
|
|
alt20=1;
|
|
}
|
|
switch (alt20) {
|
|
case 1 :
|
|
// XQueryParser.g:267:70: k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )*
|
|
k=this.match(this.input,AT,XQueryParser.FOLLOW_AT_in_pm_SchemaImport2211); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_AT.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_SchemaImport2215);
|
|
ah=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(ah.getTree());
|
|
if (org.antlr.lang.isNull(list_ah)) list_ah = [];
|
|
list_ah.push(ah.getTree());
|
|
|
|
// XQueryParser.g:267:96: ( COMMA ah+= p_StringLiteral )*
|
|
loop19:
|
|
do {
|
|
var alt19=2;
|
|
var LA19_0 = this.input.LA(1);
|
|
|
|
if ( (LA19_0==COMMA) ) {
|
|
alt19=1;
|
|
}
|
|
|
|
|
|
switch (alt19) {
|
|
case 1 :
|
|
// XQueryParser.g:267:97: COMMA ah+= p_StringLiteral
|
|
COMMA53=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_pm_SchemaImport2218); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_COMMA.add(COMMA53);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_SchemaImport2222);
|
|
ah=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(ah.getTree());
|
|
if (org.antlr.lang.isNull(list_ah)) list_ah = [];
|
|
list_ah.push(ah.getTree());
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop19;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON54=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_SchemaImport2228); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON54);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: ah, sp, us
|
|
// token labels:
|
|
// rule labels: retval, sp, us
|
|
// token list labels:
|
|
// rule list labels: ah
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_sp=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token sp",sp!=null?sp.tree:null);
|
|
var stream_us=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token us",us!=null?us.tree:null);
|
|
var stream_ah=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token ah",list_ah);
|
|
root_0 = this.adaptor.nil();
|
|
// 268:17: -> ^( SchemaImport ^( SchemaPrefix ( $sp)? ) $us ^( AtHints ( $ah)* ) )
|
|
{
|
|
// XQueryParser.g:268:20: ^( SchemaImport ^( SchemaPrefix ( $sp)? ) $us ^( AtHints ( $ah)* ) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(SchemaImport, "SchemaImport"), root_1);
|
|
|
|
// XQueryParser.g:268:35: ^( SchemaPrefix ( $sp)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(SchemaPrefix, "SchemaPrefix"), root_2);
|
|
|
|
// XQueryParser.g:268:50: ( $sp)?
|
|
if ( stream_sp.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_sp.nextTree());
|
|
|
|
}
|
|
stream_sp.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
this.adaptor.addChild(root_1, stream_us.nextTree());
|
|
// XQueryParser.g:268:60: ^( AtHints ( $ah)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(AtHints, "AtHints"), root_2);
|
|
|
|
// XQueryParser.g:268:70: ( $ah)*
|
|
while ( stream_ah.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_ah.nextTree());
|
|
|
|
}
|
|
stream_ah.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SchemaPrefix_return: (function() {
|
|
XQueryParser.p_SchemaPrefix_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SchemaPrefix_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:272:1: p_SchemaPrefix : (k+= NAMESPACE nn= p_NCName EQUAL -> ^( NamespaceName $nn) | k+= DEFAULT k+= ELEMENT k+= NAMESPACE -> DefaultElementNamespace );
|
|
// $ANTLR start "p_SchemaPrefix"
|
|
p_SchemaPrefix: function() {
|
|
var retval = new XQueryParser.p_SchemaPrefix_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var EQUAL55 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var nn = null;
|
|
|
|
var EQUAL55_tree=null;
|
|
var k_tree=null;
|
|
var stream_ELEMENT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token ELEMENT");
|
|
var stream_NAMESPACE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token NAMESPACE");
|
|
var stream_EQUAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EQUAL");
|
|
var stream_DEFAULT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DEFAULT");
|
|
var stream_p_NCName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_NCName");
|
|
try {
|
|
// XQueryParser.g:273:9: (k+= NAMESPACE nn= p_NCName EQUAL -> ^( NamespaceName $nn) | k+= DEFAULT k+= ELEMENT k+= NAMESPACE -> DefaultElementNamespace )
|
|
var alt21=2;
|
|
var LA21_0 = this.input.LA(1);
|
|
|
|
if ( (LA21_0==NAMESPACE) ) {
|
|
alt21=1;
|
|
}
|
|
else if ( (LA21_0==DEFAULT) ) {
|
|
alt21=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 21, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt21) {
|
|
case 1 :
|
|
// XQueryParser.g:273:11: k+= NAMESPACE nn= p_NCName EQUAL
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_p_SchemaPrefix2299); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_NAMESPACE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_SchemaPrefix2303);
|
|
nn=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_NCName.add(nn.getTree());
|
|
EQUAL55=this.match(this.input,EQUAL,XQueryParser.FOLLOW_EQUAL_in_p_SchemaPrefix2305); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EQUAL.add(EQUAL55);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: nn
|
|
// token labels:
|
|
// rule labels: retval, nn
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_nn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token nn",nn!=null?nn.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 274:17: -> ^( NamespaceName $nn)
|
|
{
|
|
// XQueryParser.g:274:20: ^( NamespaceName $nn)
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(NamespaceName, "NamespaceName"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_nn.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:275:11: k+= DEFAULT k+= ELEMENT k+= NAMESPACE
|
|
k=this.match(this.input,DEFAULT,XQueryParser.FOLLOW_DEFAULT_in_p_SchemaPrefix2345); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DEFAULT.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,ELEMENT,XQueryParser.FOLLOW_ELEMENT_in_p_SchemaPrefix2349); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_ELEMENT.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_p_SchemaPrefix2353); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_NAMESPACE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements:
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 276:17: -> DefaultElementNamespace
|
|
{
|
|
this.adaptor.addChild(root_0, this.adaptor.create(DefaultElementNamespace, "DefaultElementNamespace"));
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_ModuleImport_return: (function() {
|
|
XQueryParser.pm_ModuleImport_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_ModuleImport_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:280:1: pm_ModuleImport : k+= IMPORT k+= MODULE (k+= NAMESPACE nn= p_NCName EQUAL )? us= p_StringLiteral (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )? SEMICOLON -> ^( ModuleImport ^( NamespaceName ( $nn)? ) $us ^( AtHints ( $ah)* ) ) ;
|
|
// $ANTLR start "pm_ModuleImport"
|
|
pm_ModuleImport: function() {
|
|
var retval = new XQueryParser.pm_ModuleImport_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var EQUAL56 = null;
|
|
var COMMA57 = null;
|
|
var SEMICOLON58 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var list_ah=null;
|
|
var nn = null;
|
|
var us = null;
|
|
var ah = null;
|
|
var EQUAL56_tree=null;
|
|
var COMMA57_tree=null;
|
|
var SEMICOLON58_tree=null;
|
|
var k_tree=null;
|
|
var stream_AT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token AT");
|
|
var stream_IMPORT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token IMPORT");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_MODULE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token MODULE");
|
|
var stream_COMMA=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token COMMA");
|
|
var stream_NAMESPACE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token NAMESPACE");
|
|
var stream_EQUAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EQUAL");
|
|
var stream_p_NCName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_NCName");
|
|
var stream_p_StringLiteral=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_StringLiteral");
|
|
try {
|
|
// XQueryParser.g:281:9: (k+= IMPORT k+= MODULE (k+= NAMESPACE nn= p_NCName EQUAL )? us= p_StringLiteral (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )? SEMICOLON -> ^( ModuleImport ^( NamespaceName ( $nn)? ) $us ^( AtHints ( $ah)* ) ) )
|
|
// XQueryParser.g:281:11: k+= IMPORT k+= MODULE (k+= NAMESPACE nn= p_NCName EQUAL )? us= p_StringLiteral (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )? SEMICOLON
|
|
k=this.match(this.input,IMPORT,XQueryParser.FOLLOW_IMPORT_in_pm_ModuleImport2402); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_IMPORT.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,MODULE,XQueryParser.FOLLOW_MODULE_in_pm_ModuleImport2406); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_MODULE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:281:31: (k+= NAMESPACE nn= p_NCName EQUAL )?
|
|
var alt22=2;
|
|
var LA22_0 = this.input.LA(1);
|
|
|
|
if ( (LA22_0==NAMESPACE) ) {
|
|
alt22=1;
|
|
}
|
|
switch (alt22) {
|
|
case 1 :
|
|
// XQueryParser.g:281:32: k+= NAMESPACE nn= p_NCName EQUAL
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_pm_ModuleImport2411); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_NAMESPACE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_pm_ModuleImport2415);
|
|
nn=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_NCName.add(nn.getTree());
|
|
EQUAL56=this.match(this.input,EQUAL,XQueryParser.FOLLOW_EQUAL_in_pm_ModuleImport2417); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EQUAL.add(EQUAL56);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_ModuleImport2423);
|
|
us=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(us.getTree());
|
|
// XQueryParser.g:281:84: (k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )* )?
|
|
var alt24=2;
|
|
var LA24_0 = this.input.LA(1);
|
|
|
|
if ( (LA24_0==AT) ) {
|
|
alt24=1;
|
|
}
|
|
switch (alt24) {
|
|
case 1 :
|
|
// XQueryParser.g:281:85: k+= AT ah+= p_StringLiteral ( COMMA ah+= p_StringLiteral )*
|
|
k=this.match(this.input,AT,XQueryParser.FOLLOW_AT_in_pm_ModuleImport2428); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_AT.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_ModuleImport2432);
|
|
ah=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(ah.getTree());
|
|
if (org.antlr.lang.isNull(list_ah)) list_ah = [];
|
|
list_ah.push(ah.getTree());
|
|
|
|
// XQueryParser.g:281:111: ( COMMA ah+= p_StringLiteral )*
|
|
loop23:
|
|
do {
|
|
var alt23=2;
|
|
var LA23_0 = this.input.LA(1);
|
|
|
|
if ( (LA23_0==COMMA) ) {
|
|
alt23=1;
|
|
}
|
|
|
|
|
|
switch (alt23) {
|
|
case 1 :
|
|
// XQueryParser.g:281:112: COMMA ah+= p_StringLiteral
|
|
COMMA57=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_pm_ModuleImport2435); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_COMMA.add(COMMA57);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_pm_ModuleImport2439);
|
|
ah=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_StringLiteral.add(ah.getTree());
|
|
if (org.antlr.lang.isNull(list_ah)) list_ah = [];
|
|
list_ah.push(ah.getTree());
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop23;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON58=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_ModuleImport2445); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON58);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: nn, us, ah
|
|
// token labels:
|
|
// rule labels: retval, nn, us
|
|
// token list labels:
|
|
// rule list labels: ah
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_nn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token nn",nn!=null?nn.tree:null);
|
|
var stream_us=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token us",us!=null?us.tree:null);
|
|
var stream_ah=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token ah",list_ah);
|
|
root_0 = this.adaptor.nil();
|
|
// 282:17: -> ^( ModuleImport ^( NamespaceName ( $nn)? ) $us ^( AtHints ( $ah)* ) )
|
|
{
|
|
// XQueryParser.g:282:20: ^( ModuleImport ^( NamespaceName ( $nn)? ) $us ^( AtHints ( $ah)* ) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(ModuleImport, "ModuleImport"), root_1);
|
|
|
|
// XQueryParser.g:282:35: ^( NamespaceName ( $nn)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(NamespaceName, "NamespaceName"), root_2);
|
|
|
|
// XQueryParser.g:282:51: ( $nn)?
|
|
if ( stream_nn.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_nn.nextTree());
|
|
|
|
}
|
|
stream_nn.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
this.adaptor.addChild(root_1, stream_us.nextTree());
|
|
// XQueryParser.g:282:61: ^( AtHints ( $ah)* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(AtHints, "AtHints"), root_2);
|
|
|
|
// XQueryParser.g:282:71: ( $ah)*
|
|
while ( stream_ah.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_ah.nextTree());
|
|
|
|
}
|
|
stream_ah.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_VarDecl_return: (function() {
|
|
XQueryParser.pm_VarDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_VarDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:286:1: pm_VarDecl : k+= DECLARE p_PrivateOption vdt= pg_VarDeclType DOLLAR qn= p_QName (td= p_TypeDeclaration )? ( ( BIND es= p_ExprSingle ) | (k+= EXTERNAL ( BIND des= p_ExprSingle )? ) ) SEMICOLON -> ^( VarDecl $vdt $qn ^( VarType ( $td)? ) ^( VarValue ( $es)? ^( VarDefaultValue ( $des)? ) ) ) ;
|
|
// $ANTLR start "pm_VarDecl"
|
|
pm_VarDecl: function() {
|
|
var retval = new XQueryParser.pm_VarDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR60 = null;
|
|
var BIND61 = null;
|
|
var BIND62 = null;
|
|
var SEMICOLON63 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var vdt = null;
|
|
var qn = null;
|
|
var td = null;
|
|
var es = null;
|
|
var des = null;
|
|
var p_PrivateOption59 = null;
|
|
|
|
var DOLLAR60_tree=null;
|
|
var BIND61_tree=null;
|
|
var BIND62_tree=null;
|
|
var SEMICOLON63_tree=null;
|
|
var k_tree=null;
|
|
var stream_DOLLAR=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DOLLAR");
|
|
var stream_DECLARE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DECLARE");
|
|
var stream_EXTERNAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EXTERNAL");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_BIND=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token BIND");
|
|
var stream_p_TypeDeclaration=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_TypeDeclaration");
|
|
var stream_p_QName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QName");
|
|
var stream_p_PrivateOption=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_PrivateOption");
|
|
var stream_p_ExprSingle=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_ExprSingle");
|
|
var stream_pg_VarDeclType=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pg_VarDeclType");
|
|
try {
|
|
// XQueryParser.g:287:9: (k+= DECLARE p_PrivateOption vdt= pg_VarDeclType DOLLAR qn= p_QName (td= p_TypeDeclaration )? ( ( BIND es= p_ExprSingle ) | (k+= EXTERNAL ( BIND des= p_ExprSingle )? ) ) SEMICOLON -> ^( VarDecl $vdt $qn ^( VarType ( $td)? ) ^( VarValue ( $es)? ^( VarDefaultValue ( $des)? ) ) ) )
|
|
// XQueryParser.g:287:11: k+= DECLARE p_PrivateOption vdt= pg_VarDeclType DOLLAR qn= p_QName (td= p_TypeDeclaration )? ( ( BIND es= p_ExprSingle ) | (k+= EXTERNAL ( BIND des= p_ExprSingle )? ) ) SEMICOLON
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_VarDecl2515); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DECLARE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PrivateOption_in_pm_VarDecl2517);
|
|
p_PrivateOption59=this.p_PrivateOption();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_PrivateOption.add(p_PrivateOption59.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_VarDeclType_in_pm_VarDecl2521);
|
|
vdt=this.pg_VarDeclType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pg_VarDeclType.add(vdt.getTree());
|
|
DOLLAR60=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_pm_VarDecl2523); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DOLLAR.add(DOLLAR60);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_pm_VarDecl2527);
|
|
qn=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(qn.getTree());
|
|
// XQueryParser.g:287:77: (td= p_TypeDeclaration )?
|
|
var alt25=2;
|
|
var LA25_0 = this.input.LA(1);
|
|
|
|
if ( (LA25_0==AS) ) {
|
|
alt25=1;
|
|
}
|
|
switch (alt25) {
|
|
case 1 :
|
|
// XQueryParser.g:287:77: td= p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_pm_VarDecl2531);
|
|
td=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_TypeDeclaration.add(td.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:287:97: ( ( BIND es= p_ExprSingle ) | (k+= EXTERNAL ( BIND des= p_ExprSingle )? ) )
|
|
var alt27=2;
|
|
var LA27_0 = this.input.LA(1);
|
|
|
|
if ( (LA27_0==BIND) ) {
|
|
alt27=1;
|
|
}
|
|
else if ( (LA27_0==EXTERNAL) ) {
|
|
alt27=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 27, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt27) {
|
|
case 1 :
|
|
// XQueryParser.g:287:98: ( BIND es= p_ExprSingle )
|
|
// XQueryParser.g:287:98: ( BIND es= p_ExprSingle )
|
|
// XQueryParser.g:287:99: BIND es= p_ExprSingle
|
|
BIND61=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_pm_VarDecl2536); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_BIND.add(BIND61);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_pm_VarDecl2540);
|
|
es=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ExprSingle.add(es.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:287:123: (k+= EXTERNAL ( BIND des= p_ExprSingle )? )
|
|
// XQueryParser.g:287:123: (k+= EXTERNAL ( BIND des= p_ExprSingle )? )
|
|
// XQueryParser.g:287:124: k+= EXTERNAL ( BIND des= p_ExprSingle )?
|
|
k=this.match(this.input,EXTERNAL,XQueryParser.FOLLOW_EXTERNAL_in_pm_VarDecl2548); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EXTERNAL.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:287:136: ( BIND des= p_ExprSingle )?
|
|
var alt26=2;
|
|
var LA26_0 = this.input.LA(1);
|
|
|
|
if ( (LA26_0==BIND) ) {
|
|
alt26=1;
|
|
}
|
|
switch (alt26) {
|
|
case 1 :
|
|
// XQueryParser.g:287:137: BIND des= p_ExprSingle
|
|
BIND62=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_pm_VarDecl2551); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_BIND.add(BIND62);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_pm_VarDecl2555);
|
|
des=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ExprSingle.add(des.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON63=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_VarDecl2561); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON63);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: des, td, es, vdt, qn
|
|
// token labels:
|
|
// rule labels: qn, retval, des, td, vdt, es
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_qn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token qn",qn!=null?qn.tree:null);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_des=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token des",des!=null?des.tree:null);
|
|
var stream_td=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token td",td!=null?td.tree:null);
|
|
var stream_vdt=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token vdt",vdt!=null?vdt.tree:null);
|
|
var stream_es=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token es",es!=null?es.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 288:17: -> ^( VarDecl $vdt $qn ^( VarType ( $td)? ) ^( VarValue ( $es)? ^( VarDefaultValue ( $des)? ) ) )
|
|
{
|
|
// XQueryParser.g:288:20: ^( VarDecl $vdt $qn ^( VarType ( $td)? ) ^( VarValue ( $es)? ^( VarDefaultValue ( $des)? ) ) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(VarDecl, "VarDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_vdt.nextTree());
|
|
this.adaptor.addChild(root_1, stream_qn.nextTree());
|
|
// XQueryParser.g:288:39: ^( VarType ( $td)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(VarType, "VarType"), root_2);
|
|
|
|
// XQueryParser.g:288:49: ( $td)?
|
|
if ( stream_td.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_td.nextTree());
|
|
|
|
}
|
|
stream_td.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:288:55: ^( VarValue ( $es)? ^( VarDefaultValue ( $des)? ) )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(VarValue, "VarValue"), root_2);
|
|
|
|
// XQueryParser.g:288:66: ( $es)?
|
|
if ( stream_es.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_es.nextTree());
|
|
|
|
}
|
|
stream_es.reset();
|
|
// XQueryParser.g:288:71: ^( VarDefaultValue ( $des)? )
|
|
{
|
|
var root_3 = this.adaptor.nil();
|
|
root_3 = this.adaptor.becomeRoot(this.adaptor.create(VarDefaultValue, "VarDefaultValue"), root_3);
|
|
|
|
// XQueryParser.g:288:89: ( $des)?
|
|
if ( stream_des.hasNext() ) {
|
|
this.adaptor.addChild(root_3, stream_des.nextTree());
|
|
|
|
}
|
|
stream_des.reset();
|
|
|
|
this.adaptor.addChild(root_2, root_3);
|
|
}
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pg_VarDeclType_return: (function() {
|
|
XQueryParser.pg_VarDeclType_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pg_VarDeclType_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:295:1: pg_VarDeclType : ({...}? =>ku= CONSTANT -> VarConstantDecl | kv= VARIABLE -> VarVariableDecl );
|
|
// $ANTLR start "pg_VarDeclType"
|
|
pg_VarDeclType: function() {
|
|
var retval = new XQueryParser.pg_VarDeclType_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ku = null;
|
|
var kv = null;
|
|
|
|
var ku_tree=null;
|
|
var kv_tree=null;
|
|
var stream_CONSTANT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token CONSTANT");
|
|
var stream_VARIABLE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token VARIABLE");
|
|
|
|
try {
|
|
// XQueryParser.g:296:9: ({...}? =>ku= CONSTANT -> VarConstantDecl | kv= VARIABLE -> VarVariableDecl )
|
|
var alt28=2;
|
|
var LA28_0 = this.input.LA(1);
|
|
|
|
if ( (LA28_0==CONSTANT) && ((true))) {
|
|
alt28=1;
|
|
}
|
|
else if ( (LA28_0==VARIABLE) ) {
|
|
alt28=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 28, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt28) {
|
|
case 1 :
|
|
// XQueryParser.g:296:11: {...}? =>ku= CONSTANT
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pg_VarDeclType", "true");
|
|
}
|
|
ku=this.match(this.input,CONSTANT,XQueryParser.FOLLOW_CONSTANT_in_pg_VarDeclType2648); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_CONSTANT.add(ku);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements:
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 297:17: -> VarConstantDecl
|
|
{
|
|
this.adaptor.addChild(root_0, this.adaptor.create(VarConstantDecl, "VarConstantDecl"));
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:298:11: kv= VARIABLE
|
|
kv=this.match(this.input,VARIABLE,XQueryParser.FOLLOW_VARIABLE_in_pg_VarDeclType2682); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_VARIABLE.add(kv);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements:
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 299:17: -> VarVariableDecl
|
|
{
|
|
this.adaptor.addChild(root_0, this.adaptor.create(VarVariableDecl, "VarVariableDecl"));
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_ContextItemDecl_return: (function() {
|
|
XQueryParser.pm_ContextItemDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_ContextItemDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:310:1: pm_ContextItemDecl : k+= DECLARE k+= CONTEXT k+= ITEM (k+= AS p_ItemType )? ( ( BIND p_ExprSingle ) | (k+= EXTERNAL ( BIND p_ExprSingle )? ) ) SEMICOLON ;
|
|
// $ANTLR start "pm_ContextItemDecl"
|
|
pm_ContextItemDecl: function() {
|
|
var retval = new XQueryParser.pm_ContextItemDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var BIND65 = null;
|
|
var BIND67 = null;
|
|
var SEMICOLON69 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_ItemType64 = null;
|
|
var p_ExprSingle66 = null;
|
|
var p_ExprSingle68 = null;
|
|
|
|
var BIND65_tree=null;
|
|
var BIND67_tree=null;
|
|
var SEMICOLON69_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:311:9: (k+= DECLARE k+= CONTEXT k+= ITEM (k+= AS p_ItemType )? ( ( BIND p_ExprSingle ) | (k+= EXTERNAL ( BIND p_ExprSingle )? ) ) SEMICOLON )
|
|
// XQueryParser.g:311:13: k+= DECLARE k+= CONTEXT k+= ITEM (k+= AS p_ItemType )? ( ( BIND p_ExprSingle ) | (k+= EXTERNAL ( BIND p_ExprSingle )? ) ) SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_ContextItemDecl2739); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,CONTEXT,XQueryParser.FOLLOW_CONTEXT_in_pm_ContextItemDecl2743); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,ITEM,XQueryParser.FOLLOW_ITEM_in_pm_ContextItemDecl2747); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:311:43: (k+= AS p_ItemType )?
|
|
var alt29=2;
|
|
var LA29_0 = this.input.LA(1);
|
|
|
|
if ( (LA29_0==AS) ) {
|
|
alt29=1;
|
|
}
|
|
switch (alt29) {
|
|
case 1 :
|
|
// XQueryParser.g:311:44: k+= AS p_ItemType
|
|
k=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_pm_ContextItemDecl2752); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ItemType_in_pm_ContextItemDecl2754);
|
|
p_ItemType64=this.p_ItemType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ItemType64.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:311:63: ( ( BIND p_ExprSingle ) | (k+= EXTERNAL ( BIND p_ExprSingle )? ) )
|
|
var alt31=2;
|
|
var LA31_0 = this.input.LA(1);
|
|
|
|
if ( (LA31_0==BIND) ) {
|
|
alt31=1;
|
|
}
|
|
else if ( (LA31_0==EXTERNAL) ) {
|
|
alt31=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 31, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt31) {
|
|
case 1 :
|
|
// XQueryParser.g:311:64: ( BIND p_ExprSingle )
|
|
// XQueryParser.g:311:64: ( BIND p_ExprSingle )
|
|
// XQueryParser.g:311:65: BIND p_ExprSingle
|
|
BIND65=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_pm_ContextItemDecl2760); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND65_tree = this.adaptor.create(BIND65);
|
|
this.adaptor.addChild(root_0, BIND65_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_pm_ContextItemDecl2762);
|
|
p_ExprSingle66=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle66.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:311:86: (k+= EXTERNAL ( BIND p_ExprSingle )? )
|
|
// XQueryParser.g:311:86: (k+= EXTERNAL ( BIND p_ExprSingle )? )
|
|
// XQueryParser.g:311:87: k+= EXTERNAL ( BIND p_ExprSingle )?
|
|
k=this.match(this.input,EXTERNAL,XQueryParser.FOLLOW_EXTERNAL_in_pm_ContextItemDecl2770); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:311:99: ( BIND p_ExprSingle )?
|
|
var alt30=2;
|
|
var LA30_0 = this.input.LA(1);
|
|
|
|
if ( (LA30_0==BIND) ) {
|
|
alt30=1;
|
|
}
|
|
switch (alt30) {
|
|
case 1 :
|
|
// XQueryParser.g:311:100: BIND p_ExprSingle
|
|
BIND67=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_pm_ContextItemDecl2773); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND67_tree = this.adaptor.create(BIND67);
|
|
this.adaptor.addChild(root_0, BIND67_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_pm_ContextItemDecl2775);
|
|
p_ExprSingle68=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle68.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON69=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_ContextItemDecl2781); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON69_tree = this.adaptor.create(SEMICOLON69);
|
|
this.adaptor.addChild(root_0, SEMICOLON69_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_ConstructionDecl_return: (function() {
|
|
XQueryParser.pm_ConstructionDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_ConstructionDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:318:1: pm_ConstructionDecl : k+= DECLARE k+= CONSTRUCTION (k+= STRIP | k+= PRESERVE ) SEMICOLON ;
|
|
// $ANTLR start "pm_ConstructionDecl"
|
|
pm_ConstructionDecl: function() {
|
|
var retval = new XQueryParser.pm_ConstructionDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON70 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var SEMICOLON70_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:319:9: (k+= DECLARE k+= CONSTRUCTION (k+= STRIP | k+= PRESERVE ) SEMICOLON )
|
|
// XQueryParser.g:319:13: k+= DECLARE k+= CONSTRUCTION (k+= STRIP | k+= PRESERVE ) SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_ConstructionDecl2815); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,CONSTRUCTION,XQueryParser.FOLLOW_CONSTRUCTION_in_pm_ConstructionDecl2819); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:319:40: (k+= STRIP | k+= PRESERVE )
|
|
var alt32=2;
|
|
var LA32_0 = this.input.LA(1);
|
|
|
|
if ( (LA32_0==STRIP) ) {
|
|
alt32=1;
|
|
}
|
|
else if ( (LA32_0==PRESERVE) ) {
|
|
alt32=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 32, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt32) {
|
|
case 1 :
|
|
// XQueryParser.g:319:41: k+= STRIP
|
|
k=this.match(this.input,STRIP,XQueryParser.FOLLOW_STRIP_in_pm_ConstructionDecl2824); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:319:52: k+= PRESERVE
|
|
k=this.match(this.input,PRESERVE,XQueryParser.FOLLOW_PRESERVE_in_pm_ConstructionDecl2830); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON70=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_ConstructionDecl2833); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON70_tree = this.adaptor.create(SEMICOLON70);
|
|
this.adaptor.addChild(root_0, SEMICOLON70_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_FunctionDecl_return: (function() {
|
|
XQueryParser.pm_FunctionDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_FunctionDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:325:1: pm_FunctionDecl : ({...}? =>k+= DECLARE k+= SEQUENTIAL k+= FUNCTION qn= p_QName LPAREN (pl= p_ParamList )? RPAREN (td= p_TypeDeclaration )? (b= p_Block | k+= EXTERNAL ) SEMICOLON -> ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $b)? ) | k+= DECLARE p_PrivateOption p_FunctionType k+= FUNCTION qn= p_QName LPAREN (pl= p_ParamList )? RPAREN (td= p_TypeDeclaration )? (ee= p_EnclosedExpr | k+= EXTERNAL ) SEMICOLON -> ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $ee)? ) );
|
|
// $ANTLR start "pm_FunctionDecl"
|
|
pm_FunctionDecl: function() {
|
|
var retval = new XQueryParser.pm_FunctionDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LPAREN71 = null;
|
|
var RPAREN72 = null;
|
|
var SEMICOLON73 = null;
|
|
var LPAREN76 = null;
|
|
var RPAREN77 = null;
|
|
var SEMICOLON78 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var qn = null;
|
|
var pl = null;
|
|
var td = null;
|
|
var b = null;
|
|
var ee = null;
|
|
var p_PrivateOption74 = null;
|
|
var p_FunctionType75 = null;
|
|
|
|
var LPAREN71_tree=null;
|
|
var RPAREN72_tree=null;
|
|
var SEMICOLON73_tree=null;
|
|
var LPAREN76_tree=null;
|
|
var RPAREN77_tree=null;
|
|
var SEMICOLON78_tree=null;
|
|
var k_tree=null;
|
|
var stream_FUNCTION=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token FUNCTION");
|
|
var stream_DECLARE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DECLARE");
|
|
var stream_RPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token RPAREN");
|
|
var stream_EXTERNAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EXTERNAL");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_SEQUENTIAL=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEQUENTIAL");
|
|
var stream_LPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token LPAREN");
|
|
var stream_p_Block=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_Block");
|
|
var stream_p_TypeDeclaration=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_TypeDeclaration");
|
|
var stream_p_QName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QName");
|
|
var stream_p_ParamList=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_ParamList");
|
|
var stream_p_PrivateOption=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_PrivateOption");
|
|
var stream_p_FunctionType=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_FunctionType");
|
|
var stream_p_EnclosedExpr=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_EnclosedExpr");
|
|
try {
|
|
// XQueryParser.g:326:9: ({...}? =>k+= DECLARE k+= SEQUENTIAL k+= FUNCTION qn= p_QName LPAREN (pl= p_ParamList )? RPAREN (td= p_TypeDeclaration )? (b= p_Block | k+= EXTERNAL ) SEMICOLON -> ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $b)? ) | k+= DECLARE p_PrivateOption p_FunctionType k+= FUNCTION qn= p_QName LPAREN (pl= p_ParamList )? RPAREN (td= p_TypeDeclaration )? (ee= p_EnclosedExpr | k+= EXTERNAL ) SEMICOLON -> ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $ee)? ) )
|
|
var alt39=2;
|
|
var LA39_0 = this.input.LA(1);
|
|
|
|
if ( (LA39_0==DECLARE) ) {
|
|
var LA39_1 = this.input.LA(2);
|
|
|
|
if ( (LA39_1==SEQUENTIAL) && ((true))) {
|
|
alt39=1;
|
|
}
|
|
else if ( (LA39_1==FUNCTION||LA39_1==UPDATING||LA39_1==SIMPLE||LA39_1==PRIVATE) ) {
|
|
alt39=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 39, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 39, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt39) {
|
|
case 1 :
|
|
// XQueryParser.g:326:13: {...}? =>k+= DECLARE k+= SEQUENTIAL k+= FUNCTION qn= p_QName LPAREN (pl= p_ParamList )? RPAREN (td= p_TypeDeclaration )? (b= p_Block | k+= EXTERNAL ) SEMICOLON
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pm_FunctionDecl", "true");
|
|
}
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_FunctionDecl2869); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DECLARE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,SEQUENTIAL,XQueryParser.FOLLOW_SEQUENTIAL_in_pm_FunctionDecl2873); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEQUENTIAL.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,FUNCTION,XQueryParser.FOLLOW_FUNCTION_in_pm_FunctionDecl2877); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_FUNCTION.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_pm_FunctionDecl2881);
|
|
qn=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(qn.getTree());
|
|
LPAREN71=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_pm_FunctionDecl2883); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LPAREN.add(LPAREN71);
|
|
|
|
// XQueryParser.g:326:80: (pl= p_ParamList )?
|
|
var alt33=2;
|
|
var LA33_0 = this.input.LA(1);
|
|
|
|
if ( (LA33_0==DOLLAR) ) {
|
|
alt33=1;
|
|
}
|
|
switch (alt33) {
|
|
case 1 :
|
|
// XQueryParser.g:326:80: pl= p_ParamList
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ParamList_in_pm_FunctionDecl2887);
|
|
pl=this.p_ParamList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ParamList.add(pl.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN72=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_pm_FunctionDecl2890); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RPAREN.add(RPAREN72);
|
|
|
|
// XQueryParser.g:326:103: (td= p_TypeDeclaration )?
|
|
var alt34=2;
|
|
var LA34_0 = this.input.LA(1);
|
|
|
|
if ( (LA34_0==AS) ) {
|
|
alt34=1;
|
|
}
|
|
switch (alt34) {
|
|
case 1 :
|
|
// XQueryParser.g:326:103: td= p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_pm_FunctionDecl2894);
|
|
td=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_TypeDeclaration.add(td.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:326:123: (b= p_Block | k+= EXTERNAL )
|
|
var alt35=2;
|
|
var LA35_0 = this.input.LA(1);
|
|
|
|
if ( (LA35_0==LBRACKET) ) {
|
|
alt35=1;
|
|
}
|
|
else if ( (LA35_0==EXTERNAL) ) {
|
|
alt35=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 35, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt35) {
|
|
case 1 :
|
|
// XQueryParser.g:326:124: b= p_Block
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Block_in_pm_FunctionDecl2900);
|
|
b=this.p_Block();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_Block.add(b.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:326:136: k+= EXTERNAL
|
|
k=this.match(this.input,EXTERNAL,XQueryParser.FOLLOW_EXTERNAL_in_pm_FunctionDecl2906); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EXTERNAL.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON73=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_FunctionDecl2909); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON73);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: b, qn, td, pl
|
|
// token labels:
|
|
// rule labels: qn, retval, b, pl, td
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_qn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token qn",qn!=null?qn.tree:null);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_b=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token b",b!=null?b.tree:null);
|
|
var stream_pl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token pl",pl!=null?pl.tree:null);
|
|
var stream_td=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token td",td!=null?td.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 327:17: -> ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $b)? )
|
|
{
|
|
// XQueryParser.g:327:20: ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $b)? )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(FunctionDecl, "FunctionDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_qn.nextTree());
|
|
// XQueryParser.g:327:39: ^( ParamList ( $pl)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(ParamList, "ParamList"), root_2);
|
|
|
|
// XQueryParser.g:327:51: ( $pl)?
|
|
if ( stream_pl.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_pl.nextTree());
|
|
|
|
}
|
|
stream_pl.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:327:57: ^( ReturnType ( $td)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(ReturnType, "ReturnType"), root_2);
|
|
|
|
// XQueryParser.g:327:70: ( $td)?
|
|
if ( stream_td.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_td.nextTree());
|
|
|
|
}
|
|
stream_td.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:327:76: ( $b)?
|
|
if ( stream_b.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_b.nextTree());
|
|
|
|
}
|
|
stream_b.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:328:13: k+= DECLARE p_PrivateOption p_FunctionType k+= FUNCTION qn= p_QName LPAREN (pl= p_ParamList )? RPAREN (td= p_TypeDeclaration )? (ee= p_EnclosedExpr | k+= EXTERNAL ) SEMICOLON
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_FunctionDecl2971); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DECLARE.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PrivateOption_in_pm_FunctionDecl2973);
|
|
p_PrivateOption74=this.p_PrivateOption();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_PrivateOption.add(p_PrivateOption74.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_FunctionType_in_pm_FunctionDecl2975);
|
|
p_FunctionType75=this.p_FunctionType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_FunctionType.add(p_FunctionType75.getTree());
|
|
k=this.match(this.input,FUNCTION,XQueryParser.FOLLOW_FUNCTION_in_pm_FunctionDecl2979); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_FUNCTION.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_pm_FunctionDecl2983);
|
|
qn=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(qn.getTree());
|
|
LPAREN76=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_pm_FunctionDecl2985); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LPAREN.add(LPAREN76);
|
|
|
|
// XQueryParser.g:328:87: (pl= p_ParamList )?
|
|
var alt36=2;
|
|
var LA36_0 = this.input.LA(1);
|
|
|
|
if ( (LA36_0==DOLLAR) ) {
|
|
alt36=1;
|
|
}
|
|
switch (alt36) {
|
|
case 1 :
|
|
// XQueryParser.g:328:87: pl= p_ParamList
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ParamList_in_pm_FunctionDecl2989);
|
|
pl=this.p_ParamList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ParamList.add(pl.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN77=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_pm_FunctionDecl2992); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RPAREN.add(RPAREN77);
|
|
|
|
// XQueryParser.g:328:110: (td= p_TypeDeclaration )?
|
|
var alt37=2;
|
|
var LA37_0 = this.input.LA(1);
|
|
|
|
if ( (LA37_0==AS) ) {
|
|
alt37=1;
|
|
}
|
|
switch (alt37) {
|
|
case 1 :
|
|
// XQueryParser.g:328:110: td= p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_pm_FunctionDecl2996);
|
|
td=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_TypeDeclaration.add(td.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:328:130: (ee= p_EnclosedExpr | k+= EXTERNAL )
|
|
var alt38=2;
|
|
var LA38_0 = this.input.LA(1);
|
|
|
|
if ( (LA38_0==LBRACKET) ) {
|
|
alt38=1;
|
|
}
|
|
else if ( (LA38_0==EXTERNAL) ) {
|
|
alt38=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 38, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt38) {
|
|
case 1 :
|
|
// XQueryParser.g:328:131: ee= p_EnclosedExpr
|
|
this.pushFollow(XQueryParser.FOLLOW_p_EnclosedExpr_in_pm_FunctionDecl3002);
|
|
ee=this.p_EnclosedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_EnclosedExpr.add(ee.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:328:151: k+= EXTERNAL
|
|
k=this.match(this.input,EXTERNAL,XQueryParser.FOLLOW_EXTERNAL_in_pm_FunctionDecl3008); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EXTERNAL.add(k);
|
|
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON78=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_FunctionDecl3011); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON78);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: qn, td, ee, pl
|
|
// token labels:
|
|
// rule labels: qn, retval, ee, pl, td
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_qn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token qn",qn!=null?qn.tree:null);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_ee=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token ee",ee!=null?ee.tree:null);
|
|
var stream_pl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token pl",pl!=null?pl.tree:null);
|
|
var stream_td=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token td",td!=null?td.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 329:17: -> ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $ee)? )
|
|
{
|
|
// XQueryParser.g:329:20: ^( FunctionDecl $qn ^( ParamList ( $pl)? ) ^( ReturnType ( $td)? ) ( $ee)? )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(FunctionDecl, "FunctionDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_qn.nextTree());
|
|
// XQueryParser.g:329:39: ^( ParamList ( $pl)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(ParamList, "ParamList"), root_2);
|
|
|
|
// XQueryParser.g:329:51: ( $pl)?
|
|
if ( stream_pl.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_pl.nextTree());
|
|
|
|
}
|
|
stream_pl.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:329:57: ^( ReturnType ( $td)? )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(ReturnType, "ReturnType"), root_2);
|
|
|
|
// XQueryParser.g:329:70: ( $td)?
|
|
if ( stream_td.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_td.nextTree());
|
|
|
|
}
|
|
stream_td.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:329:76: ( $ee)?
|
|
if ( stream_ee.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_ee.nextTree());
|
|
|
|
}
|
|
stream_ee.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_FunctionType_return: (function() {
|
|
XQueryParser.p_FunctionType_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_FunctionType_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:336:1: p_FunctionType : ({...}? =>ku= UPDATING | {...}? =>ks= SIMPLE | );
|
|
// $ANTLR start "p_FunctionType"
|
|
p_FunctionType: function() {
|
|
var retval = new XQueryParser.p_FunctionType_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ku = null;
|
|
var ks = null;
|
|
|
|
var ku_tree=null;
|
|
var ks_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:337:9: ({...}? =>ku= UPDATING | {...}? =>ks= SIMPLE | )
|
|
var alt40=3;
|
|
var LA40_0 = this.input.LA(1);
|
|
|
|
if ( (LA40_0==UPDATING) && ((true))) {
|
|
alt40=1;
|
|
}
|
|
else if ( (LA40_0==SIMPLE) && ((true))) {
|
|
alt40=2;
|
|
}
|
|
else if ( (LA40_0==FUNCTION) ) {
|
|
alt40=3;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 40, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt40) {
|
|
case 1 :
|
|
// XQueryParser.g:337:11: {...}? =>ku= UPDATING
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_FunctionType", "true");
|
|
}
|
|
ku=this.match(this.input,UPDATING,XQueryParser.FOLLOW_UPDATING_in_p_FunctionType3091); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ku_tree = this.adaptor.create(ku);
|
|
this.adaptor.addChild(root_0, ku_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:338:11: {...}? =>ks= SIMPLE
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_FunctionType", "true");
|
|
}
|
|
ks=this.match(this.input,SIMPLE,XQueryParser.FOLLOW_SIMPLE_in_p_FunctionType3108); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ks_tree = this.adaptor.create(ks);
|
|
this.adaptor.addChild(root_0, ks_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:340:9:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PrivateOption_return: (function() {
|
|
XQueryParser.p_PrivateOption_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PrivateOption_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:342:1: p_PrivateOption : ({...}? =>kv= PRIVATE | );
|
|
// $ANTLR start "p_PrivateOption"
|
|
p_PrivateOption: function() {
|
|
var retval = new XQueryParser.p_PrivateOption_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kv = null;
|
|
|
|
var kv_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:343:9: ({...}? =>kv= PRIVATE | )
|
|
var alt41=2;
|
|
var LA41_0 = this.input.LA(1);
|
|
|
|
if ( (LA41_0==PRIVATE) && ((false))) {
|
|
alt41=1;
|
|
}
|
|
else if ( (LA41_0==CONSTANT) && ((true))) {
|
|
alt41=2;
|
|
}
|
|
else if ( (LA41_0==VARIABLE) ) {
|
|
alt41=2;
|
|
}
|
|
else if ( (LA41_0==UPDATING||LA41_0==SIMPLE) && ((true))) {
|
|
alt41=2;
|
|
}
|
|
else if ( (LA41_0==FUNCTION) ) {
|
|
alt41=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 41, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt41) {
|
|
case 1 :
|
|
// XQueryParser.g:343:11: {...}? =>kv= PRIVATE
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((false)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_PrivateOption", "false");
|
|
}
|
|
kv=this.match(this.input,PRIVATE,XQueryParser.FOLLOW_PRIVATE_in_p_PrivateOption3150); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kv_tree = this.adaptor.create(kv);
|
|
this.adaptor.addChild(root_0, kv_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:345:9:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ParamList_return: (function() {
|
|
XQueryParser.p_ParamList_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ParamList_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:351:1: p_ParamList : p+= p_Param ( COMMA p+= p_Param )* -> ( $p)+ ;
|
|
// $ANTLR start "p_ParamList"
|
|
p_ParamList: function() {
|
|
var retval = new XQueryParser.p_ParamList_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA79 = null;
|
|
var list_p=null;
|
|
var p = null;
|
|
var COMMA79_tree=null;
|
|
var stream_COMMA=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token COMMA");
|
|
var stream_p_Param=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_Param");
|
|
try {
|
|
// XQueryParser.g:352:9: (p+= p_Param ( COMMA p+= p_Param )* -> ( $p)+ )
|
|
// XQueryParser.g:352:11: p+= p_Param ( COMMA p+= p_Param )*
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Param_in_p_ParamList3193);
|
|
p=this.p_Param();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_Param.add(p.getTree());
|
|
if (org.antlr.lang.isNull(list_p)) list_p = [];
|
|
list_p.push(p.getTree());
|
|
|
|
// XQueryParser.g:352:22: ( COMMA p+= p_Param )*
|
|
loop42:
|
|
do {
|
|
var alt42=2;
|
|
var LA42_0 = this.input.LA(1);
|
|
|
|
if ( (LA42_0==COMMA) ) {
|
|
alt42=1;
|
|
}
|
|
|
|
|
|
switch (alt42) {
|
|
case 1 :
|
|
// XQueryParser.g:352:23: COMMA p+= p_Param
|
|
COMMA79=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_ParamList3196); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_COMMA.add(COMMA79);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Param_in_p_ParamList3200);
|
|
p=this.p_Param();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_Param.add(p.getTree());
|
|
if (org.antlr.lang.isNull(list_p)) list_p = [];
|
|
list_p.push(p.getTree());
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop42;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels: p
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_p=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token p",list_p);
|
|
root_0 = this.adaptor.nil();
|
|
// 353:17: -> ( $p)+
|
|
{
|
|
if ( !(stream_p.hasNext()) ) {
|
|
throw new org.antlr.runtime.tree.RewriteEarlyExitException();
|
|
}
|
|
while ( stream_p.hasNext() ) {
|
|
this.adaptor.addChild(root_0, stream_p.nextTree());
|
|
|
|
}
|
|
stream_p.reset();
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Param_return: (function() {
|
|
XQueryParser.p_Param_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Param_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:357:1: p_Param : DOLLAR qn= p_QName (td= p_TypeDeclaration )? -> ^( Param $qn ( $td)? ) ;
|
|
// $ANTLR start "p_Param"
|
|
p_Param: function() {
|
|
var retval = new XQueryParser.p_Param_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR80 = null;
|
|
var qn = null;
|
|
var td = null;
|
|
|
|
var DOLLAR80_tree=null;
|
|
var stream_DOLLAR=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DOLLAR");
|
|
var stream_p_TypeDeclaration=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_TypeDeclaration");
|
|
var stream_p_QName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QName");
|
|
try {
|
|
// XQueryParser.g:358:9: ( DOLLAR qn= p_QName (td= p_TypeDeclaration )? -> ^( Param $qn ( $td)? ) )
|
|
// XQueryParser.g:358:11: DOLLAR qn= p_QName (td= p_TypeDeclaration )?
|
|
DOLLAR80=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_Param3258); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DOLLAR.add(DOLLAR80);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_Param3262);
|
|
qn=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(qn.getTree());
|
|
// XQueryParser.g:358:31: (td= p_TypeDeclaration )?
|
|
var alt43=2;
|
|
var LA43_0 = this.input.LA(1);
|
|
|
|
if ( (LA43_0==AS) ) {
|
|
alt43=1;
|
|
}
|
|
switch (alt43) {
|
|
case 1 :
|
|
// XQueryParser.g:358:31: td= p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_Param3266);
|
|
td=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_TypeDeclaration.add(td.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: qn, td
|
|
// token labels:
|
|
// rule labels: qn, retval, td
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_qn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token qn",qn!=null?qn.tree:null);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_td=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token td",td!=null?td.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 359:17: -> ^( Param $qn ( $td)? )
|
|
{
|
|
// XQueryParser.g:359:20: ^( Param $qn ( $td)? )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(Param, "Param"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_qn.nextTree());
|
|
// XQueryParser.g:359:32: ( $td)?
|
|
if ( stream_td.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_td.nextTree());
|
|
|
|
}
|
|
stream_td.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_EnclosedExpr_return: (function() {
|
|
XQueryParser.p_EnclosedExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_EnclosedExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:363:1: p_EnclosedExpr : LBRACKET pm_Expr RBRACKET -> ^( EnclosedExpr pm_Expr ) ;
|
|
// $ANTLR start "p_EnclosedExpr"
|
|
p_EnclosedExpr: function() {
|
|
var retval = new XQueryParser.p_EnclosedExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LBRACKET81 = null;
|
|
var RBRACKET83 = null;
|
|
var pm_Expr82 = null;
|
|
|
|
var LBRACKET81_tree=null;
|
|
var RBRACKET83_tree=null;
|
|
var stream_LBRACKET=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token LBRACKET");
|
|
var stream_RBRACKET=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token RBRACKET");
|
|
var stream_pm_Expr=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_Expr");
|
|
try {
|
|
// XQueryParser.g:364:9: ( LBRACKET pm_Expr RBRACKET -> ^( EnclosedExpr pm_Expr ) )
|
|
// XQueryParser.g:364:11: LBRACKET pm_Expr RBRACKET
|
|
LBRACKET81=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_EnclosedExpr3322); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LBRACKET.add(LBRACKET81);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_EnclosedExpr3324);
|
|
pm_Expr82=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_Expr.add(pm_Expr82.getTree());
|
|
RBRACKET83=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_EnclosedExpr3326); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RBRACKET.add(RBRACKET83);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: pm_Expr
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 365:17: -> ^( EnclosedExpr pm_Expr )
|
|
{
|
|
// XQueryParser.g:365:20: ^( EnclosedExpr pm_Expr )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(EnclosedExpr, "EnclosedExpr"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_pm_Expr.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_QueryBody_return: (function() {
|
|
XQueryParser.p_QueryBody_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_QueryBody_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:369:1: p_QueryBody : pm_Expr -> ^( QueryBody pm_Expr ) ;
|
|
// $ANTLR start "p_QueryBody"
|
|
p_QueryBody: function() {
|
|
var retval = new XQueryParser.p_QueryBody_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_Expr84 = null;
|
|
|
|
var stream_pm_Expr=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_Expr");
|
|
try {
|
|
// XQueryParser.g:370:9: ( pm_Expr -> ^( QueryBody pm_Expr ) )
|
|
// XQueryParser.g:370:11: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_QueryBody3376);
|
|
pm_Expr84=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_Expr.add(pm_Expr84.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: pm_Expr
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 371:17: -> ^( QueryBody pm_Expr )
|
|
{
|
|
// XQueryParser.g:371:20: ^( QueryBody pm_Expr )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(QueryBody, "QueryBody"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_pm_Expr.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_Expr_return: (function() {
|
|
XQueryParser.pm_Expr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_Expr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:376:1: pm_Expr : p_ConcatExpr ({...}? => ( SEMICOLON ( pm_ApplyExpr )* )? | ) ({...}? => ( SEMICOLON p_ConcatExpr )+ | ) ;
|
|
// $ANTLR start "pm_Expr"
|
|
pm_Expr: function() {
|
|
var retval = new XQueryParser.pm_Expr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON86 = null;
|
|
var SEMICOLON88 = null;
|
|
var p_ConcatExpr85 = null;
|
|
var pm_ApplyExpr87 = null;
|
|
var p_ConcatExpr89 = null;
|
|
|
|
var SEMICOLON86_tree=null;
|
|
var SEMICOLON88_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:377:9: ( p_ConcatExpr ({...}? => ( SEMICOLON ( pm_ApplyExpr )* )? | ) ({...}? => ( SEMICOLON p_ConcatExpr )+ | ) )
|
|
// XQueryParser.g:377:11: p_ConcatExpr ({...}? => ( SEMICOLON ( pm_ApplyExpr )* )? | ) ({...}? => ( SEMICOLON p_ConcatExpr )+ | )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ConcatExpr_in_pm_Expr3427);
|
|
p_ConcatExpr85=this.p_ConcatExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ConcatExpr85.getTree());
|
|
// XQueryParser.g:378:11: ({...}? => ( SEMICOLON ( pm_ApplyExpr )* )? | )
|
|
var alt46=2;
|
|
var LA46_0 = this.input.LA(1);
|
|
|
|
if ( (LA46_0==SEMICOLON) && ((((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||(true)||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||(false)||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))||((true)&&(false))))) {
|
|
var LA46_1 = this.input.LA(2);
|
|
|
|
if ( ((((true)&&(false))||(true))) ) {
|
|
alt46=1;
|
|
}
|
|
else if ( ((false)) ) {
|
|
alt46=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 46, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA46_0==RBRACKET) ) {
|
|
var LA46_2 = this.input.LA(2);
|
|
|
|
if ( ((true)) ) {
|
|
alt46=1;
|
|
}
|
|
else if ( (true) ) {
|
|
alt46=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 46, 2, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA46_0==EOF) ) {
|
|
var LA46_3 = this.input.LA(2);
|
|
|
|
if ( ((true)) ) {
|
|
alt46=1;
|
|
}
|
|
else if ( (true) ) {
|
|
alt46=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 46, 3, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA46_0==RPAREN) ) {
|
|
var LA46_4 = this.input.LA(2);
|
|
|
|
if ( ((true)) ) {
|
|
alt46=1;
|
|
}
|
|
else if ( (true) ) {
|
|
alt46=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 46, 4, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA46_0==RSQUARE) ) {
|
|
var LA46_5 = this.input.LA(2);
|
|
|
|
if ( ((true)) ) {
|
|
alt46=1;
|
|
}
|
|
else if ( (true) ) {
|
|
alt46=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 46, 5, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 46, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt46) {
|
|
case 1 :
|
|
// XQueryParser.g:378:12: {...}? => ( SEMICOLON ( pm_ApplyExpr )* )?
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pm_Expr", "true");
|
|
}
|
|
// XQueryParser.g:378:22: ( SEMICOLON ( pm_ApplyExpr )* )?
|
|
var alt45=2;
|
|
var LA45_0 = this.input.LA(1);
|
|
|
|
if ( (LA45_0==SEMICOLON) ) {
|
|
var LA45_1 = this.input.LA(2);
|
|
|
|
if ( (!(((false)))) ) {
|
|
alt45=1;
|
|
}
|
|
}
|
|
switch (alt45) {
|
|
case 1 :
|
|
// XQueryParser.g:378:23: SEMICOLON ( pm_ApplyExpr )*
|
|
SEMICOLON86=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_Expr3444); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON86_tree = this.adaptor.create(SEMICOLON86);
|
|
this.adaptor.addChild(root_0, SEMICOLON86_tree);
|
|
}
|
|
// XQueryParser.g:378:33: ( pm_ApplyExpr )*
|
|
loop44:
|
|
do {
|
|
var alt44=2;
|
|
var LA44_0 = this.input.LA(1);
|
|
|
|
if ( ((LA44_0>=ANCESTOR && LA44_0<=EXIT)||(LA44_0>=SEQUENTIAL && LA44_0<=MAINTAINED)||(LA44_0>=MUTABLE && LA44_0<=LPAREN)||LA44_0==DOLLAR||(LA44_0>=STAR && LA44_0<=SMALLER)||(LA44_0>=SLASH && LA44_0<=DOT_DOT)||LA44_0==ATTR_SIGN||(LA44_0>=APOS && LA44_0<=QUOT)||LA44_0==L_NCName||(LA44_0>=L_Pragma && LA44_0<=L_DoubleLiteral)||(LA44_0>=LETDOLLAR && LA44_0<=EXPLICITLY)) ) {
|
|
alt44=1;
|
|
}
|
|
|
|
|
|
switch (alt44) {
|
|
case 1 :
|
|
// XQueryParser.g:378:33: pm_ApplyExpr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_ApplyExpr_in_pm_Expr3446);
|
|
pm_ApplyExpr87=this.pm_ApplyExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_ApplyExpr87.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop44;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:378:64:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:379:11: ({...}? => ( SEMICOLON p_ConcatExpr )+ | )
|
|
var alt48=2;
|
|
var LA48_0 = this.input.LA(1);
|
|
|
|
if ( (LA48_0==SEMICOLON) && ((false))) {
|
|
alt48=1;
|
|
}
|
|
else if ( (LA48_0==EOF||LA48_0==RPAREN||LA48_0==RBRACKET||LA48_0==RSQUARE) ) {
|
|
alt48=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 48, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt48) {
|
|
case 1 :
|
|
// XQueryParser.g:379:12: {...}? => ( SEMICOLON p_ConcatExpr )+
|
|
if ( !((false)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "pm_Expr", "false");
|
|
}
|
|
// XQueryParser.g:379:23: ( SEMICOLON p_ConcatExpr )+
|
|
var cnt47=0;
|
|
loop47:
|
|
do {
|
|
var alt47=2;
|
|
var LA47_0 = this.input.LA(1);
|
|
|
|
if ( (LA47_0==SEMICOLON) ) {
|
|
alt47=1;
|
|
}
|
|
|
|
|
|
switch (alt47) {
|
|
case 1 :
|
|
// XQueryParser.g:379:24: SEMICOLON p_ConcatExpr
|
|
SEMICOLON88=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_Expr3471); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON88_tree = this.adaptor.create(SEMICOLON88);
|
|
this.adaptor.addChild(root_0, SEMICOLON88_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ConcatExpr_in_pm_Expr3473);
|
|
p_ConcatExpr89=this.p_ConcatExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ConcatExpr89.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
if ( cnt47 >= 1 ) {
|
|
break loop47;
|
|
}
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var eee = new org.antlr.runtime.EarlyExitException(47, this.input);
|
|
throw eee;
|
|
}
|
|
cnt47++;
|
|
} while (true);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:379:64:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ExprSingle_return: (function() {
|
|
XQueryParser.p_ExprSingle_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ExprSingle_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:384:1: p_ExprSingle : ( p_FLWORExpr | p_QuantifiedExpr | p_TypeswitchExpr | p_IfExpr | p_TryCatchExpr | {...}? => p_EvalExpr | {...}? => p_InsertExpr | {...}? => p_DeleteExpr | {...}? => p_RenameExpr | {...}? => p_ReplaceExpr | {...}? => p_TransformExpr | {...}? => p_BlockExpr | {...}? => p_AssignmentExpr | {...}? => p_ExitExpr | {...}? => p_WhileExpr | p_OrExpr );
|
|
// $ANTLR start "p_ExprSingle"
|
|
p_ExprSingle: function() {
|
|
var retval = new XQueryParser.p_ExprSingle_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_FLWORExpr90 = null;
|
|
var p_QuantifiedExpr91 = null;
|
|
var p_TypeswitchExpr92 = null;
|
|
var p_IfExpr93 = null;
|
|
var p_TryCatchExpr94 = null;
|
|
var p_EvalExpr95 = null;
|
|
var p_InsertExpr96 = null;
|
|
var p_DeleteExpr97 = null;
|
|
var p_RenameExpr98 = null;
|
|
var p_ReplaceExpr99 = null;
|
|
var p_TransformExpr100 = null;
|
|
var p_BlockExpr101 = null;
|
|
var p_AssignmentExpr102 = null;
|
|
var p_ExitExpr103 = null;
|
|
var p_WhileExpr104 = null;
|
|
var p_OrExpr105 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:385:9: ( p_FLWORExpr | p_QuantifiedExpr | p_TypeswitchExpr | p_IfExpr | p_TryCatchExpr | {...}? => p_EvalExpr | {...}? => p_InsertExpr | {...}? => p_DeleteExpr | {...}? => p_RenameExpr | {...}? => p_ReplaceExpr | {...}? => p_TransformExpr | {...}? => p_BlockExpr | {...}? => p_AssignmentExpr | {...}? => p_ExitExpr | {...}? => p_WhileExpr | p_OrExpr )
|
|
var alt49=16;
|
|
alt49 = this.dfa49.predict(this.input);
|
|
switch (alt49) {
|
|
case 1 :
|
|
// XQueryParser.g:385:11: p_FLWORExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_FLWORExpr_in_p_ExprSingle3507);
|
|
p_FLWORExpr90=this.p_FLWORExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_FLWORExpr90.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:386:11: p_QuantifiedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QuantifiedExpr_in_p_ExprSingle3519);
|
|
p_QuantifiedExpr91=this.p_QuantifiedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QuantifiedExpr91.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:387:11: p_TypeswitchExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeswitchExpr_in_p_ExprSingle3531);
|
|
p_TypeswitchExpr92=this.p_TypeswitchExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeswitchExpr92.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:388:11: p_IfExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IfExpr_in_p_ExprSingle3543);
|
|
p_IfExpr93=this.p_IfExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IfExpr93.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:389:11: p_TryCatchExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TryCatchExpr_in_p_ExprSingle3555);
|
|
p_TryCatchExpr94=this.p_TryCatchExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TryCatchExpr94.getTree());
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:390:11: {...}? => p_EvalExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_EvalExpr_in_p_ExprSingle3570);
|
|
p_EvalExpr95=this.p_EvalExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_EvalExpr95.getTree());
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:391:11: {...}? => p_InsertExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InsertExpr_in_p_ExprSingle3585);
|
|
p_InsertExpr96=this.p_InsertExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InsertExpr96.getTree());
|
|
|
|
|
|
break;
|
|
case 8 :
|
|
// XQueryParser.g:392:11: {...}? => p_DeleteExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DeleteExpr_in_p_ExprSingle3600);
|
|
p_DeleteExpr97=this.p_DeleteExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DeleteExpr97.getTree());
|
|
|
|
|
|
break;
|
|
case 9 :
|
|
// XQueryParser.g:393:11: {...}? => p_RenameExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RenameExpr_in_p_ExprSingle3615);
|
|
p_RenameExpr98=this.p_RenameExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_RenameExpr98.getTree());
|
|
|
|
|
|
break;
|
|
case 10 :
|
|
// XQueryParser.g:394:11: {...}? => p_ReplaceExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ReplaceExpr_in_p_ExprSingle3630);
|
|
p_ReplaceExpr99=this.p_ReplaceExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ReplaceExpr99.getTree());
|
|
|
|
|
|
break;
|
|
case 11 :
|
|
// XQueryParser.g:395:11: {...}? => p_TransformExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TransformExpr_in_p_ExprSingle3645);
|
|
p_TransformExpr100=this.p_TransformExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TransformExpr100.getTree());
|
|
|
|
|
|
break;
|
|
case 12 :
|
|
// XQueryParser.g:396:11: {...}? => p_BlockExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_BlockExpr_in_p_ExprSingle3660);
|
|
p_BlockExpr101=this.p_BlockExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_BlockExpr101.getTree());
|
|
|
|
|
|
break;
|
|
case 13 :
|
|
// XQueryParser.g:397:11: {...}? => p_AssignmentExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AssignmentExpr_in_p_ExprSingle3675);
|
|
p_AssignmentExpr102=this.p_AssignmentExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AssignmentExpr102.getTree());
|
|
|
|
|
|
break;
|
|
case 14 :
|
|
// XQueryParser.g:398:11: {...}? => p_ExitExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExitExpr_in_p_ExprSingle3690);
|
|
p_ExitExpr103=this.p_ExitExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExitExpr103.getTree());
|
|
|
|
|
|
break;
|
|
case 15 :
|
|
// XQueryParser.g:399:11: {...}? => p_WhileExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((true)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ExprSingle", "true");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WhileExpr_in_p_ExprSingle3705);
|
|
p_WhileExpr104=this.p_WhileExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WhileExpr104.getTree());
|
|
|
|
|
|
break;
|
|
case 16 :
|
|
// XQueryParser.g:400:11: p_OrExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrExpr_in_p_ExprSingle3717);
|
|
p_OrExpr105=this.p_OrExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrExpr105.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_FLWORExpr_return: (function() {
|
|
XQueryParser.p_FLWORExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_FLWORExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:404:1: p_FLWORExpr : p_InitialClause ( p_IntermediateClause )* p_ReturnClause ;
|
|
// $ANTLR start "p_FLWORExpr"
|
|
p_FLWORExpr: function() {
|
|
var retval = new XQueryParser.p_FLWORExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_InitialClause106 = null;
|
|
var p_IntermediateClause107 = null;
|
|
var p_ReturnClause108 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:405:9: ( p_InitialClause ( p_IntermediateClause )* p_ReturnClause )
|
|
// XQueryParser.g:405:11: p_InitialClause ( p_IntermediateClause )* p_ReturnClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InitialClause_in_p_FLWORExpr3743);
|
|
p_InitialClause106=this.p_InitialClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InitialClause106.getTree());
|
|
// XQueryParser.g:405:27: ( p_IntermediateClause )*
|
|
loop50:
|
|
do {
|
|
var alt50=2;
|
|
var LA50_0 = this.input.LA(1);
|
|
|
|
if ( (LA50_0==FOR||LA50_0==ORDER||LA50_0==STABLE||LA50_0==WHERE||LA50_0==COUNT||LA50_0==GROUP||LA50_0==LETDOLLAR) ) {
|
|
alt50=1;
|
|
}
|
|
|
|
|
|
switch (alt50) {
|
|
case 1 :
|
|
// XQueryParser.g:405:27: p_IntermediateClause
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IntermediateClause_in_p_FLWORExpr3745);
|
|
p_IntermediateClause107=this.p_IntermediateClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IntermediateClause107.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop50;
|
|
}
|
|
} while (true);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ReturnClause_in_p_FLWORExpr3748);
|
|
p_ReturnClause108=this.p_ReturnClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ReturnClause108.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_InitialClause_return: (function() {
|
|
XQueryParser.p_InitialClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_InitialClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:409:1: p_InitialClause : ( p_ForClause | p_LetClause | p_WindowClause );
|
|
// $ANTLR start "p_InitialClause"
|
|
p_InitialClause: function() {
|
|
var retval = new XQueryParser.p_InitialClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ForClause109 = null;
|
|
var p_LetClause110 = null;
|
|
var p_WindowClause111 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:410:9: ( p_ForClause | p_LetClause | p_WindowClause )
|
|
var alt51=3;
|
|
var LA51_0 = this.input.LA(1);
|
|
|
|
if ( (LA51_0==FOR) ) {
|
|
var LA51_1 = this.input.LA(2);
|
|
|
|
if ( (LA51_1==DOLLAR) ) {
|
|
alt51=1;
|
|
}
|
|
else if ( (LA51_1==SLIDING||LA51_1==TUMBLING) ) {
|
|
alt51=3;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 51, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA51_0==LETDOLLAR) ) {
|
|
alt51=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 51, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt51) {
|
|
case 1 :
|
|
// XQueryParser.g:410:11: p_ForClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ForClause_in_p_InitialClause3774);
|
|
p_ForClause109=this.p_ForClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ForClause109.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:410:25: p_LetClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_LetClause_in_p_InitialClause3778);
|
|
p_LetClause110=this.p_LetClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_LetClause110.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:410:39: p_WindowClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowClause_in_p_InitialClause3782);
|
|
p_WindowClause111=this.p_WindowClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowClause111.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IntermediateClause_return: (function() {
|
|
XQueryParser.p_IntermediateClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IntermediateClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:414:1: p_IntermediateClause : ( p_InitialClause | p_WhereClause | p_GroupByClause | p_OrderByClause | p_CountClause );
|
|
// $ANTLR start "p_IntermediateClause"
|
|
p_IntermediateClause: function() {
|
|
var retval = new XQueryParser.p_IntermediateClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_InitialClause112 = null;
|
|
var p_WhereClause113 = null;
|
|
var p_GroupByClause114 = null;
|
|
var p_OrderByClause115 = null;
|
|
var p_CountClause116 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:415:9: ( p_InitialClause | p_WhereClause | p_GroupByClause | p_OrderByClause | p_CountClause )
|
|
var alt52=5;
|
|
switch ( this.input.LA(1) ) {
|
|
case FOR:
|
|
case LETDOLLAR:
|
|
alt52=1;
|
|
break;
|
|
case WHERE:
|
|
alt52=2;
|
|
break;
|
|
case GROUP:
|
|
alt52=3;
|
|
break;
|
|
case ORDER:
|
|
case STABLE:
|
|
alt52=4;
|
|
break;
|
|
case COUNT:
|
|
alt52=5;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 52, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt52) {
|
|
case 1 :
|
|
// XQueryParser.g:415:11: p_InitialClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InitialClause_in_p_IntermediateClause3808);
|
|
p_InitialClause112=this.p_InitialClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InitialClause112.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:415:29: p_WhereClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WhereClause_in_p_IntermediateClause3812);
|
|
p_WhereClause113=this.p_WhereClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WhereClause113.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:415:45: p_GroupByClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_GroupByClause_in_p_IntermediateClause3816);
|
|
p_GroupByClause114=this.p_GroupByClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_GroupByClause114.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:415:63: p_OrderByClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrderByClause_in_p_IntermediateClause3820);
|
|
p_OrderByClause115=this.p_OrderByClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrderByClause115.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:415:81: p_CountClause
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CountClause_in_p_IntermediateClause3824);
|
|
p_CountClause116=this.p_CountClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CountClause116.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ForClause_return: (function() {
|
|
XQueryParser.p_ForClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ForClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:419:1: p_ForClause : k+= FOR DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle )* ;
|
|
// $ANTLR start "p_ForClause"
|
|
p_ForClause: function() {
|
|
var retval = new XQueryParser.p_ForClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR117 = null;
|
|
var COMMA122 = null;
|
|
var DOLLAR123 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_VarName118 = null;
|
|
var p_TypeDeclaration119 = null;
|
|
var p_PositionalVar120 = null;
|
|
var p_ExprSingle121 = null;
|
|
var p_VarName124 = null;
|
|
var p_TypeDeclaration125 = null;
|
|
var p_PositionalVar126 = null;
|
|
var p_ExprSingle127 = null;
|
|
|
|
var DOLLAR117_tree=null;
|
|
var COMMA122_tree=null;
|
|
var DOLLAR123_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:420:9: (k+= FOR DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle )* )
|
|
// XQueryParser.g:420:11: k+= FOR DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,FOR,XQueryParser.FOLLOW_FOR_in_p_ForClause3852); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR117=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_ForClause3854); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR117_tree = this.adaptor.create(DOLLAR117);
|
|
this.adaptor.addChild(root_0, DOLLAR117_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_ForClause3856);
|
|
p_VarName118=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName118.getTree());
|
|
// XQueryParser.g:420:35: ( p_TypeDeclaration )?
|
|
var alt53=2;
|
|
var LA53_0 = this.input.LA(1);
|
|
|
|
if ( (LA53_0==AS) ) {
|
|
alt53=1;
|
|
}
|
|
switch (alt53) {
|
|
case 1 :
|
|
// XQueryParser.g:420:35: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_ForClause3858);
|
|
p_TypeDeclaration119=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration119.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:420:54: ( p_PositionalVar )?
|
|
var alt54=2;
|
|
var LA54_0 = this.input.LA(1);
|
|
|
|
if ( (LA54_0==AT) ) {
|
|
alt54=1;
|
|
}
|
|
switch (alt54) {
|
|
case 1 :
|
|
// XQueryParser.g:420:54: p_PositionalVar
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PositionalVar_in_p_ForClause3861);
|
|
p_PositionalVar120=this.p_PositionalVar();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PositionalVar120.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,IN,XQueryParser.FOLLOW_IN_in_p_ForClause3866); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ForClause3868);
|
|
p_ExprSingle121=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle121.getTree());
|
|
// XQueryParser.g:420:90: ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle )*
|
|
loop57:
|
|
do {
|
|
var alt57=2;
|
|
var LA57_0 = this.input.LA(1);
|
|
|
|
if ( (LA57_0==COMMA) ) {
|
|
alt57=1;
|
|
}
|
|
|
|
|
|
switch (alt57) {
|
|
case 1 :
|
|
// XQueryParser.g:420:91: COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( p_PositionalVar )? k+= IN p_ExprSingle
|
|
COMMA122=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_ForClause3871); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA122_tree = this.adaptor.create(COMMA122);
|
|
this.adaptor.addChild(root_0, COMMA122_tree);
|
|
}
|
|
DOLLAR123=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_ForClause3873); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR123_tree = this.adaptor.create(DOLLAR123);
|
|
this.adaptor.addChild(root_0, DOLLAR123_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_ForClause3875);
|
|
p_VarName124=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName124.getTree());
|
|
// XQueryParser.g:420:114: ( p_TypeDeclaration )?
|
|
var alt55=2;
|
|
var LA55_0 = this.input.LA(1);
|
|
|
|
if ( (LA55_0==AS) ) {
|
|
alt55=1;
|
|
}
|
|
switch (alt55) {
|
|
case 1 :
|
|
// XQueryParser.g:420:114: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_ForClause3877);
|
|
p_TypeDeclaration125=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration125.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:420:133: ( p_PositionalVar )?
|
|
var alt56=2;
|
|
var LA56_0 = this.input.LA(1);
|
|
|
|
if ( (LA56_0==AT) ) {
|
|
alt56=1;
|
|
}
|
|
switch (alt56) {
|
|
case 1 :
|
|
// XQueryParser.g:420:133: p_PositionalVar
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PositionalVar_in_p_ForClause3880);
|
|
p_PositionalVar126=this.p_PositionalVar();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PositionalVar126.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,IN,XQueryParser.FOLLOW_IN_in_p_ForClause3885); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ForClause3887);
|
|
p_ExprSingle127=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle127.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop57;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PositionalVar_return: (function() {
|
|
XQueryParser.p_PositionalVar_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PositionalVar_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:424:1: p_PositionalVar : ka= AT DOLLAR p_VarName ;
|
|
// $ANTLR start "p_PositionalVar"
|
|
p_PositionalVar: function() {
|
|
var retval = new XQueryParser.p_PositionalVar_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ka = null;
|
|
var DOLLAR128 = null;
|
|
var p_VarName129 = null;
|
|
|
|
var ka_tree=null;
|
|
var DOLLAR128_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:425:9: (ka= AT DOLLAR p_VarName )
|
|
// XQueryParser.g:425:11: ka= AT DOLLAR p_VarName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ka=this.match(this.input,AT,XQueryParser.FOLLOW_AT_in_p_PositionalVar3918); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
DOLLAR128=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_PositionalVar3920); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR128_tree = this.adaptor.create(DOLLAR128);
|
|
this.adaptor.addChild(root_0, DOLLAR128_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_PositionalVar3922);
|
|
p_VarName129=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName129.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_LetClause_return: (function() {
|
|
XQueryParser.p_LetClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_LetClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:429:1: p_LetClause : kl= LETDOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle )* ;
|
|
// $ANTLR start "p_LetClause"
|
|
p_LetClause: function() {
|
|
var retval = new XQueryParser.p_LetClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kl = null;
|
|
var BIND132 = null;
|
|
var COMMA134 = null;
|
|
var DOLLAR135 = null;
|
|
var BIND138 = null;
|
|
var p_VarName130 = null;
|
|
var p_TypeDeclaration131 = null;
|
|
var p_ExprSingle133 = null;
|
|
var p_VarName136 = null;
|
|
var p_TypeDeclaration137 = null;
|
|
var p_ExprSingle139 = null;
|
|
|
|
var kl_tree=null;
|
|
var BIND132_tree=null;
|
|
var COMMA134_tree=null;
|
|
var DOLLAR135_tree=null;
|
|
var BIND138_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:430:9: (kl= LETDOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle )* )
|
|
// XQueryParser.g:430:11: kl= LETDOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kl=this.match(this.input,LETDOLLAR,XQueryParser.FOLLOW_LETDOLLAR_in_p_LetClause3950); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kl_tree = this.adaptor.create(kl);
|
|
this.adaptor.addChild(root_0, kl_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_LetClause3952);
|
|
p_VarName130=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName130.getTree());
|
|
// XQueryParser.g:430:34: ( p_TypeDeclaration )?
|
|
var alt58=2;
|
|
var LA58_0 = this.input.LA(1);
|
|
|
|
if ( (LA58_0==AS) ) {
|
|
alt58=1;
|
|
}
|
|
switch (alt58) {
|
|
case 1 :
|
|
// XQueryParser.g:430:34: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_LetClause3954);
|
|
p_TypeDeclaration131=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration131.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
BIND132=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_p_LetClause3957); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND132_tree = this.adaptor.create(BIND132);
|
|
this.adaptor.addChild(root_0, BIND132_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_LetClause3959);
|
|
p_ExprSingle133=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle133.getTree());
|
|
// XQueryParser.g:430:71: ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle )*
|
|
loop60:
|
|
do {
|
|
var alt60=2;
|
|
var LA60_0 = this.input.LA(1);
|
|
|
|
if ( (LA60_0==COMMA) ) {
|
|
alt60=1;
|
|
}
|
|
|
|
|
|
switch (alt60) {
|
|
case 1 :
|
|
// XQueryParser.g:430:72: COMMA DOLLAR p_VarName ( p_TypeDeclaration )? BIND p_ExprSingle
|
|
COMMA134=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_LetClause3962); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA134_tree = this.adaptor.create(COMMA134);
|
|
this.adaptor.addChild(root_0, COMMA134_tree);
|
|
}
|
|
DOLLAR135=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_LetClause3964); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR135_tree = this.adaptor.create(DOLLAR135);
|
|
this.adaptor.addChild(root_0, DOLLAR135_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_LetClause3966);
|
|
p_VarName136=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName136.getTree());
|
|
// XQueryParser.g:430:95: ( p_TypeDeclaration )?
|
|
var alt59=2;
|
|
var LA59_0 = this.input.LA(1);
|
|
|
|
if ( (LA59_0==AS) ) {
|
|
alt59=1;
|
|
}
|
|
switch (alt59) {
|
|
case 1 :
|
|
// XQueryParser.g:430:95: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_LetClause3968);
|
|
p_TypeDeclaration137=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration137.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
BIND138=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_p_LetClause3971); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND138_tree = this.adaptor.create(BIND138);
|
|
this.adaptor.addChild(root_0, BIND138_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_LetClause3973);
|
|
p_ExprSingle139=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle139.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop60;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WindowClause_return: (function() {
|
|
XQueryParser.p_WindowClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WindowClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:434:1: p_WindowClause : kf= FOR ( p_TumblingWindowClause | p_SlidingWindowClause ) ;
|
|
// $ANTLR start "p_WindowClause"
|
|
p_WindowClause: function() {
|
|
var retval = new XQueryParser.p_WindowClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kf = null;
|
|
var p_TumblingWindowClause140 = null;
|
|
var p_SlidingWindowClause141 = null;
|
|
|
|
var kf_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:435:9: (kf= FOR ( p_TumblingWindowClause | p_SlidingWindowClause ) )
|
|
// XQueryParser.g:435:11: kf= FOR ( p_TumblingWindowClause | p_SlidingWindowClause )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kf=this.match(this.input,FOR,XQueryParser.FOLLOW_FOR_in_p_WindowClause4003); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kf_tree = this.adaptor.create(kf);
|
|
this.adaptor.addChild(root_0, kf_tree);
|
|
}
|
|
// XQueryParser.g:435:18: ( p_TumblingWindowClause | p_SlidingWindowClause )
|
|
var alt61=2;
|
|
var LA61_0 = this.input.LA(1);
|
|
|
|
if ( (LA61_0==TUMBLING) ) {
|
|
alt61=1;
|
|
}
|
|
else if ( (LA61_0==SLIDING) ) {
|
|
alt61=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 61, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt61) {
|
|
case 1 :
|
|
// XQueryParser.g:435:19: p_TumblingWindowClause
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TumblingWindowClause_in_p_WindowClause4006);
|
|
p_TumblingWindowClause140=this.p_TumblingWindowClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TumblingWindowClause140.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:435:44: p_SlidingWindowClause
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SlidingWindowClause_in_p_WindowClause4010);
|
|
p_SlidingWindowClause141=this.p_SlidingWindowClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SlidingWindowClause141.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TumblingWindowClause_return: (function() {
|
|
XQueryParser.p_TumblingWindowClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TumblingWindowClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:439:1: p_TumblingWindowClause : k+= TUMBLING k+= WINDOW DOLLAR p_VarName ( p_TypeDeclaration )? IN p_ExprSingle p_WindowStartCondition ( p_WindowEndCondition )? ;
|
|
// $ANTLR start "p_TumblingWindowClause"
|
|
p_TumblingWindowClause: function() {
|
|
var retval = new XQueryParser.p_TumblingWindowClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR142 = null;
|
|
var IN145 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_VarName143 = null;
|
|
var p_TypeDeclaration144 = null;
|
|
var p_ExprSingle146 = null;
|
|
var p_WindowStartCondition147 = null;
|
|
var p_WindowEndCondition148 = null;
|
|
|
|
var DOLLAR142_tree=null;
|
|
var IN145_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:440:9: (k+= TUMBLING k+= WINDOW DOLLAR p_VarName ( p_TypeDeclaration )? IN p_ExprSingle p_WindowStartCondition ( p_WindowEndCondition )? )
|
|
// XQueryParser.g:440:11: k+= TUMBLING k+= WINDOW DOLLAR p_VarName ( p_TypeDeclaration )? IN p_ExprSingle p_WindowStartCondition ( p_WindowEndCondition )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,TUMBLING,XQueryParser.FOLLOW_TUMBLING_in_p_TumblingWindowClause4047); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,WINDOW,XQueryParser.FOLLOW_WINDOW_in_p_TumblingWindowClause4051); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR142=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_TumblingWindowClause4053); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR142_tree = this.adaptor.create(DOLLAR142);
|
|
this.adaptor.addChild(root_0, DOLLAR142_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_TumblingWindowClause4055);
|
|
p_VarName143=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName143.getTree());
|
|
// XQueryParser.g:440:50: ( p_TypeDeclaration )?
|
|
var alt62=2;
|
|
var LA62_0 = this.input.LA(1);
|
|
|
|
if ( (LA62_0==AS) ) {
|
|
alt62=1;
|
|
}
|
|
switch (alt62) {
|
|
case 1 :
|
|
// XQueryParser.g:440:50: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_TumblingWindowClause4057);
|
|
p_TypeDeclaration144=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration144.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
IN145=this.match(this.input,IN,XQueryParser.FOLLOW_IN_in_p_TumblingWindowClause4060); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
IN145_tree = this.adaptor.create(IN145);
|
|
this.adaptor.addChild(root_0, IN145_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TumblingWindowClause4062);
|
|
p_ExprSingle146=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle146.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowStartCondition_in_p_TumblingWindowClause4064);
|
|
p_WindowStartCondition147=this.p_WindowStartCondition();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowStartCondition147.getTree());
|
|
// XQueryParser.g:440:108: ( p_WindowEndCondition )?
|
|
var alt63=2;
|
|
var LA63_0 = this.input.LA(1);
|
|
|
|
if ( (LA63_0==END||LA63_0==ONLY) ) {
|
|
alt63=1;
|
|
}
|
|
switch (alt63) {
|
|
case 1 :
|
|
// XQueryParser.g:440:108: p_WindowEndCondition
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowEndCondition_in_p_TumblingWindowClause4066);
|
|
p_WindowEndCondition148=this.p_WindowEndCondition();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowEndCondition148.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SlidingWindowClause_return: (function() {
|
|
XQueryParser.p_SlidingWindowClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SlidingWindowClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:444:1: p_SlidingWindowClause : k+= SLIDING k+= WINDOW DOLLAR p_VarName ( p_TypeDeclaration )? IN p_ExprSingle p_WindowStartCondition ( p_WindowEndCondition )? ;
|
|
// $ANTLR start "p_SlidingWindowClause"
|
|
p_SlidingWindowClause: function() {
|
|
var retval = new XQueryParser.p_SlidingWindowClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR149 = null;
|
|
var IN152 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_VarName150 = null;
|
|
var p_TypeDeclaration151 = null;
|
|
var p_ExprSingle153 = null;
|
|
var p_WindowStartCondition154 = null;
|
|
var p_WindowEndCondition155 = null;
|
|
|
|
var DOLLAR149_tree=null;
|
|
var IN152_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:445:9: (k+= SLIDING k+= WINDOW DOLLAR p_VarName ( p_TypeDeclaration )? IN p_ExprSingle p_WindowStartCondition ( p_WindowEndCondition )? )
|
|
// XQueryParser.g:445:11: k+= SLIDING k+= WINDOW DOLLAR p_VarName ( p_TypeDeclaration )? IN p_ExprSingle p_WindowStartCondition ( p_WindowEndCondition )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,SLIDING,XQueryParser.FOLLOW_SLIDING_in_p_SlidingWindowClause4096); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,WINDOW,XQueryParser.FOLLOW_WINDOW_in_p_SlidingWindowClause4100); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR149=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_SlidingWindowClause4102); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR149_tree = this.adaptor.create(DOLLAR149);
|
|
this.adaptor.addChild(root_0, DOLLAR149_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_SlidingWindowClause4104);
|
|
p_VarName150=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName150.getTree());
|
|
// XQueryParser.g:445:49: ( p_TypeDeclaration )?
|
|
var alt64=2;
|
|
var LA64_0 = this.input.LA(1);
|
|
|
|
if ( (LA64_0==AS) ) {
|
|
alt64=1;
|
|
}
|
|
switch (alt64) {
|
|
case 1 :
|
|
// XQueryParser.g:445:49: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_SlidingWindowClause4106);
|
|
p_TypeDeclaration151=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration151.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
IN152=this.match(this.input,IN,XQueryParser.FOLLOW_IN_in_p_SlidingWindowClause4109); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
IN152_tree = this.adaptor.create(IN152);
|
|
this.adaptor.addChild(root_0, IN152_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_SlidingWindowClause4111);
|
|
p_ExprSingle153=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle153.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowStartCondition_in_p_SlidingWindowClause4113);
|
|
p_WindowStartCondition154=this.p_WindowStartCondition();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowStartCondition154.getTree());
|
|
// XQueryParser.g:445:107: ( p_WindowEndCondition )?
|
|
var alt65=2;
|
|
var LA65_0 = this.input.LA(1);
|
|
|
|
if ( (LA65_0==END||LA65_0==ONLY) ) {
|
|
alt65=1;
|
|
}
|
|
switch (alt65) {
|
|
case 1 :
|
|
// XQueryParser.g:445:107: p_WindowEndCondition
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowEndCondition_in_p_SlidingWindowClause4115);
|
|
p_WindowEndCondition155=this.p_WindowEndCondition();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowEndCondition155.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WindowStartCondition_return: (function() {
|
|
XQueryParser.p_WindowStartCondition_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WindowStartCondition_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:449:1: p_WindowStartCondition : k+= START p_WindowVars k+= WHEN p_ExprSingle ;
|
|
// $ANTLR start "p_WindowStartCondition"
|
|
p_WindowStartCondition: function() {
|
|
var retval = new XQueryParser.p_WindowStartCondition_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_WindowVars156 = null;
|
|
var p_ExprSingle157 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:450:9: (k+= START p_WindowVars k+= WHEN p_ExprSingle )
|
|
// XQueryParser.g:450:11: k+= START p_WindowVars k+= WHEN p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,START,XQueryParser.FOLLOW_START_in_p_WindowStartCondition4145); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowVars_in_p_WindowStartCondition4147);
|
|
p_WindowVars156=this.p_WindowVars();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowVars156.getTree());
|
|
k=this.match(this.input,WHEN,XQueryParser.FOLLOW_WHEN_in_p_WindowStartCondition4151); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_WindowStartCondition4153);
|
|
p_ExprSingle157=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle157.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WindowEndCondition_return: (function() {
|
|
XQueryParser.p_WindowEndCondition_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WindowEndCondition_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:454:1: p_WindowEndCondition : (k+= ONLY )? k+= END p_WindowVars k+= WHEN p_ExprSingle ;
|
|
// $ANTLR start "p_WindowEndCondition"
|
|
p_WindowEndCondition: function() {
|
|
var retval = new XQueryParser.p_WindowEndCondition_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_WindowVars158 = null;
|
|
var p_ExprSingle159 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:455:9: ( (k+= ONLY )? k+= END p_WindowVars k+= WHEN p_ExprSingle )
|
|
// XQueryParser.g:455:11: (k+= ONLY )? k+= END p_WindowVars k+= WHEN p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:455:12: (k+= ONLY )?
|
|
var alt66=2;
|
|
var LA66_0 = this.input.LA(1);
|
|
|
|
if ( (LA66_0==ONLY) ) {
|
|
alt66=1;
|
|
}
|
|
switch (alt66) {
|
|
case 1 :
|
|
// XQueryParser.g:455:12: k+= ONLY
|
|
k=this.match(this.input,ONLY,XQueryParser.FOLLOW_ONLY_in_p_WindowEndCondition4182); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,END,XQueryParser.FOLLOW_END_in_p_WindowEndCondition4187); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WindowVars_in_p_WindowEndCondition4189);
|
|
p_WindowVars158=this.p_WindowVars();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WindowVars158.getTree());
|
|
k=this.match(this.input,WHEN,XQueryParser.FOLLOW_WHEN_in_p_WindowEndCondition4193); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_WindowEndCondition4195);
|
|
p_ExprSingle159=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle159.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WindowVars_return: (function() {
|
|
XQueryParser.p_WindowVars_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WindowVars_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:459:1: p_WindowVars : ( DOLLAR p_QName )? ( p_PositionalVar )? (k+= PREVIOUS DOLLAR p_QName )? (k+= NEXT DOLLAR p_QName )? ;
|
|
// $ANTLR start "p_WindowVars"
|
|
p_WindowVars: function() {
|
|
var retval = new XQueryParser.p_WindowVars_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR160 = null;
|
|
var DOLLAR163 = null;
|
|
var DOLLAR165 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName161 = null;
|
|
var p_PositionalVar162 = null;
|
|
var p_QName164 = null;
|
|
var p_QName166 = null;
|
|
|
|
var DOLLAR160_tree=null;
|
|
var DOLLAR163_tree=null;
|
|
var DOLLAR165_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:460:9: ( ( DOLLAR p_QName )? ( p_PositionalVar )? (k+= PREVIOUS DOLLAR p_QName )? (k+= NEXT DOLLAR p_QName )? )
|
|
// XQueryParser.g:460:11: ( DOLLAR p_QName )? ( p_PositionalVar )? (k+= PREVIOUS DOLLAR p_QName )? (k+= NEXT DOLLAR p_QName )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:460:11: ( DOLLAR p_QName )?
|
|
var alt67=2;
|
|
var LA67_0 = this.input.LA(1);
|
|
|
|
if ( (LA67_0==DOLLAR) ) {
|
|
alt67=1;
|
|
}
|
|
switch (alt67) {
|
|
case 1 :
|
|
// XQueryParser.g:460:12: DOLLAR p_QName
|
|
DOLLAR160=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_WindowVars4223); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR160_tree = this.adaptor.create(DOLLAR160);
|
|
this.adaptor.addChild(root_0, DOLLAR160_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_WindowVars4225);
|
|
p_QName161=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName161.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:460:29: ( p_PositionalVar )?
|
|
var alt68=2;
|
|
var LA68_0 = this.input.LA(1);
|
|
|
|
if ( (LA68_0==AT) ) {
|
|
alt68=1;
|
|
}
|
|
switch (alt68) {
|
|
case 1 :
|
|
// XQueryParser.g:460:29: p_PositionalVar
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PositionalVar_in_p_WindowVars4229);
|
|
p_PositionalVar162=this.p_PositionalVar();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PositionalVar162.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:460:46: (k+= PREVIOUS DOLLAR p_QName )?
|
|
var alt69=2;
|
|
var LA69_0 = this.input.LA(1);
|
|
|
|
if ( (LA69_0==PREVIOUS) ) {
|
|
alt69=1;
|
|
}
|
|
switch (alt69) {
|
|
case 1 :
|
|
// XQueryParser.g:460:47: k+= PREVIOUS DOLLAR p_QName
|
|
k=this.match(this.input,PREVIOUS,XQueryParser.FOLLOW_PREVIOUS_in_p_WindowVars4235); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR163=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_WindowVars4237); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR163_tree = this.adaptor.create(DOLLAR163);
|
|
this.adaptor.addChild(root_0, DOLLAR163_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_WindowVars4239);
|
|
p_QName164=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName164.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:460:76: (k+= NEXT DOLLAR p_QName )?
|
|
var alt70=2;
|
|
var LA70_0 = this.input.LA(1);
|
|
|
|
if ( (LA70_0==NEXT) ) {
|
|
alt70=1;
|
|
}
|
|
switch (alt70) {
|
|
case 1 :
|
|
// XQueryParser.g:460:77: k+= NEXT DOLLAR p_QName
|
|
k=this.match(this.input,NEXT,XQueryParser.FOLLOW_NEXT_in_p_WindowVars4246); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR165=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_WindowVars4248); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR165_tree = this.adaptor.create(DOLLAR165);
|
|
this.adaptor.addChild(root_0, DOLLAR165_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_WindowVars4250);
|
|
p_QName166=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName166.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CountClause_return: (function() {
|
|
XQueryParser.p_CountClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CountClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:473:1: p_CountClause : kc+= COUNT DOLLAR p_VarName ;
|
|
// $ANTLR start "p_CountClause"
|
|
p_CountClause: function() {
|
|
var retval = new XQueryParser.p_CountClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR167 = null;
|
|
var kc = null;
|
|
var list_kc=null;
|
|
var p_VarName168 = null;
|
|
|
|
var DOLLAR167_tree=null;
|
|
var kc_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:474:9: (kc+= COUNT DOLLAR p_VarName )
|
|
// XQueryParser.g:474:11: kc+= COUNT DOLLAR p_VarName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kc=this.match(this.input,COUNT,XQueryParser.FOLLOW_COUNT_in_p_CountClause4290); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_kc)) list_kc = [];
|
|
list_kc.push(kc);
|
|
|
|
DOLLAR167=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_CountClause4292); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR167_tree = this.adaptor.create(DOLLAR167);
|
|
this.adaptor.addChild(root_0, DOLLAR167_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_CountClause4294);
|
|
p_VarName168=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName168.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WhereClause_return: (function() {
|
|
XQueryParser.p_WhereClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WhereClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:478:1: p_WhereClause : kw+= WHERE p_ExprSingle ;
|
|
// $ANTLR start "p_WhereClause"
|
|
p_WhereClause: function() {
|
|
var retval = new XQueryParser.p_WhereClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kw = null;
|
|
var list_kw=null;
|
|
var p_ExprSingle169 = null;
|
|
|
|
var kw_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:479:9: (kw+= WHERE p_ExprSingle )
|
|
// XQueryParser.g:479:11: kw+= WHERE p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kw=this.match(this.input,WHERE,XQueryParser.FOLLOW_WHERE_in_p_WhereClause4330); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kw_tree = this.adaptor.create(kw);
|
|
this.adaptor.addChild(root_0, kw_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_kw)) list_kw = [];
|
|
list_kw.push(kw);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_WhereClause4332);
|
|
p_ExprSingle169=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle169.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_GroupByClause_return: (function() {
|
|
XQueryParser.p_GroupByClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_GroupByClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:483:1: p_GroupByClause : k+= GROUP k+= BY p_GroupingSpecList ;
|
|
// $ANTLR start "p_GroupByClause"
|
|
p_GroupByClause: function() {
|
|
var retval = new XQueryParser.p_GroupByClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_GroupingSpecList170 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:484:9: (k+= GROUP k+= BY p_GroupingSpecList )
|
|
// XQueryParser.g:484:13: k+= GROUP k+= BY p_GroupingSpecList
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,GROUP,XQueryParser.FOLLOW_GROUP_in_p_GroupByClause4362); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,BY,XQueryParser.FOLLOW_BY_in_p_GroupByClause4366); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_GroupingSpecList_in_p_GroupByClause4368);
|
|
p_GroupingSpecList170=this.p_GroupingSpecList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_GroupingSpecList170.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_GroupingSpecList_return: (function() {
|
|
XQueryParser.p_GroupingSpecList_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_GroupingSpecList_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:488:1: p_GroupingSpecList : p_GroupingSpec ( COMMA p_GroupingSpec )* ;
|
|
// $ANTLR start "p_GroupingSpecList"
|
|
p_GroupingSpecList: function() {
|
|
var retval = new XQueryParser.p_GroupingSpecList_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA172 = null;
|
|
var p_GroupingSpec171 = null;
|
|
var p_GroupingSpec173 = null;
|
|
|
|
var COMMA172_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:489:9: ( p_GroupingSpec ( COMMA p_GroupingSpec )* )
|
|
// XQueryParser.g:489:13: p_GroupingSpec ( COMMA p_GroupingSpec )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_GroupingSpec_in_p_GroupingSpecList4397);
|
|
p_GroupingSpec171=this.p_GroupingSpec();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_GroupingSpec171.getTree());
|
|
// XQueryParser.g:489:28: ( COMMA p_GroupingSpec )*
|
|
loop71:
|
|
do {
|
|
var alt71=2;
|
|
var LA71_0 = this.input.LA(1);
|
|
|
|
if ( (LA71_0==COMMA) ) {
|
|
alt71=1;
|
|
}
|
|
|
|
|
|
switch (alt71) {
|
|
case 1 :
|
|
// XQueryParser.g:489:29: COMMA p_GroupingSpec
|
|
COMMA172=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_GroupingSpecList4400); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA172_tree = this.adaptor.create(COMMA172);
|
|
this.adaptor.addChild(root_0, COMMA172_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_GroupingSpec_in_p_GroupingSpecList4402);
|
|
p_GroupingSpec173=this.p_GroupingSpec();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_GroupingSpec173.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop71;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_GroupingSpec_return: (function() {
|
|
XQueryParser.p_GroupingSpec_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_GroupingSpec_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:493:1: p_GroupingSpec : DOLLAR p_VarName (kc= COLLATION p_StringLiteral )? ;
|
|
// $ANTLR start "p_GroupingSpec"
|
|
p_GroupingSpec: function() {
|
|
var retval = new XQueryParser.p_GroupingSpec_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var DOLLAR174 = null;
|
|
var p_VarName175 = null;
|
|
var p_StringLiteral176 = null;
|
|
|
|
var kc_tree=null;
|
|
var DOLLAR174_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:494:9: ( DOLLAR p_VarName (kc= COLLATION p_StringLiteral )? )
|
|
// XQueryParser.g:494:13: DOLLAR p_VarName (kc= COLLATION p_StringLiteral )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DOLLAR174=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_GroupingSpec4432); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR174_tree = this.adaptor.create(DOLLAR174);
|
|
this.adaptor.addChild(root_0, DOLLAR174_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_GroupingSpec4434);
|
|
p_VarName175=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName175.getTree());
|
|
// XQueryParser.g:494:30: (kc= COLLATION p_StringLiteral )?
|
|
var alt72=2;
|
|
var LA72_0 = this.input.LA(1);
|
|
|
|
if ( (LA72_0==COLLATION) ) {
|
|
alt72=1;
|
|
}
|
|
switch (alt72) {
|
|
case 1 :
|
|
// XQueryParser.g:494:31: kc= COLLATION p_StringLiteral
|
|
kc=this.match(this.input,COLLATION,XQueryParser.FOLLOW_COLLATION_in_p_GroupingSpec4439); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_GroupingSpec4441);
|
|
p_StringLiteral176=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral176.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OrderByClause_return: (function() {
|
|
XQueryParser.p_OrderByClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OrderByClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:498:1: p_OrderByClause : ( (k+= ORDER k+= BY ) | (k+= STABLE k+= ORDER k+= BY ) ) p_OrderSpecList ;
|
|
// $ANTLR start "p_OrderByClause"
|
|
p_OrderByClause: function() {
|
|
var retval = new XQueryParser.p_OrderByClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_OrderSpecList177 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:499:9: ( ( (k+= ORDER k+= BY ) | (k+= STABLE k+= ORDER k+= BY ) ) p_OrderSpecList )
|
|
// XQueryParser.g:499:13: ( (k+= ORDER k+= BY ) | (k+= STABLE k+= ORDER k+= BY ) ) p_OrderSpecList
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:499:13: ( (k+= ORDER k+= BY ) | (k+= STABLE k+= ORDER k+= BY ) )
|
|
var alt73=2;
|
|
var LA73_0 = this.input.LA(1);
|
|
|
|
if ( (LA73_0==ORDER) ) {
|
|
alt73=1;
|
|
}
|
|
else if ( (LA73_0==STABLE) ) {
|
|
alt73=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 73, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt73) {
|
|
case 1 :
|
|
// XQueryParser.g:499:14: (k+= ORDER k+= BY )
|
|
// XQueryParser.g:499:14: (k+= ORDER k+= BY )
|
|
// XQueryParser.g:499:15: k+= ORDER k+= BY
|
|
k=this.match(this.input,ORDER,XQueryParser.FOLLOW_ORDER_in_p_OrderByClause4476); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,BY,XQueryParser.FOLLOW_BY_in_p_OrderByClause4480); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:499:33: (k+= STABLE k+= ORDER k+= BY )
|
|
// XQueryParser.g:499:33: (k+= STABLE k+= ORDER k+= BY )
|
|
// XQueryParser.g:499:34: k+= STABLE k+= ORDER k+= BY
|
|
k=this.match(this.input,STABLE,XQueryParser.FOLLOW_STABLE_in_p_OrderByClause4488); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,ORDER,XQueryParser.FOLLOW_ORDER_in_p_OrderByClause4492); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,BY,XQueryParser.FOLLOW_BY_in_p_OrderByClause4496); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrderSpecList_in_p_OrderByClause4500);
|
|
p_OrderSpecList177=this.p_OrderSpecList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrderSpecList177.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OrderSpecList_return: (function() {
|
|
XQueryParser.p_OrderSpecList_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OrderSpecList_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:503:1: p_OrderSpecList : p_OrderSpec ( COMMA p_OrderSpec )* ;
|
|
// $ANTLR start "p_OrderSpecList"
|
|
p_OrderSpecList: function() {
|
|
var retval = new XQueryParser.p_OrderSpecList_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA179 = null;
|
|
var p_OrderSpec178 = null;
|
|
var p_OrderSpec180 = null;
|
|
|
|
var COMMA179_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:504:9: ( p_OrderSpec ( COMMA p_OrderSpec )* )
|
|
// XQueryParser.g:504:13: p_OrderSpec ( COMMA p_OrderSpec )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrderSpec_in_p_OrderSpecList4529);
|
|
p_OrderSpec178=this.p_OrderSpec();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrderSpec178.getTree());
|
|
// XQueryParser.g:504:25: ( COMMA p_OrderSpec )*
|
|
loop74:
|
|
do {
|
|
var alt74=2;
|
|
var LA74_0 = this.input.LA(1);
|
|
|
|
if ( (LA74_0==COMMA) ) {
|
|
alt74=1;
|
|
}
|
|
|
|
|
|
switch (alt74) {
|
|
case 1 :
|
|
// XQueryParser.g:504:26: COMMA p_OrderSpec
|
|
COMMA179=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_OrderSpecList4532); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA179_tree = this.adaptor.create(COMMA179);
|
|
this.adaptor.addChild(root_0, COMMA179_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrderSpec_in_p_OrderSpecList4534);
|
|
p_OrderSpec180=this.p_OrderSpec();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrderSpec180.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop74;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OrderSpec_return: (function() {
|
|
XQueryParser.p_OrderSpec_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OrderSpec_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:508:1: p_OrderSpec : p_ExprSingle p_OrderModifier ;
|
|
// $ANTLR start "p_OrderSpec"
|
|
p_OrderSpec: function() {
|
|
var retval = new XQueryParser.p_OrderSpec_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ExprSingle181 = null;
|
|
var p_OrderModifier182 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:509:9: ( p_ExprSingle p_OrderModifier )
|
|
// XQueryParser.g:509:13: p_ExprSingle p_OrderModifier
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_OrderSpec4564);
|
|
p_ExprSingle181=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle181.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrderModifier_in_p_OrderSpec4566);
|
|
p_OrderModifier182=this.p_OrderModifier();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrderModifier182.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OrderModifier_return: (function() {
|
|
XQueryParser.p_OrderModifier_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OrderModifier_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:513:1: p_OrderModifier : (ka= ASCENDING | k+= DESCENDING )? (k+= EMPTY (k+= GREATEST | k+= LEAST ) )? (k+= COLLATION p_StringLiteral )? ;
|
|
// $ANTLR start "p_OrderModifier"
|
|
p_OrderModifier: function() {
|
|
var retval = new XQueryParser.p_OrderModifier_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ka = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_StringLiteral183 = null;
|
|
|
|
var ka_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:514:9: ( (ka= ASCENDING | k+= DESCENDING )? (k+= EMPTY (k+= GREATEST | k+= LEAST ) )? (k+= COLLATION p_StringLiteral )? )
|
|
// XQueryParser.g:514:11: (ka= ASCENDING | k+= DESCENDING )? (k+= EMPTY (k+= GREATEST | k+= LEAST ) )? (k+= COLLATION p_StringLiteral )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:514:11: (ka= ASCENDING | k+= DESCENDING )?
|
|
var alt75=3;
|
|
var LA75_0 = this.input.LA(1);
|
|
|
|
if ( (LA75_0==ASCENDING) ) {
|
|
alt75=1;
|
|
}
|
|
else if ( (LA75_0==DESCENDING) ) {
|
|
alt75=2;
|
|
}
|
|
switch (alt75) {
|
|
case 1 :
|
|
// XQueryParser.g:514:12: ka= ASCENDING
|
|
ka=this.match(this.input,ASCENDING,XQueryParser.FOLLOW_ASCENDING_in_p_OrderModifier4595); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:514:27: k+= DESCENDING
|
|
k=this.match(this.input,DESCENDING,XQueryParser.FOLLOW_DESCENDING_in_p_OrderModifier4601); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:514:43: (k+= EMPTY (k+= GREATEST | k+= LEAST ) )?
|
|
var alt77=2;
|
|
var LA77_0 = this.input.LA(1);
|
|
|
|
if ( (LA77_0==EMPTY) ) {
|
|
alt77=1;
|
|
}
|
|
switch (alt77) {
|
|
case 1 :
|
|
// XQueryParser.g:514:44: k+= EMPTY (k+= GREATEST | k+= LEAST )
|
|
k=this.match(this.input,EMPTY,XQueryParser.FOLLOW_EMPTY_in_p_OrderModifier4608); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:514:53: (k+= GREATEST | k+= LEAST )
|
|
var alt76=2;
|
|
var LA76_0 = this.input.LA(1);
|
|
|
|
if ( (LA76_0==GREATEST) ) {
|
|
alt76=1;
|
|
}
|
|
else if ( (LA76_0==LEAST) ) {
|
|
alt76=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 76, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt76) {
|
|
case 1 :
|
|
// XQueryParser.g:514:54: k+= GREATEST
|
|
k=this.match(this.input,GREATEST,XQueryParser.FOLLOW_GREATEST_in_p_OrderModifier4613); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:514:68: k+= LEAST
|
|
k=this.match(this.input,LEAST,XQueryParser.FOLLOW_LEAST_in_p_OrderModifier4619); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:514:80: (k+= COLLATION p_StringLiteral )?
|
|
var alt78=2;
|
|
var LA78_0 = this.input.LA(1);
|
|
|
|
if ( (LA78_0==COLLATION) ) {
|
|
alt78=1;
|
|
}
|
|
switch (alt78) {
|
|
case 1 :
|
|
// XQueryParser.g:514:81: k+= COLLATION p_StringLiteral
|
|
k=this.match(this.input,COLLATION,XQueryParser.FOLLOW_COLLATION_in_p_OrderModifier4627); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_OrderModifier4629);
|
|
p_StringLiteral183=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral183.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ReturnClause_return: (function() {
|
|
XQueryParser.p_ReturnClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ReturnClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:518:1: p_ReturnClause : kr= RETURN p_ExprSingle ;
|
|
// $ANTLR start "p_ReturnClause"
|
|
p_ReturnClause: function() {
|
|
var retval = new XQueryParser.p_ReturnClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kr = null;
|
|
var p_ExprSingle184 = null;
|
|
|
|
var kr_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:519:9: (kr= RETURN p_ExprSingle )
|
|
// XQueryParser.g:519:11: kr= RETURN p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kr=this.match(this.input,RETURN,XQueryParser.FOLLOW_RETURN_in_p_ReturnClause4660); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kr_tree = this.adaptor.create(kr);
|
|
this.adaptor.addChild(root_0, kr_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ReturnClause4662);
|
|
p_ExprSingle184=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle184.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_QuantifiedExpr_return: (function() {
|
|
XQueryParser.p_QuantifiedExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_QuantifiedExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:523:1: p_QuantifiedExpr : (k+= SOME | k+= EVERY ) DOLLAR p_VarName ( p_TypeDeclaration )? k+= IN p_ExprSingle ( COMMA DOLLAR p_QName ( p_TypeDeclaration )? k+= IN p_ExprSingle )* k+= SATISFIES p_ExprSingle ;
|
|
// $ANTLR start "p_QuantifiedExpr"
|
|
p_QuantifiedExpr: function() {
|
|
var retval = new XQueryParser.p_QuantifiedExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR185 = null;
|
|
var COMMA189 = null;
|
|
var DOLLAR190 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_VarName186 = null;
|
|
var p_TypeDeclaration187 = null;
|
|
var p_ExprSingle188 = null;
|
|
var p_QName191 = null;
|
|
var p_TypeDeclaration192 = null;
|
|
var p_ExprSingle193 = null;
|
|
var p_ExprSingle194 = null;
|
|
|
|
var DOLLAR185_tree=null;
|
|
var COMMA189_tree=null;
|
|
var DOLLAR190_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:524:9: ( (k+= SOME | k+= EVERY ) DOLLAR p_VarName ( p_TypeDeclaration )? k+= IN p_ExprSingle ( COMMA DOLLAR p_QName ( p_TypeDeclaration )? k+= IN p_ExprSingle )* k+= SATISFIES p_ExprSingle )
|
|
// XQueryParser.g:524:13: (k+= SOME | k+= EVERY ) DOLLAR p_VarName ( p_TypeDeclaration )? k+= IN p_ExprSingle ( COMMA DOLLAR p_QName ( p_TypeDeclaration )? k+= IN p_ExprSingle )* k+= SATISFIES p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:524:13: (k+= SOME | k+= EVERY )
|
|
var alt79=2;
|
|
var LA79_0 = this.input.LA(1);
|
|
|
|
if ( (LA79_0==SOME) ) {
|
|
alt79=1;
|
|
}
|
|
else if ( (LA79_0==EVERY) ) {
|
|
alt79=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 79, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt79) {
|
|
case 1 :
|
|
// XQueryParser.g:524:14: k+= SOME
|
|
k=this.match(this.input,SOME,XQueryParser.FOLLOW_SOME_in_p_QuantifiedExpr4693); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:524:24: k+= EVERY
|
|
k=this.match(this.input,EVERY,XQueryParser.FOLLOW_EVERY_in_p_QuantifiedExpr4699); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
DOLLAR185=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_QuantifiedExpr4702); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR185_tree = this.adaptor.create(DOLLAR185);
|
|
this.adaptor.addChild(root_0, DOLLAR185_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_QuantifiedExpr4704);
|
|
p_VarName186=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName186.getTree());
|
|
// XQueryParser.g:524:51: ( p_TypeDeclaration )?
|
|
var alt80=2;
|
|
var LA80_0 = this.input.LA(1);
|
|
|
|
if ( (LA80_0==AS) ) {
|
|
alt80=1;
|
|
}
|
|
switch (alt80) {
|
|
case 1 :
|
|
// XQueryParser.g:524:51: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_QuantifiedExpr4706);
|
|
p_TypeDeclaration187=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration187.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,IN,XQueryParser.FOLLOW_IN_in_p_QuantifiedExpr4711); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_QuantifiedExpr4713);
|
|
p_ExprSingle188=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle188.getTree());
|
|
// XQueryParser.g:524:89: ( COMMA DOLLAR p_QName ( p_TypeDeclaration )? k+= IN p_ExprSingle )*
|
|
loop82:
|
|
do {
|
|
var alt82=2;
|
|
var LA82_0 = this.input.LA(1);
|
|
|
|
if ( (LA82_0==COMMA) ) {
|
|
alt82=1;
|
|
}
|
|
|
|
|
|
switch (alt82) {
|
|
case 1 :
|
|
// XQueryParser.g:524:90: COMMA DOLLAR p_QName ( p_TypeDeclaration )? k+= IN p_ExprSingle
|
|
COMMA189=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_QuantifiedExpr4716); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA189_tree = this.adaptor.create(COMMA189);
|
|
this.adaptor.addChild(root_0, COMMA189_tree);
|
|
}
|
|
DOLLAR190=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_QuantifiedExpr4718); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR190_tree = this.adaptor.create(DOLLAR190);
|
|
this.adaptor.addChild(root_0, DOLLAR190_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_QuantifiedExpr4720);
|
|
p_QName191=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName191.getTree());
|
|
// XQueryParser.g:524:111: ( p_TypeDeclaration )?
|
|
var alt81=2;
|
|
var LA81_0 = this.input.LA(1);
|
|
|
|
if ( (LA81_0==AS) ) {
|
|
alt81=1;
|
|
}
|
|
switch (alt81) {
|
|
case 1 :
|
|
// XQueryParser.g:524:111: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_p_QuantifiedExpr4722);
|
|
p_TypeDeclaration192=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeDeclaration192.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,IN,XQueryParser.FOLLOW_IN_in_p_QuantifiedExpr4727); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_QuantifiedExpr4729);
|
|
p_ExprSingle193=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle193.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop82;
|
|
}
|
|
} while (true);
|
|
|
|
k=this.match(this.input,SATISFIES,XQueryParser.FOLLOW_SATISFIES_in_p_QuantifiedExpr4735); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_QuantifiedExpr4737);
|
|
p_ExprSingle194=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle194.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TypeswitchExpr_return: (function() {
|
|
XQueryParser.p_TypeswitchExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TypeswitchExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:528:1: p_TypeswitchExpr : k+= TYPESWITCH LPAREN pm_Expr RPAREN ( p_CaseClause )+ k+= DEFAULT ( DOLLAR p_VarName )? k+= RETURN p_ExprSingle ;
|
|
// $ANTLR start "p_TypeswitchExpr"
|
|
p_TypeswitchExpr: function() {
|
|
var retval = new XQueryParser.p_TypeswitchExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LPAREN195 = null;
|
|
var RPAREN197 = null;
|
|
var DOLLAR199 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var pm_Expr196 = null;
|
|
var p_CaseClause198 = null;
|
|
var p_VarName200 = null;
|
|
var p_ExprSingle201 = null;
|
|
|
|
var LPAREN195_tree=null;
|
|
var RPAREN197_tree=null;
|
|
var DOLLAR199_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:529:9: (k+= TYPESWITCH LPAREN pm_Expr RPAREN ( p_CaseClause )+ k+= DEFAULT ( DOLLAR p_VarName )? k+= RETURN p_ExprSingle )
|
|
// XQueryParser.g:529:11: k+= TYPESWITCH LPAREN pm_Expr RPAREN ( p_CaseClause )+ k+= DEFAULT ( DOLLAR p_VarName )? k+= RETURN p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,TYPESWITCH,XQueryParser.FOLLOW_TYPESWITCH_in_p_TypeswitchExpr4766); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
LPAREN195=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_TypeswitchExpr4768); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN195_tree = this.adaptor.create(LPAREN195);
|
|
this.adaptor.addChild(root_0, LPAREN195_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_TypeswitchExpr4770);
|
|
pm_Expr196=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr196.getTree());
|
|
RPAREN197=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_TypeswitchExpr4772); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN197_tree = this.adaptor.create(RPAREN197);
|
|
this.adaptor.addChild(root_0, RPAREN197_tree);
|
|
}
|
|
// XQueryParser.g:529:47: ( p_CaseClause )+
|
|
var cnt83=0;
|
|
loop83:
|
|
do {
|
|
var alt83=2;
|
|
var LA83_0 = this.input.LA(1);
|
|
|
|
if ( (LA83_0==CASE) ) {
|
|
alt83=1;
|
|
}
|
|
|
|
|
|
switch (alt83) {
|
|
case 1 :
|
|
// XQueryParser.g:529:47: p_CaseClause
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CaseClause_in_p_TypeswitchExpr4774);
|
|
p_CaseClause198=this.p_CaseClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CaseClause198.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
if ( cnt83 >= 1 ) {
|
|
break loop83;
|
|
}
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var eee = new org.antlr.runtime.EarlyExitException(83, this.input);
|
|
throw eee;
|
|
}
|
|
cnt83++;
|
|
} while (true);
|
|
|
|
k=this.match(this.input,DEFAULT,XQueryParser.FOLLOW_DEFAULT_in_p_TypeswitchExpr4779); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:529:72: ( DOLLAR p_VarName )?
|
|
var alt84=2;
|
|
var LA84_0 = this.input.LA(1);
|
|
|
|
if ( (LA84_0==DOLLAR) ) {
|
|
alt84=1;
|
|
}
|
|
switch (alt84) {
|
|
case 1 :
|
|
// XQueryParser.g:529:73: DOLLAR p_VarName
|
|
DOLLAR199=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_TypeswitchExpr4782); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR199_tree = this.adaptor.create(DOLLAR199);
|
|
this.adaptor.addChild(root_0, DOLLAR199_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_TypeswitchExpr4784);
|
|
p_VarName200=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName200.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,RETURN,XQueryParser.FOLLOW_RETURN_in_p_TypeswitchExpr4790); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TypeswitchExpr4792);
|
|
p_ExprSingle201=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle201.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CaseClause_return: (function() {
|
|
XQueryParser.p_CaseClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CaseClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:533:1: p_CaseClause : k+= CASE ( DOLLAR p_VarName k+= AS )? p_SequenceType k+= RETURN p_ExprSingle ;
|
|
// $ANTLR start "p_CaseClause"
|
|
p_CaseClause: function() {
|
|
var retval = new XQueryParser.p_CaseClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR202 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_VarName203 = null;
|
|
var p_SequenceType204 = null;
|
|
var p_ExprSingle205 = null;
|
|
|
|
var DOLLAR202_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:534:9: (k+= CASE ( DOLLAR p_VarName k+= AS )? p_SequenceType k+= RETURN p_ExprSingle )
|
|
// XQueryParser.g:534:11: k+= CASE ( DOLLAR p_VarName k+= AS )? p_SequenceType k+= RETURN p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,CASE,XQueryParser.FOLLOW_CASE_in_p_CaseClause4821); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:534:19: ( DOLLAR p_VarName k+= AS )?
|
|
var alt85=2;
|
|
var LA85_0 = this.input.LA(1);
|
|
|
|
if ( (LA85_0==DOLLAR) ) {
|
|
alt85=1;
|
|
}
|
|
switch (alt85) {
|
|
case 1 :
|
|
// XQueryParser.g:534:20: DOLLAR p_VarName k+= AS
|
|
DOLLAR202=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_CaseClause4824); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR202_tree = this.adaptor.create(DOLLAR202);
|
|
this.adaptor.addChild(root_0, DOLLAR202_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_CaseClause4826);
|
|
p_VarName203=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName203.getTree());
|
|
k=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_CaseClause4830); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SequenceType_in_p_CaseClause4834);
|
|
p_SequenceType204=this.p_SequenceType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SequenceType204.getTree());
|
|
k=this.match(this.input,RETURN,XQueryParser.FOLLOW_RETURN_in_p_CaseClause4838); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_CaseClause4840);
|
|
p_ExprSingle205=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle205.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IfExpr_return: (function() {
|
|
XQueryParser.p_IfExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IfExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:538:1: p_IfExpr : k+= IF LPAREN pm_Expr RPAREN k+= THEN p_ExprSingle k+= ELSE p_ExprSingle ;
|
|
// $ANTLR start "p_IfExpr"
|
|
p_IfExpr: function() {
|
|
var retval = new XQueryParser.p_IfExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LPAREN206 = null;
|
|
var RPAREN208 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var pm_Expr207 = null;
|
|
var p_ExprSingle209 = null;
|
|
var p_ExprSingle210 = null;
|
|
|
|
var LPAREN206_tree=null;
|
|
var RPAREN208_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:539:9: (k+= IF LPAREN pm_Expr RPAREN k+= THEN p_ExprSingle k+= ELSE p_ExprSingle )
|
|
// XQueryParser.g:539:11: k+= IF LPAREN pm_Expr RPAREN k+= THEN p_ExprSingle k+= ELSE p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,IF,XQueryParser.FOLLOW_IF_in_p_IfExpr4869); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
LPAREN206=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_IfExpr4871); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN206_tree = this.adaptor.create(LPAREN206);
|
|
this.adaptor.addChild(root_0, LPAREN206_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_IfExpr4873);
|
|
pm_Expr207=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr207.getTree());
|
|
RPAREN208=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_IfExpr4875); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN208_tree = this.adaptor.create(RPAREN208);
|
|
this.adaptor.addChild(root_0, RPAREN208_tree);
|
|
}
|
|
k=this.match(this.input,THEN,XQueryParser.FOLLOW_THEN_in_p_IfExpr4879); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_IfExpr4881);
|
|
p_ExprSingle209=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle209.getTree());
|
|
k=this.match(this.input,ELSE,XQueryParser.FOLLOW_ELSE_in_p_IfExpr4885); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_IfExpr4887);
|
|
p_ExprSingle210=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle210.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OrExpr_return: (function() {
|
|
XQueryParser.p_OrExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OrExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:543:1: p_OrExpr : p_AndExpr (k= OR p_AndExpr )* ;
|
|
// $ANTLR start "p_OrExpr"
|
|
p_OrExpr: function() {
|
|
var retval = new XQueryParser.p_OrExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var p_AndExpr211 = null;
|
|
var p_AndExpr212 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:544:9: ( p_AndExpr (k= OR p_AndExpr )* )
|
|
// XQueryParser.g:544:11: p_AndExpr (k= OR p_AndExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AndExpr_in_p_OrExpr4914);
|
|
p_AndExpr211=this.p_AndExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AndExpr211.getTree());
|
|
// XQueryParser.g:544:21: (k= OR p_AndExpr )*
|
|
loop86:
|
|
do {
|
|
var alt86=2;
|
|
var LA86_0 = this.input.LA(1);
|
|
|
|
if ( (LA86_0==OR) ) {
|
|
alt86=1;
|
|
}
|
|
|
|
|
|
switch (alt86) {
|
|
case 1 :
|
|
// XQueryParser.g:544:23: k= OR p_AndExpr
|
|
k=this.match(this.input,OR,XQueryParser.FOLLOW_OR_in_p_OrExpr4920); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AndExpr_in_p_OrExpr4923);
|
|
p_AndExpr212=this.p_AndExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AndExpr212.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop86;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AndExpr_return: (function() {
|
|
XQueryParser.p_AndExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AndExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:548:1: p_AndExpr : p_ComparisonExpr (k= AND p_ComparisonExpr )* ;
|
|
// $ANTLR start "p_AndExpr"
|
|
p_AndExpr: function() {
|
|
var retval = new XQueryParser.p_AndExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var p_ComparisonExpr213 = null;
|
|
var p_ComparisonExpr214 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:549:9: ( p_ComparisonExpr (k= AND p_ComparisonExpr )* )
|
|
// XQueryParser.g:549:13: p_ComparisonExpr (k= AND p_ComparisonExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ComparisonExpr_in_p_AndExpr4954);
|
|
p_ComparisonExpr213=this.p_ComparisonExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ComparisonExpr213.getTree());
|
|
// XQueryParser.g:549:30: (k= AND p_ComparisonExpr )*
|
|
loop87:
|
|
do {
|
|
var alt87=2;
|
|
var LA87_0 = this.input.LA(1);
|
|
|
|
if ( (LA87_0==AND) ) {
|
|
alt87=1;
|
|
}
|
|
|
|
|
|
switch (alt87) {
|
|
case 1 :
|
|
// XQueryParser.g:549:32: k= AND p_ComparisonExpr
|
|
k=this.match(this.input,AND,XQueryParser.FOLLOW_AND_in_p_AndExpr4960); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ComparisonExpr_in_p_AndExpr4963);
|
|
p_ComparisonExpr214=this.p_ComparisonExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ComparisonExpr214.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop87;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ComparisonExpr_return: (function() {
|
|
XQueryParser.p_ComparisonExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ComparisonExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:553:1: p_ComparisonExpr : p_RangeExpr ( ( p_ValueComp | p_GeneralComp | p_NodeComp ) p_RangeExpr )? ;
|
|
// $ANTLR start "p_ComparisonExpr"
|
|
p_ComparisonExpr: function() {
|
|
var retval = new XQueryParser.p_ComparisonExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_RangeExpr215 = null;
|
|
var p_ValueComp216 = null;
|
|
var p_GeneralComp217 = null;
|
|
var p_NodeComp218 = null;
|
|
var p_RangeExpr219 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:554:9: ( p_RangeExpr ( ( p_ValueComp | p_GeneralComp | p_NodeComp ) p_RangeExpr )? )
|
|
// XQueryParser.g:554:13: p_RangeExpr ( ( p_ValueComp | p_GeneralComp | p_NodeComp ) p_RangeExpr )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RangeExpr_in_p_ComparisonExpr4994);
|
|
p_RangeExpr215=this.p_RangeExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_RangeExpr215.getTree());
|
|
// XQueryParser.g:554:25: ( ( p_ValueComp | p_GeneralComp | p_NodeComp ) p_RangeExpr )?
|
|
var alt89=2;
|
|
var LA89_0 = this.input.LA(1);
|
|
|
|
if ( (LA89_0==EQ||LA89_0==GE||LA89_0==GT||LA89_0==IS||LA89_0==LE||LA89_0==LT||LA89_0==NE||LA89_0==EQUAL||LA89_0==NOTEQUAL||(LA89_0>=SMALLER && LA89_0<=GREATER_GREATER)) ) {
|
|
alt89=1;
|
|
}
|
|
switch (alt89) {
|
|
case 1 :
|
|
// XQueryParser.g:554:27: ( p_ValueComp | p_GeneralComp | p_NodeComp ) p_RangeExpr
|
|
// XQueryParser.g:554:27: ( p_ValueComp | p_GeneralComp | p_NodeComp )
|
|
var alt88=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case EQ:
|
|
case GE:
|
|
case GT:
|
|
case LE:
|
|
case LT:
|
|
case NE:
|
|
alt88=1;
|
|
break;
|
|
case EQUAL:
|
|
case NOTEQUAL:
|
|
case SMALLER:
|
|
case GREATER:
|
|
case SMALLEREQ:
|
|
case GREATEREQ:
|
|
alt88=2;
|
|
break;
|
|
case IS:
|
|
case SMALLER_SMALLER:
|
|
case GREATER_GREATER:
|
|
alt88=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 88, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt88) {
|
|
case 1 :
|
|
// XQueryParser.g:554:28: p_ValueComp
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ValueComp_in_p_ComparisonExpr4999);
|
|
p_ValueComp216=this.p_ValueComp();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ValueComp216.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:554:42: p_GeneralComp
|
|
this.pushFollow(XQueryParser.FOLLOW_p_GeneralComp_in_p_ComparisonExpr5003);
|
|
p_GeneralComp217=this.p_GeneralComp();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_GeneralComp217.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:554:58: p_NodeComp
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NodeComp_in_p_ComparisonExpr5007);
|
|
p_NodeComp218=this.p_NodeComp();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NodeComp218.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RangeExpr_in_p_ComparisonExpr5010);
|
|
p_RangeExpr219=this.p_RangeExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_RangeExpr219.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_RangeExpr_return: (function() {
|
|
XQueryParser.p_RangeExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_RangeExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:558:1: p_RangeExpr : p_AdditiveExpr (k= TO p_AdditiveExpr )? ;
|
|
// $ANTLR start "p_RangeExpr"
|
|
p_RangeExpr: function() {
|
|
var retval = new XQueryParser.p_RangeExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var p_AdditiveExpr220 = null;
|
|
var p_AdditiveExpr221 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:559:9: ( p_AdditiveExpr (k= TO p_AdditiveExpr )? )
|
|
// XQueryParser.g:559:13: p_AdditiveExpr (k= TO p_AdditiveExpr )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AdditiveExpr_in_p_RangeExpr5041);
|
|
p_AdditiveExpr220=this.p_AdditiveExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AdditiveExpr220.getTree());
|
|
// XQueryParser.g:559:28: (k= TO p_AdditiveExpr )?
|
|
var alt90=2;
|
|
var LA90_0 = this.input.LA(1);
|
|
|
|
if ( (LA90_0==TO) ) {
|
|
alt90=1;
|
|
}
|
|
switch (alt90) {
|
|
case 1 :
|
|
// XQueryParser.g:559:30: k= TO p_AdditiveExpr
|
|
k=this.match(this.input,TO,XQueryParser.FOLLOW_TO_in_p_RangeExpr5047); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AdditiveExpr_in_p_RangeExpr5050);
|
|
p_AdditiveExpr221=this.p_AdditiveExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AdditiveExpr221.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AdditiveExpr_return: (function() {
|
|
XQueryParser.p_AdditiveExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AdditiveExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:563:1: p_AdditiveExpr : p_MultiplicativeExpr ( ( PLUS | MINUS ) p_MultiplicativeExpr )* ;
|
|
// $ANTLR start "p_AdditiveExpr"
|
|
p_AdditiveExpr: function() {
|
|
var retval = new XQueryParser.p_AdditiveExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set223 = null;
|
|
var p_MultiplicativeExpr222 = null;
|
|
var p_MultiplicativeExpr224 = null;
|
|
|
|
var set223_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:564:9: ( p_MultiplicativeExpr ( ( PLUS | MINUS ) p_MultiplicativeExpr )* )
|
|
// XQueryParser.g:564:13: p_MultiplicativeExpr ( ( PLUS | MINUS ) p_MultiplicativeExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_MultiplicativeExpr_in_p_AdditiveExpr5081);
|
|
p_MultiplicativeExpr222=this.p_MultiplicativeExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_MultiplicativeExpr222.getTree());
|
|
// XQueryParser.g:564:34: ( ( PLUS | MINUS ) p_MultiplicativeExpr )*
|
|
loop91:
|
|
do {
|
|
var alt91=2;
|
|
var LA91_0 = this.input.LA(1);
|
|
|
|
if ( ((LA91_0>=PLUS && LA91_0<=MINUS)) ) {
|
|
alt91=1;
|
|
}
|
|
|
|
|
|
switch (alt91) {
|
|
case 1 :
|
|
// XQueryParser.g:564:36: ( PLUS | MINUS ) p_MultiplicativeExpr
|
|
set223=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=PLUS && this.input.LA(1)<=MINUS) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set223));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_MultiplicativeExpr_in_p_AdditiveExpr5093);
|
|
p_MultiplicativeExpr224=this.p_MultiplicativeExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_MultiplicativeExpr224.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop91;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_MultiplicativeExpr_return: (function() {
|
|
XQueryParser.p_MultiplicativeExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_MultiplicativeExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:568:1: p_MultiplicativeExpr : p_UnionExpr ( ( STAR | kd= DIV | ki= IDIV | km= MOD ) p_UnionExpr )* ;
|
|
// $ANTLR start "p_MultiplicativeExpr"
|
|
p_MultiplicativeExpr: function() {
|
|
var retval = new XQueryParser.p_MultiplicativeExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kd = null;
|
|
var ki = null;
|
|
var km = null;
|
|
var STAR226 = null;
|
|
var p_UnionExpr225 = null;
|
|
var p_UnionExpr227 = null;
|
|
|
|
var kd_tree=null;
|
|
var ki_tree=null;
|
|
var km_tree=null;
|
|
var STAR226_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:569:9: ( p_UnionExpr ( ( STAR | kd= DIV | ki= IDIV | km= MOD ) p_UnionExpr )* )
|
|
// XQueryParser.g:569:13: p_UnionExpr ( ( STAR | kd= DIV | ki= IDIV | km= MOD ) p_UnionExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_UnionExpr_in_p_MultiplicativeExpr5124);
|
|
p_UnionExpr225=this.p_UnionExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_UnionExpr225.getTree());
|
|
// XQueryParser.g:569:25: ( ( STAR | kd= DIV | ki= IDIV | km= MOD ) p_UnionExpr )*
|
|
loop93:
|
|
do {
|
|
var alt93=2;
|
|
var LA93_0 = this.input.LA(1);
|
|
|
|
if ( (LA93_0==DIV||LA93_0==IDIV||LA93_0==MOD||LA93_0==STAR) ) {
|
|
alt93=1;
|
|
}
|
|
|
|
|
|
switch (alt93) {
|
|
case 1 :
|
|
// XQueryParser.g:569:27: ( STAR | kd= DIV | ki= IDIV | km= MOD ) p_UnionExpr
|
|
// XQueryParser.g:569:27: ( STAR | kd= DIV | ki= IDIV | km= MOD )
|
|
var alt92=4;
|
|
switch ( this.input.LA(1) ) {
|
|
case STAR:
|
|
alt92=1;
|
|
break;
|
|
case DIV:
|
|
alt92=2;
|
|
break;
|
|
case IDIV:
|
|
alt92=3;
|
|
break;
|
|
case MOD:
|
|
alt92=4;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 92, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt92) {
|
|
case 1 :
|
|
// XQueryParser.g:569:28: STAR
|
|
STAR226=this.match(this.input,STAR,XQueryParser.FOLLOW_STAR_in_p_MultiplicativeExpr5129); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
STAR226_tree = this.adaptor.create(STAR226);
|
|
this.adaptor.addChild(root_0, STAR226_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:569:35: kd= DIV
|
|
kd=this.match(this.input,DIV,XQueryParser.FOLLOW_DIV_in_p_MultiplicativeExpr5135); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kd_tree = this.adaptor.create(kd);
|
|
this.adaptor.addChild(root_0, kd_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:569:44: ki= IDIV
|
|
ki=this.match(this.input,IDIV,XQueryParser.FOLLOW_IDIV_in_p_MultiplicativeExpr5141); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ki_tree = this.adaptor.create(ki);
|
|
this.adaptor.addChild(root_0, ki_tree);
|
|
}
|
|
if ( this.state.backtracking===0 ) {
|
|
}
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:569:57: km= MOD
|
|
km=this.match(this.input,MOD,XQueryParser.FOLLOW_MOD_in_p_MultiplicativeExpr5149); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
km_tree = this.adaptor.create(km);
|
|
this.adaptor.addChild(root_0, km_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_UnionExpr_in_p_MultiplicativeExpr5153);
|
|
p_UnionExpr227=this.p_UnionExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_UnionExpr227.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop93;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_UnionExpr_return: (function() {
|
|
XQueryParser.p_UnionExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_UnionExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:573:1: p_UnionExpr : p_IntersectExceptExpr ( (ku= UNION | VBAR ) p_IntersectExceptExpr )* ;
|
|
// $ANTLR start "p_UnionExpr"
|
|
p_UnionExpr: function() {
|
|
var retval = new XQueryParser.p_UnionExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ku = null;
|
|
var VBAR229 = null;
|
|
var p_IntersectExceptExpr228 = null;
|
|
var p_IntersectExceptExpr230 = null;
|
|
|
|
var ku_tree=null;
|
|
var VBAR229_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:574:9: ( p_IntersectExceptExpr ( (ku= UNION | VBAR ) p_IntersectExceptExpr )* )
|
|
// XQueryParser.g:574:13: p_IntersectExceptExpr ( (ku= UNION | VBAR ) p_IntersectExceptExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IntersectExceptExpr_in_p_UnionExpr5184);
|
|
p_IntersectExceptExpr228=this.p_IntersectExceptExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IntersectExceptExpr228.getTree());
|
|
// XQueryParser.g:574:35: ( (ku= UNION | VBAR ) p_IntersectExceptExpr )*
|
|
loop95:
|
|
do {
|
|
var alt95=2;
|
|
var LA95_0 = this.input.LA(1);
|
|
|
|
if ( (LA95_0==UNION||LA95_0==VBAR) ) {
|
|
alt95=1;
|
|
}
|
|
|
|
|
|
switch (alt95) {
|
|
case 1 :
|
|
// XQueryParser.g:574:37: (ku= UNION | VBAR ) p_IntersectExceptExpr
|
|
// XQueryParser.g:574:37: (ku= UNION | VBAR )
|
|
var alt94=2;
|
|
var LA94_0 = this.input.LA(1);
|
|
|
|
if ( (LA94_0==UNION) ) {
|
|
alt94=1;
|
|
}
|
|
else if ( (LA94_0==VBAR) ) {
|
|
alt94=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 94, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt94) {
|
|
case 1 :
|
|
// XQueryParser.g:574:38: ku= UNION
|
|
ku=this.match(this.input,UNION,XQueryParser.FOLLOW_UNION_in_p_UnionExpr5191); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ku_tree = this.adaptor.create(ku);
|
|
this.adaptor.addChild(root_0, ku_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:574:49: VBAR
|
|
VBAR229=this.match(this.input,VBAR,XQueryParser.FOLLOW_VBAR_in_p_UnionExpr5195); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
VBAR229_tree = this.adaptor.create(VBAR229);
|
|
this.adaptor.addChild(root_0, VBAR229_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IntersectExceptExpr_in_p_UnionExpr5198);
|
|
p_IntersectExceptExpr230=this.p_IntersectExceptExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IntersectExceptExpr230.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop95;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IntersectExceptExpr_return: (function() {
|
|
XQueryParser.p_IntersectExceptExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IntersectExceptExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:578:1: p_IntersectExceptExpr : p_InstanceofExpr ( (k= INTERSECT | k= EXCEPT ) p_InstanceofExpr )* ;
|
|
// $ANTLR start "p_IntersectExceptExpr"
|
|
p_IntersectExceptExpr: function() {
|
|
var retval = new XQueryParser.p_IntersectExceptExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var p_InstanceofExpr231 = null;
|
|
var p_InstanceofExpr232 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:579:9: ( p_InstanceofExpr ( (k= INTERSECT | k= EXCEPT ) p_InstanceofExpr )* )
|
|
// XQueryParser.g:579:13: p_InstanceofExpr ( (k= INTERSECT | k= EXCEPT ) p_InstanceofExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InstanceofExpr_in_p_IntersectExceptExpr5229);
|
|
p_InstanceofExpr231=this.p_InstanceofExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InstanceofExpr231.getTree());
|
|
// XQueryParser.g:579:30: ( (k= INTERSECT | k= EXCEPT ) p_InstanceofExpr )*
|
|
loop97:
|
|
do {
|
|
var alt97=2;
|
|
var LA97_0 = this.input.LA(1);
|
|
|
|
if ( (LA97_0==EXCEPT||LA97_0==INTERSECT) ) {
|
|
alt97=1;
|
|
}
|
|
|
|
|
|
switch (alt97) {
|
|
case 1 :
|
|
// XQueryParser.g:579:32: (k= INTERSECT | k= EXCEPT ) p_InstanceofExpr
|
|
// XQueryParser.g:579:32: (k= INTERSECT | k= EXCEPT )
|
|
var alt96=2;
|
|
var LA96_0 = this.input.LA(1);
|
|
|
|
if ( (LA96_0==INTERSECT) ) {
|
|
alt96=1;
|
|
}
|
|
else if ( (LA96_0==EXCEPT) ) {
|
|
alt96=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 96, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt96) {
|
|
case 1 :
|
|
// XQueryParser.g:579:33: k= INTERSECT
|
|
k=this.match(this.input,INTERSECT,XQueryParser.FOLLOW_INTERSECT_in_p_IntersectExceptExpr5236); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:579:47: k= EXCEPT
|
|
k=this.match(this.input,EXCEPT,XQueryParser.FOLLOW_EXCEPT_in_p_IntersectExceptExpr5242); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InstanceofExpr_in_p_IntersectExceptExpr5246);
|
|
p_InstanceofExpr232=this.p_InstanceofExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InstanceofExpr232.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop97;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_InstanceofExpr_return: (function() {
|
|
XQueryParser.p_InstanceofExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_InstanceofExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:583:1: p_InstanceofExpr : p_TreatExpr (ki= INSTANCE ko= OF p_SequenceType )? ;
|
|
// $ANTLR start "p_InstanceofExpr"
|
|
p_InstanceofExpr: function() {
|
|
var retval = new XQueryParser.p_InstanceofExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ki = null;
|
|
var ko = null;
|
|
var p_TreatExpr233 = null;
|
|
var p_SequenceType234 = null;
|
|
|
|
var ki_tree=null;
|
|
var ko_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:584:9: ( p_TreatExpr (ki= INSTANCE ko= OF p_SequenceType )? )
|
|
// XQueryParser.g:584:13: p_TreatExpr (ki= INSTANCE ko= OF p_SequenceType )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TreatExpr_in_p_InstanceofExpr5277);
|
|
p_TreatExpr233=this.p_TreatExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TreatExpr233.getTree());
|
|
// XQueryParser.g:584:25: (ki= INSTANCE ko= OF p_SequenceType )?
|
|
var alt98=2;
|
|
var LA98_0 = this.input.LA(1);
|
|
|
|
if ( (LA98_0==INSTANCE) ) {
|
|
alt98=1;
|
|
}
|
|
switch (alt98) {
|
|
case 1 :
|
|
// XQueryParser.g:584:27: ki= INSTANCE ko= OF p_SequenceType
|
|
ki=this.match(this.input,INSTANCE,XQueryParser.FOLLOW_INSTANCE_in_p_InstanceofExpr5283); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ki_tree = this.adaptor.create(ki);
|
|
this.adaptor.addChild(root_0, ki_tree);
|
|
}
|
|
ko=this.match(this.input,OF,XQueryParser.FOLLOW_OF_in_p_InstanceofExpr5287); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ko_tree = this.adaptor.create(ko);
|
|
this.adaptor.addChild(root_0, ko_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SequenceType_in_p_InstanceofExpr5289);
|
|
p_SequenceType234=this.p_SequenceType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SequenceType234.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TreatExpr_return: (function() {
|
|
XQueryParser.p_TreatExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TreatExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:588:1: p_TreatExpr : p_CastableExpr (kt= TREAT ka= AS p_SequenceType )? ;
|
|
// $ANTLR start "p_TreatExpr"
|
|
p_TreatExpr: function() {
|
|
var retval = new XQueryParser.p_TreatExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kt = null;
|
|
var ka = null;
|
|
var p_CastableExpr235 = null;
|
|
var p_SequenceType236 = null;
|
|
|
|
var kt_tree=null;
|
|
var ka_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:589:9: ( p_CastableExpr (kt= TREAT ka= AS p_SequenceType )? )
|
|
// XQueryParser.g:589:13: p_CastableExpr (kt= TREAT ka= AS p_SequenceType )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CastableExpr_in_p_TreatExpr5319);
|
|
p_CastableExpr235=this.p_CastableExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CastableExpr235.getTree());
|
|
// XQueryParser.g:589:28: (kt= TREAT ka= AS p_SequenceType )?
|
|
var alt99=2;
|
|
var LA99_0 = this.input.LA(1);
|
|
|
|
if ( (LA99_0==TREAT) ) {
|
|
alt99=1;
|
|
}
|
|
switch (alt99) {
|
|
case 1 :
|
|
// XQueryParser.g:589:30: kt= TREAT ka= AS p_SequenceType
|
|
kt=this.match(this.input,TREAT,XQueryParser.FOLLOW_TREAT_in_p_TreatExpr5325); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kt_tree = this.adaptor.create(kt);
|
|
this.adaptor.addChild(root_0, kt_tree);
|
|
}
|
|
ka=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_TreatExpr5329); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SequenceType_in_p_TreatExpr5331);
|
|
p_SequenceType236=this.p_SequenceType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SequenceType236.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CastableExpr_return: (function() {
|
|
XQueryParser.p_CastableExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CastableExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:593:1: p_CastableExpr : p_CastExpr (kc= CASTABLE ka= AS p_SingleType )? ;
|
|
// $ANTLR start "p_CastableExpr"
|
|
p_CastableExpr: function() {
|
|
var retval = new XQueryParser.p_CastableExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var ka = null;
|
|
var p_CastExpr237 = null;
|
|
var p_SingleType238 = null;
|
|
|
|
var kc_tree=null;
|
|
var ka_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:594:9: ( p_CastExpr (kc= CASTABLE ka= AS p_SingleType )? )
|
|
// XQueryParser.g:594:13: p_CastExpr (kc= CASTABLE ka= AS p_SingleType )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CastExpr_in_p_CastableExpr5370);
|
|
p_CastExpr237=this.p_CastExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CastExpr237.getTree());
|
|
// XQueryParser.g:594:24: (kc= CASTABLE ka= AS p_SingleType )?
|
|
var alt100=2;
|
|
var LA100_0 = this.input.LA(1);
|
|
|
|
if ( (LA100_0==CASTABLE) ) {
|
|
alt100=1;
|
|
}
|
|
switch (alt100) {
|
|
case 1 :
|
|
// XQueryParser.g:594:26: kc= CASTABLE ka= AS p_SingleType
|
|
kc=this.match(this.input,CASTABLE,XQueryParser.FOLLOW_CASTABLE_in_p_CastableExpr5376); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
ka=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_CastableExpr5380); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SingleType_in_p_CastableExpr5382);
|
|
p_SingleType238=this.p_SingleType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SingleType238.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CastExpr_return: (function() {
|
|
XQueryParser.p_CastExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CastExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:598:1: p_CastExpr : p_UnaryExpr (kc= CAST ka= AS p_SingleType )? ;
|
|
// $ANTLR start "p_CastExpr"
|
|
p_CastExpr: function() {
|
|
var retval = new XQueryParser.p_CastExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var ka = null;
|
|
var p_UnaryExpr239 = null;
|
|
var p_SingleType240 = null;
|
|
|
|
var kc_tree=null;
|
|
var ka_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:599:9: ( p_UnaryExpr (kc= CAST ka= AS p_SingleType )? )
|
|
// XQueryParser.g:599:13: p_UnaryExpr (kc= CAST ka= AS p_SingleType )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_UnaryExpr_in_p_CastExpr5421);
|
|
p_UnaryExpr239=this.p_UnaryExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_UnaryExpr239.getTree());
|
|
// XQueryParser.g:599:25: (kc= CAST ka= AS p_SingleType )?
|
|
var alt101=2;
|
|
var LA101_0 = this.input.LA(1);
|
|
|
|
if ( (LA101_0==CAST) ) {
|
|
alt101=1;
|
|
}
|
|
switch (alt101) {
|
|
case 1 :
|
|
// XQueryParser.g:599:27: kc= CAST ka= AS p_SingleType
|
|
kc=this.match(this.input,CAST,XQueryParser.FOLLOW_CAST_in_p_CastExpr5427); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
ka=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_CastExpr5431); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SingleType_in_p_CastExpr5433);
|
|
p_SingleType240=this.p_SingleType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SingleType240.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_UnaryExpr_return: (function() {
|
|
XQueryParser.p_UnaryExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_UnaryExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:603:1: p_UnaryExpr : ( PLUS | MINUS )* p_ValueExpr -> ^( UnaryExpr ( PLUS )* p_ValueExpr ) ;
|
|
// $ANTLR start "p_UnaryExpr"
|
|
p_UnaryExpr: function() {
|
|
var retval = new XQueryParser.p_UnaryExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var PLUS241 = null;
|
|
var MINUS242 = null;
|
|
var p_ValueExpr243 = null;
|
|
|
|
var PLUS241_tree=null;
|
|
var MINUS242_tree=null;
|
|
var stream_PLUS=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token PLUS");
|
|
var stream_MINUS=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token MINUS");
|
|
var stream_p_ValueExpr=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_ValueExpr");
|
|
try {
|
|
// XQueryParser.g:604:9: ( ( PLUS | MINUS )* p_ValueExpr -> ^( UnaryExpr ( PLUS )* p_ValueExpr ) )
|
|
// XQueryParser.g:604:13: ( PLUS | MINUS )* p_ValueExpr
|
|
// XQueryParser.g:604:13: ( PLUS | MINUS )*
|
|
loop102:
|
|
do {
|
|
var alt102=3;
|
|
var LA102_0 = this.input.LA(1);
|
|
|
|
if ( (LA102_0==PLUS) ) {
|
|
alt102=1;
|
|
}
|
|
else if ( (LA102_0==MINUS) ) {
|
|
alt102=2;
|
|
}
|
|
|
|
|
|
switch (alt102) {
|
|
case 1 :
|
|
// XQueryParser.g:604:14: PLUS
|
|
PLUS241=this.match(this.input,PLUS,XQueryParser.FOLLOW_PLUS_in_p_UnaryExpr5465); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_PLUS.add(PLUS241);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:604:21: MINUS
|
|
MINUS242=this.match(this.input,MINUS,XQueryParser.FOLLOW_MINUS_in_p_UnaryExpr5469); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_MINUS.add(MINUS242);
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop102;
|
|
}
|
|
} while (true);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ValueExpr_in_p_UnaryExpr5473);
|
|
p_ValueExpr243=this.p_ValueExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ValueExpr.add(p_ValueExpr243.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: PLUS, p_ValueExpr
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 605:17: -> ^( UnaryExpr ( PLUS )* p_ValueExpr )
|
|
{
|
|
// XQueryParser.g:605:20: ^( UnaryExpr ( PLUS )* p_ValueExpr )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(UnaryExpr, "UnaryExpr"), root_1);
|
|
|
|
// XQueryParser.g:605:32: ( PLUS )*
|
|
while ( stream_PLUS.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_PLUS.nextNode());
|
|
|
|
}
|
|
stream_PLUS.reset();
|
|
this.adaptor.addChild(root_1, stream_p_ValueExpr.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ValueExpr_return: (function() {
|
|
XQueryParser.p_ValueExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ValueExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:612:1: p_ValueExpr : ( p_ValidateExpr | p_PathExpr | p_ExtensionExpr );
|
|
// $ANTLR start "p_ValueExpr"
|
|
p_ValueExpr: function() {
|
|
var retval = new XQueryParser.p_ValueExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ValidateExpr244 = null;
|
|
var p_PathExpr245 = null;
|
|
var p_ExtensionExpr246 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:613:9: ( p_ValidateExpr | p_PathExpr | p_ExtensionExpr )
|
|
var alt103=3;
|
|
alt103 = this.dfa103.predict(this.input);
|
|
switch (alt103) {
|
|
case 1 :
|
|
// XQueryParser.g:613:11: p_ValidateExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ValidateExpr_in_p_ValueExpr5529);
|
|
p_ValidateExpr244=this.p_ValidateExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ValidateExpr244.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:614:11: p_PathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PathExpr_in_p_ValueExpr5541);
|
|
p_PathExpr245=this.p_PathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PathExpr245.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:615:11: p_ExtensionExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExtensionExpr_in_p_ValueExpr5553);
|
|
p_ExtensionExpr246=this.p_ExtensionExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExtensionExpr246.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_GeneralComp_return: (function() {
|
|
XQueryParser.p_GeneralComp_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_GeneralComp_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:619:1: p_GeneralComp : ( EQUAL | NOTEQUAL | SMALLER | SMALLEREQ | GREATER | GREATEREQ );
|
|
// $ANTLR start "p_GeneralComp"
|
|
p_GeneralComp: function() {
|
|
var retval = new XQueryParser.p_GeneralComp_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set247 = null;
|
|
|
|
var set247_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:620:9: ( EQUAL | NOTEQUAL | SMALLER | SMALLEREQ | GREATER | GREATEREQ )
|
|
// XQueryParser.g:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
set247=this.input.LT(1);
|
|
if ( this.input.LA(1)==EQUAL||this.input.LA(1)==NOTEQUAL||(this.input.LA(1)>=SMALLER && this.input.LA(1)<=GREATEREQ) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set247));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ValueComp_return: (function() {
|
|
XQueryParser.p_ValueComp_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ValueComp_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:624:1: p_ValueComp : (k= EQ | k= NE | k= LT | k= LE | k= GT | k= GE ) ;
|
|
// $ANTLR start "p_ValueComp"
|
|
p_ValueComp: function() {
|
|
var retval = new XQueryParser.p_ValueComp_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:625:9: ( (k= EQ | k= NE | k= LT | k= LE | k= GT | k= GE ) )
|
|
// XQueryParser.g:625:13: (k= EQ | k= NE | k= LT | k= LE | k= GT | k= GE )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:625:13: (k= EQ | k= NE | k= LT | k= LE | k= GT | k= GE )
|
|
var alt104=6;
|
|
switch ( this.input.LA(1) ) {
|
|
case EQ:
|
|
alt104=1;
|
|
break;
|
|
case NE:
|
|
alt104=2;
|
|
break;
|
|
case LT:
|
|
alt104=3;
|
|
break;
|
|
case LE:
|
|
alt104=4;
|
|
break;
|
|
case GT:
|
|
alt104=5;
|
|
break;
|
|
case GE:
|
|
alt104=6;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 104, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt104) {
|
|
case 1 :
|
|
// XQueryParser.g:625:14: k= EQ
|
|
k=this.match(this.input,EQ,XQueryParser.FOLLOW_EQ_in_p_ValueComp5632); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:625:21: k= NE
|
|
k=this.match(this.input,NE,XQueryParser.FOLLOW_NE_in_p_ValueComp5638); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:625:28: k= LT
|
|
k=this.match(this.input,LT,XQueryParser.FOLLOW_LT_in_p_ValueComp5644); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:625:35: k= LE
|
|
k=this.match(this.input,LE,XQueryParser.FOLLOW_LE_in_p_ValueComp5650); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:625:42: k= GT
|
|
k=this.match(this.input,GT,XQueryParser.FOLLOW_GT_in_p_ValueComp5656); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:625:49: k= GE
|
|
k=this.match(this.input,GE,XQueryParser.FOLLOW_GE_in_p_ValueComp5662); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NodeComp_return: (function() {
|
|
XQueryParser.p_NodeComp_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NodeComp_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:629:1: p_NodeComp : (ki= IS | SMALLER_SMALLER | GREATER_GREATER );
|
|
// $ANTLR start "p_NodeComp"
|
|
p_NodeComp: function() {
|
|
var retval = new XQueryParser.p_NodeComp_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ki = null;
|
|
var SMALLER_SMALLER248 = null;
|
|
var GREATER_GREATER249 = null;
|
|
|
|
var ki_tree=null;
|
|
var SMALLER_SMALLER248_tree=null;
|
|
var GREATER_GREATER249_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:630:9: (ki= IS | SMALLER_SMALLER | GREATER_GREATER )
|
|
var alt105=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case IS:
|
|
alt105=1;
|
|
break;
|
|
case SMALLER_SMALLER:
|
|
alt105=2;
|
|
break;
|
|
case GREATER_GREATER:
|
|
alt105=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 105, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt105) {
|
|
case 1 :
|
|
// XQueryParser.g:630:13: ki= IS
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ki=this.match(this.input,IS,XQueryParser.FOLLOW_IS_in_p_NodeComp5694); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ki_tree = this.adaptor.create(ki);
|
|
this.adaptor.addChild(root_0, ki_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:630:21: SMALLER_SMALLER
|
|
root_0 = this.adaptor.nil();
|
|
|
|
SMALLER_SMALLER248=this.match(this.input,SMALLER_SMALLER,XQueryParser.FOLLOW_SMALLER_SMALLER_in_p_NodeComp5698); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SMALLER_SMALLER248_tree = this.adaptor.create(SMALLER_SMALLER248);
|
|
this.adaptor.addChild(root_0, SMALLER_SMALLER248_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:630:39: GREATER_GREATER
|
|
root_0 = this.adaptor.nil();
|
|
|
|
GREATER_GREATER249=this.match(this.input,GREATER_GREATER,XQueryParser.FOLLOW_GREATER_GREATER_in_p_NodeComp5702); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
GREATER_GREATER249_tree = this.adaptor.create(GREATER_GREATER249);
|
|
this.adaptor.addChild(root_0, GREATER_GREATER249_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ValidateExpr_return: (function() {
|
|
XQueryParser.p_ValidateExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ValidateExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:634:1: p_ValidateExpr : kv= VALIDATE ( p_ValidationMode )? LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_ValidateExpr"
|
|
p_ValidateExpr: function() {
|
|
var retval = new XQueryParser.p_ValidateExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kv = null;
|
|
var LBRACKET251 = null;
|
|
var RBRACKET253 = null;
|
|
var p_ValidationMode250 = null;
|
|
var pm_Expr252 = null;
|
|
|
|
var kv_tree=null;
|
|
var LBRACKET251_tree=null;
|
|
var RBRACKET253_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:635:9: (kv= VALIDATE ( p_ValidationMode )? LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:635:13: kv= VALIDATE ( p_ValidationMode )? LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kv=this.match(this.input,VALIDATE,XQueryParser.FOLLOW_VALIDATE_in_p_ValidateExpr5732); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kv_tree = this.adaptor.create(kv);
|
|
this.adaptor.addChild(root_0, kv_tree);
|
|
}
|
|
// XQueryParser.g:635:25: ( p_ValidationMode )?
|
|
var alt106=2;
|
|
var LA106_0 = this.input.LA(1);
|
|
|
|
if ( (LA106_0==AS||LA106_0==LAX||LA106_0==STRICT) ) {
|
|
alt106=1;
|
|
}
|
|
switch (alt106) {
|
|
case 1 :
|
|
// XQueryParser.g:635:25: p_ValidationMode
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ValidationMode_in_p_ValidateExpr5734);
|
|
p_ValidationMode250=this.p_ValidationMode();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ValidationMode250.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LBRACKET251=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_ValidateExpr5737); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET251_tree = this.adaptor.create(LBRACKET251);
|
|
this.adaptor.addChild(root_0, LBRACKET251_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_ValidateExpr5739);
|
|
pm_Expr252=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr252.getTree());
|
|
RBRACKET253=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_ValidateExpr5741); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET253_tree = this.adaptor.create(RBRACKET253);
|
|
this.adaptor.addChild(root_0, RBRACKET253_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ValidationMode_return: (function() {
|
|
XQueryParser.p_ValidationMode_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ValidationMode_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:639:1: p_ValidationMode : (k= LAX | k= STRICT | (k= AS p_QName ) ) ;
|
|
// $ANTLR start "p_ValidationMode"
|
|
p_ValidationMode: function() {
|
|
var retval = new XQueryParser.p_ValidationMode_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var p_QName254 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:640:9: ( (k= LAX | k= STRICT | (k= AS p_QName ) ) )
|
|
// XQueryParser.g:640:13: (k= LAX | k= STRICT | (k= AS p_QName ) )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:640:13: (k= LAX | k= STRICT | (k= AS p_QName ) )
|
|
var alt107=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case LAX:
|
|
alt107=1;
|
|
break;
|
|
case STRICT:
|
|
alt107=2;
|
|
break;
|
|
case AS:
|
|
alt107=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 107, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt107) {
|
|
case 1 :
|
|
// XQueryParser.g:640:14: k= LAX
|
|
k=this.match(this.input,LAX,XQueryParser.FOLLOW_LAX_in_p_ValidationMode5772); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:640:22: k= STRICT
|
|
k=this.match(this.input,STRICT,XQueryParser.FOLLOW_STRICT_in_p_ValidationMode5778); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:640:33: (k= AS p_QName )
|
|
// XQueryParser.g:640:33: (k= AS p_QName )
|
|
// XQueryParser.g:640:34: k= AS p_QName
|
|
k=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_ValidationMode5785); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ValidationMode5787);
|
|
p_QName254=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName254.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ExtensionExpr_return: (function() {
|
|
XQueryParser.p_ExtensionExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ExtensionExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:644:1: p_ExtensionExpr : ( L_Pragma )+ LBRACKET ( pm_Expr )? RBRACKET ;
|
|
// $ANTLR start "p_ExtensionExpr"
|
|
p_ExtensionExpr: function() {
|
|
var retval = new XQueryParser.p_ExtensionExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var L_Pragma255 = null;
|
|
var LBRACKET256 = null;
|
|
var RBRACKET258 = null;
|
|
var pm_Expr257 = null;
|
|
|
|
var L_Pragma255_tree=null;
|
|
var LBRACKET256_tree=null;
|
|
var RBRACKET258_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:645:9: ( ( L_Pragma )+ LBRACKET ( pm_Expr )? RBRACKET )
|
|
// XQueryParser.g:645:13: ( L_Pragma )+ LBRACKET ( pm_Expr )? RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:645:13: ( L_Pragma )+
|
|
var cnt108=0;
|
|
loop108:
|
|
do {
|
|
var alt108=2;
|
|
var LA108_0 = this.input.LA(1);
|
|
|
|
if ( (LA108_0==L_Pragma) ) {
|
|
alt108=1;
|
|
}
|
|
|
|
|
|
switch (alt108) {
|
|
case 1 :
|
|
// XQueryParser.g:645:13: L_Pragma
|
|
L_Pragma255=this.match(this.input,L_Pragma,XQueryParser.FOLLOW_L_Pragma_in_p_ExtensionExpr5818); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
L_Pragma255_tree = this.adaptor.create(L_Pragma255);
|
|
this.adaptor.addChild(root_0, L_Pragma255_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
if ( cnt108 >= 1 ) {
|
|
break loop108;
|
|
}
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var eee = new org.antlr.runtime.EarlyExitException(108, this.input);
|
|
throw eee;
|
|
}
|
|
cnt108++;
|
|
} while (true);
|
|
|
|
LBRACKET256=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_ExtensionExpr5821); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET256_tree = this.adaptor.create(LBRACKET256);
|
|
this.adaptor.addChild(root_0, LBRACKET256_tree);
|
|
}
|
|
// XQueryParser.g:645:32: ( pm_Expr )?
|
|
var alt109=2;
|
|
var LA109_0 = this.input.LA(1);
|
|
|
|
if ( ((LA109_0>=ANCESTOR && LA109_0<=EXIT)||(LA109_0>=SEQUENTIAL && LA109_0<=MAINTAINED)||(LA109_0>=MUTABLE && LA109_0<=LPAREN)||LA109_0==DOLLAR||(LA109_0>=STAR && LA109_0<=SMALLER)||(LA109_0>=SLASH && LA109_0<=DOT_DOT)||LA109_0==ATTR_SIGN||(LA109_0>=APOS && LA109_0<=QUOT)||LA109_0==L_NCName||(LA109_0>=L_Pragma && LA109_0<=L_DoubleLiteral)||(LA109_0>=LETDOLLAR && LA109_0<=EXPLICITLY)) ) {
|
|
alt109=1;
|
|
}
|
|
switch (alt109) {
|
|
case 1 :
|
|
// XQueryParser.g:645:32: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_ExtensionExpr5823);
|
|
pm_Expr257=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr257.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RBRACKET258=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_ExtensionExpr5826); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET258_tree = this.adaptor.create(RBRACKET258);
|
|
this.adaptor.addChild(root_0, RBRACKET258_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PathExpr_return: (function() {
|
|
XQueryParser.p_PathExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PathExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:656:1: p_PathExpr : ( ( SLASH p_RelativePathExpr )=> ( SLASH p_RelativePathExpr ) | SLASH | SLASH_SLASH p_RelativePathExpr | p_RelativePathExpr );
|
|
// $ANTLR start "p_PathExpr"
|
|
p_PathExpr: function() {
|
|
var retval = new XQueryParser.p_PathExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SLASH259 = null;
|
|
var SLASH261 = null;
|
|
var SLASH_SLASH262 = null;
|
|
var p_RelativePathExpr260 = null;
|
|
var p_RelativePathExpr263 = null;
|
|
var p_RelativePathExpr264 = null;
|
|
|
|
var SLASH259_tree=null;
|
|
var SLASH261_tree=null;
|
|
var SLASH_SLASH262_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:657:9: ( ( SLASH p_RelativePathExpr )=> ( SLASH p_RelativePathExpr ) | SLASH | SLASH_SLASH p_RelativePathExpr | p_RelativePathExpr )
|
|
var alt110=4;
|
|
alt110 = this.dfa110.predict(this.input);
|
|
switch (alt110) {
|
|
case 1 :
|
|
// XQueryParser.g:657:11: ( SLASH p_RelativePathExpr )=> ( SLASH p_RelativePathExpr )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:657:41: ( SLASH p_RelativePathExpr )
|
|
// XQueryParser.g:657:42: SLASH p_RelativePathExpr
|
|
SLASH259=this.match(this.input,SLASH,XQueryParser.FOLLOW_SLASH_in_p_PathExpr5868); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SLASH259_tree = this.adaptor.create(SLASH259);
|
|
this.adaptor.addChild(root_0, SLASH259_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RelativePathExpr_in_p_PathExpr5870);
|
|
p_RelativePathExpr260=this.p_RelativePathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_RelativePathExpr260.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:658:11: SLASH
|
|
root_0 = this.adaptor.nil();
|
|
|
|
SLASH261=this.match(this.input,SLASH,XQueryParser.FOLLOW_SLASH_in_p_PathExpr5883); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SLASH261_tree = this.adaptor.create(SLASH261);
|
|
this.adaptor.addChild(root_0, SLASH261_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:659:11: SLASH_SLASH p_RelativePathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
SLASH_SLASH262=this.match(this.input,SLASH_SLASH,XQueryParser.FOLLOW_SLASH_SLASH_in_p_PathExpr5895); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SLASH_SLASH262_tree = this.adaptor.create(SLASH_SLASH262);
|
|
this.adaptor.addChild(root_0, SLASH_SLASH262_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RelativePathExpr_in_p_PathExpr5897);
|
|
p_RelativePathExpr263=this.p_RelativePathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_RelativePathExpr263.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:660:11: p_RelativePathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RelativePathExpr_in_p_PathExpr5909);
|
|
p_RelativePathExpr264=this.p_RelativePathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_RelativePathExpr264.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_RelativePathExpr_return: (function() {
|
|
XQueryParser.p_RelativePathExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_RelativePathExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:664:1: p_RelativePathExpr : p_StepExpr ( ( SLASH | SLASH_SLASH ) p_StepExpr )* ;
|
|
// $ANTLR start "p_RelativePathExpr"
|
|
p_RelativePathExpr: function() {
|
|
var retval = new XQueryParser.p_RelativePathExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set266 = null;
|
|
var p_StepExpr265 = null;
|
|
var p_StepExpr267 = null;
|
|
|
|
var set266_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:665:9: ( p_StepExpr ( ( SLASH | SLASH_SLASH ) p_StepExpr )* )
|
|
// XQueryParser.g:665:11: p_StepExpr ( ( SLASH | SLASH_SLASH ) p_StepExpr )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StepExpr_in_p_RelativePathExpr5937);
|
|
p_StepExpr265=this.p_StepExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StepExpr265.getTree());
|
|
// XQueryParser.g:665:22: ( ( SLASH | SLASH_SLASH ) p_StepExpr )*
|
|
loop111:
|
|
do {
|
|
var alt111=2;
|
|
var LA111_0 = this.input.LA(1);
|
|
|
|
if ( ((LA111_0>=SLASH && LA111_0<=SLASH_SLASH)) ) {
|
|
alt111=1;
|
|
}
|
|
|
|
|
|
switch (alt111) {
|
|
case 1 :
|
|
// XQueryParser.g:665:23: ( SLASH | SLASH_SLASH ) p_StepExpr
|
|
set266=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=SLASH && this.input.LA(1)<=SLASH_SLASH) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set266));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StepExpr_in_p_RelativePathExpr5948);
|
|
p_StepExpr267=this.p_StepExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StepExpr267.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop111;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_StepExpr_return: (function() {
|
|
XQueryParser.p_StepExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_StepExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:669:1: p_StepExpr : ( p_AxisStep | p_FilterExpr );
|
|
// $ANTLR start "p_StepExpr"
|
|
p_StepExpr: function() {
|
|
var retval = new XQueryParser.p_StepExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_AxisStep268 = null;
|
|
var p_FilterExpr269 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:670:9: ( p_AxisStep | p_FilterExpr )
|
|
var alt112=2;
|
|
alt112 = this.dfa112.predict(this.input);
|
|
switch (alt112) {
|
|
case 1 :
|
|
// XQueryParser.g:670:11: p_AxisStep
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AxisStep_in_p_StepExpr5976);
|
|
p_AxisStep268=this.p_AxisStep();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AxisStep268.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:671:11: p_FilterExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_FilterExpr_in_p_StepExpr5988);
|
|
p_FilterExpr269=this.p_FilterExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_FilterExpr269.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AxisStep_return: (function() {
|
|
XQueryParser.p_AxisStep_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AxisStep_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:675:1: p_AxisStep : ( p_ReverseStep | p_ForwardStep ) p_PredicateList ;
|
|
// $ANTLR start "p_AxisStep"
|
|
p_AxisStep: function() {
|
|
var retval = new XQueryParser.p_AxisStep_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ReverseStep270 = null;
|
|
var p_ForwardStep271 = null;
|
|
var p_PredicateList272 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:676:9: ( ( p_ReverseStep | p_ForwardStep ) p_PredicateList )
|
|
// XQueryParser.g:676:11: ( p_ReverseStep | p_ForwardStep ) p_PredicateList
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:676:11: ( p_ReverseStep | p_ForwardStep )
|
|
var alt113=2;
|
|
switch ( this.input.LA(1) ) {
|
|
case PARENT:
|
|
var LA113_1 = this.input.LA(2);
|
|
|
|
if ( (LA113_1==COLON_COLON) ) {
|
|
alt113=1;
|
|
}
|
|
else if ( (LA113_1==EOF||(LA113_1>=AND && LA113_1<=ASCENDING)||(LA113_1>=BY && LA113_1<=CASTABLE)||LA113_1==COLLATION||LA113_1==DEFAULT||(LA113_1>=DESCENDING && LA113_1<=DIV)||(LA113_1>=ELSE && LA113_1<=EMPTY)||LA113_1==EQ||LA113_1==EXCEPT||LA113_1==FOR||LA113_1==GE||(LA113_1>=GT && LA113_1<=IDIV)||(LA113_1>=INSTANCE && LA113_1<=IS)||LA113_1==LE||(LA113_1>=LT && LA113_1<=MOD)||LA113_1==NE||(LA113_1>=OR && LA113_1<=ORDER)||(LA113_1>=RETURN && LA113_1<=SATISFIES)||LA113_1==STABLE||(LA113_1>=TO && LA113_1<=TREAT)||LA113_1==UNION||LA113_1==WHERE||LA113_1==COUNT||(LA113_1>=END && LA113_1<=GROUP)||LA113_1==ONLY||LA113_1==START||(LA113_1>=AFTER && LA113_1<=BEFORE)||LA113_1==INTO||LA113_1==MODIFY||LA113_1==WITH||LA113_1==RPAREN||(LA113_1>=RBRACKET && LA113_1<=EQUAL)||LA113_1==NOTEQUAL||LA113_1==COMMA||(LA113_1>=STAR && LA113_1<=SLASH_SLASH)||LA113_1==COLON||(LA113_1>=SEMICOLON && LA113_1<=VBAR)||LA113_1==LETDOLLAR) ) {
|
|
alt113=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 113, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
break;
|
|
case ANCESTOR:
|
|
var LA113_2 = this.input.LA(2);
|
|
|
|
if ( (LA113_2==COLON_COLON) ) {
|
|
alt113=1;
|
|
}
|
|
else if ( (LA113_2==EOF||(LA113_2>=AND && LA113_2<=ASCENDING)||(LA113_2>=BY && LA113_2<=CASTABLE)||LA113_2==COLLATION||LA113_2==DEFAULT||(LA113_2>=DESCENDING && LA113_2<=DIV)||(LA113_2>=ELSE && LA113_2<=EMPTY)||LA113_2==EQ||LA113_2==EXCEPT||LA113_2==FOR||LA113_2==GE||(LA113_2>=GT && LA113_2<=IDIV)||(LA113_2>=INSTANCE && LA113_2<=IS)||LA113_2==LE||(LA113_2>=LT && LA113_2<=MOD)||LA113_2==NE||(LA113_2>=OR && LA113_2<=ORDER)||(LA113_2>=RETURN && LA113_2<=SATISFIES)||LA113_2==STABLE||(LA113_2>=TO && LA113_2<=TREAT)||LA113_2==UNION||LA113_2==WHERE||LA113_2==COUNT||(LA113_2>=END && LA113_2<=GROUP)||LA113_2==ONLY||LA113_2==START||(LA113_2>=AFTER && LA113_2<=BEFORE)||LA113_2==INTO||LA113_2==MODIFY||LA113_2==WITH||LA113_2==RPAREN||(LA113_2>=RBRACKET && LA113_2<=EQUAL)||LA113_2==NOTEQUAL||LA113_2==COMMA||(LA113_2>=STAR && LA113_2<=SLASH_SLASH)||LA113_2==COLON||(LA113_2>=SEMICOLON && LA113_2<=VBAR)||LA113_2==LETDOLLAR) ) {
|
|
alt113=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 113, 2, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
break;
|
|
case PRECEDING_SIBLING:
|
|
var LA113_3 = this.input.LA(2);
|
|
|
|
if ( (LA113_3==COLON_COLON) ) {
|
|
alt113=1;
|
|
}
|
|
else if ( (LA113_3==EOF||(LA113_3>=AND && LA113_3<=ASCENDING)||(LA113_3>=BY && LA113_3<=CASTABLE)||LA113_3==COLLATION||LA113_3==DEFAULT||(LA113_3>=DESCENDING && LA113_3<=DIV)||(LA113_3>=ELSE && LA113_3<=EMPTY)||LA113_3==EQ||LA113_3==EXCEPT||LA113_3==FOR||LA113_3==GE||(LA113_3>=GT && LA113_3<=IDIV)||(LA113_3>=INSTANCE && LA113_3<=IS)||LA113_3==LE||(LA113_3>=LT && LA113_3<=MOD)||LA113_3==NE||(LA113_3>=OR && LA113_3<=ORDER)||(LA113_3>=RETURN && LA113_3<=SATISFIES)||LA113_3==STABLE||(LA113_3>=TO && LA113_3<=TREAT)||LA113_3==UNION||LA113_3==WHERE||LA113_3==COUNT||(LA113_3>=END && LA113_3<=GROUP)||LA113_3==ONLY||LA113_3==START||(LA113_3>=AFTER && LA113_3<=BEFORE)||LA113_3==INTO||LA113_3==MODIFY||LA113_3==WITH||LA113_3==RPAREN||(LA113_3>=RBRACKET && LA113_3<=EQUAL)||LA113_3==NOTEQUAL||LA113_3==COMMA||(LA113_3>=STAR && LA113_3<=SLASH_SLASH)||LA113_3==COLON||(LA113_3>=SEMICOLON && LA113_3<=VBAR)||LA113_3==LETDOLLAR) ) {
|
|
alt113=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 113, 3, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
break;
|
|
case PRECEDING:
|
|
var LA113_4 = this.input.LA(2);
|
|
|
|
if ( (LA113_4==COLON_COLON) ) {
|
|
alt113=1;
|
|
}
|
|
else if ( (LA113_4==EOF||(LA113_4>=AND && LA113_4<=ASCENDING)||(LA113_4>=BY && LA113_4<=CASTABLE)||LA113_4==COLLATION||LA113_4==DEFAULT||(LA113_4>=DESCENDING && LA113_4<=DIV)||(LA113_4>=ELSE && LA113_4<=EMPTY)||LA113_4==EQ||LA113_4==EXCEPT||LA113_4==FOR||LA113_4==GE||(LA113_4>=GT && LA113_4<=IDIV)||(LA113_4>=INSTANCE && LA113_4<=IS)||LA113_4==LE||(LA113_4>=LT && LA113_4<=MOD)||LA113_4==NE||(LA113_4>=OR && LA113_4<=ORDER)||(LA113_4>=RETURN && LA113_4<=SATISFIES)||LA113_4==STABLE||(LA113_4>=TO && LA113_4<=TREAT)||LA113_4==UNION||LA113_4==WHERE||LA113_4==COUNT||(LA113_4>=END && LA113_4<=GROUP)||LA113_4==ONLY||LA113_4==START||(LA113_4>=AFTER && LA113_4<=BEFORE)||LA113_4==INTO||LA113_4==MODIFY||LA113_4==WITH||LA113_4==RPAREN||(LA113_4>=RBRACKET && LA113_4<=EQUAL)||LA113_4==NOTEQUAL||LA113_4==COMMA||(LA113_4>=STAR && LA113_4<=SLASH_SLASH)||LA113_4==COLON||(LA113_4>=SEMICOLON && LA113_4<=VBAR)||LA113_4==LETDOLLAR) ) {
|
|
alt113=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 113, 4, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
break;
|
|
case ANCESTOR_OR_SELF:
|
|
var LA113_5 = this.input.LA(2);
|
|
|
|
if ( (LA113_5==COLON_COLON) ) {
|
|
alt113=1;
|
|
}
|
|
else if ( (LA113_5==EOF||(LA113_5>=AND && LA113_5<=ASCENDING)||(LA113_5>=BY && LA113_5<=CASTABLE)||LA113_5==COLLATION||LA113_5==DEFAULT||(LA113_5>=DESCENDING && LA113_5<=DIV)||(LA113_5>=ELSE && LA113_5<=EMPTY)||LA113_5==EQ||LA113_5==EXCEPT||LA113_5==FOR||LA113_5==GE||(LA113_5>=GT && LA113_5<=IDIV)||(LA113_5>=INSTANCE && LA113_5<=IS)||LA113_5==LE||(LA113_5>=LT && LA113_5<=MOD)||LA113_5==NE||(LA113_5>=OR && LA113_5<=ORDER)||(LA113_5>=RETURN && LA113_5<=SATISFIES)||LA113_5==STABLE||(LA113_5>=TO && LA113_5<=TREAT)||LA113_5==UNION||LA113_5==WHERE||LA113_5==COUNT||(LA113_5>=END && LA113_5<=GROUP)||LA113_5==ONLY||LA113_5==START||(LA113_5>=AFTER && LA113_5<=BEFORE)||LA113_5==INTO||LA113_5==MODIFY||LA113_5==WITH||LA113_5==RPAREN||(LA113_5>=RBRACKET && LA113_5<=EQUAL)||LA113_5==NOTEQUAL||LA113_5==COMMA||(LA113_5>=STAR && LA113_5<=SLASH_SLASH)||LA113_5==COLON||(LA113_5>=SEMICOLON && LA113_5<=VBAR)||LA113_5==LETDOLLAR) ) {
|
|
alt113=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 113, 5, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
break;
|
|
case DOT_DOT:
|
|
alt113=1;
|
|
break;
|
|
case AND:
|
|
case AS:
|
|
case ASCENDING:
|
|
case AT:
|
|
case ATTRIBUTE:
|
|
case BASE_URI:
|
|
case BOUNDARY_SPACE:
|
|
case BY:
|
|
case CASE:
|
|
case CAST:
|
|
case CASTABLE:
|
|
case CHILD:
|
|
case COLLATION:
|
|
case COMMENT:
|
|
case CONSTRUCTION:
|
|
case COPY_NAMESPACES:
|
|
case DECLARE:
|
|
case DEFAULT:
|
|
case DESCENDANT:
|
|
case DESCENDANT_OR_SELF:
|
|
case DESCENDING:
|
|
case DIV:
|
|
case DOCUMENT:
|
|
case DOCUMENT_NODE:
|
|
case ELEMENT:
|
|
case ELSE:
|
|
case EMPTY:
|
|
case EMPTY_SEQUENCE:
|
|
case ENCODING:
|
|
case EQ:
|
|
case EVERY:
|
|
case EXCEPT:
|
|
case EXTERNAL:
|
|
case FOLLOWING:
|
|
case FOLLOWING_SIBLING:
|
|
case FOR:
|
|
case FUNCTION:
|
|
case GE:
|
|
case GREATEST:
|
|
case GT:
|
|
case IDIV:
|
|
case IF:
|
|
case IMPORT:
|
|
case IN:
|
|
case INHERIT:
|
|
case INSTANCE:
|
|
case INTERSECT:
|
|
case IS:
|
|
case ITEM:
|
|
case LAX:
|
|
case LE:
|
|
case LEAST:
|
|
case LET:
|
|
case LT:
|
|
case MOD:
|
|
case MODULE:
|
|
case NAMESPACE:
|
|
case NE:
|
|
case NO_INHERIT:
|
|
case NO_PRESERVE:
|
|
case NODE:
|
|
case OF:
|
|
case OPTION:
|
|
case OR:
|
|
case ORDER:
|
|
case ORDERED:
|
|
case ORDERING:
|
|
case PRESERVE:
|
|
case PROCESSING_INSTRUCTION:
|
|
case RETURN:
|
|
case SATISFIES:
|
|
case SCHEMA:
|
|
case SCHEMA_ATTRIBUTE:
|
|
case SCHEMA_ELEMENT:
|
|
case SELF:
|
|
case SOME:
|
|
case STABLE:
|
|
case STRICT:
|
|
case STRIP:
|
|
case TEXT:
|
|
case THEN:
|
|
case TO:
|
|
case TREAT:
|
|
case TYPESWITCH:
|
|
case UNION:
|
|
case UNORDERED:
|
|
case VALIDATE:
|
|
case VARIABLE:
|
|
case VERSION:
|
|
case WHERE:
|
|
case XQUERY:
|
|
case CATCH:
|
|
case CONTEXT:
|
|
case COUNT:
|
|
case DECIMAL_FORMAT:
|
|
case DECIMAL_SEPARATOR:
|
|
case DIGIT:
|
|
case END:
|
|
case GROUP:
|
|
case GROUPING_SEPARATOR:
|
|
case INFINITY:
|
|
case MINUS_SIGN:
|
|
case NAMESPACE_NODE:
|
|
case NAN:
|
|
case NEXT:
|
|
case ONLY:
|
|
case OUTER:
|
|
case PATTERN_SEPARATOR:
|
|
case PERCENT:
|
|
case PER_MILLE:
|
|
case PREVIOUS:
|
|
case SLIDING:
|
|
case START:
|
|
case TRY:
|
|
case TUMBLING:
|
|
case WHEN:
|
|
case WINDOW:
|
|
case ZERO_DIGIT:
|
|
case AFTER:
|
|
case BEFORE:
|
|
case COPY:
|
|
case DELETE:
|
|
case FIRST:
|
|
case INSERT:
|
|
case INTO:
|
|
case LAST:
|
|
case MODIFY:
|
|
case NODES:
|
|
case RENAME:
|
|
case REPLACE:
|
|
case REVALIDATION:
|
|
case SKIP:
|
|
case UPDATING:
|
|
case VALUE:
|
|
case WITH:
|
|
case BLOCK:
|
|
case CONSTANT:
|
|
case EXIT:
|
|
case SEQUENTIAL:
|
|
case SET:
|
|
case SIMPLE:
|
|
case WHILE:
|
|
case EVAL:
|
|
case USING:
|
|
case APPEND_ONLY:
|
|
case AUTOMATICALLY:
|
|
case CHECK:
|
|
case COLLECTION:
|
|
case CONSTRAINT:
|
|
case CONST:
|
|
case EQUALITY:
|
|
case FOREACH:
|
|
case FOREIGN:
|
|
case FROM:
|
|
case INDEX:
|
|
case INTEGRITY:
|
|
case KEY:
|
|
case MAINTAINED:
|
|
case MUTABLE:
|
|
case NON:
|
|
case ON:
|
|
case QUEUE:
|
|
case RANGE:
|
|
case READ_ONLY:
|
|
case UNIQUE:
|
|
case BINARY:
|
|
case PRIVATE:
|
|
case AMP_ER:
|
|
case APOS_ER:
|
|
case QUOT_ER:
|
|
case STAR:
|
|
case ATTR_SIGN:
|
|
case L_NCName:
|
|
case EXPLICITLY:
|
|
alt113=2;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 113, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt113) {
|
|
case 1 :
|
|
// XQueryParser.g:676:12: p_ReverseStep
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ReverseStep_in_p_AxisStep6015);
|
|
p_ReverseStep270=this.p_ReverseStep();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ReverseStep270.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:676:28: p_ForwardStep
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ForwardStep_in_p_AxisStep6019);
|
|
p_ForwardStep271=this.p_ForwardStep();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ForwardStep271.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PredicateList_in_p_AxisStep6022);
|
|
p_PredicateList272=this.p_PredicateList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PredicateList272.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ForwardStep_return: (function() {
|
|
XQueryParser.p_ForwardStep_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ForwardStep_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:680:1: p_ForwardStep : ( ( p_ForwardAxis p_NodeTest ) | p_AbbrevForwardStep );
|
|
// $ANTLR start "p_ForwardStep"
|
|
p_ForwardStep: function() {
|
|
var retval = new XQueryParser.p_ForwardStep_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ForwardAxis273 = null;
|
|
var p_NodeTest274 = null;
|
|
var p_AbbrevForwardStep275 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:681:9: ( ( p_ForwardAxis p_NodeTest ) | p_AbbrevForwardStep )
|
|
var alt114=2;
|
|
alt114 = this.dfa114.predict(this.input);
|
|
switch (alt114) {
|
|
case 1 :
|
|
// XQueryParser.g:681:11: ( p_ForwardAxis p_NodeTest )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:681:11: ( p_ForwardAxis p_NodeTest )
|
|
// XQueryParser.g:681:12: p_ForwardAxis p_NodeTest
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ForwardAxis_in_p_ForwardStep6049);
|
|
p_ForwardAxis273=this.p_ForwardAxis();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ForwardAxis273.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NodeTest_in_p_ForwardStep6051);
|
|
p_NodeTest274=this.p_NodeTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NodeTest274.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:681:40: p_AbbrevForwardStep
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AbbrevForwardStep_in_p_ForwardStep6056);
|
|
p_AbbrevForwardStep275=this.p_AbbrevForwardStep();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AbbrevForwardStep275.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ForwardAxis_return: (function() {
|
|
XQueryParser.p_ForwardAxis_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ForwardAxis_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:685:1: p_ForwardAxis : ( CHILD COLON_COLON | DESCENDANT COLON_COLON | ATTRIBUTE COLON_COLON | SELF COLON_COLON | DESCENDANT_OR_SELF COLON_COLON | FOLLOWING_SIBLING COLON_COLON | FOLLOWING COLON_COLON );
|
|
// $ANTLR start "p_ForwardAxis"
|
|
p_ForwardAxis: function() {
|
|
var retval = new XQueryParser.p_ForwardAxis_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var CHILD276 = null;
|
|
var COLON_COLON277 = null;
|
|
var DESCENDANT278 = null;
|
|
var COLON_COLON279 = null;
|
|
var ATTRIBUTE280 = null;
|
|
var COLON_COLON281 = null;
|
|
var SELF282 = null;
|
|
var COLON_COLON283 = null;
|
|
var DESCENDANT_OR_SELF284 = null;
|
|
var COLON_COLON285 = null;
|
|
var FOLLOWING_SIBLING286 = null;
|
|
var COLON_COLON287 = null;
|
|
var FOLLOWING288 = null;
|
|
var COLON_COLON289 = null;
|
|
|
|
var CHILD276_tree=null;
|
|
var COLON_COLON277_tree=null;
|
|
var DESCENDANT278_tree=null;
|
|
var COLON_COLON279_tree=null;
|
|
var ATTRIBUTE280_tree=null;
|
|
var COLON_COLON281_tree=null;
|
|
var SELF282_tree=null;
|
|
var COLON_COLON283_tree=null;
|
|
var DESCENDANT_OR_SELF284_tree=null;
|
|
var COLON_COLON285_tree=null;
|
|
var FOLLOWING_SIBLING286_tree=null;
|
|
var COLON_COLON287_tree=null;
|
|
var FOLLOWING288_tree=null;
|
|
var COLON_COLON289_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:686:9: ( CHILD COLON_COLON | DESCENDANT COLON_COLON | ATTRIBUTE COLON_COLON | SELF COLON_COLON | DESCENDANT_OR_SELF COLON_COLON | FOLLOWING_SIBLING COLON_COLON | FOLLOWING COLON_COLON )
|
|
var alt115=7;
|
|
switch ( this.input.LA(1) ) {
|
|
case CHILD:
|
|
alt115=1;
|
|
break;
|
|
case DESCENDANT:
|
|
alt115=2;
|
|
break;
|
|
case ATTRIBUTE:
|
|
alt115=3;
|
|
break;
|
|
case SELF:
|
|
alt115=4;
|
|
break;
|
|
case DESCENDANT_OR_SELF:
|
|
alt115=5;
|
|
break;
|
|
case FOLLOWING_SIBLING:
|
|
alt115=6;
|
|
break;
|
|
case FOLLOWING:
|
|
alt115=7;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 115, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt115) {
|
|
case 1 :
|
|
// XQueryParser.g:686:11: CHILD COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
CHILD276=this.match(this.input,CHILD,XQueryParser.FOLLOW_CHILD_in_p_ForwardAxis6082); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
CHILD276_tree = this.adaptor.create(CHILD276);
|
|
this.adaptor.addChild(root_0, CHILD276_tree);
|
|
}
|
|
COLON_COLON277=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6084); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON277_tree = this.adaptor.create(COLON_COLON277);
|
|
this.adaptor.addChild(root_0, COLON_COLON277_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:687:11: DESCENDANT COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DESCENDANT278=this.match(this.input,DESCENDANT,XQueryParser.FOLLOW_DESCENDANT_in_p_ForwardAxis6096); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DESCENDANT278_tree = this.adaptor.create(DESCENDANT278);
|
|
this.adaptor.addChild(root_0, DESCENDANT278_tree);
|
|
}
|
|
COLON_COLON279=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6098); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON279_tree = this.adaptor.create(COLON_COLON279);
|
|
this.adaptor.addChild(root_0, COLON_COLON279_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:688:11: ATTRIBUTE COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ATTRIBUTE280=this.match(this.input,ATTRIBUTE,XQueryParser.FOLLOW_ATTRIBUTE_in_p_ForwardAxis6110); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ATTRIBUTE280_tree = this.adaptor.create(ATTRIBUTE280);
|
|
this.adaptor.addChild(root_0, ATTRIBUTE280_tree);
|
|
}
|
|
COLON_COLON281=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6112); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON281_tree = this.adaptor.create(COLON_COLON281);
|
|
this.adaptor.addChild(root_0, COLON_COLON281_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:689:11: SELF COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
SELF282=this.match(this.input,SELF,XQueryParser.FOLLOW_SELF_in_p_ForwardAxis6124); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SELF282_tree = this.adaptor.create(SELF282);
|
|
this.adaptor.addChild(root_0, SELF282_tree);
|
|
}
|
|
COLON_COLON283=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6126); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON283_tree = this.adaptor.create(COLON_COLON283);
|
|
this.adaptor.addChild(root_0, COLON_COLON283_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:690:11: DESCENDANT_OR_SELF COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DESCENDANT_OR_SELF284=this.match(this.input,DESCENDANT_OR_SELF,XQueryParser.FOLLOW_DESCENDANT_OR_SELF_in_p_ForwardAxis6138); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DESCENDANT_OR_SELF284_tree = this.adaptor.create(DESCENDANT_OR_SELF284);
|
|
this.adaptor.addChild(root_0, DESCENDANT_OR_SELF284_tree);
|
|
}
|
|
COLON_COLON285=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6140); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON285_tree = this.adaptor.create(COLON_COLON285);
|
|
this.adaptor.addChild(root_0, COLON_COLON285_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:691:11: FOLLOWING_SIBLING COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
FOLLOWING_SIBLING286=this.match(this.input,FOLLOWING_SIBLING,XQueryParser.FOLLOW_FOLLOWING_SIBLING_in_p_ForwardAxis6152); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
FOLLOWING_SIBLING286_tree = this.adaptor.create(FOLLOWING_SIBLING286);
|
|
this.adaptor.addChild(root_0, FOLLOWING_SIBLING286_tree);
|
|
}
|
|
COLON_COLON287=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6154); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON287_tree = this.adaptor.create(COLON_COLON287);
|
|
this.adaptor.addChild(root_0, COLON_COLON287_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:692:11: FOLLOWING COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
FOLLOWING288=this.match(this.input,FOLLOWING,XQueryParser.FOLLOW_FOLLOWING_in_p_ForwardAxis6166); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
FOLLOWING288_tree = this.adaptor.create(FOLLOWING288);
|
|
this.adaptor.addChild(root_0, FOLLOWING288_tree);
|
|
}
|
|
COLON_COLON289=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ForwardAxis6168); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON289_tree = this.adaptor.create(COLON_COLON289);
|
|
this.adaptor.addChild(root_0, COLON_COLON289_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AbbrevForwardStep_return: (function() {
|
|
XQueryParser.p_AbbrevForwardStep_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AbbrevForwardStep_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:696:1: p_AbbrevForwardStep : ( ATTR_SIGN )? p_NodeTest ;
|
|
// $ANTLR start "p_AbbrevForwardStep"
|
|
p_AbbrevForwardStep: function() {
|
|
var retval = new XQueryParser.p_AbbrevForwardStep_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ATTR_SIGN290 = null;
|
|
var p_NodeTest291 = null;
|
|
|
|
var ATTR_SIGN290_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:697:9: ( ( ATTR_SIGN )? p_NodeTest )
|
|
// XQueryParser.g:697:11: ( ATTR_SIGN )? p_NodeTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:697:11: ( ATTR_SIGN )?
|
|
var alt116=2;
|
|
var LA116_0 = this.input.LA(1);
|
|
|
|
if ( (LA116_0==ATTR_SIGN) ) {
|
|
alt116=1;
|
|
}
|
|
switch (alt116) {
|
|
case 1 :
|
|
// XQueryParser.g:697:11: ATTR_SIGN
|
|
ATTR_SIGN290=this.match(this.input,ATTR_SIGN,XQueryParser.FOLLOW_ATTR_SIGN_in_p_AbbrevForwardStep6194); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ATTR_SIGN290_tree = this.adaptor.create(ATTR_SIGN290);
|
|
this.adaptor.addChild(root_0, ATTR_SIGN290_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NodeTest_in_p_AbbrevForwardStep6197);
|
|
p_NodeTest291=this.p_NodeTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NodeTest291.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ReverseStep_return: (function() {
|
|
XQueryParser.p_ReverseStep_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ReverseStep_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:701:1: p_ReverseStep : ( ( p_ReverseAxis p_NodeTest ) | p_AbbrevReverseStep );
|
|
// $ANTLR start "p_ReverseStep"
|
|
p_ReverseStep: function() {
|
|
var retval = new XQueryParser.p_ReverseStep_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ReverseAxis292 = null;
|
|
var p_NodeTest293 = null;
|
|
var p_AbbrevReverseStep294 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:702:9: ( ( p_ReverseAxis p_NodeTest ) | p_AbbrevReverseStep )
|
|
var alt117=2;
|
|
var LA117_0 = this.input.LA(1);
|
|
|
|
if ( ((LA117_0>=ANCESTOR && LA117_0<=ANCESTOR_OR_SELF)||(LA117_0>=PARENT && LA117_0<=PRECEDING_SIBLING)) ) {
|
|
alt117=1;
|
|
}
|
|
else if ( (LA117_0==DOT_DOT) ) {
|
|
alt117=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 117, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt117) {
|
|
case 1 :
|
|
// XQueryParser.g:702:11: ( p_ReverseAxis p_NodeTest )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:702:11: ( p_ReverseAxis p_NodeTest )
|
|
// XQueryParser.g:702:12: p_ReverseAxis p_NodeTest
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ReverseAxis_in_p_ReverseStep6224);
|
|
p_ReverseAxis292=this.p_ReverseAxis();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ReverseAxis292.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NodeTest_in_p_ReverseStep6226);
|
|
p_NodeTest293=this.p_NodeTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NodeTest293.getTree());
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:702:40: p_AbbrevReverseStep
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AbbrevReverseStep_in_p_ReverseStep6231);
|
|
p_AbbrevReverseStep294=this.p_AbbrevReverseStep();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AbbrevReverseStep294.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ReverseAxis_return: (function() {
|
|
XQueryParser.p_ReverseAxis_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ReverseAxis_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:706:1: p_ReverseAxis : ( PARENT COLON_COLON | ANCESTOR COLON_COLON | PRECEDING_SIBLING COLON_COLON | PRECEDING COLON_COLON | ANCESTOR_OR_SELF COLON_COLON );
|
|
// $ANTLR start "p_ReverseAxis"
|
|
p_ReverseAxis: function() {
|
|
var retval = new XQueryParser.p_ReverseAxis_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var PARENT295 = null;
|
|
var COLON_COLON296 = null;
|
|
var ANCESTOR297 = null;
|
|
var COLON_COLON298 = null;
|
|
var PRECEDING_SIBLING299 = null;
|
|
var COLON_COLON300 = null;
|
|
var PRECEDING301 = null;
|
|
var COLON_COLON302 = null;
|
|
var ANCESTOR_OR_SELF303 = null;
|
|
var COLON_COLON304 = null;
|
|
|
|
var PARENT295_tree=null;
|
|
var COLON_COLON296_tree=null;
|
|
var ANCESTOR297_tree=null;
|
|
var COLON_COLON298_tree=null;
|
|
var PRECEDING_SIBLING299_tree=null;
|
|
var COLON_COLON300_tree=null;
|
|
var PRECEDING301_tree=null;
|
|
var COLON_COLON302_tree=null;
|
|
var ANCESTOR_OR_SELF303_tree=null;
|
|
var COLON_COLON304_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:707:9: ( PARENT COLON_COLON | ANCESTOR COLON_COLON | PRECEDING_SIBLING COLON_COLON | PRECEDING COLON_COLON | ANCESTOR_OR_SELF COLON_COLON )
|
|
var alt118=5;
|
|
switch ( this.input.LA(1) ) {
|
|
case PARENT:
|
|
alt118=1;
|
|
break;
|
|
case ANCESTOR:
|
|
alt118=2;
|
|
break;
|
|
case PRECEDING_SIBLING:
|
|
alt118=3;
|
|
break;
|
|
case PRECEDING:
|
|
alt118=4;
|
|
break;
|
|
case ANCESTOR_OR_SELF:
|
|
alt118=5;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 118, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt118) {
|
|
case 1 :
|
|
// XQueryParser.g:707:11: PARENT COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
PARENT295=this.match(this.input,PARENT,XQueryParser.FOLLOW_PARENT_in_p_ReverseAxis6257); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
PARENT295_tree = this.adaptor.create(PARENT295);
|
|
this.adaptor.addChild(root_0, PARENT295_tree);
|
|
}
|
|
COLON_COLON296=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ReverseAxis6259); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON296_tree = this.adaptor.create(COLON_COLON296);
|
|
this.adaptor.addChild(root_0, COLON_COLON296_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:708:11: ANCESTOR COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ANCESTOR297=this.match(this.input,ANCESTOR,XQueryParser.FOLLOW_ANCESTOR_in_p_ReverseAxis6271); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ANCESTOR297_tree = this.adaptor.create(ANCESTOR297);
|
|
this.adaptor.addChild(root_0, ANCESTOR297_tree);
|
|
}
|
|
COLON_COLON298=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ReverseAxis6273); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON298_tree = this.adaptor.create(COLON_COLON298);
|
|
this.adaptor.addChild(root_0, COLON_COLON298_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:709:11: PRECEDING_SIBLING COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
PRECEDING_SIBLING299=this.match(this.input,PRECEDING_SIBLING,XQueryParser.FOLLOW_PRECEDING_SIBLING_in_p_ReverseAxis6285); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
PRECEDING_SIBLING299_tree = this.adaptor.create(PRECEDING_SIBLING299);
|
|
this.adaptor.addChild(root_0, PRECEDING_SIBLING299_tree);
|
|
}
|
|
COLON_COLON300=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ReverseAxis6287); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON300_tree = this.adaptor.create(COLON_COLON300);
|
|
this.adaptor.addChild(root_0, COLON_COLON300_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:710:11: PRECEDING COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
PRECEDING301=this.match(this.input,PRECEDING,XQueryParser.FOLLOW_PRECEDING_in_p_ReverseAxis6299); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
PRECEDING301_tree = this.adaptor.create(PRECEDING301);
|
|
this.adaptor.addChild(root_0, PRECEDING301_tree);
|
|
}
|
|
COLON_COLON302=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ReverseAxis6301); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON302_tree = this.adaptor.create(COLON_COLON302);
|
|
this.adaptor.addChild(root_0, COLON_COLON302_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:711:11: ANCESTOR_OR_SELF COLON_COLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ANCESTOR_OR_SELF303=this.match(this.input,ANCESTOR_OR_SELF,XQueryParser.FOLLOW_ANCESTOR_OR_SELF_in_p_ReverseAxis6313); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ANCESTOR_OR_SELF303_tree = this.adaptor.create(ANCESTOR_OR_SELF303);
|
|
this.adaptor.addChild(root_0, ANCESTOR_OR_SELF303_tree);
|
|
}
|
|
COLON_COLON304=this.match(this.input,COLON_COLON,XQueryParser.FOLLOW_COLON_COLON_in_p_ReverseAxis6315); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON_COLON304_tree = this.adaptor.create(COLON_COLON304);
|
|
this.adaptor.addChild(root_0, COLON_COLON304_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AbbrevReverseStep_return: (function() {
|
|
XQueryParser.p_AbbrevReverseStep_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AbbrevReverseStep_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:715:1: p_AbbrevReverseStep : DOT_DOT ;
|
|
// $ANTLR start "p_AbbrevReverseStep"
|
|
p_AbbrevReverseStep: function() {
|
|
var retval = new XQueryParser.p_AbbrevReverseStep_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOT_DOT305 = null;
|
|
|
|
var DOT_DOT305_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:716:9: ( DOT_DOT )
|
|
// XQueryParser.g:716:11: DOT_DOT
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DOT_DOT305=this.match(this.input,DOT_DOT,XQueryParser.FOLLOW_DOT_DOT_in_p_AbbrevReverseStep6341); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOT_DOT305_tree = this.adaptor.create(DOT_DOT305);
|
|
this.adaptor.addChild(root_0, DOT_DOT305_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NodeTest_return: (function() {
|
|
XQueryParser.p_NodeTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NodeTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:720:1: p_NodeTest : ( p_KindTest | p_NameTest );
|
|
// $ANTLR start "p_NodeTest"
|
|
p_NodeTest: function() {
|
|
var retval = new XQueryParser.p_NodeTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_KindTest306 = null;
|
|
var p_NameTest307 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:721:9: ( p_KindTest | p_NameTest )
|
|
var alt119=2;
|
|
alt119 = this.dfa119.predict(this.input);
|
|
switch (alt119) {
|
|
case 1 :
|
|
// XQueryParser.g:721:11: p_KindTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_KindTest_in_p_NodeTest6367);
|
|
p_KindTest306=this.p_KindTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_KindTest306.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:721:24: p_NameTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NameTest_in_p_NodeTest6371);
|
|
p_NameTest307=this.p_NameTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NameTest307.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NameTest_return: (function() {
|
|
XQueryParser.p_NameTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NameTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:725:1: p_NameTest : ( p_QName | p_Wildcard );
|
|
// $ANTLR start "p_NameTest"
|
|
p_NameTest: function() {
|
|
var retval = new XQueryParser.p_NameTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName308 = null;
|
|
var p_Wildcard309 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:726:9: ( p_QName | p_Wildcard )
|
|
var alt120=2;
|
|
var LA120_0 = this.input.LA(1);
|
|
|
|
if ( ((LA120_0>=ANCESTOR && LA120_0<=EXIT)||(LA120_0>=SEQUENTIAL && LA120_0<=MAINTAINED)||(LA120_0>=MUTABLE && LA120_0<=QUOT_ER)||LA120_0==L_NCName||LA120_0==EXPLICITLY) ) {
|
|
var LA120_1 = this.input.LA(2);
|
|
|
|
if ( (LA120_1==COLON) ) {
|
|
var LA120_3 = this.input.LA(3);
|
|
|
|
if ( (LA120_3==STAR) ) {
|
|
alt120=2;
|
|
}
|
|
else if ( ((LA120_3>=ANCESTOR && LA120_3<=EXIT)||(LA120_3>=SEQUENTIAL && LA120_3<=MAINTAINED)||(LA120_3>=MUTABLE && LA120_3<=QUOT_ER)||LA120_3==L_NCName||LA120_3==EXPLICITLY) ) {
|
|
alt120=1;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 120, 3, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA120_1==EOF||(LA120_1>=AND && LA120_1<=ASCENDING)||(LA120_1>=BY && LA120_1<=CASTABLE)||LA120_1==COLLATION||LA120_1==DEFAULT||(LA120_1>=DESCENDING && LA120_1<=DIV)||(LA120_1>=ELSE && LA120_1<=EMPTY)||LA120_1==EQ||LA120_1==EXCEPT||LA120_1==FOR||LA120_1==GE||(LA120_1>=GT && LA120_1<=IDIV)||(LA120_1>=INSTANCE && LA120_1<=IS)||LA120_1==LE||(LA120_1>=LT && LA120_1<=MOD)||LA120_1==NE||(LA120_1>=OR && LA120_1<=ORDER)||(LA120_1>=RETURN && LA120_1<=SATISFIES)||LA120_1==STABLE||(LA120_1>=TO && LA120_1<=TREAT)||LA120_1==UNION||LA120_1==WHERE||LA120_1==COUNT||(LA120_1>=END && LA120_1<=GROUP)||LA120_1==ONLY||LA120_1==START||(LA120_1>=AFTER && LA120_1<=BEFORE)||LA120_1==INTO||LA120_1==MODIFY||LA120_1==WITH||(LA120_1>=LPAREN && LA120_1<=RPAREN)||(LA120_1>=LBRACKET && LA120_1<=EQUAL)||LA120_1==NOTEQUAL||LA120_1==COMMA||(LA120_1>=STAR && LA120_1<=SLASH_SLASH)||(LA120_1>=SEMICOLON && LA120_1<=VBAR)||LA120_1==LETDOLLAR) ) {
|
|
alt120=1;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 120, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( (LA120_0==STAR) ) {
|
|
alt120=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 120, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt120) {
|
|
case 1 :
|
|
// XQueryParser.g:726:11: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_NameTest6397);
|
|
p_QName308=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName308.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:726:21: p_Wildcard
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Wildcard_in_p_NameTest6401);
|
|
p_Wildcard309=this.p_Wildcard();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_Wildcard309.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Wildcard_return: (function() {
|
|
XQueryParser.p_Wildcard_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Wildcard_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:730:1: p_Wildcard : ( STAR ( COLON p_NCName )? | ( p_NCName COLON STAR ) );
|
|
// $ANTLR start "p_Wildcard"
|
|
p_Wildcard: function() {
|
|
var retval = new XQueryParser.p_Wildcard_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var STAR310 = null;
|
|
var COLON311 = null;
|
|
var COLON314 = null;
|
|
var STAR315 = null;
|
|
var p_NCName312 = null;
|
|
var p_NCName313 = null;
|
|
|
|
var STAR310_tree=null;
|
|
var COLON311_tree=null;
|
|
var COLON314_tree=null;
|
|
var STAR315_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:731:9: ( STAR ( COLON p_NCName )? | ( p_NCName COLON STAR ) )
|
|
var alt122=2;
|
|
var LA122_0 = this.input.LA(1);
|
|
|
|
if ( (LA122_0==STAR) ) {
|
|
alt122=1;
|
|
}
|
|
else if ( ((LA122_0>=ANCESTOR && LA122_0<=EXIT)||(LA122_0>=SEQUENTIAL && LA122_0<=MAINTAINED)||(LA122_0>=MUTABLE && LA122_0<=QUOT_ER)||LA122_0==L_NCName||LA122_0==EXPLICITLY) ) {
|
|
alt122=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 122, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt122) {
|
|
case 1 :
|
|
// XQueryParser.g:731:11: STAR ( COLON p_NCName )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
STAR310=this.match(this.input,STAR,XQueryParser.FOLLOW_STAR_in_p_Wildcard6427); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
STAR310_tree = this.adaptor.create(STAR310);
|
|
this.adaptor.addChild(root_0, STAR310_tree);
|
|
}
|
|
// XQueryParser.g:731:16: ( COLON p_NCName )?
|
|
var alt121=2;
|
|
var LA121_0 = this.input.LA(1);
|
|
|
|
if ( (LA121_0==COLON) ) {
|
|
alt121=1;
|
|
}
|
|
switch (alt121) {
|
|
case 1 :
|
|
// XQueryParser.g:731:17: COLON p_NCName
|
|
COLON311=this.match(this.input,COLON,XQueryParser.FOLLOW_COLON_in_p_Wildcard6430); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON311_tree = this.adaptor.create(COLON311);
|
|
this.adaptor.addChild(root_0, COLON311_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_Wildcard6432);
|
|
p_NCName312=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName312.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:731:36: ( p_NCName COLON STAR )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:731:36: ( p_NCName COLON STAR )
|
|
// XQueryParser.g:731:37: p_NCName COLON STAR
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_Wildcard6439);
|
|
p_NCName313=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName313.getTree());
|
|
COLON314=this.match(this.input,COLON,XQueryParser.FOLLOW_COLON_in_p_Wildcard6441); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON314_tree = this.adaptor.create(COLON314);
|
|
this.adaptor.addChild(root_0, COLON314_tree);
|
|
}
|
|
STAR315=this.match(this.input,STAR,XQueryParser.FOLLOW_STAR_in_p_Wildcard6443); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
STAR315_tree = this.adaptor.create(STAR315);
|
|
this.adaptor.addChild(root_0, STAR315_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_FilterExpr_return: (function() {
|
|
XQueryParser.p_FilterExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_FilterExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:736:1: p_FilterExpr : p_PrimaryExpr p_PredicateList ;
|
|
// $ANTLR start "p_FilterExpr"
|
|
p_FilterExpr: function() {
|
|
var retval = new XQueryParser.p_FilterExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_PrimaryExpr316 = null;
|
|
var p_PredicateList317 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:737:9: ( p_PrimaryExpr p_PredicateList )
|
|
// XQueryParser.g:737:13: p_PrimaryExpr p_PredicateList
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PrimaryExpr_in_p_FilterExpr6479);
|
|
p_PrimaryExpr316=this.p_PrimaryExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PrimaryExpr316.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PredicateList_in_p_FilterExpr6481);
|
|
p_PredicateList317=this.p_PredicateList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PredicateList317.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PredicateList_return: (function() {
|
|
XQueryParser.p_PredicateList_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PredicateList_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:741:1: p_PredicateList : ( p_Predicate )* ;
|
|
// $ANTLR start "p_PredicateList"
|
|
p_PredicateList: function() {
|
|
var retval = new XQueryParser.p_PredicateList_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_Predicate318 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:742:9: ( ( p_Predicate )* )
|
|
// XQueryParser.g:742:13: ( p_Predicate )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:742:13: ( p_Predicate )*
|
|
loop123:
|
|
do {
|
|
var alt123=2;
|
|
var LA123_0 = this.input.LA(1);
|
|
|
|
if ( (LA123_0==LSQUARE) ) {
|
|
alt123=1;
|
|
}
|
|
|
|
|
|
switch (alt123) {
|
|
case 1 :
|
|
// XQueryParser.g:742:13: p_Predicate
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Predicate_in_p_PredicateList6509);
|
|
p_Predicate318=this.p_Predicate();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_Predicate318.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop123;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Predicate_return: (function() {
|
|
XQueryParser.p_Predicate_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Predicate_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:746:1: p_Predicate : LSQUARE pm_Expr RSQUARE ;
|
|
// $ANTLR start "p_Predicate"
|
|
p_Predicate: function() {
|
|
var retval = new XQueryParser.p_Predicate_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LSQUARE319 = null;
|
|
var RSQUARE321 = null;
|
|
var pm_Expr320 = null;
|
|
|
|
var LSQUARE319_tree=null;
|
|
var RSQUARE321_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:747:9: ( LSQUARE pm_Expr RSQUARE )
|
|
// XQueryParser.g:747:13: LSQUARE pm_Expr RSQUARE
|
|
root_0 = this.adaptor.nil();
|
|
|
|
LSQUARE319=this.match(this.input,LSQUARE,XQueryParser.FOLLOW_LSQUARE_in_p_Predicate6538); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LSQUARE319_tree = this.adaptor.create(LSQUARE319);
|
|
this.adaptor.addChild(root_0, LSQUARE319_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_Predicate6540);
|
|
pm_Expr320=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr320.getTree());
|
|
RSQUARE321=this.match(this.input,RSQUARE,XQueryParser.FOLLOW_RSQUARE_in_p_Predicate6542); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RSQUARE321_tree = this.adaptor.create(RSQUARE321);
|
|
this.adaptor.addChild(root_0, RSQUARE321_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PrimaryExpr_return: (function() {
|
|
XQueryParser.p_PrimaryExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PrimaryExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:751:1: p_PrimaryExpr : ( p_Literal | p_VarRef | p_ParenthesizedExpr | p_ContextItemExpr | p_FunctionCall | p_OrderedExpr | p_UnorderedExpr | p_Constructor );
|
|
// $ANTLR start "p_PrimaryExpr"
|
|
p_PrimaryExpr: function() {
|
|
var retval = new XQueryParser.p_PrimaryExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_Literal322 = null;
|
|
var p_VarRef323 = null;
|
|
var p_ParenthesizedExpr324 = null;
|
|
var p_ContextItemExpr325 = null;
|
|
var p_FunctionCall326 = null;
|
|
var p_OrderedExpr327 = null;
|
|
var p_UnorderedExpr328 = null;
|
|
var p_Constructor329 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:752:9: ( p_Literal | p_VarRef | p_ParenthesizedExpr | p_ContextItemExpr | p_FunctionCall | p_OrderedExpr | p_UnorderedExpr | p_Constructor )
|
|
var alt124=8;
|
|
alt124 = this.dfa124.predict(this.input);
|
|
switch (alt124) {
|
|
case 1 :
|
|
// XQueryParser.g:752:13: p_Literal
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Literal_in_p_PrimaryExpr6570);
|
|
p_Literal322=this.p_Literal();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_Literal322.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:753:11: p_VarRef
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarRef_in_p_PrimaryExpr6582);
|
|
p_VarRef323=this.p_VarRef();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarRef323.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:754:11: p_ParenthesizedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ParenthesizedExpr_in_p_PrimaryExpr6594);
|
|
p_ParenthesizedExpr324=this.p_ParenthesizedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ParenthesizedExpr324.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:755:11: p_ContextItemExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ContextItemExpr_in_p_PrimaryExpr6606);
|
|
p_ContextItemExpr325=this.p_ContextItemExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ContextItemExpr325.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:756:11: p_FunctionCall
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_FunctionCall_in_p_PrimaryExpr6618);
|
|
p_FunctionCall326=this.p_FunctionCall();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_FunctionCall326.getTree());
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:757:11: p_OrderedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OrderedExpr_in_p_PrimaryExpr6630);
|
|
p_OrderedExpr327=this.p_OrderedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OrderedExpr327.getTree());
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:758:11: p_UnorderedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_UnorderedExpr_in_p_PrimaryExpr6642);
|
|
p_UnorderedExpr328=this.p_UnorderedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_UnorderedExpr328.getTree());
|
|
|
|
|
|
break;
|
|
case 8 :
|
|
// XQueryParser.g:759:11: p_Constructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Constructor_in_p_PrimaryExpr6654);
|
|
p_Constructor329=this.p_Constructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_Constructor329.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Literal_return: (function() {
|
|
XQueryParser.p_Literal_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Literal_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:763:1: p_Literal : ( p_NumericLiteral | p_StringLiteral );
|
|
// $ANTLR start "p_Literal"
|
|
p_Literal: function() {
|
|
var retval = new XQueryParser.p_Literal_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_NumericLiteral330 = null;
|
|
var p_StringLiteral331 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:764:9: ( p_NumericLiteral | p_StringLiteral )
|
|
var alt125=2;
|
|
var LA125_0 = this.input.LA(1);
|
|
|
|
if ( ((LA125_0>=L_IntegerLiteral && LA125_0<=L_DoubleLiteral)) ) {
|
|
alt125=1;
|
|
}
|
|
else if ( ((LA125_0>=APOS && LA125_0<=QUOT)) ) {
|
|
alt125=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 125, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt125) {
|
|
case 1 :
|
|
// XQueryParser.g:764:13: p_NumericLiteral
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NumericLiteral_in_p_Literal6682);
|
|
p_NumericLiteral330=this.p_NumericLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NumericLiteral330.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:764:32: p_StringLiteral
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_Literal6686);
|
|
p_StringLiteral331=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral331.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NumericLiteral_return: (function() {
|
|
XQueryParser.p_NumericLiteral_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NumericLiteral_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:768:1: p_NumericLiteral : ( L_IntegerLiteral | L_DecimalLiteral | L_DoubleLiteral );
|
|
// $ANTLR start "p_NumericLiteral"
|
|
p_NumericLiteral: function() {
|
|
var retval = new XQueryParser.p_NumericLiteral_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set332 = null;
|
|
|
|
var set332_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:769:9: ( L_IntegerLiteral | L_DecimalLiteral | L_DoubleLiteral )
|
|
// XQueryParser.g:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
set332=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=L_IntegerLiteral && this.input.LA(1)<=L_DoubleLiteral) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set332));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_VarRef_return: (function() {
|
|
XQueryParser.p_VarRef_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_VarRef_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:773:1: p_VarRef : DOLLAR p_VarName ;
|
|
// $ANTLR start "p_VarRef"
|
|
p_VarRef: function() {
|
|
var retval = new XQueryParser.p_VarRef_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR333 = null;
|
|
var p_VarName334 = null;
|
|
|
|
var DOLLAR333_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:774:9: ( DOLLAR p_VarName )
|
|
// XQueryParser.g:774:13: DOLLAR p_VarName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DOLLAR333=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_VarRef6758); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR333_tree = this.adaptor.create(DOLLAR333);
|
|
this.adaptor.addChild(root_0, DOLLAR333_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_VarRef6760);
|
|
p_VarName334=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName334.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_VarName_return: (function() {
|
|
XQueryParser.p_VarName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_VarName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:778:1: p_VarName : p_QName ;
|
|
// $ANTLR start "p_VarName"
|
|
p_VarName: function() {
|
|
var retval = new XQueryParser.p_VarName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName335 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:779:9: ( p_QName )
|
|
// XQueryParser.g:779:13: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_VarName6788);
|
|
p_QName335=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName335.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ParenthesizedExpr_return: (function() {
|
|
XQueryParser.p_ParenthesizedExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ParenthesizedExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:783:1: p_ParenthesizedExpr : LPAREN ( pm_Expr )? RPAREN ;
|
|
// $ANTLR start "p_ParenthesizedExpr"
|
|
p_ParenthesizedExpr: function() {
|
|
var retval = new XQueryParser.p_ParenthesizedExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LPAREN336 = null;
|
|
var RPAREN338 = null;
|
|
var pm_Expr337 = null;
|
|
|
|
var LPAREN336_tree=null;
|
|
var RPAREN338_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:784:9: ( LPAREN ( pm_Expr )? RPAREN )
|
|
// XQueryParser.g:784:13: LPAREN ( pm_Expr )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
LPAREN336=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_ParenthesizedExpr6816); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN336_tree = this.adaptor.create(LPAREN336);
|
|
this.adaptor.addChild(root_0, LPAREN336_tree);
|
|
}
|
|
// XQueryParser.g:784:20: ( pm_Expr )?
|
|
var alt126=2;
|
|
var LA126_0 = this.input.LA(1);
|
|
|
|
if ( ((LA126_0>=ANCESTOR && LA126_0<=EXIT)||(LA126_0>=SEQUENTIAL && LA126_0<=MAINTAINED)||(LA126_0>=MUTABLE && LA126_0<=LPAREN)||LA126_0==DOLLAR||(LA126_0>=STAR && LA126_0<=SMALLER)||(LA126_0>=SLASH && LA126_0<=DOT_DOT)||LA126_0==ATTR_SIGN||(LA126_0>=APOS && LA126_0<=QUOT)||LA126_0==L_NCName||(LA126_0>=L_Pragma && LA126_0<=L_DoubleLiteral)||(LA126_0>=LETDOLLAR && LA126_0<=EXPLICITLY)) ) {
|
|
alt126=1;
|
|
}
|
|
switch (alt126) {
|
|
case 1 :
|
|
// XQueryParser.g:784:20: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_ParenthesizedExpr6818);
|
|
pm_Expr337=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr337.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN338=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_ParenthesizedExpr6821); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN338_tree = this.adaptor.create(RPAREN338);
|
|
this.adaptor.addChild(root_0, RPAREN338_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ContextItemExpr_return: (function() {
|
|
XQueryParser.p_ContextItemExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ContextItemExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:788:1: p_ContextItemExpr : DOT ;
|
|
// $ANTLR start "p_ContextItemExpr"
|
|
p_ContextItemExpr: function() {
|
|
var retval = new XQueryParser.p_ContextItemExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOT339 = null;
|
|
|
|
var DOT339_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:789:9: ( DOT )
|
|
// XQueryParser.g:789:13: DOT
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DOT339=this.match(this.input,DOT,XQueryParser.FOLLOW_DOT_in_p_ContextItemExpr6849); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOT339_tree = this.adaptor.create(DOT339);
|
|
this.adaptor.addChild(root_0, DOT339_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OrderedExpr_return: (function() {
|
|
XQueryParser.p_OrderedExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OrderedExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:793:1: p_OrderedExpr : k= ORDERED LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_OrderedExpr"
|
|
p_OrderedExpr: function() {
|
|
var retval = new XQueryParser.p_OrderedExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET340 = null;
|
|
var RBRACKET342 = null;
|
|
var pm_Expr341 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET340_tree=null;
|
|
var RBRACKET342_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:794:9: (k= ORDERED LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:794:13: k= ORDERED LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,ORDERED,XQueryParser.FOLLOW_ORDERED_in_p_OrderedExpr6879); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
LBRACKET340=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_OrderedExpr6882); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET340_tree = this.adaptor.create(LBRACKET340);
|
|
this.adaptor.addChild(root_0, LBRACKET340_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_OrderedExpr6884);
|
|
pm_Expr341=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr341.getTree());
|
|
RBRACKET342=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_OrderedExpr6886); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET342_tree = this.adaptor.create(RBRACKET342);
|
|
this.adaptor.addChild(root_0, RBRACKET342_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_UnorderedExpr_return: (function() {
|
|
XQueryParser.p_UnorderedExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_UnorderedExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:798:1: p_UnorderedExpr : k= UNORDERED LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_UnorderedExpr"
|
|
p_UnorderedExpr: function() {
|
|
var retval = new XQueryParser.p_UnorderedExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET343 = null;
|
|
var RBRACKET345 = null;
|
|
var pm_Expr344 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET343_tree=null;
|
|
var RBRACKET345_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:799:9: (k= UNORDERED LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:799:13: k= UNORDERED LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,UNORDERED,XQueryParser.FOLLOW_UNORDERED_in_p_UnorderedExpr6916); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
LBRACKET343=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_UnorderedExpr6919); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET343_tree = this.adaptor.create(LBRACKET343);
|
|
this.adaptor.addChild(root_0, LBRACKET343_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_UnorderedExpr6921);
|
|
pm_Expr344=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr344.getTree());
|
|
RBRACKET345=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_UnorderedExpr6923); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET345_tree = this.adaptor.create(RBRACKET345);
|
|
this.adaptor.addChild(root_0, RBRACKET345_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_FunctionCall_return: (function() {
|
|
XQueryParser.p_FunctionCall_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_FunctionCall_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:804:1: p_FunctionCall : p_FQName LPAREN ( p_ExprSingle ( COMMA p_ExprSingle )* )? RPAREN ;
|
|
// $ANTLR start "p_FunctionCall"
|
|
p_FunctionCall: function() {
|
|
var retval = new XQueryParser.p_FunctionCall_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LPAREN347 = null;
|
|
var COMMA349 = null;
|
|
var RPAREN351 = null;
|
|
var p_FQName346 = null;
|
|
var p_ExprSingle348 = null;
|
|
var p_ExprSingle350 = null;
|
|
|
|
var LPAREN347_tree=null;
|
|
var COMMA349_tree=null;
|
|
var RPAREN351_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:805:9: ( p_FQName LPAREN ( p_ExprSingle ( COMMA p_ExprSingle )* )? RPAREN )
|
|
// XQueryParser.g:805:13: p_FQName LPAREN ( p_ExprSingle ( COMMA p_ExprSingle )* )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_FQName_in_p_FunctionCall6952);
|
|
p_FQName346=this.p_FQName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_FQName346.getTree());
|
|
LPAREN347=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_FunctionCall6954); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN347_tree = this.adaptor.create(LPAREN347);
|
|
this.adaptor.addChild(root_0, LPAREN347_tree);
|
|
}
|
|
// XQueryParser.g:805:29: ( p_ExprSingle ( COMMA p_ExprSingle )* )?
|
|
var alt128=2;
|
|
var LA128_0 = this.input.LA(1);
|
|
|
|
if ( ((LA128_0>=ANCESTOR && LA128_0<=EXIT)||(LA128_0>=SEQUENTIAL && LA128_0<=MAINTAINED)||(LA128_0>=MUTABLE && LA128_0<=LPAREN)||LA128_0==DOLLAR||(LA128_0>=STAR && LA128_0<=SMALLER)||(LA128_0>=SLASH && LA128_0<=DOT_DOT)||LA128_0==ATTR_SIGN||(LA128_0>=APOS && LA128_0<=QUOT)||LA128_0==L_NCName||(LA128_0>=L_Pragma && LA128_0<=L_DoubleLiteral)||(LA128_0>=LETDOLLAR && LA128_0<=EXPLICITLY)) ) {
|
|
alt128=1;
|
|
}
|
|
switch (alt128) {
|
|
case 1 :
|
|
// XQueryParser.g:805:30: p_ExprSingle ( COMMA p_ExprSingle )*
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_FunctionCall6957);
|
|
p_ExprSingle348=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle348.getTree());
|
|
// XQueryParser.g:805:43: ( COMMA p_ExprSingle )*
|
|
loop127:
|
|
do {
|
|
var alt127=2;
|
|
var LA127_0 = this.input.LA(1);
|
|
|
|
if ( (LA127_0==COMMA) ) {
|
|
alt127=1;
|
|
}
|
|
|
|
|
|
switch (alt127) {
|
|
case 1 :
|
|
// XQueryParser.g:805:44: COMMA p_ExprSingle
|
|
COMMA349=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_FunctionCall6960); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA349_tree = this.adaptor.create(COMMA349);
|
|
this.adaptor.addChild(root_0, COMMA349_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_FunctionCall6962);
|
|
p_ExprSingle350=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle350.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop127;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN351=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_FunctionCall6968); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN351_tree = this.adaptor.create(RPAREN351);
|
|
this.adaptor.addChild(root_0, RPAREN351_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Constructor_return: (function() {
|
|
XQueryParser.p_Constructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Constructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:809:1: p_Constructor : ( p_DirectConstructor | p_ComputedConstructor );
|
|
// $ANTLR start "p_Constructor"
|
|
p_Constructor: function() {
|
|
var retval = new XQueryParser.p_Constructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_DirectConstructor352 = null;
|
|
var p_ComputedConstructor353 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:810:9: ( p_DirectConstructor | p_ComputedConstructor )
|
|
var alt129=2;
|
|
var LA129_0 = this.input.LA(1);
|
|
|
|
if ( (LA129_0==SMALLER||(LA129_0>=L_DirCommentConstructor && LA129_0<=L_DirPIConstructor)) ) {
|
|
alt129=1;
|
|
}
|
|
else if ( (LA129_0==ATTRIBUTE||LA129_0==COMMENT||LA129_0==DOCUMENT||LA129_0==ELEMENT||LA129_0==NAMESPACE||LA129_0==PROCESSING_INSTRUCTION||LA129_0==TEXT) ) {
|
|
alt129=2;
|
|
}
|
|
else if ( (LA129_0==BINARY) && ((false))) {
|
|
alt129=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 129, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt129) {
|
|
case 1 :
|
|
// XQueryParser.g:810:13: p_DirectConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DirectConstructor_in_p_Constructor7000);
|
|
p_DirectConstructor352=this.p_DirectConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DirectConstructor352.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:810:35: p_ComputedConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ComputedConstructor_in_p_Constructor7004);
|
|
p_ComputedConstructor353=this.p_ComputedConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ComputedConstructor353.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DirectConstructor_return: (function() {
|
|
XQueryParser.p_DirectConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DirectConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:814:1: p_DirectConstructor : ( p_DirElemConstructor | L_DirCommentConstructor | L_DirPIConstructor );
|
|
// $ANTLR start "p_DirectConstructor"
|
|
p_DirectConstructor: function() {
|
|
var retval = new XQueryParser.p_DirectConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var L_DirCommentConstructor355 = null;
|
|
var L_DirPIConstructor356 = null;
|
|
var p_DirElemConstructor354 = null;
|
|
|
|
var L_DirCommentConstructor355_tree=null;
|
|
var L_DirPIConstructor356_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:815:9: ( p_DirElemConstructor | L_DirCommentConstructor | L_DirPIConstructor )
|
|
var alt130=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case SMALLER:
|
|
alt130=1;
|
|
break;
|
|
case L_DirCommentConstructor:
|
|
alt130=2;
|
|
break;
|
|
case L_DirPIConstructor:
|
|
alt130=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 130, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt130) {
|
|
case 1 :
|
|
// XQueryParser.g:815:13: p_DirElemConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DirElemConstructor_in_p_DirectConstructor7032);
|
|
p_DirElemConstructor354=this.p_DirElemConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DirElemConstructor354.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:816:11: L_DirCommentConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
L_DirCommentConstructor355=this.match(this.input,L_DirCommentConstructor,XQueryParser.FOLLOW_L_DirCommentConstructor_in_p_DirectConstructor7044); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
L_DirCommentConstructor355_tree = this.adaptor.create(L_DirCommentConstructor355);
|
|
this.adaptor.addChild(root_0, L_DirCommentConstructor355_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:817:11: L_DirPIConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
L_DirPIConstructor356=this.match(this.input,L_DirPIConstructor,XQueryParser.FOLLOW_L_DirPIConstructor_in_p_DirectConstructor7056); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
L_DirPIConstructor356_tree = this.adaptor.create(L_DirPIConstructor356);
|
|
this.adaptor.addChild(root_0, L_DirPIConstructor356_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DirElemConstructor_return: (function() {
|
|
XQueryParser.p_DirElemConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DirElemConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:821:1: p_DirElemConstructor : SMALLER p_QName p_DirAttributeList ( EMPTY_CLOSE_TAG | ( GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER ) ) -> ^( DirElemConstructor ^( DirAttributeList ( p_DirAttributeList )* ) ^( DirElemContent ( pm_DirElemContent )* ) ) ;
|
|
// $ANTLR start "p_DirElemConstructor"
|
|
p_DirElemConstructor: function() {
|
|
var retval = new XQueryParser.p_DirElemConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SMALLER357 = null;
|
|
var EMPTY_CLOSE_TAG360 = null;
|
|
var GREATER361 = null;
|
|
var CLOSE_TAG363 = null;
|
|
var S365 = null;
|
|
var GREATER366 = null;
|
|
var p_QName358 = null;
|
|
var p_DirAttributeList359 = null;
|
|
var pm_DirElemContent362 = null;
|
|
var p_QName364 = null;
|
|
|
|
var SMALLER357_tree=null;
|
|
var EMPTY_CLOSE_TAG360_tree=null;
|
|
var GREATER361_tree=null;
|
|
var CLOSE_TAG363_tree=null;
|
|
var S365_tree=null;
|
|
var GREATER366_tree=null;
|
|
var stream_CLOSE_TAG=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token CLOSE_TAG");
|
|
var stream_GREATER=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token GREATER");
|
|
var stream_S=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token S");
|
|
var stream_EMPTY_CLOSE_TAG=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EMPTY_CLOSE_TAG");
|
|
var stream_SMALLER=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SMALLER");
|
|
var stream_p_DirAttributeList=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_DirAttributeList");
|
|
var stream_pm_DirElemContent=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_DirElemContent");
|
|
var stream_p_QName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QName");
|
|
try {
|
|
// XQueryParser.g:822:9: ( SMALLER p_QName p_DirAttributeList ( EMPTY_CLOSE_TAG | ( GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER ) ) -> ^( DirElemConstructor ^( DirAttributeList ( p_DirAttributeList )* ) ^( DirElemContent ( pm_DirElemContent )* ) ) )
|
|
// XQueryParser.g:822:13: SMALLER p_QName p_DirAttributeList ( EMPTY_CLOSE_TAG | ( GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER ) )
|
|
SMALLER357=this.match(this.input,SMALLER,XQueryParser.FOLLOW_SMALLER_in_p_DirElemConstructor7084); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SMALLER.add(SMALLER357);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_DirElemConstructor7100);
|
|
p_QName358=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(p_QName358.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DirAttributeList_in_p_DirElemConstructor7102);
|
|
p_DirAttributeList359=this.p_DirAttributeList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_DirAttributeList.add(p_DirAttributeList359.getTree());
|
|
// XQueryParser.g:824:13: ( EMPTY_CLOSE_TAG | ( GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER ) )
|
|
var alt133=2;
|
|
var LA133_0 = this.input.LA(1);
|
|
|
|
if ( (LA133_0==EMPTY_CLOSE_TAG) ) {
|
|
alt133=1;
|
|
}
|
|
else if ( (LA133_0==GREATER) ) {
|
|
alt133=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 133, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt133) {
|
|
case 1 :
|
|
// XQueryParser.g:824:14: EMPTY_CLOSE_TAG
|
|
EMPTY_CLOSE_TAG360=this.match(this.input,EMPTY_CLOSE_TAG,XQueryParser.FOLLOW_EMPTY_CLOSE_TAG_in_p_DirElemConstructor7118); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EMPTY_CLOSE_TAG.add(EMPTY_CLOSE_TAG360);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:824:32: ( GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER )
|
|
// XQueryParser.g:824:32: ( GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER )
|
|
// XQueryParser.g:824:33: GREATER ( pm_DirElemContent )* CLOSE_TAG p_QName ( S )? GREATER
|
|
GREATER361=this.match(this.input,GREATER,XQueryParser.FOLLOW_GREATER_in_p_DirElemConstructor7123); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_GREATER.add(GREATER361);
|
|
|
|
// XQueryParser.g:824:41: ( pm_DirElemContent )*
|
|
loop131:
|
|
do {
|
|
var alt131=2;
|
|
var LA131_0 = this.input.LA(1);
|
|
|
|
if ( ((LA131_0>=L_ElementContentChar && LA131_0<=ESCAPE_RBRACKET)||LA131_0==LBRACKET||LA131_0==SMALLER||(LA131_0>=L_DirCommentConstructor && LA131_0<=L_DirPIConstructor)) ) {
|
|
alt131=1;
|
|
}
|
|
|
|
|
|
switch (alt131) {
|
|
case 1 :
|
|
// XQueryParser.g:824:41: pm_DirElemContent
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_DirElemContent_in_p_DirElemConstructor7125);
|
|
pm_DirElemContent362=this.pm_DirElemContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_DirElemContent.add(pm_DirElemContent362.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop131;
|
|
}
|
|
} while (true);
|
|
|
|
CLOSE_TAG363=this.match(this.input,CLOSE_TAG,XQueryParser.FOLLOW_CLOSE_TAG_in_p_DirElemConstructor7128); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_CLOSE_TAG.add(CLOSE_TAG363);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_DirElemConstructor7130);
|
|
p_QName364=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(p_QName364.getTree());
|
|
// XQueryParser.g:824:78: ( S )?
|
|
var alt132=2;
|
|
var LA132_0 = this.input.LA(1);
|
|
|
|
if ( (LA132_0==S) ) {
|
|
alt132=1;
|
|
}
|
|
switch (alt132) {
|
|
case 1 :
|
|
// XQueryParser.g:824:78: S
|
|
S365=this.match(this.input,S,XQueryParser.FOLLOW_S_in_p_DirElemConstructor7132); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_S.add(S365);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
GREATER366=this.match(this.input,GREATER,XQueryParser.FOLLOW_GREATER_in_p_DirElemConstructor7135); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_GREATER.add(GREATER366);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_DirAttributeList, pm_DirElemContent
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 825:17: -> ^( DirElemConstructor ^( DirAttributeList ( p_DirAttributeList )* ) ^( DirElemContent ( pm_DirElemContent )* ) )
|
|
{
|
|
// XQueryParser.g:825:20: ^( DirElemConstructor ^( DirAttributeList ( p_DirAttributeList )* ) ^( DirElemContent ( pm_DirElemContent )* ) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(DirElemConstructor, "DirElemConstructor"), root_1);
|
|
|
|
// XQueryParser.g:825:41: ^( DirAttributeList ( p_DirAttributeList )* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(DirAttributeList, "DirAttributeList"), root_2);
|
|
|
|
// XQueryParser.g:825:60: ( p_DirAttributeList )*
|
|
while ( stream_p_DirAttributeList.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_p_DirAttributeList.nextTree());
|
|
|
|
}
|
|
stream_p_DirAttributeList.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
// XQueryParser.g:825:81: ^( DirElemContent ( pm_DirElemContent )* )
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(DirElemContent, "DirElemContent"), root_2);
|
|
|
|
// XQueryParser.g:825:98: ( pm_DirElemContent )*
|
|
while ( stream_pm_DirElemContent.hasNext() ) {
|
|
this.adaptor.addChild(root_2, stream_pm_DirElemContent.nextTree());
|
|
|
|
}
|
|
stream_pm_DirElemContent.reset();
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DirAttributeList_return: (function() {
|
|
XQueryParser.p_DirAttributeList_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DirAttributeList_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:830:1: p_DirAttributeList : ( S ( p_QName ( S )? EQUAL ( S )? p_DirAttributeValue )? )* ;
|
|
// $ANTLR start "p_DirAttributeList"
|
|
p_DirAttributeList: function() {
|
|
var retval = new XQueryParser.p_DirAttributeList_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var S367 = null;
|
|
var S369 = null;
|
|
var EQUAL370 = null;
|
|
var S371 = null;
|
|
var p_QName368 = null;
|
|
var p_DirAttributeValue372 = null;
|
|
|
|
var S367_tree=null;
|
|
var S369_tree=null;
|
|
var EQUAL370_tree=null;
|
|
var S371_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:831:9: ( ( S ( p_QName ( S )? EQUAL ( S )? p_DirAttributeValue )? )* )
|
|
// XQueryParser.g:831:11: ( S ( p_QName ( S )? EQUAL ( S )? p_DirAttributeValue )? )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:831:11: ( S ( p_QName ( S )? EQUAL ( S )? p_DirAttributeValue )? )*
|
|
loop137:
|
|
do {
|
|
var alt137=2;
|
|
var LA137_0 = this.input.LA(1);
|
|
|
|
if ( (LA137_0==S) ) {
|
|
alt137=1;
|
|
}
|
|
|
|
|
|
switch (alt137) {
|
|
case 1 :
|
|
// XQueryParser.g:831:12: S ( p_QName ( S )? EQUAL ( S )? p_DirAttributeValue )?
|
|
S367=this.match(this.input,S,XQueryParser.FOLLOW_S_in_p_DirAttributeList7212); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
S367_tree = this.adaptor.create(S367);
|
|
this.adaptor.addChild(root_0, S367_tree);
|
|
}
|
|
// XQueryParser.g:831:14: ( p_QName ( S )? EQUAL ( S )? p_DirAttributeValue )?
|
|
var alt136=2;
|
|
var LA136_0 = this.input.LA(1);
|
|
|
|
if ( ((LA136_0>=ANCESTOR && LA136_0<=EXIT)||(LA136_0>=SEQUENTIAL && LA136_0<=MAINTAINED)||(LA136_0>=MUTABLE && LA136_0<=QUOT_ER)||LA136_0==L_NCName||LA136_0==EXPLICITLY) ) {
|
|
alt136=1;
|
|
}
|
|
switch (alt136) {
|
|
case 1 :
|
|
// XQueryParser.g:831:15: p_QName ( S )? EQUAL ( S )? p_DirAttributeValue
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_DirAttributeList7215);
|
|
p_QName368=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName368.getTree());
|
|
// XQueryParser.g:831:23: ( S )?
|
|
var alt134=2;
|
|
var LA134_0 = this.input.LA(1);
|
|
|
|
if ( (LA134_0==S) ) {
|
|
alt134=1;
|
|
}
|
|
switch (alt134) {
|
|
case 1 :
|
|
// XQueryParser.g:831:23: S
|
|
S369=this.match(this.input,S,XQueryParser.FOLLOW_S_in_p_DirAttributeList7217); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
S369_tree = this.adaptor.create(S369);
|
|
this.adaptor.addChild(root_0, S369_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
EQUAL370=this.match(this.input,EQUAL,XQueryParser.FOLLOW_EQUAL_in_p_DirAttributeList7220); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
EQUAL370_tree = this.adaptor.create(EQUAL370);
|
|
this.adaptor.addChild(root_0, EQUAL370_tree);
|
|
}
|
|
// XQueryParser.g:831:32: ( S )?
|
|
var alt135=2;
|
|
var LA135_0 = this.input.LA(1);
|
|
|
|
if ( (LA135_0==S) ) {
|
|
alt135=1;
|
|
}
|
|
switch (alt135) {
|
|
case 1 :
|
|
// XQueryParser.g:831:32: S
|
|
S371=this.match(this.input,S,XQueryParser.FOLLOW_S_in_p_DirAttributeList7222); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
S371_tree = this.adaptor.create(S371);
|
|
this.adaptor.addChild(root_0, S371_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DirAttributeValue_in_p_DirAttributeList7225);
|
|
p_DirAttributeValue372=this.p_DirAttributeValue();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DirAttributeValue372.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop137;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DirAttributeValue_return: (function() {
|
|
XQueryParser.p_DirAttributeValue_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DirAttributeValue_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:835:1: p_DirAttributeValue : ( ( QUOT ( ESCAPE_QUOT | pm_QuotAttrValueContent )* QUOT ) -> ^( DirAttributeValue ( pm_QuotAttrValueContent )* ) | ( APOS ( ESCAPE_APOS | pm_AposAttrValueContent )* APOS ) -> ^( DirAttributeValue ( pm_AposAttrValueContent )* ) );
|
|
// $ANTLR start "p_DirAttributeValue"
|
|
p_DirAttributeValue: function() {
|
|
var retval = new XQueryParser.p_DirAttributeValue_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var QUOT373 = null;
|
|
var ESCAPE_QUOT374 = null;
|
|
var QUOT376 = null;
|
|
var APOS377 = null;
|
|
var ESCAPE_APOS378 = null;
|
|
var APOS380 = null;
|
|
var pm_QuotAttrValueContent375 = null;
|
|
var pm_AposAttrValueContent379 = null;
|
|
|
|
var QUOT373_tree=null;
|
|
var ESCAPE_QUOT374_tree=null;
|
|
var QUOT376_tree=null;
|
|
var APOS377_tree=null;
|
|
var ESCAPE_APOS378_tree=null;
|
|
var APOS380_tree=null;
|
|
var stream_ESCAPE_QUOT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token ESCAPE_QUOT");
|
|
var stream_APOS=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token APOS");
|
|
var stream_ESCAPE_APOS=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token ESCAPE_APOS");
|
|
var stream_QUOT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token QUOT");
|
|
var stream_pm_QuotAttrValueContent=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_QuotAttrValueContent");
|
|
var stream_pm_AposAttrValueContent=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_AposAttrValueContent");
|
|
try {
|
|
// XQueryParser.g:836:9: ( ( QUOT ( ESCAPE_QUOT | pm_QuotAttrValueContent )* QUOT ) -> ^( DirAttributeValue ( pm_QuotAttrValueContent )* ) | ( APOS ( ESCAPE_APOS | pm_AposAttrValueContent )* APOS ) -> ^( DirAttributeValue ( pm_AposAttrValueContent )* ) )
|
|
var alt140=2;
|
|
var LA140_0 = this.input.LA(1);
|
|
|
|
if ( (LA140_0==QUOT) ) {
|
|
alt140=1;
|
|
}
|
|
else if ( (LA140_0==APOS) ) {
|
|
alt140=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 140, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt140) {
|
|
case 1 :
|
|
// XQueryParser.g:836:11: ( QUOT ( ESCAPE_QUOT | pm_QuotAttrValueContent )* QUOT )
|
|
// XQueryParser.g:836:11: ( QUOT ( ESCAPE_QUOT | pm_QuotAttrValueContent )* QUOT )
|
|
// XQueryParser.g:836:12: QUOT ( ESCAPE_QUOT | pm_QuotAttrValueContent )* QUOT
|
|
QUOT373=this.match(this.input,QUOT,XQueryParser.FOLLOW_QUOT_in_p_DirAttributeValue7256); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_QUOT.add(QUOT373);
|
|
|
|
// XQueryParser.g:836:17: ( ESCAPE_QUOT | pm_QuotAttrValueContent )*
|
|
loop138:
|
|
do {
|
|
var alt138=3;
|
|
var LA138_0 = this.input.LA(1);
|
|
|
|
if ( (LA138_0==ESCAPE_QUOT) ) {
|
|
alt138=1;
|
|
}
|
|
else if ( (LA138_0==L_QuotAttrContentChar||(LA138_0>=L_PredefinedEntityRef && LA138_0<=ESCAPE_RBRACKET)||LA138_0==LBRACKET) ) {
|
|
alt138=2;
|
|
}
|
|
|
|
|
|
switch (alt138) {
|
|
case 1 :
|
|
// XQueryParser.g:836:18: ESCAPE_QUOT
|
|
ESCAPE_QUOT374=this.match(this.input,ESCAPE_QUOT,XQueryParser.FOLLOW_ESCAPE_QUOT_in_p_DirAttributeValue7259); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_ESCAPE_QUOT.add(ESCAPE_QUOT374);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:836:32: pm_QuotAttrValueContent
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_QuotAttrValueContent_in_p_DirAttributeValue7263);
|
|
pm_QuotAttrValueContent375=this.pm_QuotAttrValueContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_QuotAttrValueContent.add(pm_QuotAttrValueContent375.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop138;
|
|
}
|
|
} while (true);
|
|
|
|
QUOT376=this.match(this.input,QUOT,XQueryParser.FOLLOW_QUOT_in_p_DirAttributeValue7267); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_QUOT.add(QUOT376);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: pm_QuotAttrValueContent
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 837:17: -> ^( DirAttributeValue ( pm_QuotAttrValueContent )* )
|
|
{
|
|
// XQueryParser.g:837:20: ^( DirAttributeValue ( pm_QuotAttrValueContent )* )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(DirAttributeValue, "DirAttributeValue"), root_1);
|
|
|
|
// XQueryParser.g:837:40: ( pm_QuotAttrValueContent )*
|
|
while ( stream_pm_QuotAttrValueContent.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_pm_QuotAttrValueContent.nextTree());
|
|
|
|
}
|
|
stream_pm_QuotAttrValueContent.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:838:11: ( APOS ( ESCAPE_APOS | pm_AposAttrValueContent )* APOS )
|
|
// XQueryParser.g:838:11: ( APOS ( ESCAPE_APOS | pm_AposAttrValueContent )* APOS )
|
|
// XQueryParser.g:838:12: APOS ( ESCAPE_APOS | pm_AposAttrValueContent )* APOS
|
|
APOS377=this.match(this.input,APOS,XQueryParser.FOLLOW_APOS_in_p_DirAttributeValue7306); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_APOS.add(APOS377);
|
|
|
|
// XQueryParser.g:838:17: ( ESCAPE_APOS | pm_AposAttrValueContent )*
|
|
loop139:
|
|
do {
|
|
var alt139=3;
|
|
var LA139_0 = this.input.LA(1);
|
|
|
|
if ( (LA139_0==ESCAPE_APOS) ) {
|
|
alt139=1;
|
|
}
|
|
else if ( (LA139_0==L_AposAttrContentChar||(LA139_0>=L_PredefinedEntityRef && LA139_0<=ESCAPE_RBRACKET)||LA139_0==LBRACKET) ) {
|
|
alt139=2;
|
|
}
|
|
|
|
|
|
switch (alt139) {
|
|
case 1 :
|
|
// XQueryParser.g:838:18: ESCAPE_APOS
|
|
ESCAPE_APOS378=this.match(this.input,ESCAPE_APOS,XQueryParser.FOLLOW_ESCAPE_APOS_in_p_DirAttributeValue7309); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_ESCAPE_APOS.add(ESCAPE_APOS378);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:838:32: pm_AposAttrValueContent
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_AposAttrValueContent_in_p_DirAttributeValue7313);
|
|
pm_AposAttrValueContent379=this.pm_AposAttrValueContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_AposAttrValueContent.add(pm_AposAttrValueContent379.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop139;
|
|
}
|
|
} while (true);
|
|
|
|
APOS380=this.match(this.input,APOS,XQueryParser.FOLLOW_APOS_in_p_DirAttributeValue7317); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_APOS.add(APOS380);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: pm_AposAttrValueContent
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 839:17: -> ^( DirAttributeValue ( pm_AposAttrValueContent )* )
|
|
{
|
|
// XQueryParser.g:839:20: ^( DirAttributeValue ( pm_AposAttrValueContent )* )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(DirAttributeValue, "DirAttributeValue"), root_1);
|
|
|
|
// XQueryParser.g:839:40: ( pm_AposAttrValueContent )*
|
|
while ( stream_pm_AposAttrValueContent.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_pm_AposAttrValueContent.nextTree());
|
|
|
|
}
|
|
stream_pm_AposAttrValueContent.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_QuotAttrValueContent_return: (function() {
|
|
XQueryParser.pm_QuotAttrValueContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_QuotAttrValueContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:843:1: pm_QuotAttrValueContent : ( pg_QuotAttrContentChar | pg_CommonContent | p_ElemEnclosedExpr );
|
|
// $ANTLR start "pm_QuotAttrValueContent"
|
|
pm_QuotAttrValueContent: function() {
|
|
var retval = new XQueryParser.pm_QuotAttrValueContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pg_QuotAttrContentChar381 = null;
|
|
var pg_CommonContent382 = null;
|
|
var p_ElemEnclosedExpr383 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:844:9: ( pg_QuotAttrContentChar | pg_CommonContent | p_ElemEnclosedExpr )
|
|
var alt141=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case L_QuotAttrContentChar:
|
|
alt141=1;
|
|
break;
|
|
case L_PredefinedEntityRef:
|
|
case L_CharRef:
|
|
case ESCAPE_LBRACKET:
|
|
case ESCAPE_RBRACKET:
|
|
alt141=2;
|
|
break;
|
|
case LBRACKET:
|
|
alt141=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 141, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt141) {
|
|
case 1 :
|
|
// XQueryParser.g:844:11: pg_QuotAttrContentChar
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_QuotAttrContentChar_in_pm_QuotAttrValueContent7369);
|
|
pg_QuotAttrContentChar381=this.pg_QuotAttrContentChar();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pg_QuotAttrContentChar381.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:844:36: pg_CommonContent
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_CommonContent_in_pm_QuotAttrValueContent7373);
|
|
pg_CommonContent382=this.pg_CommonContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pg_CommonContent382.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:844:55: p_ElemEnclosedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElemEnclosedExpr_in_pm_QuotAttrValueContent7377);
|
|
p_ElemEnclosedExpr383=this.p_ElemEnclosedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElemEnclosedExpr383.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pg_QuotAttrContentChar_return: (function() {
|
|
XQueryParser.pg_QuotAttrContentChar_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pg_QuotAttrContentChar_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:851:1: pg_QuotAttrContentChar : L_QuotAttrContentChar -> ^( AttributeValueChar L_QuotAttrContentChar ) ;
|
|
// $ANTLR start "pg_QuotAttrContentChar"
|
|
pg_QuotAttrContentChar: function() {
|
|
var retval = new XQueryParser.pg_QuotAttrContentChar_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var L_QuotAttrContentChar384 = null;
|
|
|
|
var L_QuotAttrContentChar384_tree=null;
|
|
var stream_L_QuotAttrContentChar=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token L_QuotAttrContentChar");
|
|
|
|
try {
|
|
// XQueryParser.g:852:9: ( L_QuotAttrContentChar -> ^( AttributeValueChar L_QuotAttrContentChar ) )
|
|
// XQueryParser.g:852:11: L_QuotAttrContentChar
|
|
L_QuotAttrContentChar384=this.match(this.input,L_QuotAttrContentChar,XQueryParser.FOLLOW_L_QuotAttrContentChar_in_pg_QuotAttrContentChar7406); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_L_QuotAttrContentChar.add(L_QuotAttrContentChar384);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: L_QuotAttrContentChar
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 853:17: -> ^( AttributeValueChar L_QuotAttrContentChar )
|
|
{
|
|
// XQueryParser.g:853:20: ^( AttributeValueChar L_QuotAttrContentChar )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(AttributeValueChar, "AttributeValueChar"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_L_QuotAttrContentChar.nextNode());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_AposAttrValueContent_return: (function() {
|
|
XQueryParser.pm_AposAttrValueContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_AposAttrValueContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:858:1: pm_AposAttrValueContent : ( pg_AposAttrContentChar | pg_CommonContent | p_ElemEnclosedExpr );
|
|
// $ANTLR start "pm_AposAttrValueContent"
|
|
pm_AposAttrValueContent: function() {
|
|
var retval = new XQueryParser.pm_AposAttrValueContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pg_AposAttrContentChar385 = null;
|
|
var pg_CommonContent386 = null;
|
|
var p_ElemEnclosedExpr387 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:859:9: ( pg_AposAttrContentChar | pg_CommonContent | p_ElemEnclosedExpr )
|
|
var alt142=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case L_AposAttrContentChar:
|
|
alt142=1;
|
|
break;
|
|
case L_PredefinedEntityRef:
|
|
case L_CharRef:
|
|
case ESCAPE_LBRACKET:
|
|
case ESCAPE_RBRACKET:
|
|
alt142=2;
|
|
break;
|
|
case LBRACKET:
|
|
alt142=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 142, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt142) {
|
|
case 1 :
|
|
// XQueryParser.g:859:13: pg_AposAttrContentChar
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_AposAttrContentChar_in_pm_AposAttrValueContent7459);
|
|
pg_AposAttrContentChar385=this.pg_AposAttrContentChar();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pg_AposAttrContentChar385.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:859:38: pg_CommonContent
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_CommonContent_in_pm_AposAttrValueContent7463);
|
|
pg_CommonContent386=this.pg_CommonContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pg_CommonContent386.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:859:57: p_ElemEnclosedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElemEnclosedExpr_in_pm_AposAttrValueContent7467);
|
|
p_ElemEnclosedExpr387=this.p_ElemEnclosedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElemEnclosedExpr387.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pg_AposAttrContentChar_return: (function() {
|
|
XQueryParser.pg_AposAttrContentChar_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pg_AposAttrContentChar_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:866:1: pg_AposAttrContentChar : L_AposAttrContentChar -> ^( AttributeValueChar L_AposAttrContentChar ) ;
|
|
// $ANTLR start "pg_AposAttrContentChar"
|
|
pg_AposAttrContentChar: function() {
|
|
var retval = new XQueryParser.pg_AposAttrContentChar_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var L_AposAttrContentChar388 = null;
|
|
|
|
var L_AposAttrContentChar388_tree=null;
|
|
var stream_L_AposAttrContentChar=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token L_AposAttrContentChar");
|
|
|
|
try {
|
|
// XQueryParser.g:867:9: ( L_AposAttrContentChar -> ^( AttributeValueChar L_AposAttrContentChar ) )
|
|
// XQueryParser.g:867:11: L_AposAttrContentChar
|
|
L_AposAttrContentChar388=this.match(this.input,L_AposAttrContentChar,XQueryParser.FOLLOW_L_AposAttrContentChar_in_pg_AposAttrContentChar7496); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_L_AposAttrContentChar.add(L_AposAttrContentChar388);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: L_AposAttrContentChar
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 868:17: -> ^( AttributeValueChar L_AposAttrContentChar )
|
|
{
|
|
// XQueryParser.g:868:20: ^( AttributeValueChar L_AposAttrContentChar )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(AttributeValueChar, "AttributeValueChar"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_L_AposAttrContentChar.nextNode());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_DirElemContent_return: (function() {
|
|
XQueryParser.pm_DirElemContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_DirElemContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:873:1: pm_DirElemContent : ( p_DirectConstructor | L_CDataSection | p_ElemEnclosedExpr | pg_CommonContent | pg_ElementContentChar );
|
|
// $ANTLR start "pm_DirElemContent"
|
|
pm_DirElemContent: function() {
|
|
var retval = new XQueryParser.pm_DirElemContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var L_CDataSection390 = null;
|
|
var p_DirectConstructor389 = null;
|
|
var p_ElemEnclosedExpr391 = null;
|
|
var pg_CommonContent392 = null;
|
|
var pg_ElementContentChar393 = null;
|
|
|
|
var L_CDataSection390_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:874:9: ( p_DirectConstructor | L_CDataSection | p_ElemEnclosedExpr | pg_CommonContent | pg_ElementContentChar )
|
|
var alt143=5;
|
|
switch ( this.input.LA(1) ) {
|
|
case SMALLER:
|
|
case L_DirCommentConstructor:
|
|
case L_DirPIConstructor:
|
|
alt143=1;
|
|
break;
|
|
case L_CDataSection:
|
|
alt143=2;
|
|
break;
|
|
case LBRACKET:
|
|
alt143=3;
|
|
break;
|
|
case L_PredefinedEntityRef:
|
|
case L_CharRef:
|
|
case ESCAPE_LBRACKET:
|
|
case ESCAPE_RBRACKET:
|
|
alt143=4;
|
|
break;
|
|
case L_ElementContentChar:
|
|
alt143=5;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 143, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt143) {
|
|
case 1 :
|
|
// XQueryParser.g:874:11: p_DirectConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DirectConstructor_in_pm_DirElemContent7547);
|
|
p_DirectConstructor389=this.p_DirectConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DirectConstructor389.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:875:11: L_CDataSection
|
|
root_0 = this.adaptor.nil();
|
|
|
|
L_CDataSection390=this.match(this.input,L_CDataSection,XQueryParser.FOLLOW_L_CDataSection_in_pm_DirElemContent7559); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
L_CDataSection390_tree = this.adaptor.create(L_CDataSection390);
|
|
this.adaptor.addChild(root_0, L_CDataSection390_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:876:11: p_ElemEnclosedExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElemEnclosedExpr_in_pm_DirElemContent7571);
|
|
p_ElemEnclosedExpr391=this.p_ElemEnclosedExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElemEnclosedExpr391.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:877:11: pg_CommonContent
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_CommonContent_in_pm_DirElemContent7583);
|
|
pg_CommonContent392=this.pg_CommonContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pg_CommonContent392.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:878:11: pg_ElementContentChar
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pg_ElementContentChar_in_pm_DirElemContent7595);
|
|
pg_ElementContentChar393=this.pg_ElementContentChar();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pg_ElementContentChar393.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pg_ElementContentChar_return: (function() {
|
|
XQueryParser.pg_ElementContentChar_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pg_ElementContentChar_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:885:1: pg_ElementContentChar : L_ElementContentChar -> ^( ElementContentChar L_ElementContentChar ) ;
|
|
// $ANTLR start "pg_ElementContentChar"
|
|
pg_ElementContentChar: function() {
|
|
var retval = new XQueryParser.pg_ElementContentChar_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var L_ElementContentChar394 = null;
|
|
|
|
var L_ElementContentChar394_tree=null;
|
|
var stream_L_ElementContentChar=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token L_ElementContentChar");
|
|
|
|
try {
|
|
// XQueryParser.g:886:9: ( L_ElementContentChar -> ^( ElementContentChar L_ElementContentChar ) )
|
|
// XQueryParser.g:886:11: L_ElementContentChar
|
|
L_ElementContentChar394=this.match(this.input,L_ElementContentChar,XQueryParser.FOLLOW_L_ElementContentChar_in_pg_ElementContentChar7624); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_L_ElementContentChar.add(L_ElementContentChar394);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: L_ElementContentChar
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 887:17: -> ^( ElementContentChar L_ElementContentChar )
|
|
{
|
|
// XQueryParser.g:887:20: ^( ElementContentChar L_ElementContentChar )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(ElementContentChar, "ElementContentChar"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_L_ElementContentChar.nextNode());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pg_CommonContent_return: (function() {
|
|
XQueryParser.pg_CommonContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pg_CommonContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:895:1: pg_CommonContent : pm_CommonContent -> ^( CommonContent pm_CommonContent ) ;
|
|
// $ANTLR start "pg_CommonContent"
|
|
pg_CommonContent: function() {
|
|
var retval = new XQueryParser.pg_CommonContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_CommonContent395 = null;
|
|
|
|
var stream_pm_CommonContent=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_CommonContent");
|
|
try {
|
|
// XQueryParser.g:896:9: ( pm_CommonContent -> ^( CommonContent pm_CommonContent ) )
|
|
// XQueryParser.g:896:13: pm_CommonContent
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_CommonContent_in_pg_CommonContent7680);
|
|
pm_CommonContent395=this.pm_CommonContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_CommonContent.add(pm_CommonContent395.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: pm_CommonContent
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 897:17: -> ^( CommonContent pm_CommonContent )
|
|
{
|
|
// XQueryParser.g:897:20: ^( CommonContent pm_CommonContent )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(CommonContent, "CommonContent"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_pm_CommonContent.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_CommonContent_return: (function() {
|
|
XQueryParser.pm_CommonContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_CommonContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:902:1: pm_CommonContent : ( L_PredefinedEntityRef | L_CharRef | ESCAPE_LBRACKET | ESCAPE_RBRACKET );
|
|
// $ANTLR start "pm_CommonContent"
|
|
pm_CommonContent: function() {
|
|
var retval = new XQueryParser.pm_CommonContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set396 = null;
|
|
|
|
var set396_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:903:9: ( L_PredefinedEntityRef | L_CharRef | ESCAPE_LBRACKET | ESCAPE_RBRACKET )
|
|
// XQueryParser.g:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
set396=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=L_PredefinedEntityRef && this.input.LA(1)<=ESCAPE_RBRACKET) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set396));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ElemEnclosedExpr_return: (function() {
|
|
XQueryParser.p_ElemEnclosedExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ElemEnclosedExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:910:1: p_ElemEnclosedExpr : LBRACKET ( pm_Expr ) RBRACKET ;
|
|
// $ANTLR start "p_ElemEnclosedExpr"
|
|
p_ElemEnclosedExpr: function() {
|
|
var retval = new XQueryParser.p_ElemEnclosedExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LBRACKET397 = null;
|
|
var RBRACKET399 = null;
|
|
var pm_Expr398 = null;
|
|
|
|
var LBRACKET397_tree=null;
|
|
var RBRACKET399_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:911:9: ( LBRACKET ( pm_Expr ) RBRACKET )
|
|
// XQueryParser.g:911:13: LBRACKET ( pm_Expr ) RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
LBRACKET397=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_ElemEnclosedExpr7776); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET397_tree = this.adaptor.create(LBRACKET397);
|
|
this.adaptor.addChild(root_0, LBRACKET397_tree);
|
|
}
|
|
// XQueryParser.g:912:13: ( pm_Expr )
|
|
// XQueryParser.g:912:14: pm_Expr
|
|
if ( this.state.backtracking===0 ) {
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_ElemEnclosedExpr7793);
|
|
pm_Expr398=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr398.getTree());
|
|
if ( this.state.backtracking===0 ) {
|
|
}
|
|
|
|
|
|
|
|
RBRACKET399=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_ElemEnclosedExpr7810); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET399_tree = this.adaptor.create(RBRACKET399);
|
|
this.adaptor.addChild(root_0, RBRACKET399_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ComputedConstructor_return: (function() {
|
|
XQueryParser.p_ComputedConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ComputedConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:936:1: p_ComputedConstructor : ( p_CompDocConstructor | p_CompElemConstructor | p_CompAttrConstructor | p_CompNamespaceConstructor | p_CompTextConstructor | p_CompCommentConstructor | p_CompPIConstructor | {...}? => p_CompBinaryConstructor );
|
|
// $ANTLR start "p_ComputedConstructor"
|
|
p_ComputedConstructor: function() {
|
|
var retval = new XQueryParser.p_ComputedConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_CompDocConstructor400 = null;
|
|
var p_CompElemConstructor401 = null;
|
|
var p_CompAttrConstructor402 = null;
|
|
var p_CompNamespaceConstructor403 = null;
|
|
var p_CompTextConstructor404 = null;
|
|
var p_CompCommentConstructor405 = null;
|
|
var p_CompPIConstructor406 = null;
|
|
var p_CompBinaryConstructor407 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:937:9: ( p_CompDocConstructor | p_CompElemConstructor | p_CompAttrConstructor | p_CompNamespaceConstructor | p_CompTextConstructor | p_CompCommentConstructor | p_CompPIConstructor | {...}? => p_CompBinaryConstructor )
|
|
var alt144=8;
|
|
var LA144_0 = this.input.LA(1);
|
|
|
|
if ( (LA144_0==DOCUMENT) ) {
|
|
alt144=1;
|
|
}
|
|
else if ( (LA144_0==ELEMENT) ) {
|
|
alt144=2;
|
|
}
|
|
else if ( (LA144_0==ATTRIBUTE) ) {
|
|
alt144=3;
|
|
}
|
|
else if ( (LA144_0==NAMESPACE) ) {
|
|
alt144=4;
|
|
}
|
|
else if ( (LA144_0==TEXT) ) {
|
|
alt144=5;
|
|
}
|
|
else if ( (LA144_0==COMMENT) ) {
|
|
alt144=6;
|
|
}
|
|
else if ( (LA144_0==PROCESSING_INSTRUCTION) ) {
|
|
alt144=7;
|
|
}
|
|
else if ( (LA144_0==BINARY) && ((false))) {
|
|
alt144=8;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 144, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt144) {
|
|
case 1 :
|
|
// XQueryParser.g:937:13: p_CompDocConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompDocConstructor_in_p_ComputedConstructor7861);
|
|
p_CompDocConstructor400=this.p_CompDocConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompDocConstructor400.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:938:11: p_CompElemConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompElemConstructor_in_p_ComputedConstructor7873);
|
|
p_CompElemConstructor401=this.p_CompElemConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompElemConstructor401.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:939:11: p_CompAttrConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompAttrConstructor_in_p_ComputedConstructor7885);
|
|
p_CompAttrConstructor402=this.p_CompAttrConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompAttrConstructor402.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:940:11: p_CompNamespaceConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompNamespaceConstructor_in_p_ComputedConstructor7897);
|
|
p_CompNamespaceConstructor403=this.p_CompNamespaceConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompNamespaceConstructor403.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:941:11: p_CompTextConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompTextConstructor_in_p_ComputedConstructor7909);
|
|
p_CompTextConstructor404=this.p_CompTextConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompTextConstructor404.getTree());
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:942:11: p_CompCommentConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompCommentConstructor_in_p_ComputedConstructor7921);
|
|
p_CompCommentConstructor405=this.p_CompCommentConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompCommentConstructor405.getTree());
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:943:11: p_CompPIConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompPIConstructor_in_p_ComputedConstructor7933);
|
|
p_CompPIConstructor406=this.p_CompPIConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompPIConstructor406.getTree());
|
|
|
|
|
|
break;
|
|
case 8 :
|
|
// XQueryParser.g:944:11: {...}? => p_CompBinaryConstructor
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((false)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ComputedConstructor", "false");
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CompBinaryConstructor_in_p_ComputedConstructor7948);
|
|
p_CompBinaryConstructor407=this.p_CompBinaryConstructor();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CompBinaryConstructor407.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompDocConstructor_return: (function() {
|
|
XQueryParser.p_CompDocConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompDocConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:948:1: p_CompDocConstructor : k= DOCUMENT LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_CompDocConstructor"
|
|
p_CompDocConstructor: function() {
|
|
var retval = new XQueryParser.p_CompDocConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET408 = null;
|
|
var RBRACKET410 = null;
|
|
var pm_Expr409 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET408_tree=null;
|
|
var RBRACKET410_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:949:9: (k= DOCUMENT LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:949:13: k= DOCUMENT LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DOCUMENT,XQueryParser.FOLLOW_DOCUMENT_in_p_CompDocConstructor7982); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
LBRACKET408=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompDocConstructor7985); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET408_tree = this.adaptor.create(LBRACKET408);
|
|
this.adaptor.addChild(root_0, LBRACKET408_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompDocConstructor7987);
|
|
pm_Expr409=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr409.getTree());
|
|
RBRACKET410=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompDocConstructor7989); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET410_tree = this.adaptor.create(RBRACKET410);
|
|
this.adaptor.addChild(root_0, RBRACKET410_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompElemConstructor_return: (function() {
|
|
XQueryParser.p_CompElemConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompElemConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:953:1: p_CompElemConstructor : k= ELEMENT ( p_QName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET ;
|
|
// $ANTLR start "p_CompElemConstructor"
|
|
p_CompElemConstructor: function() {
|
|
var retval = new XQueryParser.p_CompElemConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET412 = null;
|
|
var RBRACKET414 = null;
|
|
var LBRACKET415 = null;
|
|
var RBRACKET417 = null;
|
|
var p_QName411 = null;
|
|
var pm_Expr413 = null;
|
|
var pm_Expr416 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET412_tree=null;
|
|
var RBRACKET414_tree=null;
|
|
var LBRACKET415_tree=null;
|
|
var RBRACKET417_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:954:9: (k= ELEMENT ( p_QName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET )
|
|
// XQueryParser.g:954:13: k= ELEMENT ( p_QName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,ELEMENT,XQueryParser.FOLLOW_ELEMENT_in_p_CompElemConstructor8030); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
// XQueryParser.g:954:24: ( p_QName | ( LBRACKET pm_Expr RBRACKET ) )
|
|
var alt145=2;
|
|
var LA145_0 = this.input.LA(1);
|
|
|
|
if ( ((LA145_0>=ANCESTOR && LA145_0<=EXIT)||(LA145_0>=SEQUENTIAL && LA145_0<=MAINTAINED)||(LA145_0>=MUTABLE && LA145_0<=QUOT_ER)||LA145_0==L_NCName||LA145_0==EXPLICITLY) ) {
|
|
alt145=1;
|
|
}
|
|
else if ( (LA145_0==LBRACKET) ) {
|
|
alt145=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 145, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt145) {
|
|
case 1 :
|
|
// XQueryParser.g:954:25: p_QName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_CompElemConstructor8034);
|
|
p_QName411=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName411.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:954:35: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:954:35: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:954:36: LBRACKET pm_Expr RBRACKET
|
|
LBRACKET412=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompElemConstructor8039); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET412_tree = this.adaptor.create(LBRACKET412);
|
|
this.adaptor.addChild(root_0, LBRACKET412_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompElemConstructor8041);
|
|
pm_Expr413=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr413.getTree());
|
|
RBRACKET414=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompElemConstructor8043); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET414_tree = this.adaptor.create(RBRACKET414);
|
|
this.adaptor.addChild(root_0, RBRACKET414_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LBRACKET415=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompElemConstructor8047); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET415_tree = this.adaptor.create(LBRACKET415);
|
|
this.adaptor.addChild(root_0, LBRACKET415_tree);
|
|
}
|
|
// XQueryParser.g:954:73: ( pm_Expr )?
|
|
var alt146=2;
|
|
var LA146_0 = this.input.LA(1);
|
|
|
|
if ( ((LA146_0>=ANCESTOR && LA146_0<=EXIT)||(LA146_0>=SEQUENTIAL && LA146_0<=MAINTAINED)||(LA146_0>=MUTABLE && LA146_0<=LPAREN)||LA146_0==DOLLAR||(LA146_0>=STAR && LA146_0<=SMALLER)||(LA146_0>=SLASH && LA146_0<=DOT_DOT)||LA146_0==ATTR_SIGN||(LA146_0>=APOS && LA146_0<=QUOT)||LA146_0==L_NCName||(LA146_0>=L_Pragma && LA146_0<=L_DoubleLiteral)||(LA146_0>=LETDOLLAR && LA146_0<=EXPLICITLY)) ) {
|
|
alt146=1;
|
|
}
|
|
switch (alt146) {
|
|
case 1 :
|
|
// XQueryParser.g:954:73: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompElemConstructor8049);
|
|
pm_Expr416=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr416.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RBRACKET417=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompElemConstructor8052); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET417_tree = this.adaptor.create(RBRACKET417);
|
|
this.adaptor.addChild(root_0, RBRACKET417_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompAttrConstructor_return: (function() {
|
|
XQueryParser.p_CompAttrConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompAttrConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:961:1: p_CompAttrConstructor : k= ATTRIBUTE ( p_QName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET ;
|
|
// $ANTLR start "p_CompAttrConstructor"
|
|
p_CompAttrConstructor: function() {
|
|
var retval = new XQueryParser.p_CompAttrConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET419 = null;
|
|
var RBRACKET421 = null;
|
|
var LBRACKET422 = null;
|
|
var RBRACKET424 = null;
|
|
var p_QName418 = null;
|
|
var pm_Expr420 = null;
|
|
var pm_Expr423 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET419_tree=null;
|
|
var RBRACKET421_tree=null;
|
|
var LBRACKET422_tree=null;
|
|
var RBRACKET424_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:962:9: (k= ATTRIBUTE ( p_QName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET )
|
|
// XQueryParser.g:962:13: k= ATTRIBUTE ( p_QName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,ATTRIBUTE,XQueryParser.FOLLOW_ATTRIBUTE_in_p_CompAttrConstructor8085); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
// XQueryParser.g:962:26: ( p_QName | ( LBRACKET pm_Expr RBRACKET ) )
|
|
var alt147=2;
|
|
var LA147_0 = this.input.LA(1);
|
|
|
|
if ( ((LA147_0>=ANCESTOR && LA147_0<=EXIT)||(LA147_0>=SEQUENTIAL && LA147_0<=MAINTAINED)||(LA147_0>=MUTABLE && LA147_0<=QUOT_ER)||LA147_0==L_NCName||LA147_0==EXPLICITLY) ) {
|
|
alt147=1;
|
|
}
|
|
else if ( (LA147_0==LBRACKET) ) {
|
|
alt147=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 147, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt147) {
|
|
case 1 :
|
|
// XQueryParser.g:962:27: p_QName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_CompAttrConstructor8089);
|
|
p_QName418=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName418.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:962:37: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:962:37: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:962:38: LBRACKET pm_Expr RBRACKET
|
|
LBRACKET419=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompAttrConstructor8094); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET419_tree = this.adaptor.create(LBRACKET419);
|
|
this.adaptor.addChild(root_0, LBRACKET419_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompAttrConstructor8096);
|
|
pm_Expr420=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr420.getTree());
|
|
RBRACKET421=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompAttrConstructor8098); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET421_tree = this.adaptor.create(RBRACKET421);
|
|
this.adaptor.addChild(root_0, RBRACKET421_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LBRACKET422=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompAttrConstructor8102); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET422_tree = this.adaptor.create(LBRACKET422);
|
|
this.adaptor.addChild(root_0, LBRACKET422_tree);
|
|
}
|
|
// XQueryParser.g:962:75: ( pm_Expr )?
|
|
var alt148=2;
|
|
var LA148_0 = this.input.LA(1);
|
|
|
|
if ( ((LA148_0>=ANCESTOR && LA148_0<=EXIT)||(LA148_0>=SEQUENTIAL && LA148_0<=MAINTAINED)||(LA148_0>=MUTABLE && LA148_0<=LPAREN)||LA148_0==DOLLAR||(LA148_0>=STAR && LA148_0<=SMALLER)||(LA148_0>=SLASH && LA148_0<=DOT_DOT)||LA148_0==ATTR_SIGN||(LA148_0>=APOS && LA148_0<=QUOT)||LA148_0==L_NCName||(LA148_0>=L_Pragma && LA148_0<=L_DoubleLiteral)||(LA148_0>=LETDOLLAR && LA148_0<=EXPLICITLY)) ) {
|
|
alt148=1;
|
|
}
|
|
switch (alt148) {
|
|
case 1 :
|
|
// XQueryParser.g:962:75: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompAttrConstructor8104);
|
|
pm_Expr423=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr423.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RBRACKET424=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompAttrConstructor8107); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET424_tree = this.adaptor.create(RBRACKET424);
|
|
this.adaptor.addChild(root_0, RBRACKET424_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompNamespaceConstructor_return: (function() {
|
|
XQueryParser.p_CompNamespaceConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompNamespaceConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:966:1: p_CompNamespaceConstructor : k= NAMESPACE ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET ;
|
|
// $ANTLR start "p_CompNamespaceConstructor"
|
|
p_CompNamespaceConstructor: function() {
|
|
var retval = new XQueryParser.p_CompNamespaceConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET426 = null;
|
|
var RBRACKET428 = null;
|
|
var LBRACKET429 = null;
|
|
var RBRACKET431 = null;
|
|
var p_NCName425 = null;
|
|
var pm_Expr427 = null;
|
|
var pm_Expr430 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET426_tree=null;
|
|
var RBRACKET428_tree=null;
|
|
var LBRACKET429_tree=null;
|
|
var RBRACKET431_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:967:9: (k= NAMESPACE ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET )
|
|
// XQueryParser.g:967:11: k= NAMESPACE ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,NAMESPACE,XQueryParser.FOLLOW_NAMESPACE_in_p_CompNamespaceConstructor8135); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
// XQueryParser.g:967:24: ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) )
|
|
var alt149=2;
|
|
var LA149_0 = this.input.LA(1);
|
|
|
|
if ( ((LA149_0>=ANCESTOR && LA149_0<=EXIT)||(LA149_0>=SEQUENTIAL && LA149_0<=MAINTAINED)||(LA149_0>=MUTABLE && LA149_0<=QUOT_ER)||LA149_0==L_NCName||LA149_0==EXPLICITLY) ) {
|
|
alt149=1;
|
|
}
|
|
else if ( (LA149_0==LBRACKET) ) {
|
|
alt149=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 149, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt149) {
|
|
case 1 :
|
|
// XQueryParser.g:967:25: p_NCName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_CompNamespaceConstructor8139);
|
|
p_NCName425=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName425.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:967:36: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:967:36: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:967:37: LBRACKET pm_Expr RBRACKET
|
|
LBRACKET426=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompNamespaceConstructor8144); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET426_tree = this.adaptor.create(LBRACKET426);
|
|
this.adaptor.addChild(root_0, LBRACKET426_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompNamespaceConstructor8146);
|
|
pm_Expr427=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr427.getTree());
|
|
RBRACKET428=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompNamespaceConstructor8148); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET428_tree = this.adaptor.create(RBRACKET428);
|
|
this.adaptor.addChild(root_0, RBRACKET428_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LBRACKET429=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompNamespaceConstructor8152); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET429_tree = this.adaptor.create(LBRACKET429);
|
|
this.adaptor.addChild(root_0, LBRACKET429_tree);
|
|
}
|
|
// XQueryParser.g:967:74: ( pm_Expr )?
|
|
var alt150=2;
|
|
var LA150_0 = this.input.LA(1);
|
|
|
|
if ( ((LA150_0>=ANCESTOR && LA150_0<=EXIT)||(LA150_0>=SEQUENTIAL && LA150_0<=MAINTAINED)||(LA150_0>=MUTABLE && LA150_0<=LPAREN)||LA150_0==DOLLAR||(LA150_0>=STAR && LA150_0<=SMALLER)||(LA150_0>=SLASH && LA150_0<=DOT_DOT)||LA150_0==ATTR_SIGN||(LA150_0>=APOS && LA150_0<=QUOT)||LA150_0==L_NCName||(LA150_0>=L_Pragma && LA150_0<=L_DoubleLiteral)||(LA150_0>=LETDOLLAR && LA150_0<=EXPLICITLY)) ) {
|
|
alt150=1;
|
|
}
|
|
switch (alt150) {
|
|
case 1 :
|
|
// XQueryParser.g:967:74: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompNamespaceConstructor8154);
|
|
pm_Expr430=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr430.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RBRACKET431=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompNamespaceConstructor8157); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET431_tree = this.adaptor.create(RBRACKET431);
|
|
this.adaptor.addChild(root_0, RBRACKET431_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompTextConstructor_return: (function() {
|
|
XQueryParser.p_CompTextConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompTextConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:977:1: p_CompTextConstructor : k= TEXT LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_CompTextConstructor"
|
|
p_CompTextConstructor: function() {
|
|
var retval = new XQueryParser.p_CompTextConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET432 = null;
|
|
var RBRACKET434 = null;
|
|
var pm_Expr433 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET432_tree=null;
|
|
var RBRACKET434_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:978:9: (k= TEXT LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:978:13: k= TEXT LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,TEXT,XQueryParser.FOLLOW_TEXT_in_p_CompTextConstructor8193); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
LBRACKET432=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompTextConstructor8196); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET432_tree = this.adaptor.create(LBRACKET432);
|
|
this.adaptor.addChild(root_0, LBRACKET432_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompTextConstructor8198);
|
|
pm_Expr433=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr433.getTree());
|
|
RBRACKET434=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompTextConstructor8200); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET434_tree = this.adaptor.create(RBRACKET434);
|
|
this.adaptor.addChild(root_0, RBRACKET434_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompBinaryConstructor_return: (function() {
|
|
XQueryParser.p_CompBinaryConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompBinaryConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:982:1: p_CompBinaryConstructor : k= BINARY LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_CompBinaryConstructor"
|
|
p_CompBinaryConstructor: function() {
|
|
var retval = new XQueryParser.p_CompBinaryConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET435 = null;
|
|
var RBRACKET437 = null;
|
|
var pm_Expr436 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET435_tree=null;
|
|
var RBRACKET437_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:983:9: (k= BINARY LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:983:13: k= BINARY LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,BINARY,XQueryParser.FOLLOW_BINARY_in_p_CompBinaryConstructor8230); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
LBRACKET435=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompBinaryConstructor8233); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET435_tree = this.adaptor.create(LBRACKET435);
|
|
this.adaptor.addChild(root_0, LBRACKET435_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompBinaryConstructor8235);
|
|
pm_Expr436=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr436.getTree());
|
|
RBRACKET437=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompBinaryConstructor8237); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET437_tree = this.adaptor.create(RBRACKET437);
|
|
this.adaptor.addChild(root_0, RBRACKET437_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompCommentConstructor_return: (function() {
|
|
XQueryParser.p_CompCommentConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompCommentConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:987:1: p_CompCommentConstructor : k= COMMENT LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_CompCommentConstructor"
|
|
p_CompCommentConstructor: function() {
|
|
var retval = new XQueryParser.p_CompCommentConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET438 = null;
|
|
var RBRACKET440 = null;
|
|
var pm_Expr439 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET438_tree=null;
|
|
var RBRACKET440_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:988:9: (k= COMMENT LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:988:13: k= COMMENT LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,COMMENT,XQueryParser.FOLLOW_COMMENT_in_p_CompCommentConstructor8267); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
LBRACKET438=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompCommentConstructor8270); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET438_tree = this.adaptor.create(LBRACKET438);
|
|
this.adaptor.addChild(root_0, LBRACKET438_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompCommentConstructor8272);
|
|
pm_Expr439=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr439.getTree());
|
|
RBRACKET440=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompCommentConstructor8274); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET440_tree = this.adaptor.create(RBRACKET440);
|
|
this.adaptor.addChild(root_0, RBRACKET440_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CompPIConstructor_return: (function() {
|
|
XQueryParser.p_CompPIConstructor_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CompPIConstructor_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:992:1: p_CompPIConstructor : k= PROCESSING_INSTRUCTION ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET ;
|
|
// $ANTLR start "p_CompPIConstructor"
|
|
p_CompPIConstructor: function() {
|
|
var retval = new XQueryParser.p_CompPIConstructor_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var LBRACKET442 = null;
|
|
var RBRACKET444 = null;
|
|
var LBRACKET445 = null;
|
|
var RBRACKET447 = null;
|
|
var p_NCName441 = null;
|
|
var pm_Expr443 = null;
|
|
var pm_Expr446 = null;
|
|
|
|
var k_tree=null;
|
|
var LBRACKET442_tree=null;
|
|
var RBRACKET444_tree=null;
|
|
var LBRACKET445_tree=null;
|
|
var RBRACKET447_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:993:9: (k= PROCESSING_INSTRUCTION ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET )
|
|
// XQueryParser.g:993:13: k= PROCESSING_INSTRUCTION ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) ) LBRACKET ( pm_Expr )? RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,PROCESSING_INSTRUCTION,XQueryParser.FOLLOW_PROCESSING_INSTRUCTION_in_p_CompPIConstructor8305); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
// XQueryParser.g:993:39: ( p_NCName | ( LBRACKET pm_Expr RBRACKET ) )
|
|
var alt151=2;
|
|
var LA151_0 = this.input.LA(1);
|
|
|
|
if ( ((LA151_0>=ANCESTOR && LA151_0<=EXIT)||(LA151_0>=SEQUENTIAL && LA151_0<=MAINTAINED)||(LA151_0>=MUTABLE && LA151_0<=QUOT_ER)||LA151_0==L_NCName||LA151_0==EXPLICITLY) ) {
|
|
alt151=1;
|
|
}
|
|
else if ( (LA151_0==LBRACKET) ) {
|
|
alt151=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 151, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt151) {
|
|
case 1 :
|
|
// XQueryParser.g:993:40: p_NCName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_CompPIConstructor8309);
|
|
p_NCName441=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName441.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:993:51: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:993:51: ( LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:993:52: LBRACKET pm_Expr RBRACKET
|
|
LBRACKET442=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompPIConstructor8314); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET442_tree = this.adaptor.create(LBRACKET442);
|
|
this.adaptor.addChild(root_0, LBRACKET442_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompPIConstructor8316);
|
|
pm_Expr443=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr443.getTree());
|
|
RBRACKET444=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompPIConstructor8318); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET444_tree = this.adaptor.create(RBRACKET444);
|
|
this.adaptor.addChild(root_0, RBRACKET444_tree);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LBRACKET445=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CompPIConstructor8322); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET445_tree = this.adaptor.create(LBRACKET445);
|
|
this.adaptor.addChild(root_0, LBRACKET445_tree);
|
|
}
|
|
// XQueryParser.g:993:89: ( pm_Expr )?
|
|
var alt152=2;
|
|
var LA152_0 = this.input.LA(1);
|
|
|
|
if ( ((LA152_0>=ANCESTOR && LA152_0<=EXIT)||(LA152_0>=SEQUENTIAL && LA152_0<=MAINTAINED)||(LA152_0>=MUTABLE && LA152_0<=LPAREN)||LA152_0==DOLLAR||(LA152_0>=STAR && LA152_0<=SMALLER)||(LA152_0>=SLASH && LA152_0<=DOT_DOT)||LA152_0==ATTR_SIGN||(LA152_0>=APOS && LA152_0<=QUOT)||LA152_0==L_NCName||(LA152_0>=L_Pragma && LA152_0<=L_DoubleLiteral)||(LA152_0>=LETDOLLAR && LA152_0<=EXPLICITLY)) ) {
|
|
alt152=1;
|
|
}
|
|
switch (alt152) {
|
|
case 1 :
|
|
// XQueryParser.g:993:89: pm_Expr
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CompPIConstructor8324);
|
|
pm_Expr446=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr446.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RBRACKET447=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CompPIConstructor8327); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET447_tree = this.adaptor.create(RBRACKET447);
|
|
this.adaptor.addChild(root_0, RBRACKET447_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SingleType_return: (function() {
|
|
XQueryParser.p_SingleType_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SingleType_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:997:1: p_SingleType : p_AtomicType ( QUESTION )? ;
|
|
// $ANTLR start "p_SingleType"
|
|
p_SingleType: function() {
|
|
var retval = new XQueryParser.p_SingleType_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var QUESTION449 = null;
|
|
var p_AtomicType448 = null;
|
|
|
|
var QUESTION449_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:998:9: ( p_AtomicType ( QUESTION )? )
|
|
// XQueryParser.g:998:13: p_AtomicType ( QUESTION )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AtomicType_in_p_SingleType8355);
|
|
p_AtomicType448=this.p_AtomicType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AtomicType448.getTree());
|
|
// XQueryParser.g:998:26: ( QUESTION )?
|
|
var alt153=2;
|
|
var LA153_0 = this.input.LA(1);
|
|
|
|
if ( (LA153_0==QUESTION) ) {
|
|
alt153=1;
|
|
}
|
|
switch (alt153) {
|
|
case 1 :
|
|
// XQueryParser.g:998:26: QUESTION
|
|
QUESTION449=this.match(this.input,QUESTION,XQueryParser.FOLLOW_QUESTION_in_p_SingleType8357); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
QUESTION449_tree = this.adaptor.create(QUESTION449);
|
|
this.adaptor.addChild(root_0, QUESTION449_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TypeDeclaration_return: (function() {
|
|
XQueryParser.p_TypeDeclaration_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TypeDeclaration_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1002:1: p_TypeDeclaration : k= AS st= p_SequenceType -> ^( TypeDeclaration $st) ;
|
|
// $ANTLR start "p_TypeDeclaration"
|
|
p_TypeDeclaration: function() {
|
|
var retval = new XQueryParser.p_TypeDeclaration_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var st = null;
|
|
|
|
var k_tree=null;
|
|
var stream_AS=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token AS");
|
|
var stream_p_SequenceType=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_SequenceType");
|
|
try {
|
|
// XQueryParser.g:1003:9: (k= AS st= p_SequenceType -> ^( TypeDeclaration $st) )
|
|
// XQueryParser.g:1003:13: k= AS st= p_SequenceType
|
|
k=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_TypeDeclaration8388); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_AS.add(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SequenceType_in_p_TypeDeclaration8393);
|
|
st=this.p_SequenceType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_SequenceType.add(st.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: st
|
|
// token labels:
|
|
// rule labels: retval, st
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_st=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token st",st!=null?st.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1004:17: -> ^( TypeDeclaration $st)
|
|
{
|
|
// XQueryParser.g:1004:20: ^( TypeDeclaration $st)
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(TypeDeclaration, "TypeDeclaration"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_st.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SequenceType_return: (function() {
|
|
XQueryParser.p_SequenceType_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SequenceType_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1008:1: p_SequenceType : (k= EMPTY_SEQUENCE l= LPAREN r= RPAREN -> ^( SequenceType ^( EmptySequenceTest $k $l $r) ) | it= p_ItemType ( ( p_OccurrenceIndicator )=>oi= p_OccurrenceIndicator )? -> ^( SequenceType $it ( $oi)? ) );
|
|
// $ANTLR start "p_SequenceType"
|
|
p_SequenceType: function() {
|
|
var retval = new XQueryParser.p_SequenceType_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var l = null;
|
|
var r = null;
|
|
var it = null;
|
|
var oi = null;
|
|
|
|
var k_tree=null;
|
|
var l_tree=null;
|
|
var r_tree=null;
|
|
var stream_EMPTY_SEQUENCE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token EMPTY_SEQUENCE");
|
|
var stream_RPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token RPAREN");
|
|
var stream_LPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token LPAREN");
|
|
var stream_p_ItemType=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_ItemType");
|
|
var stream_p_OccurrenceIndicator=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_OccurrenceIndicator");
|
|
try {
|
|
// XQueryParser.g:1009:9: (k= EMPTY_SEQUENCE l= LPAREN r= RPAREN -> ^( SequenceType ^( EmptySequenceTest $k $l $r) ) | it= p_ItemType ( ( p_OccurrenceIndicator )=>oi= p_OccurrenceIndicator )? -> ^( SequenceType $it ( $oi)? ) )
|
|
var alt155=2;
|
|
var LA155_0 = this.input.LA(1);
|
|
|
|
if ( (LA155_0==EMPTY_SEQUENCE) ) {
|
|
var LA155_1 = this.input.LA(2);
|
|
|
|
if ( (LA155_1==LPAREN) ) {
|
|
alt155=1;
|
|
}
|
|
else if ( (LA155_1==EOF||(LA155_1>=AND && LA155_1<=AT)||LA155_1==CASE||LA155_1==COLLATION||LA155_1==DEFAULT||(LA155_1>=DESCENDING && LA155_1<=DIV)||(LA155_1>=ELSE && LA155_1<=EMPTY)||LA155_1==EQ||(LA155_1>=EXCEPT && LA155_1<=EXTERNAL)||LA155_1==FOR||LA155_1==GE||(LA155_1>=GT && LA155_1<=IDIV)||LA155_1==IN||(LA155_1>=INSTANCE && LA155_1<=IS)||LA155_1==LE||(LA155_1>=LT && LA155_1<=MOD)||LA155_1==NE||(LA155_1>=OR && LA155_1<=ORDER)||(LA155_1>=RETURN && LA155_1<=SATISFIES)||LA155_1==STABLE||LA155_1==TO||LA155_1==UNION||LA155_1==WHERE||LA155_1==COUNT||(LA155_1>=END && LA155_1<=GROUP)||LA155_1==ONLY||LA155_1==START||(LA155_1>=AFTER && LA155_1<=BEFORE)||LA155_1==INTO||LA155_1==MODIFY||LA155_1==WITH||LA155_1==RPAREN||(LA155_1>=LBRACKET && LA155_1<=RBRACKET)||(LA155_1>=RSQUARE && LA155_1<=NOTEQUAL)||(LA155_1>=COMMA && LA155_1<=GREATER_GREATER)||LA155_1==COLON||(LA155_1>=SEMICOLON && LA155_1<=VBAR)||LA155_1==LETDOLLAR) ) {
|
|
alt155=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 155, 1, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else if ( ((LA155_0>=ANCESTOR && LA155_0<=EMPTY)||(LA155_0>=ENCODING && LA155_0<=EXIT)||(LA155_0>=SEQUENTIAL && LA155_0<=MAINTAINED)||(LA155_0>=MUTABLE && LA155_0<=QUOT_ER)||LA155_0==L_NCName||LA155_0==EXPLICITLY) ) {
|
|
alt155=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 155, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt155) {
|
|
case 1 :
|
|
// XQueryParser.g:1009:13: k= EMPTY_SEQUENCE l= LPAREN r= RPAREN
|
|
k=this.match(this.input,EMPTY_SEQUENCE,XQueryParser.FOLLOW_EMPTY_SEQUENCE_in_p_SequenceType8448); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_EMPTY_SEQUENCE.add(k);
|
|
|
|
l=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_SequenceType8453); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LPAREN.add(l);
|
|
|
|
r=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_SequenceType8457); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RPAREN.add(r);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: k, r, l
|
|
// token labels: r, l, k
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_r=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token r",r);
|
|
var stream_l=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token l",l);
|
|
var stream_k=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token k",k);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1010:17: -> ^( SequenceType ^( EmptySequenceTest $k $l $r) )
|
|
{
|
|
// XQueryParser.g:1010:20: ^( SequenceType ^( EmptySequenceTest $k $l $r) )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(SequenceType, "SequenceType"), root_1);
|
|
|
|
// XQueryParser.g:1010:35: ^( EmptySequenceTest $k $l $r)
|
|
{
|
|
var root_2 = this.adaptor.nil();
|
|
root_2 = this.adaptor.becomeRoot(this.adaptor.create(EmptySequenceTest, "EmptySequenceTest"), root_2);
|
|
|
|
this.adaptor.addChild(root_2, stream_k.nextNode());
|
|
this.adaptor.addChild(root_2, stream_l.nextNode());
|
|
this.adaptor.addChild(root_2, stream_r.nextNode());
|
|
|
|
this.adaptor.addChild(root_1, root_2);
|
|
}
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1011:11: it= p_ItemType ( ( p_OccurrenceIndicator )=>oi= p_OccurrenceIndicator )?
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ItemType_in_p_SequenceType8506);
|
|
it=this.p_ItemType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ItemType.add(it.getTree());
|
|
// XQueryParser.g:1011:25: ( ( p_OccurrenceIndicator )=>oi= p_OccurrenceIndicator )?
|
|
var alt154=2;
|
|
alt154 = this.dfa154.predict(this.input);
|
|
switch (alt154) {
|
|
case 1 :
|
|
// XQueryParser.g:1011:26: ( p_OccurrenceIndicator )=>oi= p_OccurrenceIndicator
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OccurrenceIndicator_in_p_SequenceType8517);
|
|
oi=this.p_OccurrenceIndicator();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_OccurrenceIndicator.add(oi.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: oi, it
|
|
// token labels:
|
|
// rule labels: retval, it, oi
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_it=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token it",it!=null?it.tree:null);
|
|
var stream_oi=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token oi",oi!=null?oi.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1012:17: -> ^( SequenceType $it ( $oi)? )
|
|
{
|
|
// XQueryParser.g:1012:20: ^( SequenceType $it ( $oi)? )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(SequenceType, "SequenceType"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_it.nextTree());
|
|
// XQueryParser.g:1012:39: ( $oi)?
|
|
if ( stream_oi.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_oi.nextTree());
|
|
|
|
}
|
|
stream_oi.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_OccurrenceIndicator_return: (function() {
|
|
XQueryParser.p_OccurrenceIndicator_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_OccurrenceIndicator_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1016:1: p_OccurrenceIndicator : ( QUESTION | STAR | PLUS );
|
|
// $ANTLR start "p_OccurrenceIndicator"
|
|
p_OccurrenceIndicator: function() {
|
|
var retval = new XQueryParser.p_OccurrenceIndicator_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set450 = null;
|
|
|
|
var set450_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1017:9: ( QUESTION | STAR | PLUS )
|
|
// XQueryParser.g:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
set450=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=QUESTION && this.input.LA(1)<=PLUS) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set450));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ItemType_return: (function() {
|
|
XQueryParser.p_ItemType_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ItemType_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1021:1: p_ItemType : ( p_KindTest -> ^( KindTest p_KindTest ) | {...}? => ( BINARY LPAREN RPAREN ) -> ^( BinaryTest BINARY LPAREN RPAREN ) | ( ITEM LPAREN RPAREN ) -> ^( ItemTest ITEM LPAREN RPAREN ) | p_AtomicType );
|
|
// $ANTLR start "p_ItemType"
|
|
p_ItemType: function() {
|
|
var retval = new XQueryParser.p_ItemType_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var BINARY452 = null;
|
|
var LPAREN453 = null;
|
|
var RPAREN454 = null;
|
|
var ITEM455 = null;
|
|
var LPAREN456 = null;
|
|
var RPAREN457 = null;
|
|
var p_KindTest451 = null;
|
|
var p_AtomicType458 = null;
|
|
|
|
var BINARY452_tree=null;
|
|
var LPAREN453_tree=null;
|
|
var RPAREN454_tree=null;
|
|
var ITEM455_tree=null;
|
|
var LPAREN456_tree=null;
|
|
var RPAREN457_tree=null;
|
|
var stream_RPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token RPAREN");
|
|
var stream_ITEM=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token ITEM");
|
|
var stream_BINARY=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token BINARY");
|
|
var stream_LPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token LPAREN");
|
|
var stream_p_KindTest=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_KindTest");
|
|
try {
|
|
// XQueryParser.g:1022:9: ( p_KindTest -> ^( KindTest p_KindTest ) | {...}? => ( BINARY LPAREN RPAREN ) -> ^( BinaryTest BINARY LPAREN RPAREN ) | ( ITEM LPAREN RPAREN ) -> ^( ItemTest ITEM LPAREN RPAREN ) | p_AtomicType )
|
|
var alt156=4;
|
|
alt156 = this.dfa156.predict(this.input);
|
|
switch (alt156) {
|
|
case 1 :
|
|
// XQueryParser.g:1022:11: p_KindTest
|
|
this.pushFollow(XQueryParser.FOLLOW_p_KindTest_in_p_ItemType8619);
|
|
p_KindTest451=this.p_KindTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_KindTest.add(p_KindTest451.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_KindTest
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1023:17: -> ^( KindTest p_KindTest )
|
|
{
|
|
// XQueryParser.g:1023:20: ^( KindTest p_KindTest )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(KindTest, "KindTest"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_p_KindTest.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1024:11: {...}? => ( BINARY LPAREN RPAREN )
|
|
if ( !((false)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_ItemType", "false");
|
|
}
|
|
// XQueryParser.g:1024:22: ( BINARY LPAREN RPAREN )
|
|
// XQueryParser.g:1024:23: BINARY LPAREN RPAREN
|
|
BINARY452=this.match(this.input,BINARY,XQueryParser.FOLLOW_BINARY_in_p_ItemType8659); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_BINARY.add(BINARY452);
|
|
|
|
LPAREN453=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_ItemType8661); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LPAREN.add(LPAREN453);
|
|
|
|
RPAREN454=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_ItemType8663); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RPAREN.add(RPAREN454);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: LPAREN, RPAREN, BINARY
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1025:17: -> ^( BinaryTest BINARY LPAREN RPAREN )
|
|
{
|
|
// XQueryParser.g:1025:20: ^( BinaryTest BINARY LPAREN RPAREN )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(BinaryTest, "BinaryTest"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_BINARY.nextNode());
|
|
this.adaptor.addChild(root_1, stream_LPAREN.nextNode());
|
|
this.adaptor.addChild(root_1, stream_RPAREN.nextNode());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1026:11: ( ITEM LPAREN RPAREN )
|
|
// XQueryParser.g:1026:11: ( ITEM LPAREN RPAREN )
|
|
// XQueryParser.g:1026:12: ITEM LPAREN RPAREN
|
|
ITEM455=this.match(this.input,ITEM,XQueryParser.FOLLOW_ITEM_in_p_ItemType8705); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_ITEM.add(ITEM455);
|
|
|
|
LPAREN456=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_ItemType8707); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LPAREN.add(LPAREN456);
|
|
|
|
RPAREN457=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_ItemType8709); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RPAREN.add(RPAREN457);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: RPAREN, LPAREN, ITEM
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1027:17: -> ^( ItemTest ITEM LPAREN RPAREN )
|
|
{
|
|
// XQueryParser.g:1027:20: ^( ItemTest ITEM LPAREN RPAREN )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(ItemTest, "ItemTest"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_ITEM.nextNode());
|
|
this.adaptor.addChild(root_1, stream_LPAREN.nextNode());
|
|
this.adaptor.addChild(root_1, stream_RPAREN.nextNode());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:1028:11: p_AtomicType
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AtomicType_in_p_ItemType8750);
|
|
p_AtomicType458=this.p_AtomicType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AtomicType458.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AtomicType_return: (function() {
|
|
XQueryParser.p_AtomicType_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AtomicType_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1032:1: p_AtomicType : p_QName -> ^( AtomicType p_QName ) ;
|
|
// $ANTLR start "p_AtomicType"
|
|
p_AtomicType: function() {
|
|
var retval = new XQueryParser.p_AtomicType_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName459 = null;
|
|
|
|
var stream_p_QName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QName");
|
|
try {
|
|
// XQueryParser.g:1033:9: ( p_QName -> ^( AtomicType p_QName ) )
|
|
// XQueryParser.g:1033:11: p_QName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_AtomicType8776);
|
|
p_QName459=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QName.add(p_QName459.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_QName
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1034:17: -> ^( AtomicType p_QName )
|
|
{
|
|
// XQueryParser.g:1034:20: ^( AtomicType p_QName )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(AtomicType, "AtomicType"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_p_QName.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_KindTest_return: (function() {
|
|
XQueryParser.p_KindTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_KindTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1038:1: p_KindTest : ( p_DocumentTest | p_ElementTest | p_AttributeTest | p_SchemaElementTest | p_SchemaAttributeTest | p_NamespaceNodeTest | p_PITest | p_CommentTest | p_TextTest | p_AnyKindTest );
|
|
// $ANTLR start "p_KindTest"
|
|
p_KindTest: function() {
|
|
var retval = new XQueryParser.p_KindTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_DocumentTest460 = null;
|
|
var p_ElementTest461 = null;
|
|
var p_AttributeTest462 = null;
|
|
var p_SchemaElementTest463 = null;
|
|
var p_SchemaAttributeTest464 = null;
|
|
var p_NamespaceNodeTest465 = null;
|
|
var p_PITest466 = null;
|
|
var p_CommentTest467 = null;
|
|
var p_TextTest468 = null;
|
|
var p_AnyKindTest469 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1039:9: ( p_DocumentTest | p_ElementTest | p_AttributeTest | p_SchemaElementTest | p_SchemaAttributeTest | p_NamespaceNodeTest | p_PITest | p_CommentTest | p_TextTest | p_AnyKindTest )
|
|
var alt157=10;
|
|
switch ( this.input.LA(1) ) {
|
|
case DOCUMENT_NODE:
|
|
alt157=1;
|
|
break;
|
|
case ELEMENT:
|
|
alt157=2;
|
|
break;
|
|
case ATTRIBUTE:
|
|
alt157=3;
|
|
break;
|
|
case SCHEMA_ELEMENT:
|
|
alt157=4;
|
|
break;
|
|
case SCHEMA_ATTRIBUTE:
|
|
alt157=5;
|
|
break;
|
|
case NAMESPACE_NODE:
|
|
alt157=6;
|
|
break;
|
|
case PROCESSING_INSTRUCTION:
|
|
alt157=7;
|
|
break;
|
|
case COMMENT:
|
|
alt157=8;
|
|
break;
|
|
case TEXT:
|
|
alt157=9;
|
|
break;
|
|
case NODE:
|
|
alt157=10;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 157, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt157) {
|
|
case 1 :
|
|
// XQueryParser.g:1039:11: p_DocumentTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_DocumentTest_in_p_KindTest8826);
|
|
p_DocumentTest460=this.p_DocumentTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_DocumentTest460.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1040:11: p_ElementTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElementTest_in_p_KindTest8838);
|
|
p_ElementTest461=this.p_ElementTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElementTest461.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1041:11: p_AttributeTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AttributeTest_in_p_KindTest8850);
|
|
p_AttributeTest462=this.p_AttributeTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AttributeTest462.getTree());
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:1042:11: p_SchemaElementTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SchemaElementTest_in_p_KindTest8862);
|
|
p_SchemaElementTest463=this.p_SchemaElementTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SchemaElementTest463.getTree());
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:1043:11: p_SchemaAttributeTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SchemaAttributeTest_in_p_KindTest8874);
|
|
p_SchemaAttributeTest464=this.p_SchemaAttributeTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SchemaAttributeTest464.getTree());
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:1044:11: p_NamespaceNodeTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NamespaceNodeTest_in_p_KindTest8886);
|
|
p_NamespaceNodeTest465=this.p_NamespaceNodeTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NamespaceNodeTest465.getTree());
|
|
|
|
|
|
break;
|
|
case 7 :
|
|
// XQueryParser.g:1045:11: p_PITest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PITest_in_p_KindTest8898);
|
|
p_PITest466=this.p_PITest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PITest466.getTree());
|
|
|
|
|
|
break;
|
|
case 8 :
|
|
// XQueryParser.g:1046:11: p_CommentTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CommentTest_in_p_KindTest8910);
|
|
p_CommentTest467=this.p_CommentTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CommentTest467.getTree());
|
|
|
|
|
|
break;
|
|
case 9 :
|
|
// XQueryParser.g:1047:11: p_TextTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TextTest_in_p_KindTest8922);
|
|
p_TextTest468=this.p_TextTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TextTest468.getTree());
|
|
|
|
|
|
break;
|
|
case 10 :
|
|
// XQueryParser.g:1048:11: p_AnyKindTest
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AnyKindTest_in_p_KindTest8934);
|
|
p_AnyKindTest469=this.p_AnyKindTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AnyKindTest469.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AnyKindTest_return: (function() {
|
|
XQueryParser.p_AnyKindTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AnyKindTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1052:1: p_AnyKindTest : NODE LPAREN RPAREN ;
|
|
// $ANTLR start "p_AnyKindTest"
|
|
p_AnyKindTest: function() {
|
|
var retval = new XQueryParser.p_AnyKindTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var NODE470 = null;
|
|
var LPAREN471 = null;
|
|
var RPAREN472 = null;
|
|
|
|
var NODE470_tree=null;
|
|
var LPAREN471_tree=null;
|
|
var RPAREN472_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1053:9: ( NODE LPAREN RPAREN )
|
|
// XQueryParser.g:1053:13: NODE LPAREN RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
NODE470=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_AnyKindTest8962); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
NODE470_tree = this.adaptor.create(NODE470);
|
|
this.adaptor.addChild(root_0, NODE470_tree);
|
|
}
|
|
LPAREN471=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_AnyKindTest8964); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN471_tree = this.adaptor.create(LPAREN471);
|
|
this.adaptor.addChild(root_0, LPAREN471_tree);
|
|
}
|
|
RPAREN472=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_AnyKindTest8966); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN472_tree = this.adaptor.create(RPAREN472);
|
|
this.adaptor.addChild(root_0, RPAREN472_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DocumentTest_return: (function() {
|
|
XQueryParser.p_DocumentTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DocumentTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1057:1: p_DocumentTest : DOCUMENT_NODE LPAREN ( p_ElementTest | p_SchemaElementTest )? RPAREN ;
|
|
// $ANTLR start "p_DocumentTest"
|
|
p_DocumentTest: function() {
|
|
var retval = new XQueryParser.p_DocumentTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOCUMENT_NODE473 = null;
|
|
var LPAREN474 = null;
|
|
var RPAREN477 = null;
|
|
var p_ElementTest475 = null;
|
|
var p_SchemaElementTest476 = null;
|
|
|
|
var DOCUMENT_NODE473_tree=null;
|
|
var LPAREN474_tree=null;
|
|
var RPAREN477_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1058:9: ( DOCUMENT_NODE LPAREN ( p_ElementTest | p_SchemaElementTest )? RPAREN )
|
|
// XQueryParser.g:1058:13: DOCUMENT_NODE LPAREN ( p_ElementTest | p_SchemaElementTest )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DOCUMENT_NODE473=this.match(this.input,DOCUMENT_NODE,XQueryParser.FOLLOW_DOCUMENT_NODE_in_p_DocumentTest8994); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOCUMENT_NODE473_tree = this.adaptor.create(DOCUMENT_NODE473);
|
|
this.adaptor.addChild(root_0, DOCUMENT_NODE473_tree);
|
|
}
|
|
LPAREN474=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_DocumentTest8996); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN474_tree = this.adaptor.create(LPAREN474);
|
|
this.adaptor.addChild(root_0, LPAREN474_tree);
|
|
}
|
|
// XQueryParser.g:1058:34: ( p_ElementTest | p_SchemaElementTest )?
|
|
var alt158=3;
|
|
var LA158_0 = this.input.LA(1);
|
|
|
|
if ( (LA158_0==ELEMENT) ) {
|
|
alt158=1;
|
|
}
|
|
else if ( (LA158_0==SCHEMA_ELEMENT) ) {
|
|
alt158=2;
|
|
}
|
|
switch (alt158) {
|
|
case 1 :
|
|
// XQueryParser.g:1058:35: p_ElementTest
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElementTest_in_p_DocumentTest8999);
|
|
p_ElementTest475=this.p_ElementTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElementTest475.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1058:51: p_SchemaElementTest
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SchemaElementTest_in_p_DocumentTest9003);
|
|
p_SchemaElementTest476=this.p_SchemaElementTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SchemaElementTest476.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN477=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_DocumentTest9007); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN477_tree = this.adaptor.create(RPAREN477);
|
|
this.adaptor.addChild(root_0, RPAREN477_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TextTest_return: (function() {
|
|
XQueryParser.p_TextTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TextTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1061:1: p_TextTest : TEXT LPAREN RPAREN ;
|
|
// $ANTLR start "p_TextTest"
|
|
p_TextTest: function() {
|
|
var retval = new XQueryParser.p_TextTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var TEXT478 = null;
|
|
var LPAREN479 = null;
|
|
var RPAREN480 = null;
|
|
|
|
var TEXT478_tree=null;
|
|
var LPAREN479_tree=null;
|
|
var RPAREN480_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1062:9: ( TEXT LPAREN RPAREN )
|
|
// XQueryParser.g:1062:13: TEXT LPAREN RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
TEXT478=this.match(this.input,TEXT,XQueryParser.FOLLOW_TEXT_in_p_TextTest9027); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
TEXT478_tree = this.adaptor.create(TEXT478);
|
|
this.adaptor.addChild(root_0, TEXT478_tree);
|
|
}
|
|
LPAREN479=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_TextTest9029); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN479_tree = this.adaptor.create(LPAREN479);
|
|
this.adaptor.addChild(root_0, LPAREN479_tree);
|
|
}
|
|
RPAREN480=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_TextTest9031); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN480_tree = this.adaptor.create(RPAREN480);
|
|
this.adaptor.addChild(root_0, RPAREN480_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CommentTest_return: (function() {
|
|
XQueryParser.p_CommentTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CommentTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1066:1: p_CommentTest : COMMENT LPAREN RPAREN ;
|
|
// $ANTLR start "p_CommentTest"
|
|
p_CommentTest: function() {
|
|
var retval = new XQueryParser.p_CommentTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMENT481 = null;
|
|
var LPAREN482 = null;
|
|
var RPAREN483 = null;
|
|
|
|
var COMMENT481_tree=null;
|
|
var LPAREN482_tree=null;
|
|
var RPAREN483_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1067:9: ( COMMENT LPAREN RPAREN )
|
|
// XQueryParser.g:1067:13: COMMENT LPAREN RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
COMMENT481=this.match(this.input,COMMENT,XQueryParser.FOLLOW_COMMENT_in_p_CommentTest9059); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMENT481_tree = this.adaptor.create(COMMENT481);
|
|
this.adaptor.addChild(root_0, COMMENT481_tree);
|
|
}
|
|
LPAREN482=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_CommentTest9061); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN482_tree = this.adaptor.create(LPAREN482);
|
|
this.adaptor.addChild(root_0, LPAREN482_tree);
|
|
}
|
|
RPAREN483=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_CommentTest9063); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN483_tree = this.adaptor.create(RPAREN483);
|
|
this.adaptor.addChild(root_0, RPAREN483_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NamespaceNodeTest_return: (function() {
|
|
XQueryParser.p_NamespaceNodeTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NamespaceNodeTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1071:1: p_NamespaceNodeTest : NAMESPACE_NODE LPAREN RPAREN ;
|
|
// $ANTLR start "p_NamespaceNodeTest"
|
|
p_NamespaceNodeTest: function() {
|
|
var retval = new XQueryParser.p_NamespaceNodeTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var NAMESPACE_NODE484 = null;
|
|
var LPAREN485 = null;
|
|
var RPAREN486 = null;
|
|
|
|
var NAMESPACE_NODE484_tree=null;
|
|
var LPAREN485_tree=null;
|
|
var RPAREN486_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1072:9: ( NAMESPACE_NODE LPAREN RPAREN )
|
|
// XQueryParser.g:1072:11: NAMESPACE_NODE LPAREN RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
NAMESPACE_NODE484=this.match(this.input,NAMESPACE_NODE,XQueryParser.FOLLOW_NAMESPACE_NODE_in_p_NamespaceNodeTest9089); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
NAMESPACE_NODE484_tree = this.adaptor.create(NAMESPACE_NODE484);
|
|
this.adaptor.addChild(root_0, NAMESPACE_NODE484_tree);
|
|
}
|
|
LPAREN485=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_NamespaceNodeTest9091); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN485_tree = this.adaptor.create(LPAREN485);
|
|
this.adaptor.addChild(root_0, LPAREN485_tree);
|
|
}
|
|
RPAREN486=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_NamespaceNodeTest9093); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN486_tree = this.adaptor.create(RPAREN486);
|
|
this.adaptor.addChild(root_0, RPAREN486_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_PITest_return: (function() {
|
|
XQueryParser.p_PITest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_PITest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1076:1: p_PITest : PROCESSING_INSTRUCTION LPAREN ( p_NCName | p_StringLiteral )? RPAREN ;
|
|
// $ANTLR start "p_PITest"
|
|
p_PITest: function() {
|
|
var retval = new XQueryParser.p_PITest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var PROCESSING_INSTRUCTION487 = null;
|
|
var LPAREN488 = null;
|
|
var RPAREN491 = null;
|
|
var p_NCName489 = null;
|
|
var p_StringLiteral490 = null;
|
|
|
|
var PROCESSING_INSTRUCTION487_tree=null;
|
|
var LPAREN488_tree=null;
|
|
var RPAREN491_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1077:9: ( PROCESSING_INSTRUCTION LPAREN ( p_NCName | p_StringLiteral )? RPAREN )
|
|
// XQueryParser.g:1077:13: PROCESSING_INSTRUCTION LPAREN ( p_NCName | p_StringLiteral )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
PROCESSING_INSTRUCTION487=this.match(this.input,PROCESSING_INSTRUCTION,XQueryParser.FOLLOW_PROCESSING_INSTRUCTION_in_p_PITest9121); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
PROCESSING_INSTRUCTION487_tree = this.adaptor.create(PROCESSING_INSTRUCTION487);
|
|
this.adaptor.addChild(root_0, PROCESSING_INSTRUCTION487_tree);
|
|
}
|
|
LPAREN488=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_PITest9123); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN488_tree = this.adaptor.create(LPAREN488);
|
|
this.adaptor.addChild(root_0, LPAREN488_tree);
|
|
}
|
|
// XQueryParser.g:1077:43: ( p_NCName | p_StringLiteral )?
|
|
var alt159=3;
|
|
var LA159_0 = this.input.LA(1);
|
|
|
|
if ( ((LA159_0>=ANCESTOR && LA159_0<=EXIT)||(LA159_0>=SEQUENTIAL && LA159_0<=MAINTAINED)||(LA159_0>=MUTABLE && LA159_0<=QUOT_ER)||LA159_0==L_NCName||LA159_0==EXPLICITLY) ) {
|
|
alt159=1;
|
|
}
|
|
else if ( ((LA159_0>=APOS && LA159_0<=QUOT)) ) {
|
|
alt159=2;
|
|
}
|
|
switch (alt159) {
|
|
case 1 :
|
|
// XQueryParser.g:1077:44: p_NCName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_PITest9126);
|
|
p_NCName489=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName489.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1077:55: p_StringLiteral
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_PITest9130);
|
|
p_StringLiteral490=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral490.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN491=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_PITest9134); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN491_tree = this.adaptor.create(RPAREN491);
|
|
this.adaptor.addChild(root_0, RPAREN491_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AttributeTest_return: (function() {
|
|
XQueryParser.p_AttributeTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AttributeTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1081:1: p_AttributeTest : ATTRIBUTE LPAREN ( p_AttribNameOrWildcard ( COMMA p_TypeName )? )? RPAREN ;
|
|
// $ANTLR start "p_AttributeTest"
|
|
p_AttributeTest: function() {
|
|
var retval = new XQueryParser.p_AttributeTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ATTRIBUTE492 = null;
|
|
var LPAREN493 = null;
|
|
var COMMA495 = null;
|
|
var RPAREN497 = null;
|
|
var p_AttribNameOrWildcard494 = null;
|
|
var p_TypeName496 = null;
|
|
|
|
var ATTRIBUTE492_tree=null;
|
|
var LPAREN493_tree=null;
|
|
var COMMA495_tree=null;
|
|
var RPAREN497_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1082:9: ( ATTRIBUTE LPAREN ( p_AttribNameOrWildcard ( COMMA p_TypeName )? )? RPAREN )
|
|
// XQueryParser.g:1082:13: ATTRIBUTE LPAREN ( p_AttribNameOrWildcard ( COMMA p_TypeName )? )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ATTRIBUTE492=this.match(this.input,ATTRIBUTE,XQueryParser.FOLLOW_ATTRIBUTE_in_p_AttributeTest9162); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ATTRIBUTE492_tree = this.adaptor.create(ATTRIBUTE492);
|
|
this.adaptor.addChild(root_0, ATTRIBUTE492_tree);
|
|
}
|
|
LPAREN493=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_AttributeTest9164); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN493_tree = this.adaptor.create(LPAREN493);
|
|
this.adaptor.addChild(root_0, LPAREN493_tree);
|
|
}
|
|
// XQueryParser.g:1082:30: ( p_AttribNameOrWildcard ( COMMA p_TypeName )? )?
|
|
var alt161=2;
|
|
var LA161_0 = this.input.LA(1);
|
|
|
|
if ( ((LA161_0>=ANCESTOR && LA161_0<=EXIT)||(LA161_0>=SEQUENTIAL && LA161_0<=MAINTAINED)||(LA161_0>=MUTABLE && LA161_0<=QUOT_ER)||LA161_0==STAR||LA161_0==L_NCName||LA161_0==EXPLICITLY) ) {
|
|
alt161=1;
|
|
}
|
|
switch (alt161) {
|
|
case 1 :
|
|
// XQueryParser.g:1082:31: p_AttribNameOrWildcard ( COMMA p_TypeName )?
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AttribNameOrWildcard_in_p_AttributeTest9167);
|
|
p_AttribNameOrWildcard494=this.p_AttribNameOrWildcard();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AttribNameOrWildcard494.getTree());
|
|
// XQueryParser.g:1082:54: ( COMMA p_TypeName )?
|
|
var alt160=2;
|
|
var LA160_0 = this.input.LA(1);
|
|
|
|
if ( (LA160_0==COMMA) ) {
|
|
alt160=1;
|
|
}
|
|
switch (alt160) {
|
|
case 1 :
|
|
// XQueryParser.g:1082:55: COMMA p_TypeName
|
|
COMMA495=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_AttributeTest9170); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA495_tree = this.adaptor.create(COMMA495);
|
|
this.adaptor.addChild(root_0, COMMA495_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeName_in_p_AttributeTest9172);
|
|
p_TypeName496=this.p_TypeName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeName496.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN497=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_AttributeTest9178); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN497_tree = this.adaptor.create(RPAREN497);
|
|
this.adaptor.addChild(root_0, RPAREN497_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AttribNameOrWildcard_return: (function() {
|
|
XQueryParser.p_AttribNameOrWildcard_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AttribNameOrWildcard_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1086:1: p_AttribNameOrWildcard : ( p_QName | STAR );
|
|
// $ANTLR start "p_AttribNameOrWildcard"
|
|
p_AttribNameOrWildcard: function() {
|
|
var retval = new XQueryParser.p_AttribNameOrWildcard_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var STAR499 = null;
|
|
var p_QName498 = null;
|
|
|
|
var STAR499_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1087:9: ( p_QName | STAR )
|
|
var alt162=2;
|
|
var LA162_0 = this.input.LA(1);
|
|
|
|
if ( ((LA162_0>=ANCESTOR && LA162_0<=EXIT)||(LA162_0>=SEQUENTIAL && LA162_0<=MAINTAINED)||(LA162_0>=MUTABLE && LA162_0<=QUOT_ER)||LA162_0==L_NCName||LA162_0==EXPLICITLY) ) {
|
|
alt162=1;
|
|
}
|
|
else if ( (LA162_0==STAR) ) {
|
|
alt162=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 162, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt162) {
|
|
case 1 :
|
|
// XQueryParser.g:1087:13: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_AttribNameOrWildcard9208);
|
|
p_QName498=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName498.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1087:23: STAR
|
|
root_0 = this.adaptor.nil();
|
|
|
|
STAR499=this.match(this.input,STAR,XQueryParser.FOLLOW_STAR_in_p_AttribNameOrWildcard9212); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
STAR499_tree = this.adaptor.create(STAR499);
|
|
this.adaptor.addChild(root_0, STAR499_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SchemaAttributeTest_return: (function() {
|
|
XQueryParser.p_SchemaAttributeTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SchemaAttributeTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1091:1: p_SchemaAttributeTest : SCHEMA_ATTRIBUTE LPAREN p_AttributeDeclaration RPAREN ;
|
|
// $ANTLR start "p_SchemaAttributeTest"
|
|
p_SchemaAttributeTest: function() {
|
|
var retval = new XQueryParser.p_SchemaAttributeTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SCHEMA_ATTRIBUTE500 = null;
|
|
var LPAREN501 = null;
|
|
var RPAREN503 = null;
|
|
var p_AttributeDeclaration502 = null;
|
|
|
|
var SCHEMA_ATTRIBUTE500_tree=null;
|
|
var LPAREN501_tree=null;
|
|
var RPAREN503_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1092:9: ( SCHEMA_ATTRIBUTE LPAREN p_AttributeDeclaration RPAREN )
|
|
// XQueryParser.g:1092:13: SCHEMA_ATTRIBUTE LPAREN p_AttributeDeclaration RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
SCHEMA_ATTRIBUTE500=this.match(this.input,SCHEMA_ATTRIBUTE,XQueryParser.FOLLOW_SCHEMA_ATTRIBUTE_in_p_SchemaAttributeTest9240); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SCHEMA_ATTRIBUTE500_tree = this.adaptor.create(SCHEMA_ATTRIBUTE500);
|
|
this.adaptor.addChild(root_0, SCHEMA_ATTRIBUTE500_tree);
|
|
}
|
|
LPAREN501=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_SchemaAttributeTest9242); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN501_tree = this.adaptor.create(LPAREN501);
|
|
this.adaptor.addChild(root_0, LPAREN501_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AttributeDeclaration_in_p_SchemaAttributeTest9244);
|
|
p_AttributeDeclaration502=this.p_AttributeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AttributeDeclaration502.getTree());
|
|
RPAREN503=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_SchemaAttributeTest9246); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN503_tree = this.adaptor.create(RPAREN503);
|
|
this.adaptor.addChild(root_0, RPAREN503_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AttributeDeclaration_return: (function() {
|
|
XQueryParser.p_AttributeDeclaration_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AttributeDeclaration_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1096:1: p_AttributeDeclaration : p_AttributeName ;
|
|
// $ANTLR start "p_AttributeDeclaration"
|
|
p_AttributeDeclaration: function() {
|
|
var retval = new XQueryParser.p_AttributeDeclaration_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_AttributeName504 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1097:9: ( p_AttributeName )
|
|
// XQueryParser.g:1097:11: p_AttributeName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AttributeName_in_p_AttributeDeclaration9272);
|
|
p_AttributeName504=this.p_AttributeName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AttributeName504.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ElementTest_return: (function() {
|
|
XQueryParser.p_ElementTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ElementTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1101:1: p_ElementTest : ELEMENT LPAREN ( p_ElementNameOrWildcard ( COMMA p_TypeName ( QUESTION )? )? )? RPAREN ;
|
|
// $ANTLR start "p_ElementTest"
|
|
p_ElementTest: function() {
|
|
var retval = new XQueryParser.p_ElementTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ELEMENT505 = null;
|
|
var LPAREN506 = null;
|
|
var COMMA508 = null;
|
|
var QUESTION510 = null;
|
|
var RPAREN511 = null;
|
|
var p_ElementNameOrWildcard507 = null;
|
|
var p_TypeName509 = null;
|
|
|
|
var ELEMENT505_tree=null;
|
|
var LPAREN506_tree=null;
|
|
var COMMA508_tree=null;
|
|
var QUESTION510_tree=null;
|
|
var RPAREN511_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1102:9: ( ELEMENT LPAREN ( p_ElementNameOrWildcard ( COMMA p_TypeName ( QUESTION )? )? )? RPAREN )
|
|
// XQueryParser.g:1102:13: ELEMENT LPAREN ( p_ElementNameOrWildcard ( COMMA p_TypeName ( QUESTION )? )? )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ELEMENT505=this.match(this.input,ELEMENT,XQueryParser.FOLLOW_ELEMENT_in_p_ElementTest9300); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ELEMENT505_tree = this.adaptor.create(ELEMENT505);
|
|
this.adaptor.addChild(root_0, ELEMENT505_tree);
|
|
}
|
|
LPAREN506=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_ElementTest9302); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN506_tree = this.adaptor.create(LPAREN506);
|
|
this.adaptor.addChild(root_0, LPAREN506_tree);
|
|
}
|
|
// XQueryParser.g:1102:28: ( p_ElementNameOrWildcard ( COMMA p_TypeName ( QUESTION )? )? )?
|
|
var alt165=2;
|
|
var LA165_0 = this.input.LA(1);
|
|
|
|
if ( ((LA165_0>=ANCESTOR && LA165_0<=EXIT)||(LA165_0>=SEQUENTIAL && LA165_0<=MAINTAINED)||(LA165_0>=MUTABLE && LA165_0<=QUOT_ER)||LA165_0==STAR||LA165_0==L_NCName||LA165_0==EXPLICITLY) ) {
|
|
alt165=1;
|
|
}
|
|
switch (alt165) {
|
|
case 1 :
|
|
// XQueryParser.g:1102:29: p_ElementNameOrWildcard ( COMMA p_TypeName ( QUESTION )? )?
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElementNameOrWildcard_in_p_ElementTest9305);
|
|
p_ElementNameOrWildcard507=this.p_ElementNameOrWildcard();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElementNameOrWildcard507.getTree());
|
|
// XQueryParser.g:1102:53: ( COMMA p_TypeName ( QUESTION )? )?
|
|
var alt164=2;
|
|
var LA164_0 = this.input.LA(1);
|
|
|
|
if ( (LA164_0==COMMA) ) {
|
|
alt164=1;
|
|
}
|
|
switch (alt164) {
|
|
case 1 :
|
|
// XQueryParser.g:1102:54: COMMA p_TypeName ( QUESTION )?
|
|
COMMA508=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_ElementTest9308); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA508_tree = this.adaptor.create(COMMA508);
|
|
this.adaptor.addChild(root_0, COMMA508_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeName_in_p_ElementTest9310);
|
|
p_TypeName509=this.p_TypeName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TypeName509.getTree());
|
|
// XQueryParser.g:1102:71: ( QUESTION )?
|
|
var alt163=2;
|
|
var LA163_0 = this.input.LA(1);
|
|
|
|
if ( (LA163_0==QUESTION) ) {
|
|
alt163=1;
|
|
}
|
|
switch (alt163) {
|
|
case 1 :
|
|
// XQueryParser.g:1102:71: QUESTION
|
|
QUESTION510=this.match(this.input,QUESTION,XQueryParser.FOLLOW_QUESTION_in_p_ElementTest9312); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
QUESTION510_tree = this.adaptor.create(QUESTION510);
|
|
this.adaptor.addChild(root_0, QUESTION510_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN511=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_ElementTest9319); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN511_tree = this.adaptor.create(RPAREN511);
|
|
this.adaptor.addChild(root_0, RPAREN511_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ElementNameOrWildcard_return: (function() {
|
|
XQueryParser.p_ElementNameOrWildcard_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ElementNameOrWildcard_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1106:1: p_ElementNameOrWildcard : ( p_QName | STAR );
|
|
// $ANTLR start "p_ElementNameOrWildcard"
|
|
p_ElementNameOrWildcard: function() {
|
|
var retval = new XQueryParser.p_ElementNameOrWildcard_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var STAR513 = null;
|
|
var p_QName512 = null;
|
|
|
|
var STAR513_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1107:9: ( p_QName | STAR )
|
|
var alt166=2;
|
|
var LA166_0 = this.input.LA(1);
|
|
|
|
if ( ((LA166_0>=ANCESTOR && LA166_0<=EXIT)||(LA166_0>=SEQUENTIAL && LA166_0<=MAINTAINED)||(LA166_0>=MUTABLE && LA166_0<=QUOT_ER)||LA166_0==L_NCName||LA166_0==EXPLICITLY) ) {
|
|
alt166=1;
|
|
}
|
|
else if ( (LA166_0==STAR) ) {
|
|
alt166=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 166, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt166) {
|
|
case 1 :
|
|
// XQueryParser.g:1107:13: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ElementNameOrWildcard9347);
|
|
p_QName512=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName512.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1107:23: STAR
|
|
root_0 = this.adaptor.nil();
|
|
|
|
STAR513=this.match(this.input,STAR,XQueryParser.FOLLOW_STAR_in_p_ElementNameOrWildcard9351); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
STAR513_tree = this.adaptor.create(STAR513);
|
|
this.adaptor.addChild(root_0, STAR513_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SchemaElementTest_return: (function() {
|
|
XQueryParser.p_SchemaElementTest_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SchemaElementTest_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1110:1: p_SchemaElementTest : SCHEMA_ELEMENT LPAREN p_ElementDeclaration RPAREN ;
|
|
// $ANTLR start "p_SchemaElementTest"
|
|
p_SchemaElementTest: function() {
|
|
var retval = new XQueryParser.p_SchemaElementTest_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SCHEMA_ELEMENT514 = null;
|
|
var LPAREN515 = null;
|
|
var RPAREN517 = null;
|
|
var p_ElementDeclaration516 = null;
|
|
|
|
var SCHEMA_ELEMENT514_tree=null;
|
|
var LPAREN515_tree=null;
|
|
var RPAREN517_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1111:9: ( SCHEMA_ELEMENT LPAREN p_ElementDeclaration RPAREN )
|
|
// XQueryParser.g:1111:13: SCHEMA_ELEMENT LPAREN p_ElementDeclaration RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
SCHEMA_ELEMENT514=this.match(this.input,SCHEMA_ELEMENT,XQueryParser.FOLLOW_SCHEMA_ELEMENT_in_p_SchemaElementTest9371); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SCHEMA_ELEMENT514_tree = this.adaptor.create(SCHEMA_ELEMENT514);
|
|
this.adaptor.addChild(root_0, SCHEMA_ELEMENT514_tree);
|
|
}
|
|
LPAREN515=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_SchemaElementTest9373); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN515_tree = this.adaptor.create(LPAREN515);
|
|
this.adaptor.addChild(root_0, LPAREN515_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElementDeclaration_in_p_SchemaElementTest9375);
|
|
p_ElementDeclaration516=this.p_ElementDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElementDeclaration516.getTree());
|
|
RPAREN517=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_SchemaElementTest9377); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN517_tree = this.adaptor.create(RPAREN517);
|
|
this.adaptor.addChild(root_0, RPAREN517_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ElementDeclaration_return: (function() {
|
|
XQueryParser.p_ElementDeclaration_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ElementDeclaration_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1115:1: p_ElementDeclaration : p_ElementName ;
|
|
// $ANTLR start "p_ElementDeclaration"
|
|
p_ElementDeclaration: function() {
|
|
var retval = new XQueryParser.p_ElementDeclaration_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ElementName518 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1116:9: ( p_ElementName )
|
|
// XQueryParser.g:1116:11: p_ElementName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ElementName_in_p_ElementDeclaration9403);
|
|
p_ElementName518=this.p_ElementName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ElementName518.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AttributeName_return: (function() {
|
|
XQueryParser.p_AttributeName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AttributeName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1120:1: p_AttributeName : p_QName ;
|
|
// $ANTLR start "p_AttributeName"
|
|
p_AttributeName: function() {
|
|
var retval = new XQueryParser.p_AttributeName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName519 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1121:9: ( p_QName )
|
|
// XQueryParser.g:1121:13: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_AttributeName9431);
|
|
p_QName519=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName519.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ElementName_return: (function() {
|
|
XQueryParser.p_ElementName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ElementName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1125:1: p_ElementName : p_QName ;
|
|
// $ANTLR start "p_ElementName"
|
|
p_ElementName: function() {
|
|
var retval = new XQueryParser.p_ElementName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName520 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1126:9: ( p_QName )
|
|
// XQueryParser.g:1126:13: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ElementName9459);
|
|
p_QName520=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName520.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TypeName_return: (function() {
|
|
XQueryParser.p_TypeName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TypeName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1130:1: p_TypeName : p_QName ;
|
|
// $ANTLR start "p_TypeName"
|
|
p_TypeName: function() {
|
|
var retval = new XQueryParser.p_TypeName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName521 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1131:9: ( p_QName )
|
|
// XQueryParser.g:1131:13: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_TypeName9487);
|
|
p_QName521=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName521.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TryCatchExpr_return: (function() {
|
|
XQueryParser.p_TryCatchExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TryCatchExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1141:1: p_TryCatchExpr : p_TryClause ( p_CatchClause )+ ;
|
|
// $ANTLR start "p_TryCatchExpr"
|
|
p_TryCatchExpr: function() {
|
|
var retval = new XQueryParser.p_TryCatchExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_TryClause522 = null;
|
|
var p_CatchClause523 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1142:9: ( p_TryClause ( p_CatchClause )+ )
|
|
// XQueryParser.g:1142:11: p_TryClause ( p_CatchClause )+
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TryClause_in_p_TryCatchExpr9519);
|
|
p_TryClause522=this.p_TryClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TryClause522.getTree());
|
|
// XQueryParser.g:1142:23: ( p_CatchClause )+
|
|
var cnt167=0;
|
|
loop167:
|
|
do {
|
|
var alt167=2;
|
|
var LA167_0 = this.input.LA(1);
|
|
|
|
if ( (LA167_0==CATCH) ) {
|
|
alt167=1;
|
|
}
|
|
|
|
|
|
switch (alt167) {
|
|
case 1 :
|
|
// XQueryParser.g:1142:23: p_CatchClause
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CatchClause_in_p_TryCatchExpr9521);
|
|
p_CatchClause523=this.p_CatchClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CatchClause523.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
if ( cnt167 >= 1 ) {
|
|
break loop167;
|
|
}
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var eee = new org.antlr.runtime.EarlyExitException(167, this.input);
|
|
throw eee;
|
|
}
|
|
cnt167++;
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TryClause_return: (function() {
|
|
XQueryParser.p_TryClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TryClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1146:1: p_TryClause : kc= TRY LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_TryClause"
|
|
p_TryClause: function() {
|
|
var retval = new XQueryParser.p_TryClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var LBRACKET524 = null;
|
|
var RBRACKET526 = null;
|
|
var pm_Expr525 = null;
|
|
|
|
var kc_tree=null;
|
|
var LBRACKET524_tree=null;
|
|
var RBRACKET526_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1147:9: (kc= TRY LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:1147:11: kc= TRY LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kc=this.match(this.input,TRY,XQueryParser.FOLLOW_TRY_in_p_TryClause9550); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
LBRACKET524=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_TryClause9552); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET524_tree = this.adaptor.create(LBRACKET524);
|
|
this.adaptor.addChild(root_0, LBRACKET524_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_TryClause9554);
|
|
pm_Expr525=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr525.getTree());
|
|
RBRACKET526=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_TryClause9556); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET526_tree = this.adaptor.create(RBRACKET526);
|
|
this.adaptor.addChild(root_0, RBRACKET526_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CatchClause_return: (function() {
|
|
XQueryParser.p_CatchClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CatchClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1154:1: p_CatchClause : kc= CATCH p_CatchErrorList ( p_CatchVars )? LBRACKET pm_Expr RBRACKET ;
|
|
// $ANTLR start "p_CatchClause"
|
|
p_CatchClause: function() {
|
|
var retval = new XQueryParser.p_CatchClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var LBRACKET529 = null;
|
|
var RBRACKET531 = null;
|
|
var p_CatchErrorList527 = null;
|
|
var p_CatchVars528 = null;
|
|
var pm_Expr530 = null;
|
|
|
|
var kc_tree=null;
|
|
var LBRACKET529_tree=null;
|
|
var RBRACKET531_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1155:9: (kc= CATCH p_CatchErrorList ( p_CatchVars )? LBRACKET pm_Expr RBRACKET )
|
|
// XQueryParser.g:1155:11: kc= CATCH p_CatchErrorList ( p_CatchVars )? LBRACKET pm_Expr RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kc=this.match(this.input,CATCH,XQueryParser.FOLLOW_CATCH_in_p_CatchClause9587); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CatchErrorList_in_p_CatchClause9589);
|
|
p_CatchErrorList527=this.p_CatchErrorList();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CatchErrorList527.getTree());
|
|
// XQueryParser.g:1155:37: ( p_CatchVars )?
|
|
var alt168=2;
|
|
var LA168_0 = this.input.LA(1);
|
|
|
|
if ( (LA168_0==LPAREN) ) {
|
|
alt168=1;
|
|
}
|
|
switch (alt168) {
|
|
case 1 :
|
|
// XQueryParser.g:1155:37: p_CatchVars
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CatchVars_in_p_CatchClause9591);
|
|
p_CatchVars528=this.p_CatchVars();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CatchVars528.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LBRACKET529=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_CatchClause9594); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET529_tree = this.adaptor.create(LBRACKET529);
|
|
this.adaptor.addChild(root_0, LBRACKET529_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_CatchClause9596);
|
|
pm_Expr530=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr530.getTree());
|
|
RBRACKET531=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_CatchClause9598); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET531_tree = this.adaptor.create(RBRACKET531);
|
|
this.adaptor.addChild(root_0, RBRACKET531_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CatchErrorList_return: (function() {
|
|
XQueryParser.p_CatchErrorList_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CatchErrorList_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1159:1: p_CatchErrorList : ( p_NameTest ( VBAR p_NameTest )* | {...}? => () );
|
|
// $ANTLR start "p_CatchErrorList"
|
|
p_CatchErrorList: function() {
|
|
var retval = new XQueryParser.p_CatchErrorList_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var VBAR533 = null;
|
|
var p_NameTest532 = null;
|
|
var p_NameTest534 = null;
|
|
|
|
var VBAR533_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1160:9: ( p_NameTest ( VBAR p_NameTest )* | {...}? => () )
|
|
var alt170=2;
|
|
var LA170_0 = this.input.LA(1);
|
|
|
|
if ( ((LA170_0>=ANCESTOR && LA170_0<=EXIT)||(LA170_0>=SEQUENTIAL && LA170_0<=MAINTAINED)||(LA170_0>=MUTABLE && LA170_0<=QUOT_ER)||LA170_0==STAR||LA170_0==L_NCName||LA170_0==EXPLICITLY) ) {
|
|
alt170=1;
|
|
}
|
|
else if ( (LA170_0==LPAREN||LA170_0==LBRACKET) && ((false))) {
|
|
alt170=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 170, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt170) {
|
|
case 1 :
|
|
// XQueryParser.g:1160:11: p_NameTest ( VBAR p_NameTest )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NameTest_in_p_CatchErrorList9624);
|
|
p_NameTest532=this.p_NameTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NameTest532.getTree());
|
|
// XQueryParser.g:1160:22: ( VBAR p_NameTest )*
|
|
loop169:
|
|
do {
|
|
var alt169=2;
|
|
var LA169_0 = this.input.LA(1);
|
|
|
|
if ( (LA169_0==VBAR) ) {
|
|
alt169=1;
|
|
}
|
|
|
|
|
|
switch (alt169) {
|
|
case 1 :
|
|
// XQueryParser.g:1160:23: VBAR p_NameTest
|
|
VBAR533=this.match(this.input,VBAR,XQueryParser.FOLLOW_VBAR_in_p_CatchErrorList9627); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
VBAR533_tree = this.adaptor.create(VBAR533);
|
|
this.adaptor.addChild(root_0, VBAR533_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NameTest_in_p_CatchErrorList9629);
|
|
p_NameTest534=this.p_NameTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NameTest534.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop169;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1161:11: {...}? => ()
|
|
root_0 = this.adaptor.nil();
|
|
|
|
if ( !((false)) ) {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
throw new org.antlr.runtime.FailedPredicateException(this.input, "p_CatchErrorList", "false");
|
|
}
|
|
// XQueryParser.g:1161:22: ()
|
|
// XQueryParser.g:1161:36:
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CatchVars_return: (function() {
|
|
XQueryParser.p_CatchVars_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CatchVars_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1165:2: p_CatchVars : LPAREN DOLLAR p_VarName ( COMMA DOLLAR p_VarName ( COMMA DOLLAR p_VarName )? )? RPAREN ;
|
|
// $ANTLR start "p_CatchVars"
|
|
p_CatchVars: function() {
|
|
var retval = new XQueryParser.p_CatchVars_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LPAREN535 = null;
|
|
var DOLLAR536 = null;
|
|
var COMMA538 = null;
|
|
var DOLLAR539 = null;
|
|
var COMMA541 = null;
|
|
var DOLLAR542 = null;
|
|
var RPAREN544 = null;
|
|
var p_VarName537 = null;
|
|
var p_VarName540 = null;
|
|
var p_VarName543 = null;
|
|
|
|
var LPAREN535_tree=null;
|
|
var DOLLAR536_tree=null;
|
|
var COMMA538_tree=null;
|
|
var DOLLAR539_tree=null;
|
|
var COMMA541_tree=null;
|
|
var DOLLAR542_tree=null;
|
|
var RPAREN544_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1166:9: ( LPAREN DOLLAR p_VarName ( COMMA DOLLAR p_VarName ( COMMA DOLLAR p_VarName )? )? RPAREN )
|
|
// XQueryParser.g:1166:11: LPAREN DOLLAR p_VarName ( COMMA DOLLAR p_VarName ( COMMA DOLLAR p_VarName )? )? RPAREN
|
|
root_0 = this.adaptor.nil();
|
|
|
|
LPAREN535=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_CatchVars9675); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN535_tree = this.adaptor.create(LPAREN535);
|
|
this.adaptor.addChild(root_0, LPAREN535_tree);
|
|
}
|
|
DOLLAR536=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_CatchVars9677); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR536_tree = this.adaptor.create(DOLLAR536);
|
|
this.adaptor.addChild(root_0, DOLLAR536_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_CatchVars9679);
|
|
p_VarName537=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName537.getTree());
|
|
// XQueryParser.g:1166:35: ( COMMA DOLLAR p_VarName ( COMMA DOLLAR p_VarName )? )?
|
|
var alt172=2;
|
|
var LA172_0 = this.input.LA(1);
|
|
|
|
if ( (LA172_0==COMMA) ) {
|
|
alt172=1;
|
|
}
|
|
switch (alt172) {
|
|
case 1 :
|
|
// XQueryParser.g:1166:36: COMMA DOLLAR p_VarName ( COMMA DOLLAR p_VarName )?
|
|
COMMA538=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_CatchVars9682); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA538_tree = this.adaptor.create(COMMA538);
|
|
this.adaptor.addChild(root_0, COMMA538_tree);
|
|
}
|
|
DOLLAR539=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_CatchVars9684); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR539_tree = this.adaptor.create(DOLLAR539);
|
|
this.adaptor.addChild(root_0, DOLLAR539_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_CatchVars9686);
|
|
p_VarName540=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName540.getTree());
|
|
// XQueryParser.g:1166:59: ( COMMA DOLLAR p_VarName )?
|
|
var alt171=2;
|
|
var LA171_0 = this.input.LA(1);
|
|
|
|
if ( (LA171_0==COMMA) ) {
|
|
alt171=1;
|
|
}
|
|
switch (alt171) {
|
|
case 1 :
|
|
// XQueryParser.g:1166:60: COMMA DOLLAR p_VarName
|
|
COMMA541=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_CatchVars9689); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA541_tree = this.adaptor.create(COMMA541);
|
|
this.adaptor.addChild(root_0, COMMA541_tree);
|
|
}
|
|
DOLLAR542=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_CatchVars9691); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR542_tree = this.adaptor.create(DOLLAR542);
|
|
this.adaptor.addChild(root_0, DOLLAR542_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_CatchVars9693);
|
|
p_VarName543=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName543.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RPAREN544=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_CatchVars9699); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN544_tree = this.adaptor.create(RPAREN544);
|
|
this.adaptor.addChild(root_0, RPAREN544_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_StringLiteral_return: (function() {
|
|
XQueryParser.p_StringLiteral_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_StringLiteral_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1192:1: p_StringLiteral : ( QUOT p_QuotStringLiteralContent QUOT -> ^( StringLiteral ( p_QuotStringLiteralContent )* ) | APOS p_AposStringLiteralContent APOS -> ^( StringLiteral ( p_AposStringLiteralContent )* ) );
|
|
// $ANTLR start "p_StringLiteral"
|
|
p_StringLiteral: function() {
|
|
var retval = new XQueryParser.p_StringLiteral_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var QUOT545 = null;
|
|
var QUOT547 = null;
|
|
var APOS548 = null;
|
|
var APOS550 = null;
|
|
var p_QuotStringLiteralContent546 = null;
|
|
var p_AposStringLiteralContent549 = null;
|
|
|
|
var QUOT545_tree=null;
|
|
var QUOT547_tree=null;
|
|
var APOS548_tree=null;
|
|
var APOS550_tree=null;
|
|
var stream_APOS=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token APOS");
|
|
var stream_QUOT=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token QUOT");
|
|
var stream_p_AposStringLiteralContent=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_AposStringLiteralContent");
|
|
var stream_p_QuotStringLiteralContent=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_QuotStringLiteralContent");
|
|
try {
|
|
// XQueryParser.g:1193:9: ( QUOT p_QuotStringLiteralContent QUOT -> ^( StringLiteral ( p_QuotStringLiteralContent )* ) | APOS p_AposStringLiteralContent APOS -> ^( StringLiteral ( p_AposStringLiteralContent )* ) )
|
|
var alt173=2;
|
|
var LA173_0 = this.input.LA(1);
|
|
|
|
if ( (LA173_0==QUOT) ) {
|
|
alt173=1;
|
|
}
|
|
else if ( (LA173_0==APOS) ) {
|
|
alt173=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 173, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt173) {
|
|
case 1 :
|
|
// XQueryParser.g:1193:11: QUOT p_QuotStringLiteralContent QUOT
|
|
QUOT545=this.match(this.input,QUOT,XQueryParser.FOLLOW_QUOT_in_p_StringLiteral9748); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_QUOT.add(QUOT545);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
//pushStringLexer(false);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QuotStringLiteralContent_in_p_StringLiteral9752);
|
|
p_QuotStringLiteralContent546=this.p_QuotStringLiteralContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_QuotStringLiteralContent.add(p_QuotStringLiteralContent546.getTree());
|
|
QUOT547=this.match(this.input,QUOT,XQueryParser.FOLLOW_QUOT_in_p_StringLiteral9754); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_QUOT.add(QUOT547);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
}
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_QuotStringLiteralContent
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1194:17: -> ^( StringLiteral ( p_QuotStringLiteralContent )* )
|
|
{
|
|
// XQueryParser.g:1194:20: ^( StringLiteral ( p_QuotStringLiteralContent )* )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(StringLiteral, "StringLiteral"), root_1);
|
|
|
|
// XQueryParser.g:1194:36: ( p_QuotStringLiteralContent )*
|
|
while ( stream_p_QuotStringLiteralContent.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_p_QuotStringLiteralContent.nextTree());
|
|
|
|
}
|
|
stream_p_QuotStringLiteralContent.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1195:13: APOS p_AposStringLiteralContent APOS
|
|
APOS548=this.match(this.input,APOS,XQueryParser.FOLLOW_APOS_in_p_StringLiteral9795); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_APOS.add(APOS548);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
//pushStringLexer(true);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AposStringLiteralContent_in_p_StringLiteral9799);
|
|
p_AposStringLiteralContent549=this.p_AposStringLiteralContent();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_AposStringLiteralContent.add(p_AposStringLiteralContent549.getTree());
|
|
APOS550=this.match(this.input,APOS,XQueryParser.FOLLOW_APOS_in_p_StringLiteral9801); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_APOS.add(APOS550);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
}
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_AposStringLiteralContent
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1196:17: -> ^( StringLiteral ( p_AposStringLiteralContent )* )
|
|
{
|
|
// XQueryParser.g:1196:20: ^( StringLiteral ( p_AposStringLiteralContent )* )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(StringLiteral, "StringLiteral"), root_1);
|
|
|
|
// XQueryParser.g:1196:36: ( p_AposStringLiteralContent )*
|
|
while ( stream_p_AposStringLiteralContent.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_p_AposStringLiteralContent.nextTree());
|
|
|
|
}
|
|
stream_p_AposStringLiteralContent.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_QuotStringLiteralContent_return: (function() {
|
|
XQueryParser.p_QuotStringLiteralContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_QuotStringLiteralContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1203:1: p_QuotStringLiteralContent : ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( QUOT | AMP ) )* ;
|
|
// $ANTLR start "p_QuotStringLiteralContent"
|
|
p_QuotStringLiteralContent: function() {
|
|
var retval = new XQueryParser.p_QuotStringLiteralContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set551 = null;
|
|
|
|
var set551_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1204:9: ( ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( QUOT | AMP ) )* )
|
|
// XQueryParser.g:1204:11: ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( QUOT | AMP ) )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1204:11: ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( QUOT | AMP ) )*
|
|
loop174:
|
|
do {
|
|
var alt174=2;
|
|
var LA174_0 = this.input.LA(1);
|
|
|
|
if ( ((LA174_0>=L_QuotAttrContentChar && LA174_0<=NOTEQUAL)||(LA174_0>=COMMA && LA174_0<=APOS)||(LA174_0>=NCNameStartChar && LA174_0<=EXPLICITLY)) ) {
|
|
alt174=1;
|
|
}
|
|
|
|
|
|
switch (alt174) {
|
|
case 1 :
|
|
// XQueryParser.g:
|
|
set551=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=L_QuotAttrContentChar && this.input.LA(1)<=NOTEQUAL)||(this.input.LA(1)>=COMMA && this.input.LA(1)<=APOS)||(this.input.LA(1)>=NCNameStartChar && this.input.LA(1)<=EXPLICITLY) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set551));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop174;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AposStringLiteralContent_return: (function() {
|
|
XQueryParser.p_AposStringLiteralContent_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AposStringLiteralContent_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1212:1: p_AposStringLiteralContent : ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( APOS | AMP ) )* ;
|
|
// $ANTLR start "p_AposStringLiteralContent"
|
|
p_AposStringLiteralContent: function() {
|
|
var retval = new XQueryParser.p_AposStringLiteralContent_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set552 = null;
|
|
|
|
var set552_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1213:9: ( ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( APOS | AMP ) )* )
|
|
// XQueryParser.g:1213:11: ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( APOS | AMP ) )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1213:11: ( ESCAPE_QUOT | L_CharRef | L_PredefinedEntityRef | ~ ( APOS | AMP ) )*
|
|
loop175:
|
|
do {
|
|
var alt175=2;
|
|
var LA175_0 = this.input.LA(1);
|
|
|
|
if ( ((LA175_0>=L_QuotAttrContentChar && LA175_0<=NOTEQUAL)||(LA175_0>=COMMA && LA175_0<=CHARREF_HEX)||(LA175_0>=QUOT && LA175_0<=EXPLICITLY)) ) {
|
|
alt175=1;
|
|
}
|
|
|
|
|
|
switch (alt175) {
|
|
case 1 :
|
|
// XQueryParser.g:
|
|
set552=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=L_QuotAttrContentChar && this.input.LA(1)<=NOTEQUAL)||(this.input.LA(1)>=COMMA && this.input.LA(1)<=CHARREF_HEX)||(this.input.LA(1)>=QUOT && this.input.LA(1)<=EXPLICITLY) ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set552));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop175;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_QName_return: (function() {
|
|
XQueryParser.p_QName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_QName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1246:1: p_QName : p_NCName p_LocalNCName -> ^( QName p_NCName ( p_LocalNCName )? ) ;
|
|
// $ANTLR start "p_QName"
|
|
p_QName: function() {
|
|
var retval = new XQueryParser.p_QName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_NCName553 = null;
|
|
var p_LocalNCName554 = null;
|
|
|
|
var stream_p_LocalNCName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_LocalNCName");
|
|
var stream_p_NCName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_NCName");
|
|
try {
|
|
// XQueryParser.g:1247:9: ( p_NCName p_LocalNCName -> ^( QName p_NCName ( p_LocalNCName )? ) )
|
|
// XQueryParser.g:1247:11: p_NCName p_LocalNCName
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_QName9994);
|
|
p_NCName553=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_NCName.add(p_NCName553.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_LocalNCName_in_p_QName9996);
|
|
p_LocalNCName554=this.p_LocalNCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_LocalNCName.add(p_LocalNCName554.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: p_NCName, p_LocalNCName
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1248:17: -> ^( QName p_NCName ( p_LocalNCName )? )
|
|
{
|
|
// XQueryParser.g:1248:20: ^( QName p_NCName ( p_LocalNCName )? )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(QName, "QName"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_p_NCName.nextTree());
|
|
// XQueryParser.g:1248:37: ( p_LocalNCName )?
|
|
if ( stream_p_LocalNCName.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_p_LocalNCName.nextTree());
|
|
|
|
}
|
|
stream_p_LocalNCName.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_LocalNCName_return: (function() {
|
|
XQueryParser.p_LocalNCName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_LocalNCName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1253:1: p_LocalNCName : ( COLON p_NCName )? ;
|
|
// $ANTLR start "p_LocalNCName"
|
|
p_LocalNCName: function() {
|
|
var retval = new XQueryParser.p_LocalNCName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COLON555 = null;
|
|
var p_NCName556 = null;
|
|
|
|
var COLON555_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1254:9: ( ( COLON p_NCName )? )
|
|
// XQueryParser.g:1254:11: ( COLON p_NCName )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1254:11: ( COLON p_NCName )?
|
|
var alt176=2;
|
|
var LA176_0 = this.input.LA(1);
|
|
|
|
if ( (LA176_0==COLON) ) {
|
|
alt176=1;
|
|
}
|
|
switch (alt176) {
|
|
case 1 :
|
|
// XQueryParser.g:1254:12: COLON p_NCName
|
|
COLON555=this.match(this.input,COLON,XQueryParser.FOLLOW_COLON_in_p_LocalNCName10051); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON555_tree = this.adaptor.create(COLON555);
|
|
this.adaptor.addChild(root_0, COLON555_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_LocalNCName10053);
|
|
p_NCName556=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName556.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_FQName_return: (function() {
|
|
XQueryParser.p_FQName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_FQName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1260:1: p_FQName : p_FNCName p_LocalFNCName ;
|
|
// $ANTLR start "p_FQName"
|
|
p_FQName: function() {
|
|
var retval = new XQueryParser.p_FQName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_FNCName557 = null;
|
|
var p_LocalFNCName558 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1261:9: ( p_FNCName p_LocalFNCName )
|
|
// XQueryParser.g:1261:11: p_FNCName p_LocalFNCName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_FNCName_in_p_FQName10083);
|
|
p_FNCName557=this.p_FNCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_FNCName557.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_LocalFNCName_in_p_FQName10085);
|
|
p_LocalFNCName558=this.p_LocalFNCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_LocalFNCName558.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_LocalFNCName_return: (function() {
|
|
XQueryParser.p_LocalFNCName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_LocalFNCName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1266:1: p_LocalFNCName : ( COLON p_NCName )? ;
|
|
// $ANTLR start "p_LocalFNCName"
|
|
p_LocalFNCName: function() {
|
|
var retval = new XQueryParser.p_LocalFNCName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COLON559 = null;
|
|
var p_NCName560 = null;
|
|
|
|
var COLON559_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1267:9: ( ( COLON p_NCName )? )
|
|
// XQueryParser.g:1267:11: ( COLON p_NCName )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1267:11: ( COLON p_NCName )?
|
|
var alt177=2;
|
|
var LA177_0 = this.input.LA(1);
|
|
|
|
if ( (LA177_0==COLON) ) {
|
|
alt177=1;
|
|
}
|
|
switch (alt177) {
|
|
case 1 :
|
|
// XQueryParser.g:1267:12: COLON p_NCName
|
|
COLON559=this.match(this.input,COLON,XQueryParser.FOLLOW_COLON_in_p_LocalFNCName10113); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COLON559_tree = this.adaptor.create(COLON559);
|
|
this.adaptor.addChild(root_0, COLON559_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NCName_in_p_LocalFNCName10115);
|
|
p_NCName560=this.p_NCName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NCName560.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NCName_return: (function() {
|
|
XQueryParser.p_NCName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NCName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1273:1: p_NCName : ( L_NCName | ANCESTOR | ANCESTOR_OR_SELF | AND | AS | ASCENDING | AT | ATTRIBUTE | BASE_URI | BOUNDARY_SPACE | BY | CASE | CAST | CASTABLE | CHILD | COLLATION | COMMENT | CONSTRUCTION | COPY_NAMESPACES | DECLARE | DEFAULT | DESCENDANT | DESCENDANT_OR_SELF | DESCENDING | DIV | DOCUMENT | DOCUMENT_NODE | ELEMENT | ELSE | EMPTY | EMPTY_SEQUENCE | ENCODING | EQ | EVERY | EXCEPT | EXTERNAL | FOLLOWING | FOLLOWING_SIBLING | FOR | FUNCTION | GE | GREATEST | GT | IDIV | IF | IMPORT | IN | INHERIT | INSTANCE | INTERSECT | IS | ITEM | LAX | LE | LEAST | LET | LT | MOD | MODULE | NAMESPACE | NE | NO_INHERIT | NO_PRESERVE | NODE | OF | OPTION | OR | ORDER | ORDERED | ORDERING | PARENT | PRECEDING | PRECEDING_SIBLING | PRESERVE | PROCESSING_INSTRUCTION | RETURN | SATISFIES | SCHEMA | SCHEMA_ATTRIBUTE | SCHEMA_ELEMENT | SELF | SOME | STABLE | STRICT | STRIP | TEXT | THEN | TO | TREAT | TYPESWITCH | UNION | UNORDERED | VALIDATE | VARIABLE | VERSION | WHERE | XQUERY | CATCH | CONTEXT | COUNT | DECIMAL_FORMAT | DECIMAL_SEPARATOR | DIGIT | END | GROUP | GROUPING_SEPARATOR | INFINITY | MINUS_SIGN | NAMESPACE_NODE | NAN | NEXT | ONLY | OUTER | PATTERN_SEPARATOR | PERCENT | PER_MILLE | PREVIOUS | SLIDING | START | TRY | TUMBLING | WHEN | WINDOW | ZERO_DIGIT | AFTER | BEFORE | COPY | DELETE | FIRST | INSERT | INTO | LAST | MODIFY | NODES | RENAME | REPLACE | REVALIDATION | SKIP | UPDATING | VALUE | WITH | BLOCK | CONSTANT | EXIT | SEQUENTIAL | SET | SIMPLE | WHILE | EVAL | USING | APPEND_ONLY | AUTOMATICALLY | CHECK | COLLECTION | CONSTRAINT | CONST | EQUALITY | EXPLICITLY | FOREACH | FOREIGN | FROM | INDEX | INTEGRITY | KEY | MAINTAINED | MUTABLE | NON | ON | QUEUE | RANGE | READ_ONLY | UNIQUE | BINARY | PRIVATE | AMP_ER | APOS_ER | QUOT_ER );
|
|
// $ANTLR start "p_NCName"
|
|
p_NCName: function() {
|
|
var retval = new XQueryParser.p_NCName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set561 = null;
|
|
|
|
var set561_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1274:9: ( L_NCName | ANCESTOR | ANCESTOR_OR_SELF | AND | AS | ASCENDING | AT | ATTRIBUTE | BASE_URI | BOUNDARY_SPACE | BY | CASE | CAST | CASTABLE | CHILD | COLLATION | COMMENT | CONSTRUCTION | COPY_NAMESPACES | DECLARE | DEFAULT | DESCENDANT | DESCENDANT_OR_SELF | DESCENDING | DIV | DOCUMENT | DOCUMENT_NODE | ELEMENT | ELSE | EMPTY | EMPTY_SEQUENCE | ENCODING | EQ | EVERY | EXCEPT | EXTERNAL | FOLLOWING | FOLLOWING_SIBLING | FOR | FUNCTION | GE | GREATEST | GT | IDIV | IF | IMPORT | IN | INHERIT | INSTANCE | INTERSECT | IS | ITEM | LAX | LE | LEAST | LET | LT | MOD | MODULE | NAMESPACE | NE | NO_INHERIT | NO_PRESERVE | NODE | OF | OPTION | OR | ORDER | ORDERED | ORDERING | PARENT | PRECEDING | PRECEDING_SIBLING | PRESERVE | PROCESSING_INSTRUCTION | RETURN | SATISFIES | SCHEMA | SCHEMA_ATTRIBUTE | SCHEMA_ELEMENT | SELF | SOME | STABLE | STRICT | STRIP | TEXT | THEN | TO | TREAT | TYPESWITCH | UNION | UNORDERED | VALIDATE | VARIABLE | VERSION | WHERE | XQUERY | CATCH | CONTEXT | COUNT | DECIMAL_FORMAT | DECIMAL_SEPARATOR | DIGIT | END | GROUP | GROUPING_SEPARATOR | INFINITY | MINUS_SIGN | NAMESPACE_NODE | NAN | NEXT | ONLY | OUTER | PATTERN_SEPARATOR | PERCENT | PER_MILLE | PREVIOUS | SLIDING | START | TRY | TUMBLING | WHEN | WINDOW | ZERO_DIGIT | AFTER | BEFORE | COPY | DELETE | FIRST | INSERT | INTO | LAST | MODIFY | NODES | RENAME | REPLACE | REVALIDATION | SKIP | UPDATING | VALUE | WITH | BLOCK | CONSTANT | EXIT | SEQUENTIAL | SET | SIMPLE | WHILE | EVAL | USING | APPEND_ONLY | AUTOMATICALLY | CHECK | COLLECTION | CONSTRAINT | CONST | EQUALITY | EXPLICITLY | FOREACH | FOREIGN | FROM | INDEX | INTEGRITY | KEY | MAINTAINED | MUTABLE | NON | ON | QUEUE | RANGE | READ_ONLY | UNIQUE | BINARY | PRIVATE | AMP_ER | APOS_ER | QUOT_ER )
|
|
// XQueryParser.g:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
set561=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=ANCESTOR && this.input.LA(1)<=EXIT)||(this.input.LA(1)>=SEQUENTIAL && this.input.LA(1)<=MAINTAINED)||(this.input.LA(1)>=MUTABLE && this.input.LA(1)<=QUOT_ER)||this.input.LA(1)==L_NCName||this.input.LA(1)==EXPLICITLY ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set561));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_FNCName_return: (function() {
|
|
XQueryParser.p_FNCName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_FNCName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1292:1: p_FNCName : ( L_NCName | ANCESTOR | ANCESTOR_OR_SELF | AND | AS | ASCENDING | AT | BASE_URI | BOUNDARY_SPACE | BY | CASE | CAST | CASTABLE | CHILD | COLLATION | CONSTRUCTION | COPY_NAMESPACES | DECLARE | DEFAULT | DESCENDANT | DESCENDANT_OR_SELF | DESCENDING | DIV | DOCUMENT | ELSE | EMPTY | ENCODING | EQ | EVERY | EXCEPT | EXTERNAL | FOLLOWING | FOLLOWING_SIBLING | FOR | FUNCTION | GE | GREATEST | GT | IDIV | IMPORT | IN | INHERIT | INSTANCE | INTERSECT | IS | LAX | LE | LEAST | LET | LT | MOD | MODULE | NAMESPACE | NE | NO_INHERIT | NO_PRESERVE | OF | OPTION | OR | ORDER | ORDERED | ORDERING | PARENT | PRECEDING | PRECEDING_SIBLING | PRESERVE | RETURN | SATISFIES | SCHEMA | SELF | SOME | STABLE | STRICT | STRIP | THEN | TO | TREAT | UNION | UNORDERED | VALIDATE | VARIABLE | VERSION | WHERE | XQUERY | CATCH | CONTEXT | COUNT | DECIMAL_FORMAT | DECIMAL_SEPARATOR | DIGIT | END | GROUP | GROUPING_SEPARATOR | INFINITY | MINUS_SIGN | NAN | NEXT | ONLY | OUTER | PATTERN_SEPARATOR | PERCENT | PER_MILLE | PREVIOUS | SLIDING | START | TRY | TUMBLING | WHEN | WINDOW | ZERO_DIGIT | AFTER | BEFORE | COPY | DELETE | FIRST | INSERT | INTO | LAST | MODIFY | NODES | RENAME | REPLACE | REVALIDATION | SKIP | UPDATING | VALUE | WITH | BLOCK | CONSTANT | EXIT | SEQUENTIAL | SET | SIMPLE | EVAL | USING | APPEND_ONLY | AUTOMATICALLY | CHECK | COLLECTION | CONSTRAINT | CONST | EQUALITY | EXPLICITLY | FOREACH | FOREIGN | FROM | INDEX | INTEGRITY | KEY | MAINTAINED | MUTABLE | NON | ON | QUEUE | RANGE | READ_ONLY | UNIQUE | BINARY | PRIVATE | AMP_ER | APOS_ER | QUOT_ER );
|
|
// $ANTLR start "p_FNCName"
|
|
p_FNCName: function() {
|
|
var retval = new XQueryParser.p_FNCName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var set562 = null;
|
|
|
|
var set562_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1293:9: ( L_NCName | ANCESTOR | ANCESTOR_OR_SELF | AND | AS | ASCENDING | AT | BASE_URI | BOUNDARY_SPACE | BY | CASE | CAST | CASTABLE | CHILD | COLLATION | CONSTRUCTION | COPY_NAMESPACES | DECLARE | DEFAULT | DESCENDANT | DESCENDANT_OR_SELF | DESCENDING | DIV | DOCUMENT | ELSE | EMPTY | ENCODING | EQ | EVERY | EXCEPT | EXTERNAL | FOLLOWING | FOLLOWING_SIBLING | FOR | FUNCTION | GE | GREATEST | GT | IDIV | IMPORT | IN | INHERIT | INSTANCE | INTERSECT | IS | LAX | LE | LEAST | LET | LT | MOD | MODULE | NAMESPACE | NE | NO_INHERIT | NO_PRESERVE | OF | OPTION | OR | ORDER | ORDERED | ORDERING | PARENT | PRECEDING | PRECEDING_SIBLING | PRESERVE | RETURN | SATISFIES | SCHEMA | SELF | SOME | STABLE | STRICT | STRIP | THEN | TO | TREAT | UNION | UNORDERED | VALIDATE | VARIABLE | VERSION | WHERE | XQUERY | CATCH | CONTEXT | COUNT | DECIMAL_FORMAT | DECIMAL_SEPARATOR | DIGIT | END | GROUP | GROUPING_SEPARATOR | INFINITY | MINUS_SIGN | NAN | NEXT | ONLY | OUTER | PATTERN_SEPARATOR | PERCENT | PER_MILLE | PREVIOUS | SLIDING | START | TRY | TUMBLING | WHEN | WINDOW | ZERO_DIGIT | AFTER | BEFORE | COPY | DELETE | FIRST | INSERT | INTO | LAST | MODIFY | NODES | RENAME | REPLACE | REVALIDATION | SKIP | UPDATING | VALUE | WITH | BLOCK | CONSTANT | EXIT | SEQUENTIAL | SET | SIMPLE | EVAL | USING | APPEND_ONLY | AUTOMATICALLY | CHECK | COLLECTION | CONSTRAINT | CONST | EQUALITY | EXPLICITLY | FOREACH | FOREIGN | FROM | INDEX | INTEGRITY | KEY | MAINTAINED | MUTABLE | NON | ON | QUEUE | RANGE | READ_ONLY | UNIQUE | BINARY | PRIVATE | AMP_ER | APOS_ER | QUOT_ER )
|
|
// XQueryParser.g:
|
|
root_0 = this.adaptor.nil();
|
|
|
|
set562=this.input.LT(1);
|
|
if ( (this.input.LA(1)>=ANCESTOR && this.input.LA(1)<=AT)||(this.input.LA(1)>=BASE_URI && this.input.LA(1)<=COLLATION)||(this.input.LA(1)>=CONSTRUCTION && this.input.LA(1)<=DOCUMENT)||(this.input.LA(1)>=ELSE && this.input.LA(1)<=EMPTY)||(this.input.LA(1)>=ENCODING && this.input.LA(1)<=IDIV)||(this.input.LA(1)>=IMPORT && this.input.LA(1)<=IS)||(this.input.LA(1)>=LAX && this.input.LA(1)<=NO_PRESERVE)||(this.input.LA(1)>=OF && this.input.LA(1)<=PRESERVE)||(this.input.LA(1)>=RETURN && this.input.LA(1)<=SCHEMA)||(this.input.LA(1)>=SELF && this.input.LA(1)<=STRIP)||(this.input.LA(1)>=THEN && this.input.LA(1)<=TREAT)||(this.input.LA(1)>=UNION && this.input.LA(1)<=MINUS_SIGN)||(this.input.LA(1)>=NAN && this.input.LA(1)<=EXIT)||(this.input.LA(1)>=SEQUENTIAL && this.input.LA(1)<=SIMPLE)||(this.input.LA(1)>=EVAL && this.input.LA(1)<=MAINTAINED)||(this.input.LA(1)>=MUTABLE && this.input.LA(1)<=QUOT_ER)||this.input.LA(1)==L_NCName||this.input.LA(1)==EXPLICITLY ) {
|
|
this.input.consume();
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, this.adaptor.create(set562));
|
|
this.state.errorRecovery=false;this.state.failed=false;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_RevalidationDecl_return: (function() {
|
|
XQueryParser.pm_RevalidationDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_RevalidationDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1326:1: pm_RevalidationDecl : k+= DECLARE k+= REVALIDATION (k+= STRICT | k+= LAX | k+= SKIP ) ;
|
|
// $ANTLR start "pm_RevalidationDecl"
|
|
pm_RevalidationDecl: function() {
|
|
var retval = new XQueryParser.pm_RevalidationDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1327:9: (k+= DECLARE k+= REVALIDATION (k+= STRICT | k+= LAX | k+= SKIP ) )
|
|
// XQueryParser.g:1327:11: k+= DECLARE k+= REVALIDATION (k+= STRICT | k+= LAX | k+= SKIP )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_RevalidationDecl11839); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,REVALIDATION,XQueryParser.FOLLOW_REVALIDATION_in_pm_RevalidationDecl11843); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:1327:38: (k+= STRICT | k+= LAX | k+= SKIP )
|
|
var alt178=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case STRICT:
|
|
alt178=1;
|
|
break;
|
|
case LAX:
|
|
alt178=2;
|
|
break;
|
|
case SKIP:
|
|
alt178=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 178, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt178) {
|
|
case 1 :
|
|
// XQueryParser.g:1327:39: k+= STRICT
|
|
k=this.match(this.input,STRICT,XQueryParser.FOLLOW_STRICT_in_pm_RevalidationDecl11848); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1327:51: k+= LAX
|
|
k=this.match(this.input,LAX,XQueryParser.FOLLOW_LAX_in_pm_RevalidationDecl11854); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1327:60: k+= SKIP
|
|
k=this.match(this.input,SKIP,XQueryParser.FOLLOW_SKIP_in_pm_RevalidationDecl11860); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_InsertExprTargetChoice_return: (function() {
|
|
XQueryParser.p_InsertExprTargetChoice_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_InsertExprTargetChoice_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1331:1: p_InsertExprTargetChoice : ( ( (k+= AS (k+= FIRST | k+= LAST ) )? k+= INTO ) | ka= AFTER | kb= BEFORE );
|
|
// $ANTLR start "p_InsertExprTargetChoice"
|
|
p_InsertExprTargetChoice: function() {
|
|
var retval = new XQueryParser.p_InsertExprTargetChoice_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ka = null;
|
|
var kb = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var ka_tree=null;
|
|
var kb_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1332:9: ( ( (k+= AS (k+= FIRST | k+= LAST ) )? k+= INTO ) | ka= AFTER | kb= BEFORE )
|
|
var alt181=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case AS:
|
|
case INTO:
|
|
alt181=1;
|
|
break;
|
|
case AFTER:
|
|
alt181=2;
|
|
break;
|
|
case BEFORE:
|
|
alt181=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 181, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt181) {
|
|
case 1 :
|
|
// XQueryParser.g:1332:11: ( (k+= AS (k+= FIRST | k+= LAST ) )? k+= INTO )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1332:11: ( (k+= AS (k+= FIRST | k+= LAST ) )? k+= INTO )
|
|
// XQueryParser.g:1332:12: (k+= AS (k+= FIRST | k+= LAST ) )? k+= INTO
|
|
// XQueryParser.g:1332:12: (k+= AS (k+= FIRST | k+= LAST ) )?
|
|
var alt180=2;
|
|
var LA180_0 = this.input.LA(1);
|
|
|
|
if ( (LA180_0==AS) ) {
|
|
alt180=1;
|
|
}
|
|
switch (alt180) {
|
|
case 1 :
|
|
// XQueryParser.g:1332:13: k+= AS (k+= FIRST | k+= LAST )
|
|
k=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_InsertExprTargetChoice11892); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:1332:19: (k+= FIRST | k+= LAST )
|
|
var alt179=2;
|
|
var LA179_0 = this.input.LA(1);
|
|
|
|
if ( (LA179_0==FIRST) ) {
|
|
alt179=1;
|
|
}
|
|
else if ( (LA179_0==LAST) ) {
|
|
alt179=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 179, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt179) {
|
|
case 1 :
|
|
// XQueryParser.g:1332:20: k+= FIRST
|
|
k=this.match(this.input,FIRST,XQueryParser.FOLLOW_FIRST_in_p_InsertExprTargetChoice11897); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1332:31: k+= LAST
|
|
k=this.match(this.input,LAST,XQueryParser.FOLLOW_LAST_in_p_InsertExprTargetChoice11903); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,INTO,XQueryParser.FOLLOW_INTO_in_p_InsertExprTargetChoice11910); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1333:11: ka= AFTER
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ka=this.match(this.input,AFTER,XQueryParser.FOLLOW_AFTER_in_p_InsertExprTargetChoice11926); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1334:11: kb= BEFORE
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kb=this.match(this.input,BEFORE,XQueryParser.FOLLOW_BEFORE_in_p_InsertExprTargetChoice11940); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kb_tree = this.adaptor.create(kb);
|
|
this.adaptor.addChild(root_0, kb_tree);
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_InsertExpr_return: (function() {
|
|
XQueryParser.p_InsertExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_InsertExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1338:1: p_InsertExpr : k+= INSERT (k+= NODE | k+= NODES ) p_SourceExpr p_InsertExprTargetChoice p_TargetExpr ;
|
|
// $ANTLR start "p_InsertExpr"
|
|
p_InsertExpr: function() {
|
|
var retval = new XQueryParser.p_InsertExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_SourceExpr563 = null;
|
|
var p_InsertExprTargetChoice564 = null;
|
|
var p_TargetExpr565 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1339:9: (k+= INSERT (k+= NODE | k+= NODES ) p_SourceExpr p_InsertExprTargetChoice p_TargetExpr )
|
|
// XQueryParser.g:1339:11: k+= INSERT (k+= NODE | k+= NODES ) p_SourceExpr p_InsertExprTargetChoice p_TargetExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,INSERT,XQueryParser.FOLLOW_INSERT_in_p_InsertExpr11968); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:1339:21: (k+= NODE | k+= NODES )
|
|
var alt182=2;
|
|
var LA182_0 = this.input.LA(1);
|
|
|
|
if ( (LA182_0==NODE) ) {
|
|
alt182=1;
|
|
}
|
|
else if ( (LA182_0==NODES) ) {
|
|
alt182=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 182, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt182) {
|
|
case 1 :
|
|
// XQueryParser.g:1339:22: k+= NODE
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_InsertExpr11973); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1339:32: k+= NODES
|
|
k=this.match(this.input,NODES,XQueryParser.FOLLOW_NODES_in_p_InsertExpr11979); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_SourceExpr_in_p_InsertExpr11982);
|
|
p_SourceExpr563=this.p_SourceExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_SourceExpr563.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_InsertExprTargetChoice_in_p_InsertExpr11984);
|
|
p_InsertExprTargetChoice564=this.p_InsertExprTargetChoice();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_InsertExprTargetChoice564.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TargetExpr_in_p_InsertExpr11986);
|
|
p_TargetExpr565=this.p_TargetExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TargetExpr565.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_DeleteExpr_return: (function() {
|
|
XQueryParser.p_DeleteExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_DeleteExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1343:1: p_DeleteExpr : k+= DELETE (k+= NODE | k+= NODES ) p_TargetExpr ;
|
|
// $ANTLR start "p_DeleteExpr"
|
|
p_DeleteExpr: function() {
|
|
var retval = new XQueryParser.p_DeleteExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_TargetExpr566 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1344:9: (k+= DELETE (k+= NODE | k+= NODES ) p_TargetExpr )
|
|
// XQueryParser.g:1344:11: k+= DELETE (k+= NODE | k+= NODES ) p_TargetExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DELETE,XQueryParser.FOLLOW_DELETE_in_p_DeleteExpr12015); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:1344:21: (k+= NODE | k+= NODES )
|
|
var alt183=2;
|
|
var LA183_0 = this.input.LA(1);
|
|
|
|
if ( (LA183_0==NODE) ) {
|
|
alt183=1;
|
|
}
|
|
else if ( (LA183_0==NODES) ) {
|
|
alt183=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 183, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt183) {
|
|
case 1 :
|
|
// XQueryParser.g:1344:22: k+= NODE
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_DeleteExpr12020); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1344:32: k+= NODES
|
|
k=this.match(this.input,NODES,XQueryParser.FOLLOW_NODES_in_p_DeleteExpr12026); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TargetExpr_in_p_DeleteExpr12029);
|
|
p_TargetExpr566=this.p_TargetExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TargetExpr566.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ReplaceExpr_return: (function() {
|
|
XQueryParser.p_ReplaceExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ReplaceExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1348:1: p_ReplaceExpr : k+= REPLACE (k+= VALUE k+= OF )? k+= NODE p_ExprSingle k+= WITH p_ExprSingle ;
|
|
// $ANTLR start "p_ReplaceExpr"
|
|
p_ReplaceExpr: function() {
|
|
var retval = new XQueryParser.p_ReplaceExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_ExprSingle567 = null;
|
|
var p_ExprSingle568 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1349:9: (k+= REPLACE (k+= VALUE k+= OF )? k+= NODE p_ExprSingle k+= WITH p_ExprSingle )
|
|
// XQueryParser.g:1349:11: k+= REPLACE (k+= VALUE k+= OF )? k+= NODE p_ExprSingle k+= WITH p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,REPLACE,XQueryParser.FOLLOW_REPLACE_in_p_ReplaceExpr12058); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
// XQueryParser.g:1349:22: (k+= VALUE k+= OF )?
|
|
var alt184=2;
|
|
var LA184_0 = this.input.LA(1);
|
|
|
|
if ( (LA184_0==VALUE) ) {
|
|
alt184=1;
|
|
}
|
|
switch (alt184) {
|
|
case 1 :
|
|
// XQueryParser.g:1349:23: k+= VALUE k+= OF
|
|
k=this.match(this.input,VALUE,XQueryParser.FOLLOW_VALUE_in_p_ReplaceExpr12063); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,OF,XQueryParser.FOLLOW_OF_in_p_ReplaceExpr12067); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_ReplaceExpr12073); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ReplaceExpr12075);
|
|
p_ExprSingle567=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle567.getTree());
|
|
k=this.match(this.input,WITH,XQueryParser.FOLLOW_WITH_in_p_ReplaceExpr12079); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ReplaceExpr12081);
|
|
p_ExprSingle568=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle568.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_RenameExpr_return: (function() {
|
|
XQueryParser.p_RenameExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_RenameExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1353:1: p_RenameExpr : k+= RENAME k+= NODE p_TargetExpr AS p_NewNameExpr ;
|
|
// $ANTLR start "p_RenameExpr"
|
|
p_RenameExpr: function() {
|
|
var retval = new XQueryParser.p_RenameExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var AS570 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_TargetExpr569 = null;
|
|
var p_NewNameExpr571 = null;
|
|
|
|
var AS570_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1354:9: (k+= RENAME k+= NODE p_TargetExpr AS p_NewNameExpr )
|
|
// XQueryParser.g:1354:11: k+= RENAME k+= NODE p_TargetExpr AS p_NewNameExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,RENAME,XQueryParser.FOLLOW_RENAME_in_p_RenameExpr12110); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_RenameExpr12114); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TargetExpr_in_p_RenameExpr12116);
|
|
p_TargetExpr569=this.p_TargetExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_TargetExpr569.getTree());
|
|
AS570=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_RenameExpr12118); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
AS570_tree = this.adaptor.create(AS570);
|
|
this.adaptor.addChild(root_0, AS570_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NewNameExpr_in_p_RenameExpr12120);
|
|
p_NewNameExpr571=this.p_NewNameExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NewNameExpr571.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_SourceExpr_return: (function() {
|
|
XQueryParser.p_SourceExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_SourceExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1358:1: p_SourceExpr : p_ExprSingle ;
|
|
// $ANTLR start "p_SourceExpr"
|
|
p_SourceExpr: function() {
|
|
var retval = new XQueryParser.p_SourceExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ExprSingle572 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1359:9: ( p_ExprSingle )
|
|
// XQueryParser.g:1359:11: p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_SourceExpr12147);
|
|
p_ExprSingle572=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle572.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TargetExpr_return: (function() {
|
|
XQueryParser.p_TargetExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TargetExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1363:1: p_TargetExpr : p_ExprSingle ;
|
|
// $ANTLR start "p_TargetExpr"
|
|
p_TargetExpr: function() {
|
|
var retval = new XQueryParser.p_TargetExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ExprSingle573 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1364:9: ( p_ExprSingle )
|
|
// XQueryParser.g:1364:11: p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TargetExpr12173);
|
|
p_ExprSingle573=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle573.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NewNameExpr_return: (function() {
|
|
XQueryParser.p_NewNameExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NewNameExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1368:1: p_NewNameExpr : p_ExprSingle ;
|
|
// $ANTLR start "p_NewNameExpr"
|
|
p_NewNameExpr: function() {
|
|
var retval = new XQueryParser.p_NewNameExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_ExprSingle574 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1369:9: ( p_ExprSingle )
|
|
// XQueryParser.g:1369:11: p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_NewNameExpr12199);
|
|
p_ExprSingle574=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle574.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_TransformExpr_return: (function() {
|
|
XQueryParser.p_TransformExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_TransformExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1373:1: p_TransformExpr : k+= COPY DOLLAR p_VarName BIND p_ExprSingle ( COMMA DOLLAR p_VarName BIND p_ExprSingle )* k+= MODIFY p_ExprSingle k+= RETURN p_ExprSingle ;
|
|
// $ANTLR start "p_TransformExpr"
|
|
p_TransformExpr: function() {
|
|
var retval = new XQueryParser.p_TransformExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR575 = null;
|
|
var BIND577 = null;
|
|
var COMMA579 = null;
|
|
var DOLLAR580 = null;
|
|
var BIND582 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_VarName576 = null;
|
|
var p_ExprSingle578 = null;
|
|
var p_VarName581 = null;
|
|
var p_ExprSingle583 = null;
|
|
var p_ExprSingle584 = null;
|
|
var p_ExprSingle585 = null;
|
|
|
|
var DOLLAR575_tree=null;
|
|
var BIND577_tree=null;
|
|
var COMMA579_tree=null;
|
|
var DOLLAR580_tree=null;
|
|
var BIND582_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1374:9: (k+= COPY DOLLAR p_VarName BIND p_ExprSingle ( COMMA DOLLAR p_VarName BIND p_ExprSingle )* k+= MODIFY p_ExprSingle k+= RETURN p_ExprSingle )
|
|
// XQueryParser.g:1374:11: k+= COPY DOLLAR p_VarName BIND p_ExprSingle ( COMMA DOLLAR p_VarName BIND p_ExprSingle )* k+= MODIFY p_ExprSingle k+= RETURN p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,COPY,XQueryParser.FOLLOW_COPY_in_p_TransformExpr12227); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR575=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_TransformExpr12229); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR575_tree = this.adaptor.create(DOLLAR575);
|
|
this.adaptor.addChild(root_0, DOLLAR575_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_TransformExpr12231);
|
|
p_VarName576=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName576.getTree());
|
|
BIND577=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_p_TransformExpr12233); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND577_tree = this.adaptor.create(BIND577);
|
|
this.adaptor.addChild(root_0, BIND577_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TransformExpr12235);
|
|
p_ExprSingle578=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle578.getTree());
|
|
// XQueryParser.g:1374:54: ( COMMA DOLLAR p_VarName BIND p_ExprSingle )*
|
|
loop185:
|
|
do {
|
|
var alt185=2;
|
|
var LA185_0 = this.input.LA(1);
|
|
|
|
if ( (LA185_0==COMMA) ) {
|
|
alt185=1;
|
|
}
|
|
|
|
|
|
switch (alt185) {
|
|
case 1 :
|
|
// XQueryParser.g:1374:55: COMMA DOLLAR p_VarName BIND p_ExprSingle
|
|
COMMA579=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_TransformExpr12238); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA579_tree = this.adaptor.create(COMMA579);
|
|
this.adaptor.addChild(root_0, COMMA579_tree);
|
|
}
|
|
DOLLAR580=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_TransformExpr12240); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR580_tree = this.adaptor.create(DOLLAR580);
|
|
this.adaptor.addChild(root_0, DOLLAR580_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_TransformExpr12242);
|
|
p_VarName581=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName581.getTree());
|
|
BIND582=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_p_TransformExpr12244); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND582_tree = this.adaptor.create(BIND582);
|
|
this.adaptor.addChild(root_0, BIND582_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TransformExpr12246);
|
|
p_ExprSingle583=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle583.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop185;
|
|
}
|
|
} while (true);
|
|
|
|
k=this.match(this.input,MODIFY,XQueryParser.FOLLOW_MODIFY_in_p_TransformExpr12252); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TransformExpr12254);
|
|
p_ExprSingle584=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle584.getTree());
|
|
k=this.match(this.input,RETURN,XQueryParser.FOLLOW_RETURN_in_p_TransformExpr12258); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_TransformExpr12260);
|
|
p_ExprSingle585=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle585.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_ApplyExpr_return: (function() {
|
|
XQueryParser.pm_ApplyExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_ApplyExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1384:1: pm_ApplyExpr : p_ConcatExpr SEMICOLON ;
|
|
// $ANTLR start "pm_ApplyExpr"
|
|
pm_ApplyExpr: function() {
|
|
var retval = new XQueryParser.pm_ApplyExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON587 = null;
|
|
var p_ConcatExpr586 = null;
|
|
|
|
var SEMICOLON587_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1385:9: ( p_ConcatExpr SEMICOLON )
|
|
// XQueryParser.g:1385:11: p_ConcatExpr SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ConcatExpr_in_pm_ApplyExpr12294);
|
|
p_ConcatExpr586=this.p_ConcatExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ConcatExpr586.getTree());
|
|
SEMICOLON587=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_ApplyExpr12296); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON587_tree = this.adaptor.create(SEMICOLON587);
|
|
this.adaptor.addChild(root_0, SEMICOLON587_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ConcatExpr_return: (function() {
|
|
XQueryParser.p_ConcatExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ConcatExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1389:1: p_ConcatExpr : p_ExprSingle ( COMMA p_ExprSingle )* ;
|
|
// $ANTLR start "p_ConcatExpr"
|
|
p_ConcatExpr: function() {
|
|
var retval = new XQueryParser.p_ConcatExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA589 = null;
|
|
var p_ExprSingle588 = null;
|
|
var p_ExprSingle590 = null;
|
|
|
|
var COMMA589_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1390:9: ( p_ExprSingle ( COMMA p_ExprSingle )* )
|
|
// XQueryParser.g:1390:11: p_ExprSingle ( COMMA p_ExprSingle )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ConcatExpr12322);
|
|
p_ExprSingle588=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle588.getTree());
|
|
// XQueryParser.g:1390:24: ( COMMA p_ExprSingle )*
|
|
loop186:
|
|
do {
|
|
var alt186=2;
|
|
var LA186_0 = this.input.LA(1);
|
|
|
|
if ( (LA186_0==COMMA) ) {
|
|
alt186=1;
|
|
}
|
|
|
|
|
|
switch (alt186) {
|
|
case 1 :
|
|
// XQueryParser.g:1390:25: COMMA p_ExprSingle
|
|
COMMA589=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_ConcatExpr12325); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA589_tree = this.adaptor.create(COMMA589);
|
|
this.adaptor.addChild(root_0, COMMA589_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ConcatExpr12327);
|
|
p_ExprSingle590=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle590.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop186;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_BlockExpr_return: (function() {
|
|
XQueryParser.p_BlockExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_BlockExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1394:1: p_BlockExpr : kb= BLOCK p_Block ;
|
|
// $ANTLR start "p_BlockExpr"
|
|
p_BlockExpr: function() {
|
|
var retval = new XQueryParser.p_BlockExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kb = null;
|
|
var p_Block591 = null;
|
|
|
|
var kb_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1395:9: (kb= BLOCK p_Block )
|
|
// XQueryParser.g:1395:11: kb= BLOCK p_Block
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kb=this.match(this.input,BLOCK,XQueryParser.FOLLOW_BLOCK_in_p_BlockExpr12357); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kb_tree = this.adaptor.create(kb);
|
|
this.adaptor.addChild(root_0, kb_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Block_in_p_BlockExpr12359);
|
|
p_Block591=this.p_Block();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_Block591.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_Block_return: (function() {
|
|
XQueryParser.p_Block_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_Block_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1399:1: p_Block : LBRACKET bd= pm_BlockDecls bb= p_BlockBody RBRACKET -> ^( Block $bd $bb) ;
|
|
// $ANTLR start "p_Block"
|
|
p_Block: function() {
|
|
var retval = new XQueryParser.p_Block_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var LBRACKET592 = null;
|
|
var RBRACKET593 = null;
|
|
var bd = null;
|
|
var bb = null;
|
|
|
|
var LBRACKET592_tree=null;
|
|
var RBRACKET593_tree=null;
|
|
var stream_LBRACKET=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token LBRACKET");
|
|
var stream_RBRACKET=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token RBRACKET");
|
|
var stream_p_BlockBody=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_BlockBody");
|
|
var stream_pm_BlockDecls=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_BlockDecls");
|
|
try {
|
|
// XQueryParser.g:1400:9: ( LBRACKET bd= pm_BlockDecls bb= p_BlockBody RBRACKET -> ^( Block $bd $bb) )
|
|
// XQueryParser.g:1400:11: LBRACKET bd= pm_BlockDecls bb= p_BlockBody RBRACKET
|
|
LBRACKET592=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_Block12385); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_LBRACKET.add(LBRACKET592);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_BlockDecls_in_p_Block12389);
|
|
bd=this.pm_BlockDecls();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_BlockDecls.add(bd.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_BlockBody_in_p_Block12393);
|
|
bb=this.p_BlockBody();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_BlockBody.add(bb.getTree());
|
|
RBRACKET593=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_Block12395); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_RBRACKET.add(RBRACKET593);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: bd, bb
|
|
// token labels:
|
|
// rule labels: retval, bb, bd
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_bb=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token bb",bb!=null?bb.tree:null);
|
|
var stream_bd=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token bd",bd!=null?bd.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1401:17: -> ^( Block $bd $bb)
|
|
{
|
|
// XQueryParser.g:1401:20: ^( Block $bd $bb)
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(Block, "Block"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_bd.nextTree());
|
|
this.adaptor.addChild(root_1, stream_bb.nextTree());
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_BlockDecls_return: (function() {
|
|
XQueryParser.pm_BlockDecls_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_BlockDecls_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1405:1: pm_BlockDecls : (bvd+= pm_BlockVarDecl )* -> ^( BlockDecls ( $bvd)* ) ;
|
|
// $ANTLR start "pm_BlockDecls"
|
|
pm_BlockDecls: function() {
|
|
var retval = new XQueryParser.pm_BlockDecls_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var list_bvd=null;
|
|
var bvd = null;
|
|
var stream_pm_BlockVarDecl=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule pm_BlockVarDecl");
|
|
try {
|
|
// XQueryParser.g:1406:9: ( (bvd+= pm_BlockVarDecl )* -> ^( BlockDecls ( $bvd)* ) )
|
|
// XQueryParser.g:1406:11: (bvd+= pm_BlockVarDecl )*
|
|
// XQueryParser.g:1406:14: (bvd+= pm_BlockVarDecl )*
|
|
loop187:
|
|
do {
|
|
var alt187=2;
|
|
var LA187_0 = this.input.LA(1);
|
|
|
|
if ( (LA187_0==DECLARE) ) {
|
|
var LA187_2 = this.input.LA(2);
|
|
|
|
if ( (LA187_2==DOLLAR) ) {
|
|
alt187=1;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
switch (alt187) {
|
|
case 1 :
|
|
// XQueryParser.g:1406:14: bvd+= pm_BlockVarDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_BlockVarDecl_in_pm_BlockDecls12451);
|
|
bvd=this.pm_BlockVarDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_pm_BlockVarDecl.add(bvd.getTree());
|
|
if (org.antlr.lang.isNull(list_bvd)) list_bvd = [];
|
|
list_bvd.push(bvd.getTree());
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop187;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: bvd
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels: bvd
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_bvd=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token bvd",list_bvd);
|
|
root_0 = this.adaptor.nil();
|
|
// 1407:17: -> ^( BlockDecls ( $bvd)* )
|
|
{
|
|
// XQueryParser.g:1407:20: ^( BlockDecls ( $bvd)* )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(BlockDecls, "BlockDecls"), root_1);
|
|
|
|
// XQueryParser.g:1407:33: ( $bvd)*
|
|
while ( stream_bvd.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_bvd.nextTree());
|
|
|
|
}
|
|
stream_bvd.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
pm_BlockVarDecl_return: (function() {
|
|
XQueryParser.pm_BlockVarDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.pm_BlockVarDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1411:1: pm_BlockVarDecl : kd= DECLARE DOLLAR qn= p_VarName (td= p_TypeDeclaration )? ( BIND es= p_ExprSingle )? ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( BIND p_ExprSingle )? )* SEMICOLON -> ^( BlockVarDecl $qn ( $td)? ( $es)? ) ;
|
|
// $ANTLR start "pm_BlockVarDecl"
|
|
pm_BlockVarDecl: function() {
|
|
var retval = new XQueryParser.pm_BlockVarDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kd = null;
|
|
var DOLLAR594 = null;
|
|
var BIND595 = null;
|
|
var COMMA596 = null;
|
|
var DOLLAR597 = null;
|
|
var BIND600 = null;
|
|
var SEMICOLON602 = null;
|
|
var qn = null;
|
|
var td = null;
|
|
var es = null;
|
|
var p_VarName598 = null;
|
|
var p_TypeDeclaration599 = null;
|
|
var p_ExprSingle601 = null;
|
|
|
|
var kd_tree=null;
|
|
var DOLLAR594_tree=null;
|
|
var BIND595_tree=null;
|
|
var COMMA596_tree=null;
|
|
var DOLLAR597_tree=null;
|
|
var BIND600_tree=null;
|
|
var SEMICOLON602_tree=null;
|
|
var stream_DOLLAR=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DOLLAR");
|
|
var stream_DECLARE=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token DECLARE");
|
|
var stream_SEMICOLON=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token SEMICOLON");
|
|
var stream_COMMA=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token COMMA");
|
|
var stream_BIND=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token BIND");
|
|
var stream_p_VarName=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_VarName");
|
|
var stream_p_TypeDeclaration=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_TypeDeclaration");
|
|
var stream_p_ExprSingle=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule p_ExprSingle");
|
|
try {
|
|
// XQueryParser.g:1412:9: (kd= DECLARE DOLLAR qn= p_VarName (td= p_TypeDeclaration )? ( BIND es= p_ExprSingle )? ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( BIND p_ExprSingle )? )* SEMICOLON -> ^( BlockVarDecl $qn ( $td)? ( $es)? ) )
|
|
// XQueryParser.g:1412:11: kd= DECLARE DOLLAR qn= p_VarName (td= p_TypeDeclaration )? ( BIND es= p_ExprSingle )? ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( BIND p_ExprSingle )? )* SEMICOLON
|
|
kd=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_pm_BlockVarDecl12506); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DECLARE.add(kd);
|
|
|
|
DOLLAR594=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_pm_BlockVarDecl12508); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DOLLAR.add(DOLLAR594);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_pm_BlockVarDecl12512);
|
|
qn=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_VarName.add(qn.getTree());
|
|
// XQueryParser.g:1412:44: (td= p_TypeDeclaration )?
|
|
var alt188=2;
|
|
var LA188_0 = this.input.LA(1);
|
|
|
|
if ( (LA188_0==AS) ) {
|
|
alt188=1;
|
|
}
|
|
switch (alt188) {
|
|
case 1 :
|
|
// XQueryParser.g:1412:44: td= p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_pm_BlockVarDecl12516);
|
|
td=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_TypeDeclaration.add(td.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:1412:64: ( BIND es= p_ExprSingle )?
|
|
var alt189=2;
|
|
var LA189_0 = this.input.LA(1);
|
|
|
|
if ( (LA189_0==BIND) ) {
|
|
alt189=1;
|
|
}
|
|
switch (alt189) {
|
|
case 1 :
|
|
// XQueryParser.g:1412:65: BIND es= p_ExprSingle
|
|
BIND595=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_pm_BlockVarDecl12520); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_BIND.add(BIND595);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_pm_BlockVarDecl12524);
|
|
es=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ExprSingle.add(es.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:1412:88: ( COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( BIND p_ExprSingle )? )*
|
|
loop192:
|
|
do {
|
|
var alt192=2;
|
|
var LA192_0 = this.input.LA(1);
|
|
|
|
if ( (LA192_0==COMMA) ) {
|
|
alt192=1;
|
|
}
|
|
|
|
|
|
switch (alt192) {
|
|
case 1 :
|
|
// XQueryParser.g:1412:89: COMMA DOLLAR p_VarName ( p_TypeDeclaration )? ( BIND p_ExprSingle )?
|
|
COMMA596=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_pm_BlockVarDecl12529); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_COMMA.add(COMMA596);
|
|
|
|
DOLLAR597=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_pm_BlockVarDecl12531); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_DOLLAR.add(DOLLAR597);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_pm_BlockVarDecl12533);
|
|
p_VarName598=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_VarName.add(p_VarName598.getTree());
|
|
// XQueryParser.g:1412:112: ( p_TypeDeclaration )?
|
|
var alt190=2;
|
|
var LA190_0 = this.input.LA(1);
|
|
|
|
if ( (LA190_0==AS) ) {
|
|
alt190=1;
|
|
}
|
|
switch (alt190) {
|
|
case 1 :
|
|
// XQueryParser.g:1412:112: p_TypeDeclaration
|
|
this.pushFollow(XQueryParser.FOLLOW_p_TypeDeclaration_in_pm_BlockVarDecl12535);
|
|
p_TypeDeclaration599=this.p_TypeDeclaration();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_TypeDeclaration.add(p_TypeDeclaration599.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:1412:131: ( BIND p_ExprSingle )?
|
|
var alt191=2;
|
|
var LA191_0 = this.input.LA(1);
|
|
|
|
if ( (LA191_0==BIND) ) {
|
|
alt191=1;
|
|
}
|
|
switch (alt191) {
|
|
case 1 :
|
|
// XQueryParser.g:1412:132: BIND p_ExprSingle
|
|
BIND600=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_pm_BlockVarDecl12539); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_BIND.add(BIND600);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_pm_BlockVarDecl12541);
|
|
p_ExprSingle601=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_p_ExprSingle.add(p_ExprSingle601.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop192;
|
|
}
|
|
} while (true);
|
|
|
|
SEMICOLON602=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_pm_BlockVarDecl12547); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) stream_SEMICOLON.add(SEMICOLON602);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: td, es, qn
|
|
// token labels:
|
|
// rule labels: qn, retval, td, es
|
|
// token list labels:
|
|
// rule list labels:
|
|
if ( this.state.backtracking===0 ) {
|
|
retval.tree = root_0;
|
|
var stream_qn=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token qn",qn!=null?qn.tree:null);
|
|
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
|
|
var stream_td=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token td",td!=null?td.tree:null);
|
|
var stream_es=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token es",es!=null?es.tree:null);
|
|
|
|
root_0 = this.adaptor.nil();
|
|
// 1413:17: -> ^( BlockVarDecl $qn ( $td)? ( $es)? )
|
|
{
|
|
// XQueryParser.g:1413:21: ^( BlockVarDecl $qn ( $td)? ( $es)? )
|
|
{
|
|
var root_1 = this.adaptor.nil();
|
|
root_1 = this.adaptor.becomeRoot(this.adaptor.create(BlockVarDecl, "BlockVarDecl"), root_1);
|
|
|
|
this.adaptor.addChild(root_1, stream_qn.nextTree());
|
|
// XQueryParser.g:1413:40: ( $td)?
|
|
if ( stream_td.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_td.nextTree());
|
|
|
|
}
|
|
stream_td.reset();
|
|
// XQueryParser.g:1413:45: ( $es)?
|
|
if ( stream_es.hasNext() ) {
|
|
this.adaptor.addChild(root_1, stream_es.nextTree());
|
|
|
|
}
|
|
stream_es.reset();
|
|
|
|
this.adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;}
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_BlockBody_return: (function() {
|
|
XQueryParser.p_BlockBody_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_BlockBody_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1417:1: p_BlockBody : pm_Expr ;
|
|
// $ANTLR start "p_BlockBody"
|
|
p_BlockBody: function() {
|
|
var retval = new XQueryParser.p_BlockBody_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var pm_Expr603 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1418:9: ( pm_Expr )
|
|
// XQueryParser.g:1418:11: pm_Expr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_pm_Expr_in_p_BlockBody12607);
|
|
pm_Expr603=this.pm_Expr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, pm_Expr603.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_AssignmentExpr_return: (function() {
|
|
XQueryParser.p_AssignmentExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_AssignmentExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1422:1: p_AssignmentExpr : ks= SET DOLLAR p_VarName BIND p_ExprSingle ;
|
|
// $ANTLR start "p_AssignmentExpr"
|
|
p_AssignmentExpr: function() {
|
|
var retval = new XQueryParser.p_AssignmentExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ks = null;
|
|
var DOLLAR604 = null;
|
|
var BIND606 = null;
|
|
var p_VarName605 = null;
|
|
var p_ExprSingle607 = null;
|
|
|
|
var ks_tree=null;
|
|
var DOLLAR604_tree=null;
|
|
var BIND606_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1423:9: (ks= SET DOLLAR p_VarName BIND p_ExprSingle )
|
|
// XQueryParser.g:1423:11: ks= SET DOLLAR p_VarName BIND p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ks=this.match(this.input,SET,XQueryParser.FOLLOW_SET_in_p_AssignmentExpr12635); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ks_tree = this.adaptor.create(ks);
|
|
this.adaptor.addChild(root_0, ks_tree);
|
|
}
|
|
DOLLAR604=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_AssignmentExpr12637); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR604_tree = this.adaptor.create(DOLLAR604);
|
|
this.adaptor.addChild(root_0, DOLLAR604_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_AssignmentExpr12639);
|
|
p_VarName605=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName605.getTree());
|
|
BIND606=this.match(this.input,BIND,XQueryParser.FOLLOW_BIND_in_p_AssignmentExpr12641); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
BIND606_tree = this.adaptor.create(BIND606);
|
|
this.adaptor.addChild(root_0, BIND606_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_AssignmentExpr12643);
|
|
p_ExprSingle607=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle607.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ExitExpr_return: (function() {
|
|
XQueryParser.p_ExitExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ExitExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1427:1: p_ExitExpr : ke= EXIT kr= RETURNING p_ExprSingle ;
|
|
// $ANTLR start "p_ExitExpr"
|
|
p_ExitExpr: function() {
|
|
var retval = new XQueryParser.p_ExitExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ke = null;
|
|
var kr = null;
|
|
var p_ExprSingle608 = null;
|
|
|
|
var ke_tree=null;
|
|
var kr_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1428:9: (ke= EXIT kr= RETURNING p_ExprSingle )
|
|
// XQueryParser.g:1428:11: ke= EXIT kr= RETURNING p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ke=this.match(this.input,EXIT,XQueryParser.FOLLOW_EXIT_in_p_ExitExpr12671); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ke_tree = this.adaptor.create(ke);
|
|
this.adaptor.addChild(root_0, ke_tree);
|
|
}
|
|
kr=this.match(this.input,RETURNING,XQueryParser.FOLLOW_RETURNING_in_p_ExitExpr12675); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kr_tree = this.adaptor.create(kr);
|
|
this.adaptor.addChild(root_0, kr_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ExitExpr12677);
|
|
p_ExprSingle608=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle608.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WhileExpr_return: (function() {
|
|
XQueryParser.p_WhileExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WhileExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1432:1: p_WhileExpr : kw= WHILE LPAREN p_ExprSingle RPAREN p_WhileBody ;
|
|
// $ANTLR start "p_WhileExpr"
|
|
p_WhileExpr: function() {
|
|
var retval = new XQueryParser.p_WhileExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kw = null;
|
|
var LPAREN609 = null;
|
|
var RPAREN611 = null;
|
|
var p_ExprSingle610 = null;
|
|
var p_WhileBody612 = null;
|
|
|
|
var kw_tree=null;
|
|
var LPAREN609_tree=null;
|
|
var RPAREN611_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1433:9: (kw= WHILE LPAREN p_ExprSingle RPAREN p_WhileBody )
|
|
// XQueryParser.g:1433:11: kw= WHILE LPAREN p_ExprSingle RPAREN p_WhileBody
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kw=this.match(this.input,WHILE,XQueryParser.FOLLOW_WHILE_in_p_WhileExpr12705); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kw_tree = this.adaptor.create(kw);
|
|
this.adaptor.addChild(root_0, kw_tree);
|
|
}
|
|
LPAREN609=this.match(this.input,LPAREN,XQueryParser.FOLLOW_LPAREN_in_p_WhileExpr12707); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LPAREN609_tree = this.adaptor.create(LPAREN609);
|
|
this.adaptor.addChild(root_0, LPAREN609_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_WhileExpr12709);
|
|
p_ExprSingle610=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle610.getTree());
|
|
RPAREN611=this.match(this.input,RPAREN,XQueryParser.FOLLOW_RPAREN_in_p_WhileExpr12711); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RPAREN611_tree = this.adaptor.create(RPAREN611);
|
|
this.adaptor.addChild(root_0, RPAREN611_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_WhileBody_in_p_WhileExpr12713);
|
|
p_WhileBody612=this.p_WhileBody();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_WhileBody612.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_WhileBody_return: (function() {
|
|
XQueryParser.p_WhileBody_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_WhileBody_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1437:1: p_WhileBody : p_Block ;
|
|
// $ANTLR start "p_WhileBody"
|
|
p_WhileBody: function() {
|
|
var retval = new XQueryParser.p_WhileBody_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_Block613 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1438:9: ( p_Block )
|
|
// XQueryParser.g:1438:11: p_Block
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_Block_in_p_WhileBody12739);
|
|
p_Block613=this.p_Block();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_Block613.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_EvalExpr_return: (function() {
|
|
XQueryParser.p_EvalExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_EvalExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1446:1: p_EvalExpr : ( p_UsingClause )? ke= EVAL LBRACKET p_ExprSingle RBRACKET ;
|
|
// $ANTLR start "p_EvalExpr"
|
|
p_EvalExpr: function() {
|
|
var retval = new XQueryParser.p_EvalExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ke = null;
|
|
var LBRACKET615 = null;
|
|
var RBRACKET617 = null;
|
|
var p_UsingClause614 = null;
|
|
var p_ExprSingle616 = null;
|
|
|
|
var ke_tree=null;
|
|
var LBRACKET615_tree=null;
|
|
var RBRACKET617_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1447:9: ( ( p_UsingClause )? ke= EVAL LBRACKET p_ExprSingle RBRACKET )
|
|
// XQueryParser.g:1447:11: ( p_UsingClause )? ke= EVAL LBRACKET p_ExprSingle RBRACKET
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1447:11: ( p_UsingClause )?
|
|
var alt193=2;
|
|
var LA193_0 = this.input.LA(1);
|
|
|
|
if ( (LA193_0==USING) ) {
|
|
alt193=1;
|
|
}
|
|
switch (alt193) {
|
|
case 1 :
|
|
// XQueryParser.g:1447:11: p_UsingClause
|
|
this.pushFollow(XQueryParser.FOLLOW_p_UsingClause_in_p_EvalExpr12769);
|
|
p_UsingClause614=this.p_UsingClause();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_UsingClause614.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ke=this.match(this.input,EVAL,XQueryParser.FOLLOW_EVAL_in_p_EvalExpr12774); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ke_tree = this.adaptor.create(ke);
|
|
this.adaptor.addChild(root_0, ke_tree);
|
|
}
|
|
LBRACKET615=this.match(this.input,LBRACKET,XQueryParser.FOLLOW_LBRACKET_in_p_EvalExpr12776); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
LBRACKET615_tree = this.adaptor.create(LBRACKET615);
|
|
this.adaptor.addChild(root_0, LBRACKET615_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_EvalExpr12778);
|
|
p_ExprSingle616=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle616.getTree());
|
|
RBRACKET617=this.match(this.input,RBRACKET,XQueryParser.FOLLOW_RBRACKET_in_p_EvalExpr12780); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
RBRACKET617_tree = this.adaptor.create(RBRACKET617);
|
|
this.adaptor.addChild(root_0, RBRACKET617_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_UsingClause_return: (function() {
|
|
XQueryParser.p_UsingClause_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_UsingClause_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1450:1: p_UsingClause : ku= USING DOLLAR p_VarName ( COMMA DOLLAR p_VarName )* ;
|
|
// $ANTLR start "p_UsingClause"
|
|
p_UsingClause: function() {
|
|
var retval = new XQueryParser.p_UsingClause_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ku = null;
|
|
var DOLLAR618 = null;
|
|
var COMMA620 = null;
|
|
var DOLLAR621 = null;
|
|
var p_VarName619 = null;
|
|
var p_VarName622 = null;
|
|
|
|
var ku_tree=null;
|
|
var DOLLAR618_tree=null;
|
|
var COMMA620_tree=null;
|
|
var DOLLAR621_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1451:9: (ku= USING DOLLAR p_VarName ( COMMA DOLLAR p_VarName )* )
|
|
// XQueryParser.g:1451:11: ku= USING DOLLAR p_VarName ( COMMA DOLLAR p_VarName )*
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ku=this.match(this.input,USING,XQueryParser.FOLLOW_USING_in_p_UsingClause12807); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ku_tree = this.adaptor.create(ku);
|
|
this.adaptor.addChild(root_0, ku_tree);
|
|
}
|
|
DOLLAR618=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_UsingClause12809); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR618_tree = this.adaptor.create(DOLLAR618);
|
|
this.adaptor.addChild(root_0, DOLLAR618_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_UsingClause12811);
|
|
p_VarName619=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName619.getTree());
|
|
// XQueryParser.g:1451:37: ( COMMA DOLLAR p_VarName )*
|
|
loop194:
|
|
do {
|
|
var alt194=2;
|
|
var LA194_0 = this.input.LA(1);
|
|
|
|
if ( (LA194_0==COMMA) ) {
|
|
alt194=1;
|
|
}
|
|
|
|
|
|
switch (alt194) {
|
|
case 1 :
|
|
// XQueryParser.g:1451:38: COMMA DOLLAR p_VarName
|
|
COMMA620=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_UsingClause12814); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA620_tree = this.adaptor.create(COMMA620);
|
|
this.adaptor.addChild(root_0, COMMA620_tree);
|
|
}
|
|
DOLLAR621=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_UsingClause12816); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR621_tree = this.adaptor.create(DOLLAR621);
|
|
this.adaptor.addChild(root_0, DOLLAR621_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_VarName_in_p_UsingClause12818);
|
|
p_VarName622=this.p_VarName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_VarName622.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop194;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CollectionDecl_return: (function() {
|
|
XQueryParser.p_CollectionDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CollectionDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1460:1: p_CollectionDecl : k+= DECLARE p_CollProperties k+= COLLECTION p_QName ( p_CollectionTypeDecl )? (k+= WITH p_NodeModifier k+= NODES )? SEMICOLON ;
|
|
// $ANTLR start "p_CollectionDecl"
|
|
p_CollectionDecl: function() {
|
|
var retval = new XQueryParser.p_CollectionDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON627 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_CollProperties623 = null;
|
|
var p_QName624 = null;
|
|
var p_CollectionTypeDecl625 = null;
|
|
var p_NodeModifier626 = null;
|
|
|
|
var SEMICOLON627_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1461:9: (k+= DECLARE p_CollProperties k+= COLLECTION p_QName ( p_CollectionTypeDecl )? (k+= WITH p_NodeModifier k+= NODES )? SEMICOLON )
|
|
// XQueryParser.g:1461:11: k+= DECLARE p_CollProperties k+= COLLECTION p_QName ( p_CollectionTypeDecl )? (k+= WITH p_NodeModifier k+= NODES )? SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_p_CollectionDecl12853); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CollProperties_in_p_CollectionDecl12855);
|
|
p_CollProperties623=this.p_CollProperties();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CollProperties623.getTree());
|
|
k=this.match(this.input,COLLECTION,XQueryParser.FOLLOW_COLLECTION_in_p_CollectionDecl12859); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_CollectionDecl12861);
|
|
p_QName624=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName624.getTree());
|
|
// XQueryParser.g:1461:61: ( p_CollectionTypeDecl )?
|
|
var alt195=2;
|
|
var LA195_0 = this.input.LA(1);
|
|
|
|
if ( (LA195_0==AS) ) {
|
|
alt195=1;
|
|
}
|
|
switch (alt195) {
|
|
case 1 :
|
|
// XQueryParser.g:1461:61: p_CollectionTypeDecl
|
|
this.pushFollow(XQueryParser.FOLLOW_p_CollectionTypeDecl_in_p_CollectionDecl12863);
|
|
p_CollectionTypeDecl625=this.p_CollectionTypeDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_CollectionTypeDecl625.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// XQueryParser.g:1461:83: (k+= WITH p_NodeModifier k+= NODES )?
|
|
var alt196=2;
|
|
var LA196_0 = this.input.LA(1);
|
|
|
|
if ( (LA196_0==WITH) ) {
|
|
alt196=1;
|
|
}
|
|
switch (alt196) {
|
|
case 1 :
|
|
// XQueryParser.g:1461:84: k+= WITH p_NodeModifier k+= NODES
|
|
k=this.match(this.input,WITH,XQueryParser.FOLLOW_WITH_in_p_CollectionDecl12869); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_NodeModifier_in_p_CollectionDecl12871);
|
|
p_NodeModifier626=this.p_NodeModifier();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_NodeModifier626.getTree());
|
|
k=this.match(this.input,NODES,XQueryParser.FOLLOW_NODES_in_p_CollectionDecl12875); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON627=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_p_CollectionDecl12879); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON627_tree = this.adaptor.create(SEMICOLON627);
|
|
this.adaptor.addChild(root_0, SEMICOLON627_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CollProperties_return: (function() {
|
|
XQueryParser.p_CollProperties_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CollProperties_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1464:1: p_CollProperties : ( (k+= CONST | k+= MUTABLE | k+= APPEND_ONLY | k+= QUEUE | k+= ORDERED | k+= UNORDERED )* ) ;
|
|
// $ANTLR start "p_CollProperties"
|
|
p_CollProperties: function() {
|
|
var retval = new XQueryParser.p_CollProperties_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1465:9: ( ( (k+= CONST | k+= MUTABLE | k+= APPEND_ONLY | k+= QUEUE | k+= ORDERED | k+= UNORDERED )* ) )
|
|
// XQueryParser.g:1465:11: ( (k+= CONST | k+= MUTABLE | k+= APPEND_ONLY | k+= QUEUE | k+= ORDERED | k+= UNORDERED )* )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1465:11: ( (k+= CONST | k+= MUTABLE | k+= APPEND_ONLY | k+= QUEUE | k+= ORDERED | k+= UNORDERED )* )
|
|
// XQueryParser.g:1465:12: (k+= CONST | k+= MUTABLE | k+= APPEND_ONLY | k+= QUEUE | k+= ORDERED | k+= UNORDERED )*
|
|
// XQueryParser.g:1465:12: (k+= CONST | k+= MUTABLE | k+= APPEND_ONLY | k+= QUEUE | k+= ORDERED | k+= UNORDERED )*
|
|
loop197:
|
|
do {
|
|
var alt197=7;
|
|
switch ( this.input.LA(1) ) {
|
|
case CONST:
|
|
alt197=1;
|
|
break;
|
|
case MUTABLE:
|
|
alt197=2;
|
|
break;
|
|
case APPEND_ONLY:
|
|
alt197=3;
|
|
break;
|
|
case QUEUE:
|
|
alt197=4;
|
|
break;
|
|
case ORDERED:
|
|
alt197=5;
|
|
break;
|
|
case UNORDERED:
|
|
alt197=6;
|
|
break;
|
|
|
|
}
|
|
|
|
switch (alt197) {
|
|
case 1 :
|
|
// XQueryParser.g:1465:13: k+= CONST
|
|
k=this.match(this.input,CONST,XQueryParser.FOLLOW_CONST_in_p_CollProperties12909); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1465:24: k+= MUTABLE
|
|
k=this.match(this.input,MUTABLE,XQueryParser.FOLLOW_MUTABLE_in_p_CollProperties12915); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1466:11: k+= APPEND_ONLY
|
|
k=this.match(this.input,APPEND_ONLY,XQueryParser.FOLLOW_APPEND_ONLY_in_p_CollProperties12929); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:1466:28: k+= QUEUE
|
|
k=this.match(this.input,QUEUE,XQueryParser.FOLLOW_QUEUE_in_p_CollProperties12935); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:1467:11: k+= ORDERED
|
|
k=this.match(this.input,ORDERED,XQueryParser.FOLLOW_ORDERED_in_p_CollProperties12949); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:1467:24: k+= UNORDERED
|
|
k=this.match(this.input,UNORDERED,XQueryParser.FOLLOW_UNORDERED_in_p_CollProperties12955); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop197;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_CollectionTypeDecl_return: (function() {
|
|
XQueryParser.p_CollectionTypeDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_CollectionTypeDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1470:1: p_CollectionTypeDecl : (ka= AS p_KindTest ( ( p_OccurrenceIndicator )=> p_OccurrenceIndicator )? ) ;
|
|
// $ANTLR start "p_CollectionTypeDecl"
|
|
p_CollectionTypeDecl: function() {
|
|
var retval = new XQueryParser.p_CollectionTypeDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ka = null;
|
|
var p_KindTest628 = null;
|
|
var p_OccurrenceIndicator629 = null;
|
|
|
|
var ka_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1471:9: ( (ka= AS p_KindTest ( ( p_OccurrenceIndicator )=> p_OccurrenceIndicator )? ) )
|
|
// XQueryParser.g:1471:11: (ka= AS p_KindTest ( ( p_OccurrenceIndicator )=> p_OccurrenceIndicator )? )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1471:11: (ka= AS p_KindTest ( ( p_OccurrenceIndicator )=> p_OccurrenceIndicator )? )
|
|
// XQueryParser.g:1471:12: ka= AS p_KindTest ( ( p_OccurrenceIndicator )=> p_OccurrenceIndicator )?
|
|
ka=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_CollectionTypeDecl12987); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_KindTest_in_p_CollectionTypeDecl12989);
|
|
p_KindTest628=this.p_KindTest();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_KindTest628.getTree());
|
|
// XQueryParser.g:1471:29: ( ( p_OccurrenceIndicator )=> p_OccurrenceIndicator )?
|
|
var alt198=2;
|
|
var LA198_0 = this.input.LA(1);
|
|
|
|
if ( ((LA198_0>=QUESTION && LA198_0<=PLUS)) && (this.synpred3_XQueryParser())) {
|
|
alt198=1;
|
|
}
|
|
switch (alt198) {
|
|
case 1 :
|
|
// XQueryParser.g:1471:30: ( p_OccurrenceIndicator )=> p_OccurrenceIndicator
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OccurrenceIndicator_in_p_CollectionTypeDecl12998);
|
|
p_OccurrenceIndicator629=this.p_OccurrenceIndicator();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_OccurrenceIndicator629.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_NodeModifier_return: (function() {
|
|
XQueryParser.p_NodeModifier_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_NodeModifier_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1474:1: p_NodeModifier : (k+= READ_ONLY | k+= MUTABLE ) ;
|
|
// $ANTLR start "p_NodeModifier"
|
|
p_NodeModifier: function() {
|
|
var retval = new XQueryParser.p_NodeModifier_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1475:9: ( (k+= READ_ONLY | k+= MUTABLE ) )
|
|
// XQueryParser.g:1475:11: (k+= READ_ONLY | k+= MUTABLE )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1475:11: (k+= READ_ONLY | k+= MUTABLE )
|
|
var alt199=2;
|
|
var LA199_0 = this.input.LA(1);
|
|
|
|
if ( (LA199_0==READ_ONLY) ) {
|
|
alt199=1;
|
|
}
|
|
else if ( (LA199_0==MUTABLE) ) {
|
|
alt199=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 199, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt199) {
|
|
case 1 :
|
|
// XQueryParser.g:1475:12: k+= READ_ONLY
|
|
k=this.match(this.input,READ_ONLY,XQueryParser.FOLLOW_READ_ONLY_in_p_NodeModifier13029); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1475:27: k+= MUTABLE
|
|
k=this.match(this.input,MUTABLE,XQueryParser.FOLLOW_MUTABLE_in_p_NodeModifier13035); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexDecl_return: (function() {
|
|
XQueryParser.p_IndexDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1478:1: p_IndexDecl : k+= DECLARE p_IndexProperties k+= INDEX p_IndexName k+= ON k+= NODES p_IndexDomainExpr k+= BY p_IndexKeySpec ( COMMA p_IndexKeySpec )* SEMICOLON ;
|
|
// $ANTLR start "p_IndexDecl"
|
|
p_IndexDecl: function() {
|
|
var retval = new XQueryParser.p_IndexDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var COMMA634 = null;
|
|
var SEMICOLON636 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_IndexProperties630 = null;
|
|
var p_IndexName631 = null;
|
|
var p_IndexDomainExpr632 = null;
|
|
var p_IndexKeySpec633 = null;
|
|
var p_IndexKeySpec635 = null;
|
|
|
|
var COMMA634_tree=null;
|
|
var SEMICOLON636_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1479:9: (k+= DECLARE p_IndexProperties k+= INDEX p_IndexName k+= ON k+= NODES p_IndexDomainExpr k+= BY p_IndexKeySpec ( COMMA p_IndexKeySpec )* SEMICOLON )
|
|
// XQueryParser.g:1479:11: k+= DECLARE p_IndexProperties k+= INDEX p_IndexName k+= ON k+= NODES p_IndexDomainExpr k+= BY p_IndexKeySpec ( COMMA p_IndexKeySpec )* SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_p_IndexDecl13064); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexProperties_in_p_IndexDecl13066);
|
|
p_IndexProperties630=this.p_IndexProperties();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexProperties630.getTree());
|
|
k=this.match(this.input,INDEX,XQueryParser.FOLLOW_INDEX_in_p_IndexDecl13070); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexName_in_p_IndexDecl13072);
|
|
p_IndexName631=this.p_IndexName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexName631.getTree());
|
|
k=this.match(this.input,ON,XQueryParser.FOLLOW_ON_in_p_IndexDecl13076); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,NODES,XQueryParser.FOLLOW_NODES_in_p_IndexDecl13080); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexDomainExpr_in_p_IndexDecl13082);
|
|
p_IndexDomainExpr632=this.p_IndexDomainExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexDomainExpr632.getTree());
|
|
k=this.match(this.input,BY,XQueryParser.FOLLOW_BY_in_p_IndexDecl13086); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexKeySpec_in_p_IndexDecl13088);
|
|
p_IndexKeySpec633=this.p_IndexKeySpec();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexKeySpec633.getTree());
|
|
// XQueryParser.g:1479:115: ( COMMA p_IndexKeySpec )*
|
|
loop200:
|
|
do {
|
|
var alt200=2;
|
|
var LA200_0 = this.input.LA(1);
|
|
|
|
if ( (LA200_0==COMMA) ) {
|
|
alt200=1;
|
|
}
|
|
|
|
|
|
switch (alt200) {
|
|
case 1 :
|
|
// XQueryParser.g:1479:116: COMMA p_IndexKeySpec
|
|
COMMA634=this.match(this.input,COMMA,XQueryParser.FOLLOW_COMMA_in_p_IndexDecl13091); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
COMMA634_tree = this.adaptor.create(COMMA634);
|
|
this.adaptor.addChild(root_0, COMMA634_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexKeySpec_in_p_IndexDecl13093);
|
|
p_IndexKeySpec635=this.p_IndexKeySpec();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexKeySpec635.getTree());
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop200;
|
|
}
|
|
} while (true);
|
|
|
|
SEMICOLON636=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_p_IndexDecl13097); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON636_tree = this.adaptor.create(SEMICOLON636);
|
|
this.adaptor.addChild(root_0, SEMICOLON636_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexName_return: (function() {
|
|
XQueryParser.p_IndexName_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexName_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1482:1: p_IndexName : p_QName ;
|
|
// $ANTLR start "p_IndexName"
|
|
p_IndexName: function() {
|
|
var retval = new XQueryParser.p_IndexName_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_QName637 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1483:9: ( p_QName )
|
|
// XQueryParser.g:1483:11: p_QName
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_IndexName13123);
|
|
p_QName637=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName637.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexProperties_return: (function() {
|
|
XQueryParser.p_IndexProperties_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexProperties_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1486:1: p_IndexProperties : ( (k+= UNIQUE | k+= NON k+= UNIQUE | k+= VALUE k+= RANGE | k+= VALUE k+= EQUALITY | k+= AUTOMATICALLY k+= MAINTAINED | k+= MANUALLY k+= MAINTAINED )* ) ;
|
|
// $ANTLR start "p_IndexProperties"
|
|
p_IndexProperties: function() {
|
|
var retval = new XQueryParser.p_IndexProperties_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1487:9: ( ( (k+= UNIQUE | k+= NON k+= UNIQUE | k+= VALUE k+= RANGE | k+= VALUE k+= EQUALITY | k+= AUTOMATICALLY k+= MAINTAINED | k+= MANUALLY k+= MAINTAINED )* ) )
|
|
// XQueryParser.g:1487:11: ( (k+= UNIQUE | k+= NON k+= UNIQUE | k+= VALUE k+= RANGE | k+= VALUE k+= EQUALITY | k+= AUTOMATICALLY k+= MAINTAINED | k+= MANUALLY k+= MAINTAINED )* )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
// XQueryParser.g:1487:11: ( (k+= UNIQUE | k+= NON k+= UNIQUE | k+= VALUE k+= RANGE | k+= VALUE k+= EQUALITY | k+= AUTOMATICALLY k+= MAINTAINED | k+= MANUALLY k+= MAINTAINED )* )
|
|
// XQueryParser.g:1487:12: (k+= UNIQUE | k+= NON k+= UNIQUE | k+= VALUE k+= RANGE | k+= VALUE k+= EQUALITY | k+= AUTOMATICALLY k+= MAINTAINED | k+= MANUALLY k+= MAINTAINED )*
|
|
// XQueryParser.g:1487:12: (k+= UNIQUE | k+= NON k+= UNIQUE | k+= VALUE k+= RANGE | k+= VALUE k+= EQUALITY | k+= AUTOMATICALLY k+= MAINTAINED | k+= MANUALLY k+= MAINTAINED )*
|
|
loop201:
|
|
do {
|
|
var alt201=7;
|
|
switch ( this.input.LA(1) ) {
|
|
case UNIQUE:
|
|
alt201=1;
|
|
break;
|
|
case NON:
|
|
alt201=2;
|
|
break;
|
|
case VALUE:
|
|
var LA201_4 = this.input.LA(2);
|
|
|
|
if ( (LA201_4==RANGE) ) {
|
|
alt201=3;
|
|
}
|
|
else if ( (LA201_4==EQUALITY) ) {
|
|
alt201=4;
|
|
}
|
|
|
|
|
|
break;
|
|
case AUTOMATICALLY:
|
|
alt201=5;
|
|
break;
|
|
case MANUALLY:
|
|
alt201=6;
|
|
break;
|
|
|
|
}
|
|
|
|
switch (alt201) {
|
|
case 1 :
|
|
// XQueryParser.g:1487:13: k+= UNIQUE
|
|
k=this.match(this.input,UNIQUE,XQueryParser.FOLLOW_UNIQUE_in_p_IndexProperties13152); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1487:25: k+= NON k+= UNIQUE
|
|
k=this.match(this.input,NON,XQueryParser.FOLLOW_NON_in_p_IndexProperties13158); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,UNIQUE,XQueryParser.FOLLOW_UNIQUE_in_p_IndexProperties13162); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1488:11: k+= VALUE k+= RANGE
|
|
k=this.match(this.input,VALUE,XQueryParser.FOLLOW_VALUE_in_p_IndexProperties13176); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,RANGE,XQueryParser.FOLLOW_RANGE_in_p_IndexProperties13180); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 4 :
|
|
// XQueryParser.g:1488:31: k+= VALUE k+= EQUALITY
|
|
k=this.match(this.input,VALUE,XQueryParser.FOLLOW_VALUE_in_p_IndexProperties13186); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,EQUALITY,XQueryParser.FOLLOW_EQUALITY_in_p_IndexProperties13190); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 5 :
|
|
// XQueryParser.g:1489:11: k+= AUTOMATICALLY k+= MAINTAINED
|
|
k=this.match(this.input,AUTOMATICALLY,XQueryParser.FOLLOW_AUTOMATICALLY_in_p_IndexProperties13204); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,MAINTAINED,XQueryParser.FOLLOW_MAINTAINED_in_p_IndexProperties13208); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
case 6 :
|
|
// XQueryParser.g:1489:44: k+= MANUALLY k+= MAINTAINED
|
|
k=this.match(this.input,MANUALLY,XQueryParser.FOLLOW_MANUALLY_in_p_IndexProperties13214); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,MAINTAINED,XQueryParser.FOLLOW_MAINTAINED_in_p_IndexProperties13218); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
|
|
|
|
break;
|
|
|
|
default :
|
|
break loop201;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexDomainExpr_return: (function() {
|
|
XQueryParser.p_IndexDomainExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexDomainExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1492:1: p_IndexDomainExpr : p_PathExpr ;
|
|
// $ANTLR start "p_IndexDomainExpr"
|
|
p_IndexDomainExpr: function() {
|
|
var retval = new XQueryParser.p_IndexDomainExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_PathExpr638 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1493:9: ( p_PathExpr )
|
|
// XQueryParser.g:1493:11: p_PathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PathExpr_in_p_IndexDomainExpr13247);
|
|
p_PathExpr638=this.p_PathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PathExpr638.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexKeySpec_return: (function() {
|
|
XQueryParser.p_IndexKeySpec_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexKeySpec_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1496:1: p_IndexKeySpec : p_IndexKeyExpr p_IndexKeyTypeDecl ( p_IndexKeyCollation )? ;
|
|
// $ANTLR start "p_IndexKeySpec"
|
|
p_IndexKeySpec: function() {
|
|
var retval = new XQueryParser.p_IndexKeySpec_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_IndexKeyExpr639 = null;
|
|
var p_IndexKeyTypeDecl640 = null;
|
|
var p_IndexKeyCollation641 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1497:9: ( p_IndexKeyExpr p_IndexKeyTypeDecl ( p_IndexKeyCollation )? )
|
|
// XQueryParser.g:1497:11: p_IndexKeyExpr p_IndexKeyTypeDecl ( p_IndexKeyCollation )?
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexKeyExpr_in_p_IndexKeySpec13272);
|
|
p_IndexKeyExpr639=this.p_IndexKeyExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexKeyExpr639.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexKeyTypeDecl_in_p_IndexKeySpec13274);
|
|
p_IndexKeyTypeDecl640=this.p_IndexKeyTypeDecl();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexKeyTypeDecl640.getTree());
|
|
// XQueryParser.g:1497:45: ( p_IndexKeyCollation )?
|
|
var alt202=2;
|
|
var LA202_0 = this.input.LA(1);
|
|
|
|
if ( (LA202_0==COLLATION) ) {
|
|
alt202=1;
|
|
}
|
|
switch (alt202) {
|
|
case 1 :
|
|
// XQueryParser.g:1497:45: p_IndexKeyCollation
|
|
this.pushFollow(XQueryParser.FOLLOW_p_IndexKeyCollation_in_p_IndexKeySpec13276);
|
|
p_IndexKeyCollation641=this.p_IndexKeyCollation();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_IndexKeyCollation641.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexKeyExpr_return: (function() {
|
|
XQueryParser.p_IndexKeyExpr_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexKeyExpr_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1500:1: p_IndexKeyExpr : p_PathExpr ;
|
|
// $ANTLR start "p_IndexKeyExpr"
|
|
p_IndexKeyExpr: function() {
|
|
var retval = new XQueryParser.p_IndexKeyExpr_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var p_PathExpr642 = null;
|
|
|
|
|
|
try {
|
|
// XQueryParser.g:1501:9: ( p_PathExpr )
|
|
// XQueryParser.g:1501:11: p_PathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PathExpr_in_p_IndexKeyExpr13302);
|
|
p_PathExpr642=this.p_PathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PathExpr642.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexKeyTypeDecl_return: (function() {
|
|
XQueryParser.p_IndexKeyTypeDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexKeyTypeDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1504:1: p_IndexKeyTypeDecl : ka= AS p_AtomicType ;
|
|
// $ANTLR start "p_IndexKeyTypeDecl"
|
|
p_IndexKeyTypeDecl: function() {
|
|
var retval = new XQueryParser.p_IndexKeyTypeDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var ka = null;
|
|
var p_AtomicType643 = null;
|
|
|
|
var ka_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1505:9: (ka= AS p_AtomicType )
|
|
// XQueryParser.g:1505:11: ka= AS p_AtomicType
|
|
root_0 = this.adaptor.nil();
|
|
|
|
ka=this.match(this.input,AS,XQueryParser.FOLLOW_AS_in_p_IndexKeyTypeDecl13329); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
ka_tree = this.adaptor.create(ka);
|
|
this.adaptor.addChild(root_0, ka_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_AtomicType_in_p_IndexKeyTypeDecl13331);
|
|
p_AtomicType643=this.p_AtomicType();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_AtomicType643.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_IndexKeyCollation_return: (function() {
|
|
XQueryParser.p_IndexKeyCollation_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_IndexKeyCollation_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1508:1: p_IndexKeyCollation : kc= COLLATION p_StringLiteral ;
|
|
// $ANTLR start "p_IndexKeyCollation"
|
|
p_IndexKeyCollation: function() {
|
|
var retval = new XQueryParser.p_IndexKeyCollation_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var p_StringLiteral644 = null;
|
|
|
|
var kc_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1509:9: (kc= COLLATION p_StringLiteral )
|
|
// XQueryParser.g:1509:11: kc= COLLATION p_StringLiteral
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kc=this.match(this.input,COLLATION,XQueryParser.FOLLOW_COLLATION_in_p_IndexKeyCollation13358); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_StringLiteral_in_p_IndexKeyCollation13360);
|
|
p_StringLiteral644=this.p_StringLiteral();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_StringLiteral644.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICDecl_return: (function() {
|
|
XQueryParser.p_ICDecl_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICDecl_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1512:1: p_ICDecl : k+= DECLARE k+= INTEGRITY k+= CONSTRAINT p_QName ( p_ICCollection | p_ICForeignKey ) SEMICOLON ;
|
|
// $ANTLR start "p_ICDecl"
|
|
p_ICDecl: function() {
|
|
var retval = new XQueryParser.p_ICDecl_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var SEMICOLON648 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName645 = null;
|
|
var p_ICCollection646 = null;
|
|
var p_ICForeignKey647 = null;
|
|
|
|
var SEMICOLON648_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1513:9: (k+= DECLARE k+= INTEGRITY k+= CONSTRAINT p_QName ( p_ICCollection | p_ICForeignKey ) SEMICOLON )
|
|
// XQueryParser.g:1513:11: k+= DECLARE k+= INTEGRITY k+= CONSTRAINT p_QName ( p_ICCollection | p_ICForeignKey ) SEMICOLON
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,DECLARE,XQueryParser.FOLLOW_DECLARE_in_p_ICDecl13387); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,INTEGRITY,XQueryParser.FOLLOW_INTEGRITY_in_p_ICDecl13391); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,CONSTRAINT,XQueryParser.FOLLOW_CONSTRAINT_in_p_ICDecl13395); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICDecl13398);
|
|
p_QName645=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName645.getTree());
|
|
// XQueryParser.g:1513:58: ( p_ICCollection | p_ICForeignKey )
|
|
var alt203=2;
|
|
var LA203_0 = this.input.LA(1);
|
|
|
|
if ( (LA203_0==ON) ) {
|
|
alt203=1;
|
|
}
|
|
else if ( (LA203_0==FOREIGN) ) {
|
|
alt203=2;
|
|
}
|
|
else {
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 203, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt203) {
|
|
case 1 :
|
|
// XQueryParser.g:1513:59: p_ICCollection
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICCollection_in_p_ICDecl13401);
|
|
p_ICCollection646=this.p_ICCollection();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICCollection646.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1513:76: p_ICForeignKey
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICForeignKey_in_p_ICDecl13405);
|
|
p_ICForeignKey647=this.p_ICForeignKey();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICForeignKey647.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SEMICOLON648=this.match(this.input,SEMICOLON,XQueryParser.FOLLOW_SEMICOLON_in_p_ICDecl13408); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
SEMICOLON648_tree = this.adaptor.create(SEMICOLON648);
|
|
this.adaptor.addChild(root_0, SEMICOLON648_tree);
|
|
}
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICCollection_return: (function() {
|
|
XQueryParser.p_ICCollection_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICCollection_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1516:1: p_ICCollection : k+= ON k+= COLLECTION p_QName ( p_ICCollSequence | p_ICCollSequenceUnique | p_ICCollNode ) ;
|
|
// $ANTLR start "p_ICCollection"
|
|
p_ICCollection: function() {
|
|
var retval = new XQueryParser.p_ICCollection_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName649 = null;
|
|
var p_ICCollSequence650 = null;
|
|
var p_ICCollSequenceUnique651 = null;
|
|
var p_ICCollNode652 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1517:9: (k+= ON k+= COLLECTION p_QName ( p_ICCollSequence | p_ICCollSequenceUnique | p_ICCollNode ) )
|
|
// XQueryParser.g:1517:11: k+= ON k+= COLLECTION p_QName ( p_ICCollSequence | p_ICCollSequenceUnique | p_ICCollNode )
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,ON,XQueryParser.FOLLOW_ON_in_p_ICCollection13435); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,COLLECTION,XQueryParser.FOLLOW_COLLECTION_in_p_ICCollection13439); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICCollection13442);
|
|
p_QName649=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName649.getTree());
|
|
// XQueryParser.g:1517:40: ( p_ICCollSequence | p_ICCollSequenceUnique | p_ICCollNode )
|
|
var alt204=3;
|
|
switch ( this.input.LA(1) ) {
|
|
case DOLLAR:
|
|
alt204=1;
|
|
break;
|
|
case NODE:
|
|
alt204=2;
|
|
break;
|
|
case FOREACH:
|
|
alt204=3;
|
|
break;
|
|
default:
|
|
if (this.state.backtracking>0) {this.state.failed=true; return retval;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException("", 204, 0, this.input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt204) {
|
|
case 1 :
|
|
// XQueryParser.g:1517:41: p_ICCollSequence
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICCollSequence_in_p_ICCollection13445);
|
|
p_ICCollSequence650=this.p_ICCollSequence();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICCollSequence650.getTree());
|
|
|
|
|
|
break;
|
|
case 2 :
|
|
// XQueryParser.g:1517:60: p_ICCollSequenceUnique
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICCollSequenceUnique_in_p_ICCollection13449);
|
|
p_ICCollSequenceUnique651=this.p_ICCollSequenceUnique();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICCollSequenceUnique651.getTree());
|
|
|
|
|
|
break;
|
|
case 3 :
|
|
// XQueryParser.g:1517:85: p_ICCollNode
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICCollNode_in_p_ICCollection13453);
|
|
p_ICCollNode652=this.p_ICCollNode();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICCollNode652.getTree());
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICCollSequence_return: (function() {
|
|
XQueryParser.p_ICCollSequence_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICCollSequence_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1520:1: p_ICCollSequence : DOLLAR p_QName kc= CHECK p_ExprSingle ;
|
|
// $ANTLR start "p_ICCollSequence"
|
|
p_ICCollSequence: function() {
|
|
var retval = new XQueryParser.p_ICCollSequence_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kc = null;
|
|
var DOLLAR653 = null;
|
|
var p_QName654 = null;
|
|
var p_ExprSingle655 = null;
|
|
|
|
var kc_tree=null;
|
|
var DOLLAR653_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1521:9: ( DOLLAR p_QName kc= CHECK p_ExprSingle )
|
|
// XQueryParser.g:1521:11: DOLLAR p_QName kc= CHECK p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
DOLLAR653=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_ICCollSequence13479); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR653_tree = this.adaptor.create(DOLLAR653);
|
|
this.adaptor.addChild(root_0, DOLLAR653_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICCollSequence13481);
|
|
p_QName654=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName654.getTree());
|
|
kc=this.match(this.input,CHECK,XQueryParser.FOLLOW_CHECK_in_p_ICCollSequence13485); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kc_tree = this.adaptor.create(kc);
|
|
this.adaptor.addChild(root_0, kc_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ICCollSequence13487);
|
|
p_ExprSingle655=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle655.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICCollSequenceUnique_return: (function() {
|
|
XQueryParser.p_ICCollSequenceUnique_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICCollSequenceUnique_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1524:1: p_ICCollSequenceUnique : k+= NODE k+= DOLLAR p_QName k+= CHECK k+= UNIQUE k+= KEY p_PathExpr ;
|
|
// $ANTLR start "p_ICCollSequenceUnique"
|
|
p_ICCollSequenceUnique: function() {
|
|
var retval = new XQueryParser.p_ICCollSequenceUnique_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName656 = null;
|
|
var p_PathExpr657 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1525:9: (k+= NODE k+= DOLLAR p_QName k+= CHECK k+= UNIQUE k+= KEY p_PathExpr )
|
|
// XQueryParser.g:1525:11: k+= NODE k+= DOLLAR p_QName k+= CHECK k+= UNIQUE k+= KEY p_PathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_ICCollSequenceUnique13514); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_ICCollSequenceUnique13518); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICCollSequenceUnique13520);
|
|
p_QName656=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName656.getTree());
|
|
k=this.match(this.input,CHECK,XQueryParser.FOLLOW_CHECK_in_p_ICCollSequenceUnique13524); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,UNIQUE,XQueryParser.FOLLOW_UNIQUE_in_p_ICCollSequenceUnique13528); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,KEY,XQueryParser.FOLLOW_KEY_in_p_ICCollSequenceUnique13532); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PathExpr_in_p_ICCollSequenceUnique13534);
|
|
p_PathExpr657=this.p_PathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PathExpr657.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICCollNode_return: (function() {
|
|
XQueryParser.p_ICCollNode_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICCollNode_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1528:1: p_ICCollNode : k+= FOREACH k+= NODE DOLLAR p_QName k+= CHECK p_ExprSingle ;
|
|
// $ANTLR start "p_ICCollNode"
|
|
p_ICCollNode: function() {
|
|
var retval = new XQueryParser.p_ICCollNode_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR658 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName659 = null;
|
|
var p_ExprSingle660 = null;
|
|
|
|
var DOLLAR658_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1529:9: (k+= FOREACH k+= NODE DOLLAR p_QName k+= CHECK p_ExprSingle )
|
|
// XQueryParser.g:1529:11: k+= FOREACH k+= NODE DOLLAR p_QName k+= CHECK p_ExprSingle
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,FOREACH,XQueryParser.FOLLOW_FOREACH_in_p_ICCollNode13562); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_ICCollNode13566); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR658=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_ICCollNode13568); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR658_tree = this.adaptor.create(DOLLAR658);
|
|
this.adaptor.addChild(root_0, DOLLAR658_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICCollNode13570);
|
|
p_QName659=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName659.getTree());
|
|
k=this.match(this.input,CHECK,XQueryParser.FOLLOW_CHECK_in_p_ICCollNode13574); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ExprSingle_in_p_ICCollNode13576);
|
|
p_ExprSingle660=this.p_ExprSingle();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ExprSingle660.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICForeignKey_return: (function() {
|
|
XQueryParser.p_ICForeignKey_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICForeignKey_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1532:1: p_ICForeignKey : k+= FOREIGN k+= KEY p_ICForeignKeySource p_ICForeignKeyTarget ;
|
|
// $ANTLR start "p_ICForeignKey"
|
|
p_ICForeignKey: function() {
|
|
var retval = new XQueryParser.p_ICForeignKey_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_ICForeignKeySource661 = null;
|
|
var p_ICForeignKeyTarget662 = null;
|
|
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1533:9: (k+= FOREIGN k+= KEY p_ICForeignKeySource p_ICForeignKeyTarget )
|
|
// XQueryParser.g:1533:11: k+= FOREIGN k+= KEY p_ICForeignKeySource p_ICForeignKeyTarget
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,FOREIGN,XQueryParser.FOLLOW_FOREIGN_in_p_ICForeignKey13604); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
k=this.match(this.input,KEY,XQueryParser.FOLLOW_KEY_in_p_ICForeignKey13608); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICForeignKeySource_in_p_ICForeignKey13610);
|
|
p_ICForeignKeySource661=this.p_ICForeignKeySource();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICForeignKeySource661.getTree());
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICForeignKeyTarget_in_p_ICForeignKey13612);
|
|
p_ICForeignKeyTarget662=this.p_ICForeignKeyTarget();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICForeignKeyTarget662.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICForeignKeySource_return: (function() {
|
|
XQueryParser.p_ICForeignKeySource_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICForeignKeySource_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1536:1: p_ICForeignKeySource : kf= FROM p_ICForeignKeyValues ;
|
|
// $ANTLR start "p_ICForeignKeySource"
|
|
p_ICForeignKeySource: function() {
|
|
var retval = new XQueryParser.p_ICForeignKeySource_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kf = null;
|
|
var p_ICForeignKeyValues663 = null;
|
|
|
|
var kf_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1537:9: (kf= FROM p_ICForeignKeyValues )
|
|
// XQueryParser.g:1537:11: kf= FROM p_ICForeignKeyValues
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kf=this.match(this.input,FROM,XQueryParser.FOLLOW_FROM_in_p_ICForeignKeySource13640); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kf_tree = this.adaptor.create(kf);
|
|
this.adaptor.addChild(root_0, kf_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICForeignKeyValues_in_p_ICForeignKeySource13642);
|
|
p_ICForeignKeyValues663=this.p_ICForeignKeyValues();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICForeignKeyValues663.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICForeignKeyTarget_return: (function() {
|
|
XQueryParser.p_ICForeignKeyTarget_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICForeignKeyTarget_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1540:1: p_ICForeignKeyTarget : kt= TO p_ICForeignKeyValues ;
|
|
// $ANTLR start "p_ICForeignKeyTarget"
|
|
p_ICForeignKeyTarget: function() {
|
|
var retval = new XQueryParser.p_ICForeignKeyTarget_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var kt = null;
|
|
var p_ICForeignKeyValues664 = null;
|
|
|
|
var kt_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1541:9: (kt= TO p_ICForeignKeyValues )
|
|
// XQueryParser.g:1541:11: kt= TO p_ICForeignKeyValues
|
|
root_0 = this.adaptor.nil();
|
|
|
|
kt=this.match(this.input,TO,XQueryParser.FOLLOW_TO_in_p_ICForeignKeyTarget13669); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
kt_tree = this.adaptor.create(kt);
|
|
this.adaptor.addChild(root_0, kt_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_ICForeignKeyValues_in_p_ICForeignKeyTarget13671);
|
|
p_ICForeignKeyValues664=this.p_ICForeignKeyValues();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_ICForeignKeyValues664.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// inline static return class
|
|
p_ICForeignKeyValues_return: (function() {
|
|
XQueryParser.p_ICForeignKeyValues_return = function(){};
|
|
org.antlr.lang.extend(XQueryParser.p_ICForeignKeyValues_return,
|
|
org.antlr.runtime.ParserRuleReturnScope,
|
|
{
|
|
getTree: function() { return this.tree; }
|
|
});
|
|
return;
|
|
})(),
|
|
|
|
// XQueryParser.g:1544:1: p_ICForeignKeyValues : k+= COLLECTION p_QName k+= NODE DOLLAR p_QName k+= KEY p_PathExpr ;
|
|
// $ANTLR start "p_ICForeignKeyValues"
|
|
p_ICForeignKeyValues: function() {
|
|
var retval = new XQueryParser.p_ICForeignKeyValues_return();
|
|
retval.start = this.input.LT(1);
|
|
|
|
var root_0 = null;
|
|
|
|
var DOLLAR666 = null;
|
|
var k = null;
|
|
var list_k=null;
|
|
var p_QName665 = null;
|
|
var p_QName667 = null;
|
|
var p_PathExpr668 = null;
|
|
|
|
var DOLLAR666_tree=null;
|
|
var k_tree=null;
|
|
|
|
try {
|
|
// XQueryParser.g:1545:9: (k+= COLLECTION p_QName k+= NODE DOLLAR p_QName k+= KEY p_PathExpr )
|
|
// XQueryParser.g:1545:11: k+= COLLECTION p_QName k+= NODE DOLLAR p_QName k+= KEY p_PathExpr
|
|
root_0 = this.adaptor.nil();
|
|
|
|
k=this.match(this.input,COLLECTION,XQueryParser.FOLLOW_COLLECTION_in_p_ICForeignKeyValues13698); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICForeignKeyValues13700);
|
|
p_QName665=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName665.getTree());
|
|
k=this.match(this.input,NODE,XQueryParser.FOLLOW_NODE_in_p_ICForeignKeyValues13704); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
DOLLAR666=this.match(this.input,DOLLAR,XQueryParser.FOLLOW_DOLLAR_in_p_ICForeignKeyValues13706); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
DOLLAR666_tree = this.adaptor.create(DOLLAR666);
|
|
this.adaptor.addChild(root_0, DOLLAR666_tree);
|
|
}
|
|
this.pushFollow(XQueryParser.FOLLOW_p_QName_in_p_ICForeignKeyValues13708);
|
|
p_QName667=this.p_QName();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_QName667.getTree());
|
|
k=this.match(this.input,KEY,XQueryParser.FOLLOW_KEY_in_p_ICForeignKeyValues13712); if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) {
|
|
k_tree = this.adaptor.create(k);
|
|
this.adaptor.addChild(root_0, k_tree);
|
|
}
|
|
if (org.antlr.lang.isNull(list_k)) list_k = [];
|
|
list_k.push(k);
|
|
|
|
this.pushFollow(XQueryParser.FOLLOW_p_PathExpr_in_p_ICForeignKeyValues13714);
|
|
p_PathExpr668=this.p_PathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return retval;
|
|
if ( this.state.backtracking===0 ) this.adaptor.addChild(root_0, p_PathExpr668.getTree());
|
|
|
|
|
|
|
|
retval.stop = this.input.LT(-1);
|
|
|
|
if ( this.state.backtracking===0 ) {
|
|
|
|
retval.tree = this.adaptor.rulePostProcessing(root_0);
|
|
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof org.antlr.runtime.RecognitionException) {
|
|
this.reportError(re);
|
|
this.recover(this.input,re);
|
|
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
},
|
|
|
|
// $ANTLR start "synpred1_XQueryParser"
|
|
synpred1_XQueryParser_fragment: function() {
|
|
// XQueryParser.g:657:11: ( SLASH p_RelativePathExpr )
|
|
// XQueryParser.g:657:12: SLASH p_RelativePathExpr
|
|
this.match(this.input,SLASH,XQueryParser.FOLLOW_SLASH_in_synpred1_XQueryParser5860); if (this.state.failed) return ;
|
|
this.pushFollow(XQueryParser.FOLLOW_p_RelativePathExpr_in_synpred1_XQueryParser5862);
|
|
this.p_RelativePathExpr();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return ;
|
|
|
|
|
|
},
|
|
// $ANTLR end "synpred1_XQueryParser",
|
|
|
|
// $ANTLR start "synpred2_XQueryParser"
|
|
synpred2_XQueryParser_fragment: function() {
|
|
// XQueryParser.g:1011:26: ( p_OccurrenceIndicator )
|
|
// XQueryParser.g:1011:27: p_OccurrenceIndicator
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OccurrenceIndicator_in_synpred2_XQueryParser8510);
|
|
this.p_OccurrenceIndicator();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return ;
|
|
|
|
|
|
},
|
|
// $ANTLR end "synpred2_XQueryParser",
|
|
|
|
// $ANTLR start "synpred3_XQueryParser"
|
|
synpred3_XQueryParser_fragment: function() {
|
|
// XQueryParser.g:1471:30: ( p_OccurrenceIndicator )
|
|
// XQueryParser.g:1471:31: p_OccurrenceIndicator
|
|
this.pushFollow(XQueryParser.FOLLOW_p_OccurrenceIndicator_in_synpred3_XQueryParser12993);
|
|
this.p_OccurrenceIndicator();
|
|
|
|
this.state._fsp--;
|
|
if (this.state.failed) return ;
|
|
|
|
|
|
},
|
|
// $ANTLR end "synpred3_XQueryParser"
|
|
|
|
// Delegated rules
|
|
|
|
|
|
|
|
synpred3_XQueryParser: function() {
|
|
this.state.backtracking++;
|
|
var start = this.input.mark();
|
|
try {
|
|
this.synpred3_XQueryParser_fragment(); // can never throw exception
|
|
} catch (re) {
|
|
alert("impossible: "+re.toString());
|
|
}
|
|
var success = !this.state.failed;
|
|
this.input.rewind(start);
|
|
this.state.backtracking--;
|
|
this.state.failed=false;
|
|
return success;
|
|
},
|
|
synpred1_XQueryParser: function() {
|
|
this.state.backtracking++;
|
|
var start = this.input.mark();
|
|
try {
|
|
this.synpred1_XQueryParser_fragment(); // can never throw exception
|
|
} catch (re) {
|
|
alert("impossible: "+re.toString());
|
|
}
|
|
var success = !this.state.failed;
|
|
this.input.rewind(start);
|
|
this.state.backtracking--;
|
|
this.state.failed=false;
|
|
return success;
|
|
},
|
|
synpred2_XQueryParser: function() {
|
|
this.state.backtracking++;
|
|
var start = this.input.mark();
|
|
try {
|
|
this.synpred2_XQueryParser_fragment(); // can never throw exception
|
|
} catch (re) {
|
|
alert("impossible: "+re.toString());
|
|
}
|
|
var success = !this.state.failed;
|
|
this.input.rewind(start);
|
|
this.state.backtracking--;
|
|
this.state.failed=false;
|
|
return success;
|
|
}
|
|
|
|
}, true); // important to pass true to overwrite default implementations
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA6_eotS:
|
|
"\u000d\uffff",
|
|
DFA6_eofS:
|
|
"\u0001\u0002\u0001\u000c\u0001\uffff\u0001\u000c\u0009\uffff",
|
|
DFA6_minS:
|
|
"\u0001\u0010\u0001\u0012\u0001\uffff\u0001\u0012\u0009\uffff",
|
|
DFA6_maxS:
|
|
"\u0001\u0137\u0001\u00e0\u0001\uffff\u0001\u00e0\u0009\uffff",
|
|
DFA6_acceptS:
|
|
"\u0002\uffff\u0001\u0002\u0001\uffff\u0003\u0002\u0003\u0001\u0003"+
|
|
"\u0002",
|
|
DFA6_specialS:
|
|
"\u0001\uffff\u0001\u0000\u000b\uffff}>",
|
|
DFA6_transitionS: [
|
|
"\u0012\u0002\u0001\u0001\u0019\u0002\u0001\u0003\u0062\u0002"+
|
|
"\u0001\uffff\u0014\u0002\u0001\uffff\u000d\u0002\u0001\uffff"+
|
|
"\u0001\u0002\u000a\uffff\u0004\u0002\u0005\uffff\u0004\u0002"+
|
|
"\u000c\uffff\u0001\u0002\u0002\uffff\u0002\u0002\u0002\uffff"+
|
|
"\u0001\u0002\u0006\uffff\u0006\u0002\u003b\uffff\u0002\u0002",
|
|
"\u0001\u000c\u0004\uffff\u0002\u0007\u0002\uffff\u0002\u000c"+
|
|
"\u0003\uffff\u0001\u0007\u0001\u0009\u0001\uffff\u0001\u0007"+
|
|
"\u0003\uffff\u0001\u000c\u0007\uffff\u0001\u000c\u0001\uffff"+
|
|
"\u0001\u000c\u0004\uffff\u0001\u000a\u0001\u000c\u0001\uffff"+
|
|
"\u0002\u000c\u0004\uffff\u0003\u000c\u0002\uffff\u0001\u000c"+
|
|
"\u0002\uffff\u0002\u000c\u0001\uffff\u0001\u0009\u0001\u000c"+
|
|
"\u0004\uffff\u0001\u0005\u0001\u000c\u0001\uffff\u0001\u000b"+
|
|
"\u0001\u0007\u0011\uffff\u0002\u000c\u0001\uffff\u0001\u000c"+
|
|
"\u0001\u000b\u0001\uffff\u0001\u000a\u0004\uffff\u0001\u0002"+
|
|
"\u0025\uffff\u0001\u0008\u0001\uffff\u0001\u000a\u0001\u000b"+
|
|
"\u0002\uffff\u0001\u000a\u0002\uffff\u0001\u0004\u0001\uffff"+
|
|
"\u0001\u000a\u0003\uffff\u0002\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0001\uffff\u0001\u000b\u0004\uffff\u0001\u000b\u0001\u0006"+
|
|
"\u0002\uffff\u0003\u000b\u0001\uffff\u0001\u000b\u0002\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u0001\u000a\u0003\uffff\u0001\u000c"+
|
|
"\u0004\uffff\u0001\u000c\u0001\uffff\u0001\u000c\u0001\uffff"+
|
|
"\u0001\u000c\u0001\uffff\u0001\u000c\u0001\uffff\u000b\u000c"+
|
|
"\u0002\uffff\u0001\u000c\u0003\uffff\u0002\u000c",
|
|
"",
|
|
"\u0001\u000c\u0008\uffff\u0002\u000c\u000a\uffff\u0001\u000c"+
|
|
"\u0007\uffff\u0001\u000c\u0001\uffff\u0001\u000c\u0005\uffff"+
|
|
"\u0001\u000c\u0001\uffff\u0002\u000c\u0004\uffff\u0003\u000c"+
|
|
"\u0002\uffff\u0001\u000c\u0002\uffff\u0002\u000c\u0001\u0009"+
|
|
"\u0001\uffff\u0001\u000c\u0005\uffff\u0001\u000c\u000a\uffff"+
|
|
"\u0001\u0009\u0009\uffff\u0002\u000c\u0001\uffff\u0001\u000c"+
|
|
"\u0057\uffff\u0001\u000c\u0004\uffff\u0001\u000c\u0001\uffff"+
|
|
"\u0001\u000c\u0001\uffff\u0001\u000c\u0001\uffff\u0001\u000c"+
|
|
"\u0001\uffff\u000b\u000c\u0002\uffff\u0001\u000c\u0003\uffff"+
|
|
"\u0002\u000c",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA6_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA6_eotS),
|
|
DFA6_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA6_eofS),
|
|
DFA6_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA6_minS),
|
|
DFA6_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA6_maxS),
|
|
DFA6_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA6_acceptS),
|
|
DFA6_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA6_specialS),
|
|
DFA6_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA6_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA6_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA6 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 6;
|
|
this.eot = XQueryParser.DFA6_eot;
|
|
this.eof = XQueryParser.DFA6_eof;
|
|
this.min = XQueryParser.DFA6_min;
|
|
this.max = XQueryParser.DFA6_max;
|
|
this.accept = XQueryParser.DFA6_accept;
|
|
this.special = XQueryParser.DFA6_special;
|
|
this.transition = XQueryParser.DFA6_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA6, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "()* loopback of 156:11: ( (dnd+= pm_DefaultNamespaceDecl | s+= p_Setter | nd+= pm_NamespaceDecl | i+= p_Import ) )*";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA6_1 = input.LA(1);
|
|
|
|
|
|
var index6_1 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA6_1==CONTEXT) ) {s = 2;}
|
|
|
|
else if ( (LA6_1==SEQUENTIAL) && ((true))) {s = 4;}
|
|
|
|
else if ( (LA6_1==OPTION) ) {s = 5;}
|
|
|
|
else if ( (LA6_1==INTEGRITY) && ((true))) {s = 6;}
|
|
|
|
else if ( ((LA6_1>=BASE_URI && LA6_1<=BOUNDARY_SPACE)||LA6_1==CONSTRUCTION||LA6_1==DEFAULT||LA6_1==ORDERING) ) {s = 7;}
|
|
|
|
else if ( (LA6_1==REVALIDATION) && ((true))) {s = 8;}
|
|
|
|
else if ( (LA6_1==COPY_NAMESPACES||LA6_1==NAMESPACE) ) {s = 9;}
|
|
|
|
else if ( (LA6_1==FUNCTION||LA6_1==VARIABLE||LA6_1==UPDATING||LA6_1==CONSTANT||LA6_1==SIMPLE||LA6_1==PRIVATE) ) {s = 10;}
|
|
|
|
else if ( (LA6_1==ORDERED||LA6_1==UNORDERED||LA6_1==VALUE||(LA6_1>=APPEND_ONLY && LA6_1<=AUTOMATICALLY)||LA6_1==COLLECTION||LA6_1==CONST||LA6_1==INDEX||(LA6_1>=MANUALLY && LA6_1<=NON)||LA6_1==QUEUE||LA6_1==UNIQUE) && ((true))) {s = 11;}
|
|
|
|
else if ( (LA6_1==EOF||LA6_1==AND||(LA6_1>=CAST && LA6_1<=CASTABLE)||LA6_1==DIV||LA6_1==EQ||LA6_1==EXCEPT||LA6_1==GE||(LA6_1>=GT && LA6_1<=IDIV)||(LA6_1>=INSTANCE && LA6_1<=IS)||LA6_1==LE||(LA6_1>=LT && LA6_1<=MOD)||LA6_1==NE||LA6_1==OR||(LA6_1>=TO && LA6_1<=TREAT)||LA6_1==UNION||LA6_1==LPAREN||LA6_1==LSQUARE||LA6_1==EQUAL||LA6_1==NOTEQUAL||LA6_1==COMMA||(LA6_1>=STAR && LA6_1<=SLASH_SLASH)||LA6_1==COLON||(LA6_1>=SEMICOLON && LA6_1<=VBAR)) ) {s = 12;}
|
|
|
|
|
|
input.seek(index6_1);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 6, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA7_eotS:
|
|
"\u000c\uffff",
|
|
DFA7_eofS:
|
|
"\u0001\u0001\u0001\uffff\u0001\u0001\u0009\uffff",
|
|
DFA7_minS:
|
|
"\u0001\u0010\u0001\uffff\u0001\u0012\u0004\uffff\u0001\u0036\u0004"+
|
|
"\uffff",
|
|
DFA7_maxS:
|
|
"\u0001\u0137\u0001\uffff\u0001\u00e0\u0004\uffff\u0001\u00a2\u0004"+
|
|
"\uffff",
|
|
DFA7_acceptS:
|
|
"\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0002\u0001\u0003\u0001"+
|
|
"\u0004\u0001\u0007\u0001\uffff\u0001\u0001\u0001\u0003\u0001\u0005\u0001"+
|
|
"\u0006",
|
|
DFA7_specialS:
|
|
"\u0002\uffff\u0001\u0000\u0009\uffff}>",
|
|
DFA7_transitionS: [
|
|
"\u0012\u0001\u0001\u0002\u007c\u0001\u0001\uffff\u0014\u0001"+
|
|
"\u0001\uffff\u000d\u0001\u0001\uffff\u0001\u0001\u000a\uffff"+
|
|
"\u0004\u0001\u0005\uffff\u0004\u0001\u000c\uffff\u0001\u0001"+
|
|
"\u0002\uffff\u0002\u0001\u0002\uffff\u0001\u0001\u0006\uffff"+
|
|
"\u0006\u0001\u003b\uffff\u0002\u0001",
|
|
"",
|
|
"\u0001\u0001\u0008\uffff\u0002\u0001\u000a\uffff\u0001\u0001"+
|
|
"\u0007\uffff\u0001\u0001\u0001\uffff\u0001\u0001\u0004\uffff"+
|
|
"\u0001\u0009\u0001\u0001\u0001\uffff\u0002\u0001\u0004\uffff"+
|
|
"\u0003\u0001\u0002\uffff\u0001\u0001\u0002\uffff\u0002\u0001"+
|
|
"\u0002\uffff\u0001\u0001\u0004\uffff\u0001\u0005\u0001\u0001"+
|
|
"\u0001\uffff\u0001\u000a\u0012\uffff\u0002\u0001\u0001\uffff"+
|
|
"\u0001\u0001\u0001\u000a\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0003\u0027\uffff\u0001\u0009\u0001\u000b\u0002\uffff"+
|
|
"\u0001\u0008\u0002\uffff\u0001\u0004\u0001\uffff\u0001\u0009"+
|
|
"\u0003\uffff\u0001\u000a\u0001\u000b\u0001\uffff\u0001\u000a"+
|
|
"\u0001\uffff\u0001\u000a\u0004\uffff\u0001\u000b\u0001\u0006"+
|
|
"\u0002\uffff\u0001\u000b\u0001\u000a\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000a\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u0007"+
|
|
"\u0003\uffff\u0001\u0001\u0004\uffff\u0001\u0001\u0001\uffff"+
|
|
"\u0001\u0001\u0001\uffff\u0001\u0001\u0001\uffff\u0001\u0001"+
|
|
"\u0001\uffff\u000b\u0001\u0002\uffff\u0001\u0001\u0003\uffff"+
|
|
"\u0002\u0001",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"\u0001\u0009\u0035\uffff\u0001\u0008\u002c\uffff\u0001\u0009"+
|
|
"\u0003\uffff\u0001\u0008\u0004\uffff\u0001\u0009",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA7_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA7_eotS),
|
|
DFA7_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA7_eofS),
|
|
DFA7_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA7_minS),
|
|
DFA7_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA7_maxS),
|
|
DFA7_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA7_acceptS),
|
|
DFA7_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA7_specialS),
|
|
DFA7_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA7_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA7_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA7 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 7;
|
|
this.eot = XQueryParser.DFA7_eot;
|
|
this.eof = XQueryParser.DFA7_eof;
|
|
this.min = XQueryParser.DFA7_min;
|
|
this.max = XQueryParser.DFA7_max;
|
|
this.accept = XQueryParser.DFA7_accept;
|
|
this.special = XQueryParser.DFA7_special;
|
|
this.transition = XQueryParser.DFA7_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA7, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "()* loopback of 171:11: ( pm_VarDecl | pm_ContextItemDecl | pm_FunctionDecl | pm_OptionDecl | {...}? => p_CollectionDecl | {...}? => p_IndexDecl | {...}? => p_ICDecl )*";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA7_2 = input.LA(1);
|
|
|
|
|
|
var index7_2 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA7_2==CONTEXT) ) {s = 3;}
|
|
|
|
else if ( (LA7_2==SEQUENTIAL) && ((true))) {s = 4;}
|
|
|
|
else if ( (LA7_2==OPTION) ) {s = 5;}
|
|
|
|
else if ( (LA7_2==INTEGRITY) && ((true))) {s = 6;}
|
|
|
|
else if ( (LA7_2==EOF||LA7_2==AND||(LA7_2>=CAST && LA7_2<=CASTABLE)||LA7_2==DIV||LA7_2==EQ||LA7_2==EXCEPT||LA7_2==GE||(LA7_2>=GT && LA7_2<=IDIV)||(LA7_2>=INSTANCE && LA7_2<=IS)||LA7_2==LE||(LA7_2>=LT && LA7_2<=MOD)||LA7_2==NE||LA7_2==OR||(LA7_2>=TO && LA7_2<=TREAT)||LA7_2==UNION||LA7_2==LPAREN||LA7_2==LSQUARE||LA7_2==EQUAL||LA7_2==NOTEQUAL||LA7_2==COMMA||(LA7_2>=STAR && LA7_2<=SLASH_SLASH)||LA7_2==COLON||(LA7_2>=SEMICOLON && LA7_2<=VBAR)) ) {s = 1;}
|
|
|
|
else if ( (LA7_2==PRIVATE) ) {s = 7;}
|
|
|
|
else if ( (LA7_2==VARIABLE||LA7_2==CONSTANT) ) {s = 8;}
|
|
|
|
else if ( (LA7_2==FUNCTION||LA7_2==UPDATING||LA7_2==SIMPLE) ) {s = 9;}
|
|
|
|
else if ( (LA7_2==ORDERED||LA7_2==UNORDERED||LA7_2==APPEND_ONLY||LA7_2==COLLECTION||LA7_2==CONST||LA7_2==MUTABLE||LA7_2==QUEUE) && ((true))) {s = 10;}
|
|
|
|
else if ( (LA7_2==VALUE||LA7_2==AUTOMATICALLY||LA7_2==INDEX||LA7_2==MANUALLY||LA7_2==NON||LA7_2==UNIQUE) && ((true))) {s = 11;}
|
|
|
|
|
|
input.seek(index7_2);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 7, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA8_eotS:
|
|
"\u000b\uffff",
|
|
DFA8_eofS:
|
|
"\u000b\uffff",
|
|
DFA8_minS:
|
|
"\u0001\u0022\u0001\u0017\u0001\uffff\u0001\u001e\u0007\uffff",
|
|
DFA8_maxS:
|
|
"\u0001\u0022\u0001\u0097\u0001\uffff\u0001\u0052\u0007\uffff",
|
|
DFA8_acceptS:
|
|
"\u0002\uffff\u0001\u0001\u0001\uffff\u0001\u0003\u0001\u0004\u0001"+
|
|
"\u0005\u0001\u0007\u0001\u0008\u0001\u0002\u0001\u0006",
|
|
DFA8_specialS:
|
|
"\u0001\uffff\u0001\u0000\u0009\uffff}>",
|
|
DFA8_transitionS: [
|
|
"\u0001\u0001",
|
|
"\u0001\u0004\u0001\u0002\u0007\uffff\u0001\u0005\u0001\u0008"+
|
|
"\u0001\uffff\u0001\u0003\u0030\uffff\u0001\u0006\u0042\uffff"+
|
|
"\u0001\u0007",
|
|
"",
|
|
"\u0001\u0009\u0033\uffff\u0001\u000a",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA8_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA8_eotS),
|
|
DFA8_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA8_eofS),
|
|
DFA8_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA8_minS),
|
|
DFA8_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA8_maxS),
|
|
DFA8_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA8_acceptS),
|
|
DFA8_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA8_specialS),
|
|
DFA8_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA8_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA8_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA8 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 8;
|
|
this.eot = XQueryParser.DFA8_eot;
|
|
this.eof = XQueryParser.DFA8_eof;
|
|
this.min = XQueryParser.DFA8_min;
|
|
this.max = XQueryParser.DFA8_max;
|
|
this.accept = XQueryParser.DFA8_accept;
|
|
this.special = XQueryParser.DFA8_special;
|
|
this.transition = XQueryParser.DFA8_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA8, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "179:1: p_Setter : ( pm_BoundarySpaceDecl | pm_DefaultCollationDecl | pm_BaseURIDecl | pm_ConstructionDecl | pm_OrderingModeDecl | pm_EmptyOrderDecl | {...}? => pm_RevalidationDecl | pm_CopyNamespacesDecl );";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA8_1 = input.LA(1);
|
|
|
|
|
|
var index8_1 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA8_1==BOUNDARY_SPACE) ) {s = 2;}
|
|
|
|
else if ( (LA8_1==DEFAULT) ) {s = 3;}
|
|
|
|
else if ( (LA8_1==BASE_URI) ) {s = 4;}
|
|
|
|
else if ( (LA8_1==CONSTRUCTION) ) {s = 5;}
|
|
|
|
else if ( (LA8_1==ORDERING) ) {s = 6;}
|
|
|
|
else if ( (LA8_1==REVALIDATION) && ((true))) {s = 7;}
|
|
|
|
else if ( (LA8_1==COPY_NAMESPACES) ) {s = 8;}
|
|
|
|
|
|
input.seek(index8_1);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 8, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA49_eotS:
|
|
"\u0022\uffff",
|
|
DFA49_eofS:
|
|
"\u0001\uffff\u0001\u0013\u0001\uffff\u0010\u0013\u000f\uffff",
|
|
DFA49_minS:
|
|
"\u0001\u0010\u0001\u0012\u0001\uffff\u0010\u0012\u000f\uffff",
|
|
DFA49_maxS:
|
|
"\u0001\u0137\u0001\u0136\u0001\uffff\u0010\u0136\u000f\uffff",
|
|
DFA49_acceptS:
|
|
"\u0002\uffff\u0001\u0001\u0010\uffff\u0001\u0010\u0001\u0002\u0001"+
|
|
"\u0003\u0001\u0004\u0001\u0005\u0001\u0006\u0001\u0007\u0001\u0008\u0001"+
|
|
"\u0009\u0001\u000a\u0001\u000b\u0001\u000c\u0001\u000d\u0001\u000e\u0001"+
|
|
"\u000f",
|
|
DFA49_specialS:
|
|
"\u0008\uffff\u0001\u0000\u0001\u0003\u0001\u000a\u0001\u0001\u0001"+
|
|
"\u0007\u0001\u0009\u0001\u0002\u0001\u0005\u0001\u0004\u0001\u0006\u0001"+
|
|
"\u0008\u000f\uffff}>",
|
|
DFA49_transitionS: [
|
|
"\u0020\u0013\u0001\u0004\u0004\u0013\u0001\u0001\u0005\u0013"+
|
|
"\u0001\u0006\u0024\u0013\u0001\u0003\u0007\u0013\u0001\u0005"+
|
|
"\u001d\u0013\u0001\u0007\u0006\u0013\u0001\u000e\u0001\u000b"+
|
|
"\u0001\u0013\u0001\u000a\u0004\u0013\u0001\u000c\u0001\u000d"+
|
|
"\u0005\u0013\u0001\u000f\u0001\u0013\u0001\u0011\u0001\uffff"+
|
|
"\u0001\u0013\u0001\u0010\u0001\u0013\u0001\u0012\u0001\u0009"+
|
|
"\u0001\u0008\u000e\u0013\u0001\uffff\u000d\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u000a\uffff\u0004\u0013\u0005\uffff\u0004\u0013"+
|
|
"\u000c\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0002\uffff"+
|
|
"\u0001\u0013\u0006\uffff\u0006\u0013\u003b\uffff\u0001\u0002"+
|
|
"\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0005\uffff\u0001\u0002\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0002\u0003\uffff\u0002\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u0001\u0013\u0007\uffff\u0001\u0013"+
|
|
"\u0025\uffff\u0002\u0013\u0001\u0002\u0001\uffff\u0004\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u000b\u0013\u0002\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0055\uffff\u0001\u0013",
|
|
"",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\u0014"+
|
|
"\u0001\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\u0014"+
|
|
"\u0001\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0001\u0015\u0001\u0013"+
|
|
"\u0002\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0001\u0016\u0001\u0013"+
|
|
"\u0002\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u0017\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\u0018"+
|
|
"\u0001\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u0018\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0002\uffff"+
|
|
"\u0001\u0019\u0002\uffff\u0002\u0013\u0007\uffff\u0002\u0013"+
|
|
"\u0005\uffff\u0001\u0013\u0004\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0004\uffff\u0001\u0013\u0003\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0006\uffff\u0001\u0013\u0006\uffff"+
|
|
"\u0001\u0013\u0005\uffff\u0002\u0013\u0004\uffff\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0001\u0019\u0006\uffff\u0001\u0013"+
|
|
"\u0025\uffff\u0002\u0013\u0002\uffff\u0004\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff\u000b\u0013"+
|
|
"\u0002\uffff\u0001\u0013\u0003\uffff\u0002\u0013\u0055\uffff"+
|
|
"\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0002\uffff"+
|
|
"\u0001\u001a\u0002\uffff\u0002\u0013\u0007\uffff\u0002\u0013"+
|
|
"\u0005\uffff\u0001\u0013\u0004\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0004\uffff\u0001\u0013\u0003\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0006\uffff\u0001\u0013\u0006\uffff"+
|
|
"\u0001\u0013\u0005\uffff\u0002\u0013\u0004\uffff\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0001\u001a\u0006\uffff\u0001\u0013"+
|
|
"\u0025\uffff\u0002\u0013\u0002\uffff\u0004\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff\u000b\u0013"+
|
|
"\u0002\uffff\u0001\u0013\u0003\uffff\u0002\u0013\u0055\uffff"+
|
|
"\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0002\uffff"+
|
|
"\u0001\u001b\u0002\uffff\u0002\u0013\u0007\uffff\u0002\u0013"+
|
|
"\u0005\uffff\u0001\u0013\u0004\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0004\uffff\u0001\u0013\u0003\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0006\uffff\u0001\u0013\u0006\uffff"+
|
|
"\u0001\u0013\u0005\uffff\u0002\u0013\u0004\uffff\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0007\uffff\u0001\u0013\u0025\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0004\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0002\uffff"+
|
|
"\u0001\u001c\u0002\uffff\u0002\u0013\u0007\uffff\u0002\u0013"+
|
|
"\u0005\uffff\u0001\u0013\u0004\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0004\uffff\u0001\u0013\u0003\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0006\uffff\u0001\u0013\u0006\uffff"+
|
|
"\u0001\u0013\u0005\uffff\u0002\u0013\u0004\uffff\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0006\uffff\u0001\u001c\u0001\u0013"+
|
|
"\u0025\uffff\u0002\u0013\u0002\uffff\u0004\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff\u000b\u0013"+
|
|
"\u0002\uffff\u0001\u0013\u0003\uffff\u0002\u0013\u0055\uffff"+
|
|
"\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\u001d"+
|
|
"\u0001\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\uffff"+
|
|
"\u0001\u001e\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0002\u0013\u0001\u001f"+
|
|
"\u0001\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0003\uffff\u0001\u0020\u0021\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0004\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0001\uffff\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"\u0003\u0013\u0005\uffff\u0003\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0001\u0013\u0002\uffff\u0002\u0013\u0003\uffff"+
|
|
"\u0002\u0013\u0002\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0001\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0003\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0002\uffff\u0002\u0013\u0002\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0007\uffff\u0002\u0013\u0005\uffff\u0001\u0013"+
|
|
"\u0004\uffff\u0002\u0013\u0001\uffff\u0001\u0013\u0004\uffff"+
|
|
"\u0001\u0013\u0003\uffff\u0001\u0013\u0003\uffff\u0002\u0013"+
|
|
"\u0006\uffff\u0001\u0013\u0006\uffff\u0001\u0013\u0005\uffff"+
|
|
"\u0002\u0013\u0004\uffff\u0001\u0013\u0001\uffff\u0001\u0013"+
|
|
"\u0007\uffff\u0001\u0013\u0025\uffff\u0001\u0021\u0001\u0013"+
|
|
"\u0002\uffff\u0004\u0013\u0001\uffff\u0001\u0013\u0001\uffff"+
|
|
"\u0001\u0013\u0001\uffff\u000b\u0013\u0002\uffff\u0001\u0013"+
|
|
"\u0003\uffff\u0002\u0013\u0055\uffff\u0001\u0013",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA49_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA49_eotS),
|
|
DFA49_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA49_eofS),
|
|
DFA49_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA49_minS),
|
|
DFA49_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA49_maxS),
|
|
DFA49_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA49_acceptS),
|
|
DFA49_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA49_specialS),
|
|
DFA49_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA49_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA49_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA49 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 49;
|
|
this.eot = XQueryParser.DFA49_eot;
|
|
this.eof = XQueryParser.DFA49_eof;
|
|
this.min = XQueryParser.DFA49_min;
|
|
this.max = XQueryParser.DFA49_max;
|
|
this.accept = XQueryParser.DFA49_accept;
|
|
this.special = XQueryParser.DFA49_special;
|
|
this.transition = XQueryParser.DFA49_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA49, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "384:1: p_ExprSingle : ( p_FLWORExpr | p_QuantifiedExpr | p_TypeswitchExpr | p_IfExpr | p_TryCatchExpr | {...}? => p_EvalExpr | {...}? => p_InsertExpr | {...}? => p_DeleteExpr | {...}? => p_RenameExpr | {...}? => p_ReplaceExpr | {...}? => p_TransformExpr | {...}? => p_BlockExpr | {...}? => p_AssignmentExpr | {...}? => p_ExitExpr | {...}? => p_WhileExpr | p_OrExpr );";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA49_8 = input.LA(1);
|
|
|
|
|
|
var index49_8 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_8==DOLLAR) && ((true))) {s = 24;}
|
|
|
|
else if ( (LA49_8==EOF||(LA49_8>=AND && LA49_8<=ASCENDING)||(LA49_8>=CASE && LA49_8<=CASTABLE)||LA49_8==COLLATION||LA49_8==DEFAULT||(LA49_8>=DESCENDING && LA49_8<=DIV)||(LA49_8>=ELSE && LA49_8<=EMPTY)||LA49_8==EQ||LA49_8==EXCEPT||LA49_8==FOR||LA49_8==GE||(LA49_8>=GT && LA49_8<=IDIV)||(LA49_8>=INSTANCE && LA49_8<=IS)||LA49_8==LE||(LA49_8>=LT && LA49_8<=MOD)||LA49_8==NE||(LA49_8>=OR && LA49_8<=ORDER)||(LA49_8>=RETURN && LA49_8<=SATISFIES)||LA49_8==STABLE||(LA49_8>=TO && LA49_8<=TREAT)||LA49_8==UNION||LA49_8==WHERE||LA49_8==COUNT||(LA49_8>=END && LA49_8<=GROUP)||LA49_8==ONLY||LA49_8==START||(LA49_8>=AFTER && LA49_8<=BEFORE)||LA49_8==INTO||LA49_8==MODIFY||LA49_8==WITH||(LA49_8>=LPAREN && LA49_8<=RPAREN)||(LA49_8>=RBRACKET && LA49_8<=EQUAL)||LA49_8==NOTEQUAL||LA49_8==COMMA||(LA49_8>=STAR && LA49_8<=SLASH_SLASH)||LA49_8==COLON||(LA49_8>=SEMICOLON && LA49_8<=VBAR)||LA49_8==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_8);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 1 :
|
|
var LA49_11 = input.LA(1);
|
|
|
|
|
|
var index49_11 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_11==NODE||LA49_11==NODES) && ((true))) {s = 26;}
|
|
|
|
else if ( (LA49_11==EOF||(LA49_11>=AND && LA49_11<=ASCENDING)||(LA49_11>=CASE && LA49_11<=CASTABLE)||LA49_11==COLLATION||LA49_11==DEFAULT||(LA49_11>=DESCENDING && LA49_11<=DIV)||(LA49_11>=ELSE && LA49_11<=EMPTY)||LA49_11==EQ||LA49_11==EXCEPT||LA49_11==FOR||LA49_11==GE||(LA49_11>=GT && LA49_11<=IDIV)||(LA49_11>=INSTANCE && LA49_11<=IS)||LA49_11==LE||(LA49_11>=LT && LA49_11<=MOD)||LA49_11==NE||(LA49_11>=OR && LA49_11<=ORDER)||(LA49_11>=RETURN && LA49_11<=SATISFIES)||LA49_11==STABLE||(LA49_11>=TO && LA49_11<=TREAT)||LA49_11==UNION||LA49_11==WHERE||LA49_11==COUNT||(LA49_11>=END && LA49_11<=GROUP)||LA49_11==ONLY||LA49_11==START||(LA49_11>=AFTER && LA49_11<=BEFORE)||LA49_11==INTO||LA49_11==MODIFY||LA49_11==WITH||(LA49_11>=LPAREN && LA49_11<=RPAREN)||(LA49_11>=RBRACKET && LA49_11<=EQUAL)||LA49_11==NOTEQUAL||LA49_11==COMMA||(LA49_11>=STAR && LA49_11<=SLASH_SLASH)||LA49_11==COLON||(LA49_11>=SEMICOLON && LA49_11<=VBAR)||LA49_11==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_11);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 2 :
|
|
var LA49_14 = input.LA(1);
|
|
|
|
|
|
var index49_14 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_14==DOLLAR) && ((true))) {s = 29;}
|
|
|
|
else if ( (LA49_14==EOF||(LA49_14>=AND && LA49_14<=ASCENDING)||(LA49_14>=CASE && LA49_14<=CASTABLE)||LA49_14==COLLATION||LA49_14==DEFAULT||(LA49_14>=DESCENDING && LA49_14<=DIV)||(LA49_14>=ELSE && LA49_14<=EMPTY)||LA49_14==EQ||LA49_14==EXCEPT||LA49_14==FOR||LA49_14==GE||(LA49_14>=GT && LA49_14<=IDIV)||(LA49_14>=INSTANCE && LA49_14<=IS)||LA49_14==LE||(LA49_14>=LT && LA49_14<=MOD)||LA49_14==NE||(LA49_14>=OR && LA49_14<=ORDER)||(LA49_14>=RETURN && LA49_14<=SATISFIES)||LA49_14==STABLE||(LA49_14>=TO && LA49_14<=TREAT)||LA49_14==UNION||LA49_14==WHERE||LA49_14==COUNT||(LA49_14>=END && LA49_14<=GROUP)||LA49_14==ONLY||LA49_14==START||(LA49_14>=AFTER && LA49_14<=BEFORE)||LA49_14==INTO||LA49_14==MODIFY||LA49_14==WITH||(LA49_14>=LPAREN && LA49_14<=RPAREN)||(LA49_14>=RBRACKET && LA49_14<=EQUAL)||LA49_14==NOTEQUAL||LA49_14==COMMA||(LA49_14>=STAR && LA49_14<=SLASH_SLASH)||LA49_14==COLON||(LA49_14>=SEMICOLON && LA49_14<=VBAR)||LA49_14==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_14);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 3 :
|
|
var LA49_9 = input.LA(1);
|
|
|
|
|
|
var index49_9 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_9==LBRACKET) && ((true))) {s = 24;}
|
|
|
|
else if ( (LA49_9==EOF||(LA49_9>=AND && LA49_9<=ASCENDING)||(LA49_9>=CASE && LA49_9<=CASTABLE)||LA49_9==COLLATION||LA49_9==DEFAULT||(LA49_9>=DESCENDING && LA49_9<=DIV)||(LA49_9>=ELSE && LA49_9<=EMPTY)||LA49_9==EQ||LA49_9==EXCEPT||LA49_9==FOR||LA49_9==GE||(LA49_9>=GT && LA49_9<=IDIV)||(LA49_9>=INSTANCE && LA49_9<=IS)||LA49_9==LE||(LA49_9>=LT && LA49_9<=MOD)||LA49_9==NE||(LA49_9>=OR && LA49_9<=ORDER)||(LA49_9>=RETURN && LA49_9<=SATISFIES)||LA49_9==STABLE||(LA49_9>=TO && LA49_9<=TREAT)||LA49_9==UNION||LA49_9==WHERE||LA49_9==COUNT||(LA49_9>=END && LA49_9<=GROUP)||LA49_9==ONLY||LA49_9==START||(LA49_9>=AFTER && LA49_9<=BEFORE)||LA49_9==INTO||LA49_9==MODIFY||LA49_9==WITH||(LA49_9>=LPAREN && LA49_9<=RPAREN)||(LA49_9>=RBRACKET && LA49_9<=EQUAL)||LA49_9==NOTEQUAL||LA49_9==COMMA||(LA49_9>=STAR && LA49_9<=SLASH_SLASH)||LA49_9==COLON||(LA49_9>=SEMICOLON && LA49_9<=VBAR)||LA49_9==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_9);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 4 :
|
|
var LA49_16 = input.LA(1);
|
|
|
|
|
|
var index49_16 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_16==DOLLAR) && ((true))) {s = 31;}
|
|
|
|
else if ( (LA49_16==EOF||(LA49_16>=AND && LA49_16<=ASCENDING)||(LA49_16>=CASE && LA49_16<=CASTABLE)||LA49_16==COLLATION||LA49_16==DEFAULT||(LA49_16>=DESCENDING && LA49_16<=DIV)||(LA49_16>=ELSE && LA49_16<=EMPTY)||LA49_16==EQ||LA49_16==EXCEPT||LA49_16==FOR||LA49_16==GE||(LA49_16>=GT && LA49_16<=IDIV)||(LA49_16>=INSTANCE && LA49_16<=IS)||LA49_16==LE||(LA49_16>=LT && LA49_16<=MOD)||LA49_16==NE||(LA49_16>=OR && LA49_16<=ORDER)||(LA49_16>=RETURN && LA49_16<=SATISFIES)||LA49_16==STABLE||(LA49_16>=TO && LA49_16<=TREAT)||LA49_16==UNION||LA49_16==WHERE||LA49_16==COUNT||(LA49_16>=END && LA49_16<=GROUP)||LA49_16==ONLY||LA49_16==START||(LA49_16>=AFTER && LA49_16<=BEFORE)||LA49_16==INTO||LA49_16==MODIFY||LA49_16==WITH||(LA49_16>=LPAREN && LA49_16<=RPAREN)||(LA49_16>=RBRACKET && LA49_16<=EQUAL)||LA49_16==NOTEQUAL||LA49_16==COMMA||(LA49_16>=STAR && LA49_16<=SLASH_SLASH)||LA49_16==COLON||(LA49_16>=SEMICOLON && LA49_16<=VBAR)||LA49_16==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_16);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 5 :
|
|
var LA49_15 = input.LA(1);
|
|
|
|
|
|
var index49_15 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_15==LBRACKET) && ((true))) {s = 30;}
|
|
|
|
else if ( (LA49_15==EOF||(LA49_15>=AND && LA49_15<=ASCENDING)||(LA49_15>=CASE && LA49_15<=CASTABLE)||LA49_15==COLLATION||LA49_15==DEFAULT||(LA49_15>=DESCENDING && LA49_15<=DIV)||(LA49_15>=ELSE && LA49_15<=EMPTY)||LA49_15==EQ||LA49_15==EXCEPT||LA49_15==FOR||LA49_15==GE||(LA49_15>=GT && LA49_15<=IDIV)||(LA49_15>=INSTANCE && LA49_15<=IS)||LA49_15==LE||(LA49_15>=LT && LA49_15<=MOD)||LA49_15==NE||(LA49_15>=OR && LA49_15<=ORDER)||(LA49_15>=RETURN && LA49_15<=SATISFIES)||LA49_15==STABLE||(LA49_15>=TO && LA49_15<=TREAT)||LA49_15==UNION||LA49_15==WHERE||LA49_15==COUNT||(LA49_15>=END && LA49_15<=GROUP)||LA49_15==ONLY||LA49_15==START||(LA49_15>=AFTER && LA49_15<=BEFORE)||LA49_15==INTO||LA49_15==MODIFY||LA49_15==WITH||(LA49_15>=LPAREN && LA49_15<=RPAREN)||(LA49_15>=RBRACKET && LA49_15<=EQUAL)||LA49_15==NOTEQUAL||LA49_15==COMMA||(LA49_15>=STAR && LA49_15<=SLASH_SLASH)||LA49_15==COLON||(LA49_15>=SEMICOLON && LA49_15<=VBAR)||LA49_15==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_15);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 6 :
|
|
var LA49_17 = input.LA(1);
|
|
|
|
|
|
var index49_17 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_17==RETURNING) && ((true))) {s = 32;}
|
|
|
|
else if ( (LA49_17==EOF||(LA49_17>=AND && LA49_17<=ASCENDING)||(LA49_17>=CASE && LA49_17<=CASTABLE)||LA49_17==COLLATION||LA49_17==DEFAULT||(LA49_17>=DESCENDING && LA49_17<=DIV)||(LA49_17>=ELSE && LA49_17<=EMPTY)||LA49_17==EQ||LA49_17==EXCEPT||LA49_17==FOR||LA49_17==GE||(LA49_17>=GT && LA49_17<=IDIV)||(LA49_17>=INSTANCE && LA49_17<=IS)||LA49_17==LE||(LA49_17>=LT && LA49_17<=MOD)||LA49_17==NE||(LA49_17>=OR && LA49_17<=ORDER)||(LA49_17>=RETURN && LA49_17<=SATISFIES)||LA49_17==STABLE||(LA49_17>=TO && LA49_17<=TREAT)||LA49_17==UNION||LA49_17==WHERE||LA49_17==COUNT||(LA49_17>=END && LA49_17<=GROUP)||LA49_17==ONLY||LA49_17==START||(LA49_17>=AFTER && LA49_17<=BEFORE)||LA49_17==INTO||LA49_17==MODIFY||LA49_17==WITH||(LA49_17>=LPAREN && LA49_17<=RPAREN)||(LA49_17>=RBRACKET && LA49_17<=EQUAL)||LA49_17==NOTEQUAL||LA49_17==COMMA||(LA49_17>=STAR && LA49_17<=SLASH_SLASH)||LA49_17==COLON||(LA49_17>=SEMICOLON && LA49_17<=VBAR)||LA49_17==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_17);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 7 :
|
|
var LA49_12 = input.LA(1);
|
|
|
|
|
|
var index49_12 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_12==NODE) && ((true))) {s = 27;}
|
|
|
|
else if ( (LA49_12==EOF||(LA49_12>=AND && LA49_12<=ASCENDING)||(LA49_12>=CASE && LA49_12<=CASTABLE)||LA49_12==COLLATION||LA49_12==DEFAULT||(LA49_12>=DESCENDING && LA49_12<=DIV)||(LA49_12>=ELSE && LA49_12<=EMPTY)||LA49_12==EQ||LA49_12==EXCEPT||LA49_12==FOR||LA49_12==GE||(LA49_12>=GT && LA49_12<=IDIV)||(LA49_12>=INSTANCE && LA49_12<=IS)||LA49_12==LE||(LA49_12>=LT && LA49_12<=MOD)||LA49_12==NE||(LA49_12>=OR && LA49_12<=ORDER)||(LA49_12>=RETURN && LA49_12<=SATISFIES)||LA49_12==STABLE||(LA49_12>=TO && LA49_12<=TREAT)||LA49_12==UNION||LA49_12==WHERE||LA49_12==COUNT||(LA49_12>=END && LA49_12<=GROUP)||LA49_12==ONLY||LA49_12==START||(LA49_12>=AFTER && LA49_12<=BEFORE)||LA49_12==INTO||LA49_12==MODIFY||LA49_12==WITH||(LA49_12>=LPAREN && LA49_12<=RPAREN)||(LA49_12>=RBRACKET && LA49_12<=EQUAL)||LA49_12==NOTEQUAL||LA49_12==COMMA||(LA49_12>=STAR && LA49_12<=SLASH_SLASH)||LA49_12==COLON||(LA49_12>=SEMICOLON && LA49_12<=VBAR)||LA49_12==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_12);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 8 :
|
|
var LA49_18 = input.LA(1);
|
|
|
|
|
|
var index49_18 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_18==LPAREN) && ((true))) {s = 33;}
|
|
|
|
else if ( (LA49_18==EOF||(LA49_18>=AND && LA49_18<=ASCENDING)||(LA49_18>=CASE && LA49_18<=CASTABLE)||LA49_18==COLLATION||LA49_18==DEFAULT||(LA49_18>=DESCENDING && LA49_18<=DIV)||(LA49_18>=ELSE && LA49_18<=EMPTY)||LA49_18==EQ||LA49_18==EXCEPT||LA49_18==FOR||LA49_18==GE||(LA49_18>=GT && LA49_18<=IDIV)||(LA49_18>=INSTANCE && LA49_18<=IS)||LA49_18==LE||(LA49_18>=LT && LA49_18<=MOD)||LA49_18==NE||(LA49_18>=OR && LA49_18<=ORDER)||(LA49_18>=RETURN && LA49_18<=SATISFIES)||LA49_18==STABLE||(LA49_18>=TO && LA49_18<=TREAT)||LA49_18==UNION||LA49_18==WHERE||LA49_18==COUNT||(LA49_18>=END && LA49_18<=GROUP)||LA49_18==ONLY||LA49_18==START||(LA49_18>=AFTER && LA49_18<=BEFORE)||LA49_18==INTO||LA49_18==MODIFY||LA49_18==WITH||LA49_18==RPAREN||(LA49_18>=RBRACKET && LA49_18<=EQUAL)||LA49_18==NOTEQUAL||LA49_18==COMMA||(LA49_18>=STAR && LA49_18<=SLASH_SLASH)||LA49_18==COLON||(LA49_18>=SEMICOLON && LA49_18<=VBAR)||LA49_18==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_18);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 9 :
|
|
var LA49_13 = input.LA(1);
|
|
|
|
|
|
var index49_13 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_13==NODE||LA49_13==VALUE) && ((true))) {s = 28;}
|
|
|
|
else if ( (LA49_13==EOF||(LA49_13>=AND && LA49_13<=ASCENDING)||(LA49_13>=CASE && LA49_13<=CASTABLE)||LA49_13==COLLATION||LA49_13==DEFAULT||(LA49_13>=DESCENDING && LA49_13<=DIV)||(LA49_13>=ELSE && LA49_13<=EMPTY)||LA49_13==EQ||LA49_13==EXCEPT||LA49_13==FOR||LA49_13==GE||(LA49_13>=GT && LA49_13<=IDIV)||(LA49_13>=INSTANCE && LA49_13<=IS)||LA49_13==LE||(LA49_13>=LT && LA49_13<=MOD)||LA49_13==NE||(LA49_13>=OR && LA49_13<=ORDER)||(LA49_13>=RETURN && LA49_13<=SATISFIES)||LA49_13==STABLE||(LA49_13>=TO && LA49_13<=TREAT)||LA49_13==UNION||LA49_13==WHERE||LA49_13==COUNT||(LA49_13>=END && LA49_13<=GROUP)||LA49_13==ONLY||LA49_13==START||(LA49_13>=AFTER && LA49_13<=BEFORE)||LA49_13==INTO||LA49_13==MODIFY||LA49_13==WITH||(LA49_13>=LPAREN && LA49_13<=RPAREN)||(LA49_13>=RBRACKET && LA49_13<=EQUAL)||LA49_13==NOTEQUAL||LA49_13==COMMA||(LA49_13>=STAR && LA49_13<=SLASH_SLASH)||LA49_13==COLON||(LA49_13>=SEMICOLON && LA49_13<=VBAR)||LA49_13==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_13);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 10 :
|
|
var LA49_10 = input.LA(1);
|
|
|
|
|
|
var index49_10 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA49_10==NODE||LA49_10==NODES) && ((true))) {s = 25;}
|
|
|
|
else if ( (LA49_10==EOF||(LA49_10>=AND && LA49_10<=ASCENDING)||(LA49_10>=CASE && LA49_10<=CASTABLE)||LA49_10==COLLATION||LA49_10==DEFAULT||(LA49_10>=DESCENDING && LA49_10<=DIV)||(LA49_10>=ELSE && LA49_10<=EMPTY)||LA49_10==EQ||LA49_10==EXCEPT||LA49_10==FOR||LA49_10==GE||(LA49_10>=GT && LA49_10<=IDIV)||(LA49_10>=INSTANCE && LA49_10<=IS)||LA49_10==LE||(LA49_10>=LT && LA49_10<=MOD)||LA49_10==NE||(LA49_10>=OR && LA49_10<=ORDER)||(LA49_10>=RETURN && LA49_10<=SATISFIES)||LA49_10==STABLE||(LA49_10>=TO && LA49_10<=TREAT)||LA49_10==UNION||LA49_10==WHERE||LA49_10==COUNT||(LA49_10>=END && LA49_10<=GROUP)||LA49_10==ONLY||LA49_10==START||(LA49_10>=AFTER && LA49_10<=BEFORE)||LA49_10==INTO||LA49_10==MODIFY||LA49_10==WITH||(LA49_10>=LPAREN && LA49_10<=RPAREN)||(LA49_10>=RBRACKET && LA49_10<=EQUAL)||LA49_10==NOTEQUAL||LA49_10==COMMA||(LA49_10>=STAR && LA49_10<=SLASH_SLASH)||LA49_10==COLON||(LA49_10>=SEMICOLON && LA49_10<=VBAR)||LA49_10==LETDOLLAR) ) {s = 19;}
|
|
|
|
|
|
input.seek(index49_10);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 49, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA103_eotS:
|
|
"\u002d\uffff",
|
|
DFA103_eofS:
|
|
"\u002d\uffff",
|
|
DFA103_minS:
|
|
"\u0001\u0010\u002c\uffff",
|
|
DFA103_maxS:
|
|
"\u0001\u0137\u002c\uffff",
|
|
DFA103_acceptS:
|
|
"\u0001\uffff\u0001\u0001\u0001\u0002\u0029\uffff\u0001\u0003",
|
|
DFA103_specialS:
|
|
"\u002d\uffff}>",
|
|
DFA103_transitionS: [
|
|
"\u005b\u0002\u0001\u0001\u0033\u0002\u0001\uffff\u0014\u0002"+
|
|
"\u0001\uffff\u000d\u0002\u0001\uffff\u0001\u0002\u000a\uffff"+
|
|
"\u0001\u0002\u0002\uffff\u0001\u0002\u0005\uffff\u0004\u0002"+
|
|
"\u000c\uffff\u0001\u0002\u0002\uffff\u0002\u0002\u0002\uffff"+
|
|
"\u0001\u0002\u0006\uffff\u0001\u002c\u0005\u0002\u003c\uffff"+
|
|
"\u0001\u0002",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA103_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA103_eotS),
|
|
DFA103_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA103_eofS),
|
|
DFA103_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA103_minS),
|
|
DFA103_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA103_maxS),
|
|
DFA103_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA103_acceptS),
|
|
DFA103_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA103_specialS),
|
|
DFA103_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA103_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA103_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA103 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 103;
|
|
this.eot = XQueryParser.DFA103_eot;
|
|
this.eof = XQueryParser.DFA103_eof;
|
|
this.min = XQueryParser.DFA103_min;
|
|
this.max = XQueryParser.DFA103_max;
|
|
this.accept = XQueryParser.DFA103_accept;
|
|
this.special = XQueryParser.DFA103_special;
|
|
this.transition = XQueryParser.DFA103_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA103, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "612:1: p_ValueExpr : ( p_ValidateExpr | p_PathExpr | p_ExtensionExpr );";
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA110_eotS:
|
|
"\u002d\uffff",
|
|
DFA110_eofS:
|
|
"\u002d\uffff",
|
|
DFA110_minS:
|
|
"\u0001\u0010\u0001\u0000\u002b\uffff",
|
|
DFA110_maxS:
|
|
"\u0001\u0137\u0001\u0000\u002b\uffff",
|
|
DFA110_acceptS:
|
|
"\u0002\uffff\u0001\u0003\u0001\u0004\u0027\uffff\u0001\u0001\u0001"+
|
|
"\u0002",
|
|
DFA110_specialS:
|
|
"\u0001\uffff\u0001\u0000\u002b\uffff}>",
|
|
DFA110_transitionS: [
|
|
"\u008f\u0003\u0001\uffff\u0014\u0003\u0001\uffff\u000d\u0003"+
|
|
"\u0001\uffff\u0001\u0003\u000a\uffff\u0001\u0003\u0002\uffff"+
|
|
"\u0001\u0003\u0005\uffff\u0001\u0001\u0001\u0002\u0002\u0003"+
|
|
"\u000c\uffff\u0001\u0003\u0002\uffff\u0002\u0003\u0002\uffff"+
|
|
"\u0001\u0003\u0007\uffff\u0005\u0003\u003c\uffff\u0001\u0003",
|
|
"\u0001\uffff",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA110_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA110_eotS),
|
|
DFA110_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA110_eofS),
|
|
DFA110_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA110_minS),
|
|
DFA110_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA110_maxS),
|
|
DFA110_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA110_acceptS),
|
|
DFA110_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA110_specialS),
|
|
DFA110_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA110_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA110_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA110 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 110;
|
|
this.eot = XQueryParser.DFA110_eot;
|
|
this.eof = XQueryParser.DFA110_eof;
|
|
this.min = XQueryParser.DFA110_min;
|
|
this.max = XQueryParser.DFA110_max;
|
|
this.accept = XQueryParser.DFA110_accept;
|
|
this.special = XQueryParser.DFA110_special;
|
|
this.transition = XQueryParser.DFA110_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA110, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "656:1: p_PathExpr : ( ( SLASH p_RelativePathExpr )=> ( SLASH p_RelativePathExpr ) | SLASH | SLASH_SLASH p_RelativePathExpr | p_RelativePathExpr );";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA110_1 = input.LA(1);
|
|
|
|
|
|
var index110_1 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (this.synpred1_XQueryParser()) ) {s = 43;}
|
|
|
|
else if ( (true) ) {s = 44;}
|
|
|
|
|
|
input.seek(index110_1);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 110, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA112_eotS:
|
|
"\u00d1\uffff",
|
|
DFA112_eofS:
|
|
"\u0001\uffff\u0005\u0006\u0001\uffff\u000c\u0006\u0001\uffff\u0005"+
|
|
"\u0006\u00b7\uffff\u0001\u0006",
|
|
DFA112_minS:
|
|
"\u0001\u0010\u0005\u0012\u0001\uffff\u0002\u0012\u0001\u0010\u0004"+
|
|
"\u0012\u0002\u0010\u0003\u0012\u0001\uffff\u0002\u0012\u0001\u0010\u0002"+
|
|
"\u0012\u0001\u0010\u0003\u0013\u0001\u004f\u0010\u0010\u0001\u0084\u0001"+
|
|
"\u0010\u0002\u0019\u0001\u0052\u0001\u00c3\u0001\u0010\u0001\u0015\u0001"+
|
|
"\u0076\u0001\u0015\u0002\u001e\u0001\u0038\u0001\u00c4\u0001\u0010\u0001"+
|
|
"\u005a\u0009\u0010\u0003\u0013\u0001\u004f\u0010\u0010\u0001\u0084\u0001"+
|
|
"\u0010\u0002\u0019\u0001\u0052\u0001\u00c3\u0001\u0010\u0001\u0015\u0001"+
|
|
"\u0076\u0001\u0015\u0002\u001e\u0001\u0038\u0001\u00c4\u0001\u0010\u0001"+
|
|
"\u005a\u0009\u0010\u0003\u0013\u0001\u004f\u0010\u0010\u0001\u0084\u0001"+
|
|
"\u0010\u0002\u0019\u0001\u0052\u0001\u00c3\u0001\u0010\u0001\u0015\u0001"+
|
|
"\u0076\u0001\u0015\u0002\u001e\u0001\u0038\u0001\u00c4\u0001\u0010\u0001"+
|
|
"\u005a\u0009\u0010\u0003\u0013\u0001\u004f\u0010\u0010\u0001\u0084\u0001"+
|
|
"\u0010\u0002\u0019\u0001\u0052\u0001\u00c3\u0001\u0010\u0001\u0015\u0001"+
|
|
"\u0076\u0001\u0015\u0002\u001e\u0001\u0038\u0001\u00c4\u0001\u0010\u0001"+
|
|
"\u005a\u0009\u0010\u0002\uffff\u0001\u0012",
|
|
DFA112_maxS:
|
|
"\u0001\u0137\u0005\u0136\u0001\uffff\u0002\u0136\u0001\u0137\u0004"+
|
|
"\u0136\u0002\u0137\u0003\u0136\u0001\uffff\u0002\u0136\u0001\u0137\u0002"+
|
|
"\u0136\u0001\u0137\u0004\u00db\u0010\u0137\u0001\u00db\u0001\u0137\u0004"+
|
|
"\u00db\u0001\u0137\u0003\u00db\u0002\u0136\u0001\u00db\u0001\u00eb\u0001"+
|
|
"\u0137\u0001\u00db\u0009\u0137\u0004\u00db\u0010\u0137\u0001\u00db\u0001"+
|
|
"\u0137\u0004\u00db\u0001\u0137\u0003\u00db\u0002\u0136\u0001\u00db\u0001"+
|
|
"\u00eb\u0001\u0137\u0001\u00db\u0009\u0137\u0004\u00c4\u0010\u0137\u0001"+
|
|
"\u00c4\u0001\u0137\u0004\u00c4\u0001\u0137\u0003\u00c4\u0002\u0136\u0001"+
|
|
"\u00c4\u0001\u00eb\u0001\u0137\u0001\u00c4\u0009\u0137\u0004\u00c4\u0010"+
|
|
"\u0137\u0001\u00c4\u0001\u0137\u0004\u00c4\u0001\u0137\u0003\u00c4\u0002"+
|
|
"\u0136\u0001\u00c4\u0001\u00eb\u0001\u0137\u0001\u00c4\u0009\u0137\u0002"+
|
|
"\uffff\u0001\u0136",
|
|
DFA112_acceptS:
|
|
"\u0006\uffff\u0001\u0001\u000c\uffff\u0001\u0002\u00ba\uffff\u0002"+
|
|
"\u0002\u0001\uffff",
|
|
DFA112_specialS:
|
|
"\u0017\uffff\u0001\u0000\u00b9\uffff}>",
|
|
DFA112_transitionS: [
|
|
"\u0001\u0002\u0001\u0005\u0004\u0018\u0001\u0009\u0006\u0018"+
|
|
"\u0001\u0007\u0001\u0018\u0001\u0010\u0004\u0018\u0001\u0008"+
|
|
"\u0001\u000b\u0002\u0018\u0001\u0015\u0001\u0006\u0001\u000e"+
|
|
"\u0002\u0018\u0001\u0006\u0005\u0018\u0001\u000d\u0001\u000c"+
|
|
"\u0006\u0018\u0001\u0006\u0006\u0018\u0001\u0006\u0007\u0018"+
|
|
"\u0001\u0016\u0003\u0018\u0001\u0006\u0004\u0018\u0001\u0012"+
|
|
"\u0001\u0018\u0001\u0001\u0001\u0004\u0001\u0003\u0001\u0018"+
|
|
"\u0001\u000f\u0003\u0018\u0002\u0006\u0001\u000a\u0004\u0018"+
|
|
"\u0001\u0011\u0003\u0018\u0001\u0006\u0001\u0018\u0001\u0014"+
|
|
"\u0010\u0018\u0001\u0006\u0023\u0018\u0001\uffff\u0003\u0018"+
|
|
"\u0001\u0006\u0010\u0018\u0001\uffff\u0007\u0018\u0001\u0017"+
|
|
"\u0004\u0018\u0001\u0013\u0001\uffff\u0001\u0013\u000a\uffff"+
|
|
"\u0001\u0006\u0002\uffff\u0001\u0013\u0007\uffff\u0001\u0013"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0002\uffff\u0002\u0013"+
|
|
"\u0002\uffff\u0001\u0018\u0007\uffff\u0005\u0013\u003c\uffff"+
|
|
"\u0001\u0018",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0002\u0013\u0001\u002c\u0001\u0041\u0001\u0038\u0004\u0013"+
|
|
"\u0001\u0046\u0001\u003e\u0001\u001a\u0001\u001b\u0001\u0013"+
|
|
"\u0001\u003b\u0004\u0013\u0001\u003d\u0002\u0013\u0001\u0039"+
|
|
"\u0001\u0021\u0003\u0013\u0001\u003f\u0001\u003a\u0002\u0013"+
|
|
"\u0001\u0025\u0001\u0013\u0001\u001f\u0003\u0013\u0001\u002e"+
|
|
"\u0001\u0013\u0001\u002a\u0001\u0013\u0001\u0029\u0001\u0022"+
|
|
"\u0004\u0013\u0001\u001d\u0001\u001e\u0001\u002b\u0002\u0013"+
|
|
"\u0001\u0028\u0002\u0013\u0001\u0027\u0001\u0023\u0002\u0013"+
|
|
"\u0001\u0026\u0005\u0013\u0001\u002d\u0001\u0031\u0007\u0013"+
|
|
"\u0001\u0034\u0001\u003c\u0005\u0013\u0001\u0032\u0004\u0013"+
|
|
"\u0001\u0024\u0001\u001c\u0001\u0013\u0001\u0020\u0004\u0013"+
|
|
"\u0001\u002f\u0003\u0013\u0001\u0033\u0003\u0013\u0001\u0037"+
|
|
"\u0001\u0030\u0006\u0013\u0001\u0036\u0006\u0013\u0001\u0035"+
|
|
"\u0005\u0013\u0001\u0043\u0001\u0044\u0004\u0013\u0001\u0042"+
|
|
"\u0001\u0013\u0001\u0045\u0007\u0013\u0001\u0040\u0003\u0013"+
|
|
"\u0001\uffff\u0014\u0013\u0001\uffff\u000c\u0013\u0002\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0002\u0006\u000d\uffff\u0001\u0013"+
|
|
"\u0047\uffff\u0001\u0006\u0001\u0013",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0002\u0013\u0001\u0059\u0001\u006e\u0001\u0065\u0004\u0013"+
|
|
"\u0001\u0073\u0001\u006b\u0001\u0047\u0001\u0048\u0001\u0013"+
|
|
"\u0001\u0068\u0004\u0013\u0001\u006a\u0002\u0013\u0001\u0066"+
|
|
"\u0001\u004e\u0003\u0013\u0001\u006c\u0001\u0067\u0002\u0013"+
|
|
"\u0001\u0052\u0001\u0013\u0001\u004c\u0003\u0013\u0001\u005b"+
|
|
"\u0001\u0013\u0001\u0057\u0001\u0013\u0001\u0056\u0001\u004f"+
|
|
"\u0004\u0013\u0001\u004a\u0001\u004b\u0001\u0058\u0002\u0013"+
|
|
"\u0001\u0055\u0002\u0013\u0001\u0054\u0001\u0050\u0002\u0013"+
|
|
"\u0001\u0053\u0005\u0013\u0001\u005a\u0001\u005e\u0007\u0013"+
|
|
"\u0001\u0061\u0001\u0069\u0005\u0013\u0001\u005f\u0004\u0013"+
|
|
"\u0001\u0051\u0001\u0049\u0001\u0013\u0001\u004d\u0004\u0013"+
|
|
"\u0001\u005c\u0003\u0013\u0001\u0060\u0003\u0013\u0001\u0064"+
|
|
"\u0001\u005d\u0006\u0013\u0001\u0063\u0006\u0013\u0001\u0062"+
|
|
"\u0005\u0013\u0001\u0070\u0001\u0071\u0004\u0013\u0001\u006f"+
|
|
"\u0001\u0013\u0001\u0072\u0007\u0013\u0001\u006d\u0003\u0013"+
|
|
"\u0001\uffff\u0014\u0013\u0001\uffff\u000c\u0013\u0002\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0002\u0006\u000d\uffff\u0001\u0013"+
|
|
"\u0047\uffff\u0001\u0006\u0001\u0013",
|
|
"\u0002\u0013\u0001\u0086\u0001\u009b\u0001\u0092\u0004\u0013"+
|
|
"\u0001\u00a0\u0001\u0098\u0001\u0074\u0001\u0075\u0001\u0013"+
|
|
"\u0001\u0095\u0004\u0013\u0001\u0097\u0002\u0013\u0001\u0093"+
|
|
"\u0001\u007b\u0003\u0013\u0001\u0099\u0001\u0094\u0002\u0013"+
|
|
"\u0001\u007f\u0001\u0013\u0001\u0079\u0003\u0013\u0001\u0088"+
|
|
"\u0001\u0013\u0001\u0084\u0001\u0013\u0001\u0083\u0001\u007c"+
|
|
"\u0004\u0013\u0001\u0077\u0001\u0078\u0001\u0085\u0002\u0013"+
|
|
"\u0001\u0082\u0002\u0013\u0001\u0081\u0001\u007d\u0002\u0013"+
|
|
"\u0001\u0080\u0005\u0013\u0001\u0087\u0001\u008b\u0007\u0013"+
|
|
"\u0001\u008e\u0001\u0096\u0005\u0013\u0001\u008c\u0004\u0013"+
|
|
"\u0001\u007e\u0001\u0076\u0001\u0013\u0001\u007a\u0004\u0013"+
|
|
"\u0001\u0089\u0003\u0013\u0001\u008d\u0003\u0013\u0001\u0091"+
|
|
"\u0001\u008a\u0006\u0013\u0001\u0090\u0006\u0013\u0001\u008f"+
|
|
"\u0005\u0013\u0001\u009d\u0001\u009e\u0004\u0013\u0001\u009c"+
|
|
"\u0001\u0013\u0001\u009f\u0007\u0013\u0001\u009a\u0003\u0013"+
|
|
"\u0001\uffff\u0014\u0013\u0001\uffff\u000c\u0013\u0002\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0002\u0006\u000d\uffff\u0001\u0013"+
|
|
"\u0047\uffff\u0001\u0006\u0001\u0013",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0002\u0006\u0001\uffff"+
|
|
"\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0002\u0006\u0001\uffff"+
|
|
"\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0019\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0019\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u0013\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0019\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0002\u0013\u0001\u00b3\u0001\u00c8\u0001\u00bf\u0004\u0013"+
|
|
"\u0001\u00cd\u0001\u00c5\u0001\u00a1\u0001\u00a2\u0001\u0013"+
|
|
"\u0001\u00c2\u0004\u0013\u0001\u00c4\u0002\u0013\u0001\u00c0"+
|
|
"\u0001\u00a8\u0003\u0013\u0001\u00c6\u0001\u00c1\u0002\u0013"+
|
|
"\u0001\u00ac\u0001\u0013\u0001\u00a6\u0003\u0013\u0001\u00b5"+
|
|
"\u0001\u0013\u0001\u00b1\u0001\u0013\u0001\u00b0\u0001\u00a9"+
|
|
"\u0004\u0013\u0001\u00a4\u0001\u00a5\u0001\u00b2\u0002\u0013"+
|
|
"\u0001\u00af\u0002\u0013\u0001\u00ae\u0001\u00aa\u0002\u0013"+
|
|
"\u0001\u00ad\u0005\u0013\u0001\u00b4\u0001\u00b8\u0007\u0013"+
|
|
"\u0001\u00bb\u0001\u00c3\u0005\u0013\u0001\u00b9\u0004\u0013"+
|
|
"\u0001\u00ab\u0001\u00a3\u0001\u0013\u0001\u00a7\u0004\u0013"+
|
|
"\u0001\u00b6\u0003\u0013\u0001\u00ba\u0003\u0013\u0001\u00be"+
|
|
"\u0001\u00b7\u0006\u0013\u0001\u00bd\u0006\u0013\u0001\u00bc"+
|
|
"\u0005\u0013\u0001\u00ca\u0001\u00cb\u0004\u0013\u0001\u00c9"+
|
|
"\u0001\u0013\u0001\u00cc\u0007\u0013\u0001\u00c7\u0003\u0013"+
|
|
"\u0001\uffff\u0014\u0013\u0001\uffff\u000d\u0013\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0013\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0019\u0003\uffff\u0002\u0006\u000d\uffff\u0001\u0013"+
|
|
"\u0047\uffff\u0001\u0006\u0001\u0013",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u00cf\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u00ce\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff"+
|
|
"\u0001\u0019\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u00cf\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0002\uffff\u0001\u0019"+
|
|
"\u0003\uffff\u0002\u0006\u0055\uffff\u0001\u0006",
|
|
"\u008f\u00d0\u0001\uffff\u0014\u00d0\u0001\uffff\u000c\u00d0"+
|
|
"\u000d\uffff\u0001\u0006\u001f\uffff\u0001\u00d0\u0048\uffff"+
|
|
"\u0001\u00d0",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0074\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u0002\uffff\u0001\u0006\u003b\uffff\u0001\u0006"+
|
|
"\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0071\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf"+
|
|
"\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u004d\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf"+
|
|
"\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u000e\uffff\u0001\u00cf\u005a\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u000e\uffff\u0001\u00cf\u005a\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u007e\uffff\u0001\u00cf"+
|
|
"\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u00cf\u0016\uffff\u0001\u00cf\u000e\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0068\uffff\u0001\u0006\u0001\u00cf\u0016\uffff"+
|
|
"\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000c\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0001\u00cf\u0016\uffff\u0001\u00cf"+
|
|
"\u0012\uffff\u0001\u0006\u0048\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0005\uffff\u0004\u0006\u0001\u00cf"+
|
|
"\u000b\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0002\uffff"+
|
|
"\u0001\u0006\u0007\uffff\u0005\u0006\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0074\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u0002\uffff\u0001\u0006\u003b\uffff\u0001\u0006"+
|
|
"\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0071\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf"+
|
|
"\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u004d\uffff\u0001\u00cf\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf"+
|
|
"\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u000e\uffff\u0001\u00cf\u005a\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u000e\uffff\u0001\u00cf\u005a\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u007e\uffff\u0001\u00cf"+
|
|
"\u0016\uffff\u0001\u00cf",
|
|
"\u0001\u00cf\u0016\uffff\u0001\u00cf\u000e\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0068\uffff\u0001\u0006\u0001\u00cf\u0016\uffff"+
|
|
"\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000c\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0001\u00cf\u0016\uffff\u0001\u00cf"+
|
|
"\u0012\uffff\u0001\u0006\u0048\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u0001\u00cf\u000b\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0006\u0006\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0005\uffff\u0004\u0006\u0001\u00cf"+
|
|
"\u000b\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0002\uffff"+
|
|
"\u0001\u0006\u0007\uffff\u0005\u0006\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0074\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u0002\uffff\u0001\u0006\u003b\uffff\u0001\u0006"+
|
|
"\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0071\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf",
|
|
"\u0001\u0006\u004d\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u0069\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u0069\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u007e\uffff\u0001\u00cf",
|
|
"\u0001\u00cf\u0025\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0068\uffff\u0001\u0006\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000c\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0001\u00cf\u0029\uffff\u0001\u0006"+
|
|
"\u0048\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0005\uffff\u0004\u0006\u000c\uffff"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0005\u0006\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00b0\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0074\uffff\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003c\uffff\u0001\u0006",
|
|
"\u0001\u0006\u0002\uffff\u0001\u0006\u003b\uffff\u0001\u0006"+
|
|
"\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u00aa\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0071\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf",
|
|
"\u0001\u0006\u004d\uffff\u0001\u00cf",
|
|
"\u0001\u0006\u0067\uffff\u0001\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u003a\uffff\u0001\u0006\u0001\u00cf",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u0069\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000d\uffff\u0001\u0006\u0008\uffff\u0001\u0006"+
|
|
"\u001c\uffff\u0001\u0006\u0007\uffff\u0001\u0006\u0006\uffff"+
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u0003\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u004c\uffff\u0001\u00cf\u0007\uffff"+
|
|
"\u0001\u0006\u0069\uffff\u0001\u0006",
|
|
"\u0001\u0006\u000c\uffff\u0001\u0006\u007e\uffff\u0001\u00cf",
|
|
"\u0001\u00cf\u0025\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u0001\u0006\u0068\uffff\u0001\u0006\u0001\u00cf",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000c\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0001\u00cf\u0029\uffff\u0001\u0006"+
|
|
"\u0048\uffff\u0001\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0004\u0006"+
|
|
"\u0005\uffff\u0004\u0006\u000c\uffff\u0001\u0006\u0002\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0006\uffff\u0006\u0006"+
|
|
"\u003b\uffff\u0002\u0006",
|
|
"\u008f\u0006\u0001\uffff\u0014\u0006\u0001\uffff\u000d\u0006"+
|
|
"\u0001\uffff\u0001\u0006\u0001\u00cf\u0009\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0001\u0006\u0005\uffff\u0004\u0006\u000c\uffff"+
|
|
"\u0001\u0006\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0005\u0006\u003c\uffff\u0001\u0006",
|
|
"",
|
|
"",
|
|
"\u0003\u0006\u0004\uffff\u0004\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0001\u0006\u0002\uffff\u0002\u0006\u0003\uffff"+
|
|
"\u0002\u0006\u0002\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0003\uffff\u0001\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0003\u0006\u0002\uffff\u0001\u0006"+
|
|
"\u0002\uffff\u0002\u0006\u0002\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0007\uffff\u0002\u0006\u0005\uffff\u0001\u0006"+
|
|
"\u0004\uffff\u0002\u0006\u0001\uffff\u0001\u0006\u0004\uffff"+
|
|
"\u0001\u0006\u0003\uffff\u0001\u0006\u0003\uffff\u0002\u0006"+
|
|
"\u0006\uffff\u0001\u0006\u0006\uffff\u0001\u0006\u0005\uffff"+
|
|
"\u0002\u0006\u0004\uffff\u0001\u0006\u0001\uffff\u0001\u0006"+
|
|
"\u0007\uffff\u0001\u0006\u0025\uffff\u0001\u00cf\u0001\u0006"+
|
|
"\u0002\uffff\u0004\u0006\u0001\uffff\u0001\u0006\u0001\uffff"+
|
|
"\u0001\u0006\u0001\uffff\u000b\u0006\u0006\uffff\u0002\u0006"+
|
|
"\u0055\uffff\u0001\u0006"
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA112_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA112_eotS),
|
|
DFA112_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA112_eofS),
|
|
DFA112_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA112_minS),
|
|
DFA112_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA112_maxS),
|
|
DFA112_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA112_acceptS),
|
|
DFA112_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA112_specialS),
|
|
DFA112_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA112_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA112_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA112 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 112;
|
|
this.eot = XQueryParser.DFA112_eot;
|
|
this.eof = XQueryParser.DFA112_eof;
|
|
this.min = XQueryParser.DFA112_min;
|
|
this.max = XQueryParser.DFA112_max;
|
|
this.accept = XQueryParser.DFA112_accept;
|
|
this.special = XQueryParser.DFA112_special;
|
|
this.transition = XQueryParser.DFA112_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA112, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "669:1: p_StepExpr : ( p_AxisStep | p_FilterExpr );";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA112_23 = input.LA(1);
|
|
|
|
|
|
var index112_23 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA112_23==LBRACKET) && ((false))) {s = 206;}
|
|
|
|
else if ( (LA112_23==COLON) ) {s = 25;}
|
|
|
|
else if ( (LA112_23==EOF||(LA112_23>=AND && LA112_23<=ASCENDING)||(LA112_23>=BY && LA112_23<=CASTABLE)||LA112_23==COLLATION||LA112_23==DEFAULT||(LA112_23>=DESCENDING && LA112_23<=DIV)||(LA112_23>=ELSE && LA112_23<=EMPTY)||LA112_23==EQ||LA112_23==EXCEPT||LA112_23==FOR||LA112_23==GE||(LA112_23>=GT && LA112_23<=IDIV)||(LA112_23>=INSTANCE && LA112_23<=IS)||LA112_23==LE||(LA112_23>=LT && LA112_23<=MOD)||LA112_23==NE||(LA112_23>=OR && LA112_23<=ORDER)||(LA112_23>=RETURN && LA112_23<=SATISFIES)||LA112_23==STABLE||(LA112_23>=TO && LA112_23<=TREAT)||LA112_23==UNION||LA112_23==WHERE||LA112_23==COUNT||(LA112_23>=END && LA112_23<=GROUP)||LA112_23==ONLY||LA112_23==START||(LA112_23>=AFTER && LA112_23<=BEFORE)||LA112_23==INTO||LA112_23==MODIFY||LA112_23==WITH||LA112_23==RPAREN||(LA112_23>=RBRACKET && LA112_23<=EQUAL)||LA112_23==NOTEQUAL||LA112_23==COMMA||(LA112_23>=STAR && LA112_23<=SLASH_SLASH)||(LA112_23>=SEMICOLON && LA112_23<=VBAR)||LA112_23==LETDOLLAR) ) {s = 6;}
|
|
|
|
else if ( (LA112_23==LPAREN) ) {s = 207;}
|
|
|
|
|
|
input.seek(index112_23);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 112, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA114_eotS:
|
|
"\u000a\uffff",
|
|
DFA114_eofS:
|
|
"\u0001\uffff\u0007\u0008\u0002\uffff",
|
|
DFA114_minS:
|
|
"\u0001\u0010\u0007\u0012\u0002\uffff",
|
|
DFA114_maxS:
|
|
"\u0001\u0137\u0007\u0136\u0002\uffff",
|
|
DFA114_acceptS:
|
|
"\u0008\uffff\u0001\u0002\u0001\u0001",
|
|
DFA114_specialS:
|
|
"\u000a\uffff}>",
|
|
DFA114_transitionS: [
|
|
"\u0006\u0008\u0001\u0003\u0006\u0008\u0001\u0001\u0006\u0008"+
|
|
"\u0001\u0002\u0001\u0005\u000d\u0008\u0001\u0007\u0001\u0006"+
|
|
"\u002a\u0008\u0001\u0004\u003f\u0008\u0001\uffff\u0014\u0008"+
|
|
"\u0001\uffff\u000c\u0008\u000d\uffff\u0001\u0008\u0018\uffff"+
|
|
"\u0001\u0008\u0006\uffff\u0001\u0008\u0048\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0026\uffff\u0001\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0026\uffff\u0001\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0025\uffff\u0002\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0026\uffff\u0001\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0026\uffff\u0001\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0026\uffff\u0001\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"\u0003\u0008\u0004\uffff\u0004\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0001\u0008\u0002\uffff\u0002\u0008\u0003\uffff"+
|
|
"\u0002\u0008\u0002\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0003\uffff\u0001\u0008\u0001\uffff\u0001\u0008\u0001\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0003\u0008\u0002\uffff\u0001\u0008"+
|
|
"\u0002\uffff\u0002\u0008\u0002\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0007\uffff\u0002\u0008\u0005\uffff\u0001\u0008"+
|
|
"\u0004\uffff\u0002\u0008\u0001\uffff\u0001\u0008\u0004\uffff"+
|
|
"\u0001\u0008\u0003\uffff\u0001\u0008\u0003\uffff\u0002\u0008"+
|
|
"\u0006\uffff\u0001\u0008\u0006\uffff\u0001\u0008\u0005\uffff"+
|
|
"\u0002\u0008\u0004\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0007\uffff\u0001\u0008\u0026\uffff\u0001\u0008\u0002\uffff"+
|
|
"\u0004\u0008\u0001\uffff\u0001\u0008\u0001\uffff\u0001\u0008"+
|
|
"\u0001\uffff\u000b\u0008\u0002\uffff\u0001\u0008\u0001\u0009"+
|
|
"\u0002\uffff\u0002\u0008\u0055\uffff\u0001\u0008",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA114_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA114_eotS),
|
|
DFA114_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA114_eofS),
|
|
DFA114_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA114_minS),
|
|
DFA114_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA114_maxS),
|
|
DFA114_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA114_acceptS),
|
|
DFA114_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA114_specialS),
|
|
DFA114_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA114_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA114_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA114 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 114;
|
|
this.eot = XQueryParser.DFA114_eot;
|
|
this.eof = XQueryParser.DFA114_eof;
|
|
this.min = XQueryParser.DFA114_min;
|
|
this.max = XQueryParser.DFA114_max;
|
|
this.accept = XQueryParser.DFA114_accept;
|
|
this.special = XQueryParser.DFA114_special;
|
|
this.transition = XQueryParser.DFA114_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA114, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "680:1: p_ForwardStep : ( ( p_ForwardAxis p_NodeTest ) | p_AbbrevForwardStep );";
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA119_eotS:
|
|
"\u000d\uffff",
|
|
DFA119_eofS:
|
|
"\u0001\uffff\u000a\u000b\u0002\uffff",
|
|
DFA119_minS:
|
|
"\u0001\u0010\u000a\u0012\u0002\uffff",
|
|
DFA119_maxS:
|
|
"\u0001\u0137\u000a\u0136\u0002\uffff",
|
|
DFA119_acceptS:
|
|
"\u000b\uffff\u0001\u0002\u0001\u0001",
|
|
DFA119_specialS:
|
|
"\u000d\uffff}>",
|
|
DFA119_transitionS: [
|
|
"\u0006\u000b\u0001\u0003\u0008\u000b\u0001\u0008\u0009\u000b"+
|
|
"\u0001\u0001\u0001\u0002\u0023\u000b\u0001\u000a\u000a\u000b"+
|
|
"\u0001\u0007\u0003\u000b\u0001\u0005\u0001\u0004\u0005\u000b"+
|
|
"\u0001\u0009\u0016\u000b\u0001\u0006\u0023\u000b\u0001\uffff"+
|
|
"\u0014\u000b\u0001\uffff\u000c\u000b\u000d\uffff\u0001\u000b"+
|
|
"\u001f\uffff\u0001\u000b\u0048\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"\u0003\u000b\u0004\uffff\u0004\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0001\u000b\u0002\uffff\u0002\u000b\u0003\uffff"+
|
|
"\u0002\u000b\u0002\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0001\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0003\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0002\uffff\u0002\u000b\u0002\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0007\uffff\u0002\u000b\u0005\uffff\u0001\u000b"+
|
|
"\u0004\uffff\u0002\u000b\u0001\uffff\u0001\u000b\u0004\uffff"+
|
|
"\u0001\u000b\u0003\uffff\u0001\u000b\u0003\uffff\u0002\u000b"+
|
|
"\u0006\uffff\u0001\u000b\u0006\uffff\u0001\u000b\u0005\uffff"+
|
|
"\u0002\u000b\u0004\uffff\u0001\u000b\u0001\uffff\u0001\u000b"+
|
|
"\u0007\uffff\u0001\u000b\u0025\uffff\u0001\u000c\u0001\u000b"+
|
|
"\u0002\uffff\u0004\u000b\u0001\uffff\u0001\u000b\u0001\uffff"+
|
|
"\u0001\u000b\u0001\uffff\u000b\u000b\u0002\uffff\u0001\u000b"+
|
|
"\u0003\uffff\u0002\u000b\u0055\uffff\u0001\u000b",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA119_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA119_eotS),
|
|
DFA119_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA119_eofS),
|
|
DFA119_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA119_minS),
|
|
DFA119_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA119_maxS),
|
|
DFA119_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA119_acceptS),
|
|
DFA119_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA119_specialS),
|
|
DFA119_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA119_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA119_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA119 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 119;
|
|
this.eot = XQueryParser.DFA119_eot;
|
|
this.eof = XQueryParser.DFA119_eof;
|
|
this.min = XQueryParser.DFA119_min;
|
|
this.max = XQueryParser.DFA119_max;
|
|
this.accept = XQueryParser.DFA119_accept;
|
|
this.special = XQueryParser.DFA119_special;
|
|
this.transition = XQueryParser.DFA119_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA119, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "720:1: p_NodeTest : ( p_KindTest | p_NameTest );";
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA124_eotS:
|
|
"\u000f\uffff",
|
|
DFA124_eofS:
|
|
"\u000f\uffff",
|
|
DFA124_minS:
|
|
"\u0001\u0010\u0004\uffff\u0003\u00c1\u0001\uffff\u0001\u0010\u0001"+
|
|
"\u00c1\u0004\uffff",
|
|
DFA124_maxS:
|
|
"\u0001\u0137\u0004\uffff\u0003\u00db\u0001\uffff\u0001\u0137\u0001"+
|
|
"\u00db\u0004\uffff",
|
|
DFA124_acceptS:
|
|
"\u0001\uffff\u0001\u0001\u0001\u0002\u0001\u0003\u0001\u0004\u0003"+
|
|
"\uffff\u0001\u0008\u0002\uffff\u0001\u0005\u0001\u0006\u0001\u0007\u0001"+
|
|
"\u0008",
|
|
DFA124_specialS:
|
|
"\u000a\uffff\u0001\u0000\u0004\uffff}>",
|
|
DFA124_transitionS: [
|
|
"\u0006\u000b\u0001\u0008\u0008\u000b\u0001\u0008\u0008\u000b"+
|
|
"\u0001\u0007\u0001\uffff\u0001\u0008\u0002\u000b\u0001\uffff"+
|
|
"\u000d\u000b\u0001\uffff\u0006\u000b\u0001\uffff\u0007\u000b"+
|
|
"\u0001\u0009\u0003\u000b\u0001\uffff\u0004\u000b\u0001\u0005"+
|
|
"\u0005\u000b\u0001\u0008\u0003\u000b\u0002\uffff\u0005\u000b"+
|
|
"\u0001\u0008\u0003\u000b\u0001\uffff\u0001\u000b\u0001\u0006"+
|
|
"\u0010\u000b\u0001\uffff\u0023\u000b\u0001\uffff\u0003\u000b"+
|
|
"\u0001\uffff\u0010\u000b\u0001\uffff\u0007\u000b\u0001\u000a"+
|
|
"\u0004\u000b\u0001\u0003\u0001\uffff\u0001\u0002\u000d\uffff"+
|
|
"\u0001\u0008\u0007\uffff\u0001\u0004\u0010\uffff\u0002\u0001"+
|
|
"\u0002\uffff\u0001\u000b\u0007\uffff\u0002\u0008\u0003\u0001"+
|
|
"\u003c\uffff\u0001\u000b",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"\u0001\u000b\u0002\uffff\u0001\u000c\u0016\uffff\u0001\u000b",
|
|
"\u0001\u000b\u0002\uffff\u0001\u000d\u0016\uffff\u0001\u000b",
|
|
"\u0001\u000b\u0002\uffff\u0001\u0008\u0016\uffff\u0001\u000b",
|
|
"",
|
|
"\u008f\u0008\u0001\uffff\u0014\u0008\u0001\uffff\u000c\u0008"+
|
|
"\u0001\u000b\u0002\uffff\u0001\u0008\u0016\uffff\u0001\u000b"+
|
|
"\u0012\uffff\u0001\u0008\u0048\uffff\u0001\u0008",
|
|
"\u0001\u000b\u0002\uffff\u0001\u000e\u0016\uffff\u0001\u000b",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA124_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA124_eotS),
|
|
DFA124_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA124_eofS),
|
|
DFA124_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA124_minS),
|
|
DFA124_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA124_maxS),
|
|
DFA124_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA124_acceptS),
|
|
DFA124_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA124_specialS),
|
|
DFA124_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA124_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA124_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA124 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 124;
|
|
this.eot = XQueryParser.DFA124_eot;
|
|
this.eof = XQueryParser.DFA124_eof;
|
|
this.min = XQueryParser.DFA124_min;
|
|
this.max = XQueryParser.DFA124_max;
|
|
this.accept = XQueryParser.DFA124_accept;
|
|
this.special = XQueryParser.DFA124_special;
|
|
this.transition = XQueryParser.DFA124_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA124, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "751:1: p_PrimaryExpr : ( p_Literal | p_VarRef | p_ParenthesizedExpr | p_ContextItemExpr | p_FunctionCall | p_OrderedExpr | p_UnorderedExpr | p_Constructor );";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA124_10 = input.LA(1);
|
|
|
|
|
|
var index124_10 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA124_10==LBRACKET) && ((false))) {s = 14;}
|
|
|
|
else if ( (LA124_10==LPAREN||LA124_10==COLON) ) {s = 11;}
|
|
|
|
|
|
input.seek(index124_10);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 124, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA154_eotS:
|
|
"\u003e\uffff",
|
|
DFA154_eofS:
|
|
"\u0001\u0002\u003d\uffff",
|
|
DFA154_minS:
|
|
"\u0001\u0012\u0001\u0000\u0005\uffff\u0001\u0000\u0036\uffff",
|
|
DFA154_maxS:
|
|
"\u0001\u0136\u0001\u0000\u0005\uffff\u0001\u0000\u0036\uffff",
|
|
DFA154_acceptS:
|
|
"\u0002\uffff\u0001\u0002\u0008\uffff\u0001\u0001\u0032\uffff",
|
|
DFA154_specialS:
|
|
"\u0001\u0000\u0001\u0001\u0005\uffff\u0001\u0002\u0036\uffff}>",
|
|
DFA154_transitionS: [
|
|
"\u0004\u0002\u0004\uffff\u0001\u0002\u0003\uffff\u0001\u0002"+
|
|
"\u0004\uffff\u0001\u0002\u0002\uffff\u0002\u0002\u0003\uffff"+
|
|
"\u0002\u0002\u0002\uffff\u0001\u0002\u0001\uffff\u0002\u0002"+
|
|
"\u0002\uffff\u0001\u0002\u0001\uffff\u0001\u0002\u0001\uffff"+
|
|
"\u0002\u0002\u0002\uffff\u0001\u0002\u0001\uffff\u0003\u0002"+
|
|
"\u0002\uffff\u0001\u0002\u0002\uffff\u0002\u0002\u0002\uffff"+
|
|
"\u0001\u0002\u0005\uffff\u0002\u0002\u0007\uffff\u0002\u0002"+
|
|
"\u0005\uffff\u0001\u0002\u0004\uffff\u0001\u0002\u0002\uffff"+
|
|
"\u0001\u0002\u0004\uffff\u0001\u0002\u0003\uffff\u0001\u0002"+
|
|
"\u0003\uffff\u0002\u0002\u0006\uffff\u0001\u0002\u0006\uffff"+
|
|
"\u0001\u0002\u0005\uffff\u0002\u0002\u0004\uffff\u0001\u0002"+
|
|
"\u0001\uffff\u0001\u0002\u0007\uffff\u0001\u0002\u0026\uffff"+
|
|
"\u0001\u0002\u0001\uffff\u0002\u0002\u0001\uffff\u0004\u0002"+
|
|
"\u0001\uffff\u0001\u0002\u0001\u000b\u0001\u0001\u0001\u0007"+
|
|
"\u0007\u0002\u0008\uffff\u0002\u0002\u0055\uffff\u0001\u0002",
|
|
"\u0001\uffff",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"\u0001\uffff",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA154_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA154_eotS),
|
|
DFA154_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA154_eofS),
|
|
DFA154_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA154_minS),
|
|
DFA154_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA154_maxS),
|
|
DFA154_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA154_acceptS),
|
|
DFA154_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA154_specialS),
|
|
DFA154_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA154_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA154_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA154 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 154;
|
|
this.eot = XQueryParser.DFA154_eot;
|
|
this.eof = XQueryParser.DFA154_eof;
|
|
this.min = XQueryParser.DFA154_min;
|
|
this.max = XQueryParser.DFA154_max;
|
|
this.accept = XQueryParser.DFA154_accept;
|
|
this.special = XQueryParser.DFA154_special;
|
|
this.transition = XQueryParser.DFA154_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA154, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "1011:25: ( ( p_OccurrenceIndicator )=>oi= p_OccurrenceIndicator )?";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA154_0 = input.LA(1);
|
|
|
|
|
|
var index154_0 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA154_0==STAR) ) {s = 1;}
|
|
|
|
else if ( (LA154_0==EOF||(LA154_0>=AND && LA154_0<=AT)||LA154_0==CASE||LA154_0==COLLATION||LA154_0==DEFAULT||(LA154_0>=DESCENDING && LA154_0<=DIV)||(LA154_0>=ELSE && LA154_0<=EMPTY)||LA154_0==EQ||(LA154_0>=EXCEPT && LA154_0<=EXTERNAL)||LA154_0==FOR||LA154_0==GE||(LA154_0>=GT && LA154_0<=IDIV)||LA154_0==IN||(LA154_0>=INSTANCE && LA154_0<=IS)||LA154_0==LE||(LA154_0>=LT && LA154_0<=MOD)||LA154_0==NE||(LA154_0>=OR && LA154_0<=ORDER)||(LA154_0>=RETURN && LA154_0<=SATISFIES)||LA154_0==STABLE||LA154_0==TO||LA154_0==UNION||LA154_0==WHERE||LA154_0==COUNT||(LA154_0>=END && LA154_0<=GROUP)||LA154_0==ONLY||LA154_0==START||(LA154_0>=AFTER && LA154_0<=BEFORE)||LA154_0==INTO||LA154_0==MODIFY||LA154_0==WITH||LA154_0==RPAREN||(LA154_0>=LBRACKET && LA154_0<=RBRACKET)||(LA154_0>=RSQUARE && LA154_0<=NOTEQUAL)||LA154_0==COMMA||(LA154_0>=MINUS && LA154_0<=GREATER_GREATER)||(LA154_0>=SEMICOLON && LA154_0<=VBAR)||LA154_0==LETDOLLAR) ) {s = 2;}
|
|
|
|
else if ( (LA154_0==PLUS) ) {s = 7;}
|
|
|
|
else if ( (LA154_0==QUESTION) && (this.synpred2_XQueryParser())) {s = 11;}
|
|
|
|
|
|
input.seek(index154_0);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 1 :
|
|
var LA154_1 = input.LA(1);
|
|
|
|
|
|
var index154_1 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (this.synpred2_XQueryParser()) ) {s = 11;}
|
|
|
|
else if ( (true) ) {s = 2;}
|
|
|
|
|
|
input.seek(index154_1);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 2 :
|
|
var LA154_7 = input.LA(1);
|
|
|
|
|
|
var index154_7 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (this.synpred2_XQueryParser()) ) {s = 11;}
|
|
|
|
else if ( (true) ) {s = 2;}
|
|
|
|
|
|
input.seek(index154_7);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 154, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA156_eotS:
|
|
"\u0011\uffff",
|
|
DFA156_eofS:
|
|
"\u0001\uffff\u000c\u000d\u0004\uffff",
|
|
DFA156_minS:
|
|
"\u0001\u0010\u000c\u0012\u0004\uffff",
|
|
DFA156_maxS:
|
|
"\u0001\u0137\u000c\u0136\u0004\uffff",
|
|
DFA156_acceptS:
|
|
"\u000d\uffff\u0001\u0004\u0001\u0001\u0001\u0002\u0001\u0003",
|
|
DFA156_specialS:
|
|
"\u000b\uffff\u0001\u0000\u0005\uffff}>",
|
|
DFA156_transitionS: [
|
|
"\u0006\u000d\u0001\u0003\u0008\u000d\u0001\u0008\u0009\u000d"+
|
|
"\u0001\u0001\u0001\u0002\u0017\u000d\u0001\u000c\u000b\u000d"+
|
|
"\u0001\u000a\u000a\u000d\u0001\u0007\u0003\u000d\u0001\u0005"+
|
|
"\u0001\u0004\u0005\u000d\u0001\u0009\u0016\u000d\u0001\u0006"+
|
|
"\u0023\u000d\u0001\uffff\u0014\u000d\u0001\uffff\u0007\u000d"+
|
|
"\u0001\u000b\u0004\u000d\u002d\uffff\u0001\u000d\u0048\uffff"+
|
|
"\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000e\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u000f\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"\u0004\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0004\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0003\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0002\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0001\uffff\u0001\u000d\u0001\uffff"+
|
|
"\u0002\u000d\u0002\uffff\u0001\u000d\u0001\uffff\u0003\u000d"+
|
|
"\u0002\uffff\u0001\u000d\u0002\uffff\u0002\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0007\uffff\u0002\u000d"+
|
|
"\u0005\uffff\u0001\u000d\u0004\uffff\u0001\u000d\u0002\uffff"+
|
|
"\u0001\u000d\u0004\uffff\u0001\u000d\u0003\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0006\uffff\u0001\u000d\u0006\uffff"+
|
|
"\u0001\u000d\u0005\uffff\u0002\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0001\uffff\u0001\u000d\u0007\uffff\u0001\u000d\u0025\uffff"+
|
|
"\u0001\u0010\u0001\u000d\u0001\uffff\u0002\u000d\u0001\uffff"+
|
|
"\u0004\u000d\u0001\uffff\u000b\u000d\u0004\uffff\u0001\u000d"+
|
|
"\u0003\uffff\u0002\u000d\u0055\uffff\u0001\u000d",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
]
|
|
});
|
|
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
DFA156_eot:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA156_eotS),
|
|
DFA156_eof:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA156_eofS),
|
|
DFA156_min:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA156_minS),
|
|
DFA156_max:
|
|
org.antlr.runtime.DFA.unpackEncodedStringToUnsignedChars(XQueryParser.DFA156_maxS),
|
|
DFA156_accept:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA156_acceptS),
|
|
DFA156_special:
|
|
org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA156_specialS),
|
|
DFA156_transition: (function() {
|
|
var a = [],
|
|
i,
|
|
numStates = XQueryParser.DFA156_transitionS.length;
|
|
for (i=0; i<numStates; i++) {
|
|
a.push(org.antlr.runtime.DFA.unpackEncodedString(XQueryParser.DFA156_transitionS[i]));
|
|
}
|
|
return a;
|
|
})()
|
|
});
|
|
|
|
XQueryParser.DFA156 = function(recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 156;
|
|
this.eot = XQueryParser.DFA156_eot;
|
|
this.eof = XQueryParser.DFA156_eof;
|
|
this.min = XQueryParser.DFA156_min;
|
|
this.max = XQueryParser.DFA156_max;
|
|
this.accept = XQueryParser.DFA156_accept;
|
|
this.special = XQueryParser.DFA156_special;
|
|
this.transition = XQueryParser.DFA156_transition;
|
|
};
|
|
|
|
org.antlr.lang.extend(XQueryParser.DFA156, org.antlr.runtime.DFA, {
|
|
getDescription: function() {
|
|
return "1021:1: p_ItemType : ( p_KindTest -> ^( KindTest p_KindTest ) | {...}? => ( BINARY LPAREN RPAREN ) -> ^( BinaryTest BINARY LPAREN RPAREN ) | ( ITEM LPAREN RPAREN ) -> ^( ItemTest ITEM LPAREN RPAREN ) | p_AtomicType );";
|
|
},
|
|
specialStateTransition: function(s, input) {
|
|
var _s = s;
|
|
/* bind to recognizer so semantic predicates can be evaluated */
|
|
var retval = (function(s, input) {
|
|
switch ( s ) {
|
|
case 0 :
|
|
var LA156_11 = input.LA(1);
|
|
|
|
|
|
var index156_11 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (LA156_11==LPAREN) && ((false))) {s = 15;}
|
|
|
|
else if ( (LA156_11==EOF||(LA156_11>=AND && LA156_11<=AT)||LA156_11==CASE||LA156_11==COLLATION||LA156_11==DEFAULT||(LA156_11>=DESCENDING && LA156_11<=DIV)||(LA156_11>=ELSE && LA156_11<=EMPTY)||LA156_11==EQ||(LA156_11>=EXCEPT && LA156_11<=EXTERNAL)||LA156_11==FOR||LA156_11==GE||(LA156_11>=GT && LA156_11<=IDIV)||LA156_11==IN||(LA156_11>=INSTANCE && LA156_11<=IS)||LA156_11==LE||(LA156_11>=LT && LA156_11<=MOD)||LA156_11==NE||(LA156_11>=OR && LA156_11<=ORDER)||(LA156_11>=RETURN && LA156_11<=SATISFIES)||LA156_11==STABLE||LA156_11==TO||LA156_11==UNION||LA156_11==WHERE||LA156_11==COUNT||(LA156_11>=END && LA156_11<=GROUP)||LA156_11==ONLY||LA156_11==START||(LA156_11>=AFTER && LA156_11<=BEFORE)||LA156_11==INTO||LA156_11==MODIFY||LA156_11==WITH||LA156_11==RPAREN||(LA156_11>=LBRACKET && LA156_11<=RBRACKET)||(LA156_11>=RSQUARE && LA156_11<=NOTEQUAL)||(LA156_11>=COMMA && LA156_11<=GREATER_GREATER)||LA156_11==COLON||(LA156_11>=SEMICOLON && LA156_11<=VBAR)||LA156_11==LETDOLLAR) ) {s = 13;}
|
|
|
|
|
|
input.seek(index156_11);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
}).call(this.recognizer, s, input);
|
|
if (!org.antlr.lang.isUndefined(retval)) {
|
|
return retval;
|
|
}
|
|
if (this.recognizer.state.backtracking>0) {this.recognizer.state.failed=true; return -1;}
|
|
var nvae =
|
|
new org.antlr.runtime.NoViableAltException(this.getDescription(), 156, _s, input);
|
|
this.error(nvae);
|
|
throw nvae;
|
|
},
|
|
dummy: null
|
|
});
|
|
|
|
|
|
// public class variables
|
|
org.antlr.lang.augmentObject(XQueryParser, {
|
|
tokenNames: ["<invalid>", "<EOR>", "<DOWN>", "<UP>", "L_QuotAttrContentChar", "L_AposAttrContentChar", "L_ElementContentChar", "L_CDataSection", "L_PredefinedEntityRef", "L_CharRef", "ESCAPE_LBRACKET", "ESCAPE_RBRACKET", "ESCAPE_APOS", "ESCAPE_QUOT", "CDATA_START", "CDATA_END", "ANCESTOR", "ANCESTOR_OR_SELF", "AND", "AS", "ASCENDING", "AT", "ATTRIBUTE", "BASE_URI", "BOUNDARY_SPACE", "BY", "CASE", "CAST", "CASTABLE", "CHILD", "COLLATION", "COMMENT", "CONSTRUCTION", "COPY_NAMESPACES", "DECLARE", "DEFAULT", "DESCENDANT", "DESCENDANT_OR_SELF", "DESCENDING", "DIV", "DOCUMENT", "DOCUMENT_NODE", "ELEMENT", "ELSE", "EMPTY", "EMPTY_SEQUENCE", "ENCODING", "EQ", "EVERY", "EXCEPT", "EXTERNAL", "FOLLOWING", "FOLLOWING_SIBLING", "FOR", "FUNCTION", "GE", "GREATEST", "GT", "IDIV", "IF", "IMPORT", "IN", "INHERIT", "INSTANCE", "INTERSECT", "IS", "ITEM", "LAX", "LE", "LEAST", "LET", "LT", "MOD", "MODULE", "NAMESPACE", "NE", "NO_INHERIT", "NO_PRESERVE", "NODE", "OF", "OPTION", "OR", "ORDER", "ORDERED", "ORDERING", "PARENT", "PRECEDING", "PRECEDING_SIBLING", "PRESERVE", "PROCESSING_INSTRUCTION", "RETURN", "SATISFIES", "SCHEMA", "SCHEMA_ATTRIBUTE", "SCHEMA_ELEMENT", "SELF", "SOME", "STABLE", "STRICT", "STRIP", "TEXT", "THEN", "TO", "TREAT", "TYPESWITCH", "UNION", "UNORDERED", "VALIDATE", "VARIABLE", "VERSION", "WHERE", "XQUERY", "CATCH", "CONTEXT", "COUNT", "DECIMAL_FORMAT", "DECIMAL_SEPARATOR", "DIGIT", "END", "GROUP", "GROUPING_SEPARATOR", "INFINITY", "MINUS_SIGN", "NAMESPACE_NODE", "NAN", "NEXT", "ONLY", "OUTER", "PATTERN_SEPARATOR", "PERCENT", "PER_MILLE", "PREVIOUS", "SLIDING", "START", "TRY", "TUMBLING", "WHEN", "WINDOW", "ZERO_DIGIT", "AFTER", "BEFORE", "COPY", "DELETE", "FIRST", "INSERT", "INTO", "LAST", "MODIFY", "NODES", "RENAME", "REPLACE", "REVALIDATION", "SKIP", "UPDATING", "VALUE", "WITH", "BLOCK", "CONSTANT", "EXIT", "RETURNING", "SEQUENTIAL", "SET", "SIMPLE", "WHILE", "EVAL", "USING", "APPEND_ONLY", "AUTOMATICALLY", "CHECK", "COLLECTION", "CONSTRAINT", "CONST", "EQUALITY", "FOREACH", "FOREIGN", "FROM", "INDEX", "INTEGRITY", "KEY", "MAINTAINED", "MANUALLY", "MUTABLE", "NON", "ON", "QUEUE", "RANGE", "READ_ONLY", "UNIQUE", "BINARY", "PRIVATE", "AMP_ER", "APOS_ER", "QUOT_ER", "LPAREN", "RPAREN", "DOLLAR", "LBRACKET", "RBRACKET", "LSQUARE", "RSQUARE", "EQUAL", "BIND", "NOTEQUAL", "AMP", "COMMA", "QUESTION", "STAR", "PLUS", "MINUS", "SMALLER", "GREATER", "SMALLEREQ", "GREATEREQ", "SMALLER_SMALLER", "GREATER_GREATER", "SLASH", "SLASH_SLASH", "DOT", "DOT_DOT", "COLON", "COLON_COLON", "EMPTY_CLOSE_TAG", "CLOSE_TAG", "SEMICOLON", "VBAR", "PRAGMA_START", "PRAGMA_END", "XML_COMMENT_START", "XML_COMMENT_END", "PI_START", "PI_END", "ATTR_SIGN", "CHARREF_DEC", "CHARREF_HEX", "APOS", "QUOT", "NCNameStartChar", "NCNameChar", "L_NCName", "Letter", "HexLetter", "Digit", "Digits", "S", "SU", "L_Pragma", "L_DirCommentConstructor", "L_DirPIConstructor", "L_IntegerLiteral", "L_DecimalLiteral", "L_DoubleLiteral", "L_Comment", "L_AnyChar", "L_QuotStringLiteralChar", "L_AposStringLiteralChar", "LibraryModule", "MainModule", "VersionDecl", "VersionDeclEncoding", "VersionDeclVersion", "ModuleDecl", "Prolog", "DefaultNamespaceDecls", "DefaultNamespaceDecl", "Setters", "Setter", "NamespaceDecls", "NamespaceDecl", "Imports", "SchemaImport", "SchemaPrefix", "NamespaceName", "DefaultElementNamespace", "AtHints", "ModuleImport", "BaseURIDecl", "OrderedDecls", "VarDecl", "VarType", "VarValue", "VarDefaultValue", "VarConstantDecl", "VarVariableDecl", "FunctionDecl", "ParamList", "ReturnType", "OptionDecl", "TypeDeclaration", "Param", "EnclosedExpr", "QueryBody", "UnaryExpr", "DirElemConstructor", "DirAttributeList", "DirAttributeValue", "DirElemContent", "CommonContent", "SequenceType", "EmptySequenceTest", "KindTest", "ItemTest", "AtomicType", "StringLiteral", "ElementContentChar", "AttributeValueChar", "QName", "Block", "BlockDecls", "BlockVarDecl", "BinaryTest", "LETDOLLAR", "EXPLICITLY"],
|
|
FOLLOW_p_VersionDecl_in_p_Module523: new org.antlr.runtime.BitSet([0x00000000, 0x10000004,0x00000200, 0x00000000]),
|
|
FOLLOW_p_LibraryModule_in_p_Module558: new org.antlr.runtime.BitSet([0x00000000, 0x00000000]),
|
|
FOLLOW_p_MainModule_in_p_Module584: new org.antlr.runtime.BitSet([0x00000000, 0x00000000]),
|
|
FOLLOW_EOF_in_p_Module613: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_XQUERY_in_p_VersionDecl641: new org.antlr.runtime.BitSet([0x00000000, 0x00004000,0x00000000, 0x00002000]),
|
|
FOLLOW_ENCODING_in_p_VersionDecl647: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_VersionDecl651: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_VERSION_in_p_VersionDecl672: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_VersionDecl676: new org.antlr.runtime.BitSet([0x00000000, 0x00004000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_ENCODING_in_p_VersionDecl682: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_VersionDecl686: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_p_VersionDecl692: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_Prolog_in_p_MainModule758: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_QueryBody_in_p_MainModule760: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ModuleDecl_in_p_LibraryModule816: new org.antlr.runtime.BitSet([0x00000000, 0x10000004,0x00000200, 0x00000000]),
|
|
FOLLOW_pm_Prolog_in_p_LibraryModule818: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_MODULE_in_p_ModuleDecl874: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000400, 0x00000000]),
|
|
FOLLOW_NAMESPACE_in_p_ModuleDecl878: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_ModuleDecl880: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_EQUAL_in_p_ModuleDecl882: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_ModuleDecl884: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_p_ModuleDecl886: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_DefaultNamespaceDecl_in_pm_Prolog945: new org.antlr.runtime.BitSet([0x00000000, 0x10000004]),
|
|
FOLLOW_p_Setter_in_pm_Prolog951: new org.antlr.runtime.BitSet([0x00000000, 0x10000004]),
|
|
FOLLOW_pm_NamespaceDecl_in_pm_Prolog957: new org.antlr.runtime.BitSet([0x00000000, 0x10000004]),
|
|
FOLLOW_p_Import_in_pm_Prolog963: new org.antlr.runtime.BitSet([0x00000000, 0x10000004]),
|
|
FOLLOW_pg_OrderedDecl_in_pm_Prolog970: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_VarDecl_in_pg_OrderedDecl1248: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_pm_ContextItemDecl_in_pg_OrderedDecl1252: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_pm_FunctionDecl_in_pg_OrderedDecl1256: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_pm_OptionDecl_in_pg_OrderedDecl1260: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_p_CollectionDecl_in_pg_OrderedDecl1275: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_p_IndexDecl_in_pg_OrderedDecl1290: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_p_ICDecl_in_pg_OrderedDecl1305: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_pm_BoundarySpaceDecl_in_p_Setter1334: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_DefaultCollationDecl_in_p_Setter1346: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_BaseURIDecl_in_p_Setter1358: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_ConstructionDecl_in_p_Setter1370: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_OrderingModeDecl_in_p_Setter1382: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_EmptyOrderDecl_in_p_Setter1394: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_RevalidationDecl_in_p_Setter1409: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_CopyNamespacesDecl_in_p_Setter1421: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_SchemaImport_in_p_Import1447: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_ModuleImport_in_p_Import1451: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_NamespaceDecl1482: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000400, 0x00000000]),
|
|
FOLLOW_NAMESPACE_in_pm_NamespaceDecl1486: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_pm_NamespaceDecl1490: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_EQUAL_in_pm_NamespaceDecl1492: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_NamespaceDecl1496: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_NamespaceDecl1498: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_BoundarySpaceDecl1561: new org.antlr.runtime.BitSet([0x01000000, 0x00000000]),
|
|
FOLLOW_BOUNDARY_SPACE_in_pm_BoundarySpaceDecl1565: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x01000000, 0x00000008]),
|
|
FOLLOW_PRESERVE_in_pm_BoundarySpaceDecl1570: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_STRIP_in_pm_BoundarySpaceDecl1576: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_BoundarySpaceDecl1579: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_DefaultNamespaceDecl1607: new org.antlr.runtime.BitSet([0x00000000, 0x00000008]),
|
|
FOLLOW_DEFAULT_in_pm_DefaultNamespaceDecl1611: new org.antlr.runtime.BitSet([0x00000000, 0x00400400]),
|
|
FOLLOW_ELEMENT_in_pm_DefaultNamespaceDecl1616: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000400, 0x00000000]),
|
|
FOLLOW_FUNCTION_in_pm_DefaultNamespaceDecl1622: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000400, 0x00000000]),
|
|
FOLLOW_NAMESPACE_in_pm_DefaultNamespaceDecl1627: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_DefaultNamespaceDecl1629: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_DefaultNamespaceDecl1631: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_OptionDecl1662: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00010000, 0x00000000]),
|
|
FOLLOW_OPTION_in_pm_OptionDecl1666: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_pm_OptionDecl1668: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_OptionDecl1670: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_OptionDecl1672: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_OrderingModeDecl1703: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00100000, 0x00000000]),
|
|
FOLLOW_ORDERING_in_pm_OrderingModeDecl1707: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00080000, 0x00000400]),
|
|
FOLLOW_ORDERED_in_pm_OrderingModeDecl1712: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_UNORDERED_in_pm_OrderingModeDecl1718: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_OrderingModeDecl1721: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_EmptyOrderDecl1752: new org.antlr.runtime.BitSet([0x00000000, 0x00000008]),
|
|
FOLLOW_DEFAULT_in_pm_EmptyOrderDecl1756: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00040000, 0x00000000]),
|
|
FOLLOW_ORDER_in_pm_EmptyOrderDecl1760: new org.antlr.runtime.BitSet([0x00000000, 0x00001000]),
|
|
FOLLOW_EMPTY_in_pm_EmptyOrderDecl1764: new org.antlr.runtime.BitSet([0x00000000, 0x01000000,0x00000020, 0x00000000]),
|
|
FOLLOW_GREATEST_in_pm_EmptyOrderDecl1769: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_LEAST_in_pm_EmptyOrderDecl1775: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_EmptyOrderDecl1778: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_CopyNamespacesDecl1809: new org.antlr.runtime.BitSet([0x00000000, 0x00000002]),
|
|
FOLLOW_COPY_NAMESPACES_in_pm_CopyNamespacesDecl1813: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x01002000, 0x00000000]),
|
|
FOLLOW_p_PreserveMode_in_pm_CopyNamespacesDecl1815: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_pm_CopyNamespacesDecl1817: new org.antlr.runtime.BitSet([0x00000000, 0x40000000,0x00001000, 0x00000000]),
|
|
FOLLOW_p_InheritMode_in_pm_CopyNamespacesDecl1819: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_CopyNamespacesDecl1821: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_p_DecimalFormatDecl1852: new org.antlr.runtime.BitSet([0x00000000, 0x00000008,0x00000000, 0x00080000]),
|
|
FOLLOW_DECIMAL_FORMAT_in_p_DecimalFormatDecl1856: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_DecimalFormatDecl1858: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x17300000,0x00000407, 0x00000000]),
|
|
FOLLOW_DEFAULT_in_p_DecimalFormatDecl1864: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00080000]),
|
|
FOLLOW_DECIMAL_FORMAT_in_p_DecimalFormatDecl1866: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x17300000,0x00000407, 0x00000000]),
|
|
FOLLOW_p_DFPropertyName_in_p_DecimalFormatDecl1871: new org.antlr.runtime.BitSet([0x00000000, 0x00008000]),
|
|
FOLLOW_EQ_in_p_DecimalFormatDecl1874: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_DecimalFormatDecl1876: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_p_DecimalFormatDecl1878: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECIMAL_SEPARATOR_in_p_DFPropertyName1907: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_GROUPING_SEPARATOR_in_p_DFPropertyName1913: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_INFINITY_in_p_DFPropertyName1919: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_MINUS_SIGN_in_p_DFPropertyName1925: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NAN_in_p_DFPropertyName1931: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PERCENT_in_p_DFPropertyName1937: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PER_MILLE_in_p_DFPropertyName1943: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ZERO_DIGIT_in_p_DFPropertyName1949: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DIGIT_in_p_DFPropertyName1955: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PATTERN_SEPARATOR_in_p_DFPropertyName1961: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PRESERVE_in_p_PreserveMode1993: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NO_PRESERVE_in_p_PreserveMode1999: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_INHERIT_in_p_InheritMode2032: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NO_INHERIT_in_p_InheritMode2038: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_DefaultCollationDecl2078: new org.antlr.runtime.BitSet([0x00000000, 0x00000008]),
|
|
FOLLOW_DEFAULT_in_pm_DefaultCollationDecl2082: new org.antlr.runtime.BitSet([0x40000000, 0x00000000]),
|
|
FOLLOW_COLLATION_in_pm_DefaultCollationDecl2086: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_DefaultCollationDecl2088: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_DefaultCollationDecl2090: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_BaseURIDecl2129: new org.antlr.runtime.BitSet([0x00800000, 0x00000000]),
|
|
FOLLOW_BASE_URI_in_pm_BaseURIDecl2133: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_BaseURIDecl2137: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_BaseURIDecl2139: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_IMPORT_in_pm_SchemaImport2193: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_SCHEMA_in_pm_SchemaImport2197: new org.antlr.runtime.BitSet([0x00000000, 0x00000008,0x00000400, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_SchemaPrefix_in_pm_SchemaImport2201: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_SchemaImport2206: new org.antlr.runtime.BitSet([0x00200000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_AT_in_pm_SchemaImport2211: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_SchemaImport2215: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_pm_SchemaImport2218: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_SchemaImport2222: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_SchemaImport2228: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NAMESPACE_in_p_SchemaPrefix2299: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_SchemaPrefix2303: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_EQUAL_in_p_SchemaPrefix2305: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DEFAULT_in_p_SchemaPrefix2345: new org.antlr.runtime.BitSet([0x00000000, 0x00000400]),
|
|
FOLLOW_ELEMENT_in_p_SchemaPrefix2349: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000400, 0x00000000]),
|
|
FOLLOW_NAMESPACE_in_p_SchemaPrefix2353: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_IMPORT_in_pm_ModuleImport2402: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_MODULE_in_pm_ModuleImport2406: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000400, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_NAMESPACE_in_pm_ModuleImport2411: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_pm_ModuleImport2415: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_EQUAL_in_pm_ModuleImport2417: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_ModuleImport2423: new org.antlr.runtime.BitSet([0x00200000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_AT_in_pm_ModuleImport2428: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_ModuleImport2432: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_pm_ModuleImport2435: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_pm_ModuleImport2439: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_ModuleImport2445: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_VarDecl2515: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00001000,0x20000000, 0x20000000]),
|
|
FOLLOW_p_PrivateOption_in_pm_VarDecl2517: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00001000,0x20000000, 0x20000000]),
|
|
FOLLOW_pg_VarDeclType_in_pm_VarDecl2521: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_pm_VarDecl2523: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_pm_VarDecl2527: new org.antlr.runtime.BitSet([0x00080000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_pm_VarDecl2531: new org.antlr.runtime.BitSet([0x00000000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_pm_VarDecl2536: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_pm_VarDecl2540: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_EXTERNAL_in_pm_VarDecl2548: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000200, 0x00000000]),
|
|
FOLLOW_BIND_in_pm_VarDecl2551: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_pm_VarDecl2555: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_VarDecl2561: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_CONSTANT_in_pg_VarDeclType2648: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_VARIABLE_in_pg_VarDeclType2682: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_ContextItemDecl2739: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00020000]),
|
|
FOLLOW_CONTEXT_in_pm_ContextItemDecl2743: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_ITEM_in_pm_ContextItemDecl2747: new org.antlr.runtime.BitSet([0x00080000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_AS_in_pm_ContextItemDecl2752: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_ItemType_in_pm_ContextItemDecl2754: new org.antlr.runtime.BitSet([0x00000000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_pm_ContextItemDecl2760: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_pm_ContextItemDecl2762: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_EXTERNAL_in_pm_ContextItemDecl2770: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000200, 0x00000000]),
|
|
FOLLOW_BIND_in_pm_ContextItemDecl2773: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_pm_ContextItemDecl2775: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_ContextItemDecl2781: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_ConstructionDecl2815: new org.antlr.runtime.BitSet([0x00000000, 0x00000001]),
|
|
FOLLOW_CONSTRUCTION_in_pm_ConstructionDecl2819: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x01000000, 0x00000008]),
|
|
FOLLOW_STRIP_in_pm_ConstructionDecl2824: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_PRESERVE_in_pm_ConstructionDecl2830: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_ConstructionDecl2833: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_FunctionDecl2869: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000001]),
|
|
FOLLOW_SEQUENTIAL_in_pm_FunctionDecl2873: new org.antlr.runtime.BitSet([0x00000000, 0x00400000]),
|
|
FOLLOW_FUNCTION_in_pm_FunctionDecl2877: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_pm_FunctionDecl2881: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_pm_FunctionDecl2883: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x0000000C, 0x00000000]),
|
|
FOLLOW_p_ParamList_in_pm_FunctionDecl2887: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_pm_FunctionDecl2890: new org.antlr.runtime.BitSet([0x00080000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_pm_FunctionDecl2894: new org.antlr.runtime.BitSet([0x00000000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_Block_in_pm_FunctionDecl2900: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_EXTERNAL_in_pm_FunctionDecl2906: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_FunctionDecl2909: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_FunctionDecl2971: new org.antlr.runtime.BitSet([0x00000000, 0x00400000,0x00000000, 0x00000000,0x02000000, 0x20000004]),
|
|
FOLLOW_p_PrivateOption_in_pm_FunctionDecl2973: new org.antlr.runtime.BitSet([0x00000000, 0x00400000,0x00000000, 0x00000000,0x02000000, 0x00000004]),
|
|
FOLLOW_p_FunctionType_in_pm_FunctionDecl2975: new org.antlr.runtime.BitSet([0x00000000, 0x00400000]),
|
|
FOLLOW_FUNCTION_in_pm_FunctionDecl2979: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_pm_FunctionDecl2983: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_pm_FunctionDecl2985: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x0000000C, 0x00000000]),
|
|
FOLLOW_p_ParamList_in_pm_FunctionDecl2989: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_pm_FunctionDecl2992: new org.antlr.runtime.BitSet([0x00080000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_pm_FunctionDecl2996: new org.antlr.runtime.BitSet([0x00000000, 0x00040000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_EnclosedExpr_in_pm_FunctionDecl3002: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_EXTERNAL_in_pm_FunctionDecl3008: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_FunctionDecl3011: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_UPDATING_in_p_FunctionType3091: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SIMPLE_in_p_FunctionType3108: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PRIVATE_in_p_PrivateOption3150: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_Param_in_p_ParamList3193: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_ParamList3196: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_Param_in_p_ParamList3200: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_Param3258: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_Param3262: new org.antlr.runtime.BitSet([0x00080002, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_Param3266: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_EnclosedExpr3322: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_EnclosedExpr3324: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_EnclosedExpr3326: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_Expr_in_p_QueryBody3376: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ConcatExpr_in_pm_Expr3427: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_Expr3444: new org.antlr.runtime.BitSet([0xFFFF0002, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x8783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_ApplyExpr_in_pm_Expr3446: new org.antlr.runtime.BitSet([0xFFFF0002, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x8783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_SEMICOLON_in_pm_Expr3471: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ConcatExpr_in_pm_Expr3473: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_p_FLWORExpr_in_p_ExprSingle3507: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QuantifiedExpr_in_p_ExprSingle3519: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_TypeswitchExpr_in_p_ExprSingle3531: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_IfExpr_in_p_ExprSingle3543: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_TryCatchExpr_in_p_ExprSingle3555: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_EvalExpr_in_p_ExprSingle3570: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_InsertExpr_in_p_ExprSingle3585: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_DeleteExpr_in_p_ExprSingle3600: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_RenameExpr_in_p_ExprSingle3615: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ReplaceExpr_in_p_ExprSingle3630: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_TransformExpr_in_p_ExprSingle3645: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_BlockExpr_in_p_ExprSingle3660: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AssignmentExpr_in_p_ExprSingle3675: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ExitExpr_in_p_ExprSingle3690: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_WhileExpr_in_p_ExprSingle3705: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_OrExpr_in_p_ExprSingle3717: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_InitialClause_in_p_FLWORExpr3743: new org.antlr.runtime.BitSet([0x00000000, 0x00200000,0x04040000, 0x00844002,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00400000]),
|
|
FOLLOW_p_IntermediateClause_in_p_FLWORExpr3745: new org.antlr.runtime.BitSet([0x00000000, 0x00200000,0x04040000, 0x00844002,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00400000]),
|
|
FOLLOW_p_ReturnClause_in_p_FLWORExpr3748: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ForClause_in_p_InitialClause3774: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_LetClause_in_p_InitialClause3778: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_WindowClause_in_p_InitialClause3782: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_InitialClause_in_p_IntermediateClause3808: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_WhereClause_in_p_IntermediateClause3812: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_GroupByClause_in_p_IntermediateClause3816: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_OrderByClause_in_p_IntermediateClause3820: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CountClause_in_p_IntermediateClause3824: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_FOR_in_p_ForClause3852: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_ForClause3854: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_ForClause3856: new org.antlr.runtime.BitSet([0x00280000, 0x20000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_ForClause3858: new org.antlr.runtime.BitSet([0x00200000, 0x20000000]),
|
|
FOLLOW_p_PositionalVar_in_p_ForClause3861: new org.antlr.runtime.BitSet([0x00000000, 0x20000000]),
|
|
FOLLOW_IN_in_p_ForClause3866: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ForClause3868: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_ForClause3871: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_ForClause3873: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_ForClause3875: new org.antlr.runtime.BitSet([0x00280000, 0x20000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_ForClause3877: new org.antlr.runtime.BitSet([0x00200000, 0x20000000]),
|
|
FOLLOW_p_PositionalVar_in_p_ForClause3880: new org.antlr.runtime.BitSet([0x00000000, 0x20000000]),
|
|
FOLLOW_IN_in_p_ForClause3885: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ForClause3887: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_AT_in_p_PositionalVar3918: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_PositionalVar3920: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_PositionalVar3922: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LETDOLLAR_in_p_LetClause3950: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_LetClause3952: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_LetClause3954: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_p_LetClause3957: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_LetClause3959: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_LetClause3962: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_LetClause3964: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_LetClause3966: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_LetClause3968: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_p_LetClause3971: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_LetClause3973: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_FOR_in_p_WindowClause4003: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000090, 0x00000000]),
|
|
FOLLOW_p_TumblingWindowClause_in_p_WindowClause4006: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_SlidingWindowClause_in_p_WindowClause4010: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_TUMBLING_in_p_TumblingWindowClause4047: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_WINDOW_in_p_TumblingWindowClause4051: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_TumblingWindowClause4053: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_TumblingWindowClause4055: new org.antlr.runtime.BitSet([0x00080000, 0x20000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_TumblingWindowClause4057: new org.antlr.runtime.BitSet([0x00000000, 0x20000000]),
|
|
FOLLOW_IN_in_p_TumblingWindowClause4060: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_TumblingWindowClause4062: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_p_WindowStartCondition_in_p_TumblingWindowClause4064: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x40400000]),
|
|
FOLLOW_p_WindowEndCondition_in_p_TumblingWindowClause4066: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SLIDING_in_p_SlidingWindowClause4096: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_WINDOW_in_p_SlidingWindowClause4100: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_SlidingWindowClause4102: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_SlidingWindowClause4104: new org.antlr.runtime.BitSet([0x00080000, 0x20000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_SlidingWindowClause4106: new org.antlr.runtime.BitSet([0x00000000, 0x20000000]),
|
|
FOLLOW_IN_in_p_SlidingWindowClause4109: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_SlidingWindowClause4111: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_p_WindowStartCondition_in_p_SlidingWindowClause4113: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x40400000]),
|
|
FOLLOW_p_WindowEndCondition_in_p_SlidingWindowClause4115: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_START_in_p_WindowStartCondition4145: new org.antlr.runtime.BitSet([0x00200000, 0x00000000,0x00000000, 0x20000000,0x00000108, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_WindowVars_in_p_WindowStartCondition4147: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_WHEN_in_p_WindowStartCondition4151: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_WindowStartCondition4153: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ONLY_in_p_WindowEndCondition4182: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00400000]),
|
|
FOLLOW_END_in_p_WindowEndCondition4187: new org.antlr.runtime.BitSet([0x00200000, 0x00000000,0x00000000, 0x20000000,0x00000108, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_WindowVars_in_p_WindowEndCondition4189: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_WHEN_in_p_WindowEndCondition4193: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_WindowEndCondition4195: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_WindowVars4223: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_WindowVars4225: new org.antlr.runtime.BitSet([0x00200002, 0x00000000,0x00000000, 0x20000000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_PositionalVar_in_p_WindowVars4229: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x20000000,0x00000008, 0x00000000]),
|
|
FOLLOW_PREVIOUS_in_p_WindowVars4235: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_WindowVars4237: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_WindowVars4239: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x20000000]),
|
|
FOLLOW_NEXT_in_p_WindowVars4246: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_WindowVars4248: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_WindowVars4250: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COUNT_in_p_CountClause4290: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_CountClause4292: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_CountClause4294: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_WHERE_in_p_WhereClause4330: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_WhereClause4332: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_GROUP_in_p_GroupByClause4362: new org.antlr.runtime.BitSet([0x02000000, 0x00000000]),
|
|
FOLLOW_BY_in_p_GroupByClause4366: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_GroupingSpecList_in_p_GroupByClause4368: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_GroupingSpec_in_p_GroupingSpecList4397: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_GroupingSpecList4400: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_GroupingSpec_in_p_GroupingSpecList4402: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_GroupingSpec4432: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_GroupingSpec4434: new org.antlr.runtime.BitSet([0x40000002, 0x00000000]),
|
|
FOLLOW_COLLATION_in_p_GroupingSpec4439: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_GroupingSpec4441: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ORDER_in_p_OrderByClause4476: new org.antlr.runtime.BitSet([0x02000000, 0x00000000]),
|
|
FOLLOW_BY_in_p_OrderByClause4480: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_STABLE_in_p_OrderByClause4488: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00040000, 0x00000000]),
|
|
FOLLOW_ORDER_in_p_OrderByClause4492: new org.antlr.runtime.BitSet([0x02000000, 0x00000000]),
|
|
FOLLOW_BY_in_p_OrderByClause4496: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_OrderSpecList_in_p_OrderByClause4500: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_OrderSpec_in_p_OrderSpecList4529: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_OrderSpecList4532: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_OrderSpec_in_p_OrderSpecList4534: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_p_ExprSingle_in_p_OrderSpec4564: new org.antlr.runtime.BitSet([0x40100000, 0x00001040]),
|
|
FOLLOW_p_OrderModifier_in_p_OrderSpec4566: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ASCENDING_in_p_OrderModifier4595: new org.antlr.runtime.BitSet([0x40000002, 0x00001000]),
|
|
FOLLOW_DESCENDING_in_p_OrderModifier4601: new org.antlr.runtime.BitSet([0x40000002, 0x00001000]),
|
|
FOLLOW_EMPTY_in_p_OrderModifier4608: new org.antlr.runtime.BitSet([0x00000000, 0x01000000,0x00000020, 0x00000000]),
|
|
FOLLOW_GREATEST_in_p_OrderModifier4613: new org.antlr.runtime.BitSet([0x40000002, 0x00000000]),
|
|
FOLLOW_LEAST_in_p_OrderModifier4619: new org.antlr.runtime.BitSet([0x40000002, 0x00000000]),
|
|
FOLLOW_COLLATION_in_p_OrderModifier4627: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_OrderModifier4629: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_RETURN_in_p_ReturnClause4660: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ReturnClause4662: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SOME_in_p_QuantifiedExpr4693: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_EVERY_in_p_QuantifiedExpr4699: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_QuantifiedExpr4702: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_QuantifiedExpr4704: new org.antlr.runtime.BitSet([0x00080000, 0x20000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_QuantifiedExpr4706: new org.antlr.runtime.BitSet([0x00000000, 0x20000000]),
|
|
FOLLOW_IN_in_p_QuantifiedExpr4711: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_QuantifiedExpr4713: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x08000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_QuantifiedExpr4716: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_QuantifiedExpr4718: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_QuantifiedExpr4720: new org.antlr.runtime.BitSet([0x00080000, 0x20000000]),
|
|
FOLLOW_p_TypeDeclaration_in_p_QuantifiedExpr4722: new org.antlr.runtime.BitSet([0x00000000, 0x20000000]),
|
|
FOLLOW_IN_in_p_QuantifiedExpr4727: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_QuantifiedExpr4729: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x08000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_SATISFIES_in_p_QuantifiedExpr4735: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_QuantifiedExpr4737: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_TYPESWITCH_in_p_TypeswitchExpr4766: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_TypeswitchExpr4768: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_TypeswitchExpr4770: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_TypeswitchExpr4772: new org.antlr.runtime.BitSet([0x04000000, 0x00000000]),
|
|
FOLLOW_p_CaseClause_in_p_TypeswitchExpr4774: new org.antlr.runtime.BitSet([0x04000000, 0x00000008]),
|
|
FOLLOW_DEFAULT_in_p_TypeswitchExpr4779: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x04000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_TypeswitchExpr4782: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_TypeswitchExpr4784: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x04000000, 0x00000000]),
|
|
FOLLOW_RETURN_in_p_TypeswitchExpr4790: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_TypeswitchExpr4792: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_CASE_in_p_CaseClause4821: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000009, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_DOLLAR_in_p_CaseClause4824: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_CaseClause4826: new org.antlr.runtime.BitSet([0x00080000, 0x00000000]),
|
|
FOLLOW_AS_in_p_CaseClause4830: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000009, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_SequenceType_in_p_CaseClause4834: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x04000000, 0x00000000]),
|
|
FOLLOW_RETURN_in_p_CaseClause4838: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_CaseClause4840: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_IF_in_p_IfExpr4869: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_IfExpr4871: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_IfExpr4873: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_IfExpr4875: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000020]),
|
|
FOLLOW_THEN_in_p_IfExpr4879: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_IfExpr4881: new org.antlr.runtime.BitSet([0x00000000, 0x00000800]),
|
|
FOLLOW_ELSE_in_p_IfExpr4885: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_IfExpr4887: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AndExpr_in_p_OrExpr4914: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00020000, 0x00000000]),
|
|
FOLLOW_OR_in_p_OrExpr4920: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_AndExpr_in_p_OrExpr4923: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00020000, 0x00000000]),
|
|
FOLLOW_p_ComparisonExpr_in_p_AndExpr4954: new org.antlr.runtime.BitSet([0x00040002, 0x00000000]),
|
|
FOLLOW_AND_in_p_AndExpr4960: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ComparisonExpr_in_p_AndExpr4963: new org.antlr.runtime.BitSet([0x00040002, 0x00000000]),
|
|
FOLLOW_p_RangeExpr_in_p_ComparisonExpr4994: new org.antlr.runtime.BitSet([0x00000002, 0x02808000,0x00000892, 0x00000000,0x00000000, 0x00000000,0x007E0500, 0x00000000]),
|
|
FOLLOW_p_ValueComp_in_p_ComparisonExpr4999: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_GeneralComp_in_p_ComparisonExpr5003: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_NodeComp_in_p_ComparisonExpr5007: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_RangeExpr_in_p_ComparisonExpr5010: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AdditiveExpr_in_p_RangeExpr5041: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000040]),
|
|
FOLLOW_TO_in_p_RangeExpr5047: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_AdditiveExpr_in_p_RangeExpr5050: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_MultiplicativeExpr_in_p_AdditiveExpr5081: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00018000, 0x00000000]),
|
|
FOLLOW_set_in_p_AdditiveExpr5085: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_MultiplicativeExpr_in_p_AdditiveExpr5093: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00018000, 0x00000000]),
|
|
FOLLOW_p_UnionExpr_in_p_MultiplicativeExpr5124: new org.antlr.runtime.BitSet([0x00000002, 0x04000080,0x00000100, 0x00000000,0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_STAR_in_p_MultiplicativeExpr5129: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_DIV_in_p_MultiplicativeExpr5135: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_IDIV_in_p_MultiplicativeExpr5141: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_MOD_in_p_MultiplicativeExpr5149: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_UnionExpr_in_p_MultiplicativeExpr5153: new org.antlr.runtime.BitSet([0x00000002, 0x04000080,0x00000100, 0x00000000,0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_p_IntersectExceptExpr_in_p_UnionExpr5184: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000200,0x00000000, 0x00000000,0x00000000, 0x00000001]),
|
|
FOLLOW_UNION_in_p_UnionExpr5191: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_VBAR_in_p_UnionExpr5195: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_IntersectExceptExpr_in_p_UnionExpr5198: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000200,0x00000000, 0x00000000,0x00000000, 0x00000001]),
|
|
FOLLOW_p_InstanceofExpr_in_p_IntersectExceptExpr5229: new org.antlr.runtime.BitSet([0x00000002, 0x00020000,0x00000001, 0x00000000]),
|
|
FOLLOW_INTERSECT_in_p_IntersectExceptExpr5236: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_EXCEPT_in_p_IntersectExceptExpr5242: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_InstanceofExpr_in_p_IntersectExceptExpr5246: new org.antlr.runtime.BitSet([0x00000002, 0x00020000,0x00000001, 0x00000000]),
|
|
FOLLOW_p_TreatExpr_in_p_InstanceofExpr5277: new org.antlr.runtime.BitSet([0x00000002, 0x80000000]),
|
|
FOLLOW_INSTANCE_in_p_InstanceofExpr5283: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00008000, 0x00000000]),
|
|
FOLLOW_OF_in_p_InstanceofExpr5287: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000009, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_SequenceType_in_p_InstanceofExpr5289: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CastableExpr_in_p_TreatExpr5319: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000080]),
|
|
FOLLOW_TREAT_in_p_TreatExpr5325: new org.antlr.runtime.BitSet([0x00080000, 0x00000000]),
|
|
FOLLOW_AS_in_p_TreatExpr5329: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000009, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_SequenceType_in_p_TreatExpr5331: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CastExpr_in_p_CastableExpr5370: new org.antlr.runtime.BitSet([0x10000002, 0x00000000]),
|
|
FOLLOW_CASTABLE_in_p_CastableExpr5376: new org.antlr.runtime.BitSet([0x00080000, 0x00000000]),
|
|
FOLLOW_AS_in_p_CastableExpr5380: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_SingleType_in_p_CastableExpr5382: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_UnaryExpr_in_p_CastExpr5421: new org.antlr.runtime.BitSet([0x08000002, 0x00000000]),
|
|
FOLLOW_CAST_in_p_CastExpr5427: new org.antlr.runtime.BitSet([0x00080000, 0x00000000]),
|
|
FOLLOW_AS_in_p_CastExpr5431: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_SingleType_in_p_CastExpr5433: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PLUS_in_p_UnaryExpr5465: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_MINUS_in_p_UnaryExpr5469: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ValueExpr_in_p_UnaryExpr5473: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ValidateExpr_in_p_ValueExpr5529: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_PathExpr_in_p_ValueExpr5541: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ExtensionExpr_in_p_ValueExpr5553: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_p_GeneralComp0: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_EQ_in_p_ValueComp5632: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NE_in_p_ValueComp5638: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LT_in_p_ValueComp5644: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LE_in_p_ValueComp5650: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_GT_in_p_ValueComp5656: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_GE_in_p_ValueComp5662: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_IS_in_p_NodeComp5694: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SMALLER_SMALLER_in_p_NodeComp5698: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_GREATER_GREATER_in_p_NodeComp5702: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_VALIDATE_in_p_ValidateExpr5732: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000008, 0x00000004,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_ValidationMode_in_p_ValidateExpr5734: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_ValidateExpr5737: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_ValidateExpr5739: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_ValidateExpr5741: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LAX_in_p_ValidationMode5772: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_STRICT_in_p_ValidationMode5778: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_AS_in_p_ValidationMode5785: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ValidationMode5787: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_Pragma_in_p_ExtensionExpr5818: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00200000]),
|
|
FOLLOW_LBRACKET_in_p_ExtensionExpr5821: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C02B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_ExtensionExpr5823: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_ExtensionExpr5826: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SLASH_in_p_PathExpr5868: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_RelativePathExpr_in_p_PathExpr5870: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SLASH_in_p_PathExpr5883: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SLASH_SLASH_in_p_PathExpr5895: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_RelativePathExpr_in_p_PathExpr5897: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_RelativePathExpr_in_p_PathExpr5909: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_StepExpr_in_p_RelativePathExpr5937: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x01800000, 0x00000000]),
|
|
FOLLOW_set_in_p_RelativePathExpr5940: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_StepExpr_in_p_RelativePathExpr5948: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x01800000, 0x00000000]),
|
|
FOLLOW_p_AxisStep_in_p_StepExpr5976: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_FilterExpr_in_p_StepExpr5988: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ReverseStep_in_p_AxisStep6015: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000040, 0x00000000]),
|
|
FOLLOW_p_ForwardStep_in_p_AxisStep6019: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000040, 0x00000000]),
|
|
FOLLOW_p_PredicateList_in_p_AxisStep6022: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ForwardAxis_in_p_ForwardStep6049: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x04004001, 0x00004080,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NodeTest_in_p_ForwardStep6051: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AbbrevForwardStep_in_p_ForwardStep6056: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_CHILD_in_p_ForwardAxis6082: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6084: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DESCENDANT_in_p_ForwardAxis6096: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6098: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ATTRIBUTE_in_p_ForwardAxis6110: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6112: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SELF_in_p_ForwardAxis6124: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6126: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DESCENDANT_OR_SELF_in_p_ForwardAxis6138: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6140: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_FOLLOWING_SIBLING_in_p_ForwardAxis6152: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6154: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_FOLLOWING_in_p_ForwardAxis6166: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ForwardAxis6168: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ATTR_SIGN_in_p_AbbrevForwardStep6194: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x04004001, 0x00004080,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NodeTest_in_p_AbbrevForwardStep6197: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ReverseAxis_in_p_ReverseStep6224: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x04004001, 0x00004080,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NodeTest_in_p_ReverseStep6226: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AbbrevReverseStep_in_p_ReverseStep6231: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PARENT_in_p_ReverseAxis6257: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ReverseAxis6259: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ANCESTOR_in_p_ReverseAxis6271: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ReverseAxis6273: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PRECEDING_SIBLING_in_p_ReverseAxis6285: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ReverseAxis6287: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PRECEDING_in_p_ReverseAxis6299: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ReverseAxis6301: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ANCESTOR_OR_SELF_in_p_ReverseAxis6313: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x10000000, 0x00000000]),
|
|
FOLLOW_COLON_COLON_in_p_ReverseAxis6315: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOT_DOT_in_p_AbbrevReverseStep6341: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_KindTest_in_p_NodeTest6367: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_NameTest_in_p_NodeTest6371: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_NameTest6397: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_Wildcard_in_p_NameTest6401: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_STAR_in_p_Wildcard6427: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000]),
|
|
FOLLOW_COLON_in_p_Wildcard6430: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_Wildcard6432: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_NCName_in_p_Wildcard6439: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000]),
|
|
FOLLOW_COLON_in_p_Wildcard6441: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_STAR_in_p_Wildcard6443: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_PrimaryExpr_in_p_FilterExpr6479: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000040, 0x00000000]),
|
|
FOLLOW_p_PredicateList_in_p_FilterExpr6481: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_Predicate_in_p_PredicateList6509: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000040, 0x00000000]),
|
|
FOLLOW_LSQUARE_in_p_Predicate6538: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_Predicate6540: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000080, 0x00000000]),
|
|
FOLLOW_RSQUARE_in_p_Predicate6542: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_Literal_in_p_PrimaryExpr6570: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_VarRef_in_p_PrimaryExpr6582: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ParenthesizedExpr_in_p_PrimaryExpr6594: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ContextItemExpr_in_p_PrimaryExpr6606: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_FunctionCall_in_p_PrimaryExpr6618: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_OrderedExpr_in_p_PrimaryExpr6630: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_UnorderedExpr_in_p_PrimaryExpr6642: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_Constructor_in_p_PrimaryExpr6654: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_NumericLiteral_in_p_Literal6682: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_StringLiteral_in_p_Literal6686: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_p_NumericLiteral0: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_VarRef6758: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_VarRef6760: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_VarName6788: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_ParenthesizedExpr6816: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00F, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_ParenthesizedExpr6818: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_ParenthesizedExpr6821: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOT_in_p_ContextItemExpr6849: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ORDERED_in_p_OrderedExpr6879: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_OrderedExpr6882: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_OrderedExpr6884: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_OrderedExpr6886: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_UNORDERED_in_p_UnorderedExpr6916: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_UnorderedExpr6919: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_UnorderedExpr6921: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_UnorderedExpr6923: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_FQName_in_p_FunctionCall6952: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_FunctionCall6954: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00F, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_FunctionCall6957: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001004, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_FunctionCall6960: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_FunctionCall6962: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_FunctionCall6968: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_DirectConstructor_in_p_Constructor7000: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ComputedConstructor_in_p_Constructor7004: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_DirElemConstructor_in_p_DirectConstructor7032: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_DirCommentConstructor_in_p_DirectConstructor7044: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_DirPIConstructor_in_p_DirectConstructor7056: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SMALLER_in_p_DirElemConstructor7084: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_DirElemConstructor7100: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x20040000, 0x00080000]),
|
|
FOLLOW_p_DirAttributeList_in_p_DirElemConstructor7102: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x20040000, 0x00000000]),
|
|
FOLLOW_EMPTY_CLOSE_TAG_in_p_DirElemConstructor7118: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_GREATER_in_p_DirElemConstructor7123: new org.antlr.runtime.BitSet([0x00000FC0, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x40020010, 0x00C00000]),
|
|
FOLLOW_pm_DirElemContent_in_p_DirElemConstructor7125: new org.antlr.runtime.BitSet([0x00000FC0, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x40020010, 0x00C00000]),
|
|
FOLLOW_CLOSE_TAG_in_p_DirElemConstructor7128: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_DirElemConstructor7130: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00040000, 0x00080000]),
|
|
FOLLOW_S_in_p_DirElemConstructor7132: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00040000, 0x00000000]),
|
|
FOLLOW_GREATER_in_p_DirElemConstructor7135: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_S_in_p_DirAttributeList7212: new org.antlr.runtime.BitSet([0xFFFF0002, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00084000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_DirAttributeList7215: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00080000]),
|
|
FOLLOW_S_in_p_DirAttributeList7217: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000100, 0x00000000]),
|
|
FOLLOW_EQUAL_in_p_DirAttributeList7220: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00080C00]),
|
|
FOLLOW_S_in_p_DirAttributeList7222: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00080C00]),
|
|
FOLLOW_p_DirAttributeValue_in_p_DirAttributeList7225: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00080000]),
|
|
FOLLOW_QUOT_in_p_DirAttributeValue7256: new org.antlr.runtime.BitSet([0x00002F10, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000800]),
|
|
FOLLOW_ESCAPE_QUOT_in_p_DirAttributeValue7259: new org.antlr.runtime.BitSet([0x00002F10, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000800]),
|
|
FOLLOW_pm_QuotAttrValueContent_in_p_DirAttributeValue7263: new org.antlr.runtime.BitSet([0x00002F10, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000800]),
|
|
FOLLOW_QUOT_in_p_DirAttributeValue7267: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_APOS_in_p_DirAttributeValue7306: new org.antlr.runtime.BitSet([0x00001F20, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000400]),
|
|
FOLLOW_ESCAPE_APOS_in_p_DirAttributeValue7309: new org.antlr.runtime.BitSet([0x00001F20, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000400]),
|
|
FOLLOW_pm_AposAttrValueContent_in_p_DirAttributeValue7313: new org.antlr.runtime.BitSet([0x00001F20, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000400]),
|
|
FOLLOW_APOS_in_p_DirAttributeValue7317: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pg_QuotAttrContentChar_in_pm_QuotAttrValueContent7369: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pg_CommonContent_in_pm_QuotAttrValueContent7373: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ElemEnclosedExpr_in_pm_QuotAttrValueContent7377: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_QuotAttrContentChar_in_pg_QuotAttrContentChar7406: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pg_AposAttrContentChar_in_pm_AposAttrValueContent7459: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pg_CommonContent_in_pm_AposAttrValueContent7463: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ElemEnclosedExpr_in_pm_AposAttrValueContent7467: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_AposAttrContentChar_in_pg_AposAttrContentChar7496: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_DirectConstructor_in_pm_DirElemContent7547: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_CDataSection_in_pm_DirElemContent7559: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ElemEnclosedExpr_in_pm_DirElemContent7571: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pg_CommonContent_in_pm_DirElemContent7583: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pg_ElementContentChar_in_pm_DirElemContent7595: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_L_ElementContentChar_in_pg_ElementContentChar7624: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_CommonContent_in_pg_CommonContent7680: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_pm_CommonContent0: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_ElemEnclosedExpr7776: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_ElemEnclosedExpr7793: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_ElemEnclosedExpr7810: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompDocConstructor_in_p_ComputedConstructor7861: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompElemConstructor_in_p_ComputedConstructor7873: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompAttrConstructor_in_p_ComputedConstructor7885: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompNamespaceConstructor_in_p_ComputedConstructor7897: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompTextConstructor_in_p_ComputedConstructor7909: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompCommentConstructor_in_p_ComputedConstructor7921: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompPIConstructor_in_p_ComputedConstructor7933: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CompBinaryConstructor_in_p_ComputedConstructor7948: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOCUMENT_in_p_CompDocConstructor7982: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompDocConstructor7985: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompDocConstructor7987: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompDocConstructor7989: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ELEMENT_in_p_CompElemConstructor8030: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000011, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_CompElemConstructor8034: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompElemConstructor8039: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompElemConstructor8041: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompElemConstructor8043: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompElemConstructor8047: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C02B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompElemConstructor8049: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompElemConstructor8052: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ATTRIBUTE_in_p_CompAttrConstructor8085: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000011, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_CompAttrConstructor8089: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompAttrConstructor8094: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompAttrConstructor8096: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompAttrConstructor8098: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompAttrConstructor8102: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C02B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompAttrConstructor8104: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompAttrConstructor8107: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NAMESPACE_in_p_CompNamespaceConstructor8135: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000011, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_CompNamespaceConstructor8139: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompNamespaceConstructor8144: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompNamespaceConstructor8146: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompNamespaceConstructor8148: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompNamespaceConstructor8152: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C02B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompNamespaceConstructor8154: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompNamespaceConstructor8157: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_TEXT_in_p_CompTextConstructor8193: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompTextConstructor8196: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompTextConstructor8198: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompTextConstructor8200: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_BINARY_in_p_CompBinaryConstructor8230: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompBinaryConstructor8233: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompBinaryConstructor8235: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompBinaryConstructor8237: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COMMENT_in_p_CompCommentConstructor8267: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompCommentConstructor8270: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompCommentConstructor8272: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompCommentConstructor8274: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PROCESSING_INSTRUCTION_in_p_CompPIConstructor8305: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000011, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_CompPIConstructor8309: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompPIConstructor8314: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompPIConstructor8316: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompPIConstructor8318: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CompPIConstructor8322: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C02B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CompPIConstructor8324: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CompPIConstructor8327: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AtomicType_in_p_SingleType8355: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00002000, 0x00000000]),
|
|
FOLLOW_QUESTION_in_p_SingleType8357: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_AS_in_p_TypeDeclaration8388: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000009, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_SequenceType_in_p_TypeDeclaration8393: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_EMPTY_SEQUENCE_in_p_SequenceType8448: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_SequenceType8453: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_SequenceType8457: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ItemType_in_p_SequenceType8506: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x0000E000, 0x00000000]),
|
|
FOLLOW_p_OccurrenceIndicator_in_p_SequenceType8517: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_p_OccurrenceIndicator0: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_KindTest_in_p_ItemType8619: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_BINARY_in_p_ItemType8659: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_ItemType8661: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_ItemType8663: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ITEM_in_p_ItemType8705: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_ItemType8707: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_ItemType8709: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AtomicType_in_p_ItemType8750: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_AtomicType8776: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_DocumentTest_in_p_KindTest8826: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ElementTest_in_p_KindTest8838: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AttributeTest_in_p_KindTest8850: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_SchemaElementTest_in_p_KindTest8862: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_SchemaAttributeTest_in_p_KindTest8874: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_NamespaceNodeTest_in_p_KindTest8886: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_PITest_in_p_KindTest8898: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_CommentTest_in_p_KindTest8910: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_TextTest_in_p_KindTest8922: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AnyKindTest_in_p_KindTest8934: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NODE_in_p_AnyKindTest8962: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_AnyKindTest8964: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_AnyKindTest8966: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOCUMENT_NODE_in_p_DocumentTest8994: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_DocumentTest8996: new org.antlr.runtime.BitSet([0x00000000, 0x00000400,0x40000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_p_ElementTest_in_p_DocumentTest8999: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_p_SchemaElementTest_in_p_DocumentTest9003: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_DocumentTest9007: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_TEXT_in_p_TextTest9027: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_TextTest9029: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_TextTest9031: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COMMENT_in_p_CommentTest9059: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_CommentTest9061: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_CommentTest9063: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NAMESPACE_NODE_in_p_NamespaceNodeTest9089: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_NamespaceNodeTest9091: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_NamespaceNodeTest9093: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_PROCESSING_INSTRUCTION_in_p_PITest9121: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_PITest9123: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000005, 0x00004C00,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_PITest9126: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_p_StringLiteral_in_p_PITest9130: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_PITest9134: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ATTRIBUTE_in_p_AttributeTest9162: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_AttributeTest9164: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00004005, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_AttribNameOrWildcard_in_p_AttributeTest9167: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001004, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_AttributeTest9170: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_TypeName_in_p_AttributeTest9172: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_AttributeTest9178: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_AttribNameOrWildcard9208: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_STAR_in_p_AttribNameOrWildcard9212: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SCHEMA_ATTRIBUTE_in_p_SchemaAttributeTest9240: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_SchemaAttributeTest9242: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_AttributeDeclaration_in_p_SchemaAttributeTest9244: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_SchemaAttributeTest9246: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_AttributeName_in_p_AttributeDeclaration9272: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ELEMENT_in_p_ElementTest9300: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_ElementTest9302: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00004005, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_ElementNameOrWildcard_in_p_ElementTest9305: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001004, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_ElementTest9308: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_TypeName_in_p_ElementTest9310: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00002004, 0x00000000]),
|
|
FOLLOW_QUESTION_in_p_ElementTest9312: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_ElementTest9319: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_ElementNameOrWildcard9347: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_STAR_in_p_ElementNameOrWildcard9351: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SCHEMA_ELEMENT_in_p_SchemaElementTest9371: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_SchemaElementTest9373: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_ElementDeclaration_in_p_SchemaElementTest9375: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_SchemaElementTest9377: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ElementName_in_p_ElementDeclaration9403: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_AttributeName9431: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_ElementName9459: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_TypeName9487: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_TryClause_in_p_TryCatchExpr9519: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00010000]),
|
|
FOLLOW_p_CatchClause_in_p_TryCatchExpr9521: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00010000]),
|
|
FOLLOW_TRY_in_p_TryClause9550: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_TryClause9552: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_TryClause9554: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_TryClause9556: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_CATCH_in_p_CatchClause9587: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x04004013, 0x00004080,0x00000000, 0x00800000]),
|
|
FOLLOW_p_CatchErrorList_in_p_CatchClause9589: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000012, 0x00000000]),
|
|
FOLLOW_p_CatchVars_in_p_CatchClause9591: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_CatchClause9594: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_Expr_in_p_CatchClause9596: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_CatchClause9598: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_NameTest_in_p_CatchErrorList9624: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000001]),
|
|
FOLLOW_VBAR_in_p_CatchErrorList9627: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x04004001, 0x00004080,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NameTest_in_p_CatchErrorList9629: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000001]),
|
|
FOLLOW_LPAREN_in_p_CatchVars9675: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_CatchVars9677: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_CatchVars9679: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001004, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_CatchVars9682: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_CatchVars9684: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_CatchVars9686: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001004, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_CatchVars9689: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_CatchVars9691: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_CatchVars9693: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_CatchVars9699: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_QUOT_in_p_StringLiteral9748: new org.antlr.runtime.BitSet([0xFFFFFFF0, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFF7FF, 0xFFFFFFFF,0xFFFFFFFF, 0x00FFFFFF]),
|
|
FOLLOW_p_QuotStringLiteralContent_in_p_StringLiteral9752: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000800]),
|
|
FOLLOW_QUOT_in_p_StringLiteral9754: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_APOS_in_p_StringLiteral9795: new org.antlr.runtime.BitSet([0xFFFFFFF0, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFF7FF, 0xFFFFFFFF,0xFFFFFFFF, 0x00FFFFFF]),
|
|
FOLLOW_p_AposStringLiteralContent_in_p_StringLiteral9799: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000400]),
|
|
FOLLOW_APOS_in_p_StringLiteral9801: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_p_QuotStringLiteralContent9857: new org.antlr.runtime.BitSet([0xFFFFFFF2, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFF7FF, 0xFFFFF7FF,0xFFFFFFFF, 0x00FFFFFF]),
|
|
FOLLOW_set_in_p_AposStringLiteralContent9909: new org.antlr.runtime.BitSet([0xFFFFFFF2, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0xFFFFF7FF, 0xFFFFFBFF,0xFFFFFFFF, 0x00FFFFFF]),
|
|
FOLLOW_p_NCName_in_p_QName9994: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000]),
|
|
FOLLOW_p_LocalNCName_in_p_QName9996: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COLON_in_p_LocalNCName10051: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_LocalNCName10053: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_FNCName_in_p_FQName10083: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000]),
|
|
FOLLOW_p_LocalFNCName_in_p_FQName10085: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COLON_in_p_LocalFNCName10113: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_NCName_in_p_LocalFNCName10115: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_p_NCName0: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_set_in_p_FNCName0: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_pm_RevalidationDecl11839: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00800000, 0x00000000]),
|
|
FOLLOW_REVALIDATION_in_pm_RevalidationDecl11843: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000008, 0x00000004,0x01000000, 0x00000000]),
|
|
FOLLOW_STRICT_in_pm_RevalidationDecl11848: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LAX_in_pm_RevalidationDecl11854: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SKIP_in_pm_RevalidationDecl11860: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_AS_in_p_InsertExprTargetChoice11892: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00048000, 0x00000000]),
|
|
FOLLOW_FIRST_in_p_InsertExprTargetChoice11897: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00020000, 0x00000000]),
|
|
FOLLOW_LAST_in_p_InsertExprTargetChoice11903: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00020000, 0x00000000]),
|
|
FOLLOW_INTO_in_p_InsertExprTargetChoice11910: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_AFTER_in_p_InsertExprTargetChoice11926: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_BEFORE_in_p_InsertExprTargetChoice11940: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_INSERT_in_p_InsertExpr11968: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000,0x00100000, 0x00000000]),
|
|
FOLLOW_NODE_in_p_InsertExpr11973: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_NODES_in_p_InsertExpr11979: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_SourceExpr_in_p_InsertExpr11982: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000000, 0x00000000,0x00021800, 0x00000000]),
|
|
FOLLOW_p_InsertExprTargetChoice_in_p_InsertExpr11984: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_TargetExpr_in_p_InsertExpr11986: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DELETE_in_p_DeleteExpr12015: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000,0x00100000, 0x00000000]),
|
|
FOLLOW_NODE_in_p_DeleteExpr12020: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_NODES_in_p_DeleteExpr12026: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_TargetExpr_in_p_DeleteExpr12029: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_REPLACE_in_p_ReplaceExpr12058: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000,0x04000000, 0x00000000]),
|
|
FOLLOW_VALUE_in_p_ReplaceExpr12063: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00008000, 0x00000000]),
|
|
FOLLOW_OF_in_p_ReplaceExpr12067: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_NODE_in_p_ReplaceExpr12073: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ReplaceExpr12075: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000]),
|
|
FOLLOW_WITH_in_p_ReplaceExpr12079: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ReplaceExpr12081: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_RENAME_in_p_RenameExpr12110: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_NODE_in_p_RenameExpr12114: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_TargetExpr_in_p_RenameExpr12116: new org.antlr.runtime.BitSet([0x00080000, 0x00000000]),
|
|
FOLLOW_AS_in_p_RenameExpr12118: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_NewNameExpr_in_p_RenameExpr12120: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ExprSingle_in_p_SourceExpr12147: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ExprSingle_in_p_TargetExpr12173: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ExprSingle_in_p_NewNameExpr12199: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COPY_in_p_TransformExpr12227: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_TransformExpr12229: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_TransformExpr12231: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_p_TransformExpr12233: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_TransformExpr12235: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00080000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_TransformExpr12238: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_TransformExpr12240: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_TransformExpr12242: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_p_TransformExpr12244: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_TransformExpr12246: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00080000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_MODIFY_in_p_TransformExpr12252: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_TransformExpr12254: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x04000000, 0x00000000]),
|
|
FOLLOW_RETURN_in_p_TransformExpr12258: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_TransformExpr12260: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ConcatExpr_in_pm_ApplyExpr12294: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_ApplyExpr12296: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ExprSingle_in_p_ConcatExpr12322: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_ConcatExpr12325: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ConcatExpr12327: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_BLOCK_in_p_BlockExpr12357: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_Block_in_p_BlockExpr12359: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_Block12385: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_pm_BlockDecls_in_p_Block12389: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_BlockBody_in_p_Block12393: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_Block12395: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_BlockVarDecl_in_pm_BlockDecls12451: new org.antlr.runtime.BitSet([0x00000002, 0x00000004]),
|
|
FOLLOW_DECLARE_in_pm_BlockVarDecl12506: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_pm_BlockVarDecl12508: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_pm_BlockVarDecl12512: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001200, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_pm_BlockVarDecl12516: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001200, 0x00000000]),
|
|
FOLLOW_BIND_in_pm_BlockVarDecl12520: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_pm_BlockVarDecl12524: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_pm_BlockVarDecl12529: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_pm_BlockVarDecl12531: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_pm_BlockVarDecl12533: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001200, 0x00000000]),
|
|
FOLLOW_p_TypeDeclaration_in_pm_BlockVarDecl12535: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001200, 0x00000000]),
|
|
FOLLOW_BIND_in_pm_BlockVarDecl12539: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_pm_BlockVarDecl12541: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_pm_BlockVarDecl12547: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_pm_Expr_in_p_BlockBody12607: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SET_in_p_AssignmentExpr12635: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_AssignmentExpr12637: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_AssignmentExpr12639: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000200, 0x00000000]),
|
|
FOLLOW_BIND_in_p_AssignmentExpr12641: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_AssignmentExpr12643: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_EXIT_in_p_ExitExpr12671: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_RETURNING_in_p_ExitExpr12675: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ExitExpr12677: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_WHILE_in_p_WhileExpr12705: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000002, 0x00000000]),
|
|
FOLLOW_LPAREN_in_p_WhileExpr12707: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_WhileExpr12709: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000004, 0x00000000]),
|
|
FOLLOW_RPAREN_in_p_WhileExpr12711: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_p_WhileBody_in_p_WhileExpr12713: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_Block_in_p_WhileBody12739: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_UsingClause_in_p_EvalExpr12769: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000010]),
|
|
FOLLOW_EVAL_in_p_EvalExpr12774: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000010, 0x00000000]),
|
|
FOLLOW_LBRACKET_in_p_EvalExpr12776: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_EvalExpr12778: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000020, 0x00000000]),
|
|
FOLLOW_RBRACKET_in_p_EvalExpr12780: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_USING_in_p_UsingClause12807: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_UsingClause12809: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_UsingClause12811: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_UsingClause12814: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_UsingClause12816: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_VarName_in_p_UsingClause12818: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00001000, 0x00000000]),
|
|
FOLLOW_DECLARE_in_p_CollectionDecl12853: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200A40]),
|
|
FOLLOW_p_CollProperties_in_p_CollectionDecl12855: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000200]),
|
|
FOLLOW_COLLECTION_in_p_CollectionDecl12859: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_CollectionDecl12861: new org.antlr.runtime.BitSet([0x00080000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_p_CollectionTypeDecl_in_p_CollectionDecl12863: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x08000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_WITH_in_p_CollectionDecl12869: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x04200000]),
|
|
FOLLOW_p_NodeModifier_in_p_CollectionDecl12871: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00100000, 0x00000000]),
|
|
FOLLOW_NODES_in_p_CollectionDecl12875: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_p_CollectionDecl12879: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_CONST_in_p_CollProperties12909: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200840]),
|
|
FOLLOW_MUTABLE_in_p_CollProperties12915: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200840]),
|
|
FOLLOW_APPEND_ONLY_in_p_CollProperties12929: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200840]),
|
|
FOLLOW_QUEUE_in_p_CollProperties12935: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200840]),
|
|
FOLLOW_ORDERED_in_p_CollProperties12949: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200840]),
|
|
FOLLOW_UNORDERED_in_p_CollProperties12955: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00080000, 0x00000400,0x00000000, 0x01200840]),
|
|
FOLLOW_AS_in_p_CollectionTypeDecl12987: new org.antlr.runtime.BitSet([0x80400000, 0x00000600,0x62004000, 0x08000010]),
|
|
FOLLOW_p_KindTest_in_p_CollectionTypeDecl12989: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x0000E000, 0x00000000]),
|
|
FOLLOW_p_OccurrenceIndicator_in_p_CollectionTypeDecl12998: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_READ_ONLY_in_p_NodeModifier13029: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_MUTABLE_in_p_NodeModifier13035: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_p_IndexDecl13064: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08510080]),
|
|
FOLLOW_p_IndexProperties_in_p_IndexDecl13066: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00010000]),
|
|
FOLLOW_INDEX_in_p_IndexDecl13070: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_IndexName_in_p_IndexDecl13072: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00800000]),
|
|
FOLLOW_ON_in_p_IndexDecl13076: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00100000, 0x00000000]),
|
|
FOLLOW_NODES_in_p_IndexDecl13080: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_IndexDomainExpr_in_p_IndexDecl13082: new org.antlr.runtime.BitSet([0x02000000, 0x00000000]),
|
|
FOLLOW_BY_in_p_IndexDecl13086: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_IndexKeySpec_in_p_IndexDecl13088: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_COMMA_in_p_IndexDecl13091: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_IndexKeySpec_in_p_IndexDecl13093: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80001000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_p_IndexDecl13097: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_QName_in_p_IndexName13123: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_UNIQUE_in_p_IndexProperties13152: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08500080]),
|
|
FOLLOW_NON_in_p_IndexProperties13158: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x08000000]),
|
|
FOLLOW_UNIQUE_in_p_IndexProperties13162: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08500080]),
|
|
FOLLOW_VALUE_in_p_IndexProperties13176: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x02000000]),
|
|
FOLLOW_RANGE_in_p_IndexProperties13180: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08500080]),
|
|
FOLLOW_VALUE_in_p_IndexProperties13186: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00001000]),
|
|
FOLLOW_EQUALITY_in_p_IndexProperties13190: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08500080]),
|
|
FOLLOW_AUTOMATICALLY_in_p_IndexProperties13204: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00080000]),
|
|
FOLLOW_MAINTAINED_in_p_IndexProperties13208: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08500080]),
|
|
FOLLOW_MANUALLY_in_p_IndexProperties13214: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00080000]),
|
|
FOLLOW_MAINTAINED_in_p_IndexProperties13218: new org.antlr.runtime.BitSet([0x00000002, 0x00000000,0x00000000, 0x00000000,0x04000000, 0x08500080]),
|
|
FOLLOW_p_PathExpr_in_p_IndexDomainExpr13247: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_IndexKeyExpr_in_p_IndexKeySpec13272: new org.antlr.runtime.BitSet([0x00080000, 0x00000000]),
|
|
FOLLOW_p_IndexKeyTypeDecl_in_p_IndexKeySpec13274: new org.antlr.runtime.BitSet([0x40000002, 0x00000000]),
|
|
FOLLOW_p_IndexKeyCollation_in_p_IndexKeySpec13276: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_PathExpr_in_p_IndexKeyExpr13302: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_AS_in_p_IndexKeyTypeDecl13329: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_AtomicType_in_p_IndexKeyTypeDecl13331: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COLLATION_in_p_IndexKeyCollation13358: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000C00]),
|
|
FOLLOW_p_StringLiteral_in_p_IndexKeyCollation13360: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DECLARE_in_p_ICDecl13387: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00020000]),
|
|
FOLLOW_INTEGRITY_in_p_ICDecl13391: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000400]),
|
|
FOLLOW_CONSTRAINT_in_p_ICDecl13395: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICDecl13398: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00804000]),
|
|
FOLLOW_p_ICCollection_in_p_ICDecl13401: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_p_ICForeignKey_in_p_ICDecl13405: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x80000000, 0x00000000]),
|
|
FOLLOW_SEMICOLON_in_p_ICDecl13408: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_ON_in_p_ICCollection13435: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000200]),
|
|
FOLLOW_COLLECTION_in_p_ICCollection13439: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICCollection13442: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000,0x00000000, 0x00002000,0x00000008, 0x00000000]),
|
|
FOLLOW_p_ICCollSequence_in_p_ICCollection13445: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ICCollSequenceUnique_in_p_ICCollection13449: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_ICCollNode_in_p_ICCollection13453: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_ICCollSequence13479: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICCollSequence13481: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000100]),
|
|
FOLLOW_CHECK_in_p_ICCollSequence13485: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ICCollSequence13487: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_NODE_in_p_ICCollSequenceUnique13514: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_ICCollSequenceUnique13518: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICCollSequenceUnique13520: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000100]),
|
|
FOLLOW_CHECK_in_p_ICCollSequenceUnique13524: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x08000000]),
|
|
FOLLOW_UNIQUE_in_p_ICCollSequenceUnique13528: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00040000]),
|
|
FOLLOW_KEY_in_p_ICCollSequenceUnique13532: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_PathExpr_in_p_ICCollSequenceUnique13534: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_FOREACH_in_p_ICCollNode13562: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_NODE_in_p_ICCollNode13566: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_ICCollNode13568: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICCollNode13570: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000100]),
|
|
FOLLOW_CHECK_in_p_ICCollNode13574: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0783C00B, 0x07E04C80,0x00000000, 0x00C00000]),
|
|
FOLLOW_p_ExprSingle_in_p_ICCollNode13576: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_FOREIGN_in_p_ICForeignKey13604: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00040000]),
|
|
FOLLOW_KEY_in_p_ICForeignKey13608: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00008000]),
|
|
FOLLOW_p_ICForeignKeySource_in_p_ICForeignKey13610: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000040]),
|
|
FOLLOW_p_ICForeignKeyTarget_in_p_ICForeignKey13612: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_FROM_in_p_ICForeignKeySource13640: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000200]),
|
|
FOLLOW_p_ICForeignKeyValues_in_p_ICForeignKeySource13642: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_TO_in_p_ICForeignKeyTarget13669: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000200]),
|
|
FOLLOW_p_ICForeignKeyValues_in_p_ICForeignKeyTarget13671: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_COLLECTION_in_p_ICForeignKeyValues13698: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICForeignKeyValues13700: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00004000, 0x00000000]),
|
|
FOLLOW_NODE_in_p_ICForeignKeyValues13704: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000008, 0x00000000]),
|
|
FOLLOW_DOLLAR_in_p_ICForeignKeyValues13706: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x00000001, 0x00004000,0x00000000, 0x00800000]),
|
|
FOLLOW_p_QName_in_p_ICForeignKeyValues13708: new org.antlr.runtime.BitSet([0x00000000, 0x00000000,0x00000000, 0x00000000,0x00000000, 0x00040000]),
|
|
FOLLOW_KEY_in_p_ICForeignKeyValues13712: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_PathExpr_in_p_ICForeignKeyValues13714: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_SLASH_in_synpred1_XQueryParser5860: new org.antlr.runtime.BitSet([0xFFFF0000, 0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF,0x7FFFFFFF, 0xFFEFFFFF,0x0782400B, 0x07C04C80,0x00000000, 0x00800000]),
|
|
FOLLOW_p_RelativePathExpr_in_synpred1_XQueryParser5862: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_OccurrenceIndicator_in_synpred2_XQueryParser8510: new org.antlr.runtime.BitSet([0x00000002, 0x00000000]),
|
|
FOLLOW_p_OccurrenceIndicator_in_synpred3_XQueryParser12993: new org.antlr.runtime.BitSet([0x00000002, 0x00000000])
|
|
});
|
|
|
|
})();
|
|
|
|
});
|