All Classes and Interfaces
Class
Description
An aliased relation.
Represents a rule with a bunch of alternatives.
Represents the use of an annotation.
Represents an annotation definition.
Represents array initializer used in variable definition.
Represents an "array[i]" expression.
Represents an array type literal.
Represents an "assert" statement.
Expression like "expr between a and b".
Deprecated.
Represents binary expression such as "a + b".
An expression of binary operator.
An expression like "expr in (select ...)".
Represents a block.
"true" or "false".
Represents "break" statement.
The main calculator parser.
A cast expression.
Represents a character literal.
Evaluates a char to a boolean.
Provides common
CharPredicate
implementations.Common facilities to check precondition, postcondition and invariants.
Represents a class definition;
Represents a static initializer or an instance initializer.
Represents "Foo.class".
Represents "?:" expression.
Represents a constructor definition.
Represents "continue" statement.
Models cross join.
Represents a decimal point number.
Represents interface, class, enum or annotation.
Parses class, interface, enum, annotation declarations.
Represents the body of interface, class, or annotation.
Parses a list of pattern started with a delimiter, separated and optionally
ended by the delimiter.
Represents the "do ...
A parser that always returns an empty mutable list.
Empty implementation of
ParseErrorDetails
for subclasses to override.Represents an enum definition.
Represents an enum value.
Reports parser errors in human-readable format.
Represents any expression.
Any expression
Represents the comma delimited expression list used in the initializer of a "for" loop.
Parses java expression.
Parser for expressions.
Represents a method call statement.
Represents a field definition.
Represents the enhanced for loop statement.
Represents the traditional for loop.
The "
case when cond1 then val1 when cond2 then val2 else def end
" expression.A function call.
"group by" clause.
Represents a simple name as expression.
Represents an "if" statement.
Represents an import statement.
Processes indentation based lexical structure according to the
Off-side rule.
Represents "expr instanceof type".
Represents any integral number literal.
Represents an interface definition.
Functors used only internally by this package.
A simple, efficient and dynamic int list.
Maps two integers to a boolean value.
Common utilities for working with io.
Lexer specific for the Java language rules.
Models a join.
The type of a join.
Helper class for creating lexers and parsers for keywords.
Represents a label statement such as "foo:".
Represents lambda expressions.
A
Lexicon
is a group of lexical words that can be tokenized by a single tokenizer.Represents "expr like 'pattern' escape 'escape'" expression.
Creates a {link List}.
Internal utility to work with
List
.Represents a literal rule.
Deprecated.
Prefer to use
SourceLocation
instead.Represents "? super SomeBound" type literal.
Deprecated.
Use
Function
instead.Deprecated.
Use
BiFunction
instead.Maps 3 objects of type
A
, B
and C
respectively to an object of type
T
.Maps 4 objects of type
A
, B
, C
and D
respectively
to an object of type T
.Maps 5 objects of type
A
, B
, C
, D
and E
respectively
to an object of type T
.Maps 6 objects to an object of type
T
.Maps 7 objects to an object of type
T
.Maps 8 objects to an object of type
T
.Provides common implementations of
Map
interface and the variants.Represents any class member, interface member, enum member etc.
Represents expressions like
obj.f(...)
.Represents a method definition.
Represents expressions like
obj::f
.Represents either a built-in modifier or annotation.
Parses any nestable comment pattern.
Represents a nested declaration.
Represents a "new Foo[] {...}" or "new Foo[size] {...}" expression.
Represents a non-qualified "new" statement with possibly anonymous class syntax.
Represents the no-op statement ";".
Represents "null".
Represents "null".
A number expression.
Transforms the recognized character range to an integer within 64 bits.
Distinguishes between "L", "F", "D" and int.
Utility functions for any object.
Operators
Defines operators used in Java.
Helper class for creating parsers and lexers for operators.
A suite is a list of overlapping operators, where some operators are prefixes of other
operators.
A list of suites in the reverse order of the suites.
Builds
Parser
to parse expressions with operator-precedence grammar.Describes operator associativity, in order of precedence.
The "order by" clause.
Deprecated.
Prefer to using a lambda expression to convert to your own type.
Represents a parameter definition.
Represents the context state during parsing.
Allows tracing of parsing progress during error condition, to ease debugging.
Describes details of a parsing error to support fine-grained error handling.
Defines grammar and encapsulates parsing logic.
Defines the mode that a parser should be run in.
An atomic mutable reference to
Parser
used in recursive grammars.Is thrown when any grammar error happens or any exception is thrown during parsing.
Provides common
Parser
implementations.Represents
ParseContext
for token level parsing.Represents the syntactical structure of the input being parsed.
Encapsulates algorithm to recognize certain string pattern.
Provides common
Pattern
implementations.Represents expression with postfix unary operator.
Represents expression with prefix unary operator.
Annotates anything that should be private but is allowing test cases to access it.
Represents a single java source file.
Represents a single projection in a select statement, it can be either an expression, a wildcard
or an expression with an alias.
Represents "obj.field", "SomeType.staticField", "SomeType.SomeNestedType"
or "org.codehaus.jparsec" kind of qualified expressions.
Represents a qualified name in import or package statement.
A qualified name like "a.b.c".
An expression like "a.b.c".
Represents a quantified rule.
Qualifies a rule.
Models a relation such as a select statement, or a table.
Parser for relation.
Deprecated.
Represents "return" statement.
Represents any rule in BNF.
Represents a rule definition.
Parser for bnf rules.
Represents a reference to a named production rule.
Provides common
Parser
implementations that scan the source and match certain string
patterns.Parser state for scanner.
Represents scientific notation number.
Models the select statement.
Represents a sequential rule.
The "
case expr when cond then val ... end
" expression.Represents a non-array type literal.
Represents a location inside the source.
Locates the line and column number of a 0-based index in the source.
Represents any statement.
Parses a statement.
A string literal.
Represents a string literal.
Translates the recognized string literal to a
String
.Manipulates String.
Internal utility for
String
operation.Represents a "this(params)" statement.
Represents the "super" keyword.
Represents the "switch case" expression.
Represents "synchronized" block.
Represents built in modifiers.
Models a table name.
Parses terminals in a bnf.
Parser for terminals.
Lexers and terminal level parsers for SQL.
Provides convenient API to build lexer and parsers for terminals.
Entry point for parser and tokenizers of character literal.
Entry point for parser and tokenizers of decimal number literal represented as
String
.Entry point for parser and tokenizers of regular identifier.
Entry point for any arbitrary integer literal represented as a
String
.Entry point for parser and tokenizers of integral number literal represented as
Long
.Entry point for parser and tokenizers of scientific notation literal.
Entry point for parser and tokenizers of string literal.
Represents a "this(params)" statement.
"this" or "A.B.this".
Represents a "throw" statement.
Represents any token with a token value and the 0-based index in the source.
Maps a
Token
to a an object of type T
, or null if the token isn't recognized.Provides common token values.
Represents a fragment tagged according to its semantics.
Represents a scientific notation with a significand (mantissa) and an exponent.
Pre-built
Tokens.Fragment
token tags.A TreeNode remembers it's parent (which corresponds to a parent parser that syntactically
encloses this parter), it's previous node (which is the parser at the same syntactical level
and had just succeeded before this parser started).
Represents the "try-catch-finally" statement.
Deprecated.
Prefer to using a lambda expression to convert to your own type.
Deprecated.
Prefer to using a lambda expression to convert to your own type.
Deprecated.
Prefer to using a lambda expression to convert to your own type.
Models a tuple of expressions such as "(1, 2, 3)".
Deprecated.
Prefer to using a lambda expression to convert to your own type.
Represents a type literal.
Parses any type literal.
Represents a type parameter in a type or method definition.
Deprecated.
Use
UnaryOperator
instead.Models an expression with unary operator.
Models an expression like "exists (select ...)".
Models a union relation.
Represents "? extends SomeBound" type literal.
Base class that implements
Object.equals(Object)
, Object.hashCode()
and
Object#toString()
on final fields.Represents a single variable declaration.
Represents the "while () ..." statement.
"a.b.*" or "*".
Parsed result with the matched source text.
BinaryOperator
instead.