All Classes and Interfaces
Class
Description
Abstract base class of most regular
Matchers.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 InvalidInputErrors 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
GraphNodes).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
Matchers.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 InvalidInputErrors 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.