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_CONTAINS:

  81.       jj_consume_token(FUNCTION_CONTAINS);

  82.       break;

  83.     case FUNCTION_SUBSTRING_BEFORE:

  84.       jj_consume_token(FUNCTION_SUBSTRING_BEFORE);

  85.       break;

  86.     case FUNCTION_SUBSTRING_AFTER:

  87.       jj_consume_token(FUNCTION_SUBSTRING_AFTER);

  88.       break;

  89.     case FUNCTION_SUBSTRING:

  90.       jj_consume_token(FUNCTION_SUBSTRING);

  91.       break;

  92.     case FUNCTION_STRING_LENGTH:

  93.       jj_consume_token(FUNCTION_STRING_LENGTH);

  94.       break;

  95.     case FUNCTION_NORMALIZE_SPACE:

  96.       jj_consume_token(FUNCTION_NORMALIZE_SPACE);

  97.       break;

  98.     case FUNCTION_TRANSLATE:

  99.       jj_consume_token(FUNCTION_TRANSLATE);

  100.       break;

  101.     case FUNCTION_BOOLEAN:

  102.       jj_consume_token(FUNCTION_BOOLEAN);

  103.       break;

  104.     case FUNCTION_NOT:

  105.       jj_consume_token(FUNCTION_NOT);

  106.       break;

  107.     case FUNCTION_TRUE:

  108.       jj_consume_token(FUNCTION_TRUE);

  109.       break;

  110.     case FUNCTION_FALSE:

  111.       jj_consume_token(FUNCTION_FALSE);

  112.       break;

  113.     case FUNCTION_NULL:

  114.       jj_consume_token(FUNCTION_NULL);

  115.       break;

  116.     case FUNCTION_LANG:

  117.       jj_consume_token(FUNCTION_LANG);

  118.       break;

  119.     case FUNCTION_NUMBER:

  120.       jj_consume_token(FUNCTION_NUMBER);

  121.       break;

  122.     case FUNCTION_SUM:

  123.       jj_consume_token(FUNCTION_SUM);

  124.       break;

  125.     case FUNCTION_FLOOR:

  126.       jj_consume_token(FUNCTION_FLOOR);

  127.       break;

  128.     case FUNCTION_CEILING:

  129.       jj_consume_token(FUNCTION_CEILING);

  130.       break;

  131.     case FUNCTION_ROUND:

  132.       jj_consume_token(FUNCTION_ROUND);

  133.       break;

  134.     case FUNCTION_KEY:

  135.       jj_consume_token(FUNCTION_KEY);

  136.       break;

  137.     case FUNCTION_FORMAT_NUMBER:

  138.       jj_consume_token(FUNCTION_FORMAT_NUMBER);

  139.       break;

  140.     default:

  141.       jj_la1[0] = jj_gen;

  142.       jj_consume_token(-1);

  143.       throw new ParseException();

  144.     }

  145.         {if (true) return token.image;}

  146.     throw new Error("Missing return statement in function");

  147.   }

  148. 

  149.   final public String NCName_Without_CoreFunctions() throws ParseException {

  150.     switch (jj_nt.kind) {

  151.     case NCName:

  152.       jj_consume_token(NCName);

  153.       break;

  154.     case OR:

  155.       jj_consume_token(OR);

  156.       break;

  157.     case AND:

  158.       jj_consume_token(AND);

  159.       break;

  160.     case MOD:

  161.       jj_consume_token(MOD);

  162.       break;

  163.     case DIV:

  164.       jj_consume_token(DIV);

  165.       break;

  166.     default:

  167.       jj_la1[1] = jj_gen;

  168.       jj_consume_token(-1);

  169.       throw new ParseException();

  170.     }

  171.         {if (true) return token.image;}

  172.     throw new Error("Missing return statement in function");

  173.   }

  174. 

  175.   final public int CoreFunctionName() throws ParseException {

  176.     int code;

  177.     switch (jj_nt.kind) {

  178.     case FUNCTION_LAST:

  179.       jj_consume_token(FUNCTION_LAST);

  180.                                       code = Compiler.FUNCTION_LAST;

  181.       break;

  182.     case FUNCTION_POSITION:

  183.       jj_consume_token(FUNCTION_POSITION);

  184.                                       code = Compiler.FUNCTION_POSITION;

  185.       break;

  186.     case FUNCTION_COUNT:

  187.       jj_consume_token(FUNCTION_COUNT);

  188.                                       code = Compiler.FUNCTION_COUNT;

  189.       break;

  190.     case FUNCTION_ID:

  191.       jj_consume_token(FUNCTION_ID);

  192.                                       code = Compiler.FUNCTION_ID;

  193.       break;

  194.     case FUNCTION_LOCAL_NAME:

  195.       jj_consume_token(FUNCTION_LOCAL_NAME);

  196.                                       code = Compiler.FUNCTION_LOCAL_NAME;

  197.       break;

  198.     case FUNCTION_NAMESPACE_URI:

  199.       jj_consume_token(FUNCTION_NAMESPACE_URI);

  200.                                       code = Compiler.FUNCTION_NAMESPACE_URI;

  201.       break;

  202.     case FUNCTION_NAME:

  203.       jj_consume_token(FUNCTION_NAME);

  204.                                       code = Compiler.FUNCTION_NAME;

  205.       break;

  206.     case FUNCTION_STRING:

  207.       jj_consume_token(FUNCTION_STRING);

  208.                                       code = Compiler.FUNCTION_STRING;

  209.       break;

  210.     case FUNCTION_CONCAT:

  211.       jj_consume_token(FUNCTION_CONCAT);

  212.                                       code = Compiler.FUNCTION_CONCAT;

  213.       break;

  214.     case FUNCTION_STARTS_WITH:

  215.       jj_consume_token(FUNCTION_STARTS_WITH);

  216.                                       code = Compiler.FUNCTION_STARTS_WITH;

  217.       break;

  218.     case FUNCTION_CONTAINS:

  219.       jj_consume_token(FUNCTION_CONTAINS);

  220.                                       code = Compiler.FUNCTION_CONTAINS;

  221.       break;

  222.     case FUNCTION_SUBSTRING_BEFORE:

  223.       jj_consume_token(FUNCTION_SUBSTRING_BEFORE);

  224.                                       code = Compiler.FUNCTION_SUBSTRING_BEFORE;

  225.       break;

  226.     case FUNCTION_SUBSTRING_AFTER:

  227.       jj_consume_token(FUNCTION_SUBSTRING_AFTER);

  228.                                       code = Compiler.FUNCTION_SUBSTRING_AFTER;

  229.       break;

  230.     case FUNCTION_SUBSTRING:

  231.       jj_consume_token(FUNCTION_SUBSTRING);

  232.                                       code = Compiler.FUNCTION_SUBSTRING;

  233.       break;

  234.     case FUNCTION_STRING_LENGTH:

  235.       jj_consume_token(FUNCTION_STRING_LENGTH);

  236.                                       code = Compiler.FUNCTION_STRING_LENGTH;

  237.       break;

  238.     case FUNCTION_NORMALIZE_SPACE:

  239.       jj_consume_token(FUNCTION_NORMALIZE_SPACE);

  240.                                       code = Compiler.FUNCTION_NORMALIZE_SPACE;

  241.       break;

  242.     case FUNCTION_TRANSLATE:

  243.       jj_consume_token(FUNCTION_TRANSLATE);

  244.                                       code = Compiler.FUNCTION_TRANSLATE;

  245.       break;

  246.     case FUNCTION_BOOLEAN:

  247.       jj_consume_token(FUNCTION_BOOLEAN);

  248.                                       code = Compiler.FUNCTION_BOOLEAN;

  249.       break;

  250.     case FUNCTION_NOT:

  251.       jj_consume_token(FUNCTION_NOT);

  252.                                       code = Compiler.FUNCTION_NOT;

  253.       break;

  254.     case FUNCTION_TRUE:

  255.       jj_consume_token(FUNCTION_TRUE);

  256.                                       code = Compiler.FUNCTION_TRUE;

  257.       break;

  258.     case FUNCTION_FALSE:

  259.       jj_consume_token(FUNCTION_FALSE);

  260.                                       code = Compiler.FUNCTION_FALSE;

  261.       break;

  262.     case FUNCTION_NULL:

  263.       jj_consume_token(FUNCTION_NULL);

  264.                                       code = Compiler.FUNCTION_NULL;

  265.       break;

  266.     case FUNCTION_LANG:

  267.       jj_consume_token(FUNCTION_LANG);

  268.                                       code = Compiler.FUNCTION_LANG;

  269.       break;

  270.     case FUNCTION_NUMBER:

  271.       jj_consume_token(FUNCTION_NUMBER);

  272.                                       code = Compiler.FUNCTION_NUMBER;

  273.       break;

  274.     case FUNCTION_SUM:

  275.       jj_consume_token(FUNCTION_SUM);

  276.                                       code = Compiler.FUNCTION_SUM;

  277.       break;

  278.     case FUNCTION_FLOOR:

  279.       jj_consume_token(FUNCTION_FLOOR);

  280.                                       code = Compiler.FUNCTION_FLOOR;

  281.       break;

  282.     case FUNCTION_CEILING:

  283.       jj_consume_token(FUNCTION_CEILING);

  284.                                       code = Compiler.FUNCTION_CEILING;

  285.       break;

  286.     case FUNCTION_ROUND:

  287.       jj_consume_token(FUNCTION_ROUND);

  288.                                       code = Compiler.FUNCTION_ROUND;

  289.       break;

  290.     case FUNCTION_KEY:

  291.       jj_consume_token(FUNCTION_KEY);

  292.                                       code = Compiler.FUNCTION_KEY;

  293.       break;

  294.     case FUNCTION_FORMAT_NUMBER:

  295.       jj_consume_token(FUNCTION_FORMAT_NUMBER);

  296.                                       code = Compiler.FUNCTION_FORMAT_NUMBER;

  297.       break;

  298.     default:

  299.       jj_la1[2] = jj_gen;

  300.       jj_consume_token(-1);

  301.       throw new ParseException();

  302.     }

  303.         {if (true) return code;}

  304.     throw new Error("Missing return statement in function");

  305.   }

  306. 

  307.   final public Object QName() throws ParseException {

  308.  String nc1, nc2 = null;

  309.     nc1 = NCName();

  310.     switch (jj_nt.kind) {

  311.     case 79:

  312.       jj_consume_token(79);

  313.       nc2 = NCName();

  314.       break;

  315.     default:

  316.       jj_la1[3] = jj_gen;

  317.       ;

  318.     }

  319.         if (nc2 == null){

  320.             {if (true) return compiler.qname(null, nc1);}

  321.         }

  322.         else {

  323.             {if (true) return compiler.qname(nc1, nc2);}

  324.         }

  325.     throw new Error("Missing return statement in function");

  326.   }

  327. 

  328.   final public Object QName_Without_CoreFunctions() throws ParseException {

  329.     String nc1, nc2 = null;

  330.     if (jj_2_1(2147483647)) {

  331.       nc1 = NCName();

  332.       jj_consume_token(79);

  333.       nc2 = NCName();

  334.     } else {

  335.       switch (jj_nt.kind) {

  336.       case OR:

  337.       case AND:

  338.       case MOD:

  339.       case DIV:

  340.       case NCName:

  341.         nc1 = NCName_Without_CoreFunctions();

  342.         break;

  343.       default:

  344.         jj_la1[4] = jj_gen;

  345.         jj_consume_token(-1);

  346.         throw new ParseException();

  347.       }

  348.     }

  349.         if (nc2 == null){

  350.             {if (true) return compiler.qname(null, nc1);}

  351.         }

  352.         else {

  353.             {if (true) return compiler.qname(nc1, nc2);}

  354.         }

  355.     throw new Error("Missing return statement in function");

  356.   }

  357. 

  358.   final public Object parseExpression() throws ParseException {

  359.     Object ex;

  360.     ex = Expression();

  361.     jj_consume_token(0);

  362.         {if (true) return ex;}

  363.     throw new Error("Missing return statement in function");

  364.   }

  365. 

  366. /* ################################################################################### */

  367. /* XSLT Patterns (http://www.w3.org/1999/08/WD-xslt-19990813)                          */

  368. /* ################################################################################### */

  369. 

  370. /* [XSLT1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern  */

  371. 

  372. //void Pattern() :

  373. //{}

  374. //{

  375. //        LocationPathPattern() ( <UNION> LocationPathPattern() )* <EOF>

  376. //}

  377. //

  378. //

  379. ///* [XSLT2] LocationPathPattern ::=

  380. //   '/' RelativePathPattern? | IdKeyPattern (('/' | '//' RelativePathPattern)? | '//'? RelativePathPattern

  381. //*/

  382. //

  383. //void LocationPathPattern() :

  384. //{}

  385. //{

  386. //        <SLASH> ( RelativePathPattern() )?

  387. //    |    (

  388. //        LOOKAHEAD(IdKeyPattern())

  389. //            IdKeyPattern() ( ( <SLASH> | <SLASHSLASH>) RelativePathPattern() )?

  390. //        |    ( <SLASHSLASH> )? RelativePathPattern()

  391. //        )

  392. //}

  393. //

  394. //

  395. //

  396. ///* [XSLT3] IdKeyPattern    ::=    'id' '(' Literal ')' | 'key' '(' Literal ',' Literal ')'  */

  397. //

  398. //void IdKeyPattern() :

  399. //{}

  400. //{

  401. //        <ID> "(" <Literal> ")"

  402. //    |    <KEY>  "(" <Literal> "," <Literal> ")"

  403. //}

  404. //

  405. //

  406. ///* [XSLT4] RelativePathPattern    ::=    StepPattern | RelativePathPattern '/' StepPattern

  407. //                           | RelativePathPattern '//' StepPattern

  408. //*/

  409. //void RelativePathPattern() :

  410. //{}

  411. //{

  412. //        StepPattern() ( ( <SLASH>| <SLASHSLASH> ) StepPattern()    )*

  413. //}

  414. //

  415. //

  416. ///* [XSLT5]    StepPattern    ::=    AbbreviatedAxisSpecifier NodeTest Predicate*   */

  417. //void StepPattern() :

  418. //{}

  419. //{

  420. //        AbbreviatedAxisSpecifier() NodeTest() (Predicate())*

  421. //}

  422. 

  423. 

  424. 

  425. // See XPath Syntax (http://www.w3.org/TR/xpath )

  426. 

  427. 

  428. //void XPath() :

  429. //{}

  430. //{

  431. //    LocationPath()

  432. //    <EOF>

  433. //}

  434. 

  435. 

  436. /* [1] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath  */

  437.   final public Object LocationPath() throws ParseException {

  438.  Object ex = null;

  439.     switch (jj_nt.kind) {

  440.     case OR:

  441.     case AND:

  442.     case MOD:

  443.     case DIV:

  444.     case NODE:

  445.     case TEXT:

  446.     case COMMENT:

  447.     case PI:

  448.     case AXIS_SELF:

  449.     case AXIS_CHILD:

  450.     case AXIS_PARENT:

  451.     case AXIS_ANCESTOR:

  452.     case AXIS_ATTRIBUTE:

  453.     case AXIS_NAMESPACE:

  454.     case AXIS_PRECEDING:

  455.     case AXIS_FOLLOWING:

  456.     case AXIS_DESCENDANT:

  457.     case AXIS_ANCESTOR_OR_SELF:

  458.     case AXIS_FOLLOWING_SIBLING:

  459.     case AXIS_PRECEDING_SIBLING:

  460.     case AXIS_DESCENDANT_OR_SELF:

  461.     case FUNCTION_LAST:

  462.     case FUNCTION_POSITION:

  463.     case FUNCTION_COUNT:

  464.     case FUNCTION_ID:

  465.     case FUNCTION_KEY:

  466.     case FUNCTION_LOCAL_NAME:

  467.     case FUNCTION_NAMESPACE_URI:

  468.     case FUNCTION_NAME:

  469.     case FUNCTION_STRING:

  470.     case FUNCTION_CONCAT:

  471.     case FUNCTION_STARTS_WITH:

  472.     case FUNCTION_CONTAINS:

  473.     case FUNCTION_SUBSTRING_BEFORE:

  474.     case FUNCTION_SUBSTRING_AFTER:

  475.     case FUNCTION_SUBSTRING:

  476.     case FUNCTION_STRING_LENGTH:

  477.     case FUNCTION_NORMALIZE_SPACE:

  478.     case FUNCTION_TRANSLATE:

  479.     case FUNCTION_BOOLEAN:

  480.     case FUNCTION_NOT:

  481.     case FUNCTION_TRUE:

  482.     case FUNCTION_FALSE:

  483.     case FUNCTION_NULL:

  484.     case FUNCTION_LANG:

  485.     case FUNCTION_NUMBER:

  486.     case FUNCTION_SUM:

  487.     case FUNCTION_FLOOR:

  488.     case FUNCTION_CEILING:

  489.     case FUNCTION_ROUND:

  490.     case FUNCTION_FORMAT_NUMBER:

  491.     case NCName:

  492.     case 82:

  493.     case 83:

  494.     case 86:

  495.     case 88:

  496.       ex = RelativeLocationPath();

  497.       break;

  498.     case SLASH:

  499.     case SLASHSLASH:

  500.       ex = AbsoluteLocationPath();

  501.       break;

  502.     default:

  503.       jj_la1[5] = jj_gen;

  504.       jj_consume_token(-1);

  505.       throw new ParseException();

  506.     }

  507.         {if (true) return ex;}

  508.     throw new Error("Missing return statement in function");

  509.   }

  510. 

  511. /* [2] AbsoluteLocationPath ::= '/' RelativeLocationPath? | AbbreviatedAbsoluteLocationPath  */

  512. /* [10]    AbbreviatedAbsoluteLocationPath    ::=    '//' RelativeLocationPath  */

  513.   final public Object AbsoluteLocationPath() throws ParseException {

  514.     ArrayList steps = new ArrayList();

  515.     if (jj_2_2(2147483647)) {

  516.       LocationStep(steps);

  517.       label_1:

  518.       while (true) {

  519.         switch (jj_nt.kind) {

  520.         case SLASH:

  521.         case SLASHSLASH:

  522.           ;

  523.           break;

  524.         default:

  525.           jj_la1[6] = jj_gen;

  526.           break label_1;

  527.         }

  528.         LocationStep(steps);

  529.       }

  530.     } else {

  531.       switch (jj_nt.kind) {

  532.       case SLASH:

  533.         jj_consume_token(SLASH);

  534.         break;

  535.       default:

  536.         jj_la1[7] = jj_gen;

  537.         jj_consume_token(-1);

  538.         throw new ParseException();

  539.       }

  540.     }

  541.         {if (true) return compiler.locationPath(true, steps.toArray());}

  542.     throw new Error("Missing return statement in function");

  543.   }

  544. 

  545. /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */

  546.   final public Object RelativeLocationPath() throws ParseException {

  547.     ArrayList steps = new ArrayList();

  548.     NodeTest(steps);

  549.     label_2:

  550.     while (true) {

  551.       switch (jj_nt.kind) {

  552.       case SLASH:

  553.       case SLASHSLASH:

  554.         ;

  555.         break;

  556.       default:

  557.         jj_la1[8] = jj_gen;

  558.         break label_2;

  559.       }

  560.       LocationStep(steps);

  561.     }

  562.         {if (true) return compiler.locationPath(false, steps.toArray());}

  563.     throw new Error("Missing return statement in function");

  564.   }

  565. 

  566. /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */

  567. /* [11]    AbbreviatedRelativeLocationPath    ::=    RelativeLocationPath '//' Step  */

  568. 

  569. 

  570. /*--------------------*/

  571. /* 2.1 Location Steps */

  572. /*--------------------*/

  573. 

  574. /* [4] Step ::= AxisSpecifier NodeTest Predicate*   | AbbreviatedStep  */

  575.   final public void LocationStep(ArrayList steps) throws ParseException {

  576.     Object t;

  577.     Object s;

  578.     switch (jj_nt.kind) {

  579.     case SLASH:

  580.       jj_consume_token(SLASH);

  581.       break;

  582.     case SLASHSLASH:

  583.       jj_consume_token(SLASHSLASH);

  584.             // Abbreviated step: descendant-or-self::node()

  585.             t = compiler.nodeTypeTest(Compiler.NODE_TYPE_NODE);

  586.             steps.add(compiler.step(Compiler.AXIS_DESCENDANT_OR_SELF, t, null));

  587.       break;

  588.     default:

  589.       jj_la1[9] = jj_gen;

  590.       jj_consume_token(-1);

  591.       throw new ParseException();

  592.     }

  593.     NodeTest(steps);

  594.   }

  595. 

  596. /* [7] NodeTest ::= WildcardName | NodeType '(' ')' | 'processing-instruction' '(' Literal ')' */

  597.   final public void NodeTest(ArrayList steps) throws ParseException {

  598.     int axis;

  599.     int type = -1;

  600.     String instruction = null;

  601.     Object name = null;

  602.     Object s;

  603.     Object p;

  604.     ArrayList ps = new ArrayList();

  605.     switch (jj_nt.kind) {

  606.     case OR:

  607.     case AND:

  608.     case MOD:

  609.     case DIV:

  610.     case NODE:

  611.     case TEXT:

  612.     case COMMENT:

  613.     case PI:

  614.     case AXIS_SELF:

  615.     case AXIS_CHILD:

  616.     case AXIS_PARENT:

  617.     case AXIS_ANCESTOR:

  618.     case AXIS_ATTRIBUTE:

  619.     case AXIS_NAMESPACE:

  620.     case AXIS_PRECEDING:

  621.     case AXIS_FOLLOWING:

  622.     case AXIS_DESCENDANT:

  623.     case AXIS_ANCESTOR_OR_SELF:

  624.     case AXIS_FOLLOWING_SIBLING:

  625.     case AXIS_PRECEDING_SIBLING:

  626.     case AXIS_DESCENDANT_OR_SELF:

  627.     case FUNCTION_LAST:

  628.     case FUNCTION_POSITION:

  629.     case FUNCTION_COUNT:

  630.     case FUNCTION_ID:

  631.     case FUNCTION_KEY:

  632.     case FUNCTION_LOCAL_NAME:

  633.     case FUNCTION_NAMESPACE_URI:

  634.     case FUNCTION_NAME:

  635.     case FUNCTION_STRING:

  636.     case FUNCTION_CONCAT:

  637.     case FUNCTION_STARTS_WITH:

  638.     case FUNCTION_CONTAINS:

  639.     case FUNCTION_SUBSTRING_BEFORE:

  640.     case FUNCTION_SUBSTRING_AFTER:

  641.     case FUNCTION_SUBSTRING:

  642.     case FUNCTION_STRING_LENGTH:

  643.     case FUNCTION_NORMALIZE_SPACE:

  644.     case FUNCTION_TRANSLATE:

  645.     case FUNCTION_BOOLEAN:

  646.     case FUNCTION_NOT:

  647.     case FUNCTION_TRUE:

  648.     case FUNCTION_FALSE:

  649.     case FUNCTION_NULL:

  650.     case FUNCTION_LANG:

  651.     case FUNCTION_NUMBER:

  652.     case FUNCTION_SUM:

  653.     case FUNCTION_FLOOR:

  654.     case FUNCTION_CEILING:

  655.     case FUNCTION_ROUND:

  656.     case FUNCTION_FORMAT_NUMBER:

  657.     case NCName:

  658.     case 86:

  659.     case 88:

  660.       axis = AxisSpecifier();

  661.       if (jj_2_3(2147483647)) {

  662.         type = NodeType();

  663.         jj_consume_token(80);

  664.         jj_consume_token(81);

  665.       } else if (jj_2_4(2147483647)) {

  666.         jj_consume_token(PI);

  667.         jj_consume_token(80);

  668.         jj_consume_token(Literal);

  669.                     instruction = unescape(token.image.substring(1, token.image.length() - 1));

  670.         jj_consume_token(81);

  671.       } else {

  672.         switch (jj_nt.kind) {

  673.         case OR:

  674.         case AND:

  675.         case MOD:

  676.         case DIV:

  677.         case NODE:

  678.         case TEXT:

  679.         case COMMENT:

  680.         case PI:

  681.         case FUNCTION_LAST:

  682.         case FUNCTION_POSITION:

  683.         case FUNCTION_COUNT:

  684.         case FUNCTION_ID:

  685.         case FUNCTION_KEY:

  686.         case FUNCTION_LOCAL_NAME:

  687.         case FUNCTION_NAMESPACE_URI:

  688.         case FUNCTION_NAME:

  689.         case FUNCTION_STRING:

  690.         case FUNCTION_CONCAT:

  691.         case FUNCTION_STARTS_WITH:

  692.         case FUNCTION_CONTAINS:

  693.         case FUNCTION_SUBSTRING_BEFORE:

  694.         case FUNCTION_SUBSTRING_AFTER:

  695.         case FUNCTION_SUBSTRING:

  696.         case FUNCTION_STRING_LENGTH:

  697.         case FUNCTION_NORMALIZE_SPACE:

  698.         case FUNCTION_TRANSLATE:

  699.         case FUNCTION_BOOLEAN:

  700.         case FUNCTION_NOT:

  701.         case FUNCTION_TRUE:

  702.         case FUNCTION_FALSE:

  703.         case FUNCTION_NULL:

  704.         case FUNCTION_LANG:

  705.         case FUNCTION_NUMBER:

  706.         case FUNCTION_SUM:

  707.         case FUNCTION_FLOOR:

  708.         case FUNCTION_CEILING:

  709.         case FUNCTION_ROUND:

  710.         case FUNCTION_FORMAT_NUMBER:

  711.         case NCName:

  712.         case 88:

  713.           name = WildcardName();

  714.           break;

  715.         default:

  716.           jj_la1[10] = jj_gen;

  717.           jj_consume_token(-1);

  718.           throw new ParseException();

  719.         }

  720.       }

  721.       break;

  722.     case 82:

  723.       jj_consume_token(82);

  724.                     axis = Compiler.AXIS_SELF;

  725.                     type = Compiler.NODE_TYPE_NODE;

  726.       break;

  727.     case 83:

  728.       jj_consume_token(83);

  729.                     axis = Compiler.AXIS_PARENT;

  730.                     type = Compiler.NODE_TYPE_NODE;

  731.       break;

  732.     default:

  733.       jj_la1[11] = jj_gen;

  734.       jj_consume_token(-1);

  735.       throw new ParseException();

  736.     }

  737.     label_3:

  738.     while (true) {

  739.       switch (jj_nt.kind) {

  740.       case 84:

  741.         ;

  742.         break;

  743.       default:

  744.         jj_la1[12] = jj_gen;

  745.         break label_3;

  746.       }

  747.       p = Predicate();

  748.                 ps.add(p);

  749.     }

  750.         if (name != null){

  751.             s = compiler.nodeNameTest(name);

  752.         }

  753.         else if (instruction != null){

  754.             s = compiler.processingInstructionTest(instruction);

  755.         }

  756.         else {

  757.             s = compiler.nodeTypeTest(type);

  758.         }

  759.         steps.add(compiler.step(axis, s, ps.toArray()));

  760.   }

  761. 

  762. /* [5] AxisSpecifier ::=    AxisName '::' | AbbreviatedAxisSpecifier  */

  763.   final public int AxisSpecifier() throws ParseException {

  764.     int axis;

  765.     switch (jj_nt.kind) {

  766.     case AXIS_SELF:

  767.     case AXIS_CHILD:

  768.     case AXIS_PARENT:

  769.     case AXIS_ANCESTOR:

  770.     case AXIS_ATTRIBUTE:

  771.     case AXIS_NAMESPACE:

  772.     case AXIS_PRECEDING:

  773.     case AXIS_FOLLOWING:

  774.     case AXIS_DESCENDANT:

  775.     case AXIS_ANCESTOR_OR_SELF:

  776.     case AXIS_FOLLOWING_SIBLING:

  777.     case AXIS_PRECEDING_SIBLING:

  778.     case AXIS_DESCENDANT_OR_SELF:

  779.       axis = AxisName();

  780.       break;

  781.     default:

  782.       jj_la1[13] = jj_gen;

  783.       axis = AbbreviatedAxisSpecifier();

  784.     }

  785.         {if (true) return axis;}

  786.     throw new Error("Missing return statement in function");

  787.   }

  788. 

  789. /*----------*/

  790. /* 2.2 Axes */

  791. /*----------*/

  792. 

  793. /* [6] AxisName ::= 'ancestor' | 'ancestor-or-self' | 'attribute'  | 'child' | 'descendant'

  794.                     | 'descendant-or-self' | 'following' | 'following-sibling' | 'namespace'

  795.                        | 'parent' | 'preceding' | 'preceding-sibling' | 'self'

  796. */

  797.   final public int AxisName() throws ParseException {

  798.     int axis = 0;

  799.     switch (jj_nt.kind) {

  800.     case AXIS_SELF:

  801.       jj_consume_token(AXIS_SELF);

  802.                                           axis = Compiler.AXIS_SELF;

  803.       break;

  804.     case AXIS_CHILD:

  805.       jj_consume_token(AXIS_CHILD);

  806.                                           axis = Compiler.AXIS_CHILD;

  807.       break;

  808.     case AXIS_PARENT:

  809.       jj_consume_token(AXIS_PARENT);

  810.                                           axis = Compiler.AXIS_PARENT;

  811.       break;

  812.     case AXIS_ANCESTOR:

  813.       jj_consume_token(AXIS_ANCESTOR);

  814.                                           axis = Compiler.AXIS_ANCESTOR;

  815.       break;

  816.     case AXIS_ATTRIBUTE:

  817.       jj_consume_token(AXIS_ATTRIBUTE);

  818.                                           axis = Compiler.AXIS_ATTRIBUTE;

  819.       break;

  820.     case AXIS_NAMESPACE:

  821.       jj_consume_token(AXIS_NAMESPACE);

  822.                                           axis = Compiler.AXIS_NAMESPACE;

  823.       break;

  824.     case AXIS_PRECEDING:

  825.       jj_consume_token(AXIS_PRECEDING);

  826.                                           axis = Compiler.AXIS_PRECEDING;

  827.       break;

  828.     case AXIS_FOLLOWING:

  829.       jj_consume_token(AXIS_FOLLOWING);

  830.                                           axis = Compiler.AXIS_FOLLOWING;

  831.       break;

  832.     case AXIS_DESCENDANT:

  833.       jj_consume_token(AXIS_DESCENDANT);

  834.                                           axis = Compiler.AXIS_DESCENDANT;

  835.       break;

  836.     case AXIS_ANCESTOR_OR_SELF:

  837.       jj_consume_token(AXIS_ANCESTOR_OR_SELF);

  838.                                           axis = Compiler.AXIS_ANCESTOR_OR_SELF;

  839.       break;

  840.     case AXIS_FOLLOWING_SIBLING:

  841.       jj_consume_token(AXIS_FOLLOWING_SIBLING);

  842.                                           axis = Compiler.AXIS_FOLLOWING_SIBLING;

  843.       break;

  844.     case AXIS_PRECEDING_SIBLING:

  845.       jj_consume_token(AXIS_PRECEDING_SIBLING);

  846.                                           axis = Compiler.AXIS_PRECEDING_SIBLING;

  847.       break;

  848.     case AXIS_DESCENDANT_OR_SELF:

  849.       jj_consume_token(AXIS_DESCENDANT_OR_SELF);

  850.                                           axis = Compiler.AXIS_DESCENDANT_OR_SELF;

  851.       break;

  852.     default:

  853.       jj_la1[14] = jj_gen;

  854.       jj_consume_token(-1);

  855.       throw new ParseException();

  856.     }

  857.         {if (true) return axis;}

  858.     throw new Error("Missing return statement in function");

  859.   }

  860. 

  861. /*----------------*/

  862. /* 2.3 Node Tests */

  863. /*----------------*/

  864. 

  865. /*----------------*/

  866. /* 2.4 Predicates */

  867. /*----------------*/

  868. 

  869. /* [8] Predicate ::= '[' PredicateExpr ']'  */

  870. /* [9] PredicateExpr ::=  Expr  */

  871.   final public Object Predicate() throws ParseException {

  872.     Object ex;

  873.     jj_consume_token(84);

  874.     ex = Expression();

  875.     jj_consume_token(85);

  876.         {if (true) return ex;}

  877.     throw new Error("Missing return statement in function");

  878.   }

  879. 

  880. /* [12]    AbbreviatedStep    ::=    '.'  | '..'  */

  881. 

  882. /* [13]    AbbreviatedAxisSpecifier    ::=    '@'? */

  883.   final public int AbbreviatedAxisSpecifier() throws ParseException {

  884.     int axis = Compiler.AXIS_CHILD;

  885.     switch (jj_nt.kind) {

  886.     case 86:

  887.       jj_consume_token(86);

  888.            axis = Compiler.AXIS_ATTRIBUTE;

  889.       break;

  890.     default:

  891.       jj_la1[15] = jj_gen;

  892.       ;

  893.     }

  894.         {if (true) return axis;}

  895.     throw new Error("Missing return statement in function");

  896.   }

  897. 

  898. /*---------------*/

  899. /* 3 Expressions */

  900. /*---------------*/

  901. 

  902. /*------------*/

  903. /* 3.1 Basics */

  904. /*------------*/

  905. 

  906. /*

  907. The effect of the grammar is that the order of precedence is (lowest precedence first):

  908.     or

  909.     and

  910.     =, !=

  911.     <=, <, >=, >

  912. and all operators are left associative.

  913. For example, 3 > 2 > 1 is equivalent to (3 > 2) > 1, which evaluates to false.

  914. */

  915. 

  916. /* [14] Expr ::= OrExpr */

  917.   final public Object Expression() throws ParseException {

  918.  Object ex;

  919.     ex = OrExpr();

  920.         {if (true) return ex;}

  921.     throw new Error("Missing return statement in function");

  922.   }

  923. 

  924. /* [15] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall */

  925.   final public Object PrimaryExpr() throws ParseException {

  926.     Object ex = null;

  927.     switch (jj_nt.kind) {

  928.     case VARIABLE:

  929.       ex = VariableReference();

  930.       break;

  931.     case 80:

  932.       jj_consume_token(80);

  933.       ex = Expression();

  934.       jj_consume_token(81);

  935.       break;

  936.     case Literal:

  937.       jj_consume_token(Literal);

  938.                       ex = compiler.literal(unescape(token.image.substring(1, token.image.length() - 1)));

  939.       break;

  940.     case Number:

  941.       jj_consume_token(Number);

  942.                       ex = compiler.number(token.image);

  943.       break;

  944.     default:

  945.       jj_la1[16] = jj_gen;

  946.       if (jj_2_5(2147483647)) {

  947.         ex = CoreFunctionCall();

  948.       } else {

  949.         switch (jj_nt.kind) {

  950.         case OR:

  951.         case AND:

  952.         case MOD:

  953.         case DIV:

  954.         case NODE:

  955.         case TEXT:

  956.         case COMMENT:

  957.         case PI:

  958.         case FUNCTION_LAST:

  959.         case FUNCTION_POSITION:

  960.         case FUNCTION_COUNT:

  961.         case FUNCTION_ID:

  962.         case FUNCTION_KEY:

  963.         case FUNCTION_LOCAL_NAME:

  964.         case FUNCTION_NAMESPACE_URI:

  965.         case FUNCTION_NAME:

  966.         case FUNCTION_STRING:

  967.         case FUNCTION_CONCAT:

  968.         case FUNCTION_STARTS_WITH:

  969.         case FUNCTION_CONTAINS:

  970.         case FUNCTION_SUBSTRING_BEFORE:

  971.         case FUNCTION_SUBSTRING_AFTER:

  972.         case FUNCTION_SUBSTRING:

  973.         case FUNCTION_STRING_LENGTH:

  974.         case FUNCTION_NORMALIZE_SPACE:

  975.         case FUNCTION_TRANSLATE:

  976.         case FUNCTION_BOOLEAN:

  977.         case FUNCTION_NOT:

  978.         case FUNCTION_TRUE:

  979.         case FUNCTION_FALSE:

  980.         case FUNCTION_NULL:

  981.         case FUNCTION_LANG:

  982.         case FUNCTION_NUMBER:

  983.         case FUNCTION_SUM:

  984.         case FUNCTION_FLOOR:

  985.         case FUNCTION_CEILING:

  986.         case FUNCTION_ROUND:

  987.         case FUNCTION_FORMAT_NUMBER:

  988.         case NCName:

  989.           ex = FunctionCall();

  990.           break;

  991.         default:

  992.           jj_la1[17] = jj_gen;

  993.           jj_consume_token(-1);

  994.           throw new ParseException();

  995.         }

  996.       }

  997.     }

  998.         {if (true) return ex;}

  999.     throw new Error("Missing return statement in function");

  1000.   }

  1001. 

  1002. /*--------------------*/

  1003. /* 3.2 Function Calls */

  1004. /*--------------------*/

  1005. 

  1006. /* [16]    FunctionCall    ::=    FunctionName '(' ( Argument ( ',' Argument)*)? ')'  */

  1007.   final public Object FunctionCall() throws ParseException {

  1008.     Object name;

  1009.     ArrayList args;

  1010.     name = FunctionName();

  1011.     args = ArgumentList();

  1012.         if (args == null){

  1013.             {if (true) return compiler.function(name, null);}

  1014.         }

  1015.         else {

  1016.             {if (true) return compiler.function(name, args.toArray());}

  1017.         }

  1018.     throw new Error("Missing return statement in function");

  1019.   }

  1020. 

  1021.   final public Object CoreFunctionCall() throws ParseException {

  1022.     int code = 0;

  1023.     ArrayList args;

  1024.     code = CoreFunctionName();

  1025.     args = ArgumentList();

  1026.         if (args == null){

  1027.             {if (true) return compiler.function(code, null);}

  1028.         }

  1029.         else {

  1030.             {if (true) return compiler.function(code, args.toArray());}

  1031.         }

  1032.     throw new Error("Missing return statement in function");

  1033.   }

  1034. 

  1035.   final public ArrayList ArgumentList() throws ParseException {

  1036.     ArrayList args = null;

  1037.     Object arg;

  1038.     jj_consume_token(80);

  1039.     switch (jj_nt.kind) {

  1040.     case SLASH:

  1041.     case SLASHSLASH:

  1042.     case MINUS:

  1043.     case VARIABLE:

  1044.     case Literal:

  1045.     case Number:

  1046.     case OR:

  1047.     case AND:

  1048.     case MOD:

  1049.     case DIV:

  1050.     case NODE:

  1051.     case TEXT:

  1052.     case COMMENT:

  1053.     case PI:

  1054.     case AXIS_SELF:

  1055.     case AXIS_CHILD:

  1056.     case AXIS_PARENT:

  1057.     case AXIS_ANCESTOR:

  1058.     case AXIS_ATTRIBUTE:

  1059.     case AXIS_NAMESPACE:

  1060.     case AXIS_PRECEDING:

  1061.     case AXIS_FOLLOWING:

  1062.     case AXIS_DESCENDANT:

  1063.     case AXIS_ANCESTOR_OR_SELF:

  1064.     case AXIS_FOLLOWING_SIBLING:

  1065.     case AXIS_PRECEDING_SIBLING:

  1066.     case AXIS_DESCENDANT_OR_SELF:

  1067.     case FUNCTION_LAST:

  1068.     case FUNCTION_POSITION:

  1069.     case FUNCTION_COUNT:

  1070.     case FUNCTION_ID:

  1071.     case FUNCTION_KEY:

  1072.     case FUNCTION_LOCAL_NAME:

  1073.     case FUNCTION_NAMESPACE_URI:

  1074.     case FUNCTION_NAME:

  1075.     case FUNCTION_STRING:

  1076.     case FUNCTION_CONCAT:

  1077.     case FUNCTION_STARTS_WITH:

  1078.     case FUNCTION_CONTAINS:

  1079.     case FUNCTION_SUBSTRING_BEFORE:

  1080.     case FUNCTION_SUBSTRING_AFTER:

  1081.     case FUNCTION_SUBSTRING:

  1082.     case FUNCTION_STRING_LENGTH:

  1083.     case FUNCTION_NORMALIZE_SPACE:

  1084.     case FUNCTION_TRANSLATE:

  1085.     case FUNCTION_BOOLEAN:

  1086.     case FUNCTION_NOT:

  1087.     case FUNCTION_TRUE:

  1088.     case FUNCTION_FALSE:

  1089.     case FUNCTION_NULL:

  1090.     case FUNCTION_LANG:

  1091.     case FUNCTION_NUMBER:

  1092.     case FUNCTION_SUM:

  1093.     case FUNCTION_FLOOR:

  1094.     case FUNCTION_CEILING:

  1095.     case FUNCTION_ROUND:

  1096.     case FUNCTION_FORMAT_NUMBER:

  1097.     case NCName:

  1098.     case 80:

  1099.     case 82:

  1100.     case 83:

  1101.     case 86:

  1102.     case 88:

  1103.       arg = Argument();

  1104.                                 args = new ArrayList(); args.add(arg);

  1105.       label_4:

  1106.       while (true) {

  1107.         switch (jj_nt.kind) {

  1108.         case 87:

  1109.           ;

  1110.           break;

  1111.         default:

  1112.           jj_la1[18] = jj_gen;

  1113.           break label_4;

  1114.         }

  1115.         jj_consume_token(87);

  1116.         arg = Argument();

  1117.                                        args.add(arg);

  1118.       }

  1119.       break;

  1120.     default:

  1121.       jj_la1[19] = jj_gen;

  1122.       ;

  1123.     }

  1124.     jj_consume_token(81);

  1125.         {if (true) return args;}

  1126.     throw new Error("Missing return statement in function");

  1127.   }

  1128. 

  1129. /* [17]    Argument    ::=    Expr */

  1130.   final public Object Argument() throws ParseException {

  1131.     Object ex;

  1132.     ex = Expression();

  1133.         {if (true) return ex;}

  1134.     throw new Error("Missing return statement in function");

  1135.   }

  1136. 

  1137. /*---------------*/

  1138. /* 3.3 Node-sets */

  1139. /*---------------*/

  1140. 

  1141. /* [18] UnionExpr    ::=    PathExpr | UnionExpr '|' PathExpr */

  1142.   final public Object UnionExpr() throws ParseException {

  1143.     Object ex, r;

  1144.     ArrayList list = null;

  1145.     ex = PathExpr();

  1146.     label_5:

  1147.     while (true) {

  1148.       switch (jj_nt.kind) {

  1149.       case UNION:

  1150.         ;

  1151.         break;

  1152.       default:

  1153.         jj_la1[20] = jj_gen;

  1154.         break label_5;

  1155.       }

  1156.       jj_consume_token(UNION);

  1157.       r = PathExpr();

  1158.                 if (list == null){

  1159.                     list = new ArrayList();

  1160.                     list.add(ex);

  1161.                 }

  1162.                 list.add(r);

  1163.     }

  1164.         if (list != null){

  1165.             ex = compiler.union(list.toArray());

  1166.         }

  1167.         {if (true) return ex;}

  1168.     throw new Error("Missing return statement in function");

  1169.   }

  1170. 

  1171. /* [19] PathExpr ::= LocationPath | FilterExpr | FilterExpr '/' RelativeLocationPath | FilterExpr '//' RelativeLocationPath  */

  1172.   final public Object PathExpr() throws ParseException {

  1173.     Object ex = null;

  1174.     Object[] steps;

  1175.     if (jj_2_6(2147483647)) {

  1176.       ex = FilterExpr();

  1177.     } else {

  1178.       switch (jj_nt.kind) {

  1179.       case SLASH:

  1180.       case SLASHSLASH:

  1181.       case OR:

  1182.       case AND:

  1183.       case MOD:

  1184.       case DIV:

  1185.       case NODE:

  1186.       case TEXT:

  1187.       case COMMENT:

  1188.       case PI:

  1189.       case AXIS_SELF:

  1190.       case AXIS_CHILD:

  1191.       case AXIS_PARENT:

  1192.       case AXIS_ANCESTOR:

  1193.       case AXIS_ATTRIBUTE:

  1194.       case AXIS_NAMESPACE:

  1195.       case AXIS_PRECEDING:

  1196.       case AXIS_FOLLOWING:

  1197.       case AXIS_DESCENDANT:

  1198.       case AXIS_ANCESTOR_OR_SELF:

  1199.       case AXIS_FOLLOWING_SIBLING:

  1200.       case AXIS_PRECEDING_SIBLING:

  1201.       case AXIS_DESCENDANT_OR_SELF:

  1202.       case FUNCTION_LAST:

  1203.       case FUNCTION_POSITION:

  1204.       case FUNCTION_COUNT:

  1205.       case FUNCTION_ID:

  1206.       case FUNCTION_KEY:

  1207.       case FUNCTION_LOCAL_NAME:

  1208.       case FUNCTION_NAMESPACE_URI:

  1209.       case FUNCTION_NAME:

  1210.       case FUNCTION_STRING:

  1211.       case FUNCTION_CONCAT:

  1212.       case FUNCTION_STARTS_WITH:

  1213.       case FUNCTION_CONTAINS:

  1214.       case FUNCTION_SUBSTRING_BEFORE:

  1215.       case FUNCTION_SUBSTRING_AFTER:

  1216.       case FUNCTION_SUBSTRING:

  1217.       case FUNCTION_STRING_LENGTH:

  1218.       case FUNCTION_NORMALIZE_SPACE:

  1219.       case FUNCTION_TRANSLATE:

  1220.       case FUNCTION_BOOLEAN:

  1221.       case FUNCTION_NOT:

  1222.       case FUNCTION_TRUE:

  1223.       case FUNCTION_FALSE:

  1224.       case FUNCTION_NULL:

  1225.       case FUNCTION_LANG:

  1226.       case FUNCTION_NUMBER:

  1227.       case FUNCTION_SUM:

  1228.       case FUNCTION_FLOOR:

  1229.       case FUNCTION_CEILING:

  1230.       case FUNCTION_ROUND:

  1231.       case FUNCTION_FORMAT_NUMBER:

  1232.       case NCName:

  1233.       case 82:

  1234.       case 83:

  1235.       case 86:

  1236.       case 88:

  1237.         ex = LocationPath();

  1238.         break;

  1239.       default:

  1240.         jj_la1[21] = jj_gen;

  1241.         jj_consume_token(-1);

  1242.         throw new ParseException();

  1243.       }

  1244.     }

  1245.         {if (true) return ex;}

  1246.     throw new Error("Missing return statement in function");

  1247.   }

  1248. 

  1249. /* [20]    FilterExpr    ::=    PrimaryExpr    | FilterExpr Predicate */

  1250.   final public Object FilterExpr() throws ParseException {

  1251.     Object ex, p;

  1252.     ArrayList ps = new ArrayList();

  1253.     boolean path = false;

  1254.     ArrayList steps = new ArrayList();

  1255.     ex = PrimaryExpr();

  1256.     label_6:

  1257.     while (true) {

  1258.       switch (jj_nt.kind) {

  1259.       case 84:

  1260.         ;

  1261.         break;

  1262.       default:

  1263.         jj_la1[22] = jj_gen;

  1264.         break label_6;

  1265.       }

  1266.       p = Predicate();

  1267.                 path = true;

  1268.                 ps.add(p);

  1269.     }

  1270.     label_7:

  1271.     while (true) {

  1272.       switch (jj_nt.kind) {

  1273.       case SLASH:

  1274.       case SLASHSLASH:

  1275.         ;

  1276.         break;

  1277.       default:

  1278.         jj_la1[23] = jj_gen;

  1279.         break label_7;

  1280.       }

  1281.       LocationStep(steps);

  1282.                 path = true;

  1283.     }

  1284.         if (path){

  1285.             {if (true) return compiler.expressionPath(ex, ps.toArray(), steps.toArray());}

  1286.         }

  1287.         else {

  1288.             {if (true) return ex;}

  1289.         }

  1290.     throw new Error("Missing return statement in function");

  1291.   }

  1292. 

  1293. /*--------------*/

  1294. /* 3.4 Booleans */

  1295. /*--------------*/

  1296. 

  1297. /* [21] OrExpr    ::=    AndExpr | OrExpr 'or' AndExpr */

  1298.   final public Object OrExpr() throws ParseException {

  1299.     Object ex, r;

  1300.     ArrayList list = null;

  1301.     ex = AndExpr();

  1302.     label_8:

  1303.     while (true) {

  1304.       switch (jj_nt.kind) {

  1305.       case OR:

  1306.         ;

  1307.         break;

  1308.       default:

  1309.         jj_la1[24] = jj_gen;

  1310.         break label_8;

  1311.       }

  1312.       jj_consume_token(OR);

  1313.       r = AndExpr();

  1314.                 if (list == null){

  1315.                     list = new ArrayList();

  1316.                     list.add(ex);

  1317.                 }

  1318.                 list.add(r);

  1319.     }

  1320.         if (list != null){

  1321.             ex = compiler.or(list.toArray());

  1322.         }

  1323.         {if (true) return ex;}

  1324.     throw new Error("Missing return statement in function");

  1325.   }

  1326. 

  1327. /* [22] AndExpr    ::=    EqualityExpr  | AndExpr 'and' EqualityExpr  */

  1328.   final public Object AndExpr() throws ParseException {

  1329.     Object ex, r;

  1330.     ArrayList list = null;

  1331.     ex = EqualityExpr();

  1332.     label_9:

  1333.     while (true) {

  1334.       switch (jj_nt.kind) {

  1335.       case AND:

  1336.         ;

  1337.         break;

  1338.       default:

  1339.         jj_la1[25] = jj_gen;

  1340.         break label_9;

  1341.       }

  1342.       jj_consume_token(AND);

  1343.       r = EqualityExpr();

  1344.                 if (list == null){

  1345.                     list = new ArrayList();

  1346.                     list.add(ex);

  1347.                 }

  1348.                 list.add(r);

  1349.     }

  1350.         if (list != null){

  1351.             ex = compiler.and(list.toArray());

  1352.         }

  1353.         {if (true) return ex;}

  1354.     throw new Error("Missing return statement in function");

  1355.   }

  1356. 

  1357. /* [23] EqualityExpr    ::=    RelationalExpr | EqualityExpr '=' RelationalExpr | EqualityExpr '!=' RelationalExpr */

  1358.   final public Object EqualityExpr() throws ParseException {

  1359.  Object ex, r;

  1360.     ex = RelationalExpr();

  1361.     label_10:

  1362.     while (true) {

  1363.       switch (jj_nt.kind) {

  1364.       case EQ:

  1365.       case NEQ:

  1366.         ;

  1367.         break;

  1368.       default:

  1369.         jj_la1[26] = jj_gen;

  1370.         break label_10;

  1371.       }

  1372.       switch (jj_nt.kind) {

  1373.       case EQ:

  1374.         jj_consume_token(EQ);

  1375.         r = RelationalExpr();

  1376.                                           ex = compiler.equal(ex, r);

  1377.         break;

  1378.       case NEQ:

  1379.         jj_consume_token(NEQ);

  1380.         r = RelationalExpr();

  1381.                                           ex = compiler.notEqual(ex, r);

  1382.         break;

  1383.       default:

  1384.         jj_la1[27] = jj_gen;

  1385.         jj_consume_token(-1);

  1386.         throw new ParseException();

  1387.       }

  1388.     }

  1389.         {if (true) return ex;}

  1390.     throw new Error("Missing return statement in function");

  1391.   }

  1392. 

  1393. /* [24] RelationalExpr    ::=    AdditiveExpr | RelationalExpr '<' AdditiveExpr | RelationalExpr '>' AdditiveExpr

  1394.                        | RelationalExpr '<=' AdditiveExpr  | RelationalExpr '>=' AdditiveExpr */

  1395.   final public Object RelationalExpr() throws ParseException {

  1396.  Object ex, r;

  1397.     ex = AdditiveExpr();

  1398.     label_11:

  1399.     while (true) {

  1400.       switch (jj_nt.kind) {

  1401.       case LT:

  1402.       case LTE:

  1403.       case GT:

  1404.       case GTE:

  1405.         ;

  1406.         break;

  1407.       default:

  1408.         jj_la1[28] = jj_gen;

  1409.         break label_11;

  1410.       }

  1411.       switch (jj_nt.kind) {

  1412.       case LT:

  1413.         jj_consume_token(LT);

  1414.         r = AdditiveExpr();

  1415.                                         ex = compiler.lessThan(ex, r);

  1416.         break;

  1417.       case GT:

  1418.         jj_consume_token(GT);

  1419.         r = AdditiveExpr();

  1420.                                         ex = compiler.greaterThan(ex, r);

  1421.         break;

  1422.       case LTE:

  1423.         jj_consume_token(LTE);

  1424.         r = AdditiveExpr();

  1425.                                         ex = compiler.lessThanOrEqual(ex, r);

  1426.         break;

  1427.       case GTE:

  1428.         jj_consume_token(GTE);

  1429.         r = AdditiveExpr();

  1430.                                         ex = compiler.greaterThanOrEqual(ex, r);

  1431.         break;

  1432.       default:

  1433.         jj_la1[29] = jj_gen;

  1434.         jj_consume_token(-1);

  1435.         throw new ParseException();

  1436.       }

  1437.     }

  1438.         {if (true) return ex;}

  1439.     throw new Error("Missing return statement in function");

  1440.   }

  1441. 

  1442. /*-------------*/

  1443. /* 3.5 Numbers */

  1444. /*-------------*/

  1445. 

  1446. /* [25] AdditiveExpr ::= MultiplicativeExpr  | AdditiveExpr '+' MultiplicativeExpr  | AdditiveExpr '-' MultiplicativeExpr  */

  1447.   final public Object AdditiveExpr() throws ParseException {

  1448.     Object ex, r;

  1449.     ArrayList list = null;

  1450.     ex = SubtractiveExpr();

  1451.     label_12:

  1452.     while (true) {

  1453.       switch (jj_nt.kind) {

  1454.       case PLUS:

  1455.         ;

  1456.         break;

  1457.       default:

  1458.         jj_la1[30] = jj_gen;

  1459.         break label_12;

  1460.       }

  1461.       jj_consume_token(PLUS);

  1462.       r = SubtractiveExpr();

  1463.                 if (list == null){

  1464.                     list = new ArrayList();

  1465.                     list.add(ex);

  1466.                 }

  1467.                 list.add(r);

  1468.     }

  1469.         if (list != null){

  1470.             ex = compiler.sum(list.toArray());

  1471.         }

  1472.         {if (true) return ex;}

  1473.     throw new Error("Missing return statement in function");

  1474.   }

  1475. 

  1476.   final public Object SubtractiveExpr() throws ParseException {

  1477.     Object ex, r = null;

  1478.     ex = MultiplicativeExpr();

  1479.     label_13:

  1480.     while (true) {

  1481.       switch (jj_nt.kind) {

  1482.       case MINUS:

  1483.         ;

  1484.         break;

  1485.       default:

  1486.         jj_la1[31] = jj_gen;

  1487.         break label_13;

  1488.       }

  1489.       jj_consume_token(MINUS);

  1490.       r = MultiplicativeExpr();

  1491.                                                ex = compiler.minus(ex, r);

  1492.     }

  1493.         {if (true) return ex;}

  1494.     throw new Error("Missing return statement in function");

  1495.   }

  1496. 

  1497. /* [26] MultiplicativeExpr ::= UnaryExpr | MultiplicativeExpr MultiplyOperator UnaryExpr

  1498.             | MultiplicativeExpr 'div' UnaryExpr | MultiplicativeExpr 'mod' UnaryExpr  */

  1499.   final public Object MultiplicativeExpr() throws ParseException {

  1500.     Object ex, r;

  1501.     ex = UnaryExpr();

  1502.     label_14:

  1503.     while (true) {

  1504.       switch (jj_nt.kind) {

  1505.       case MOD:

  1506.       case DIV:

  1507.       case 88:

  1508.         ;

  1509.         break;

  1510.       default:

  1511.         jj_la1[32] = jj_gen;

  1512.         break label_14;

  1513.       }

  1514.       switch (jj_nt.kind) {

  1515.       case 88:

  1516.         jj_consume_token(88);

  1517.         r = UnaryExpr();

  1518.                                     ex = compiler.multiply(ex, r);

  1519.         break;

  1520.       case DIV:

  1521.         jj_consume_token(DIV);

  1522.         r = UnaryExpr();

  1523.                                     ex = compiler.divide(ex, r);

  1524.         break;

  1525.       case MOD:

  1526.         jj_consume_token(MOD);

  1527.         r = UnaryExpr();

  1528.                                     ex = compiler.mod(ex, r);

  1529.         break;

  1530.       default:

  1531.         jj_la1[33] = jj_gen;

  1532.         jj_consume_token(-1);

  1533.         throw new ParseException();

  1534.       }

  1535.     }

  1536.         {if (true) return ex;}

  1537.     throw new Error("Missing return statement in function");

  1538.   }

  1539. 

  1540. /* [27]    UnaryExpr    ::=    UnionExpr  | '-' UnaryExpr  */

  1541.   final public Object UnaryExpr() throws ParseException {

  1542.     Object ex;

  1543.     switch (jj_nt.kind) {

  1544.     case SLASH:

  1545.     case SLASHSLASH:

  1546.     case VARIABLE:

  1547.     case Literal:

  1548.     case Number:

  1549.     case OR:

  1550.     case AND:

  1551.     case MOD:

  1552.     case DIV:

  1553.     case NODE:

  1554.     case TEXT:

  1555.     case COMMENT:

  1556.     case PI:

  1557.     case AXIS_SELF:

  1558.     case AXIS_CHILD:

  1559.     case AXIS_PARENT:

  1560.     case AXIS_ANCESTOR:

  1561.     case AXIS_ATTRIBUTE:

  1562.     case AXIS_NAMESPACE:

  1563.     case AXIS_PRECEDING:

  1564.     case AXIS_FOLLOWING:

  1565.     case AXIS_DESCENDANT:

  1566.     case AXIS_ANCESTOR_OR_SELF:

  1567.     case AXIS_FOLLOWING_SIBLING:

  1568.     case AXIS_PRECEDING_SIBLING:

  1569.     case AXIS_DESCENDANT_OR_SELF:

  1570.     case FUNCTION_LAST:

  1571.     case FUNCTION_POSITION:

  1572.     case FUNCTION_COUNT:

  1573.     case FUNCTION_ID:

  1574.     case FUNCTION_KEY:

  1575.     case FUNCTION_LOCAL_NAME:

  1576.     case FUNCTION_NAMESPACE_URI:

  1577.     case FUNCTION_NAME:

  1578.     case FUNCTION_STRING:

  1579.     case FUNCTION_CONCAT:

  1580.     case FUNCTION_STARTS_WITH:

  1581.     case FUNCTION_CONTAINS:

  1582.     case FUNCTION_SUBSTRING_BEFORE:

  1583.     case FUNCTION_SUBSTRING_AFTER:

  1584.     case FUNCTION_SUBSTRING:

  1585.     case FUNCTION_STRING_LENGTH:

  1586.     case FUNCTION_NORMALIZE_SPACE:

  1587.     case FUNCTION_TRANSLATE:

  1588.     case FUNCTION_BOOLEAN:

  1589.     case FUNCTION_NOT:

  1590.     case FUNCTION_TRUE:

  1591.     case FUNCTION_FALSE:

  1592.     case FUNCTION_NULL:

  1593.     case FUNCTION_LANG:

  1594.     case FUNCTION_NUMBER:

  1595.     case FUNCTION_SUM:

  1596.     case FUNCTION_FLOOR:

  1597.     case FUNCTION_CEILING:

  1598.     case FUNCTION_ROUND:

  1599.     case FUNCTION_FORMAT_NUMBER:

  1600.     case NCName:

  1601.     case 80:

  1602.     case 82:

  1603.     case 83:

  1604.     case 86:

  1605.     case 88:

  1606.       ex = UnionExpr();

  1607.       break;

  1608.     case MINUS:

  1609.       jj_consume_token(MINUS);

  1610.       ex = UnaryExpr();

  1611.                                     ex = compiler.minus(ex);

  1612.       break;

  1613.     default:

  1614.       jj_la1[34] = jj_gen;

  1615.       jj_consume_token(-1);

  1616.       throw new ParseException();

  1617.     }

  1618.         {if (true) return ex;}

  1619.     throw new Error("Missing return statement in function");

  1620.   }

  1621. 

  1622. /*-------------*/

  1623. /* 3.6 Strings */

  1624. /*-------------*/

  1625. 

  1626. /*----------------------------------*/

  1627. /* 3.7 Expression Lexical Structure */

  1628. /*----------------------------------*/

  1629. /*

  1630. The following special tokenization rules must be applied in the order

  1631. specified to disambiguate the grammar:

  1632. 

  1633. 1. If there is a preceding token and the preceding token is not one of

  1634.    @, ::, (, [, , or an Operator,

  1635.    then a * must be recognized as a MultiplyOperator and an NCName must

  1636.    be recognized as an OperatorName.

  1637. 

  1638. 2. If the character following an NCName (possibly after intervening ExprWhitespace)

  1639.    is (, then the token must be recognized as a NodeType or a FunctionName.

  1640. 

  1641. 3. If the two characters following an NCName (possibly after intervening ExprWhitespace)

  1642.    are ::, then the token must be recognized as an AxisName.

  1643. 

  1644. 4. Otherwise, the token must not be recognized as a MultiplyOperator, an OperatorName,

  1645.    a NodeType, a FunctionName, or an AxisName.

  1646. */

  1647. 

  1648. /*

  1649. [28]    ExprToken    ::=    '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'

  1650.    | WildcardName  | NodeType  | Operator  | FunctionName  | AxisName  | Literal

  1651.    | Number  | VariableReference

  1652. */

  1653. /* [34]    MultiplyOperator    ::=    '*'  */

  1654. 

  1655. /* [35]    FunctionName    ::=    QName - NodeType   */

  1656.   final public Object FunctionName() throws ParseException {

  1657.     Object qname;

  1658.     qname = QName_Without_CoreFunctions();

  1659.         {if (true) return qname;}

  1660.     throw new Error("Missing return statement in function");

  1661.   }

  1662. 

  1663. /* [36]    VariableReference    ::=    '$' QName  */

  1664.   final public Object VariableReference() throws ParseException {

  1665.     Object ex;

  1666.     jj_consume_token(VARIABLE);

  1667.     ex = QName();

  1668.         {if (true) return compiler.variableReference(ex);}

  1669.     throw new Error("Missing return statement in function");

  1670.   }

  1671. 

  1672. /* [37]    WildcardName    ::=    '*'     | NCName ':' '*'     | QName  */

  1673.   final public Object WildcardName() throws ParseException {

  1674.     Object qn;

  1675.     String nc1, nc2 = null;

  1676.     switch (jj_nt.kind) {

  1677.     case 88:

  1678.       jj_consume_token(88);

  1679.       break;

  1680.     case OR:

  1681.     case AND:

  1682.     case MOD:

  1683.     case DIV:

  1684.     case NODE:

  1685.     case TEXT:

  1686.     case COMMENT:

  1687.     case PI:

  1688.     case FUNCTION_LAST:

  1689.     case FUNCTION_POSITION:

  1690.     case FUNCTION_COUNT:

  1691.     case FUNCTION_ID:

  1692.     case FUNCTION_KEY:

  1693.     case FUNCTION_LOCAL_NAME:

  1694.     case FUNCTION_NAMESPACE_URI:

  1695.     case FUNCTION_NAME:

  1696.     case FUNCTION_STRING:

  1697.     case FUNCTION_CONCAT:

  1698.     case FUNCTION_STARTS_WITH:

  1699.     case FUNCTION_CONTAINS:

  1700.     case FUNCTION_SUBSTRING_BEFORE:

  1701.     case FUNCTION_SUBSTRING_AFTER:

  1702.     case FUNCTION_SUBSTRING:

  1703.     case FUNCTION_STRING_LENGTH:

  1704.     case FUNCTION_NORMALIZE_SPACE:

  1705.     case FUNCTION_TRANSLATE:

  1706.     case FUNCTION_BOOLEAN:

  1707.     case FUNCTION_NOT:

  1708.     case FUNCTION_TRUE:

  1709.     case FUNCTION_FALSE:

  1710.     case FUNCTION_NULL:

  1711.     case FUNCTION_LANG:

  1712.     c