V
- the type of the parser valuespublic abstract class BaseParser<V> extends BaseActions<V>
Modifier and Type | Field and Description |
---|---|
static Rule |
ANY
Matches any character except
Chars.EOI . |
static Rule |
DEDENT
Matches the special
Chars.DEDENT character produces by the org.parboiled.buffers.IndentDedentInputBuffer |
static Rule |
EMPTY
Matches nothing and always succeeds.
|
static Rule |
EOI
Matches the
Chars.EOI (end of input) character. |
static Rule |
INDENT
Matches the special
Chars.INDENT character produces by the org.parboiled.buffers.IndentDedentInputBuffer |
static Rule |
NOTHING
Matches nothing and always fails.
|
Constructor and Description |
---|
BaseParser() |
Modifier and Type | Method and Description |
---|---|
static Action |
ACTION(boolean expression)
Explicitly marks the wrapped expression as an action expression.
|
Rule |
AnyOf(char[] characters)
Creates a new rule that matches any of the characters in the given char array.
|
Rule |
AnyOf(Characters characters)
Creates a new rule that matches any of the given characters.
|
Rule |
AnyOf(java.lang.String characters)
Creates a new rule that matches any of the characters in the given string.
|
Rule |
Ch(char c)
Explicitly creates a rule matching the given character.
|
Rule |
CharRange(char cLow,
char cHigh)
Creates a rule matching a range of characters from cLow to cHigh (both inclusively).
|
Rule |
FirstOf(java.lang.Object[] rules)
Creates a new rule that successively tries all of the given subrules and succeeds when the first one of
its subrules matches.
|
Rule |
FirstOf(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
Creates a new rule that successively tries all of the given subrules and succeeds when the first one of
its subrules matches.
|
protected Rule |
fromCharArray(char[] array)
Used internally to convert the given char array to a parser rule.
|
protected Rule |
fromCharLiteral(char c)
Used internally to convert the given character literal to a parser rule.
|
protected Rule |
fromStringLiteral(java.lang.String string)
Used internally to convert the given string literal to a parser rule.
|
Rule |
IgnoreCase(char... characters)
Explicitly creates a rule matching the given string in a case-independent fashion.
|
Rule |
IgnoreCase(char c)
Explicitly creates a rule matching the given character case-independently.
|
Rule |
IgnoreCase(java.lang.String string)
Explicitly creates a rule matching the given string in a case-independent fashion.
|
<P extends BaseParser<V>> |
newInstance()
Creates a new instance of this parsers class using the no-arg constructor.
|
Rule |
NoneOf(char[] characters)
Creates a new rule that matches all characters except the ones in the given char array and EOI.
|
Rule |
NoneOf(java.lang.String characters)
Creates a new rule that matches all characters except the ones in the given string and EOI.
|
Rule |
NTimes(int repetitions,
java.lang.Object rule)
Creates a new rule that repeatedly matches a given sub rule a certain fixed number of times.
|
Rule |
NTimes(int repetitions,
java.lang.Object rule,
java.lang.Object separator)
Creates a new rule that repeatedly matches a given sub rule a certain fixed number of times, optionally
separated by a given separator rule.
|
Rule |
OneOrMore(java.lang.Object rule)
Creates a new rule that tries repeated matches of its subrule and succeeds if the subrule matches at least once.
|
Rule |
OneOrMore(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
Creates a new rule that tries repeated matches of a sequence of the given subrules and succeeds if the sequence
matches at least once.
|
Rule |
Optional(java.lang.Object rule)
Creates a new rule that tries a match on its subrule and always succeeds, independently of the matching
success of its sub rule.
|
Rule |
Optional(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
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.
|
Rule |
Sequence(java.lang.Object[] rules)
Creates a new rule that only succeeds if all of its subrule succeed, one after the other.
|
Rule |
Sequence(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
Creates a new rule that only succeeds if all of its subrule succeed, one after the other.
|
Rule |
String(char... characters)
Explicitly creates a rule matching the given string.
|
Rule |
String(java.lang.String string)
Explicitly creates a rule matching the given string.
|
Rule |
Test(java.lang.Object rule)
Creates a new rule that acts as a syntactic predicate, i.e.
|
Rule |
Test(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
Creates a new rule that acts as a syntactic predicate, i.e.
|
Rule |
TestNot(java.lang.Object rule)
Creates a new rule that acts as an inverse syntactic predicate, i.e.
|
Rule |
TestNot(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
Creates a new rule that acts as an inverse syntactic predicate, i.e.
|
Rule |
toRule(java.lang.Object obj)
Converts the given object to a rule.
|
Rule[] |
toRules(java.lang.Object... objects)
Converts the given object array to an array of rules.
|
Rule |
ZeroOrMore(java.lang.Object rule)
Creates a new rule that tries repeated matches of its subrule.
|
Rule |
ZeroOrMore(java.lang.Object rule,
java.lang.Object rule2,
java.lang.Object... moreRules)
Creates a new rule that tries repeated matches of the sequence of the given sub rules.
|
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
public static final Rule INDENT
Chars.INDENT
character produces by the org.parboiled.buffers.IndentDedentInputBufferpublic static final Rule DEDENT
Chars.DEDENT
character produces by the org.parboiled.buffers.IndentDedentInputBufferpublic static final Rule EMPTY
public static final Rule NOTHING
public <P extends BaseParser<V>> P newInstance()
Parboiled.createParser(Class, Object...)
for creating
new parser instances since this method does not use reflection.P
- the parser classpublic Rule Ch(char c)
fromCharLiteral(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.
c
- the char to matchpublic Rule IgnoreCase(char c)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
c
- the char to match independently of its casepublic Rule CharRange(char cLow, char cHigh)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
arguments will yield the same rule instance.
cLow
- the start char of the range (inclusively)cHigh
- the end char of the range (inclusively)public Rule AnyOf(java.lang.String characters)
Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
characters
- the characterspublic Rule AnyOf(char[] characters)
Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
characters
- the characterspublic Rule AnyOf(Characters characters)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
characters
- the characterspublic Rule NoneOf(java.lang.String characters)
Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
characters
- the characterspublic Rule NoneOf(char[] characters)
Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
characters
- the characterspublic Rule String(java.lang.String string)
fromStringLiteral(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.
string
- the String to matchpublic Rule String(char... characters)
fromStringLiteral(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.
characters
- the characters of the string to matchpublic Rule IgnoreCase(java.lang.String string)
Note: This methods provides caching, which means that multiple invocations with the same argument will yield the same rule instance.
string
- the string to matchpublic Rule IgnoreCase(char... characters)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
characters
- the characters of the string to matchpublic Rule FirstOf(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule FirstOf(java.lang.Object[] rules)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
rules
- the subrulespublic Rule OneOrMore(java.lang.Object rule)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
rule
- the subrulepublic Rule OneOrMore(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule Optional(java.lang.Object rule)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
rule
- the subrulepublic Rule Optional(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule Sequence(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule Sequence(java.lang.Object[] rules)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
arguments will yield the same rule instance.
rules
- the sub rulespublic Rule Test(java.lang.Object rule)
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 see SkipActionsInPredicates
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
rule
- the subrulepublic Rule Test(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
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 see SkipActionsInPredicates
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule TestNot(java.lang.Object rule)
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 see SkipActionsInPredicates
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
rule
- the subrulepublic Rule TestNot(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
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 see SkipActionsInPredicates
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule ZeroOrMore(java.lang.Object rule)
Note: This methods carries a Cached
annotation, which means that multiple invocations with the same
argument will yield the same rule instance.
rule
- the subrulepublic Rule ZeroOrMore(java.lang.Object rule, java.lang.Object rule2, java.lang.Object... moreRules)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
rule
- the first subrulerule2
- the second subrulemoreRules
- the other subrulespublic Rule NTimes(int repetitions, java.lang.Object rule)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
repetitions
- The number of repetitions to match. Must be >= 0.rule
- the sub rule to match repeatedly.public Rule NTimes(int repetitions, java.lang.Object rule, java.lang.Object separator)
Note: This methods provides caching, which means that multiple invocations with the same arguments will yield the same rule instance.
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.public static Action ACTION(boolean expression)
Action
instance during parser construction.expression
- the expression to turn into an Actionprotected Rule fromCharLiteral(char c)
c
- the characterprotected Rule fromStringLiteral(java.lang.String string)
string
- the stringprotected Rule fromCharArray(char[] array)
array
- the char arraypublic Rule[] toRules(java.lang.Object... objects)
objects
- the objects to convertpublic Rule toRule(java.lang.Object obj)
obj
- the object to convert