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.
Use BinaryOperator instead.
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.
Common Function implementations that maps from String.
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.