Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

com.evolvedbinary.xpath.parser
Class XPathParser

java.lang.Object
  extended by org.parboiled.BaseActions<V>
      extended by org.parboiled.BaseParser<ASTNode>
          extended by com.evolvedbinary.xpath.parser.XPathParser
All Implemented Interfaces:
org.parboiled.ContextAware<ASTNode>
public class XPathParser
extends org.parboiled.BaseParser<ASTNode>

Field Summary
 
Fields inherited from class org.parboiled.BaseParser
ANY, DEDENT, EMPTY, EOI, INDENT, NOTHING
 
Constructor Summary
XPathParser(Boolean enableActions)
           
 
Method Summary
 org.parboiled.Rule AbbrevForwardStep()
          [31] AbbrevForwardStep ::= "@"? NodeTest
 org.parboiled.Rule AbbrevReverseStep()
          [34] AbbrevReverseStep ::= ".."
 org.parboiled.Rule AdditiveExpr()
          [12] AdditiveExpr ::= MultiplicativeExpr ( ("+" | "-") MultiplicativeExpr )* Value stack head either: AdditiveExpr / MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule AndExpr()
          [9] AndExpr ::= ComparisonExpr ( "and" ComparisonExpr )*
 org.parboiled.Rule AnyKindTest()
          [55] AnyKindTest ::= "node" "(" ")"
 org.parboiled.Rule AtomicType()
          [53] AtomicType ::= QName
 org.parboiled.Rule AttribNameOrWildcard()
          [61] AttribNameOrWildcard ::= AttributeName | "*"
 org.parboiled.Rule AttributeDeclaration()
          [63] AttributeDeclaration ::= AttributeName
 org.parboiled.Rule AttributeName()
          [68] AttributeName ::= QName
 org.parboiled.Rule AttributeTest()
          [60] AttributeTest ::= "attribute" "(" (AttribNameOrWildcard ("," TypeName)?)? ")"
 org.parboiled.Rule AxisStep()
          [28] AxisStep ::= (ReverseStep | ForwardStep) PredicateList
 org.parboiled.Rule CastableExpr()
          [18] CastableExpr ::= CastExpr ( "castable" "as" SingleType )? Value stack head either: CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule CastExpr()
          [19] CastExpr ::= UnaryExpr ( "cast" "as" SingleType )? Value stack head either: CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule Comment()
          [77] Comment ::= "(:" (CommentContents | Comment)* ":)" //ws: explicit
 org.parboiled.Rule CommentContents()
          [82] CommentContents ::= (Char+ - (Char* ('(:' | ':)') Char*))
 org.parboiled.Rule CommentTest()
          [58] CommentTest ::= "comment" "(" ")"
 org.parboiled.Rule ComparisonExpr()
          [10] ComparisonExpr ::= RangeExpr ( (ValueComp | GeneralComp | NodeComp) RangeExpr )? Value stack head either: ComparisonExpr / RangeExpr / AdditiveExpr / MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule ContextItemExpr()
          [47] ContextItemExpr ::= "."
 org.parboiled.Rule DecimalLiteral()
          [72] DecimalLiteral ::= ("." Digits) | (Digits "." [0-9]*) //ws: explicit
 org.parboiled.Rule Digits()
          [81] Digits ::= [0-9]+
 org.parboiled.Rule DocumentTest()
          [56] DocumentTest ::= "document-node" "(" (ElementTest | SchemaElementTest)? ")"
 org.parboiled.Rule DoubleLiteral()
          [73] DoubleLiteral ::= (("." Digits) | (Digits ("." [0-9]*)?)) [eE] [+-]? Digits //ws: explicit
 org.parboiled.Rule ElementDeclaration()
          [67] ElementDeclaration ::= ElementName
 org.parboiled.Rule ElementName()
          [69] ElementName ::= QName
 org.parboiled.Rule ElementNameOrWildcard()
          [65] ElementNameOrWildcard ::= ElementName | "*"
 org.parboiled.Rule ElementTest()
          [64] ElementTest ::= "element" "(" (ElementNameOrWildcard ("," TypeName "?"?)?)? ")"
 org.parboiled.Rule EscapeApos()
          [76] EscapeApos ::= "''"
 org.parboiled.Rule EscapeQuot()
          [75] EscapeQuot ::= '""'
 org.parboiled.Rule Expr()
          [2] Expr ::= ExprSingle ("," ExprSingle)*
 org.parboiled.Rule ExprSingle()
          [3] ExprSingle ::= ForExpr | QuantifiedExpr | IfExpr | OrExpr
 org.parboiled.Rule FilterExpr()
          [38] FilterExpr ::= PrimaryExpr PredicateList
 org.parboiled.Rule ForExpr()
          [4] ForExpr ::= SimpleForClause "return" ExprSingle
 org.parboiled.Rule ForwardAxis()
          [30] ForwardAxis ::= ("child" "::") | ("descendant" "::") | ("attribute" "::") | ("self" "::") | ("descendant-or-self" "::") | ("following-sibling" "::") | ("following" "::") | ("namespace" "::")
 org.parboiled.Rule ForwardStep()
          [29] ForwardStep ::= (ForwardAxis NodeTest) | AbbrevForwardStep
 org.parboiled.Rule FunctionCall()
          [48] FunctionCall ::= QName "(" (ExprSingle ("," ExprSingle)*)? ")" //xgs:reserved-function-names
 org.parboiled.Rule GeneralComp()
          [22] GeneralComp ::= "=" | "!=" | "<" | "<=" | ">" | ">="
 org.parboiled.Rule IfExpr()
          [7] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle
 org.parboiled.Rule InstanceofExpr()
          [16] InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )? Value stack head either: InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule IntegerLiteral()
          [71] IntegerLiteral ::= Digits
 org.parboiled.Rule IntersectExceptExpr()
          [15] IntersectExceptExpr ::= InstanceofExpr ( ("intersect" | "except") InstanceofExpr )* Value stack head either: IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule ItemType()
          [52] ItemType ::= KindTest | ("item" "(" ")") | AtomicType
 org.parboiled.Rule KindTest()
          [54] KindTest ::= DocumentTest | ElementTest | AttributeTest | SchemaElementTest | SchemaAttributeTest | PITest | CommentTest | TextTest | AnyKindTest
 org.parboiled.Rule Literal()
          [42] Literal ::= NumericLiteral | StringLiteral
 org.parboiled.Rule MultiplicativeExpr()
          [13] MultiplicativeExpr ::= UnionExpr ( ("*" | "div" | "idiv" | "mod") UnionExpr )* Value stack head either: MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule NameTest()
          [36] NameTest ::= QName | Wildcard
 org.parboiled.Rule NCName()
          [79] NCName ::= [http://www.w3.org/TR/REC-xml-names/#NT-NCName]Names //xgs: xml-version
 org.parboiled.Rule NodeComp()
          [24] NodeComp ::= "is" | "<<" | ">>"
 org.parboiled.Rule NodeTest()
          [35] NodeTest ::= KindTest | NameTest
 org.parboiled.Rule NumericLiteral()
          [43] NumericLiteral ::= IntegerLiteral | DecimalLiteral | DoubleLiteral
 org.parboiled.Rule OccurrenceIndicator()
          [51] OccurrenceIndicator ::= "?" | "*" | "+"
 org.parboiled.Rule OrExpr()
          [8] OrExpr ::= AndExpr ( "or" AndExpr )*
 org.parboiled.Rule ParenthesizedExpr()
          [46] ParenthesizedExpr ::= "(" Expr? ")"
 org.parboiled.Rule PathExpr()
          [25] PathExpr ::= ("/" RelativePathExpr?) | ("//" RelativePathExpr) | RelativePathExpr
 ASTNode peek()
           
 org.parboiled.Rule PITest()
          [59] PITest ::= "processing-instruction" "(" (NCName | StringLiteral)? ")"
 ASTNode pop()
           
 org.parboiled.Rule Predicate()
          [40] Predicate ::= "[" Expr "]"
 org.parboiled.Rule PredicateList()
          [39] PredicateList ::= Predicate*
 org.parboiled.Rule PrimaryExpr()
          [41] PrimaryExpr ::= Literal | VarRef | ParenthesizedExpr | ContextItemExpr | FunctionCall
 boolean push(ASTNode value)
           
 org.parboiled.Rule QName()
          [78] QName ::= [http://www.w3.org/TR/REC-xml-names/#NT-QName]Names //xgs: xml-version
 org.parboiled.Rule QuantifiedExpr()
          [6] QuantifiedExpr ::= ("some" | "every") "$" VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* "satisfies" ExprSingle
 org.parboiled.Rule RangeExpr()
          [11] RangeExpr ::= AdditiveExpr ( "to" AdditiveExpr )? Value stack head either: RangeExpr / AdditiveExpr / MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule RelativePathExpr()
          [26] RelativePathExpr ::= StepExpr (("/" | "//") StepExpr)*
 PathExpr relativePathToPath(StepExpr initialStep, RelativePathExpr relativePathExpr)
          Converts a Relative Path Expression to a Path Expression
 org.parboiled.Rule ReverseAxis()
          [33] ReverseAxis ::= ("parent" "::") | ("ancestor" "::") | ("preceding-sibling" "::") | ("preceding" "::") | ("ancestor-or-self" "::")
 org.parboiled.Rule ReverseStep()
          [32] ReverseStep ::= (ReverseAxis NodeTest) | AbbrevReverseStep
 org.parboiled.Rule SchemaAttributeTest()
          [62] SchemaAttributeTest ::= "schema-attribute" "(" AttributeDeclaration ")"
 org.parboiled.Rule SchemaElementTest()
          [66] SchemaElementTest ::= "schema-element" "(" ElementDeclaration ")"
 org.parboiled.Rule SequenceType()
          [50] SequenceType ::= ("empty-sequence" "(" ")") | (ItemType OccurrenceIndicator?)
 org.parboiled.Rule SimpleForClause()
          [5] SimpleForClause ::= "for" "$" VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)*
 org.parboiled.Rule SingleType()
          [49] SingleType ::= AtomicType "?"? //gn: parens
 org.parboiled.Rule StepExpr()
          [27] StepExpr ::= FilterExpr | AxisStep
 org.parboiled.Rule StringLiteral()
          [74] StringLiteral ::= ('"' (EscapeQuot | [^"])* '"') | ("'" (EscapeApos | [^'])* "'") //ws: explicit
 org.parboiled.Rule TextTest()
          [57] TextTest ::= "text" "(" ")"
 org.parboiled.Rule TreatExpr()
          [17] TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )? Value stack head either: TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule TypeName()
          [70] TypeName ::= QName
 org.parboiled.Rule UnaryExpr()
          [20] UnaryExpr ::= ("-" | "+")* ValueExpr Value stack head either: UnaryExpr / ValueExpr
 org.parboiled.Rule UnionExpr()
          [14] UnionExpr ::= IntersectExceptExpr ( ("union" | "|") IntersectExceptExpr )* Value stack head either: UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr
 org.parboiled.Rule ValueComp()
          [23] ValueComp ::= "eq" | "ne" | "lt" | "le" | "gt" | "ge"
 org.parboiled.Rule ValueExpr()
          [21] ValueExpr ::= PathExpr
 org.parboiled.Rule VarName()
          [45] VarName ::= QName
 org.parboiled.Rule VarRef()
          [44] VarRef ::= "$" VarName
 org.parboiled.Rule Wildcard()
          [37] Wildcard ::= "*" | (NCName ":" "*") | ("*" ":" NCName) //ws: explicit
 org.parboiled.Rule withEOI(org.parboiled.Rule rule)
          Wraps any other rule to consume all input End of input is signalled by a Chars.EOI
 org.parboiled.Rule Xml_Char()
          Same as [https://www.w3.org/TR/xml/#NT-Char]Char [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
 org.parboiled.Rule Xml_S()
          Same as [https://www.w3.org/TR/xml/#NT-S]S [3] S ::= (#x20 | #x9 | #xD | #xA)+
 org.parboiled.Rule XmlNames_LocalPart()
          [11] LocalPart ::= NCName
 org.parboiled.Rule XmlNames_Name_minusColon()
          Modified from Extensible Markup Language (XML) 1.0 (Fifth Edition) Same as [https://www.w3.org/TR/REC-xml/#NT-Name]Name but with the ':' character removed! [_5] Name ::= NameStartChar_minusColon (NameChar)*
 org.parboiled.Rule XmlNames_NameChar()
          Modified from Extensible Markup Language (XML) 1.0 (Fifth Edition) Same as [https://www.w3.org/TR/xml/#NT-NameStartChar]NameChar but with the ':' character removed [_4a] NameChar ::= NameStartChar_minusColon | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
 org.parboiled.Rule XmlNames_NameStartChar_minusColon()
          Modified from Extensible Markup Language (XML) 1.0 (Fifth Edition) Same as [https://www.w3.org/TR/xml/#NT-NameStartChar]NameStartChar but with the ':' character removed! [_4] NameStartChar ::= [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
 org.parboiled.Rule XmlNames_NCName()
          [4] NCName ::= [https://www.w3.org/TR/REC-xml/#NT-Name]Name - (Char* ':' Char*) // An XML Name, minus the ":"
 org.parboiled.Rule XmlNames_Prefix()
          [10] Prefix ::= NCName
 org.parboiled.Rule XmlNames_PrefixedName()
          [8] PartialPrefixedName ::= Prefix ':' LocalPart
 org.parboiled.Rule XmlNames_QName()
          [7] QName ::= PartialPrefixedName | UnprefixedName
 org.parboiled.Rule XmlNames_UnprefixedName()
          [9] UnprefixedName ::= LocalPart
 org.parboiled.Rule XPath()
          [1] XPath ::= Expr
 
Methods inherited from class org.parboiled.BaseParser
ACTION, AnyOf, AnyOf, AnyOf, Ch, CharRange, FirstOf, FirstOf, fromCharArray, fromCharLiteral, fromStringLiteral, IgnoreCase, IgnoreCase, IgnoreCase, newInstance, NoneOf, NoneOf, NTimes, NTimes, OneOrMore, OneOrMore, Optional, Optional, Sequence, Sequence, String, String, Test, Test, TestNot, TestNot, toRule, toRules, ZeroOrMore, ZeroOrMore
 
Methods inherited from class org.parboiled.BaseActions
currentChar, currentIndex, drop, drop, dup, getContext, hasError, inPredicate, match, matchedChar, matchEnd, matchLength, matchOrDefault, matchRange, matchStart, nodeSuppressed, peek, poke, poke, pop, position, push, pushAll, setContext, swap, swap3, swap4, swap5, swap6
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

XPathParser

public XPathParser(Boolean enableActions)
Method Detail

push

public boolean push(ASTNode value)
Overrides:
push in class org.parboiled.BaseActions<ASTNode>

pop

public ASTNode pop()
Overrides:
pop in class org.parboiled.BaseActions<ASTNode>

peek

public ASTNode peek()
Overrides:
peek in class org.parboiled.BaseActions<ASTNode>

XPath

public org.parboiled.Rule XPath()
[1] XPath ::= Expr

Expr

public org.parboiled.Rule Expr()
[2] Expr ::= ExprSingle ("," ExprSingle)*

ExprSingle

public org.parboiled.Rule ExprSingle()
[3] ExprSingle ::= ForExpr | QuantifiedExpr | IfExpr | OrExpr

ForExpr

public org.parboiled.Rule ForExpr()
[4] ForExpr ::= SimpleForClause "return" ExprSingle

SimpleForClause

public org.parboiled.Rule SimpleForClause()
[5] SimpleForClause ::= "for" "$" VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)*

QuantifiedExpr

public org.parboiled.Rule QuantifiedExpr()
[6] QuantifiedExpr ::= ("some" | "every") "$" VarName "in" ExprSingle ("," "$" VarName "in" ExprSingle)* "satisfies" ExprSingle

IfExpr

public org.parboiled.Rule IfExpr()
[7] IfExpr ::= "if" "(" Expr ")" "then" ExprSingle "else" ExprSingle

OrExpr

public org.parboiled.Rule OrExpr()
[8] OrExpr ::= AndExpr ( "or" AndExpr )*

AndExpr

public org.parboiled.Rule AndExpr()
[9] AndExpr ::= ComparisonExpr ( "and" ComparisonExpr )*

ComparisonExpr

public org.parboiled.Rule ComparisonExpr()
[10] ComparisonExpr ::= RangeExpr ( (ValueComp | GeneralComp | NodeComp) RangeExpr )? Value stack head either: ComparisonExpr / RangeExpr / AdditiveExpr / MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

RangeExpr

public org.parboiled.Rule RangeExpr()
[11] RangeExpr ::= AdditiveExpr ( "to" AdditiveExpr )? Value stack head either: RangeExpr / AdditiveExpr / MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

AdditiveExpr

public org.parboiled.Rule AdditiveExpr()
[12] AdditiveExpr ::= MultiplicativeExpr ( ("+" | "-") MultiplicativeExpr )* Value stack head either: AdditiveExpr / MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

MultiplicativeExpr

public org.parboiled.Rule MultiplicativeExpr()
[13] MultiplicativeExpr ::= UnionExpr ( ("*" | "div" | "idiv" | "mod") UnionExpr )* Value stack head either: MultiplicativeExpr / UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

UnionExpr

public org.parboiled.Rule UnionExpr()
[14] UnionExpr ::= IntersectExceptExpr ( ("union" | "|") IntersectExceptExpr )* Value stack head either: UnionExpr / IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

IntersectExceptExpr

public org.parboiled.Rule IntersectExceptExpr()
[15] IntersectExceptExpr ::= InstanceofExpr ( ("intersect" | "except") InstanceofExpr )* Value stack head either: IntersectExceptExpr / InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

InstanceofExpr

public org.parboiled.Rule InstanceofExpr()
[16] InstanceofExpr ::= TreatExpr ( "instance" "of" SequenceType )? Value stack head either: InstanceOfExpr / TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

TreatExpr

public org.parboiled.Rule TreatExpr()
[17] TreatExpr ::= CastableExpr ( "treat" "as" SequenceType )? Value stack head either: TreatExpr / CastableExpr / CastExpr / UnaryExpr / ValueExpr

CastableExpr

public org.parboiled.Rule CastableExpr()
[18] CastableExpr ::= CastExpr ( "castable" "as" SingleType )? Value stack head either: CastableExpr / CastExpr / UnaryExpr / ValueExpr

CastExpr

public org.parboiled.Rule CastExpr()
[19] CastExpr ::= UnaryExpr ( "cast" "as" SingleType )? Value stack head either: CastExpr / UnaryExpr / ValueExpr

UnaryExpr

public org.parboiled.Rule UnaryExpr()
[20] UnaryExpr ::= ("-" | "+")* ValueExpr Value stack head either: UnaryExpr / ValueExpr

ValueExpr

public org.parboiled.Rule ValueExpr()
[21] ValueExpr ::= PathExpr

GeneralComp

public org.parboiled.Rule GeneralComp()
[22] GeneralComp ::= "=" | "!=" | "<" | "<=" | ">" | ">="

ValueComp

public org.parboiled.Rule ValueComp()
[23] ValueComp ::= "eq" | "ne" | "lt" | "le" | "gt" | "ge"

NodeComp

public org.parboiled.Rule NodeComp()
[24] NodeComp ::= "is" | "<<" | ">>"

PathExpr

public org.parboiled.Rule PathExpr()
[25] PathExpr ::= ("/" RelativePathExpr?) | ("//" RelativePathExpr) | RelativePathExpr

relativePathToPath

public PathExpr relativePathToPath(@Nullable
                                   StepExpr initialStep,
                                   @Nullable
                                   RelativePathExpr relativePathExpr)
Converts a Relative Path Expression to a Path Expression

Parameters:
initialStep - An initial step or null, if this Path Expression is still relative and not absolute
relativePathExpr - The RelativePathExpr or null if there is only an initial step, i.e. "/"
Returns:
The Path Expression
Throws:
IllegalArgumentException - if both initialStep and relativePathExpr are null

RelativePathExpr

public org.parboiled.Rule RelativePathExpr()
[26] RelativePathExpr ::= StepExpr (("/" | "//") StepExpr)*

StepExpr

public org.parboiled.Rule StepExpr()
[27] StepExpr ::= FilterExpr | AxisStep

AxisStep

public org.parboiled.Rule AxisStep()
[28] AxisStep ::= (ReverseStep | ForwardStep) PredicateList

ForwardStep

public org.parboiled.Rule ForwardStep()
[29] ForwardStep ::= (ForwardAxis NodeTest) | AbbrevForwardStep

ForwardAxis

public org.parboiled.Rule ForwardAxis()
[30] ForwardAxis ::= ("child" "::") | ("descendant" "::") | ("attribute" "::") | ("self" "::") | ("descendant-or-self" "::") | ("following-sibling" "::") | ("following" "::") | ("namespace" "::")

AbbrevForwardStep

public org.parboiled.Rule AbbrevForwardStep()
[31] AbbrevForwardStep ::= "@"? NodeTest

ReverseStep

public org.parboiled.Rule ReverseStep()
[32] ReverseStep ::= (ReverseAxis NodeTest) | AbbrevReverseStep

ReverseAxis

public org.parboiled.Rule ReverseAxis()
[33] ReverseAxis ::= ("parent" "::") | ("ancestor" "::") | ("preceding-sibling" "::") | ("preceding" "::") | ("ancestor-or-self" "::")

AbbrevReverseStep

public org.parboiled.Rule AbbrevReverseStep()
[34] AbbrevReverseStep ::= ".."

NodeTest

public org.parboiled.Rule NodeTest()
[35] NodeTest ::= KindTest | NameTest

NameTest

public org.parboiled.Rule NameTest()
[36] NameTest ::= QName | Wildcard

Wildcard

public org.parboiled.Rule Wildcard()
[37] Wildcard ::= "*" | (NCName ":" "*") | ("*" ":" NCName) //ws: explicit

FilterExpr

public org.parboiled.Rule FilterExpr()
[38] FilterExpr ::= PrimaryExpr PredicateList

PredicateList

public org.parboiled.Rule PredicateList()
[39] PredicateList ::= Predicate*

Predicate

public org.parboiled.Rule Predicate()
[40] Predicate ::= "[" Expr "]"

PrimaryExpr

public org.parboiled.Rule PrimaryExpr()
[41] PrimaryExpr ::= Literal | VarRef | ParenthesizedExpr | ContextItemExpr | FunctionCall

Literal

public org.parboiled.Rule Literal()
[42] Literal ::= NumericLiteral | StringLiteral

NumericLiteral

public org.parboiled.Rule NumericLiteral()
[43] NumericLiteral ::= IntegerLiteral | DecimalLiteral | DoubleLiteral

VarRef

public org.parboiled.Rule VarRef()
[44] VarRef ::= "$" VarName

VarName

public org.parboiled.Rule VarName()
[45] VarName ::= QName

ParenthesizedExpr

public org.parboiled.Rule ParenthesizedExpr()
[46] ParenthesizedExpr ::= "(" Expr? ")"

ContextItemExpr

public org.parboiled.Rule ContextItemExpr()
[47] ContextItemExpr ::= "."

FunctionCall

public org.parboiled.Rule FunctionCall()
[48] FunctionCall ::= QName "(" (ExprSingle ("," ExprSingle)*)? ")" //xgs:reserved-function-names

SingleType

public org.parboiled.Rule SingleType()
[49] SingleType ::= AtomicType "?"? //gn: parens

SequenceType

public org.parboiled.Rule SequenceType()
[50] SequenceType ::= ("empty-sequence" "(" ")") | (ItemType OccurrenceIndicator?)

OccurrenceIndicator

public org.parboiled.Rule OccurrenceIndicator()
[51] OccurrenceIndicator ::= "?" | "*" | "+"

ItemType

public org.parboiled.Rule ItemType()
[52] ItemType ::= KindTest | ("item" "(" ")") | AtomicType

AtomicType

public org.parboiled.Rule AtomicType()
[53] AtomicType ::= QName

KindTest

public org.parboiled.Rule KindTest()
[54] KindTest ::= DocumentTest | ElementTest | AttributeTest | SchemaElementTest | SchemaAttributeTest | PITest | CommentTest | TextTest | AnyKindTest

AnyKindTest

public org.parboiled.Rule AnyKindTest()
[55] AnyKindTest ::= "node" "(" ")"

DocumentTest

public org.parboiled.Rule DocumentTest()
[56] DocumentTest ::= "document-node" "(" (ElementTest | SchemaElementTest)? ")"

TextTest

public org.parboiled.Rule TextTest()
[57] TextTest ::= "text" "(" ")"

CommentTest

public org.parboiled.Rule CommentTest()
[58] CommentTest ::= "comment" "(" ")"

PITest

public org.parboiled.Rule PITest()
[59] PITest ::= "processing-instruction" "(" (NCName | StringLiteral)? ")"

AttributeTest

public org.parboiled.Rule AttributeTest()
[60] AttributeTest ::= "attribute" "(" (AttribNameOrWildcard ("," TypeName)?)? ")"

AttribNameOrWildcard

public org.parboiled.Rule AttribNameOrWildcard()
[61] AttribNameOrWildcard ::= AttributeName | "*"

SchemaAttributeTest

public org.parboiled.Rule SchemaAttributeTest()
[62] SchemaAttributeTest ::= "schema-attribute" "(" AttributeDeclaration ")"

AttributeDeclaration

public org.parboiled.Rule AttributeDeclaration()
[63] AttributeDeclaration ::= AttributeName

ElementTest

public org.parboiled.Rule ElementTest()
[64] ElementTest ::= "element" "(" (ElementNameOrWildcard ("," TypeName "?"?)?)? ")"

ElementNameOrWildcard

public org.parboiled.Rule ElementNameOrWildcard()
[65] ElementNameOrWildcard ::= ElementName | "*"

SchemaElementTest

public org.parboiled.Rule SchemaElementTest()
[66] SchemaElementTest ::= "schema-element" "(" ElementDeclaration ")"

ElementDeclaration

public org.parboiled.Rule ElementDeclaration()
[67] ElementDeclaration ::= ElementName

AttributeName

public org.parboiled.Rule AttributeName()
[68] AttributeName ::= QName

ElementName

public org.parboiled.Rule ElementName()
[69] ElementName ::= QName

TypeName

public org.parboiled.Rule TypeName()
[70] TypeName ::= QName

IntegerLiteral

public org.parboiled.Rule IntegerLiteral()
[71] IntegerLiteral ::= Digits

DecimalLiteral

public org.parboiled.Rule DecimalLiteral()
[72] DecimalLiteral ::= ("." Digits) | (Digits "." [0-9]*) //ws: explicit

DoubleLiteral

public org.parboiled.Rule DoubleLiteral()
[73] DoubleLiteral ::= (("." Digits) | (Digits ("." [0-9]*)?)) [eE] [+-]? Digits //ws: explicit

StringLiteral

public org.parboiled.Rule StringLiteral()
[74] StringLiteral ::= ('"' (EscapeQuot | [^"])* '"') | ("'" (EscapeApos | [^'])* "'") //ws: explicit

EscapeQuot

public org.parboiled.Rule EscapeQuot()
[75] EscapeQuot ::= '""'

EscapeApos

public org.parboiled.Rule EscapeApos()
[76] EscapeApos ::= "''"

Comment

public org.parboiled.Rule Comment()
[77] Comment ::= "(:" (CommentContents | Comment)* ":)" //ws: explicit

QName

public org.parboiled.Rule QName()
[78] QName ::= [http://www.w3.org/TR/REC-xml-names/#NT-QName]Names //xgs: xml-version

NCName

public org.parboiled.Rule NCName()
[79] NCName ::= [http://www.w3.org/TR/REC-xml-names/#NT-NCName]Names //xgs: xml-version

Digits

public org.parboiled.Rule Digits()
[81] Digits ::= [0-9]+

CommentContents

public org.parboiled.Rule CommentContents()
[82] CommentContents ::= (Char+ - (Char* ('(:' | ':)') Char*))

XmlNames_QName

public org.parboiled.Rule XmlNames_QName()
[7] QName ::= PartialPrefixedName | UnprefixedName

XmlNames_PrefixedName

public org.parboiled.Rule XmlNames_PrefixedName()
[8] PartialPrefixedName ::= Prefix ':' LocalPart

XmlNames_UnprefixedName

public org.parboiled.Rule XmlNames_UnprefixedName()
[9] UnprefixedName ::= LocalPart

XmlNames_Prefix

public org.parboiled.Rule XmlNames_Prefix()
[10] Prefix ::= NCName

XmlNames_LocalPart

public org.parboiled.Rule XmlNames_LocalPart()
[11] LocalPart ::= NCName

XmlNames_NCName

public org.parboiled.Rule XmlNames_NCName()
[4] NCName ::= [https://www.w3.org/TR/REC-xml/#NT-Name]Name - (Char* ':' Char*) // An XML Name, minus the ":"

XmlNames_Name_minusColon

public org.parboiled.Rule XmlNames_Name_minusColon()
Modified from Extensible Markup Language (XML) 1.0 (Fifth Edition) Same as [https://www.w3.org/TR/REC-xml/#NT-Name]Name but with the ':' character removed! [_5] Name ::= NameStartChar_minusColon (NameChar)*

XmlNames_NameStartChar_minusColon

public org.parboiled.Rule XmlNames_NameStartChar_minusColon()
Modified from Extensible Markup Language (XML) 1.0 (Fifth Edition) Same as [https://www.w3.org/TR/xml/#NT-NameStartChar]NameStartChar but with the ':' character removed! [_4] NameStartChar ::= [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]

XmlNames_NameChar

public org.parboiled.Rule XmlNames_NameChar()
Modified from Extensible Markup Language (XML) 1.0 (Fifth Edition) Same as [https://www.w3.org/TR/xml/#NT-NameStartChar]NameChar but with the ':' character removed [_4a] NameChar ::= NameStartChar_minusColon | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]

Xml_S

public org.parboiled.Rule Xml_S()
Same as [https://www.w3.org/TR/xml/#NT-S]S [3] S ::= (#x20 | #x9 | #xD | #xA)+

Xml_Char

public org.parboiled.Rule Xml_Char()
Same as [https://www.w3.org/TR/xml/#NT-Char]Char [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]

withEOI

public org.parboiled.Rule withEOI(org.parboiled.Rule rule)
Wraps any other rule to consume all input End of input is signalled by a Chars.EOI

Parameters:
rule - Any XPathParser rule
Returns:
The rule followed by an EOI rule
Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
Copyright © 2016 Evolved Binary Ltd.. All Rights Reserved.