@NonNullByDefault
| Interface | Description |
|---|---|
| IReport |
Common interface for reports of problems found during
the generation of lexical analyzers or parsers
|
| Regular.Folder<V> |
An instance of
Regular.Folder is a set of methods to
apply to the various cases of a regular expression, depending
on its form, as part of a (possibly) recursive traversal of
the regular expression structure. |
| Class | Description |
|---|---|
| CExtent |
Instances of this class describe ranges of characters
in files, and are used to link parsed entities with
their concrete representation in the original sources.
|
| Extent |
Instances of this class describe ranges of characters
in files, and are used to link parsed entities with
their concrete representation in the original sources.
|
| IReport.Impl |
A default implementation for
IReport |
| Lexer |
A lexer definition is a set of lexer rules
along with arbitrary header and footer sections.
|
| Lexer.Builder |
A builder class for
Lexer, where entries can be
added incrementally, and which takes care of collecting
problem reports along the way |
| Lexer.Clause |
A clause associates a regular expression
to a Java semantic action.
|
| Lexer.Entry |
A lexer rule entry is a sequence of regular expressions
associated to semantic actions.
|
| Lexer.Entry.Builder |
A builder class for lexer entries,
which lets one add clauses incrementally
|
| Located<T> |
This class allows wrapping values of some type
with a start and end positions
as provided by the lexing engine.
|
| Option |
An
Option instance represents a configuration
option as set in a lexer or parser description file. |
| PExtent |
Instances of this class describe ranges of characters
in files, and are used to link parsed entities with
their concrete representation in the original sources.
|
| PExtent.Builder |
Builder class for parameterized extends
|
| PExtent.Hole |
A
PExtent.Hole represents a special part of an extent
which is bound to some PExtent.Hole.name and can be instantiated later
on. |
| PGrammar |
A parametric parser description is a set of possibly parametric
grammar rules along with arbitrary
header and footer sections.
|
| PGrammar.Builder |
A builder class for
PGrammar, where rules can be
added incrementally, and which takes care of collecting
problem reports along the way |
| PGrammarRule |
Describes a (potentially parametric) grammar rule for a
non-terminal in a parametric grammar description.
|
| PGrammarRule.Builder |
A builder class for grammar rules,
where productions can be added incrementally
|
| PGrammars |
Static utilities about
PGrammars |
| PGrammars.Dependencies |
Represents the dependencies between the various non-terminals
in some grammar.
|
| PProduction |
A parameterized grammar production consists of
a sequence of production items
some of them being actual grammar items
(terminals or non-terminals, the latter potentially
applied recursively to other actuals) and others being
simply semantic actions.
|
| PProduction.ActionItem |
Represents a semantic action item, i.e. a semantic
action which is performed by the generated parser
when the enclosing production rule is executed.
|
| PProduction.Actual |
Represents an actual production item, i.e.
|
| PProduction.ActualExpr |
An expression representing the application of some grammar rule,
potentially via applications of parameterized rules of the grammar
to other symbols or expressions.
|
| PProduction.Builder |
Builder class for productions, allows adding
production items incrementally
|
| PProduction.Continue |
Represents a continuation of the current rule,
and unlike the equivalent actual,
this allows the generator to produce an optimized
tail-recursive call.
|
| PProduction.Item |
The base class for production items.
|
| Regular |
Instances of
Regular represent concrete
regular expressions. |
| Regular.Alternate |
Instances of regular expressions that represent a choice
a | b between two regular expressions. |
| Regular.Binding |
Instances of regular expressions that represent
expressions whose matchers will be bound to
a specified name
|
| Regular.Characters |
Instances of regular expressions that match exactly
one character amongst a set of possible characters.
|
| Regular.Eof |
The singleton class that stands for the regular expression
matching the "end of input", or EOF, which only matches
when the input string has been entirely consumed.
|
| Regular.Epsilon |
The singleton class that stands for the empty
regular expression ε, which only matches the empty string.
|
| Regular.Gen |
Generates random regular expressions based on a
probability configuration
and a random number generator
|
| Regular.Gen.Config |
Configuration of the generator
Probabilities specified for each kind of
regular expressions are cumulative, can be set
individually but must be increasing, since they
are tested in the order of definition.
|
| Regular.Repetition |
Instances of regular expressions that represent the Kleene
closure
r* of some regular expression r,
i.e. matching zero, one or more repetitions of r |
| Regular.Sequence |
Instances of regular expressions that represent the
concatenation
ab of two regular expressions. |
| Regulars |
This class contains various utility methods
about regular expressions.
|
| Regulars.MatchResult |
The result of a successful match of a
regular expression against some input string
|
| Regulars.VarsInfo |
Gathers information about the nature of various
bindings in a regular expression.
|
| Reporter | |
| TokenDecl |
A token declaration describes the token
name, which is the name
used in grammar rules to denote that terminal,
and the potential value type
associated to these tokens.
|
| Enum | Description |
|---|---|
| IReport.Severity |
Enum describing the severity of the reported problem
|
| PGrammars.Args |
Enumeration representing the different constraints which can exist
on the arguments of a symbol in a grammar: arguments can either
be mandatory, forbidden, or there may be no constraint at all.
|
| PGrammars.Sort |
This enumeration describes the various sorts which can characterize
the kind of terminals or non-terminals (or more generally actual
expressions) that can stand for some formal parameter in a parametric
grammar.
|
| PProduction.ItemKind |
Enumeration which describes the different kinds of
implementations of
PProduction.Item. |
| Regular.Kind |
Enumeration which describes the different kinds of
concrete implementations of
Regular. |
| Exception | Description |
|---|---|
| Lexer.IllFormedException |
Exception raised by the lexer builder class
when trying to construct an ill-formed lexer description.
|
| PGrammar.IllFormedException |
Exception raised by the grammar builder class
when trying to construct an ill-formed grammar description.
|