) { return token.image; } } int CoreFunctionName() : { int code; } { ( { code = Compiler.FUNCTION_LAST; } | { code = Compiler.FUNCTION_POSITION; } | { code = Compiler.FUNCTION_COUNT; } | { code = Compiler.FUNCTION_ID; } | { code = Compiler.FUNCTION_LOCAL_NAME; } | { code = Compiler.FUNCTION_NAMESPACE_URI; } | { code = Compiler.FUNCTION_NAME; } | { code = Compiler.FUNCTION_STRING; } | { code = Compiler.FUNCTION_CONCAT; } | { code = Compiler.FUNCTION_STARTS_WITH; } | { code = Compiler.FUNCTION_CONTAINS; } | { code = Compiler.FUNCTION_SUBSTRING_BEFORE; } | { code = Compiler.FUNCTION_SUBSTRING_AFTER; } | { code = Compiler.FUNCTION_SUBSTRING; } | { code = Compiler.FUNCTION_STRING_LENGTH; } | { code = Compiler.FUNCTION_NORMALIZE_SPACE; } | { code = Compiler.FUNCTION_TRANSLATE; } | { code = Compiler.FUNCTION_BOOLEAN; } | { code = Compiler.FUNCTION_NOT; } | { code = Compiler.FUNCTION_TRUE; } | { code = Compiler.FUNCTION_FALSE; } | { code = Compiler.FUNCTION_NULL; } | { code = Compiler.FUNCTION_LANG; } | { code = Compiler.FUNCTION_NUMBER; } | { code = Compiler.FUNCTION_SUM; } | { code = Compiler.FUNCTION_FLOOR; } | { code = Compiler.FUNCTION_CEILING; } | { code = Compiler.FUNCTION_ROUND; } | { code = Compiler.FUNCTION_KEY; } | { code = Compiler.FUNCTION_FORMAT_NUMBER; } ) { return code; } } Object QName() : {String nc1, nc2 = null;} { nc1 = NCName() ( ":" nc2 = NCName() )? { if (nc2 == null){ return compiler.qname(null, nc1); } else { return compiler.qname(nc1, nc2); } } } Object QName_Without_CoreFunctions() : { String nc1, nc2 = null; } { ( LOOKAHEAD(NCName() ":") nc1 = NCName() ":" nc2 = NCName() | nc1 = NCName_Without_CoreFunctions() ) { if (nc2 == null){ return compiler.qname(null, nc1); } else { return compiler.qname(nc1, nc2); } } } Object parseExpression() : { Object ex; } { ex = Expression() { return ex; } } /* ################################################################################### */ /* XSLT Patterns (http://www.w3.org/1999/08/WD-xslt-19990813) */ /* ################################################################################### */ /* [XSLT1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern */ //void Pattern() : //{} //{ // LocationPathPattern() ( LocationPathPattern() )* //} // // ///* [XSLT2] LocationPathPattern ::= // '/' RelativePathPattern? | IdKeyPattern (('/' | '//' RelativePathPattern)? | '//'? RelativePathPattern //*/ // //void LocationPathPattern() : //{} //{ // ( RelativePathPattern() )? // | ( // LOOKAHEAD(IdKeyPattern()) // IdKeyPattern() ( ( | ) RelativePathPattern() )? // | ( )? RelativePathPattern() // ) //} // // // ///* [XSLT3] IdKeyPattern ::= 'id' '(' Literal ')' | 'key' '(' Literal ',' Literal ')' */ // //void IdKeyPattern() : //{} //{ // "(" ")" // | "(" "," ")" //} // // ///* [XSLT4] RelativePathPattern ::= StepPattern | RelativePathPattern '/' StepPattern // | RelativePathPattern '//' StepPattern //*/ //void RelativePathPattern() : //{} //{ // StepPattern() ( ( | ) StepPattern() )* //} // // ///* [XSLT5] StepPattern ::= AbbreviatedAxisSpecifier NodeTest Predicate* */ //void StepPattern() : //{} //{ // AbbreviatedAxisSpecifier() NodeTest() (Predicate())* //} // See XPath Syntax (http://www.w3.org/TR/xpath ) //void XPath() : //{} //{ // LocationPath() // //} /* [1] LocationPath ::= RelativeLocationPath | AbsoluteLocationPath */ Object LocationPath() : {Object ex = null;} { ( ex = RelativeLocationPath() | ex = AbsoluteLocationPath() ) { return ex; } } /* [2] AbsoluteLocationPath ::= '/' RelativeLocationPath? | AbbreviatedAbsoluteLocationPath */ /* [10] AbbreviatedAbsoluteLocationPath ::= '//' RelativeLocationPath */ Object AbsoluteLocationPath() : { ArrayList steps = new ArrayList(); } { ( LOOKAHEAD(LocationStep(steps)) (LocationStep(steps) ( LocationStep(steps) )* ) | ) { return compiler.locationPath(true, steps.toArray()); } } /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */ Object RelativeLocationPath() : { ArrayList steps = new ArrayList(); } { ( NodeTest(steps) ( LocationStep(steps) )* ) { return compiler.locationPath(false, steps.toArray()); } } /* [3] RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | AbbreviatedRelativeLocationPath */ /* [11] AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step */ /*--------------------*/ /* 2.1 Location Steps */ /*--------------------*/ /* [4] Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep */ void LocationStep(ArrayList steps) : { Object t; Object s; } { ( | { // Abbreviated step: descendant-or-self::node() t = compiler.nodeTypeTest(Compiler.NODE_TYPE_NODE); steps.add(compiler.step(Compiler.AXIS_DESCENDANT_OR_SELF, t, null)); } ) NodeTest(steps) } /* [7] NodeTest ::= WildcardName | NodeType '(' ')' | 'processing-instruction' '(' Literal ')' */ void NodeTest(ArrayList steps) : { int axis; int type = -1; String instruction = null; Object name = null; Object s; Object p; ArrayList ps = new ArrayList(); } { ( ( axis = AxisSpecifier() ( LOOKAHEAD(NodeType() "(" ")") type = NodeType() "(" ")" | LOOKAHEAD() "(" { instruction = unescape(token.image.substring(1, token.image.length() - 1)); } ")" | name = WildcardName() ) | "." { axis = Compiler.AXIS_SELF; type = Compiler.NODE_TYPE_NODE; } | ".." { axis = Compiler.AXIS_PARENT; type = Compiler.NODE_TYPE_NODE; } ) ( p = Predicate() { ps.add(p); } )* ) { if (name != null){ s = compiler.nodeNameTest(name); } else if (instruction != null){ s = compiler.processingInstructionTest(instruction); } else { s = compiler.nodeTypeTest(type); } steps.add(compiler.step(axis, s, ps.toArray())); } } /* [5] AxisSpecifier ::= AxisName '::' | AbbreviatedAxisSpecifier */ int AxisSpecifier() : { int axis; } { ( axis = AxisName() | axis = AbbreviatedAxisSpecifier() ) { return axis; } } /*----------*/ /* 2.2 Axes */ /*----------*/ /* [6] AxisName ::= 'ancestor' | 'ancestor-or-self' | 'attribute' | 'child' | 'descendant' | 'descendant-or-self' | 'following' | 'following-sibling' | 'namespace' | 'parent' | 'preceding' | 'preceding-sibling' | 'self' */ int AxisName() : { int axis = 0; } { ( { axis = Compiler.AXIS_SELF; } | { axis = Compiler.AXIS_CHILD; } | { axis = Compiler.AXIS_PARENT; } | { axis = Compiler.AXIS_ANCESTOR; } | { axis = Compiler.AXIS_ATTRIBUTE; } | { axis = Compiler.AXIS_NAMESPACE; } | { axis = Compiler.AXIS_PRECEDING; } | { axis = Compiler.AXIS_FOLLOWING; } | { axis = Compiler.AXIS_DESCENDANT; } | { axis = Compiler.AXIS_ANCESTOR_OR_SELF; } | { axis = Compiler.AXIS_FOLLOWING_SIBLING; } | { axis = Compiler.AXIS_PRECEDING_SIBLING; } | { axis = Compiler.AXIS_DESCENDANT_OR_SELF; } ) { return axis; } } /*----------------*/ /* 2.3 Node Tests */ /*----------------*/ /*----------------*/ /* 2.4 Predicates */ /*----------------*/ /* [8] Predicate ::= '[' PredicateExpr ']' */ /* [9] PredicateExpr ::= Expr */ Object Predicate() : { Object ex; } { "[" ex = Expression() "]" { return ex; } } /* [12] AbbreviatedStep ::= '.' | '..' */ /* [13] AbbreviatedAxisSpecifier ::= '@'? */ int AbbreviatedAxisSpecifier() : { int axis = Compiler.AXIS_CHILD; } { ( "@" {axis = Compiler.AXIS_ATTRIBUTE; } )? { return axis; } } /*---------------*/ /* 3 Expressions */ /*---------------*/ /*------------*/ /* 3.1 Basics */ /*------------*/ /* The effect of the grammar is that the order of precedence is (lowest precedence first): or and =, != <=, <, >=, > and all operators are left associative. For example, 3 > 2 > 1 is equivalent to (3 > 2) > 1, which evaluates to false. */ /* [14] Expr ::= OrExpr */ Object Expression() : {Object ex;} { ex = OrExpr() { return ex; } } /* [15] PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall */ Object PrimaryExpr() : { Object ex = null; } { ( ex = VariableReference() | "(" ex = Expression() ")" | { ex = compiler.literal(unescape(token.image.substring(1, token.image.length() - 1))); } | { ex = compiler.number(token.image); } | LOOKAHEAD(CoreFunctionName() "(") ex = CoreFunctionCall() | ex = FunctionCall() ) { return ex; } } /*--------------------*/ /* 3.2 Function Calls */ /*--------------------*/ /* [16] FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')' */ Object FunctionCall() : { Object name; ArrayList args; } { name = FunctionName() args = ArgumentList() { if (args == null){ return compiler.function(name, null); } else { return compiler.function(name, args.toArray()); } } } Object CoreFunctionCall() : { int code = 0; ArrayList args; } { ( code = CoreFunctionName() ) args = ArgumentList() { if (args == null){ return compiler.function(code, null); } else { return compiler.function(code, args.toArray()); } } } ArrayList ArgumentList() : { ArrayList args = null; Object arg; } { "(" ( arg = Argument() { args = new ArrayList(); args.add(arg); } ( "," arg = Argument() { args.add(arg); } )* )? ")" { return args; } } /* [17] Argument ::= Expr */ Object Argument() : { Object ex; } { ex = Expression() { return ex; } } /*---------------*/ /* 3.3 Node-sets */ /*---------------*/ /* [18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr */ Object UnionExpr() : { Object ex, r; ArrayList list = null; } { ( ex = PathExpr() ( r = PathExpr() { if (list == null){ list = new ArrayList(); list.add(ex); } list.add(r); } )* ) { if (list != null){ ex = compiler.union(list.toArray()); } return ex; } } /* [19] PathExpr ::= LocationPath | FilterExpr | FilterExpr '/' RelativeLocationPath | FilterExpr '//' RelativeLocationPath */ Object PathExpr() : { Object ex = null; Object[] steps; } { ( // Reason for LOOKAHEAD: // foo:bar() - filter path // foo:bar - location path LOOKAHEAD(PrimaryExpr()) ex = FilterExpr() | ex = LocationPath() ) { return ex; } } /* [20] FilterExpr ::= PrimaryExpr | FilterExpr Predicate */ Object FilterExpr() : { Object ex, p; ArrayList ps = new ArrayList(); boolean path = false; ArrayList steps = new ArrayList(); } { ( ex = PrimaryExpr() ( p = Predicate() { path = true; ps.add(p); } )* ( LocationStep(steps) { path = true; } )* ) { if (path){ return compiler.expressionPath(ex, ps.toArray(), steps.toArray()); } else { return ex; } } } /*--------------*/ /* 3.4 Booleans */ /*--------------*/ /* [21] OrExpr ::= AndExpr | OrExpr 'or' AndExpr */ Object OrExpr() : { Object ex, r; ArrayList list = null; } { ( ex = AndExpr() ( r = AndExpr() { if (list == null){ list = new ArrayList(); list.add(ex); } list.add(r); } )* ) { if (list != null){ ex = compiler.or(list.toArray()); } return ex; } } /* [22] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr */ Object AndExpr() : { Object ex, r; ArrayList list = null; } { ( ex = EqualityExpr() ( r = EqualityExpr() { if (list == null){ list = new ArrayList(); list.add(ex); } list.add(r); } )* ) { if (list != null){ ex = compiler.and(list.toArray()); } return ex; } } /* [23] EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr | EqualityExpr '!=' RelationalExpr */ Object EqualityExpr() : {Object ex, r;} { ( ex = RelationalExpr() (( r = RelationalExpr() { ex = compiler.equal(ex, r); } | r = RelationalExpr() { ex = compiler.notEqual(ex, r); } ))* ) { return ex; } } /* [24] RelationalExpr ::= AdditiveExpr | RelationalExpr '<' AdditiveExpr | RelationalExpr '>' AdditiveExpr | RelationalExpr '<=' AdditiveExpr | RelationalExpr '>=' AdditiveExpr */ Object RelationalExpr() : {Object ex, r;} { ( ex = AdditiveExpr() (( r = AdditiveExpr() { ex = compiler.lessThan(ex, r); } | r = AdditiveExpr() { ex = compiler.greaterThan(ex, r); } | r = AdditiveExpr() { ex = compiler.lessThanOrEqual(ex, r); } | r = AdditiveExpr() { ex = compiler.greaterThanOrEqual(ex, r); } ))* ) { return ex; } } /*-------------*/ /* 3.5 Numbers */ /*-------------*/ /* [25] AdditiveExpr ::= MultiplicativeExpr | AdditiveExpr '+' MultiplicativeExpr | AdditiveExpr '-' MultiplicativeExpr */ Object AdditiveExpr() : { Object ex, r; ArrayList list = null; } { ( ex = SubtractiveExpr() (( r = SubtractiveExpr() { if (list == null){ list = new ArrayList(); list.add(ex); } list.add(r); } ))* ) { if (list != null){ ex = compiler.sum(list.toArray()); } return ex; } } Object SubtractiveExpr() : { Object ex, r = null; } { ( ex = MultiplicativeExpr() ( r = MultiplicativeExpr() { ex = compiler.minus(ex, r); } )* ) { return ex; } } /* [26] MultiplicativeExpr ::= UnaryExpr | MultiplicativeExpr MultiplyOperator UnaryExpr | MultiplicativeExpr 'div' UnaryExpr | MultiplicativeExpr 'mod' UnaryExpr */ Object MultiplicativeExpr() : { Object ex, r; } { ( ex = UnaryExpr() ( ( "*" r = UnaryExpr() { ex = compiler.multiply(ex, r); } |

