View Javadoc

1   /* Generated By:JavaCC: Do not edit this line. XPathParser.java */
2       package org.apache.commons.jxpath.ri.parser;
3   
4       import org.apache.commons.jxpath.ri.Compiler;
5       import java.util.ArrayList;
6   
7       public class XPathParser implements XPathParserConstants {
8           private Compiler compiler;
9   
10          public void setCompiler(Compiler compiler){
11              this.compiler = compiler;
12          }
13  
14          private String unescape(String string){
15              int index = string.indexOf("'");
16              while (index != -1){
17                  string = string.substring(0, index) + "\'" + string.substring(index + 6);
18                  index = string.indexOf("'");
19              }
20              index = string.indexOf(""");
21              while (index != -1){
22                  string = string.substring(0, index) + "\"" + string.substring(index + 6);
23                  index = string.indexOf(""");
24              }
25              return string;
26          }
27  
28  // Note: XPath does not have reserved words, so we have to include all these terminals
29    final public String NCName() throws ParseException {
30      switch (jj_nt.kind) {
31      case OR:
32      case AND:
33      case MOD:
34      case DIV:
35      case NCName:
36        NCName_Without_CoreFunctions();
37        break;
38      case NODE:
39        jj_consume_token(NODE);
40        break;
41      case TEXT:
42        jj_consume_token(TEXT);
43        break;
44      case COMMENT:
45        jj_consume_token(COMMENT);
46        break;
47      case PI:
48        jj_consume_token(PI);
49        break;
50      case FUNCTION_LAST:
51        jj_consume_token(FUNCTION_LAST);
52        break;
53      case FUNCTION_POSITION:
54        jj_consume_token(FUNCTION_POSITION);
55        break;
56      case FUNCTION_COUNT:
57        jj_consume_token(FUNCTION_COUNT);
58        break;
59      case FUNCTION_ID:
60        jj_consume_token(FUNCTION_ID);
61        break;
62      case FUNCTION_LOCAL_NAME:
63        jj_consume_token(FUNCTION_LOCAL_NAME);
64        break;
65      case FUNCTION_NAMESPACE_URI:
66        jj_consume_token(FUNCTION_NAMESPACE_URI);
67        break;
68      case FUNCTION_NAME:
69        jj_consume_token(FUNCTION_NAME);
70        break;
71      case FUNCTION_STRING:
72        jj_consume_token(FUNCTION_STRING);
73        break;
74      case FUNCTION_CONCAT:
75        jj_consume_token(FUNCTION_CONCAT);
76        break;
77      case FUNCTION_STARTS_WITH:
78        jj_consume_token(FUNCTION_STARTS_WITH);
79        break;
80      case FUNCTION_ENDS_WITH:
81        jj_consume_token(FUNCTION_ENDS_WITH);
82        break;
83      case FUNCTION_CONTAINS:
84        jj_consume_token(FUNCTION_CONTAINS);
85        break;
86      case FUNCTION_SUBSTRING_BEFORE:
87        jj_consume_token(FUNCTION_SUBSTRING_BEFORE);
88        break;
89      case FUNCTION_SUBSTRING_AFTER:
90        jj_consume_token(FUNCTION_SUBSTRING_AFTER);
91        break;
92      case FUNCTION_SUBSTRING:
93        jj_consume_token(FUNCTION_SUBSTRING);
94        break;
95      case FUNCTION_STRING_LENGTH:
96        jj_consume_token(FUNCTION_STRING_LENGTH);
97        break;
98      case FUNCTION_NORMALIZE_SPACE:
99        jj_consume_token(FUNCTION_NORMALIZE_SPACE);
100       break;
101     case FUNCTION_TRANSLATE:
102       jj_consume_token(FUNCTION_TRANSLATE);
103       break;
104     case FUNCTION_BOOLEAN:
105       jj_consume_token(FUNCTION_BOOLEAN);
106       break;
107     case FUNCTION_NOT:
108       jj_consume_token(FUNCTION_NOT);
109       break;
110     case FUNCTION_TRUE:
111       jj_consume_token(FUNCTION_TRUE);
112       break;
113     case FUNCTION_FALSE:
114       jj_consume_token(FUNCTION_FALSE);
115       break;
116     case FUNCTION_NULL:
117       jj_consume_token(FUNCTION_NULL);
118       break;
119     case FUNCTION_LANG:
120       jj_consume_token(FUNCTION_LANG);
121       break;
122     case FUNCTION_NUMBER:
123       jj_consume_token(FUNCTION_NUMBER);
124       break;
125     case FUNCTION_SUM:
126       jj_consume_token(FUNCTION_SUM);
127       break;
128     case FUNCTION_FLOOR:
129       jj_consume_token(FUNCTION_FLOOR);
130       break;
131     case FUNCTION_CEILING:
132       jj_consume_token(FUNCTION_CEILING);
133       break;
134     case FUNCTION_ROUND:
135       jj_consume_token(FUNCTION_ROUND);
136       break;
137     case FUNCTION_KEY:
138       jj_consume_token(FUNCTION_KEY);
139       break;
140     case FUNCTION_FORMAT_NUMBER:
141       jj_consume_token(FUNCTION_FORMAT_NUMBER);
142       break;
143     default:
144       jj_la1[0] = jj_gen;
145       jj_consume_token(-1);
146       throw new ParseException();
147     }
148         {if (true) return token.image;}
149     throw new Error("Missing return statement in function");
150   }
151 
152   final public String NCName_Without_CoreFunctions() throws ParseException {
153     switch (jj_nt.kind) {
154     case NCName:
155       jj_consume_token(NCName);
156       break;
157     case OR:
158       jj_consume_token(OR);
159       break;
160     case AND:
161       jj_consume_token(AND);
162       break;
163     case MOD:
164       jj_consume_token(MOD);
165       break;
166     case DIV:
167       jj_consume_token(DIV);
168       break;
169     default:
170       jj_la1[1] = jj_gen;
171       jj_consume_token(-1);
172       throw new ParseException();
173     }
174         {if (true) return token.image;}
175     throw new Error("Missing return statement in function");
176   }
177 
178   final public int CoreFunctionName() throws ParseException {
179     int code;
180     switch (jj_nt.kind) {
181     case FUNCTION_LAST:
182       jj_consume_token(FUNCTION_LAST);
183                                       code = Compiler.FUNCTION_LAST;
184       break;
185     case FUNCTION_POSITION:
186       jj_consume_token(FUNCTION_POSITION);
187                                       code = Compiler.FUNCTION_POSITION;
188       break;
189     case FUNCTION_COUNT:
190       jj_consume_token(FUNCTION_COUNT);
191                                       code = Compiler.FUNCTION_COUNT;
192       break;
193     case FUNCTION_ID:
194       jj_consume_token(FUNCTION_ID);
195                                       code = Compiler.FUNCTION_ID;
196       break;
197     case FUNCTION_LOCAL_NAME:
198       jj_consume_token(FUNCTION_LOCAL_NAME);
199                                       code = Compiler.FUNCTION_LOCAL_NAME;
200       break;
201     case FUNCTION_NAMESPACE_URI:
202       jj_consume_token(FUNCTION_NAMESPACE_URI);
203                                       code = Compiler.FUNCTION_NAMESPACE_URI;
204       break;
205     case FUNCTION_NAME:
206       jj_consume_token(FUNCTION_NAME);
207                                       code = Compiler.FUNCTION_NAME;
208       break;
209     case FUNCTION_STRING:
210       jj_consume_token(FUNCTION_STRING);
211                                       code = Compiler.FUNCTION_STRING;
212       break;
213     case FUNCTION_CONCAT:
214       jj_consume_token(FUNCTION_CONCAT);
215                                       code = Compiler.FUNCTION_CONCAT;
216       break;
217     case FUNCTION_STARTS_WITH:
218       jj_consume_token(FUNCTION_STARTS_WITH);
219                                       code = Compiler.FUNCTION_STARTS_WITH;
220       break;
221     case FUNCTION_ENDS_WITH:
222       jj_consume_token(FUNCTION_ENDS_WITH);
223                                       code = Compiler.FUNCTION_ENDS_WITH;
224       break;
225     case FUNCTION_CONTAINS:
226       jj_consume_token(FUNCTION_CONTAINS);
227                                       code = Compiler.FUNCTION_CONTAINS;
228       break;
229     case FUNCTION_SUBSTRING_BEFORE:
230       jj_consume_token(FUNCTION_SUBSTRING_BEFORE);
231                                       code = Compiler.FUNCTION_SUBSTRING_BEFORE;
232       break;
233     case FUNCTION_SUBSTRING_AFTER:
234       jj_consume_token(FUNCTION_SUBSTRING_AFTER);
235                                       code = Compiler.FUNCTION_SUBSTRING_AFTER;
236       break;
237     case FUNCTION_SUBSTRING:
238       jj_consume_token(FUNCTION_SUBSTRING);
239                                       code = Compiler.FUNCTION_SUBSTRING;
240       break;
241     case FUNCTION_STRING_LENGTH:
242       jj_consume_token(FUNCTION_STRING_LENGTH);
243                                       code = Compiler.FUNCTION_STRING_LENGTH;
244       break;
245     case FUNCTION_NORMALIZE_SPACE:
246       jj_consume_token(FUNCTION_NORMALIZE_SPACE);
247                                       code = Compiler.FUNCTION_NORMALIZE_SPACE;
248       break;
249     case FUNCTION_TRANSLATE:
250       jj_consume_token(FUNCTION_TRANSLATE);
251                                       code = Compiler.FUNCTION_TRANSLATE;
252       break;
253     case FUNCTION_BOOLEAN:
254       jj_consume_token(FUNCTION_BOOLEAN);
255                                       code = Compiler.FUNCTION_BOOLEAN;
256       break;
257     case FUNCTION_NOT:
258       jj_consume_token(FUNCTION_NOT);
259                                       code = Compiler.FUNCTION_NOT;
260       break;
261     case FUNCTION_TRUE:
262       jj_consume_token(FUNCTION_TRUE);
263                                       code = Compiler.FUNCTION_TRUE;
264       break;
265     case FUNCTION_FALSE:
266       jj_consume_token(FUNCTION_FALSE);
267                                       code = Compiler.FUNCTION_FALSE;
268       break;
269     case FUNCTION_NULL:
270       jj_consume_token(FUNCTION_NULL);
271                                       code = Compiler.FUNCTION_NULL;
272       break;
273     case FUNCTION_LANG:
274       jj_consume_token(FUNCTION_LANG);
275                                       code = Compiler.FUNCTION_LANG;
276       break;
277     case FUNCTION_NUMBER:
278       jj_consume_token(FUNCTION_NUMBER);
279                                       code = Compiler.FUNCTION_NUMBER;
280       break;
281     case FUNCTION_SUM:
282       jj_consume_token(FUNCTION_SUM);
283                                       code = Compiler.FUNCTION_SUM;
284       break;
285     case FUNCTION_FLOOR:
286       jj_consume_token(FUNCTION_FLOOR);
287                                       code = Compiler.FUNCTION_FLOOR;
288       break;
289     case FUNCTION_CEILING:
290       jj_consume_token(FUNCTION_CEILING);
291                                       code = Compiler.FUNCTION_CEILING;
292       break;
293     case FUNCTION_ROUND:
294       jj_consume_token(FUNCTION_ROUND);
295                                       code = Compiler.FUNCTION_ROUND;
296       break;
297     case FUNCTION_KEY:
298       jj_consume_token(FUNCTION_KEY);
299                                       code = Compiler.FUNCTION_KEY;
300       break;
301     case FUNCTION_FORMAT_NUMBER:
302       jj_consume_token(FUNCTION_FORMAT_NUMBER);
303                                       code = Compiler.FUNCTION_FORMAT_NUMBER;
304       break;
305     default:
306       jj_la1[2] = jj_gen;
307       jj_consume_token(-1);
308       throw new ParseException();
309     }
310         {if (true) return code;}
311     throw new Error("Missing return statement in function");
312   }
313 
314   final public Object QName() throws ParseException {
315  String nc1, nc2 = null;
316     nc1 = NCName();
317     switch (jj_nt.kind) {
318     case 80:
319       jj_consume_token(80);
320       nc2 = NCName();
321       break;
322     default:
323       jj_la1[3] = jj_gen;
324       ;
325     }
326         if (nc2 == null){
327             {if (true) return compiler.qname(null, nc1);}
328         }
329         else {
330             {if (true) return compiler.qname(nc1, nc2);}
331         }
332     throw new Error("Missing return statement in function");
333   }
334 
335   final public Object QName_Without_CoreFunctions() throws ParseException {
336     String nc1, nc2 = null;
337     if (jj_2_1(2147483647)) {
338       nc1 = NCName();
339       jj_consume_token(80);
340       nc2 = NCName();
341     } else {
342       switch (jj_nt.kind) {
343       case OR:
344       case AND:
345       case MOD:
346       case DIV:
347       case NCName:
348         nc1 = NCName_Without_CoreFunctions();
349         break;
350       default:
351         jj_la1[4] = jj_gen;
352         jj_consume_token(-1);
353         throw new ParseException();
354       }
355     }
356         if (nc2 == null){
357             {if (true) return compiler.qname(null, nc1);}
358         }
359         else {
360             {if (true) return compiler.qname(nc1, nc2);}
361         }
362     throw new Error("Missing return statement in function");
363   }
364 
365   final public Object parseExpression() throws ParseException {
366     Object ex;
367     ex = Expression();
368     jj_consume_token(0);
369         {if (true) return ex;}
370     throw new Error("Missing return statement in function");
371   }
372 
373 /* ################################################################################### */
374 /* XSLT Patterns (http://www.w3.org/1999/08/WD-xslt-19990813)" target="alexandria_uri">http://www.w3.org/1999/08/WD-xslt-19990813)                          */
375 /* ################################################################################### */
376 
377 /* [XSLT1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern  */
378 
379 //void Pattern() :
380 //{}
381 //{
382 //        LocationPathPattern() ( <UNION> LocationPathPattern() )* <EOF>
383 //}
384 //
385 //
386 ///* [XSLT2] LocationPathPattern ::=
387 //   '/' RelativePathPattern? | IdKeyPattern (('/' | '//' RelativePathPattern)? | '//'? RelativePathPattern
388 //*/
389 //
390 //void LocationPathPattern() :
391 //{}
392 //{
393 //        <SLASH> ( RelativePathPattern() )?
394 //    |    (
395 //        LOOKAHEAD(IdKeyPattern())
396 //            IdKeyPattern() ( ( <SLASH> | <SLASHSLASH>) RelativePathPattern() )?
397 //        |    ( <SLASHSLASH> )? RelativePathPattern()
398 //        )
399 //}
400 //
401 //
402 //
403 ///* [XSLT3] IdKeyPattern    ::=    'id' '(' Literal ')' | 'key' '(' Literal ',' Literal ')'  */
404 //
405 //void IdKeyPattern() :
406 //{}
407 //{
408 //        <ID> "(" <Literal> ")"
409 //    |    <KEY>  "(" <Literal> "," <Literal> ")"
410 //}
411 //
412 //
413 ///* [XSLT4] RelativePathPattern    ::=    StepPattern | RelativePathPattern '/' StepPattern
414 //                           | RelativePathPattern '//' StepPattern
415 //*/
416 //void RelativePathPattern() :
417 //{}
418 //{
419 //        StepPattern() ( ( <SLASH>| <SLASHSLASH> ) StepPattern()    )*
420 //}
421 //
422 //
423 ///* [XSLT5]    StepPattern    ::=    AbbreviatedAxisSpecifier NodeTest Predicate*   */
424 //void StepPattern() :
425 //{}
426 //{
427 //        AbbreviatedAxisSpecifier() NodeTest() (Predicate())*
428 //}
429 
430 
431 
432 // See XPath Syntax (http://www.w3.org/TR/xpath )
433 
434 
435 //void XPath() :
436 //{}
437 //{
438 //    LocationPath()
439 //    <EOF>
440 //}
441 
442 
443 /* [1] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath  */
444   final public Object LocationPath() throws ParseException {
445  Object ex = null;
446     switch (jj_nt.kind) {
447     case OR:
448     case AND:
449     case MOD:
450     case DIV:
451     case NODE:
452     case TEXT:
453     case COMMENT:
454     case PI:
455     case AXIS_SELF:
456     case AXIS_CHILD:
457     case AXIS_PARENT:
458     case AXIS_ANCESTOR:
459     case AXIS_ATTRIBUTE:
460     case AXIS_NAMESPACE:
461     case AXIS_PRECEDING:
462     case AXIS_FOLLOWING:
463     case AXIS_DESCENDANT:
464     case AXIS_ANCESTOR_OR_SELF:
465     case AXIS_FOLLOWING_SIBLING:
466     case AXIS_PRECEDING_SIBLING:
467     case AXIS_DESCENDANT_OR_SELF:
468     case FUNCTION_LAST:
469     case FUNCTION_POSITION:
470     case FUNCTION_COUNT:
471     case FUNCTION_ID:
472     case FUNCTION_KEY:
473     case FUNCTION_LOCAL_NAME:
474     case FUNCTION_NAMESPACE_URI:
475     case FUNCTION_NAME:
476     case FUNCTION_STRING:
477     case FUNCTION_CONCAT:
478     case FUNCTION_STARTS_WITH:
479     case FUNCTION_ENDS_WITH:
480     case FUNCTION_CONTAINS:
481     case FUNCTION_SUBSTRING_BEFORE:
482     case FUNCTION_SUBSTRING_AFTER:
483     case FUNCTION_SUBSTRING:
484     case FUNCTION_STRING_LENGTH:
485     case FUNCTION_NORMALIZE_SPACE:
486     case FUNCTION_TRANSLATE:
487     case FUNCTION_BOOLEAN:
488     case FUNCTION_NOT:
489     case FUNCTION_TRUE:
490     case FUNCTION_FALSE:
491     case FUNCTION_NULL:
492     case FUNCTION_LANG:
493     case FUNCTION_NUMBER:
494     case FUNCTION_SUM:
495     case FUNCTION_FLOOR:
496     case FUNCTION_CEILING:
497     case FUNCTION_ROUND:
498     case FUNCTION_FORMAT_NUMBER:
499     case NCName:
500     case 83:
501     case 84:
502     case 87:
503     case 89:
504       ex = RelativeLocationPath();
505       break;
506     case SLASH:
507     case SLASHSLASH:
508       ex = AbsoluteLocationPath();
509       break;
510     default:
511       jj_la1[5] = jj_gen;
512       jj_consume_token(-1);
513       throw new ParseException();
514     }
515         {if (true) return ex;}
516     throw new Error("Missing return statement in function");
517   }
518 
519 /* [2] AbsoluteLocationPath ::= '/' RelativeLocationPath? | AbbreviatedAbsoluteLocationPath  */
520 /* [10]    AbbreviatedAbsoluteLocationPath    ::=    '//' RelativeLocationPath  */
521   final public Object AbsoluteLocationPath() throws ParseException {
522     ArrayList steps = new ArrayList();
523     if (jj_2_2(2147483647)) {
524       LocationStep(steps);
525       label_1:
526       while (true) {
527         switch (jj_nt.kind) {
528         case SLASH:
529         case SLASHSLASH:
530           ;
531           break;
532         default:
533           jj_la1[6] = jj_gen;
534           break label_1;
535         }
536         LocationStep(steps);
537       }
538     } else {
539       switch (jj_nt.kind) {
540       case SLASH:
541         jj_consume_token(SLASH);
542         break;
543       default:
544         jj_la1[7] = jj_gen;
545         jj_consume_token(-1);
546         throw new ParseException();
547       }
548     }
549         {if (true) return compiler.locationPath(true, steps.toArray());}
550     throw new Error("Missing return statement in function");
551   }
552 
553 /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */
554   final public Object RelativeLocationPath() throws ParseException {
555     ArrayList steps = new ArrayList();
556     NodeTest(steps);
557     label_2:
558     while (true) {
559       switch (jj_nt.kind) {
560       case SLASH:
561       case SLASHSLASH:
562         ;
563         break;
564       default:
565         jj_la1[8] = jj_gen;
566         break label_2;
567       }
568       LocationStep(steps);
569     }
570         {if (true) return compiler.locationPath(false, steps.toArray());}
571     throw new Error("Missing return statement in function");
572   }
573 
574 /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */
575 /* [11]    AbbreviatedRelativeLocationPath    ::=    RelativeLocationPath '//' Step  */
576 
577 
578 /*--------------------*/
579 /* 2.1 Location Steps */
580 /*--------------------*/
581 
582 /* [4] Step ::= AxisSpecifier NodeTest Predicate*   | AbbreviatedStep  */
583   final public void LocationStep(ArrayList steps) throws ParseException {
584     Object t;
585     Object s;
586     switch (jj_nt.kind) {
587     case SLASH:
588       jj_consume_token(SLASH);
589       break;
590     case SLASHSLASH:
591       jj_consume_token(SLASHSLASH);
592             // Abbreviated step: descendant-or-self::node()
593             t = compiler.nodeTypeTest(Compiler.NODE_TYPE_NODE);
594             steps.add(compiler.step(Compiler.AXIS_DESCENDANT_OR_SELF, t, null));
595       break;
596     default:
597       jj_la1[9] = jj_gen;
598       jj_consume_token(-1);
599       throw new ParseException();
600     }
601     NodeTest(steps);
602   }
603 
604 /* [7] NodeTest ::= WildcardName | NodeType '(' ')' | 'processing-instruction' '(' Literal ')' */
605   final public void NodeTest(ArrayList steps) throws ParseException {
606     int axis;
607     int type = -1;
608     String instruction = null;
609     Object name = null;
610     Object s;
611     Object p;
612     ArrayList ps = new ArrayList();
613     switch (jj_nt.kind) {
614     case OR:
615     case AND:
616     case MOD:
617     case DIV:
618     case NODE:
619     case TEXT:
620     case COMMENT:
621     case PI:
622     case AXIS_SELF:
623     case AXIS_CHILD:
624     case AXIS_PARENT:
625     case AXIS_ANCESTOR:
626     case AXIS_ATTRIBUTE:
627     case AXIS_NAMESPACE:
628     case AXIS_PRECEDING:
629     case AXIS_FOLLOWING:
630     case AXIS_DESCENDANT:
631     case AXIS_ANCESTOR_OR_SELF:
632     case AXIS_FOLLOWING_SIBLING:
633     case AXIS_PRECEDING_SIBLING:
634     case AXIS_DESCENDANT_OR_SELF:
635     case FUNCTION_LAST:
636     case FUNCTION_POSITION:
637     case FUNCTION_COUNT:
638     case FUNCTION_ID:
639     case FUNCTION_KEY:
640     case FUNCTION_LOCAL_NAME:
641     case FUNCTION_NAMESPACE_URI:
642     case FUNCTION_NAME:
643     case FUNCTION_STRING:
644     case FUNCTION_CONCAT:
645     case FUNCTION_STARTS_WITH:
646     case FUNCTION_ENDS_WITH:
647     case FUNCTION_CONTAINS:
648     case FUNCTION_SUBSTRING_BEFORE:
649     case FUNCTION_SUBSTRING_AFTER:
650     case FUNCTION_SUBSTRING:
651     case FUNCTION_STRING_LENGTH:
652     case FUNCTION_NORMALIZE_SPACE:
653     case FUNCTION_TRANSLATE:
654     case FUNCTION_BOOLEAN:
655     case FUNCTION_NOT:
656     case FUNCTION_TRUE:
657     case FUNCTION_FALSE:
658     case FUNCTION_NULL:
659     case FUNCTION_LANG:
660     case FUNCTION_NUMBER:
661     case FUNCTION_SUM:
662     case FUNCTION_FLOOR:
663     case FUNCTION_CEILING:
664     case FUNCTION_ROUND:
665     case FUNCTION_FORMAT_NUMBER:
666     case NCName:
667     case 87:
668     case 89:
669       axis = AxisSpecifier();
670       if (jj_2_3(2147483647)) {
671         type = NodeType();
672         jj_consume_token(81);
673         jj_consume_token(82);
674       } else if (jj_2_4(2147483647)) {
675         jj_consume_token(PI);
676         jj_consume_token(81);
677         jj_consume_token(Literal);
678                     instruction = unescape(token.image.substring(1, token.image.length() - 1));
679         jj_consume_token(82);
680       } else {
681         switch (jj_nt.kind) {
682         case OR:
683         case AND:
684         case MOD:
685         case DIV:
686         case NODE:
687         case TEXT:
688         case COMMENT:
689         case PI:
690         case FUNCTION_LAST:
691         case FUNCTION_POSITION:
692         case FUNCTION_COUNT:
693         case FUNCTION_ID:
694         case FUNCTION_KEY:
695         case FUNCTION_LOCAL_NAME:
696         case FUNCTION_NAMESPACE_URI:
697         case FUNCTION_NAME:
698         case FUNCTION_STRING:
699         case FUNCTION_CONCAT:
700         case FUNCTION_STARTS_WITH:
701         case FUNCTION_ENDS_WITH:
702         case FUNCTION_CONTAINS:
703         case FUNCTION_SUBSTRING_BEFORE:
704         case FUNCTION_SUBSTRING_AFTER:
705         case FUNCTION_SUBSTRING:
706         case FUNCTION_STRING_LENGTH:
707         case FUNCTION_NORMALIZE_SPACE:
708         case FUNCTION_TRANSLATE:
709         case FUNCTION_BOOLEAN:
710         case FUNCTION_NOT:
711         case FUNCTION_TRUE:
712         case FUNCTION_FALSE:
713         case FUNCTION_NULL:
714         case FUNCTION_LANG:
715         case FUNCTION_NUMBER:
716         case FUNCTION_SUM:
717         case FUNCTION_FLOOR:
718         case FUNCTION_CEILING:
719         case FUNCTION_ROUND:
720         case FUNCTION_FORMAT_NUMBER:
721         case NCName:
722         case 89:
723           name = WildcardName();
724           break;
725         default:
726           jj_la1[10] = jj_gen;
727           jj_consume_token(-1);
728           throw new ParseException();
729         }
730       }
731       break;
732     case 83:
733       jj_consume_token(83);
734                     axis = Compiler.AXIS_SELF;
735                     type = Compiler.NODE_TYPE_NODE;
736       break;
737     case 84:
738       jj_consume_token(84);
739                     axis = Compiler.AXIS_PARENT;
740                     type = Compiler.NODE_TYPE_NODE;
741       break;
742     default:
743       jj_la1[11] = jj_gen;
744       jj_consume_token(-1);
745       throw new ParseException();
746     }
747     label_3:
748     while (true) {
749       switch (jj_nt.kind) {
750       case 85:
751         ;
752         break;
753       default:
754         jj_la1[12] = jj_gen;
755         break label_3;
756       }
757       p = Predicate();
758                 ps.add(p);
759     }
760         if (name != null){
761             s = compiler.nodeNameTest(name);
762         }
763         else if (instruction != null){
764             s = compiler.processingInstructionTest(instruction);
765         }
766         else {
767             s = compiler.nodeTypeTest(type);
768         }
769         steps.add(compiler.step(axis, s, ps.toArray()));
770   }
771 
772 /* [5] AxisSpecifier ::=    AxisName '::' | AbbreviatedAxisSpecifier  */
773   final public int AxisSpecifier() throws ParseException {
774     int axis;
775     switch (jj_nt.kind) {
776     case AXIS_SELF:
777     case AXIS_CHILD:
778     case AXIS_PARENT:
779     case AXIS_ANCESTOR:
780     case AXIS_ATTRIBUTE:
781     case AXIS_NAMESPACE:
782     case AXIS_PRECEDING:
783     case AXIS_FOLLOWING:
784     case AXIS_DESCENDANT:
785     case AXIS_ANCESTOR_OR_SELF:
786     case AXIS_FOLLOWING_SIBLING:
787     case AXIS_PRECEDING_SIBLING:
788     case AXIS_DESCENDANT_OR_SELF:
789       axis = AxisName();
790       break;
791     default:
792       jj_la1[13] = jj_gen;
793       axis = AbbreviatedAxisSpecifier();
794     }
795         {if (true) return axis;}
796     throw new Error("Missing return statement in function");
797   }
798 
799 /*----------*/
800 /* 2.2 Axes */
801 /*----------*/
802 
803 /* [6] AxisName ::= 'ancestor' | 'ancestor-or-self' | 'attribute'  | 'child' | 'descendant'
804                     | 'descendant-or-self' | 'following' | 'following-sibling' | 'namespace'
805                        | 'parent' | 'preceding' | 'preceding-sibling' | 'self'
806 */
807   final public int AxisName() throws ParseException {
808     int axis = 0;
809     switch (jj_nt.kind) {
810     case AXIS_SELF:
811       jj_consume_token(AXIS_SELF);
812                                           axis = Compiler.AXIS_SELF;
813       break;
814     case AXIS_CHILD:
815       jj_consume_token(AXIS_CHILD);
816                                           axis = Compiler.AXIS_CHILD;
817       break;
818     case AXIS_PARENT:
819       jj_consume_token(AXIS_PARENT);
820                                           axis = Compiler.AXIS_PARENT;
821       break;
822     case AXIS_ANCESTOR:
823       jj_consume_token(AXIS_ANCESTOR);
824                                           axis = Compiler.AXIS_ANCESTOR;
825       break;
826     case AXIS_ATTRIBUTE:
827       jj_consume_token(AXIS_ATTRIBUTE);
828                                           axis = Compiler.AXIS_ATTRIBUTE;
829       break;
830     case AXIS_NAMESPACE:
831       jj_consume_token(AXIS_NAMESPACE);
832                                           axis = Compiler.AXIS_NAMESPACE;
833       break;
834     case AXIS_PRECEDING:
835       jj_consume_token(AXIS_PRECEDING);
836                                           axis = Compiler.AXIS_PRECEDING;
837       break;
838     case AXIS_FOLLOWING:
839       jj_consume_token(AXIS_FOLLOWING);
840                                           axis = Compiler.AXIS_FOLLOWING;
841       break;
842     case AXIS_DESCENDANT:
843       jj_consume_token(AXIS_DESCENDANT);
844                                           axis = Compiler.AXIS_DESCENDANT;
845       break;
846     case AXIS_ANCESTOR_OR_SELF:
847       jj_consume_token(AXIS_ANCESTOR_OR_SELF);
848                                           axis = Compiler.AXIS_ANCESTOR_OR_SELF;
849       break;
850     case AXIS_FOLLOWING_SIBLING:
851       jj_consume_token(AXIS_FOLLOWING_SIBLING);
852                                           axis = Compiler.AXIS_FOLLOWING_SIBLING;
853       break;
854     case AXIS_PRECEDING_SIBLING:
855       jj_consume_token(AXIS_PRECEDING_SIBLING);
856                                           axis = Compiler.AXIS_PRECEDING_SIBLING;
857       break;
858     case AXIS_DESCENDANT_OR_SELF:
859       jj_consume_token(AXIS_DESCENDANT_OR_SELF);
860                                           axis = Compiler.AXIS_DESCENDANT_OR_SELF;
861       break;
862     default:
863       jj_la1[14] = jj_gen;
864       jj_consume_token(-1);
865       throw new ParseException();
866     }
867         {if (true) return axis;}
868     throw new Error("Missing return statement in function");
869   }
870 
871 /*----------------*/
872 /* 2.3 Node Tests */
873 /*----------------*/
874 
875 /*----------------*/
876 /* 2.4 Predicates */
877 /*----------------*/
878 
879 /* [8] Predicate ::= '[' PredicateExpr ']'  */
880 /* [9] PredicateExpr ::=  Expr  */
881   final public Object Predicate() throws ParseException {
882     Object ex;
883     jj_consume_token(85);
884     ex = Expression();
885     jj_consume_token(86);
886         {if (true) return ex;}
887     throw new Error("Missing return statement in function");
888   }
889 
890 /* [12]    AbbreviatedStep    ::=    '.'  | '..'  */
891 
892 /* [13]    AbbreviatedAxisSpecifier    ::=    '@'? */
893   final public int AbbreviatedAxisSpecifier() throws ParseException {
894     int axis = Compiler.AXIS_CHILD;
895     switch (jj_nt.kind) {
896     case 87:
897       jj_consume_token(87);
898            axis = Compiler.AXIS_ATTRIBUTE;
899       break;
900     default:
901       jj_la1[15] = jj_gen;
902       ;
903     }
904         {if (true) return axis;}
905     throw new Error("Missing return statement in function");
906   }
907 
908 /*---------------*/
909 /* 3 Expressions */
910 /*---------------*/
911 
912 /*------------*/
913 /* 3.1 Basics */
914 /*------------*/
915 
916 /*
917 The effect of the grammar is that the order of precedence is (lowest precedence first):
918     or
919     and
920     =, !=
921     <=, <, >=, >
922 and all operators are left associative.
923 For example, 3 > 2 > 1 is equivalent to (3 > 2) > 1, which evaluates to false.
924 */
925 
926 /* [14] Expr ::= OrExpr */
927   final public Object Expression() throws ParseException {
928  Object ex;
929     ex = OrExpr();
930         {if (true) return ex;}
931     throw new Error("Missing return statement in function");
932   }
933 
934 /* [15] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall */
935   final public Object PrimaryExpr() throws ParseException {
936     Object ex = null;
937     switch (jj_nt.kind) {
938     case VARIABLE:
939       ex = VariableReference();
940       break;
941     case 81:
942       jj_consume_token(81);
943       ex = Expression();
944       jj_consume_token(82);
945       break;
946     case Literal:
947       jj_consume_token(Literal);
948                       ex = compiler.literal(unescape(token.image.substring(1, token.image.length() - 1)));
949       break;
950     case Number:
951       jj_consume_token(Number);
952                       ex = compiler.number(token.image);
953       break;
954     default:
955       jj_la1[16] = jj_gen;
956       if (jj_2_5(2147483647)) {
957         ex = CoreFunctionCall();
958       } else {
959         switch (jj_nt.kind) {
960         case OR:
961         case AND:
962         case MOD:
963         case DIV:
964         case NODE:
965         case TEXT:
966         case COMMENT:
967         case PI:
968         case FUNCTION_LAST:
969         case FUNCTION_POSITION:
970         case FUNCTION_COUNT:
971         case FUNCTION_ID:
972         case FUNCTION_KEY:
973         case FUNCTION_LOCAL_NAME:
974         case FUNCTION_NAMESPACE_URI:
975         case FUNCTION_NAME:
976         case FUNCTION_STRING:
977         case FUNCTION_CONCAT:
978         case FUNCTION_STARTS_WITH:
979         case FUNCTION_ENDS_WITH:
980         case FUNCTION_CONTAINS:
981         case FUNCTION_SUBSTRING_BEFORE:
982         case FUNCTION_SUBSTRING_AFTER:
983         case FUNCTION_SUBSTRING:
984         case FUNCTION_STRING_LENGTH:
985         case FUNCTION_NORMALIZE_SPACE:
986         case FUNCTION_TRANSLATE:
987         case FUNCTION_BOOLEAN:
988         case FUNCTION_NOT:
989         case FUNCTION_TRUE:
990         case FUNCTION_FALSE:
991         case FUNCTION_NULL:
992         case FUNCTION_LANG:
993         case FUNCTION_NUMBER:
994         case FUNCTION_SUM:
995         case FUNCTION_FLOOR:
996         case FUNCTION_CEILING:
997         case FUNCTION_ROUND:
998         case FUNCTION_FORMAT_NUMBER:
999         case NCName:
1000           ex = FunctionCall();
1001           break;
1002         default:
1003           jj_la1[17] = jj_gen;
1004           jj_consume_token(-1);
1005           throw new ParseException();
1006         }
1007       }
1008     }
1009         {if (true) return ex;}
1010     throw new Error("Missing return statement in function");
1011   }
1012 
1013 /*--------------------*/
1014 /* 3.2 Function Calls */
1015 /*--------------------*/
1016 
1017 /* [16]    FunctionCall    ::=    FunctionName '(' ( Argument ( ',' Argument)*)? ')'  */
1018   final public Object FunctionCall() throws ParseException {
1019     Object name;
1020     ArrayList args;
1021     name = FunctionName();
1022     args = ArgumentList();
1023         if (args == null){
1024             {if (true) return compiler.function(name, null);}
1025         }
1026         else {
1027             {if (true) return compiler.function(name, args.toArray());}
1028         }
1029     throw new Error("Missing return statement in function");
1030   }
1031 
1032   final public Object CoreFunctionCall() throws ParseException {
1033     int code = 0;
1034     ArrayList args;
1035     code = CoreFunctionName();
1036     args = ArgumentList();
1037         if (args == null){
1038             {if (true) return compiler.function(code, null);}
1039         }
1040         else {
1041             {if (true) return compiler.function(code, args.toArray());}
1042         }
1043     throw new Error("Missing return statement in function");
1044   }
1045 
1046   final public ArrayList ArgumentList() throws ParseException {
1047     ArrayList args = null;
1048     Object arg;
1049     jj_consume_token(81);
1050     switch (jj_nt.kind) {
1051     case SLASH:
1052     case SLASHSLASH:
1053     case MINUS:
1054     case VARIABLE:
1055     case Literal:
1056     case Number:
1057     case OR:
1058     case AND:
1059     case MOD:
1060     case DIV:
1061     case NODE:
1062     case TEXT:
1063     case COMMENT:
1064     case PI:
1065     case AXIS_SELF:
1066     case AXIS_CHILD:
1067     case AXIS_PARENT:
1068     case AXIS_ANCESTOR:
1069     case AXIS_ATTRIBUTE:
1070     case AXIS_NAMESPACE:
1071     case AXIS_PRECEDING:
1072     case AXIS_FOLLOWING:
1073     case AXIS_DESCENDANT:
1074     case AXIS_ANCESTOR_OR_SELF:
1075     case AXIS_FOLLOWING_SIBLING:
1076     case AXIS_PRECEDING_SIBLING:
1077     case AXIS_DESCENDANT_OR_SELF:
1078     case FUNCTION_LAST:
1079     case FUNCTION_POSITION:
1080     case FUNCTION_COUNT:
1081     case FUNCTION_ID:
1082     case FUNCTION_KEY:
1083     case FUNCTION_LOCAL_NAME:
1084     case FUNCTION_NAMESPACE_URI:
1085     case FUNCTION_NAME:
1086     case FUNCTION_STRING:
1087     case FUNCTION_CONCAT:
1088     case FUNCTION_STARTS_WITH:
1089     case FUNCTION_ENDS_WITH:
1090     case FUNCTION_CONTAINS:
1091     case FUNCTION_SUBSTRING_BEFORE:
1092     case FUNCTION_SUBSTRING_AFTER:
1093     case FUNCTION_SUBSTRING:
1094     case FUNCTION_STRING_LENGTH:
1095     case FUNCTION_NORMALIZE_SPACE:
1096     case FUNCTION_TRANSLATE:
1097     case FUNCTION_BOOLEAN:
1098     case FUNCTION_NOT:
1099     case FUNCTION_TRUE:
1100     case FUNCTION_FALSE:
1101     case FUNCTION_NULL:
1102     case FUNCTION_LANG:
1103     case FUNCTION_NUMBER:
1104     case FUNCTION_SUM:
1105     case FUNCTION_FLOOR:
1106     case FUNCTION_CEILING:
1107     case FUNCTION_ROUND:
1108     case FUNCTION_FORMAT_NUMBER:
1109     case NCName:
1110     case 81:
1111     case 83:
1112     case 84:
1113     case 87:
1114     case 89:
1115       arg = Argument();
1116                                 args = new ArrayList(); args.add(arg);
1117       label_4:
1118       while (true) {
1119         switch (jj_nt.kind) {
1120         case 88:
1121           ;
1122           break;
1123         default:
1124           jj_la1[18] = jj_gen;
1125           break label_4;
1126         }
1127         jj_consume_token(88);
1128         arg = Argument();
1129                                        args.add(arg);
1130       }
1131       break;
1132     default:
1133       jj_la1[19] = jj_gen;
1134       ;
1135     }
1136     jj_consume_token(82);
1137         {if (true) return args;}
1138     throw new Error("Missing return statement in function");
1139   }
1140 
1141 /* [17]    Argument    ::=    Expr */
1142   final public Object Argument() throws ParseException {
1143     Object ex;
1144     ex = Expression();
1145         {if (true) return ex;}
1146     throw new Error("Missing return statement in function");
1147   }
1148 
1149 /*---------------*/
1150 /* 3.3 Node-sets */
1151 /*---------------*/
1152 
1153 /* [18] UnionExpr    ::=    PathExpr | UnionExpr '|' PathExpr */
1154   final public Object UnionExpr() throws ParseException {
1155     Object ex, r;
1156     ArrayList list = null;
1157     ex = PathExpr();
1158     label_5:
1159     while (true) {
1160       switch (jj_nt.kind) {
1161       case UNION:
1162         ;
1163         break;
1164       default:
1165         jj_la1[20] = jj_gen;
1166         break label_5;
1167       }
1168       jj_consume_token(UNION);
1169       r = PathExpr();
1170                 if (list == null){
1171                     list = new ArrayList();
1172                     list.add(ex);
1173                 }
1174                 list.add(r);
1175     }
1176         if (list != null){
1177             ex = compiler.union(list.toArray());
1178         }
1179         {if (true) return ex;}
1180     throw new Error("Missing return statement in function");
1181   }
1182 
1183 /* [19] PathExpr ::= LocationPath | FilterExpr | FilterExpr '/' RelativeLocationPath | FilterExpr '//' RelativeLocationPath  */
1184   final public Object PathExpr() throws ParseException {
1185     Object ex = null;
1186     Object[] steps;
1187     if (jj_2_6(2147483647)) {
1188       ex = FilterExpr();
1189     } else {
1190       switch (jj_nt.kind) {
1191       case SLASH:
1192       case SLASHSLASH:
1193       case OR:
1194       case AND:
1195       case MOD:
1196       case DIV:
1197       case NODE:
1198       case TEXT:
1199       case COMMENT:
1200       case PI:
1201       case AXIS_SELF:
1202       case AXIS_CHILD:
1203       case AXIS_PARENT:
1204       case AXIS_ANCESTOR:
1205       case AXIS_ATTRIBUTE:
1206       case AXIS_NAMESPACE:
1207       case AXIS_PRECEDING:
1208       case AXIS_FOLLOWING:
1209       case AXIS_DESCENDANT:
1210       case AXIS_ANCESTOR_OR_SELF:
1211       case AXIS_FOLLOWING_SIBLING:
1212       case AXIS_PRECEDING_SIBLING:
1213       case AXIS_DESCENDANT_OR_SELF:
1214       case FUNCTION_LAST:
1215       case FUNCTION_POSITION:
1216       case FUNCTION_COUNT:
1217       case FUNCTION_ID:
1218       case FUNCTION_KEY:
1219       case FUNCTION_LOCAL_NAME:
1220       case FUNCTION_NAMESPACE_URI:
1221       case FUNCTION_NAME:
1222       case FUNCTION_STRING:
1223       case FUNCTION_CONCAT:
1224       case FUNCTION_STARTS_WITH:
1225       case FUNCTION_ENDS_WITH:
1226       case FUNCTION_CONTAINS:
1227       case FUNCTION_SUBSTRING_BEFORE:
1228       case FUNCTION_SUBSTRING_AFTER:
1229       case FUNCTION_SUBSTRING:
1230       case FUNCTION_STRING_LENGTH:
1231       case FUNCTION_NORMALIZE_SPACE:
1232       case FUNCTION_TRANSLATE:
1233       case FUNCTION_BOOLEAN:
1234       case FUNCTION_NOT:
1235       case FUNCTION_TRUE:
1236       case FUNCTION_FALSE:
1237       case FUNCTION_NULL:
1238       case FUNCTION_LANG:
1239       case FUNCTION_NUMBER:
1240       case FUNCTION_SUM:
1241       case FUNCTION_FLOOR:
1242       case FUNCTION_CEILING:
1243       case FUNCTION_ROUND:
1244       case FUNCTION_FORMAT_NUMBER:
1245       case NCName:
1246       case 83:
1247       case 84:
1248       case 87:
1249       case 89:
1250         ex = LocationPath();
1251         break;
1252       default:
1253         jj_la1[21] = jj_gen;
1254         jj_consume_token(-1);
1255         throw new ParseException();
1256       }
1257     }
1258         {if (true) return ex;}
1259     throw new Error("Missing return statement in function");
1260   }
1261 
1262 /* [20]    FilterExpr    ::=    PrimaryExpr    | FilterExpr Predicate */
1263   final public Object FilterExpr() throws ParseException {
1264     Object ex, p;
1265     ArrayList ps = new ArrayList();
1266     boolean path = false;
1267     ArrayList steps = new ArrayList();
1268     ex = PrimaryExpr();
1269     label_6:
1270     while (true) {
1271       switch (jj_nt.kind) {
1272       case 85:
1273         ;
1274         break;
1275       default:
1276         jj_la1[22] = jj_gen;
1277         break label_6;
1278       }
1279       p = Predicate();
1280                 path = true;
1281                 ps.add(p);
1282     }
1283     label_7:
1284     while (true) {
1285       switch (jj_nt.kind) {
1286       case SLASH:
1287       case SLASHSLASH:
1288         ;
1289         break;
1290       default:
1291         jj_la1[23] = jj_gen;
1292         break label_7;
1293       }
1294       LocationStep(steps);
1295                 path = true;
1296     }
1297         if (path){
1298             {if (true) return compiler.expressionPath(ex, ps.toArray(), steps.toArray());}
1299         }
1300         else {
1301             {if (true) return ex;}
1302         }
1303     throw new Error("Missing return statement in function");
1304   }
1305 
1306 /*--------------*/
1307 /* 3.4 Booleans */
1308 /*--------------*/
1309 
1310 /* [21] OrExpr    ::=    AndExpr | OrExpr 'or' AndExpr */
1311   final public Object OrExpr() throws ParseException {
1312     Object ex, r;
1313     ArrayList list = null;
1314     ex = AndExpr();
1315     label_8:
1316     while (true) {
1317       switch (jj_nt.kind) {
1318       case OR:
1319         ;
1320         break;
1321       default:
1322         jj_la1[24] = jj_gen;
1323         break label_8;
1324       }
1325       jj_consume_token(OR);
1326       r = AndExpr();
1327                 if (list == null){
1328                     list = new ArrayList();
1329                     list.add(ex);
1330                 }
1331                 list.add(r);
1332     }
1333         if (list != null){
1334             ex = compiler.or(list.toArray());
1335         }
1336         {if (true) return ex;}
1337     throw new Error("Missing return statement in function");
1338   }
1339 
1340 /* [22] AndExpr    ::=    EqualityExpr  | AndExpr 'and' EqualityExpr  */
1341   final public Object AndExpr() throws ParseException {
1342     Object ex, r;
1343     ArrayList list = null;
1344     ex = EqualityExpr();
1345     label_9:
1346     while (true) {
1347       switch (jj_nt.kind) {
1348       case AND:
1349         ;
1350         break;
1351       default:
1352         jj_la1[25] = jj_gen;
1353         break label_9;
1354       }
1355       jj_consume_token(AND);
1356       r = EqualityExpr();
1357                 if (list == null){
1358                     list = new ArrayList();
1359                     list.add(ex);
1360                 }
1361                 list.add(r);
1362     }
1363         if (list != null){
1364             ex = compiler.and(list.toArray());
1365         }
1366         {if (true) return ex;}
1367     throw new Error("Missing return statement in function");
1368   }
1369 
1370 /* [23] EqualityExpr    ::=    RelationalExpr | EqualityExpr '=' RelationalExpr | EqualityExpr '!=' RelationalExpr */
1371   final public Object EqualityExpr() throws ParseException {
1372  Object ex, r;
1373     ex = RelationalExpr();
1374     label_10:
1375     while (true) {
1376       switch (jj_nt.kind) {
1377       case EQ:
1378       case NEQ:
1379         ;
1380         break;
1381       default:
1382         jj_la1[26] = jj_gen;
1383         break label_10;
1384       }
1385       switch (jj_nt.kind) {
1386       case EQ:
1387         jj_consume_token(EQ);
1388         r = RelationalExpr();
1389                                           ex = compiler.equal(ex, r);
1390         break;
1391       case NEQ:
1392         jj_consume_token(NEQ);
1393         r = RelationalExpr();
1394                                           ex = compiler.notEqual(ex, r);
1395         break;
1396       default:
1397         jj_la1[27] = jj_gen;
1398         jj_consume_token(-1);
1399         throw new ParseException();
1400       }
1401     }
1402         {if (true) return ex;}
1403     throw new Error("Missing return statement in function");
1404   }
1405 
1406 /* [24] RelationalExpr    ::=    AdditiveExpr | RelationalExpr '<' AdditiveExpr | RelationalExpr '>' AdditiveExpr
1407                        | RelationalExpr '<=' AdditiveExpr  | RelationalExpr '>=' AdditiveExpr */
1408   final public Object RelationalExpr() throws ParseException {
1409  Object ex, r;
1410     ex = AdditiveExpr();
1411     label_11:
1412     while (true) {
1413       switch (jj_nt.kind) {
1414       case LT:
1415       case LTE:
1416       case GT:
1417       case GTE:
1418         ;
1419         break;
1420       default:
1421         jj_la1[28] = jj_gen;
1422         break label_11;
1423       }
1424       switch (jj_nt.kind) {
1425       case LT:
1426         jj_consume_token(LT);
1427         r = AdditiveExpr();
1428                                         ex = compiler.lessThan(ex, r);
1429         break;
1430       case GT:
1431         jj_consume_token(GT);
1432         r = AdditiveExpr();
1433                                         ex = compiler.greaterThan(ex, r);
1434         break;
1435       case LTE:
1436         jj_consume_token(LTE);
1437         r = AdditiveExpr();
1438                                         ex = compiler.lessThanOrEqual(ex, r);
1439         break;
1440       case GTE:
1441         jj_consume_token(GTE);
1442         r = AdditiveExpr();
1443                                         ex = compiler.greaterThanOrEqual(ex, r);
1444         break;
1445       default:
1446         jj_la1[29] = jj_gen;
1447         jj_consume_token(-1);
1448         throw new ParseException();
1449       }
1450     }
1451         {if (true) return ex;}
1452     throw new Error("Missing return statement in function");
1453   }
1454 
1455 /*-------------*/
1456 /* 3.5 Numbers */
1457 /*-------------*/
1458 
1459 /* [25] AdditiveExpr ::= MultiplicativeExpr  | AdditiveExpr '+' MultiplicativeExpr  | AdditiveExpr '-' MultiplicativeExpr  */
1460   final public Object AdditiveExpr() throws ParseException {
1461     Object ex, r;
1462     ArrayList list = null;
1463     ex = SubtractiveExpr();
1464     label_12:
1465     while (true) {
1466       switch (jj_nt.kind) {
1467       case PLUS:
1468         ;
1469         break;
1470       default:
1471         jj_la1[30] = jj_gen;
1472         break label_12;
1473       }
1474       jj_consume_token(PLUS);
1475       r = SubtractiveExpr();
1476                 if (list == null){
1477                     list = new ArrayList();
1478                     list.add(ex);
1479                 }
1480                 list.add(r);
1481     }
1482         if (list != null){
1483             ex = compiler.sum(list.toArray());
1484         }
1485         {if (true) return ex;}
1486     throw new Error("Missing return statement in function");
1487   }
1488 
1489   final public Object SubtractiveExpr() throws ParseException {
1490     Object ex, r = null;
1491     ex = MultiplicativeExpr();
1492     label_13:
1493     while (true) {
1494       switch (jj_nt.kind) {
1495       case MINUS:
1496         ;
1497         break;
1498       default:
1499         jj_la1[31] = jj_gen;
1500         break label_13;
1501       }
1502       jj_consume_token(MINUS);
1503       r = MultiplicativeExpr();
1504                                                ex = compiler.minus(ex, r);
1505     }
1506         {if (true) return ex;}
1507     throw new Error("Missing return statement in function");
1508   }
1509 
1510 /* [26] MultiplicativeExpr ::= UnaryExpr | MultiplicativeExpr MultiplyOperator UnaryExpr
1511             | MultiplicativeExpr 'div' UnaryExpr | MultiplicativeExpr 'mod' UnaryExpr  */
1512   final public Object MultiplicativeExpr() throws ParseException {
1513     Object ex, r;
1514     ex = UnaryExpr();
1515     label_14:
1516     while (true) {
1517       switch (jj_nt.kind) {
1518       case MOD:
1519       case DIV:
1520       case 89:
1521         ;
1522         break;
1523       default:
1524         jj_la1[32] = jj_gen;
1525         break label_14;
1526       }
1527       switch (jj_nt.kind) {
1528       case 89:
1529         jj_consume_token(89);
1530         r = UnaryExpr();
1531                                     ex = compiler.multiply(ex, r);
1532         break;
1533       case DIV:
1534         jj_consume_token(DIV);
1535         r = UnaryExpr();
1536                                     ex = compiler.divide(ex, r);
1537         break;
1538       case MOD:
1539         jj_consume_token(MOD);
1540         r = UnaryExpr();
1541                                     ex = compiler.mod(ex, r);
1542         break;
1543       default:
1544         jj_la1[33] = jj_gen;
1545         jj_consume_token(-1);
1546         throw new ParseException();
1547       }
1548     }
1549         {if (true) return ex;}
1550     throw new Error("Missing return statement in function");
1551   }
1552 
1553 /* [27]    UnaryExpr    ::=    UnionExpr  | '-' UnaryExpr  */
1554   final public Object UnaryExpr() throws ParseException {
1555     Object ex;
1556     switch (jj_nt.kind) {
1557     case SLASH:
1558     case SLASHSLASH:
1559     case VARIABLE:
1560     case Literal:
1561     case Number:
1562     case OR:
1563     case AND:
1564     case MOD:
1565     case DIV:
1566     case NODE:
1567     case TEXT:
1568     case COMMENT:
1569     case PI:
1570     case AXIS_SELF:
1571     case AXIS_CHILD:
1572     case AXIS_PARENT:
1573     case AXIS_ANCESTOR:
1574     case AXIS_ATTRIBUTE:
1575     case AXIS_NAMESPACE:
1576     case AXIS_PRECEDING:
1577     case AXIS_FOLLOWING:
1578     case AXIS_DESCENDANT:
1579     case AXIS_ANCESTOR_OR_SELF:
1580     case AXIS_FOLLOWING_SIBLING:
1581     case AXIS_PRECEDING_SIBLING:
1582     case AXIS_DESCENDANT_OR_SELF:
1583     case FUNCTION_LAST:
1584     case FUNCTION_POSITION:
1585     case FUNCTION_COUNT:
1586     case FUNCTION_ID:
1587     case FUNCTION_KEY:
1588     case FUNCTION_LOCAL_NAME:
1589     case FUNCTION_NAMESPACE_URI:
1590     case FUNCTION_NAME:
1591     case FUNCTION_STRING:
1592     case FUNCTION_CONCAT:
1593     case FUNCTION_STARTS_WITH:
1594     case FUNCTION_ENDS_WITH:
1595     case FUNCTION_CONTAINS:
1596     case FUNCTION_SUBSTRING_BEFORE:
1597     case FUNCTION_SUBSTRING_AFTER:
1598     case FUNCTION_SUBSTRING:
1599     case FUNCTION_STRING_LENGTH:
1600     case FUNCTION_NORMALIZE_SPACE:
1601     case FUNCTION_TRANSLATE:
1602     case FUNCTION_BOOLEAN:
1603     case FUNCTION_NOT:
1604     case FUNCTION_TRUE:
1605     case FUNCTION_FALSE:
1606     case FUNCTION_NULL:
1607     case FUNCTION_LANG:
1608     case FUNCTION_NUMBER:
1609     case FUNCTION_SUM:
1610     case FUNCTION_FLOOR:
1611     case FUNCTION_CEILING:
1612     case FUNCTION_ROUND:
1613     case FUNCTION_FORMAT_NUMBER:
1614     case NCName:
1615     case 81:
1616     case 83:
1617     case 84:
1618     case 87:
1619     case 89:
1620       ex = UnionExpr();
1621       break;
1622     case MINUS:
1623       jj_consume_token(MINUS);
1624       ex = UnaryExpr();
1625                                     ex = compiler.minus(ex);
1626       break;
1627     default:
1628       jj_la1[34] = jj_gen;
1629       jj_consume_token(-1);
1630       throw new ParseException();
1631     }
1632         {if (true) return ex;}
1633     throw new Error("Missing return statement in function");
1634   }
1635 
1636 /*-------------*/
1637 /* 3.6 Strings */
1638 /*-------------*/
1639 
1640 /*----------------------------------*/
1641 /* 3.7 Expression Lexical Structure */
1642 /*----------------------------------*/
1643 /*
1644 The following special tokenization rules must be applied in the order
1645 specified to disambiguate the grammar:
1646 
1647 1. If there is a preceding token and the preceding token is not one of
1648    @, ::, (, [, , or an Operator,
1649    then a * must be recognized as a MultiplyOperator and an NCName must
1650    be recognized as an OperatorName.
1651 
1652 2. If the character following an NCName (possibly after intervening ExprWhitespace)
1653    is (, then the token must be recognized as a NodeType or a FunctionName.
1654 
1655 3. If the two characters following an NCName (possibly after intervening ExprWhitespace)
1656    are ::, then the token must be recognized as an AxisName.
1657 
1658 4. Otherwise, the token must not be recognized as a MultiplyOperator, an OperatorName,
1659    a NodeType, a FunctionName, or an AxisName.
1660 */
1661 
1662 /*
1663 [28]    ExprToken    ::=    '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
1664    | WildcardName  | NodeType  | Operator  | FunctionName  | AxisName  | Literal
1665    | Number  | VariableReference
1666 */
1667 /* [34]    MultiplyOperator    ::=    '*'  */
1668 
1669 /* [35]    FunctionName    ::=    QName - NodeType   */
1670   final public Object FunctionName() throws ParseException {
1671     Object qname;
1672     qname = QName_Without_CoreFunctions();
1673         {if (true) return qname;}
1674     throw new Error("Missing return statement in function");
1675   }
1676 
1677 /* [36]    VariableReference    ::=    '$' QName  */
1678   final public Object VariableReference() throws ParseException {
1679     Object ex;
1680     jj_consume_token(VARIABLE);
1681     ex = QName();
1682         {if (true) return compiler.variableReference(ex);}
1683     throw new Error("Missing return statement in function");
1684   }
1685 
1686 /* [37]    WildcardName    ::=    '*'     | NCName ':' '*'     | QName  */
1687   final public Object WildcardName() throws ParseException {
1688     Object qn;
1689     String nc1, nc2 = null;
1690     switch (jj_nt.kind) {
1691     case 89:
1692       jj_consume_token(89);
1693       break;
1694     case OR:
1695     case AND:
1696     case MOD:
1697     case DIV:
1698     case NODE:
1699     case TEXT:
1700     case COMMENT:
1701     case PI:
1702     case FUNCTION_LAST:
1703     case FUNCTION_POSITION:
1704     case FUNCTION_COUNT:
1705     case FUNCTION_ID:
1706     case FUNCTION_KEY:
1707     case FUNCTION_LOCAL_NAME:
1708     case FUNCTION_NAMESPACE_URI:
1709     case FUNCTION_NAME:
1710     case FUNCTION_STRING:
1711     case FUNCTION_CONCAT:
1712     case FUNCTION_STARTS_WITH:
1713     case FUNCTION_ENDS_WITH:
1714     case FUNCTION_CONTAINS:
1715     case FUNCTION_SUBSTRING_BEFORE:
1716     case FUNCTION_SUBSTRING_AFTER:
1717     case FUNCTION_SUBSTRING:
1718     case FUNCTION_STRING_LENGTH:
1719     case FUNCTION_NORMALIZE_SPACE:
1720     case FUNCTION_TRANSLATE:
1721     case FUNCTION_BOOLEAN:
1722     case FUNCTION_NOT:
1723     case FUNCTION_TRUE:
1724     case FUNCTION_FALSE:
1725     case FUNCTION_NULL:
1726     case FUNCTION_LANG:
1727     case FUNCTION_NUMBER:
1728     case FUNCTION_SUM:
1729     case FUNCTION_FLOOR:
1730     case FUNCTION_CEILING:
1731     case FUNCTION_ROUND:
1732     case FUNCTION_FORMAT_NUMBER:
1733     case NCName:
1734       NCName();
1735       break;
1736     default:
1737       jj_la1[35] = jj_gen;
1738       jj_consume_token(-1);
1739       throw new ParseException();
1740     }
1741                            nc1 = token.image;
1742     switch (jj_nt.kind) {
1743     case 80:
1744       jj_consume_token(80);
1745       switch (jj_nt.kind) {
1746       case 89:
1747         jj_consume_token(89);
1748         break;
1749       case OR:
1750       case AND:
1751       case MOD:
1752       case DIV:
1753       case NODE:
1754       case TEXT:
1755       case COMMENT:
1756       case PI:
1757       case FUNCTION_LAST:
1758       case FUNCTION_POSITION:
1759       case FUNCTION_COUNT:
1760       case FUNCTION_ID:
1761       case FUNCTION_KEY:
1762       case FUNCTION_LOCAL_NAME:
1763       case FUNCTION_NAMESPACE_URI:
1764       case FUNCTION_NAME:
1765       case FUNCTION_STRING:
1766       case FUNCTION_CONCAT:
1767       case FUNCTION_STARTS_WITH:
1768       case FUNCTION_ENDS_WITH:
1769       case FUNCTION_CONTAINS:
1770       case FUNCTION_SUBSTRING_BEFORE:
1771       case FUNCTION_SUBSTRING_AFTER:
1772       case FUNCTION_SUBSTRING:
1773       case FUNCTION_STRING_LENGTH:
1774       case FUNCTION_NORMALIZE_SPACE:
1775       case FUNCTION_TRANSLATE:
1776       case FUNCTION_BOOLEAN:
1777       case FUNCTION_NOT:
1778       case FUNCTION_TRUE:
1779       case FUNCTION_FALSE:
1780       case FUNCTION_NULL:
1781       case FUNCTION_LANG:
1782       case FUNCTION_NUMBER:
1783       case FUNCTION_SUM:
1784       case FUNCTION_FLOOR:
1785       case FUNCTION_CEILING:
1786       case FUNCTION_ROUND:
1787       case FUNCTION_FORMAT_NUMBER:
1788       case NCName:
1789         NCName();
1790         break;
1791       default:
1792         jj_la1[36] = jj_gen;
1793         jj_consume_token(-1);
1794         throw new ParseException();
1795       }
1796                                nc2 = token.image;
1797       break;
1798     default:
1799       jj_la1[37] = jj_gen;
1800       ;
1801     }
1802         if (nc2 != null){
1803             qn = compiler.qname(nc1, nc2);
1804         }
1805         else {
1806             qn = compiler.qname(null, nc1);
1807         }
1808         {if (true) return qn;}
1809     throw new Error("Missing return statement in function");
1810   }
1811 
1812 /* [38]    NodeType    ::=    'comment' | 'text'  | 'processing-instruction'  | 'node'  */
1813   final public int NodeType() throws ParseException {
1814     int type;
1815     switch (jj_nt.kind) {
1816     case TEXT:
1817       jj_consume_token(TEXT);
1818                       type = Compiler.NODE_TYPE_TEXT;
1819       break;
1820     case NODE:
1821       jj_consume_token(NODE);
1822                       type = Compiler.NODE_TYPE_NODE;
1823       break;
1824     case COMMENT:
1825       jj_consume_token(COMMENT);
1826                       type = Compiler.NODE_TYPE_COMMENT;
1827       break;
1828     case PI:
1829       jj_consume_token(PI);
1830                       type = Compiler.NODE_TYPE_PI;
1831       break;
1832     default:
1833       jj_la1[38] = jj_gen;
1834       jj_consume_token(-1);
1835       throw new ParseException();
1836     }
1837         {if (true) return type;}
1838     throw new Error("Missing return statement in function");
1839   }
1840 
1841   final private boolean jj_2_1(int xla) {
1842     jj_la = xla; jj_lastpos = jj_scanpos = token;
1843     try { return !jj_3_1(); }
1844     catch(LookaheadSuccess ls) { return true; }
1845     finally { jj_save(0, xla); }
1846   }
1847 
1848   final private boolean jj_2_2(int xla) {
1849     jj_la = xla; jj_lastpos = jj_scanpos = token;
1850     try { return !jj_3_2(); }
1851     catch(LookaheadSuccess ls) { return true; }
1852     finally { jj_save(1, xla); }
1853   }
1854 
1855   final private boolean jj_2_3(int xla) {
1856     jj_la = xla; jj_lastpos = jj_scanpos = token;
1857     try { return !jj_3_3(); }
1858     catch(LookaheadSuccess ls) { return true; }
1859     finally { jj_save(2, xla); }
1860   }
1861 
1862   final private boolean jj_2_4(int xla) {
1863     jj_la = xla; jj_lastpos = jj_scanpos = token;
1864     try { return !jj_3_4(); }
1865     catch(LookaheadSuccess ls) { return true; }
1866     finally { jj_save(3, xla); }
1867   }
1868 
1869   final private boolean jj_2_5(int xla) {
1870     jj_la = xla; jj_lastpos = jj_scanpos = token;
1871     try { return !jj_3_5(); }
1872     catch(LookaheadSuccess ls) { return true; }
1873     finally { jj_save(4, xla); }
1874   }
1875 
1876   final private boolean jj_2_6(int xla) {
1877     jj_la = xla; jj_lastpos = jj_scanpos = token;
1878     try { return !jj_3_6(); }
1879     catch(LookaheadSuccess ls) { return true; }
1880     finally { jj_save(5, xla); }
1881   }
1882 
1883   final private boolean jj_3_2() {
1884     if (jj_3R_16()) return true;
1885     return false;
1886   }
1887 
1888   final private boolean jj_3R_144() {
1889     if (jj_3R_16()) return true;
1890     return false;
1891   }
1892 
1893   final private boolean jj_3R_143() {
1894     if (jj_3R_77()) return true;
1895     return false;
1896   }
1897 
1898   final private boolean jj_3R_150() {
1899     if (jj_3R_16()) return true;
1900     Token xsp;
1901     while (true) {
1902       xsp = jj_scanpos;
1903       if (jj_3R_151()) { jj_scanpos = xsp; break; }
1904     }
1905     return false;
1906   }
1907 
1908   final private boolean jj_3R_132() {
1909     if (jj_scan_token(MINUS)) return true;
1910     if (jj_3R_129()) return true;
1911     return false;
1912   }
1913 
1914   final private boolean jj_3R_130() {
1915     Token xsp;
1916     xsp = jj_scanpos;
1917     if (jj_3R_133()) {
1918     jj_scanpos = xsp;
1919     if (jj_3R_134()) {
1920     jj_scanpos = xsp;
1921     if (jj_3R_135()) return true;
1922     }
1923     }
1924     return false;
1925   }
1926 
1927   final private boolean jj_3R_148() {
1928     Token xsp;
1929     xsp = jj_scanpos;
1930     if (jj_3R_150()) {
1931     jj_scanpos = xsp;
1932     if (jj_scan_token(6)) return true;
1933     }
1934     return false;
1935   }
1936 
1937   final private boolean jj_3R_131() {
1938     if (jj_3R_136()) return true;
1939     return false;
1940   }
1941 
1942   final private boolean jj_3R_64() {
1943     Token xsp;
1944     xsp = jj_scanpos;
1945     if (jj_scan_token(79)) {
1946     jj_scanpos = xsp;
1947     if (jj_scan_token(27)) {
1948     jj_scanpos = xsp;
1949     if (jj_scan_token(28)) {
1950     jj_scanpos = xsp;
1951     if (jj_scan_token(29)) {
1952     jj_scanpos = xsp;
1953     if (jj_scan_token(30)) return true;
1954     }
1955     }
1956     }
1957     }
1958     return false;
1959   }
1960 
1961   final private boolean jj_3R_113() {
1962     if (jj_scan_token(87)) return true;
1963     return false;
1964   }
1965 
1966   final private boolean jj_3R_91() {
1967     Token xsp;
1968     xsp = jj_scanpos;
1969     if (jj_3R_113()) jj_scanpos = xsp;
1970     return false;
1971   }
1972 
1973   final private boolean jj_3R_141() {
1974     if (jj_3R_19()) return true;
1975     Token xsp;
1976     while (true) {
1977       xsp = jj_scanpos;
1978       if (jj_3R_143()) { jj_scanpos = xsp; break; }
1979     }
1980     while (true) {
1981       xsp = jj_scanpos;
1982       if (jj_3R_144()) { jj_scanpos = xsp; break; }
1983     }
1984     return false;
1985   }
1986 
1987   final private boolean jj_3R_129() {
1988     Token xsp;
1989     xsp = jj_scanpos;
1990     if (jj_3R_131()) {
1991     jj_scanpos = xsp;
1992     if (jj_3R_132()) return true;
1993     }
1994     return false;
1995   }
1996 
1997   final private boolean jj_3_6() {
1998     if (jj_3R_19()) return true;
1999     return false;
2000   }
2001 
2002   final private boolean jj_3R_146() {
2003     if (jj_3R_148()) return true;
2004     return false;
2005   }
2006 
2007   final private boolean jj_3R_135() {
2008     if (jj_scan_token(MOD)) return true;
2009     if (jj_3R_129()) return true;
2010     return false;
2011   }
2012 
2013   final private boolean jj_3R_145() {
2014     if (jj_3R_147()) return true;
2015     return false;
2016   }
2017 
2018   final private boolean jj_3R_134() {
2019     if (jj_scan_token(DIV)) return true;
2020     if (jj_3R_129()) return true;
2021     return false;
2022   }
2023 
2024   final private boolean jj_3R_133() {
2025     if (jj_scan_token(89)) return true;
2026     if (jj_3R_129()) return true;
2027     return false;
2028   }
2029 
2030   final private boolean jj_3R_142() {
2031     Token xsp;
2032     xsp = jj_scanpos;
2033     if (jj_3R_145()) {
2034     jj_scanpos = xsp;
2035     if (jj_3R_146()) return true;
2036     }
2037     return false;
2038   }
2039 
2040   final private boolean jj_3R_140() {
2041     if (jj_3R_142()) return true;
2042     return false;
2043   }
2044 
2045   final private boolean jj_3R_139() {
2046     if (jj_3R_141()) return true;
2047     return false;
2048   }
2049 
2050   final private boolean jj_3R_77() {
2051     if (jj_scan_token(85)) return true;
2052     if (jj_3R_70()) return true;
2053     if (jj_scan_token(86)) return true;
2054     return false;
2055   }
2056 
2057   final private boolean jj_3R_127() {
2058     if (jj_3R_129()) return true;
2059     Token xsp;
2060     while (true) {
2061       xsp = jj_scanpos;
2062       if (jj_3R_130()) { jj_scanpos = xsp; break; }
2063     }
2064     return false;
2065   }
2066 
2067   final private boolean jj_3R_137() {
2068     Token xsp;
2069     xsp = jj_scanpos;
2070     if (jj_3R_139()) {
2071     jj_scanpos = xsp;
2072     if (jj_3R_140()) return true;
2073     }
2074     return false;
2075   }
2076 
2077   final private boolean jj_3R_128() {
2078     if (jj_scan_token(MINUS)) return true;
2079     if (jj_3R_127()) return true;
2080     return false;
2081   }
2082 
2083   final private boolean jj_3R_112() {
2084     if (jj_scan_token(AXIS_DESCENDANT_OR_SELF)) return true;
2085     return false;
2086   }
2087 
2088   final private boolean jj_3R_111() {
2089     if (jj_scan_token(AXIS_PRECEDING_SIBLING)) return true;
2090     return false;
2091   }
2092 
2093   final private boolean jj_3R_110() {
2094     if (jj_scan_token(AXIS_FOLLOWING_SIBLING)) return true;
2095     return false;
2096   }
2097 
2098   final private boolean jj_3R_122() {
2099     if (jj_scan_token(PLUS)) return true;
2100     if (jj_3R_121()) return true;
2101     return false;
2102   }
2103 
2104   final private boolean jj_3R_109() {
2105     if (jj_scan_token(AXIS_ANCESTOR_OR_SELF)) return true;
2106     return false;
2107   }
2108 
2109   final private boolean jj_3R_108() {
2110     if (jj_scan_token(AXIS_DESCENDANT)) return true;
2111     return false;
2112   }
2113 
2114   final private boolean jj_3R_107() {
2115     if (jj_scan_token(AXIS_FOLLOWING)) return true;
2116     return false;
2117   }
2118 
2119   final private boolean jj_3R_106() {
2120     if (jj_scan_token(AXIS_PRECEDING)) return true;
2121     return false;
2122   }
2123 
2124   final private boolean jj_3R_121() {
2125     if (jj_3R_127()) return true;
2126     Token xsp;
2127     while (true) {
2128       xsp = jj_scanpos;
2129       if (jj_3R_128()) { jj_scanpos = xsp; break; }
2130     }
2131     return false;
2132   }
2133 
2134   final private boolean jj_3R_105() {
2135     if (jj_scan_token(AXIS_NAMESPACE)) return true;
2136     return false;
2137   }
2138 
2139   final private boolean jj_3R_104() {
2140     if (jj_scan_token(AXIS_ATTRIBUTE)) return true;
2141     return false;
2142   }
2143 
2144   final private boolean jj_3R_103() {
2145     if (jj_scan_token(AXIS_ANCESTOR)) return true;
2146     return false;
2147   }
2148 
2149   final private boolean jj_3R_20() {
2150     if (jj_3R_64()) return true;
2151     return false;
2152   }
2153 
2154   final private boolean jj_3R_102() {
2155     if (jj_scan_token(AXIS_PARENT)) return true;
2156     return false;
2157   }
2158 
2159   final private boolean jj_3R_101() {
2160     if (jj_scan_token(AXIS_CHILD)) return true;
2161     return false;
2162   }
2163 
2164   final private boolean jj_3R_100() {
2165     if (jj_scan_token(AXIS_SELF)) return true;
2166     return false;
2167   }
2168 
2169   final private boolean jj_3R_138() {
2170     if (jj_scan_token(UNION)) return true;
2171     if (jj_3R_137()) return true;
2172     return false;
2173   }
2174 
2175   final private boolean jj_3R_15() {
2176     Token xsp;
2177     xsp = jj_scanpos;
2178     if (jj_3R_20()) {
2179     jj_scanpos = xsp;
2180     if (jj_scan_token(31)) {
2181     jj_scanpos = xsp;
2182     if (jj_scan_token(32)) {
2183     jj_scanpos = xsp;
2184     if (jj_scan_token(33)) {
2185     jj_scanpos = xsp;
2186     if (jj_scan_token(34)) {
2187     jj_scanpos = xsp;
2188     if (jj_scan_token(48)) {
2189     jj_scanpos = xsp;
2190     if (jj_scan_token(49)) {
2191     jj_scanpos = xsp;
2192     if (jj_scan_token(50)) {
2193     jj_scanpos = xsp;
2194     if (jj_scan_token(51)) {
2195     jj_scanpos = xsp;
2196     if (jj_scan_token(53)) {
2197     jj_scanpos = xsp;
2198     if (jj_scan_token(54)) {
2199     jj_scanpos = xsp;
2200     if (jj_scan_token(55)) {
2201     jj_scanpos = xsp;
2202     if (jj_scan_token(56)) {
2203     jj_scanpos = xsp;
2204     if (jj_scan_token(57)) {
2205     jj_scanpos = xsp;
2206     if (jj_scan_token(58)) {
2207     jj_scanpos = xsp;
2208     if (jj_scan_token(59)) {
2209     jj_scanpos = xsp;
2210     if (jj_scan_token(60)) {
2211     jj_scanpos = xsp;
2212     if (jj_scan_token(61)) {
2213     jj_scanpos = xsp;
2214     if (jj_scan_token(62)) {
2215     jj_scanpos = xsp;
2216     if (jj_scan_token(63)) {
2217     jj_scanpos = xsp;
2218     if (jj_scan_token(64)) {
2219     jj_scanpos = xsp;
2220     if (jj_scan_token(65)) {
2221     jj_scanpos = xsp;
2222     if (jj_scan_token(66)) {
2223     jj_scanpos = xsp;
2224     if (jj_scan_token(67)) {
2225     jj_scanpos = xsp;
2226     if (jj_scan_token(68)) {
2227     jj_scanpos = xsp;
2228     if (jj_scan_token(69)) {
2229     jj_scanpos = xsp;
2230     if (jj_scan_token(70)) {
2231     jj_scanpos = xsp;
2232     if (jj_scan_token(71)) {
2233     jj_scanpos = xsp;
2234     if (jj_scan_token(72)) {
2235     jj_scanpos = xsp;
2236     if (jj_scan_token(73)) {
2237     jj_scanpos = xsp;
2238     if (jj_scan_token(74)) {
2239     jj_scanpos = xsp;
2240     if (jj_scan_token(75)) {
2241     jj_scanpos = xsp;
2242     if (jj_scan_token(76)) {
2243     jj_scanpos = xsp;
2244     if (jj_scan_token(77)) {
2245     jj_scanpos = xsp;
2246     if (jj_scan_token(52)) {
2247     jj_scanpos = xsp;
2248     if (jj_scan_token(78)) return true;
2249     }
2250     }
2251     }
2252     }
2253     }
2254     }
2255     }
2256     }
2257     }
2258     }
2259     }
2260     }
2261     }
2262     }
2263     }
2264     }
2265     }
2266     }
2267     }
2268     }
2269     }
2270     }
2271     }
2272     }
2273     }
2274     }
2275     }
2276     }
2277     }
2278     }
2279     }
2280     }
2281     }
2282     }
2283     }
2284     return false;
2285   }
2286 
2287   final private boolean jj_3R_90() {
2288     Token xsp;
2289     xsp = jj_scanpos;
2290     if (jj_3R_100()) {
2291     jj_scanpos = xsp;
2292     if (jj_3R_101()) {
2293     jj_scanpos = xsp;
2294     if (jj_3R_102()) {
2295     jj_scanpos = xsp;
2296     if (jj_3R_103()) {
2297     jj_scanpos = xsp;
2298     if (jj_3R_104()) {
2299     jj_scanpos = xsp;
2300     if (jj_3R_105()) {
2301     jj_scanpos = xsp;
2302     if (jj_3R_106()) {
2303     jj_scanpos = xsp;
2304     if (jj_3R_107()) {
2305     jj_scanpos = xsp;
2306     if (jj_3R_108()) {
2307     jj_scanpos = xsp;
2308     if (jj_3R_109()) {
2309     jj_scanpos = xsp;
2310     if (jj_3R_110()) {
2311     jj_scanpos = xsp;
2312     if (jj_3R_111()) {
2313     jj_scanpos = xsp;
2314     if (jj_3R_112()) return true;
2315     }
2316     }
2317     }
2318     }
2319     }
2320     }
2321     }
2322     }
2323     }
2324     }
2325     }
2326     }
2327     return false;
2328   }
2329 
2330   final private boolean jj_3R_136() {
2331     if (jj_3R_137()) return true;
2332     Token xsp;
2333     while (true) {
2334       xsp = jj_scanpos;
2335       if (jj_3R_138()) { jj_scanpos = xsp; break; }
2336     }
2337     return false;
2338   }
2339 
2340   final private boolean jj_3R_118() {
2341     Token xsp;
2342     xsp = jj_scanpos;
2343     if (jj_3R_123()) {
2344     jj_scanpos = xsp;
2345     if (jj_3R_124()) {
2346     jj_scanpos = xsp;
2347     if (jj_3R_125()) {
2348     jj_scanpos = xsp;
2349     if (jj_3R_126()) return true;
2350     }
2351     }
2352     }
2353     return false;
2354   }
2355 
2356   final private boolean jj_3R_117() {
2357     if (jj_3R_121()) return true;
2358     Token xsp;
2359     while (true) {
2360       xsp = jj_scanpos;
2361       if (jj_3R_122()) { jj_scanpos = xsp; break; }
2362     }
2363     return false;
2364   }
2365 
2366   final private boolean jj_3R_83() {
2367     if (jj_3R_91()) return true;
2368     return false;
2369   }
2370 
2371   final private boolean jj_3R_82() {
2372     if (jj_3R_90()) return true;
2373     return false;
2374   }
2375 
2376   final private boolean jj_3R_96() {
2377     if (jj_3R_70()) return true;
2378     return false;
2379   }
2380 
2381   final private boolean jj_3R_126() {
2382     if (jj_scan_token(GTE)) return true;
2383     if (jj_3R_117()) return true;
2384     return false;
2385   }
2386 
2387   final private boolean jj_3R_97() {
2388     if (jj_scan_token(88)) return true;
2389     if (jj_3R_96()) return true;
2390     return false;
2391   }
2392 
2393   final private boolean jj_3R_125() {
2394     if (jj_scan_token(LTE)) return true;
2395     if (jj_3R_117()) return true;
2396     return false;
2397   }
2398 
2399   final private boolean jj_3R_73() {
2400     Token xsp;
2401     xsp = jj_scanpos;
2402     if (jj_3R_82()) {
2403     jj_scanpos = xsp;
2404     if (jj_3R_83()) return true;
2405     }
2406     return false;
2407   }
2408 
2409   final private boolean jj_3R_124() {
2410     if (jj_scan_token(GT)) return true;
2411     if (jj_3R_117()) return true;
2412     return false;
2413   }
2414 
2415   final private boolean jj_3R_116() {
2416     Token xsp;
2417     xsp = jj_scanpos;
2418     if (jj_3R_119()) {
2419     jj_scanpos = xsp;
2420     if (jj_3R_120()) return true;
2421     }
2422     return false;
2423   }
2424 
2425   final private boolean jj_3R_123() {
2426     if (jj_scan_token(LT)) return true;
2427     if (jj_3R_117()) return true;
2428     return false;
2429   }
2430 
2431   final private boolean jj_3R_88() {
2432     if (jj_3R_96()) return true;
2433     Token xsp;
2434     while (true) {
2435       xsp = jj_scanpos;
2436       if (jj_3R_97()) { jj_scanpos = xsp; break; }
2437     }
2438     return false;
2439   }
2440 
2441   final private boolean jj_3R_115() {
2442     if (jj_3R_117()) return true;
2443     Token xsp;
2444     while (true) {
2445       xsp = jj_scanpos;
2446       if (jj_3R_118()) { jj_scanpos = xsp; break; }
2447     }
2448     return false;
2449   }
2450 
2451   final private boolean jj_3R_26() {
2452     if (jj_scan_token(PI)) return true;
2453     return false;
2454   }
2455 
2456   final private boolean jj_3R_80() {
2457     if (jj_scan_token(81)) return true;
2458     Token xsp;
2459     xsp = jj_scanpos;
2460     if (jj_3R_88()) jj_scanpos = xsp;
2461     if (jj_scan_token(82)) return true;
2462     return false;
2463   }
2464 
2465   final private boolean jj_3R_25() {
2466     if (jj_scan_token(COMMENT)) return true;
2467     return false;
2468   }
2469 
2470   final private boolean jj_3R_24() {
2471     if (jj_scan_token(NODE)) return true;
2472     return false;
2473   }
2474 
2475   final private boolean jj_3R_120() {
2476     if (jj_scan_token(NEQ)) return true;
2477     if (jj_3R_115()) return true;
2478     return false;
2479   }
2480 
2481   final private boolean jj_3R_23() {
2482     if (jj_scan_token(TEXT)) return true;
2483     return false;
2484   }
2485 
2486   final private boolean jj_3R_119() {
2487     if (jj_scan_token(EQ)) return true;
2488     if (jj_3R_115()) return true;
2489     return false;
2490   }
2491 
2492   final private boolean jj_3R_68() {
2493     if (jj_3R_77()) return true;
2494     return false;
2495   }
2496 
2497   final private boolean jj_3_1() {
2498     if (jj_3R_15()) return true;
2499     if (jj_scan_token(80)) return true;
2500     return false;
2501   }
2502 
2503   final private boolean jj_3_4() {
2504     if (jj_scan_token(PI)) return true;
2505     return false;
2506   }
2507 
2508   final private boolean jj_3_3() {
2509     if (jj_3R_17()) return true;
2510     if (jj_scan_token(81)) return true;
2511     if (jj_scan_token(82)) return true;
2512     return false;
2513   }
2514 
2515   final private boolean jj_3R_17() {
2516     Token xsp;
2517     xsp = jj_scanpos;
2518     if (jj_3R_23()) {
2519     jj_scanpos = xsp;
2520     if (jj_3R_24()) {
2521     jj_scanpos = xsp;
2522     if (jj_3R_25()) {
2523     jj_scanpos = xsp;
2524     if (jj_3R_26()) return true;
2525     }
2526     }
2527     }
2528     return false;
2529   }
2530 
2531   final private boolean jj_3R_67() {
2532     if (jj_scan_token(84)) return true;
2533     return false;
2534   }
2535 
2536   final private boolean jj_3R_114() {
2537     if (jj_3R_15()) return true;
2538     return false;
2539   }
2540 
2541   final private boolean jj_3R_66() {
2542     if (jj_scan_token(83)) return true;
2543     return false;
2544   }
2545 
2546   final private boolean jj_3R_94() {
2547     if (jj_3R_115()) return true;
2548     Token xsp;
2549     while (true) {
2550       xsp = jj_scanpos;
2551       if (jj_3R_116()) { jj_scanpos = xsp; break; }
2552     }
2553     return false;
2554   }
2555 
2556   final private boolean jj_3R_76() {
2557     if (jj_3R_84()) return true;
2558     return false;
2559   }
2560 
2561   final private boolean jj_3R_99() {
2562     if (jj_3R_64()) return true;
2563     return false;
2564   }
2565 
2566   final private boolean jj_3R_98() {
2567     if (jj_3R_15()) return true;
2568     if (jj_scan_token(80)) return true;
2569     if (jj_3R_15()) return true;
2570     return false;
2571   }
2572 
2573   final private boolean jj_3R_75() {
2574     if (jj_scan_token(PI)) return true;
2575     if (jj_scan_token(81)) return true;
2576     if (jj_scan_token(Literal)) return true;
2577     if (jj_scan_token(82)) return true;
2578     return false;
2579   }
2580 
2581   final private boolean jj_3R_92() {
2582     if (jj_3R_15()) return true;
2583     return false;
2584   }
2585 
2586   final private boolean jj_3R_74() {
2587     if (jj_3R_17()) return true;
2588     if (jj_scan_token(81)) return true;
2589     if (jj_scan_token(82)) return true;
2590     return false;
2591   }
2592 
2593   final private boolean jj_3R_71() {
2594     if (jj_3R_18()) return true;
2595     if (jj_3R_80()) return true;
2596     return false;
2597   }
2598 
2599   final private boolean jj_3R_93() {
2600     if (jj_scan_token(80)) return true;
2601     Token xsp;
2602     xsp = jj_scanpos;
2603     if (jj_scan_token(89)) {
2604     jj_scanpos = xsp;
2605     if (jj_3R_114()) return true;
2606     }
2607     return false;
2608   }
2609 
2610   final private boolean jj_3R_65() {
2611     if (jj_3R_73()) return true;
2612     Token xsp;
2613     xsp = jj_scanpos;
2614     if (jj_3R_74()) {
2615     jj_scanpos = xsp;
2616     if (jj_3R_75()) {
2617     jj_scanpos = xsp;
2618     if (jj_3R_76()) return true;
2619     }
2620     }
2621     return false;
2622   }
2623 
2624   final private boolean jj_3R_85() {
2625     if (jj_scan_token(80)) return true;
2626     if (jj_3R_15()) return true;
2627     return false;
2628   }
2629 
2630   final private boolean jj_3R_89() {
2631     Token xsp;
2632     xsp = jj_scanpos;
2633     if (jj_3R_98()) {
2634     jj_scanpos = xsp;
2635     if (jj_3R_99()) return true;
2636     }
2637     return false;
2638   }
2639 
2640   final private boolean jj_3R_95() {
2641     if (jj_scan_token(AND)) return true;
2642     if (jj_3R_94()) return true;
2643     return false;
2644   }
2645 
2646   final private boolean jj_3R_84() {
2647     Token xsp;
2648     xsp = jj_scanpos;
2649     if (jj_scan_token(89)) {
2650     jj_scanpos = xsp;
2651     if (jj_3R_92()) return true;
2652     }
2653     xsp = jj_scanpos;
2654     if (jj_3R_93()) jj_scanpos = xsp;
2655     return false;
2656   }
2657 
2658   final private boolean jj_3R_22() {
2659     Token xsp;
2660     xsp = jj_scanpos;
2661     if (jj_3R_65()) {
2662     jj_scanpos = xsp;
2663     if (jj_3R_66()) {
2664     jj_scanpos = xsp;
2665     if (jj_3R_67()) return true;
2666     }
2667     }
2668     while (true) {
2669       xsp = jj_scanpos;
2670       if (jj_3R_68()) { jj_scanpos = xsp; break; }
2671     }
2672     return false;
2673   }
2674 
2675   final private boolean jj_3R_72() {
2676     if (jj_3R_81()) return true;
2677     if (jj_3R_80()) return true;
2678     return false;
2679   }
2680 
2681   final private boolean jj_3R_86() {
2682     if (jj_3R_94()) return true;
2683     Token xsp;
2684     while (true) {
2685       xsp = jj_scanpos;
2686       if (jj_3R_95()) { jj_scanpos = xsp; break; }
2687     }
2688     return false;
2689   }
2690 
2691   final private boolean jj_3R_151() {
2692     if (jj_3R_16()) return true;
2693     return false;
2694   }
2695 
2696   final private boolean jj_3_5() {
2697     if (jj_3R_18()) return true;
2698     if (jj_scan_token(81)) return true;
2699     return false;
2700   }
2701 
2702   final private boolean jj_3R_78() {
2703     if (jj_3R_15()) return true;
2704     Token xsp;
2705     xsp = jj_scanpos;
2706     if (jj_3R_85()) jj_scanpos = xsp;
2707     return false;
2708   }
2709 
2710   final private boolean jj_3R_69() {
2711     if (jj_scan_token(VARIABLE)) return true;
2712     if (jj_3R_78()) return true;
2713     return false;
2714   }
2715 
2716   final private boolean jj_3R_57() {
2717     if (jj_scan_token(FUNCTION_FORMAT_NUMBER)) return true;
2718     return false;
2719   }
2720 
2721   final private boolean jj_3R_56() {
2722     if (jj_scan_token(FUNCTION_KEY)) return true;
2723     return false;
2724   }
2725 
2726   final private boolean jj_3R_55() {
2727     if (jj_scan_token(FUNCTION_ROUND)) return true;
2728     return false;
2729   }
2730 
2731   final private boolean jj_3R_63() {
2732     if (jj_3R_72()) return true;
2733     return false;
2734   }
2735 
2736   final private boolean jj_3R_54() {
2737     if (jj_scan_token(FUNCTION_CEILING)) return true;
2738     return false;
2739   }
2740 
2741   final private boolean jj_3R_62() {
2742     if (jj_3R_71()) return true;
2743     return false;
2744   }
2745 
2746   final private boolean jj_3R_53() {
2747     if (jj_scan_token(FUNCTION_FLOOR)) return true;
2748     return false;
2749   }
2750 
2751   final private boolean jj_3R_61() {
2752     if (jj_scan_token(Number)) return true;
2753     return false;
2754   }
2755 
2756   final private boolean jj_3R_52() {
2757     if (jj_scan_token(FUNCTION_SUM)) return true;
2758     return false;
2759   }
2760 
2761   final private boolean jj_3R_21() {
2762     if (jj_scan_token(SLASHSLASH)) return true;
2763     return false;
2764   }
2765 
2766   final private boolean jj_3R_60() {
2767     if (jj_scan_token(Literal)) return true;
2768     return false;
2769   }
2770 
2771   final private boolean jj_3R_51() {
2772     if (jj_scan_token(FUNCTION_NUMBER)) return true;
2773     return false;
2774   }
2775 
2776   final private boolean jj_3R_59() {
2777     if (jj_scan_token(81)) return true;
2778     if (jj_3R_70()) return true;
2779     if (jj_scan_token(82)) return true;
2780     return false;
2781   }
2782 
2783   final private boolean jj_3R_87() {
2784     if (jj_scan_token(OR)) return true;
2785     if (jj_3R_86()) return true;
2786     return false;
2787   }
2788 
2789   final private boolean jj_3R_50() {
2790     if (jj_scan_token(FUNCTION_LANG)) return true;
2791     return false;
2792   }
2793 
2794   final private boolean jj_3R_58() {
2795     if (jj_3R_69()) return true;
2796     return false;
2797   }
2798 
2799   final private boolean jj_3R_81() {
2800     if (jj_3R_89()) return true;
2801     return false;
2802   }
2803 
2804   final private boolean jj_3R_49() {
2805     if (jj_scan_token(FUNCTION_NULL)) return true;
2806     return false;
2807   }
2808 
2809   final private boolean jj_3R_48() {
2810     if (jj_scan_token(FUNCTION_FALSE)) return true;
2811     return false;
2812   }
2813 
2814   final private boolean jj_3R_47() {
2815     if (jj_scan_token(FUNCTION_TRUE)) return true;
2816     return false;
2817   }
2818 
2819   final private boolean jj_3R_46() {
2820     if (jj_scan_token(FUNCTION_NOT)) return true;
2821     return false;
2822   }
2823 
2824   final private boolean jj_3R_16() {
2825     Token xsp;
2826     xsp = jj_scanpos;
2827     if (jj_scan_token(6)) {
2828     jj_scanpos = xsp;
2829     if (jj_3R_21()) return true;
2830     }
2831     if (jj_3R_22()) return true;
2832     return false;
2833   }
2834 
2835   final private boolean jj_3R_149() {
2836     if (jj_3R_16()) return true;
2837     return false;
2838   }
2839 
2840   final private boolean jj_3R_45() {
2841     if (jj_scan_token(FUNCTION_BOOLEAN)) return true;
2842     return false;
2843   }
2844 
2845   final private boolean jj_3R_44() {
2846     if (jj_scan_token(FUNCTION_TRANSLATE)) return true;
2847     return false;
2848   }
2849 
2850   final private boolean jj_3R_19() {
2851     Token xsp;
2852     xsp = jj_scanpos;
2853     if (jj_3R_58()) {
2854     jj_scanpos = xsp;
2855     if (jj_3R_59()) {
2856     jj_scanpos = xsp;
2857     if (jj_3R_60()) {
2858     jj_scanpos = xsp;
2859     if (jj_3R_61()) {
2860     jj_scanpos = xsp;
2861     if (jj_3R_62()) {
2862     jj_scanpos = xsp;
2863     if (jj_3R_63()) return true;
2864     }
2865     }
2866     }
2867     }
2868     }
2869     return false;
2870   }
2871 
2872   final private boolean jj_3R_43() {
2873     if (jj_scan_token(FUNCTION_NORMALIZE_SPACE)) return true;
2874     return false;
2875   }
2876 
2877   final private boolean jj_3R_42() {
2878     if (jj_scan_token(FUNCTION_STRING_LENGTH)) return true;
2879     return false;
2880   }
2881 
2882   final private boolean jj_3R_41() {
2883     if (jj_scan_token(FUNCTION_SUBSTRING)) return true;
2884     return false;
2885   }
2886 
2887   final private boolean jj_3R_40() {
2888     if (jj_scan_token(FUNCTION_SUBSTRING_AFTER)) return true;
2889     return false;
2890   }
2891 
2892   final private boolean jj_3R_79() {
2893     if (jj_3R_86()) return true;
2894     Token xsp;
2895     while (true) {
2896       xsp = jj_scanpos;
2897       if (jj_3R_87()) { jj_scanpos = xsp; break; }
2898     }
2899     return false;
2900   }
2901 
2902   final private boolean jj_3R_39() {
2903     if (jj_scan_token(FUNCTION_SUBSTRING_BEFORE)) return true;
2904     return false;
2905   }
2906 
2907   final private boolean jj_3R_38() {
2908     if (jj_scan_token(FUNCTION_CONTAINS)) return true;
2909     return false;
2910   }
2911 
2912   final private boolean jj_3R_37() {
2913     if (jj_scan_token(FUNCTION_ENDS_WITH)) return true;
2914     return false;
2915   }
2916 
2917   final private boolean jj_3R_36() {
2918     if (jj_scan_token(FUNCTION_STARTS_WITH)) return true;
2919     return false;
2920   }
2921 
2922   final private boolean jj_3R_35() {
2923     if (jj_scan_token(FUNCTION_CONCAT)) return true;
2924     return false;
2925   }
2926 
2927   final private boolean jj_3R_34() {
2928     if (jj_scan_token(FUNCTION_STRING)) return true;
2929     return false;
2930   }
2931 
2932   final private boolean jj_3R_33() {
2933     if (jj_scan_token(FUNCTION_NAME)) return true;
2934     return false;
2935   }
2936 
2937   final private boolean jj_3R_32() {
2938     if (jj_scan_token(FUNCTION_NAMESPACE_URI)) return true;
2939     return false;
2940   }
2941 
2942   final private boolean jj_3R_31() {
2943     if (jj_scan_token(FUNCTION_LOCAL_NAME)) return true;
2944     return false;
2945   }
2946 
2947   final private boolean jj_3R_70() {
2948     if (jj_3R_79()) return true;
2949     return false;
2950   }
2951 
2952   final private boolean jj_3R_30() {
2953     if (jj_scan_token(FUNCTION_ID)) return true;
2954     return false;
2955   }
2956 
2957   final private boolean jj_3R_29() {
2958     if (jj_scan_token(FUNCTION_COUNT)) return true;
2959     return false;
2960   }
2961 
2962   final private boolean jj_3R_28() {
2963     if (jj_scan_token(FUNCTION_POSITION)) return true;
2964     return false;
2965   }
2966 
2967   final private boolean jj_3R_27() {
2968     if (jj_scan_token(FUNCTION_LAST)) return true;
2969     return false;
2970   }
2971 
2972   final private boolean jj_3R_147() {
2973     if (jj_3R_22()) return true;
2974     Token xsp;
2975     while (true) {
2976       xsp = jj_scanpos;
2977       if (jj_3R_149()) { jj_scanpos = xsp; break; }
2978     }
2979     return false;
2980   }
2981 
2982   final private boolean jj_3R_18() {
2983     Token xsp;
2984     xsp = jj_scanpos;
2985     if (jj_3R_27()) {
2986     jj_scanpos = xsp;
2987     if (jj_3R_28()) {
2988     jj_scanpos = xsp;
2989     if (jj_3R_29()) {
2990     jj_scanpos = xsp;
2991     if (jj_3R_30()) {
2992     jj_scanpos = xsp;
2993     if (jj_3R_31()) {
2994     jj_scanpos = xsp;
2995     if (jj_3R_32()) {
2996     jj_scanpos = xsp;
2997     if (jj_3R_33()) {
2998     jj_scanpos = xsp;
2999     if (jj_3R_34()) {
3000     jj_scanpos = xsp;
3001     if (jj_3R_35()) {
3002     jj_scanpos = xsp;
3003     if (jj_3R_36()) {
3004     jj_scanpos = xsp;
3005     if (jj_3R_37()) {
3006     jj_scanpos = xsp;
3007     if (jj_3R_38()) {
3008     jj_scanpos = xsp;
3009     if (jj_3R_39()) {
3010     jj_scanpos = xsp;
3011     if (jj_3R_40()) {
3012     jj_scanpos = xsp;
3013     if (jj_3R_41()) {
3014     jj_scanpos = xsp;
3015     if (jj_3R_42()) {
3016     jj_scanpos = xsp;
3017     if (jj_3R_43()) {
3018     jj_scanpos = xsp;
3019     if (jj_3R_44()) {
3020     jj_scanpos = xsp;
3021     if (jj_3R_45()) {
3022     jj_scanpos = xsp;
3023     if (jj_3R_46()) {
3024     jj_scanpos = xsp;
3025     if (jj_3R_47()) {
3026     jj_scanpos = xsp;
3027     if (jj_3R_48()) {
3028     jj_scanpos = xsp;
3029     if (jj_3R_49()) {
3030     jj_scanpos = xsp;
3031     if (jj_3R_50()) {
3032     jj_scanpos = xsp;
3033     if (jj_3R_51()) {
3034     jj_scanpos = xsp;
3035     if (jj_3R_52()) {
3036     jj_scanpos = xsp;
3037     if (jj_3R_53()) {
3038     jj_scanpos = xsp;
3039     if (jj_3R_54()) {
3040     jj_scanpos = xsp;
3041     if (jj_3R_55()) {
3042     jj_scanpos = xsp;
3043     if (jj_3R_56()) {
3044     jj_scanpos = xsp;
3045     if (jj_3R_57()) return true;
3046     }
3047     }
3048     }
3049     }
3050     }
3051     }
3052     }
3053     }
3054     }
3055     }
3056     }
3057     }
3058     }
3059     }
3060     }
3061     }
3062     }
3063     }
3064     }
3065     }
3066     }
3067     }
3068     }
3069     }
3070     }
3071     }
3072     }
3073     }
3074     }
3075     }
3076     return false;
3077   }
3078 
3079   public XPathParserTokenManager token_source;
3080   SimpleCharStream jj_input_stream;
3081   public Token token, jj_nt;
3082   private Token jj_scanpos, jj_lastpos;
3083   private int jj_la;
3084   public boolean lookingAhead = false;
3085   private boolean jj_semLA;
3086   private int jj_gen;
3087   final private int[] jj_la1 = new int[39];
3088   static private int[] jj_la1_0;
3089   static private int[] jj_la1_1;
3090   static private int[] jj_la1_2;
3091   static {
3092       jj_la1_0();
3093       jj_la1_1();
3094       jj_la1_2();
3095    }
3096    private static void jj_la1_0() {
3097       jj_la1_0 = new int[] {0xf8000000,0x78000000,0x0,0x0,0x78000000,0xf80000c0,0xc0,0x40,0xc0,0xc0,0xf8000000,0xf8000000,0x0,0x0,0x0,0x0,0x160000,0xf8000000,0x0,0xf81604c0,0x100,0xf80000c0,0x0,0xc0,0x8000000,0x10000000,0x1800,0x1800,0x1e000,0x1e000,0x200,0x400,0x60000000,0x60000000,0xf81604c0,0xf8000000,0xf8000000,0x0,0x80000000,};
3098    }
3099    private static void jj_la1_1() {
3100       jj_la1_1 = new int[] {0xffff0007,0x0,0xffff0000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffff0007,0xffffffff,0x0,0xfff8,0xfff8,0x0,0x0,0xffff0007,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffff0007,0xffff0007,0x0,0x7,};
3101    }
3102    private static void jj_la1_2() {
3103       jj_la1_2 = new int[] {0xffff,0x8000,0x7fff,0x10000,0x8000,0x298ffff,0x0,0x0,0x0,0x0,0x200ffff,0x298ffff,0x200000,0x0,0x0,0x800000,0x20000,0xffff,0x1000000,0x29affff,0x0,0x298ffff,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x29affff,0x200ffff,0x200ffff,0x10000,0x0,};
3104    }
3105   final private JJCalls[] jj_2_rtns = new JJCalls[6];
3106   private boolean jj_rescan = false;
3107   private int jj_gc = 0;
3108 
3109   public XPathParser(java.io.InputStream stream) {
3110     jj_input_stream = new SimpleCharStream(stream, 1, 1);
3111     token_source = new XPathParserTokenManager(jj_input_stream);
3112     token = new Token();
3113     token.next = jj_nt = token_source.getNextToken();
3114     jj_gen = 0;
3115     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
3116     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3117   }
3118 
3119   public void ReInit(java.io.InputStream stream) {
3120     jj_input_stream.ReInit(stream, 1, 1);
3121     token_source.ReInit(jj_input_stream);
3122     token = new Token();
3123     token.next = jj_nt = token_source.getNextToken();
3124     jj_gen = 0;
3125     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
3126     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3127   }
3128 
3129   public XPathParser(java.io.Reader stream) {
3130     jj_input_stream = new SimpleCharStream(stream, 1, 1);
3131     token_source = new XPathParserTokenManager(jj_input_stream);
3132     token = new Token();
3133     token.next = jj_nt = token_source.getNextToken();
3134     jj_gen = 0;
3135     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
3136     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3137   }
3138 
3139   public void ReInit(java.io.Reader stream) {
3140     jj_input_stream.ReInit(stream, 1, 1);
3141     token_source.ReInit(jj_input_stream);
3142     token = new Token();
3143     token.next = jj_nt = token_source.getNextToken();
3144     jj_gen = 0;
3145     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
3146     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3147   }
3148 
3149   public XPathParser(XPathParserTokenManager tm) {
3150     token_source = tm;
3151     token = new Token();
3152     token.next = jj_nt = token_source.getNextToken();
3153     jj_gen = 0;
3154     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
3155     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3156   }
3157 
3158   public void ReInit(XPathParserTokenManager tm) {
3159     token_source = tm;
3160     token = new Token();
3161     token.next = jj_nt = token_source.getNextToken();
3162     jj_gen = 0;
3163     for (int i = 0; i < 39; i++) jj_la1[i] = -1;
3164     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3165   }
3166 
3167   final private Token jj_consume_token(int kind) throws ParseException {
3168     Token oldToken = token;
3169     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
3170     else jj_nt = jj_nt.next = token_source.getNextToken();
3171     if (token.kind == kind) {
3172       jj_gen++;
3173       if (++jj_gc > 100) {
3174         jj_gc = 0;
3175         for (int i = 0; i < jj_2_rtns.length; i++) {
3176           JJCalls c = jj_2_rtns[i];
3177           while (c != null) {
3178             if (c.gen < jj_gen) c.first = null;
3179             c = c.next;
3180           }
3181         }
3182       }
3183       return token;
3184     }
3185     jj_nt = token;
3186     token = oldToken;
3187     jj_kind = kind;
3188     throw generateParseException();
3189   }
3190 
3191   static private final class LookaheadSuccess extends java.lang.Error { }
3192   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3193   final private boolean jj_scan_token(int kind) {
3194     if (jj_scanpos == jj_lastpos) {
3195       jj_la--;
3196       if (jj_scanpos.next == null) {
3197         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3198       } else {
3199         jj_lastpos = jj_scanpos = jj_scanpos.next;
3200       }
3201     } else {
3202       jj_scanpos = jj_scanpos.next;
3203     }
3204     if (jj_rescan) {
3205       int i = 0; Token tok = token;
3206       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3207       if (tok != null) jj_add_error_token(kind, i);
3208     }
3209     if (jj_scanpos.kind != kind) return true;
3210     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3211     return false;
3212   }
3213 
3214   final public Token getNextToken() {
3215     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
3216     else jj_nt = jj_nt.next = token_source.getNextToken();
3217     jj_gen++;
3218     return token;
3219   }
3220 
3221   final public Token getToken(int index) {
3222     Token t = lookingAhead ? jj_scanpos : token;
3223     for (int i = 0; i < index; i++) {
3224       if (t.next != null) t = t.next;
3225       else t = t.next = token_source.getNextToken();
3226     }
3227     return t;
3228   }
3229 
3230   private java.util.Vector jj_expentries = new java.util.Vector();
3231   private int[] jj_expentry;
3232   private int jj_kind = -1;
3233   private int[] jj_lasttokens = new int[100];
3234   private int jj_endpos;
3235 
3236   private void jj_add_error_token(int kind, int pos) {
3237     if (pos >= 100) return;
3238     if (pos == jj_endpos + 1) {
3239       jj_lasttokens[jj_endpos++] = kind;
3240     } else if (jj_endpos != 0) {
3241       jj_expentry = new int[jj_endpos];
3242       for (int i = 0; i < jj_endpos; i++) {
3243         jj_expentry[i] = jj_lasttokens[i];
3244       }
3245       boolean exists = false;
3246       for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
3247         int[] oldentry = (int[])(e.nextElement());
3248         if (oldentry.length == jj_expentry.length) {
3249           exists = true;
3250           for (int i = 0; i < jj_expentry.length; i++) {
3251             if (oldentry[i] != jj_expentry[i]) {
3252               exists = false;
3253               break;
3254             }
3255           }
3256           if (exists) break;
3257         }
3258       }
3259       if (!exists) jj_expentries.addElement(jj_expentry);
3260       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3261     }
3262   }
3263 
3264   public ParseException generateParseException() {
3265     jj_expentries.removeAllElements();
3266     boolean[] la1tokens = new boolean[90];
3267     for (int i = 0; i < 90; i++) {
3268       la1tokens[i] = false;
3269     }
3270     if (jj_kind >= 0) {
3271       la1tokens[jj_kind] = true;
3272       jj_kind = -1;
3273     }
3274     for (int i = 0; i < 39; i++) {
3275       if (jj_la1[i] == jj_gen) {
3276         for (int j = 0; j < 32; j++) {
3277           if ((jj_la1_0[i] & (1<<j)) != 0) {
3278             la1tokens[j] = true;
3279           }
3280           if ((jj_la1_1[i] & (1<<j)) != 0) {
3281             la1tokens[32+j] = true;
3282           }
3283           if ((jj_la1_2[i] & (1<<j)) != 0) {
3284             la1tokens[64+j] = true;
3285           }
3286         }
3287       }
3288     }
3289     for (int i = 0; i < 90; i++) {
3290       if (la1tokens[i]) {
3291         jj_expentry = new int[1];
3292         jj_expentry[0] = i;
3293         jj_expentries.addElement(jj_expentry);
3294       }
3295     }
3296     jj_endpos = 0;
3297     jj_rescan_token();
3298     jj_add_error_token(0, 0);
3299     int[][] exptokseq = new int[jj_expentries.size()][];
3300     for (int i = 0; i < jj_expentries.size(); i++) {
3301       exptokseq[i] = (int[])jj_expentries.elementAt(i);
3302     }
3303     return new ParseException(token, exptokseq, tokenImage);
3304   }
3305 
3306   final public void enable_tracing() {
3307   }
3308 
3309   final public void disable_tracing() {
3310   }
3311 
3312   final private void jj_rescan_token() {
3313     jj_rescan = true;
3314     for (int i = 0; i < 6; i++) {
3315       JJCalls p = jj_2_rtns[i];
3316       do {
3317         if (p.gen > jj_gen) {
3318           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3319           switch (i) {
3320             case 0: jj_3_1(); break;
3321             case 1: jj_3_2(); break;
3322             case 2: jj_3_3(); break;
3323             case 3: jj_3_4(); break;
3324             case 4: jj_3_5(); break;
3325             case 5: jj_3_6(); break;
3326           }
3327         }
3328         p = p.next;
3329       } while (p != null);
3330     }
3331     jj_rescan = false;
3332   }
3333 
3334   final private void jj_save(int index, int xla) {
3335     JJCalls p = jj_2_rtns[index];
3336     while (p.gen > jj_gen) {
3337       if (p.next == null) { p = p.next = new JJCalls(); break; }
3338       p = p.next;
3339     }
3340     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3341   }
3342 
3343   static final class JJCalls {
3344     int gen;
3345     Token first;
3346     int arg;
3347     JJCalls next;
3348   }
3349 
3350     }