All Classes and Interfaces
Class
Description
Abstract base class of most regular
Matcher
s.Instances of classes implementing this interface can be used directly in a rule definition to define a parser action.
A
ParseError
wrapping an ActionException.Exception that can be thrown by parser actions to signal that an error has occurred that is to be collected
in the ParseErrors for the parsing run.
A
Matcher
matching any single character except EOI.A
Matcher
matching a single character out of a given Characters
set.A basic
ParseError
implementation for a one-char parse error with an optional error message.The most basic of all
ParseRunner
implementations.A
TreeNode
specialization with only two child nodes, left and right.A
MatcherVisitor
determining whether a matcher can legally succeed with an empty match.An immutable, set-like aggregation of (relatively few) characters that allows for an inverted semantic
("all chars except these few").
A
Matcher
matching a single character case-independently.A
Matcher
matching a single given character.A
Matcher
matching a single character out of a given range of characters.Utility methods for grammar integrity checks.
A Context object is available to parser actions methods during their runtime and provides various support functionalities.
Interface that can be implemented by classes containing action methods.
Base class of custom matcher implementations.
Immutable default implementation of an InputBuffer.
A
Formatter
for InvalidInputError
s that automatically creates the correct "expected" text
for the error.A basic
MatcherVisitor
implementation that delegates all visiting methods to one default value method.An implementation of a stack of value objects providing an efficient snapshot capability and a number of convenience
methods.
A MatcherVisitor that executes a given
DoWithMatcherVisitor.Action
against a whole matcher hierarchy in a depth-first manner.A
Matcher
that always successfully matches nothing.A
ParseRunner
implementation that creates a simple BasicParseError
for the first error found in the
input and adds it to the list of ParseErrors.A
ParseRunner
implementation that creates an
InvalidInputError
for the error at a known error location.General utility methods regarding parse errors.
A
Matcher
trying all of its submatchers in sequence and succeeding when the first submatcher succeeds.A specialized FirstOfMatcher that handles FirstOf(string, string, ...) rules much faster that the regular
FirstOfMatcher.
Collects the matchers that can legally follow the given matcher according to the grammar into a given
list.
The capability to transform an object of type T into a string representation.
Returns the first character a given matcher can start a match with.
Exception thrown by parboiled if a problem with the integrity of the grammar rules has been detected.
A node in a directed graph (that may have cycles).
General utility methods for operating on directed graphs (consisting of
GraphNode
s).Exception thrown by the IndentDedentInputbuffer upon detection of an illegal indentation.
A simple immutable implementation of the
BinaryTreeNode
interface.A simple, immutable
GraphNode
implementation.A simple, immutable List implementation wrapping an array.
An
ImmutableGraphNode
specialization representing a tree node with a parent field linking back to the nodes
(only) parent.Special, immutable InputBuffer implementation for indentation based grammars.
A simple immutable container for a range of indices into an underlying InputBuffer.
Abstraction of a simple char[] buffer holding the input text to be parsed.
A
ParseError
describing one or more input characters that are illegal with regard to the underlying
language grammar.A
MatcherVisitor
determining whether a matcher is a basic single character matcher.A
MatcherVisitor
determining whether a matcher can start a match with a given char.A simple Node predicate determining whether a Node matches a given label prefix.
A Matcher instance is responsible for "executing" a specific Rule instance, i.e.
The Context implementation orchestrating most of the matching process.
Holds a snapshot of the current
Matcher
stack at a certain point during the parsing process.The interface to be implemented by all visitors of
Matcher
s.A MatchHandler is responsible for actually running the match of a given
MatcherContext
.Special wrapping matcher that performs memoization of the last mismatch of the wrapped sub rule.
A
MutableTreeNode
specialization also satisfying the BinaryTreeNode
interface
and providing mutability methods.A simple
MutableBinaryTreeNode
implementation based on the MutableTreeNodeImpl
.An InputBuffer wrapping another InputBuffer and providing for the ability to insert (and undo) characters at
certain index positions.
A
TreeNode
specialiation that allow for mutability of the tree structure.A base implementation of the
MutableTreeNode
.Represents a node in the parse tree created during a parsing run.
A simple Formatter that provides String representation for parse tree nodes.
A
Matcher
that never matches anything.A
Matcher
that repeatedly tries its submatcher against the input.A
Matcher
that tries its submatcher once against the input and always succeeds.Common interface of all parboiled parse error implementations.
Exception that is thrown for any problem during the parsing run that cannot be overcome automatically.
A ParseRunner performs the actual parsing run of a given parser rule on a given input text.
General utility methods for operating on parse trees.
Exception type not directly used by parboiled but included as a convenience base class for custom exceptions
(or to be used directly if no custom exception types are required).
A simple container encapsulating the result of a parsing run.
Simple container class for a line/column position in the input text.
Simple static methods to be called at the start of your own methods to verify
correct arguments and state.
The ProfilingParseRunner is a special
ParseRunner
implementation that "watches" a parser digest a number
of inputs and collects all sorts of statistical data on the what rules have matched how many times, the number
of reincovations of rules at identical input locations, and so on.A
ParseRunner
implementation that is able to recover from InvalidInputError
s in the input and therefore
report more than just the first InvalidInputError
if the input does not conform to the rule grammar.A simple container holding a reference to another object.
A
ParseRunner
implementation that properly reports the first InvalidInputError
if the input
does not conform to the rule grammar.Describes the return values of parser rule production methods.
A
Matcher
that executes all of its submatchers in sequence and only succeeds if all submatchers succeed.An action that can optionally be skipped when run underneath a predicate matcher.
Simple specialization of a
Var
for StringBuilders.A
SequenceMatcher
specialization for sequences of CharMatchers.General utility methods for string manipulation.
Simple specialization of a
Var
for Strings.A special
Matcher
not actually matching any input but rather trying its submatcher against the current input
position.A special
Matcher
not actually matching any input but rather trying its submatcher against the current input
position.A simple Formatter falling back to the objects toString() method.
A
ParseRunner
implementation used for debugging purposes.A specialization of a
GraphNode
that contains a reference to its parent, thereby making the graph a tree
(since each node can now have only one parent node).General utility methods for operating on tree, i.e.
General utility methods.
A ValueStack is a stack implementation for parser values.
This class provides a "local variable"-like construct for action expressions in parser rule methods.
Special wrapping matcher that manages the creation and destruction of execution frames for a number of action vars.
A
Matcher
that repeatedly tries its submatcher against the input.