r = UnaryExpr() { ex = compiler.divide(ex, r); } | r = UnaryExpr() { ex = compiler.mod(ex, r); } ) )* ) { return ex; } } /* [27] UnaryExpr ::= UnionExpr | '-' UnaryExpr */ Object UnaryExpr() : { Object ex; } { ( ex = UnionExpr() | ex = UnaryExpr() { ex = compiler.minus(ex);} ) { return ex; } } /*-------------*/ /* 3.6 Strings */ /*-------------*/ /*----------------------------------*/ /* 3.7 Expression Lexical Structure */ /*----------------------------------*/ /* The following special tokenization rules must be applied in the order specified to disambiguate the grammar: 1. If there is a preceding token and the preceding token is not one of @, ::, (, [, , or an Operator, then a * must be recognized as a MultiplyOperator and an NCName must be recognized as an OperatorName. 2. If the character following an NCName (possibly after intervening ExprWhitespace) is (, then the token must be recognized as a NodeType or a FunctionName. 3. If the two characters following an NCName (possibly after intervening ExprWhitespace) are ::, then the token must be recognized as an AxisName. 4. Otherwise, the token must not be recognized as a MultiplyOperator, an OperatorName, a NodeType, a FunctionName, or an AxisName. */ /* [28] ExprToken ::= '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::' | WildcardName | NodeType | Operator | FunctionName | AxisName | Literal | Number | VariableReference */ /* [34] MultiplyOperator ::= '*' */ /* [35] FunctionName ::= QName - NodeType */ Object FunctionName() : { Object qname; } { qname = QName_Without_CoreFunctions() { return qname; } } /* [36] VariableReference ::= '$' QName */ Object VariableReference() : { Object ex; } { ex = QName() { return compiler.variableReference(ex); } } /* [37] WildcardName ::= '*' | NCName ':' '*' | QName */ Object WildcardName() : { Object qn; String nc1, nc2 = null; } { ( ("*" | NCName()) { nc1 = token.image; } (":" ("*" | NCName()) {nc2 = token.image;} )? ) { if (nc2 != null){ qn = compiler.qname(nc1, nc2); } else { qn = compiler.qname(null, nc1); } return qn; } } /* [38] NodeType ::= 'comment' | 'text' | 'processing-instruction' | 'node' */ int NodeType() : { int type; } { ( { type = Compiler.NODE_TYPE_TEXT; } | { type = Compiler.NODE_TYPE_NODE; } | { type = Compiler.NODE_TYPE_COMMENT; } | { type = Compiler.NODE_TYPE_PI; } ) { return type; } }