Class BaseParser<V>
- Type Parameters:
V
- the type of the parser values
- All Implemented Interfaces:
ContextAware<V>
-
Field Summary
Modifier and TypeFieldDescriptionstatic final Rule
Matches any character exceptChars.EOI
.static final Rule
Matches the specialChars.DEDENT
character produces by the org.parboiled.buffers.IndentDedentInputBufferstatic final Rule
Matches nothing and always succeeds.static final Rule
Matches theChars.EOI
(end of input) character.static final Rule
Matches the specialChars.INDENT
character produces by the org.parboiled.buffers.IndentDedentInputBufferstatic final Rule
Matches nothing and always fails. -
Constructor Summary
-
Method Summary
Modifier and TypeMethodDescriptionstatic Action
ACTION
(boolean expression) Explicitly marks the wrapped expression as an action expression.AnyOf
(char[] characters) Creates a new rule that matches any of the characters in the given char array.Creates a new rule that matches any of the characters in the given string.AnyOf
(Characters characters) Creates a new rule that matches any of the given characters.Ch
(char c) Explicitly creates a rule matching the given character.CharRange
(char cLow, char cHigh) Creates a rule matching a range of characters from cLow to cHigh (both inclusively).Creates a new rule that successively tries all of the given subrules and succeeds when the first one of its subrules matches.Creates a new rule that successively tries all of the given subrules and succeeds when the first one of its subrules matches.IgnoreCase
(char c) Explicitly creates a rule matching the given character case-independently.IgnoreCase
(char... characters) Explicitly creates a rule matching the given string in a case-independent fashion.IgnoreCase
(String string) Explicitly creates a rule matching the given string in a case-independent fashion.<P extends BaseParser<V>>
PCreates a new instance of this parsers class using the no-arg constructor.NoneOf
(char[] characters) Creates a new rule that matches all characters except the ones in the given char array and EOI.Creates a new rule that matches all characters except the ones in the given string and EOI.Creates a new rule that repeatedly matches a given sub rule a certain fixed number of times.Creates a new rule that repeatedly matches a given sub rule a certain fixed number of times, optionally separated by a given separator rule.Creates a new rule that tries repeated matches of its subrule and succeeds if the subrule matches at least once.Creates a new rule that tries repeated matches of a sequence of the given subrules and succeeds if the sequence matches at least once.Creates a new rule that tries a match on its subrule and always succeeds, independently of the matching success of its sub rule.Creates a new rule that tries a match on the sequence of the given subrules and always succeeds, independently of the matching success of its sub sequence.Creates a new rule that only succeeds if all of its subrule succeed, one after the other.Creates a new rule that only succeeds if all of its subrule succeed, one after the other.String
(char... characters) Explicitly creates a rule matching the given string.Explicitly creates a rule matching the given string.Creates a new rule that acts as a syntactic predicate, i.e.Creates a new rule that acts as a syntactic predicate, i.e.Creates a new rule that acts as an inverse syntactic predicate, i.e.Creates a new rule that acts as an inverse syntactic predicate, i.e.Converts the given object to a rule.Rule[]
Converts the given object array to an array of rules.ZeroOrMore
(Object rule) Creates a new rule that tries repeated matches of its subrule.ZeroOrMore
(Object rule, Object rule2, Object... moreRules) Creates a new rule that tries repeated matches of the sequence of the given sub rules.Methods inherited from class org.parboiled.BaseActions
currentChar, currentIndex, drop, drop, dup, getContext, hasError, inPredicate, match, matchedChar, matchEnd, matchLength, matchOrDefault, matchRange, matchStart, nodeSuppressed, peek, peek, poke, poke, pop, pop, position, push, push, pushAll, setContext, swap, swap3, swap4, swap5, swap6
-
Field Details
-
EOI
Matches theChars.EOI
(end of input) character. -
INDENT
Matches the specialChars.INDENT
character produces by the org.parboiled.buffers.IndentDedentInputBuffer -
DEDENT
Matches the specialChars.DEDENT
character produces by the org.parboiled.buffers.IndentDedentInputBuffer -
ANY
Matches any character exceptChars.EOI
. -
EMPTY
Matches nothing and always succeeds. -
NOTHING
Matches nothing and always fails.
-
-
Constructor Details
-
BaseParser
public BaseParser()
-
-
Method Details
-
newInstance
Creates a new instance of this parsers class using the no-arg constructor. If no no-arg constructor exists this method will fail with a java.lang.NoSuchMethodError. Using this method is faster than usingParboiled.createParser(Class, Object...)
for creating new parser instances since this method does not use reflection.- Type Parameters:
P
- the parser class- Returns:
- a new parser instance
-
Ch
Explicitly creates a rule matching the given character. Normally you can just specify the character literal directly in you rule description. However, if you don't want to go throughfromCharLiteral(char)
, e.g. because you redefined it, you can also use this wrapper.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
c
- the char to match- Returns:
- a new rule
-
IgnoreCase
Explicitly creates a rule matching the given character case-independently.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
c
- the char to match independently of its case- Returns:
- a new rule
-
CharRange
Creates a rule matching a range of characters from cLow to cHigh (both inclusively).Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same arguments will yield the same rule instance.- Parameters:
cLow
- the start char of the range (inclusively)cHigh
- the end char of the range (inclusively)- Returns:
- a new rule
-
AnyOf
Creates a new rule that matches any of the characters in the given string.Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
- Parameters:
characters
- the characters- Returns:
- a new rule
-
AnyOf
Creates a new rule that matches any of the characters in the given char array.Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
- Parameters:
characters
- the characters- Returns:
- a new rule
-
AnyOf
Creates a new rule that matches any of the given characters.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
characters
- the characters- Returns:
- a new rule
-
NoneOf
Creates a new rule that matches all characters except the ones in the given string and EOI.Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
- Parameters:
characters
- the characters- Returns:
- a new rule
-
NoneOf
Creates a new rule that matches all characters except the ones in the given char array and EOI.Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
- Parameters:
characters
- the characters- Returns:
- a new rule
-
String
Explicitly creates a rule matching the given string. Normally you can just specify the string literal directly in you rule description. However, if you want to not go throughfromStringLiteral(String)
, e.g. because you redefined it, you can also use this wrapper.Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
- Parameters:
string
- the String to match- Returns:
- a new rule
-
String
Explicitly creates a rule matching the given string. Normally you can just specify the string literal directly in you rule description. However, if you want to not go throughfromStringLiteral(String)
, e.g. because you redefined it, you can also use this wrapper.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
characters
- the characters of the string to match- Returns:
- a new rule
-
IgnoreCase
Explicitly creates a rule matching the given string in a case-independent fashion.Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
- Parameters:
string
- the string to match- Returns:
- a new rule
-
IgnoreCase
Explicitly creates a rule matching the given string in a case-independent fashion.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
characters
- the characters of the string to match- Returns:
- a new rule
-
FirstOf
Creates a new rule that successively tries all of the given subrules and succeeds when the first one of its subrules matches. If all subrules fail this rule fails as well.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
FirstOf
Creates a new rule that successively tries all of the given subrules and succeeds when the first one of its subrules matches. If all subrules fail this rule fails as well.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
rules
- the subrules- Returns:
- a new rule
-
OneOrMore
Creates a new rule that tries repeated matches of its subrule and succeeds if the subrule matches at least once. If the subrule does not match at least once this rule fails.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
rule
- the subrule- Returns:
- a new rule
-
OneOrMore
Creates a new rule that tries repeated matches of a sequence of the given subrules and succeeds if the sequence matches at least once. If the sequence does not match at least once this rule fails.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
Optional
Creates a new rule that tries a match on its subrule and always succeeds, independently of the matching success of its sub rule.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
rule
- the subrule- Returns:
- a new rule
-
Optional
Creates a new rule that tries a match on the sequence of the given subrules and always succeeds, independently of the matching success of its sub sequence.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
Sequence
Creates a new rule that only succeeds if all of its subrule succeed, one after the other.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
Sequence
Creates a new rule that only succeeds if all of its subrule succeed, one after the other.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same arguments will yield the same rule instance.- Parameters:
rules
- the sub rules- Returns:
- a new rule
-
Test
Creates a new rule that acts as a syntactic predicate, i.e. tests the given sub rule against the current input position without actually matching any characters. Succeeds if the sub rule succeeds and fails if the sub rule rails. Since this rule does not actually consume any input it will never create a parse tree node.
Also it carries a
SuppressNode
annotation, which means all sub nodes will also never create a parse tree node. This can be important for actions contained in sub rules of this rule that otherwise expect the presence of certain parse tree structures in their context. Also seeSkipActionsInPredicates
Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
rule
- the subrule- Returns:
- a new rule
-
Test
Creates a new rule that acts as a syntactic predicate, i.e. tests the sequence of the given sub rule against the current input position without actually matching any characters. Succeeds if the sub sequence succeeds and fails if the sub sequence rails. Since this rule does not actually consume any input it will never create a parse tree node.
Also it carries a
SuppressNode
annotation, which means all sub nodes will also never create a parse tree node. This can be important for actions contained in sub rules of this rule that otherwise expect the presence of certain parse tree structures in their context. Also seeSkipActionsInPredicates
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
TestNot
Creates a new rule that acts as an inverse syntactic predicate, i.e. tests the given sub rule against the current input position without actually matching any characters. Succeeds if the sub rule fails and fails if the sub rule succeeds. Since this rule does not actually consume any input it will never create a parse tree node.
Also it carries a
SuppressNode
annotation, which means all sub nodes will also never create a parse tree node. This can be important for actions contained in sub rules of this rule that otherwise expect the presence of certain parse tree structures in their context. Also seeSkipActionsInPredicates
Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
rule
- the subrule- Returns:
- a new rule
-
TestNot
Creates a new rule that acts as an inverse syntactic predicate, i.e. tests the sequence of the given sub rules against the current input position without actually matching any characters. Succeeds if the sub sequence fails and fails if the sub sequence succeeds. Since this rule does not actually consume any input it will never create a parse tree node.
Also it carries a
SuppressNode
annotation, which means all sub nodes will also never create a parse tree node. This can be important for actions contained in sub rules of this rule that otherwise expect the presence of certain parse tree structures in their context. Also seeSkipActionsInPredicates
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
ZeroOrMore
Creates a new rule that tries repeated matches of its subrule. Succeeds always, even if the subrule doesn't match even once.Note: This methods carries a
Cached
annotation, which means that multiple invocations with the same argument will yield the same rule instance.- Parameters:
rule
- the subrule- Returns:
- a new rule
-
ZeroOrMore
Creates a new rule that tries repeated matches of the sequence of the given sub rules. Succeeds always, even if the sub sequence doesn't match even once.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrules- Returns:
- a new rule
-
NTimes
Creates a new rule that repeatedly matches a given sub rule a certain fixed number of times.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
repetitions
- The number of repetitions to match. Must be >= 0.rule
- the sub rule to match repeatedly.- Returns:
- a new rule
-
NTimes
Creates a new rule that repeatedly matches a given sub rule a certain fixed number of times, optionally separated by a given separator rule.Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
- Parameters:
repetitions
- The number of repetitions to match. Must be >= 0.rule
- the sub rule to match repeatedly.separator
- the separator to match, if null the individual sub rules will be matched without separator.- Returns:
- a new rule
-
ACTION
Explicitly marks the wrapped expression as an action expression. parboiled transforms the wrapped expression into anAction
instance during parser construction.- Parameters:
expression
- the expression to turn into an Action- Returns:
- the Action wrapping the given expression
-
toRules
Converts the given object array to an array of rules.- Parameters:
objects
- the objects to convert- Returns:
- the rules corresponding to the given objects
-
toRule
Converts the given object to a rule. This method can be overriden to enable the use of custom objects directly in rule specifications.- Parameters:
obj
- the object to convert- Returns:
- the rule corresponding to the given object
-