Debian Codegraph @

jackrabbit-spi-commons/src/main/javacc/xpath/XPath.jjt

raw
1 /*
2 * Generated using "maven jackrabbit:generage-xpath-parser-jjt" from the
3 * the following files with the following copyright and license notices:
4 *
5 * javacc.xsl, jjtree.xsl, and strip.xsl:
6 * --------------------------------------
7 * Copyright (c) 2002 World Wide Web Consortium,
8 * (Massachusetts Institute of Technology, Institut National de
9 * Recherche en Informatique et en Automatique, Keio University). All
10 * Rights Reserved. This program is distributed under the W3C's Software
11 * Intellectual Property License. This program is distributed in the
12 * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
13 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 * PURPOSE.
15 * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
16 *
17 * jjtree-jackrabbit.xsl:
18 * ----------------------
19 * Licensed to the Apache Software Foundation (ASF) under one or more
20 * contributor license agreements. See the NOTICE file distributed with
21 * this work for additional information regarding copyright ownership.
22 * The ASF licenses this file to You under the Apache License, Version 2.0
23 * (the "License"); you may not use this file except in compliance with
24 * the License. You may obtain a copy of the License at
25 *
26 * http://www.apache.org/licenses/LICENSE-2.0
27 *
28 * Unless required by applicable law or agreed to in writing, software
29 * distributed under the License is distributed on an "AS IS" BASIS,
30 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31 * See the License for the specific language governing permissions and
32 * limitations under the License.
33 *
34 * xpath-grammar.xml:
35 * ------------------
36 * Copyright (c) 2002 W3C(r) (http://www.w3.org/) (MIT (http://www.lcs.mit.edu/),
37 * INRIA (http://www.inria.fr/), Keio (http://www.keio.ac.jp/)),
38 * All Rights Reserved.
39 * See http://www.w3.org/Consortium/Legal/ipr-notice-20000612#Copyright.
40 * W3C liability
41 * (http://www.w3.org/Consortium/Legal/ipr-notice-20000612#Legal_Disclaimer),
42 * trademark
43 * (http://www.w3.org/Consortium/Legal/ipr-notice-20000612#W3C_Trademarks),
44 * document use
45 * (http://www.w3.org/Consortium/Legal/copyright-documents-19990405),
46 * and software licensing rules
47 * (http://www.w3.org/Consortium/Legal/copyright-software-19980720)
48 * apply.
49 */
50 options {
51
52
53 STATIC = false;
54 MULTI=false;
55 VISITOR=true ; // invokes the JJTree Visitor support
56 NODE_SCOPE_HOOK=false;
57 NODE_USES_PARSER=true;
58
59 }
60
61
62 PARSER_BEGIN(XPath)
63
64
65 package org.apache.jackrabbit.spi.commons.query.xpath;
66
67 import java.io.*;
68 import java.util.Stack;
69 import java.util.Vector;
70
71 public class XPath {
72
73
74 boolean m_isMatchPattern = false;
75 boolean isStep = false;
76
77 Stack binaryTokenStack = new Stack();
78
79 public Node createNode(int id) {
80 return null;
81 }
82
83
84
85 public static void main(String args[])
86 throws Exception
87 {
88 int numberArgsLeft = args.length;
89 int argsStart = 0;
90 boolean isMatchParser = false;
91 if(numberArgsLeft > 0)
92 {
93 if(args[argsStart].equals("-match"))
94 {
95 isMatchParser = true;
96 System.out.println("Match Pattern Parser");
97 argsStart++;
98 numberArgsLeft--;
99 }
100 }
101 if(numberArgsLeft > 0)
102 {
103 try
104 {
105 final boolean dumpTree = true;
106 if(args[0].endsWith(".xquery"))
107 {
108 System.out.println("Running test for: "+args[0]);
109 File file = new File(args[0]);
110 FileInputStream fis = new FileInputStream(file);
111 XPath parser = new XPath(fis);
112 SimpleNode tree = parser.XPath2();
113 if(dumpTree)
114 tree.dump("|") ;
115 }
116 else
117 {
118 for(int i = argsStart; i < args.length; i++)
119 {
120 System.out.println();
121 System.out.println("Test["+i+"]: "+args[i]);
122 XPath parser = new XPath(new java.io.StringBufferInputStream(args[i]));
123 SimpleNode tree;
124 if(isMatchParser)
125 {
126 tree = parser.XPath2();
127 }
128 else
129 {
130 tree = parser.XPath2();
131 }
132 ((SimpleNode)tree.jjtGetChild(0)).dump("|") ;
133 }
134 System.out.println("Success!!!!");
135 }
136 }
137 catch(ParseException pe)
138 {
139 System.err.println(pe.getMessage());
140 }
141 return;
142 }
143 java.io.DataInputStream dinput = new java.io.DataInputStream(System.in);
144 while(true)
145 {
146 try
147 {
148 System.err.println("Type Expression: ");
149 String input = dinput.readLine();
150 if(null == input || input.trim().length() == 0)
151 break;
152 XPath parser = new XPath(new java.io.StringBufferInputStream(input));
153 SimpleNode tree;
154 if(isMatchParser)
155 {
156 tree = parser.XPath2();
157 }
158 else
159 {
160 tree = parser.XPath2();
161 }
162 ((SimpleNode)tree.jjtGetChild(0)).dump("|") ;
163 }
164 catch(ParseException pe)
165 {
166 System.err.println(pe.getMessage());
167 }
168 catch(Exception e)
169 {
170 System.err.println(e.getMessage());
171 }
172 }
173 }
174 }
175
176 PARSER_END(XPath)
177
178
179
180 TOKEN_MGR_DECLS : {
181 private Stack stateStack = new Stack();
182 // private Vector persistentLexStates = new Vector();
183 static final int PARENMARKER = 2000;
184
185 /**
186 * Push the current state onto the state stack.
187 */
188 private void pushState()
189 {
190 // System.err.println("pushing: "+curLexState); printLinePos();
191 stateStack.addElement(new Integer(curLexState));
192 }
193
194 /**
195 * Push the given state onto the state stack.
196 * @param state Must be a valid state.
197 */
198 private void pushState(int state)
199 {
200 stateStack.push(new Integer(state));
201 }
202
203 /**
204 * Pop the state on the state stack, and switch to that state.
205 */
206 private void popState()
207 {
208 if (stateStack.size() == 0)
209 {
210 printLinePos();
211 }
212
213 int nextState = ((Integer) stateStack.pop()).intValue();
214 // System.err.println("pop "+nextState); printLinePos();
215 if(nextState == PARENMARKER)
216 printLinePos();
217 SwitchTo(nextState);
218 }
219
220 /**
221 * Push the given state onto the state stack.
222 * @param state Must be a valid state.
223 */
224 private boolean isState(int state)
225 {
226 for (int i = 0; i < stateStack.size(); i++) {
227 if(((Integer) stateStack.elementAt(i)).intValue() == state)
228 {
229 return true;
230 }
231 }
232 return false;
233 }
234
235 /**
236 * Push a parenthesis state. This pushes, in addition to the
237 * lexical state value, a special marker that lets
238 * resetParenStateOrSwitch(int state)
239 * know if it should pop and switch. Used for the comma operator.
240 */
241 private void pushParenState(int commaState, int rparState)
242 {
243 stateStack.push(new Integer(rparState));
244 stateStack.push(new Integer(commaState));
245 stateStack.push(new Integer(PARENMARKER));
246 SwitchTo(commaState);
247 }
248
249
250 /**
251 * Print the current line position.
252 */
253 public void printLinePos()
254 {
255 System.err.println("Line: " + input_stream.getEndLine());
256 }
257 }
258
259
260 SimpleNode XPath2() :
261 {}
262 {
263 QueryList()<EOF>
264 { return jjtThis ; }
265 }
266
267 <DEFAULT>
268 TOKEN :
269 {
270 < IntegerLiteral : <Digits> > : OPERATOR
271 }
272
273 <DEFAULT>
274 TOKEN :
275 {
276 < DecimalLiteral : (("." <Digits>) | (<Digits> "." (["0" - "9"])*)) > : OPERATOR
277 }
278
279 <DEFAULT>
280 TOKEN :
281 {
282 < DoubleLiteral : (("." <Digits>) | (<Digits> ("." (["0" - "9"])*)?)) ["e", "E"] (["+", "-"])? <Digits> > : OPERATOR
283 }
284
285 <DEFAULT, OPERATOR>
286 TOKEN :
287 {
288 < StringLiteral : (("\"" ((("\"" "\"") | ~["\""]))* "\"") | ("'" ((("'" "'") | ~["'"]))* "'")) > : OPERATOR
289 }
290
291 <KINDTESTFORPI>
292 TOKEN :
293 {
294 < StringLiteralForKindTest : (("\"" ((("\"" "\"") | ~["\""]))* "\"") | ("'" ((("'" "'") | ~["'"]))* "'")) > : KINDTESTFORPI
295 }
296
297 <DEFAULT>
298 TOKEN :
299 {
300 < XQueryVersion : "xquery" (<skip_>)* "version" > : XQUERYVERSION
301 }
302
303 <XQUERYVERSION>
304 TOKEN :
305 {
306 < StringLiteralForVersion : (("\"" ((("\"" "\"") | ~["\""]))* "\"") | ("'" ((("'" "'") | ~["'"]))* "'")) > : XQUERYVERSION
307 }
308
309 <XQUERYVERSION>
310 TOKEN :
311 {
312 < XQueryEncoding : "encoding" > : XQUERYVERSION
313 }
314
315 <DEFAULT, ITEMTYPE>
316 TOKEN :
317 {
318 < AtStringLiteral : "at" (<skip_>)* <URLLiteral> > : DEFAULT
319 }
320
321 <NAMESPACEDECL, NAMESPACEKEYWORD>
322 TOKEN :
323 {
324 < URLLiteral : (("\"" ((("\"" "\"") | ~["\""]))* "\"") | ("'" ((("'" "'") | ~["'"]))* "'")) > : DEFAULT
325 }
326
327 <DEFAULT>
328 TOKEN :
329 {
330 < ModuleNamespace : "module" (<skip_>)* "namespace" > : NAMESPACEDECL
331 }
332 <DEFAULT, OPERATOR, KINDTEST, NAMESPACEDECL, XMLSPACE_DECL, SINGLETYPE, ITEMTYPE, NAMESPACEKEYWORD, VARNAME, OCCURRENCEINDICATOR, CLOSEKINDTEST, XQUERYVERSION>
333 SKIP:
334 {
335 < <skip_>>
336 }
337
338 TOKEN :
339 {
340 < #skip_ : (((<WhitespaceChar>)+ )) >
341 }
342
343
344 <OCCURRENCEINDICATOR>
345 SKIP :
346 {
347 < NotOccurrenceIndicator : ~["*", "?", "+"] > { input_stream.backup(1); } : OPERATOR
348 }
349
350 <DEFAULT>
351 TOKEN :
352 {
353 < ProcessingInstructionStart : "<?" > { pushState(OPERATOR); } : PROCESSING_INSTRUCTION
354 }
355
356 <ELEMENT_CONTENT>
357 TOKEN :
358 {
359 < ProcessingInstructionStartForElementContent : "<?" > { pushState(); } : PROCESSING_INSTRUCTION
360 }
361
362 <PROCESSING_INSTRUCTION, PROCESSING_INSTRUCTION_CONTENT>
363 TOKEN :
364 {
365 < ProcessingInstructionEnd : "?>" > { popState(); }
366 }
367
368 <DEFAULT>
369 TOKEN :
370 {
371 < AxisChild : "child" (<skip_>)* "::" > : DEFAULT
372 }
373
374 <DEFAULT>
375 TOKEN :
376 {
377 < AxisDescendant : "descendant" (<skip_>)* "::" > : DEFAULT
378 }
379
380 <DEFAULT>
381 TOKEN :
382 {
383 < AxisParent : "parent" (<skip_>)* "::" > : DEFAULT
384 }
385
386 <DEFAULT>
387 TOKEN :
388 {
389 < AxisAttribute : "attribute" (<skip_>)* "::" > : DEFAULT
390 }
391
392 <DEFAULT>
393 TOKEN :
394 {
395 < AxisSelf : "self" (<skip_>)* "::" > : DEFAULT
396 }
397
398 <DEFAULT>
399 TOKEN :
400 {
401 < AxisDescendantOrSelf : "descendant-or-self" (<skip_>)* "::" > : DEFAULT
402 }
403
404 <DEFAULT>
405 TOKEN :
406 {
407 < AxisAncestor : "ancestor" (<skip_>)* "::" > : DEFAULT
408 }
409
410 <DEFAULT>
411 TOKEN :
412 {
413 < AxisFollowingSibling : "following-sibling" (<skip_>)* "::" > : DEFAULT
414 }
415
416 <DEFAULT>
417 TOKEN :
418 {
419 < AxisPrecedingSibling : "preceding-sibling" (<skip_>)* "::" > : DEFAULT
420 }
421
422 <DEFAULT>
423 TOKEN :
424 {
425 < AxisFollowing : "following" (<skip_>)* "::" > : DEFAULT
426 }
427
428 <DEFAULT>
429 TOKEN :
430 {
431 < AxisPreceding : "preceding" (<skip_>)* "::" > : DEFAULT
432 }
433
434 <DEFAULT>
435 TOKEN :
436 {
437 < AxisAncestorOrSelf : "ancestor-or-self" (<skip_>)* "::" > : DEFAULT
438 }
439
440 <DEFAULT>
441 TOKEN :
442 {
443 < DefineFunction : "declare" (<skip_>)+ "function" > : DEFAULT
444 }
445
446 <DEFAULT>
447 TOKEN :
448 {
449 < DeclareOrdering : "declare" (<skip_>)+ "ordering" > : OPERATOR
450 }
451
452 <OPERATOR>
453 TOKEN :
454 {
455 < Ordered : "ordered" > : DEFAULT
456 }
457
458 <OPERATOR>
459 TOKEN :
460 {
461 < Unordered : "unordered" > : DEFAULT
462 }
463
464 <DEFAULT>
465 TOKEN :
466 {
467 < DeclareDefaultOrderingEmpty : "declare" (<skip_>)+ "default" (<skip_>)+ "order" > : OPERATOR
468 }
469
470 <DEFAULT>
471 TOKEN :
472 {
473 < DeclareInheritNamespaces : "declare" (<skip_>)+ "inherit-namespaces" > : OPERATOR
474 }
475
476 <OPERATOR>
477 TOKEN :
478 {
479 < Yes : "yes" > : DEFAULT
480 }
481
482 <OPERATOR>
483 TOKEN :
484 {
485 < No : "no" > : DEFAULT
486 }
487
488 <OPERATOR, ITEMTYPE>
489 TOKEN :
490 {
491 < External : "external" > : DEFAULT
492 }
493
494 <OPERATOR, ITEMTYPE>
495 TOKEN :
496 {
497 < Or : "or" > : DEFAULT
498 }
499
500 <OPERATOR, ITEMTYPE>
501 TOKEN :
502 {
503 < And : "and" > : DEFAULT
504 }
505
506 <OPERATOR, ITEMTYPE>
507 TOKEN :
508 {
509 < Div : "div" > : DEFAULT
510 }
511
512 <OPERATOR, ITEMTYPE>
513 TOKEN :
514 {
515 < Idiv : "idiv" > : DEFAULT
516 }
517
518 <OPERATOR, ITEMTYPE>
519 TOKEN :
520 {
521 < Mod : "mod" > : DEFAULT
522 }
523
524 <OPERATOR>
525 TOKEN :
526 {
527 < Multiply : "*" > : DEFAULT
528 }
529
530 <OPERATOR, ITEMTYPE>
531 TOKEN :
532 {
533 < In : "in" > : DEFAULT
534 }
535
536 <PROCESSING_INSTRUCTION>
537 TOKEN :
538 {
539 < PITarget : <NCName> > : PROCESSING_INSTRUCTION
540 }
541
542 TOKEN :
543 {
544 < #Prefix : <NCName> >
545 }
546
547 TOKEN :
548 {
549 < #LocalPart : <NCName> >
550 }
551
552 <DEFAULT, OPERATOR, ITEMTYPE>
553 TOKEN :
554 {
555 < VariableIndicator : "$" > : VARNAME
556 }
557
558 <VARNAME>
559 TOKEN :
560 {
561 < VarName : <QName> > : OPERATOR
562 }
563
564 TOKEN :
565 {
566 < #ValidationMode : ("lax" | "strict") >
567 }
568
569 <OPERATOR>
570 TOKEN :
571 {
572 < SchemaModeForDeclareConstruction : ("preserve" | "strip") > : DEFAULT
573 }
574
575 <CLOSEKINDTEST>
576 TOKEN :
577 {
578 < Nillable : "?" > : CLOSEKINDTEST
579 }
580
581 <DEFAULT>
582 TOKEN :
583 {
584 < DeclareConstruction : "declare" (<skip_>)+ "construction" > : OPERATOR
585 }
586
587 <OPERATOR, ITEMTYPE>
588 TOKEN :
589 {
590 < Satisfies : "satisfies" > : DEFAULT
591 }
592
593 <OPERATOR, ITEMTYPE>
594 TOKEN :
595 {
596 < Return : "return" > : DEFAULT
597 }
598
599 <OPERATOR, ITEMTYPE>
600 TOKEN :
601 {
602 < Then : "then" > : DEFAULT
603 }
604
605 <OPERATOR, ITEMTYPE>
606 TOKEN :
607 {
608 < Else : "else" > : DEFAULT
609 }
610
611 <OPERATOR>
612 TOKEN :
613 {
614 < Default : "default" > : OPERATOR
615 }
616
617 <DEFAULT>
618 TOKEN :
619 {
620 < DeclareXMLSpace : "declare" (<skip_>)+ "xmlspace" > : XMLSPACE_DECL
621 }
622
623 <DEFAULT>
624 TOKEN :
625 {
626 < DeclareBaseURI : "declare" (<skip_>)+ "base-uri" > : NAMESPACEDECL
627 }
628
629 <XMLSPACE_DECL>
630 TOKEN :
631 {
632 < XMLSpacePreserve : "preserve" > : DEFAULT
633 }
634
635 <XMLSPACE_DECL>
636 TOKEN :
637 {
638 < XMLSpaceStrip : "strip" > : DEFAULT
639 }
640
641 <NAMESPACEKEYWORD>
642 TOKEN :
643 {
644 < Namespace : "namespace" > : NAMESPACEDECL
645 }
646
647 <DEFAULT>
648 TOKEN :
649 {
650 < DeclareNamespace : "declare" (<skip_>)+ "namespace" > : NAMESPACEDECL
651 }
652
653 <OPERATOR, ITEMTYPE>
654 TOKEN :
655 {
656 < To : "to" > : DEFAULT
657 }
658
659 <OPERATOR, ITEMTYPE>
660 TOKEN :
661 {
662 < Where : "where" > : DEFAULT
663 }
664
665 <OPERATOR>
666 TOKEN :
667 {
668 < Collation : "collation" > : OPERATOR
669 }
670
671 <OPERATOR, ITEMTYPE>
672 TOKEN :
673 {
674 < Intersect : "intersect" > : DEFAULT
675 }
676
677 <OPERATOR, ITEMTYPE>
678 TOKEN :
679 {
680 < Union : "union" > : DEFAULT
681 }
682
683 <OPERATOR, ITEMTYPE>
684 TOKEN :
685 {
686 < Except : "except" > : DEFAULT
687 }
688
689 <DEFAULT, OPERATOR, ITEMTYPE>
690 TOKEN :
691 {
692 < As : "as" > : ITEMTYPE
693 }
694
695 <OPERATOR, ITEMTYPE>
696 TOKEN :
697 {
698 < AtWord : "at" > : DEFAULT
699 }
700
701 <OPERATOR, ITEMTYPE>
702 TOKEN :
703 {
704 < Case : "case" > : ITEMTYPE
705 }
706
707 <OPERATOR, ITEMTYPE>
708 TOKEN :
709 {
710 < Instanceof : "instance" (<skip_>)+ "of" > : ITEMTYPE
711 }
712
713 <OPERATOR, ITEMTYPE>
714 TOKEN :
715 {
716 < Castable : "castable" (<skip_>)+ "as" > : SINGLETYPE
717 }
718
719 <ITEMTYPE>
720 TOKEN :
721 {
722 < Item : "item" (<skip_>)* "(" (<skip_>)* ")" > : OCCURRENCEINDICATOR
723 }
724
725 <DEFAULT>
726 TOKEN :
727 {
728 < ElementType : "element" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
729 }
730
731 <DEFAULT>
732 TOKEN :
733 {
734 < AttributeType : "attribute" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
735 }
736
737 <DEFAULT>
738 TOKEN :
739 {
740 < SchemaElementType : "schema-element" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
741 }
742
743 <DEFAULT>
744 TOKEN :
745 {
746 < SchemaAttributeType : "schema-attribute" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
747 }
748
749 <DEFAULT>
750 TOKEN :
751 {
752 < OrderedOpen : "ordered" (<skip_>)* "{" > { pushState(OPERATOR); } : DEFAULT
753 }
754
755 <DEFAULT>
756 TOKEN :
757 {
758 < UnorderedOpen : "unordered" (<skip_>)* "{" > { pushState(OPERATOR); } : DEFAULT
759 }
760
761 <DEFAULT>
762 TOKEN :
763 {
764 < ElementQNameLbrace : "element" (<skip_>)+ <QName> (<skip_>)* "{" > { pushState(OPERATOR); }
765 }
766
767 <DEFAULT>
768 TOKEN :
769 {
770 < AttributeQNameLbrace : "attribute" (<skip_>)+ <QName> (<skip_>)* "{" > { pushState(OPERATOR); }
771 }
772
773 <DEFAULT>
774 TOKEN :
775 {
776 < PINCNameLbrace : "processing-instruction" (<skip_>)+ <NCName> (<skip_>)* "{" > { pushState(OPERATOR); }
777 }
778
779 <DEFAULT>
780 TOKEN :
781 {
782 < PILbrace : "processing-instruction" (<skip_>)* "{" > { pushState(OPERATOR); }
783 }
784
785 <DEFAULT>
786 TOKEN :
787 {
788 < CommentLbrace : "comment" (<skip_>)* "{" > { pushState(OPERATOR); }
789 }
790
791 <DEFAULT>
792 TOKEN :
793 {
794 < ElementLbrace : "element" (<skip_>)* "{" > { pushState(OPERATOR); } : DEFAULT
795 }
796
797 <DEFAULT>
798 TOKEN :
799 {
800 < AttributeLbrace : "attribute" (<skip_>)* "{" > { pushState(OPERATOR); } : DEFAULT
801 }
802
803 <DEFAULT>
804 TOKEN :
805 {
806 < TextLbrace : "text" (<skip_>)* "{" > { pushState(OPERATOR); }
807 }
808
809 <DEFAULT>
810 TOKEN :
811 {
812 < DeclareCollation : "declare" (<skip_>)+ "default" (<skip_>)+ "collation" > : NAMESPACEDECL
813 }
814
815 <NAMESPACEKEYWORD>
816 TOKEN :
817 {
818 < DefaultElement : "default" (<skip_>)+ "element" > : NAMESPACEKEYWORD
819 }
820
821 <DEFAULT>
822 TOKEN :
823 {
824 < DeclareDefaultElement : "declare" (<skip_>)+ "default" (<skip_>)+ "element" > : NAMESPACEKEYWORD
825 }
826
827 <DEFAULT>
828 TOKEN :
829 {
830 < DeclareDefaultFunction : "declare" (<skip_>)+ "default" (<skip_>)+ "function" > : NAMESPACEKEYWORD
831 }
832
833 <ITEMTYPE>
834 TOKEN :
835 {
836 < EmptyTok : "empty" (<skip_>)* "(" (<skip_>)* ")" > : OPERATOR
837 }
838
839 <DEFAULT>
840 TOKEN :
841 {
842 < ImportSchemaToken : "import" (<skip_>)+ "schema" > : NAMESPACEKEYWORD
843 }
844
845 <DEFAULT>
846 TOKEN :
847 {
848 < ImportModuleToken : "import" (<skip_>)+ "module" > : NAMESPACEKEYWORD
849 }
850
851 TOKEN :
852 {
853 < #Nmstart : (<Letter> | "_") >
854 }
855
856 TOKEN :
857 {
858 < #Nmchar : (<Letter> | <CombiningChar> | <Extender> | <Digit> | "." | "-" | "_") >
859 }
860
861 <DEFAULT>
862 TOKEN :
863 {
864 < Star : "*" > : OPERATOR
865 }
866
867 <KINDTEST>
868 TOKEN :
869 {
870 < AnyName : "*" > : CLOSEKINDTEST
871 }
872
873 <DEFAULT>
874 TOKEN :
875 {
876 < NCNameColonStar : <NCName> ":" "*" > : OPERATOR
877 }
878
879 <DEFAULT>
880 TOKEN :
881 {
882 < StarColonNCName : "*" ":" <NCName> > : OPERATOR
883 }
884
885 <DEFAULT>
886 TOKEN :
887 {
888 < Root : "/" > : DEFAULT
889 }
890
891 <DEFAULT>
892 TOKEN :
893 {
894 < RootDescendants : "//" > : DEFAULT
895 }
896
897 <OPERATOR>
898 TOKEN :
899 {
900 < Slash : "/" > : DEFAULT
901 }
902
903 <OPERATOR>
904 TOKEN :
905 {
906 < SlashSlash : "//" > : DEFAULT
907 }
908
909 <OPERATOR, ITEMTYPE>
910 TOKEN :
911 {
912 < Equals : "=" > : DEFAULT
913 }
914
915 <NAMESPACEDECL>
916 TOKEN :
917 {
918 < AssignEquals : "=" > : NAMESPACEDECL
919 }
920
921 <OPERATOR, ITEMTYPE>
922 TOKEN :
923 {
924 < Is : "is" > : DEFAULT
925 }
926
927 <OPERATOR, ITEMTYPE>
928 TOKEN :
929 {
930 < NotEquals : "!=" > : DEFAULT
931 }
932
933 <OPERATOR, ITEMTYPE>
934 TOKEN :
935 {
936 < LtEquals : "<=" > : DEFAULT
937 }
938
939 <OPERATOR, ITEMTYPE>
940 TOKEN :
941 {
942 < LtLt : "<<" > : DEFAULT
943 }
944
945 <OPERATOR, ITEMTYPE>
946 TOKEN :
947 {
948 < GtEquals : ">=" > : DEFAULT
949 }
950
951 <OPERATOR, ITEMTYPE>
952 TOKEN :
953 {
954 < GtGt : ">>" > : DEFAULT
955 }
956
957 <OPERATOR, ITEMTYPE>
958 TOKEN :
959 {
960 < FortranEq : "eq" > : DEFAULT
961 }
962
963 <OPERATOR, ITEMTYPE>
964 TOKEN :
965 {
966 < FortranNe : "ne" > : DEFAULT
967 }
968
969 <OPERATOR, ITEMTYPE>
970 TOKEN :
971 {
972 < FortranGt : "gt" > : DEFAULT
973 }
974
975 <OPERATOR, ITEMTYPE>
976 TOKEN :
977 {
978 < FortranGe : "ge" > : DEFAULT
979 }
980
981 <OPERATOR, ITEMTYPE>
982 TOKEN :
983 {
984 < FortranLt : "lt" > : DEFAULT
985 }
986
987 <OPERATOR, ITEMTYPE>
988 TOKEN :
989 {
990 < FortranLe : "le" > : DEFAULT
991 }
992
993 <OPERATOR, ITEMTYPE>
994 TOKEN :
995 {
996 < ColonEquals : ":=" > : DEFAULT
997 }
998
999 <OPERATOR, ITEMTYPE>
1000 TOKEN :
1001 {
1002 < Lt : "<" > : DEFAULT
1003 }
1004
1005 <OPERATOR, ITEMTYPE>
1006 TOKEN :
1007 {
1008 < Gt : ">" > : DEFAULT
1009 }
1010
1011 <OPERATOR, ITEMTYPE>
1012 TOKEN :
1013 {
1014 < Minus : "-" > : DEFAULT
1015 }
1016
1017 <OPERATOR>
1018 TOKEN :
1019 {
1020 < Plus : "+" > : DEFAULT
1021 }
1022
1023 <DEFAULT>
1024 TOKEN :
1025 {
1026 < UnaryMinus : "-" > : DEFAULT
1027 }
1028
1029 <DEFAULT>
1030 TOKEN :
1031 {
1032 < UnaryPlus : "+" > : DEFAULT
1033 }
1034
1035 <OPERATOR, OCCURRENCEINDICATOR>
1036 TOKEN :
1037 {
1038 < OccurrenceZeroOrOne : "?" > : OPERATOR
1039 }
1040
1041 <OCCURRENCEINDICATOR>
1042 TOKEN :
1043 {
1044 < OccurrenceZeroOrMore : "*" > : OPERATOR
1045 }
1046
1047 <OCCURRENCEINDICATOR>
1048 TOKEN :
1049 {
1050 < OccurrenceOneOrMore : "+" > : OPERATOR
1051 }
1052
1053 <OPERATOR, ITEMTYPE>
1054 TOKEN :
1055 {
1056 < Vbar : "|" > : DEFAULT
1057 }
1058
1059 <DEFAULT, ITEMTYPE>
1060 TOKEN :
1061 {
1062 < Lpar : "(" > : DEFAULT
1063 }
1064
1065 <DEFAULT>
1066 TOKEN :
1067 {
1068 < At : "@" > : DEFAULT
1069 }
1070
1071 <OPERATOR, ITEMTYPE>
1072 TOKEN :
1073 {
1074 < Lbrack : "[" > : DEFAULT
1075 }
1076
1077 <OPERATOR>
1078 TOKEN :
1079 {
1080 < Rbrack : "]" > : OPERATOR
1081 }
1082
1083 <DEFAULT, OPERATOR>
1084 TOKEN :
1085 {
1086 < Rpar : ")" > : OPERATOR
1087 }
1088
1089 <KINDTEST, KINDTESTFORPI, CLOSEKINDTEST>
1090 TOKEN :
1091 {
1092 < RparForKindTest : ")" > { popState(); }
1093 }
1094
1095 <DEFAULT>
1096 TOKEN :
1097 {
1098 < Some : "some" (<skip_>)* <VariableIndicator> > : VARNAME
1099 }
1100
1101 <DEFAULT>
1102 TOKEN :
1103 {
1104 < Every : "every" (<skip_>)* <VariableIndicator> > : VARNAME
1105 }
1106
1107 <DEFAULT, OPERATOR>
1108 TOKEN :
1109 {
1110 < ForVariable : "for" (<skip_>)* <VariableIndicator> > : VARNAME
1111 }
1112
1113 <DEFAULT, OPERATOR>
1114 TOKEN :
1115 {
1116 < LetVariable : "let" (<skip_>)* <VariableIndicator> > : VARNAME
1117 }
1118
1119 <OPERATOR, ITEMTYPE>
1120 TOKEN :
1121 {
1122 < CastAs : "cast" (<skip_>)+ "as" > : SINGLETYPE
1123 }
1124
1125 <OPERATOR, ITEMTYPE>
1126 TOKEN :
1127 {
1128 < TreatAs : "treat" (<skip_>)+ "as" > : ITEMTYPE
1129 }
1130
1131 <DEFAULT>
1132 TOKEN :
1133 {
1134 < ValidateLbrace : "validate" (<skip_>)* "{" > { pushState(OPERATOR); } : DEFAULT
1135 }
1136
1137 <DEFAULT>
1138 TOKEN :
1139 {
1140 < ValidateSchemaMode : "validate" (<skip_>)+ <ValidationMode> > { pushState(OPERATOR); } : DEFAULT
1141 }
1142
1143 TOKEN :
1144 {
1145 < #Digits : (["0" - "9"])+ >
1146 }
1147
1148 <DEFAULT>
1149 TOKEN :
1150 {
1151 < DocumentLpar : "document-node" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
1152 }
1153
1154 <ITEMTYPE>
1155 TOKEN :
1156 {
1157 < DocumentLparForKindTest : "document-node" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1158 }
1159
1160 <DEFAULT>
1161 TOKEN :
1162 {
1163 < DocumentLbrace : "document" (<skip_>)* "{" > { pushState(OPERATOR); }
1164 }
1165
1166 <DEFAULT>
1167 TOKEN :
1168 {
1169 < NodeLpar : "node" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
1170 }
1171
1172 <DEFAULT>
1173 TOKEN :
1174 {
1175 < CommentLpar : "comment" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
1176 }
1177
1178 <DEFAULT>
1179 TOKEN :
1180 {
1181 < TextLpar : "text" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTEST
1182 }
1183
1184 <DEFAULT>
1185 TOKEN :
1186 {
1187 < ProcessingInstructionLpar : "processing-instruction" (<skip_>)* "(" > { pushState(OPERATOR); } : KINDTESTFORPI
1188 }
1189
1190 <ITEMTYPE>
1191 TOKEN :
1192 {
1193 < ElementTypeForKindTest : "element" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1194 }
1195
1196 <KINDTEST>
1197 TOKEN :
1198 {
1199 < ElementTypeForDocumentTest : "element" (<skip_>)* "(" > { pushState(KINDTEST); } : KINDTEST
1200 }
1201
1202 <ITEMTYPE>
1203 TOKEN :
1204 {
1205 < AttributeTypeForKindTest : "attribute" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1206 }
1207
1208 <ITEMTYPE>
1209 TOKEN :
1210 {
1211 < SchemaElementTypeForKindTest : "schema-element" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1212 }
1213
1214 <KINDTEST>
1215 TOKEN :
1216 {
1217 < SchemaElementTypeForDocumentTest : "schema-element" (<skip_>)* "(" > { pushState(KINDTEST); } : KINDTEST
1218 }
1219
1220 <ITEMTYPE>
1221 TOKEN :
1222 {
1223 < SchemaAttributeTypeForKindTest : "schema-attribute" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1224 }
1225
1226 <ITEMTYPE>
1227 TOKEN :
1228 {
1229 < ProcessingInstructionLparForKindTest : "processing-instruction" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTESTFORPI
1230 }
1231
1232 <ITEMTYPE>
1233 TOKEN :
1234 {
1235 < TextLparForKindTest : "text" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1236 }
1237
1238 <ITEMTYPE>
1239 TOKEN :
1240 {
1241 < CommentLparForKindTest : "comment" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1242 }
1243
1244 <ITEMTYPE>
1245 TOKEN :
1246 {
1247 < NodeLparForKindTest : "node" (<skip_>)* "(" > { pushState(OCCURRENCEINDICATOR); } : KINDTEST
1248 }
1249
1250 <DEFAULT>
1251 TOKEN :
1252 {
1253 < IfLpar : "if" (<skip_>)* "(" > : DEFAULT
1254 }
1255
1256 <DEFAULT>
1257 TOKEN :
1258 {
1259 < TypeswitchLpar : "typeswitch" (<skip_>)* "(" > : DEFAULT
1260 }
1261
1262 <DEFAULT, OPERATOR, ITEMTYPE>
1263 TOKEN :
1264 {
1265 < Comma : "," > : DEFAULT
1266 }
1267
1268 <CLOSEKINDTEST>
1269 TOKEN :
1270 {
1271 < CommaForKindTest : "," > : KINDTEST
1272 }
1273
1274 <DEFAULT, OPERATOR, XQUERYVERSION, ITEMTYPE>
1275 TOKEN :
1276 {
1277 < SemiColon : ";" > : DEFAULT
1278 }
1279
1280 <DEFAULT, OPERATOR>
1281 TOKEN :
1282 {
1283 < QuerySeparator : "%%%" > : DEFAULT
1284 }
1285
1286 <START_TAG>
1287 TOKEN :
1288 {
1289 < OpenQuot : "\"" > : QUOT_ATTRIBUTE_CONTENT
1290 }
1291
1292 <QUOT_ATTRIBUTE_CONTENT>
1293 TOKEN :
1294 {
1295 < CloseQuot : "\"" > : START_TAG
1296 }
1297
1298 <DEFAULT>
1299 TOKEN :
1300 {
1301 < Dot : "." > : OPERATOR
1302 }
1303
1304 <DEFAULT>
1305 TOKEN :
1306 {
1307 < DotDot : ".." > : OPERATOR
1308 }
1309
1310 <OPERATOR, ITEMTYPE>
1311 TOKEN :
1312 {
1313 < OrderBy : "order" (<skip_>)+ "by" > : DEFAULT
1314 }
1315
1316 <OPERATOR, ITEMTYPE>
1317 TOKEN :
1318 {
1319 < OrderByStable : "stable" (<skip_>)+ "order" (<skip_>)+ "by" > : DEFAULT
1320 }
1321
1322 <OPERATOR>
1323 TOKEN :
1324 {
1325 < Ascending : "ascending" > : OPERATOR
1326 }
1327
1328 <OPERATOR>
1329 TOKEN :
1330 {
1331 < Descending : "descending" > : OPERATOR
1332 }
1333
1334 <OPERATOR>
1335 TOKEN :
1336 {
1337 < EmptyGreatest : "empty" (<skip_>)+ "greatest" > : OPERATOR
1338 }
1339
1340 <OPERATOR>
1341 TOKEN :
1342 {
1343 < EmptyLeast : "empty" (<skip_>)+ "least" > : OPERATOR
1344 }
1345
1346 <DEFAULT>
1347 TOKEN :
1348 {
1349 < DefineVariable : "declare" (<skip_>)+ "variable" (<skip_>)* <VariableIndicator> > : VARNAME
1350 }
1351
1352 <ITEMTYPE>
1353 TOKEN :
1354 {
1355 < QNameForSequenceType : (<Prefix> ":")? <LocalPart> > : OCCURRENCEINDICATOR
1356 }
1357
1358 <SINGLETYPE, ITEMTYPE>
1359 TOKEN :
1360 {
1361 < QNameForAtomicType : (<Prefix> ":")? <LocalPart> > : OPERATOR
1362 }
1363
1364 <KINDTEST>
1365 TOKEN :
1366 {
1367 < QNameForItemType : (<Prefix> ":")? <LocalPart> > : CLOSEKINDTEST
1368 }
1369
1370 <EXT_NAME>
1371 SPECIAL_TOKEN :
1372 {
1373 < ExtensionQName : (<Prefix> ":")? <LocalPart> > : EXT_CONTENT
1374 }
1375
1376 <DEFAULT>
1377 TOKEN :
1378 {
1379 < QNameLpar : <QName> (<skip_>)* "(" > : DEFAULT
1380 }
1381
1382 <NAMESPACEDECL>
1383 TOKEN :
1384 {
1385 < NCNameForPrefix : <Nmstart> (<Nmchar>)* > : NAMESPACEDECL
1386 }
1387
1388 <KINDTESTFORPI>
1389 TOKEN :
1390 {
1391 < NCNameForPI : <Nmstart> (<Nmchar>)* > : KINDTESTFORPI
1392 }
1393
1394 <DEFAULT>
1395 TOKEN :
1396 {
1397 < CdataSectionStart : "<![CDATA[" > { pushState(OPERATOR); } : CDATA_SECTION
1398 }
1399
1400 <ELEMENT_CONTENT>
1401 TOKEN :
1402 {
1403 < CdataSectionStartForElementContent : "<![CDATA[" > { pushState(); } : CDATA_SECTION
1404 }
1405
1406 <CDATA_SECTION>
1407 TOKEN :
1408 {
1409 < CdataSectionEnd : ("]" "]" ">") > { popState(); }
1410 }
1411
1412 <ELEMENT_CONTENT, QUOT_ATTRIBUTE_CONTENT, APOS_ATTRIBUTE_CONTENT>
1413 TOKEN :
1414 {
1415 < PredefinedEntityRef : "&" ("lt" | "gt" | "amp" | "quot" | "apos") ";" >
1416 }
1417
1418 <ELEMENT_CONTENT, QUOT_ATTRIBUTE_CONTENT, APOS_ATTRIBUTE_CONTENT>
1419 TOKEN :
1420 {
1421 < CharRef : "&#" (<Digits> | ("x" <HexDigits>)) ";" >
1422 }
1423
1424 TOKEN :
1425 {
1426 < #HexDigits : (["0" - "9", "a" - "f", "A" - "F"])+ >
1427 }
1428
1429 <ELEMENT_CONTENT>
1430 TOKEN :
1431 {
1432 < StartTagOpen : "<" > { pushState(); } : START_TAG
1433 }
1434
1435 <DEFAULT>
1436 TOKEN :
1437 {
1438 < StartTagOpenRoot : "<" > { pushState(OPERATOR); } : START_TAG
1439 }
1440
1441 <START_TAG>
1442 TOKEN :
1443 {
1444 < StartTagClose : ">" > : ELEMENT_CONTENT
1445 }
1446
1447 <START_TAG>
1448 TOKEN :
1449 {
1450 < EmptyTagClose : "/>" > { popState(); }
1451 }
1452
1453 <ELEMENT_CONTENT>
1454 TOKEN :
1455 {
1456 < EndTagOpen : "</" > : END_TAG
1457 }
1458
1459 <END_TAG>
1460 TOKEN :
1461 {
1462 < EndTagClose : ">" > { popState(); }
1463 }
1464
1465 <START_TAG>
1466 TOKEN :
1467 {
1468 < ValueIndicator : "=" > : START_TAG
1469 }
1470
1471 <START_TAG, END_TAG>
1472 TOKEN :
1473 {
1474 < TagQName : <QName> >
1475 }
1476
1477 <ELEMENT_CONTENT, QUOT_ATTRIBUTE_CONTENT, APOS_ATTRIBUTE_CONTENT>
1478 TOKEN :
1479 {
1480 < Lbrace : "{" > { pushState(); } : DEFAULT
1481 }
1482
1483 <DEFAULT, OPERATOR, KINDTEST, CLOSEKINDTEST>
1484 TOKEN :
1485 {
1486 < LbraceExprEnclosure : "{" > { pushState(OPERATOR); } : DEFAULT
1487 }
1488
1489 <ELEMENT_CONTENT, QUOT_ATTRIBUTE_CONTENT, APOS_ATTRIBUTE_CONTENT>
1490 TOKEN :
1491 {
1492 < LCurlyBraceEscape : "{{" >
1493 }
1494
1495 <ELEMENT_CONTENT, QUOT_ATTRIBUTE_CONTENT, APOS_ATTRIBUTE_CONTENT>
1496 TOKEN :
1497 {
1498 < RCurlyBraceEscape : "}}" >
1499 }
1500
1501 <QUOT_ATTRIBUTE_CONTENT>
1502 TOKEN :
1503 {
1504 < EscapeQuot : "\"\"" > : QUOT_ATTRIBUTE_CONTENT
1505 }
1506
1507 <APOS_ATTRIBUTE_CONTENT>
1508 TOKEN :
1509 {
1510 < EscapeApos : "''" > : APOS_ATTRIBUTE_CONTENT
1511 }
1512
1513 <ELEMENT_CONTENT>
1514 TOKEN :
1515 {
1516 < ElementContentChar : <Char> > : ELEMENT_CONTENT
1517 }
1518
1519 <QUOT_ATTRIBUTE_CONTENT>
1520 TOKEN :
1521 {
1522 < QuotAttrContentChar : <Char> > : QUOT_ATTRIBUTE_CONTENT
1523 }
1524
1525 <APOS_ATTRIBUTE_CONTENT>
1526 TOKEN :
1527 {
1528 < AposAttrContentChar : <Char> > : APOS_ATTRIBUTE_CONTENT
1529 }
1530
1531 <XML_COMMENT>
1532 TOKEN :
1533 {
1534 < CommentContentChar : <Char> > : XML_COMMENT
1535 }
1536
1537 <XML_COMMENT>
1538 TOKEN :
1539 {
1540 < CommentContentCharDash : "-" <Char> > : XML_COMMENT
1541 }
1542
1543 <PROCESSING_INSTRUCTION_CONTENT>
1544 TOKEN :
1545 {
1546 < PIContentChar : ["\t", "\r", "\n", "\u0020" - "\uFFFD"] > : PROCESSING_INSTRUCTION_CONTENT
1547 }
1548
1549 <CDATA_SECTION>
1550 TOKEN :
1551 {
1552 < CDataSectionChar : ["\t", "\r", "\n", "\u0020" - "\uFFFD"] > : CDATA_SECTION
1553 }
1554
1555 <START_TAG>
1556 TOKEN :
1557 {
1558 < OpenApos : "'" > : APOS_ATTRIBUTE_CONTENT
1559 }
1560
1561 <APOS_ATTRIBUTE_CONTENT>
1562 TOKEN :
1563 {
1564 < CloseApos : "'" > : START_TAG
1565 }
1566
1567 SPECIAL_TOKEN :
1568 {
1569 < #Pragma : <ExtensionStart> (<SForExt>)? <PragmaKeyword> <SForExt> <ExtensionQName> (<SForExt> <ExtensionContents>)? <ExtensionEnd> >
1570 }
1571
1572 SPECIAL_TOKEN :
1573 {
1574 < #MUExtension : <ExtensionStart> (<SForExt>)? <Extension> <SForExt> <ExtensionQName> (<SForExt> <ExtensionContents>)? <ExtensionEnd> >
1575 }
1576
1577 SPECIAL_TOKEN :
1578 {
1579 < #ExtensionContents : (<ExtensionContentChar>)* >
1580 }
1581
1582 <DEFAULT, OPERATOR, NAMESPACEDECL, NAMESPACEKEYWORD, XMLSPACE_DECL, ITEMTYPE, VARNAME, EXPR_COMMENT>
1583 SPECIAL_TOKEN :
1584 {
1585 < ExtensionStart : "(::" > { pushState(); } : EXT_KEY
1586 }
1587
1588 <EXT_CONTENT>
1589 SPECIAL_TOKEN :
1590 {
1591 < ExtensionContentChar : <Char> >
1592 }
1593
1594 <EXT_CONTENT>
1595 SPECIAL_TOKEN :
1596 {
1597 < ExtensionEnd : "::)" > { popState(); }
1598 }
1599
1600 SKIP :
1601 {
1602 < #Comment : <CommentStart> ((<CommentContents>))* <CommentEnd> >
1603 }
1604
1605 SPECIAL_TOKEN :
1606 {
1607 < #CommentContents : (<CommentContent>)+ >
1608 }
1609
1610 <DEFAULT, OPERATOR, NAMESPACEDECL, NAMESPACEKEYWORD, XMLSPACE_DECL, SINGLETYPE, ITEMTYPE, KINDTEST, KINDTESTFORPI, CLOSEKINDTEST, OCCURRENCEINDICATOR, VARNAME, EXPR_COMMENT>
1611 SPECIAL_TOKEN :
1612 {
1613 < CommentStart : "(:" > { pushState(); } : EXPR_COMMENT
1614 }
1615
1616 <EXPR_COMMENT>
1617 SPECIAL_TOKEN :
1618 {
1619 < CommentContent : <Char> >
1620 }
1621
1622 <EXPR_COMMENT>
1623 SPECIAL_TOKEN :
1624 {
1625 < CommentEnd : ":)" > { popState(); }
1626 }
1627
1628 <EXT_KEY>
1629 SPECIAL_TOKEN :
1630 {
1631 < PragmaKeyword : "pragma" > : EXT_NAME
1632 }
1633
1634 <EXT_KEY>
1635 SPECIAL_TOKEN :
1636 {
1637 < Extension : "extension" > : EXT_NAME
1638 }
1639
1640 <DEFAULT>
1641 TOKEN :
1642 {
1643 < XmlCommentStart : "<!--" > { pushState(OPERATOR); } : XML_COMMENT
1644 }
1645
1646 <ELEMENT_CONTENT>
1647 TOKEN :
1648 {
1649 < XmlCommentStartForElementContent : "<!--" > { pushState(); } : XML_COMMENT
1650 }
1651
1652 <XML_COMMENT>
1653 TOKEN :
1654 {
1655 < XmlCommentEnd : "-->" > { popState(); }
1656 }
1657
1658 <DEFAULT>
1659 TOKEN :
1660 {
1661 < QName : (<Prefix> ":")? <LocalPart> > : OPERATOR
1662 }
1663
1664 TOKEN :
1665 {
1666 < #NCName : <Nmstart> (<Nmchar>)* >
1667 }
1668
1669 <START_TAG, END_TAG>
1670 TOKEN :
1671 {
1672 < S : (<WhitespaceChar>)+ >
1673 }
1674
1675 <PROCESSING_INSTRUCTION>
1676 TOKEN :
1677 {
1678 < SForPI : (<WhitespaceChar>)+ > : PROCESSING_INSTRUCTION_CONTENT
1679 }
1680
1681 <EXT_CONTENT, EXT_KEY, EXT_NAME>
1682 SPECIAL_TOKEN :
1683 {
1684 < SForExt : (<WhitespaceChar>)+ >
1685 }
1686
1687 TOKEN :
1688 {
1689 < #Char : ["\t", "\r", "\n", "\u0020" - "\uFFFD"] >
1690 }
1691
1692 <DEFAULT, OPERATOR>
1693 TOKEN :
1694 {
1695 < Rbrace : "}" > { popState(); }
1696 }
1697
1698 TOKEN :
1699 {
1700 < #WhitespaceChar : ["\t", "\r", "\n", " "] >
1701 }
1702
1703 TOKEN :
1704 {
1705 < #Letter : (<BaseChar> | <Ideographic>) >
1706 }
1707
1708 TOKEN :
1709 {
1710 < #BaseChar : ["\u0041" - "\u005a", "\u0061" - "\u007a", "\u00c0" - "\u00d6", "\u00d8" - "\u00f6", "\u00f8" - "\u00ff", "\u0100" - "\u0131", "\u0134" - "\u013e", "\u0141" - "\u0148", "\u014a" - "\u017e", "\u0180" - "\u01c3", "\u01cd" - "\u01f0", "\u01f4" - "\u01f5", "\u01fa" - "\u0217", "\u0250" - "\u02a8", "\u02bb" - "\u02c1", "\u0386", "\u0388" - "\u038a", "\u038c", "\u038e" - "\u03a1", "\u03a3" - "\u03ce", "\u03d0" - "\u03d6", "\u03da", "\u03dc", "\u03de", "\u03e0", "\u03e2" - "\u03f3", "\u0401" - "\u040c", "\u040e" - "\u044f", "\u0451" - "\u045c", "\u045e" - "\u0481", "\u0490" - "\u04c4", "\u04c7" - "\u04c8", "\u04cb" - "\u04cc", "\u04d0" - "\u04eb", "\u04ee" - "\u04f5", "\u04f8" - "\u04f9", "\u0531" - "\u0556", "\u0559", "\u0561" - "\u0586", "\u05d0" - "\u05ea", "\u05f0" - "\u05f2", "\u0621" - "\u063a", "\u0641" - "\u064a", "\u0671" - "\u06b7", "\u06ba" - "\u06be", "\u06c0" - "\u06ce", "\u06d0" - "\u06d3", "\u06d5", "\u06e5" - "\u06e6", "\u0905" - "\u0939", "\u093d", "\u0958" - "\u0961", "\u0985" - "\u098c", "\u098f" - "\u0990", "\u0993" - "\u09a8", "\u09aa" - "\u09b0", "\u09b2", "\u09b6" - "\u09b9", "\u09dc" - "\u09dd", "\u09df" - "\u09e1", "\u09f0" - "\u09f1", "\u0a05" - "\u0a0a", "\u0a0f" - "\u0a10", "\u0a13" - "\u0a28", "\u0a2a" - "\u0a30", "\u0a32" - "\u0a33", "\u0a35" - "\u0a36", "\u0a38" - "\u0a39", "\u0a59" - "\u0a5c", "\u0a5e", "\u0a72" - "\u0a74", "\u0a85" - "\u0a8b", "\u0a8d", "\u0a8f" - "\u0a91", "\u0a93" - "\u0aa8", "\u0aaa" - "\u0ab0", "\u0ab2" - "\u0ab3", "\u0ab5" - "\u0ab9", "\u0abd", "\u0ae0", "\u0b05" - "\u0b0c", "\u0b0f" - "\u0b10", "\u0b13" - "\u0b28", "\u0b2a" - "\u0b30", "\u0b32" - "\u0b33", "\u0b36" - "\u0b39", "\u0b3d", "\u0b5c" - "\u0b5d", "\u0b5f" - "\u0b61", "\u0b85" - "\u0b8a", "\u0b8e" - "\u0b90", "\u0b92" - "\u0b95", "\u0b99" - "\u0b9a", "\u0b9c", "\u0b9e" - "\u0b9f", "\u0ba3" - "\u0ba4", "\u0ba8" - "\u0baa", "\u0bae" - "\u0bb5", "\u0bb7" - "\u0bb9", "\u0c05" - "\u0c0c", "\u0c0e" - "\u0c10", "\u0c12" - "\u0c28", "\u0c2a" - "\u0c33", "\u0c35" - "\u0c39", "\u0c60" - "\u0c61", "\u0c85" - "\u0c8c", "\u0c8e" - "\u0c90", "\u0c92" - "\u0ca8", "\u0caa" - "\u0cb3", "\u0cb5" - "\u0cb9", "\u0cde", "\u0ce0" - "\u0ce1", "\u0d05" - "\u0d0c", "\u0d0e" - "\u0d10", "\u0d12" - "\u0d28", "\u0d2a" - "\u0d39", "\u0d60" - "\u0d61", "\u0e01" - "\u0e2e", "\u0e30", "\u0e32" - "\u0e33", "\u0e40" - "\u0e45", "\u0e81" - "\u0e82", "\u0e84", "\u0e87" - "\u0e88", "\u0e8a", "\u0e8d", "\u0e94" - "\u0e97", "\u0e99" - "\u0e9f", "\u0ea1" - "\u0ea3", "\u0ea5", "\u0ea7", "\u0eaa" - "\u0eab", "\u0ead" - "\u0eae", "\u0eb0", "\u0eb2" - "\u0eb3", "\u0ebd", "\u0ec0" - "\u0ec4", "\u0f40" - "\u0f47", "\u0f49" - "\u0f69", "\u10a0" - "\u10c5", "\u10d0" - "\u10f6", "\u1100", "\u1102" - "\u1103", "\u1105" - "\u1107", "\u1109", "\u110b" - "\u110c", "\u110e" - "\u1112", "\u113c", "\u113e", "\u1140", "\u114c", "\u114e", "\u1150", "\u1154" - "\u1155", "\u1159", "\u115f" - "\u1161", "\u1163", "\u1165", "\u1167", "\u1169", "\u116d" - "\u116e", "\u1172" - "\u1173", "\u1175", "\u119e", "\u11a8", "\u11ab", "\u11ae" - "\u11af", "\u11b7" - "\u11b8", "\u11ba", "\u11bc" - "\u11c2", "\u11eb", "\u11f0", "\u11f9", "\u1e00" - "\u1e9b", "\u1ea0" - "\u1ef9", "\u1f00" - "\u1f15", "\u1f18" - "\u1f1d", "\u1f20" - "\u1f45", "\u1f48" - "\u1f4d", "\u1f50" - "\u1f57", "\u1f59", "\u1f5b", "\u1f5d", "\u1f5f" - "\u1f7d", "\u1f80" - "\u1fb4", "\u1fb6" - "\u1fbc", "\u1fbe", "\u1fc2" - "\u1fc4", "\u1fc6" - "\u1fcc", "\u1fd0" - "\u1fd3", "\u1fd6" - "\u1fdb", "\u1fe0" - "\u1fec", "\u1ff2" - "\u1ff4", "\u1ff6" - "\u1ffc", "\u2126", "\u212a" - "\u212b", "\u212e", "\u2180" - "\u2182", "\u3041" - "\u3094", "\u30a1" - "\u30fa", "\u3105" - "\u312c", "\uac00" - "\ud7a3"] >
1711 }
1712
1713 TOKEN :
1714 {
1715 < #Ideographic : ["\u4e00" - "\u9fa5", "\u3007", "\u3021" - "\u3029"] >
1716 }
1717
1718 TOKEN :
1719 {
1720 < #CombiningChar : ["\u0300" - "\u0345", "\u0360" - "\u0361", "\u0483" - "\u0486", "\u0591" - "\u05a1", "\u05a3" - "\u05b9", "\u05bb" - "\u05bd", "\u05bf", "\u05c1" - "\u05c2", "\u05c4", "\u064b" - "\u0652", "\u0670", "\u06d6" - "\u06dc", "\u06dd" - "\u06df", "\u06e0" - "\u06e4", "\u06e7" - "\u06e8", "\u06ea" - "\u06ed", "\u0901" - "\u0903", "\u093c", "\u093e" - "\u094c", "\u094d", "\u0951" - "\u0954", "\u0962" - "\u0963", "\u0981" - "\u0983", "\u09bc", "\u09be", "\u09bf", "\u09c0" - "\u09c4", "\u09c7" - "\u09c8", "\u09cb" - "\u09cd", "\u09d7", "\u09e2" - "\u09e3", "\u0a02", "\u0a3c", "\u0a3e", "\u0a3f", "\u0a40" - "\u0a42", "\u0a47" - "\u0a48", "\u0a4b" - "\u0a4d", "\u0a70" - "\u0a71", "\u0a81" - "\u0a83", "\u0abc", "\u0abe" - "\u0ac5", "\u0ac7" - "\u0ac9", "\u0acb" - "\u0acd", "\u0b01" - "\u0b03", "\u0b3c", "\u0b3e" - "\u0b43", "\u0b47" - "\u0b48", "\u0b4b" - "\u0b4d", "\u0b56" - "\u0b57", "\u0b82" - "\u0b83", "\u0bbe" - "\u0bc2", "\u0bc6" - "\u0bc8", "\u0bca" - "\u0bcd", "\u0bd7", "\u0c01" - "\u0c03", "\u0c3e" - "\u0c44", "\u0c46" - "\u0c48", "\u0c4a" - "\u0c4d", "\u0c55" - "\u0c56", "\u0c82" - "\u0c83", "\u0cbe" - "\u0cc4", "\u0cc6" - "\u0cc8", "\u0cca" - "\u0ccd", "\u0cd5" - "\u0cd6", "\u0d02" - "\u0d03", "\u0d3e" - "\u0d43", "\u0d46" - "\u0d48", "\u0d4a" - "\u0d4d", "\u0d57", "\u0e31", "\u0e34" - "\u0e3a", "\u0e47" - "\u0e4e", "\u0eb1", "\u0eb4" - "\u0eb9", "\u0ebb" - "\u0ebc", "\u0ec8" - "\u0ecd", "\u0f18" - "\u0f19", "\u0f35", "\u0f37", "\u0f39", "\u0f3e", "\u0f3f", "\u0f71" - "\u0f84", "\u0f86" - "\u0f8b", "\u0f90" - "\u0f95", "\u0f97", "\u0f99" - "\u0fad", "\u0fb1" - "\u0fb7", "\u0fb9", "\u20d0" - "\u20dc", "\u20e1", "\u302a" - "\u302f", "\u3099", "\u309a"] >
1721 }
1722
1723 TOKEN :
1724 {
1725 < #Digit : ["\u0030" - "\u0039", "\u0660" - "\u0669", "\u06f0" - "\u06f9", "\u0966" - "\u096f", "\u09e6" - "\u09ef", "\u0a66" - "\u0a6f", "\u0ae6" - "\u0aef", "\u0b66" - "\u0b6f", "\u0be7" - "\u0bef", "\u0c66" - "\u0c6f", "\u0ce6" - "\u0cef", "\u0d66" - "\u0d6f", "\u0e50" - "\u0e59", "\u0ed0" - "\u0ed9", "\u0f20" - "\u0f29"] >
1726 }
1727
1728 TOKEN :
1729 {
1730 < #Extender : ["\u00b7", "\u02d0", "\u02d1", "\u0387", "\u0640", "\u0e46", "\u0ec6", "\u3005", "\u3031" - "\u3035", "\u309d" - "\u309e", "\u30fc" - "\u30fe"] >
1731 }
1732
1733 <OPERATOR>
1734 SKIP :
1735 {
1736 < NotOperatorKeyword : (["0" - "9", "a" - "z", "A" - "Z"])+ >
1737 }
1738
1739 <DEFAULT>
1740 SKIP :
1741 {
1742 < NotNumber : (("." <Digits>) | (<Digits> ("." (["0" - "9"])*)?)) (["e", "E"] (["+", "-"])? <Digits>)? ["a" - "z", "A" - "Z"] (["0" - "9", "a" - "z", "A" - "Z"])* > : OPERATOR
1743 }
1744 void QueryList() :
1745 {}
1746 {
1747 Module() (<QuerySeparator> [Module()])*
1748 }
1749
1750 void Module() :
1751 {}
1752 {
1753 [VersionDecl()] (MainModule() | LibraryModule())
1754 }
1755
1756 void VersionDecl() :
1757 {}
1758 {
1759 <XQueryVersion>{jjtThis.processToken(token);} #XQueryVersion(true) <StringLiteralForVersion>{jjtThis.processToken(token);} #StringLiteralForVersion(true) [<XQueryEncoding>{jjtThis.processToken(token);} #XQueryEncoding(true) <StringLiteralForVersion>{jjtThis.processToken(token);} #StringLiteralForVersion(true)] Separator()
1760 }
1761
1762 void MainModule() :
1763 {}
1764 {
1765 Prolog() QueryBody()
1766 }
1767
1768 void LibraryModule() :
1769 {}
1770 {
1771 ModuleDecl() Prolog()
1772 }
1773
1774 void ModuleDecl() :
1775 {}
1776 {
1777 <ModuleNamespace>{jjtThis.processToken(token);} #ModuleNamespace(true) <NCNameForPrefix>{jjtThis.processToken(token);} #NCNameForPrefix(true) <AssignEquals>{jjtThis.processToken(token);} #AssignEquals(true) <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true) Separator()
1778 }
1779
1780 void Prolog() :
1781 {}
1782 {
1783 (Setter() Separator())* ((Import() | NamespaceDecl() | DefaultNamespaceDecl()) Separator())* ((VarDecl() | FunctionDecl()) Separator())*
1784 }
1785
1786 void Setter() :
1787 {}
1788 {
1789 (XMLSpaceDecl() | DefaultCollationDecl() | BaseURIDecl() | ConstructionDecl() | OrderingModeDecl() | EmptyOrderingDecl() | InheritNamespacesDecl())
1790 }
1791
1792 void Import() :
1793 {}
1794 {
1795 (SchemaImport() | ModuleImport())
1796 }
1797
1798 void Separator() :
1799 {}
1800 {
1801 <SemiColon>
1802 }
1803
1804 void NamespaceDecl() :
1805 {}
1806 {
1807 <DeclareNamespace>{jjtThis.processToken(token);} #DeclareNamespace(true) <NCNameForPrefix>{jjtThis.processToken(token);} #NCNameForPrefix(true) <AssignEquals>{jjtThis.processToken(token);} #AssignEquals(true) <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true)
1808 }
1809
1810 void XMLSpaceDecl() :
1811 {}
1812 {
1813 <DeclareXMLSpace>{jjtThis.processToken(token);} #DeclareXMLSpace(true) (<XMLSpacePreserve>{jjtThis.processToken(token);} #XMLSpacePreserve(true) | <XMLSpaceStrip>{jjtThis.processToken(token);} #XMLSpaceStrip(true))
1814 }
1815
1816 void DefaultNamespaceDecl() :
1817 {}
1818 {
1819 (<DeclareDefaultElement>{jjtThis.processToken(token);} #DeclareDefaultElement(true) | <DeclareDefaultFunction>{jjtThis.processToken(token);} #DeclareDefaultFunction(true)) <Namespace>{jjtThis.processToken(token);} #Namespace(true) <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true)
1820 }
1821
1822 void OrderingModeDecl() :
1823 {}
1824 {
1825 <DeclareOrdering>{jjtThis.processToken(token);} #DeclareOrdering(true) (<Ordered>{jjtThis.processToken(token);} #Ordered(true) | <Unordered>{jjtThis.processToken(token);} #Unordered(true))
1826 }
1827
1828 void EmptyOrderingDecl() :
1829 {}
1830 {
1831 <DeclareDefaultOrderingEmpty>{jjtThis.processToken(token);} #DeclareDefaultOrderingEmpty(true) (<EmptyGreatest>{jjtThis.processToken(token);} #EmptyGreatest(true) | <EmptyLeast>{jjtThis.processToken(token);} #EmptyLeast(true))
1832 }
1833
1834 void InheritNamespacesDecl() :
1835 {}
1836 {
1837 <DeclareInheritNamespaces>{jjtThis.processToken(token);} #DeclareInheritNamespaces(true) (<Yes>{jjtThis.processToken(token);} #Yes(true) | <No>{jjtThis.processToken(token);} #No(true))
1838 }
1839
1840 void DefaultCollationDecl() :
1841 {}
1842 {
1843 <DeclareCollation>{jjtThis.processToken(token);} #DeclareCollation(true) <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true)
1844 }
1845
1846 void BaseURIDecl() :
1847 {}
1848 {
1849 <DeclareBaseURI>{jjtThis.processToken(token);} #DeclareBaseURI(true) <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true)
1850 }
1851
1852 void SchemaImport() :
1853 {}
1854 {
1855 <ImportSchemaToken>{jjtThis.processToken(token);} #ImportSchemaToken(true) [SchemaPrefix()] <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true) [<AtStringLiteral>{jjtThis.processToken(token);} #AtStringLiteral(true) (<Comma> <StringLiteral>{jjtThis.processToken(token);} #StringLiteral(true))*]
1856 }
1857
1858 void SchemaPrefix() :
1859 {}
1860 {
1861 ((<Namespace>{jjtThis.processToken(token);} #Namespace(true) <NCNameForPrefix>{jjtThis.processToken(token);} #NCNameForPrefix(true) <AssignEquals>{jjtThis.processToken(token);} #AssignEquals(true)) | (<DefaultElement>{jjtThis.processToken(token);} #DefaultElement(true) <Namespace>{jjtThis.processToken(token);} #Namespace(true)))
1862 }
1863
1864 void ModuleImport() :
1865 {}
1866 {
1867 <ImportModuleToken>{jjtThis.processToken(token);} #ImportModuleToken(true) [<Namespace>{jjtThis.processToken(token);} #Namespace(true) <NCNameForPrefix>{jjtThis.processToken(token);} #NCNameForPrefix(true) <AssignEquals>{jjtThis.processToken(token);} #AssignEquals(true)] <URLLiteral>{jjtThis.processToken(token);} #URLLiteral(true) [<AtStringLiteral>{jjtThis.processToken(token);} #AtStringLiteral(true) (<Comma> <StringLiteral>{jjtThis.processToken(token);} #StringLiteral(true))*]
1868 }
1869
1870 void VarDecl() :
1871 {}
1872 {
1873 <DefineVariable>{jjtThis.processToken(token);} #DefineVariable(true) <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] ((<ColonEquals>{jjtThis.processToken(token);} #ColonEquals(true) ExprSingle()) | <External>{jjtThis.processToken(token);} #External(true))
1874 }
1875
1876 void ConstructionDecl() :
1877 {}
1878 {
1879 <DeclareConstruction>{jjtThis.processToken(token);} #DeclareConstruction(true) <SchemaModeForDeclareConstruction>{jjtThis.processToken(token);} #SchemaModeForDeclareConstruction(true)
1880 }
1881
1882 void FunctionDecl() :
1883 {}
1884 {
1885 <DefineFunction>{jjtThis.processToken(token);} #DefineFunction(true) <QNameLpar>{jjtThis.processToken(token);} #QNameLpar(true) [ParamList()] (<Rpar> (<As> {jjtThis.processToken(token);} #As(true) SequenceType())?) (EnclosedExpr() | <External>{jjtThis.processToken(token);} #External(true))
1886 }
1887
1888 void ParamList() :
1889 {}
1890 {
1891 Param() (<Comma> Param())*
1892 }
1893
1894 void Param() :
1895 {}
1896 {
1897 <VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()]
1898 }
1899
1900 void EnclosedExpr() :
1901 {}
1902 {
1903 (<Lbrace>{jjtThis.processToken(token);} #Lbrace(true) | <LbraceExprEnclosure>{jjtThis.processToken(token);} #LbraceExprEnclosure(true)) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
1904 }
1905
1906 void QueryBody() :
1907 {}
1908 {
1909 (Expr())
1910 }
1911
1912 void Expr() :
1913 {}
1914 {
1915 ExprSingle() (<Comma> ExprSingle())*
1916 }
1917
1918 void ExprSingle() #void :
1919 {}
1920 {
1921 (FLWORExpr() | QuantifiedExpr() | TypeswitchExpr() | IfExpr() | OrExpr())
1922 }
1923
1924 void FLWORExpr() :
1925 {}
1926 {
1927 ((ForClause() | LetClause()))+ [WhereClause()] [OrderByClause()] <Return> ExprSingle()
1928 }
1929
1930 void ForClause() #void :
1931 {}
1932 {
1933 <ForVariable> <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] [PositionalVar()] <In>{jjtThis.processToken(token);} #In(true) ExprSingle() (<Comma> <VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] [PositionalVar()] <In>{jjtThis.processToken(token);} #In(true) ExprSingle())*
1934 }
1935
1936 void PositionalVar() :
1937 {}
1938 {
1939 <AtWord>{jjtThis.processToken(token);} #AtWord(true) <VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true)
1940 }
1941
1942 void LetClause() :
1943 {}
1944 {
1945 <LetVariable>{jjtThis.processToken(token);} #LetVariable(true) <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] <ColonEquals>{jjtThis.processToken(token);} #ColonEquals(true) ExprSingle() (<Comma> <VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] <ColonEquals>{jjtThis.processToken(token);} #ColonEquals(true) ExprSingle())*
1946 }
1947
1948 void WhereClause() :
1949 {}
1950 {
1951 <Where>{jjtThis.processToken(token);} #Where(true) ExprSingle()
1952 }
1953
1954 void OrderByClause() :
1955 {}
1956 {
1957 (<OrderBy>{jjtThis.processToken(token);} #OrderBy(true) | <OrderByStable>{jjtThis.processToken(token);} #OrderByStable(true)) OrderSpecList()
1958 }
1959
1960 void OrderSpecList() :
1961 {}
1962 {
1963 OrderSpec() (<Comma> OrderSpec())*
1964 }
1965
1966 void OrderSpec() :
1967 {}
1968 {
1969 ExprSingle() OrderModifier()
1970 }
1971
1972 void OrderModifier() :
1973 {}
1974 {
1975 [(<Ascending>{jjtThis.processToken(token);} #Ascending(true) | <Descending>{jjtThis.processToken(token);} #Descending(true))] [(<EmptyGreatest>{jjtThis.processToken(token);} #EmptyGreatest(true) | <EmptyLeast>{jjtThis.processToken(token);} #EmptyLeast(true))] [<Collation>{jjtThis.processToken(token);} #Collation(true) <StringLiteral>{jjtThis.processToken(token);} #StringLiteral(true)]
1976 }
1977
1978 void QuantifiedExpr() :
1979 {}
1980 {
1981 (<Some>{jjtThis.processToken(token);} #Some(true) | <Every>{jjtThis.processToken(token);} #Every(true)) <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] <In>{jjtThis.processToken(token);} #In(true) ExprSingle() (<Comma> <VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true) [TypeDeclaration()] <In>{jjtThis.processToken(token);} #In(true) ExprSingle())* <Satisfies>{jjtThis.processToken(token);} #Satisfies(true) ExprSingle()
1982 }
1983
1984 void TypeswitchExpr() :
1985 {}
1986 {
1987 <TypeswitchLpar> Expr() <Rpar> (CaseClause())+ <Default>{jjtThis.processToken(token);} #Default(true) [<VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true)] <Return> ExprSingle()
1988 }
1989
1990 void CaseClause() :
1991 {}
1992 {
1993 <Case>{jjtThis.processToken(token);} #Case(true) [<VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true) <As>{jjtThis.processToken(token);} #As(true)] SequenceType() <Return> ExprSingle()
1994 }
1995
1996 void IfExpr() :
1997 {}
1998 {
1999 <IfLpar> Expr() <Rpar> <Then> ExprSingle() <Else> ExprSingle()
2000 }
2001
2002 void OperatorExpr() #void :
2003 {}
2004 {
2005 OrExpr()
2006 }
2007
2008 void OrExpr() #OrExpr(> 1) :
2009 {}
2010 {
2011 AndExpr() (<Or>
2012
2013 {binaryTokenStack.push(token);}
2014 AndExpr()
2015 {
2016 try
2017 {
2018 jjtThis.processToken((Token)binaryTokenStack.pop());
2019 }
2020 catch(java.util.EmptyStackException e)
2021 {
2022 token_source.printLinePos();
2023 e.printStackTrace();
2024 throw e;
2025 }
2026 }
2027 #OrExpr(2))*
2028 }
2029
2030 void AndExpr() #AndExpr(> 1) :
2031 {}
2032 {
2033 ComparisonExpr() (<And>
2034
2035 {binaryTokenStack.push(token);}
2036 ComparisonExpr()
2037 {
2038 try
2039 {
2040 jjtThis.processToken((Token)binaryTokenStack.pop());
2041 }
2042 catch(java.util.EmptyStackException e)
2043 {
2044 token_source.printLinePos();
2045 e.printStackTrace();
2046 throw e;
2047 }
2048 }
2049 #AndExpr(2))*
2050 }
2051
2052 void ComparisonExpr() #ComparisonExpr(> 1) :
2053 {}
2054 {
2055 RangeExpr() ((ValueComp() | GeneralComp() | NodeComp()) RangeExpr()
2056 {
2057 try
2058 {
2059 jjtThis.processToken((Token)binaryTokenStack.pop());
2060 }
2061 catch(java.util.EmptyStackException e)
2062 {
2063 token_source.printLinePos();
2064 e.printStackTrace();
2065 throw e;
2066 }
2067 }
2068 #ComparisonExpr(2))?
2069 }
2070
2071 void RangeExpr() #RangeExpr(> 1) :
2072 {}
2073 {
2074 AdditiveExpr() (<To>
2075
2076 {binaryTokenStack.push(token);}
2077 AdditiveExpr()
2078 {
2079 try
2080 {
2081 jjtThis.processToken((Token)binaryTokenStack.pop());
2082 }
2083 catch(java.util.EmptyStackException e)
2084 {
2085 token_source.printLinePos();
2086 e.printStackTrace();
2087 throw e;
2088 }
2089 }
2090 #RangeExpr(2))?
2091 }
2092
2093 void AdditiveExpr() #AdditiveExpr(> 1) :
2094 {}
2095 {
2096 MultiplicativeExpr() ((<Plus>
2097
2098 {binaryTokenStack.push(token);}
2099 | <Minus>
2100
2101 {binaryTokenStack.push(token);}
2102 ) MultiplicativeExpr()
2103 {
2104 try
2105 {
2106 jjtThis.processToken((Token)binaryTokenStack.pop());
2107 }
2108 catch(java.util.EmptyStackException e)
2109 {
2110 token_source.printLinePos();
2111 e.printStackTrace();
2112 throw e;
2113 }
2114 }
2115 #AdditiveExpr(2))*
2116 }
2117
2118 void MultiplicativeExpr() #MultiplicativeExpr(> 1) :
2119 {}
2120 {
2121 UnionExpr() ((<Multiply>
2122
2123 {binaryTokenStack.push(token);}
2124 | <Div>
2125
2126 {binaryTokenStack.push(token);}
2127 | <Idiv>
2128
2129 {binaryTokenStack.push(token);}
2130 | <Mod>
2131
2132 {binaryTokenStack.push(token);}
2133 ) UnionExpr()
2134 {
2135 try
2136 {
2137 jjtThis.processToken((Token)binaryTokenStack.pop());
2138 }
2139 catch(java.util.EmptyStackException e)
2140 {
2141 token_source.printLinePos();
2142 e.printStackTrace();
2143 throw e;
2144 }
2145 }
2146 #MultiplicativeExpr(2))*
2147 }
2148
2149 void UnionExpr() #UnionExpr(> 1) :
2150 {}
2151 {
2152 IntersectExceptExpr() ((<Union>
2153
2154 {binaryTokenStack.push(token);}
2155 | <Vbar>
2156
2157 {binaryTokenStack.push(token);}
2158 ) IntersectExceptExpr()
2159 {
2160 try
2161 {
2162 jjtThis.processToken((Token)binaryTokenStack.pop());
2163 }
2164 catch(java.util.EmptyStackException e)
2165 {
2166 token_source.printLinePos();
2167 e.printStackTrace();
2168 throw e;
2169 }
2170 }
2171 #UnionExpr(2))*
2172 }
2173
2174 void IntersectExceptExpr() #IntersectExceptExpr(> 1) :
2175 {}
2176 {
2177 InstanceofExpr() ((<Intersect>
2178
2179 {binaryTokenStack.push(token);}
2180 | <Except>
2181
2182 {binaryTokenStack.push(token);}
2183 ) InstanceofExpr()
2184 {
2185 try
2186 {
2187 jjtThis.processToken((Token)binaryTokenStack.pop());
2188 }
2189 catch(java.util.EmptyStackException e)
2190 {
2191 token_source.printLinePos();
2192 e.printStackTrace();
2193 throw e;
2194 }
2195 }
2196 #IntersectExceptExpr(2))*
2197 }
2198
2199 void InstanceofExpr() #InstanceofExpr(> 1) :
2200 {}
2201 {
2202 TreatExpr() (<Instanceof> SequenceType())?
2203 }
2204
2205 void TreatExpr() #TreatExpr(> 1) :
2206 {}
2207 {
2208 CastableExpr() (<TreatAs> SequenceType())?
2209 }
2210
2211 void CastableExpr() #CastableExpr(> 1) :
2212 {}
2213 {
2214 CastExpr() (<Castable> SingleType())?
2215 }
2216
2217 void CastExpr() #CastExpr(> 1) :
2218 {}
2219 {
2220 UnaryExpr() (<CastAs>{jjtThis.processToken(token);} #CastAs(true) SingleType())?
2221 }
2222
2223 void UnaryExpr() #UnaryExpr(keepUnary) :
2224 {boolean keepUnary=false;}
2225 {
2226 (<UnaryMinus>{keepUnary=true;jjtThis.processToken(token);} #UnaryMinus(true) | <UnaryPlus>{keepUnary=true;jjtThis.processToken(token);} #UnaryPlus(true))* ValueExpr()
2227 }
2228
2229 void ValueExpr() #void :
2230 {}
2231 {
2232 (ValidateExpr() | PathExpr())
2233 }
2234
2235 void GeneralComp() #void :
2236 {}
2237 {
2238 (<Equals>
2239
2240 {binaryTokenStack.push(token);}
2241 | <NotEquals>
2242
2243 {binaryTokenStack.push(token);}
2244 | <Lt>
2245
2246 {binaryTokenStack.push(token);}
2247 | <LtEquals>
2248
2249 {binaryTokenStack.push(token);}
2250 | <Gt>
2251
2252 {binaryTokenStack.push(token);}
2253 | <GtEquals>
2254
2255 {binaryTokenStack.push(token);}
2256 )
2257 }
2258
2259 void ValueComp() #void :
2260 {}
2261 {
2262 (<FortranEq>
2263
2264 {binaryTokenStack.push(token);}
2265 | <FortranNe>
2266
2267 {binaryTokenStack.push(token);}
2268 | <FortranLt>
2269
2270 {binaryTokenStack.push(token);}
2271 | <FortranLe>
2272
2273 {binaryTokenStack.push(token);}
2274 | <FortranGt>
2275
2276 {binaryTokenStack.push(token);}
2277 | <FortranGe>
2278
2279 {binaryTokenStack.push(token);}
2280 )
2281 }
2282
2283 void NodeComp() #void :
2284 {}
2285 {
2286 (<Is>
2287
2288 {binaryTokenStack.push(token);}
2289 | <LtLt>
2290
2291 {binaryTokenStack.push(token);}
2292 | <GtGt>
2293
2294 {binaryTokenStack.push(token);}
2295 )
2296 }
2297
2298 void ValidateExpr() :
2299 {}
2300 {
2301 (<ValidateLbrace>{jjtThis.processToken(token);} #ValidateLbrace(true) | (<ValidateSchemaMode>{jjtThis.processToken(token);} #ValidateSchemaMode(true) <LbraceExprEnclosure>{jjtThis.processToken(token);} #LbraceExprEnclosure(true))) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2302 }
2303
2304 void PathExpr() #PathExpr(>0) :
2305 {}
2306 {
2307 ((<Root>{jjtThis.processToken(token);} #Root(true) [RelativePathExpr()]) | (<RootDescendants>{jjtThis.processToken(token);} #RootDescendants(true) RelativePathExpr()) | RelativePathExpr())
2308 }
2309
2310 void RelativePathExpr() #void :
2311 {}
2312 {
2313 StepExpr() ((<Slash> | <SlashSlash>{jjtThis.processToken(token);} #SlashSlash(true)) StepExpr())*
2314 }
2315
2316 void StepExpr() #StepExpr(>1 || isStep) :
2317 {boolean savedIsStep = isStep; isStep=false;}
2318 {
2319 ({isStep=true;}AxisStep(){isStep = savedIsStep;} | FilterExpr(){isStep = savedIsStep;})
2320 }
2321
2322 void AxisStep() #void :
2323 {}
2324 {
2325 (ForwardStep() | ReverseStep()) PredicateList()
2326 }
2327
2328 void ForwardStep() #void :
2329 {}
2330 {
2331 ((ForwardAxis() NodeTest()) | AbbrevForwardStep())
2332 }
2333
2334 void ForwardAxis() #void :
2335 {}
2336 {
2337 (<AxisChild>{jjtThis.processToken(token);} #AxisChild(true) | <AxisDescendant>{jjtThis.processToken(token);} #AxisDescendant(true) | <AxisAttribute>{jjtThis.processToken(token);} #AxisAttribute(true) | <AxisSelf>{jjtThis.processToken(token);} #AxisSelf(true) | <AxisDescendantOrSelf>{jjtThis.processToken(token);} #AxisDescendantOrSelf(true) | <AxisFollowingSibling>{jjtThis.processToken(token);} #AxisFollowingSibling(true) | <AxisFollowing>{jjtThis.processToken(token);} #AxisFollowing(true))
2338 }
2339
2340 void AbbrevForwardStep() #void :
2341 {}
2342 {
2343 [<At>{jjtThis.processToken(token);} #At(true)] NodeTest()
2344 }
2345
2346 void ReverseStep() #void :
2347 {}
2348 {
2349 ((ReverseAxis() NodeTest()) | AbbrevReverseStep())
2350 }
2351
2352 void ReverseAxis() #void :
2353 {}
2354 {
2355 (<AxisParent>{jjtThis.processToken(token);} #AxisParent(true) | <AxisAncestor>{jjtThis.processToken(token);} #AxisAncestor(true) | <AxisPrecedingSibling>{jjtThis.processToken(token);} #AxisPrecedingSibling(true) | <AxisPreceding>{jjtThis.processToken(token);} #AxisPreceding(true) | <AxisAncestorOrSelf>{jjtThis.processToken(token);} #AxisAncestorOrSelf(true))
2356 }
2357
2358 void AbbrevReverseStep() #void :
2359 {}
2360 {
2361 <DotDot>{jjtThis.processToken(token);} #DotDot(true)
2362 }
2363
2364 void NodeTest() :
2365 {}
2366 {
2367 (KindTest() | NameTest())
2368 }
2369
2370 void NameTest() :
2371 {}
2372 {
2373 (<QName>{jjtThis.processToken(token);} #QName(true) | Wildcard())
2374 }
2375
2376 void Wildcard() #void :
2377 {}
2378 {
2379 (<Star>{jjtThis.processToken(token);} #Star(true) | <NCNameColonStar>{jjtThis.processToken(token);} #NCNameColonStar(true) | <StarColonNCName>{jjtThis.processToken(token);} #StarColonNCName(true))
2380 }
2381
2382 void FilterExpr() #void :
2383 {}
2384 {
2385 PrimaryExpr() PredicateList()
2386 }
2387
2388 void PredicateList() #PredicateList(> 0) :
2389 {}
2390 {
2391 (Predicate())*
2392 }
2393
2394 void Predicate() #Predicate(> 0) :
2395 {}
2396 {
2397 <Lbrack> Expr() <Rbrack>
2398 }
2399
2400 void PrimaryExpr() #void :
2401 {}
2402 {
2403 (Literal() | VarRef() | ParenthesizedExpr() | {isStep=true;}ContextItemExpr() | FunctionCall() | Constructor() | OrderedExpr() | UnorderedExpr())
2404 }
2405
2406 void Literal() #void :
2407 {}
2408 {
2409 (NumericLiteral() | <StringLiteral>{jjtThis.processToken(token);} #StringLiteral(true))
2410 }
2411
2412 void NumericLiteral() #void :
2413 {}
2414 {
2415 (<IntegerLiteral>{jjtThis.processToken(token);} #IntegerLiteral(true) | <DecimalLiteral>{jjtThis.processToken(token);} #DecimalLiteral(true) | <DoubleLiteral>{jjtThis.processToken(token);} #DoubleLiteral(true))
2416 }
2417
2418 void VarRef() #void :
2419 {}
2420 {
2421 <VariableIndicator> <VarName>{jjtThis.processToken(token);} #VarName(true)
2422 }
2423
2424 void ParenthesizedExpr() #void :
2425 {}
2426 {
2427 <Lpar> [Expr()] <Rpar>
2428 }
2429
2430 void ContextItemExpr() #void :
2431 {}
2432 {
2433 <Dot>{jjtThis.processToken(token);} #Dot(true)
2434 }
2435
2436 void OrderedExpr() #void :
2437 {}
2438 {
2439 <OrderedOpen>{jjtThis.processToken(token);} #OrderedOpen(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2440 }
2441
2442 void UnorderedExpr() #void :
2443 {}
2444 {
2445 <UnorderedOpen>{jjtThis.processToken(token);} #UnorderedOpen(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2446 }
2447
2448 void FunctionCall() :
2449 {}
2450 {
2451 (<QNameLpar>{jjtThis.processToken(token);} #QNameLpar(true)) [ExprSingle() (<Comma> ExprSingle())*] <Rpar>
2452 }
2453
2454 void Constructor() :
2455 {}
2456 {
2457 (DirectConstructor() | ComputedConstructor())
2458 }
2459
2460 void DirectConstructor() :
2461 {}
2462 {
2463 (DirElemConstructor() | DirCommentConstructor() | DirPIConstructor())
2464 }
2465
2466 void DirElemConstructor() :
2467 {}
2468 {
2469 (<StartTagOpenRoot>{jjtThis.processToken(token);} #StartTagOpenRoot(true) | <StartTagOpen>{jjtThis.processToken(token);} #StartTagOpen(true)) <TagQName>{jjtThis.processToken(token);} #TagQName(true) DirAttributeList() (<EmptyTagClose>{jjtThis.processToken(token);} #EmptyTagClose(true) | (<StartTagClose>{jjtThis.processToken(token);} #StartTagClose(true) (DirElemContent())* <EndTagOpen>{jjtThis.processToken(token);} #EndTagOpen(true) <TagQName>{jjtThis.processToken(token);} #TagQName(true) [<S>{jjtThis.processToken(token);} #S(true)] <EndTagClose>{jjtThis.processToken(token);} #EndTagClose(true)))
2470 }
2471
2472 void DirAttributeList() :
2473 {}
2474 {
2475 (<S>{jjtThis.processToken(token);} #S(true) [<TagQName>{jjtThis.processToken(token);} #TagQName(true) [<S>{jjtThis.processToken(token);} #S(true)] <ValueIndicator>{jjtThis.processToken(token);} #ValueIndicator(true) [<S>{jjtThis.processToken(token);} #S(true)] DirAttributeValue()])*
2476 }
2477
2478 void DirAttributeValue() :
2479 {}
2480 {
2481 ((<OpenQuot>{jjtThis.processToken(token);} #OpenQuot(true) ((<EscapeQuot>{jjtThis.processToken(token);} #EscapeQuot(true) | QuotAttrValueContent()))* <CloseQuot>{jjtThis.processToken(token);} #CloseQuot(true)) | (<OpenApos>{jjtThis.processToken(token);} #OpenApos(true) ((<EscapeApos>{jjtThis.processToken(token);} #EscapeApos(true) | AposAttrValueContent()))* <CloseApos>{jjtThis.processToken(token);} #CloseApos(true)))
2482 }
2483
2484 void QuotAttrValueContent() :
2485 {}
2486 {
2487 (<QuotAttrContentChar>{jjtThis.processToken(token);} #QuotAttrContentChar(true) | CommonContent())
2488 }
2489
2490 void AposAttrValueContent() :
2491 {}
2492 {
2493 (<AposAttrContentChar>{jjtThis.processToken(token);} #AposAttrContentChar(true) | CommonContent())
2494 }
2495
2496 void DirElemContent() :
2497 {}
2498 {
2499 (DirectConstructor() | <ElementContentChar>{jjtThis.processToken(token);} #ElementContentChar(true) | CDataSection() | CommonContent())
2500 }
2501
2502 void CommonContent() :
2503 {}
2504 {
2505 (<PredefinedEntityRef>{jjtThis.processToken(token);} #PredefinedEntityRef(true) | <CharRef>{jjtThis.processToken(token);} #CharRef(true) | <LCurlyBraceEscape>{jjtThis.processToken(token);} #LCurlyBraceEscape(true) | <RCurlyBraceEscape>{jjtThis.processToken(token);} #RCurlyBraceEscape(true) | EnclosedExpr())
2506 }
2507
2508 void DirCommentConstructor() :
2509 {}
2510 {
2511 (<XmlCommentStartForElementContent>{jjtThis.processToken(token);} #XmlCommentStartForElementContent(true) | <XmlCommentStart>{jjtThis.processToken(token);} #XmlCommentStart(true)) DirCommentContents() <XmlCommentEnd>{jjtThis.processToken(token);} #XmlCommentEnd(true)
2512 }
2513
2514 void DirCommentContents() :
2515 {}
2516 {
2517 ((<CommentContentChar>{jjtThis.processToken(token);} #CommentContentChar(true) | <CommentContentCharDash>{jjtThis.processToken(token);} #CommentContentCharDash(true)))*
2518 }
2519
2520 void DirPIConstructor() :
2521 {}
2522 {
2523 (<ProcessingInstructionStartForElementContent>{jjtThis.processToken(token);} #ProcessingInstructionStartForElementContent(true) | <ProcessingInstructionStart>{jjtThis.processToken(token);} #ProcessingInstructionStart(true)) <PITarget>{jjtThis.processToken(token);} #PITarget(true) [<SForPI>{jjtThis.processToken(token);} #SForPI(true) DirPIContents()] <ProcessingInstructionEnd>{jjtThis.processToken(token);} #ProcessingInstructionEnd(true)
2524 }
2525
2526 void DirPIContents() :
2527 {}
2528 {
2529 (<PIContentChar>{jjtThis.processToken(token);} #PIContentChar(true))*
2530 }
2531
2532 void CDataSection() :
2533 {}
2534 {
2535 (<CdataSectionStartForElementContent>{jjtThis.processToken(token);} #CdataSectionStartForElementContent(true) | <CdataSectionStart>{jjtThis.processToken(token);} #CdataSectionStart(true)) CDataSectionContents() <CdataSectionEnd>{jjtThis.processToken(token);} #CdataSectionEnd(true)
2536 }
2537
2538 void CDataSectionContents() :
2539 {}
2540 {
2541 (<CDataSectionChar>{jjtThis.processToken(token);} #CDataSectionChar(true))*
2542 }
2543
2544 void ComputedConstructor() :
2545 {}
2546 {
2547 (CompDocConstructor() | CompElemConstructor() | CompAttrConstructor() | CompTextConstructor() | CompCommentConstructor() | CompPIConstructor())
2548 }
2549
2550 void CompDocConstructor() :
2551 {}
2552 {
2553 <DocumentLbrace>{jjtThis.processToken(token);} #DocumentLbrace(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2554 }
2555
2556 void CompElemConstructor() :
2557 {}
2558 {
2559 (<ElementQNameLbrace>{jjtThis.processToken(token);} #ElementQNameLbrace(true) | (<ElementLbrace>{jjtThis.processToken(token);} #ElementLbrace(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true) <LbraceExprEnclosure>{jjtThis.processToken(token);} #LbraceExprEnclosure(true))) [ContentExpr()] <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2560 }
2561
2562 void ContentExpr() :
2563 {}
2564 {
2565 Expr()
2566 }
2567
2568 void CompAttrConstructor() :
2569 {}
2570 {
2571 (<AttributeQNameLbrace>{jjtThis.processToken(token);} #AttributeQNameLbrace(true) | (<AttributeLbrace>{jjtThis.processToken(token);} #AttributeLbrace(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true) <LbraceExprEnclosure>{jjtThis.processToken(token);} #LbraceExprEnclosure(true))) [Expr()] <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2572 }
2573
2574 void CompTextConstructor() :
2575 {}
2576 {
2577 <TextLbrace>{jjtThis.processToken(token);} #TextLbrace(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2578 }
2579
2580 void CompCommentConstructor() :
2581 {}
2582 {
2583 <CommentLbrace>{jjtThis.processToken(token);} #CommentLbrace(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2584 }
2585
2586 void CompPIConstructor() :
2587 {}
2588 {
2589 (<PINCNameLbrace>{jjtThis.processToken(token);} #PINCNameLbrace(true) | (<PILbrace>{jjtThis.processToken(token);} #PILbrace(true) Expr() <Rbrace>{jjtThis.processToken(token);} #Rbrace(true) <LbraceExprEnclosure>{jjtThis.processToken(token);} #LbraceExprEnclosure(true))) [Expr()] <Rbrace>{jjtThis.processToken(token);} #Rbrace(true)
2590 }
2591
2592 void SingleType() :
2593 {}
2594 {
2595 AtomicType() [<OccurrenceZeroOrOne>{jjtThis.processToken(token);} #OccurrenceZeroOrOne(true)]
2596 }
2597
2598 void TypeDeclaration() :
2599 {}
2600 {
2601 <As>{jjtThis.processToken(token);} #As(true) SequenceType()
2602 }
2603
2604 void SequenceType() :
2605 {}
2606 {
2607 ((ItemType() [OccurrenceIndicator()]) | <EmptyTok>{jjtThis.processToken(token);} #EmptyTok(true))
2608 }
2609
2610 void OccurrenceIndicator() #void :
2611 {}
2612 {
2613 (<OccurrenceZeroOrOne>{jjtThis.processToken(token);} #OccurrenceZeroOrOne(true) | <OccurrenceZeroOrMore>{jjtThis.processToken(token);} #OccurrenceZeroOrMore(true) | <OccurrenceOneOrMore>{jjtThis.processToken(token);} #OccurrenceOneOrMore(true))
2614 }
2615
2616 void ItemType() #void :
2617 {}
2618 {
2619 (AtomicType() | KindTest() | <Item>{jjtThis.processToken(token);} #Item(true))
2620 }
2621
2622 void AtomicType() :
2623 {}
2624 {
2625 (<QNameForAtomicType>{jjtThis.processToken(token);} #QNameForAtomicType(true) | <QNameForSequenceType>{jjtThis.processToken(token);} #QNameForSequenceType(true))
2626 }
2627
2628 void KindTest() #void :
2629 {}
2630 {
2631 (DocumentTest() | ElementTest() | AttributeTest() | SchemaElementTest() | SchemaAttributeTest() | PITest() | CommentTest() | TextTest() | AnyKindTest())
2632 }
2633
2634 void AnyKindTest() :
2635 {}
2636 {
2637 (<NodeLpar> | <NodeLparForKindTest>{jjtThis.processToken(token);} #NodeLparForKindTest(true)) <RparForKindTest>
2638 }
2639
2640 void DocumentTest() :
2641 {}
2642 {
2643 (<DocumentLpar>{jjtThis.processToken(token);} #DocumentLpar(true) | <DocumentLparForKindTest>{jjtThis.processToken(token);} #DocumentLparForKindTest(true)) [(ElementTest() | SchemaElementTest())] <RparForKindTest>
2644 }
2645
2646 void TextTest() :
2647 {}
2648 {
2649 (<TextLpar> | <TextLparForKindTest>{jjtThis.processToken(token);} #TextLparForKindTest(true)) <RparForKindTest>
2650 }
2651
2652 void CommentTest() :
2653 {}
2654 {
2655 (<CommentLpar> | <CommentLparForKindTest>{jjtThis.processToken(token);} #CommentLparForKindTest(true)) <RparForKindTest>
2656 }
2657
2658 void PITest() :
2659 {}
2660 {
2661 (<ProcessingInstructionLpar> | <ProcessingInstructionLparForKindTest>{jjtThis.processToken(token);} #ProcessingInstructionLparForKindTest(true)) [(<NCNameForPI>{jjtThis.processToken(token);} #NCNameForPI(true) | <StringLiteralForKindTest>{jjtThis.processToken(token);} #StringLiteralForKindTest(true))] <RparForKindTest>
2662 }
2663
2664 void AttributeTest() :
2665 {}
2666 {
2667 (<AttributeType>{jjtThis.processToken(token);} #AttributeType(true) | <AttributeTypeForKindTest>{jjtThis.processToken(token);} #AttributeTypeForKindTest(true)) [(AttribNameOrWildcard() [<CommaForKindTest>{jjtThis.processToken(token);} #CommaForKindTest(true) TypeName()])] <RparForKindTest>
2668 }
2669
2670 void AttribNameOrWildcard() :
2671 {}
2672 {
2673 (AttributeName() | <AnyName>{jjtThis.processToken(token);} #AnyName(true))
2674 }
2675
2676 void SchemaAttributeTest() :
2677 {}
2678 {
2679 (<SchemaAttributeType>{jjtThis.processToken(token);} #SchemaAttributeType(true) | <SchemaAttributeTypeForKindTest>{jjtThis.processToken(token);} #SchemaAttributeTypeForKindTest(true)) AttributeDeclaration() <RparForKindTest>
2680 }
2681
2682 void AttributeDeclaration() :
2683 {}
2684 {
2685 AttributeName()
2686 }
2687
2688 void ElementTest() :
2689 {}
2690 {
2691 (<ElementType>{jjtThis.processToken(token);} #ElementType(true) | <ElementTypeForKindTest>{jjtThis.processToken(token);} #ElementTypeForKindTest(true) | <ElementTypeForDocumentTest>{jjtThis.processToken(token);} #ElementTypeForDocumentTest(true)) [(ElementNameOrWildcard() [<CommaForKindTest>{jjtThis.processToken(token);} #CommaForKindTest(true) TypeName() [<Nillable>{jjtThis.processToken(token);} #Nillable(true)]])] <RparForKindTest>
2692 }
2693
2694 void ElementNameOrWildcard() :
2695 {}
2696 {
2697 (ElementName() | <AnyName>{jjtThis.processToken(token);} #AnyName(true))
2698 }
2699
2700 void SchemaElementTest() :
2701 {}
2702 {
2703 (<SchemaElementType>{jjtThis.processToken(token);} #SchemaElementType(true) | <SchemaElementTypeForKindTest>{jjtThis.processToken(token);} #SchemaElementTypeForKindTest(true) | <SchemaElementTypeForDocumentTest>{jjtThis.processToken(token);} #SchemaElementTypeForDocumentTest(true)) ElementDeclaration() <RparForKindTest>
2704 }
2705
2706 void ElementDeclaration() :
2707 {}
2708 {
2709 ElementName()
2710 }
2711
2712 void AttributeName() :
2713 {}
2714 {
2715 <QNameForItemType>{jjtThis.processToken(token);} #QNameForItemType(true)
2716 }
2717
2718 void ElementName() :
2719 {}
2720 {
2721 <QNameForItemType>{jjtThis.processToken(token);} #QNameForItemType(true)
2722 }
2723
2724 void TypeName() :
2725 {}
2726 {
2727 <QNameForItemType>{jjtThis.processToken(token);} #QNameForItemType(true)
2728 }
2729