All Classes and Interfaces
Class
Description
Abstract base class of all ArrayBuffer classes, exists solely to avoid code duplication.
Abstract base interface for states of an automaton.
Basic interface for transitions of an automaton.
This class provides an alternative way of calculating the next transition - instead of checking
all transitions in sequential manner, all ranges of all transitions are merged into one sorted
array, which is then searched in tree-recursive fashion.
Data structure for optimized matching of multiple ranges in one lower byte range.
A character matcher that always matches.
Regex AST visitor that will find convert all NFA successors of a given
Term to
ASTTransitions (by calculating their respective GroupBoundaries) and annotate for
every successor which LookAheadAssertions and/or LookBehindAssertions it should
be merged with.A group that commits to its first successful match.
A reference to the contents of a previously matched capturing group.
Abstract base class for states of an automaton.
Matcher that matches multiple characters with a common high byte using a bit set.
Example: characters
Example: characters
တ, ဠ, ူ have a common high byte 0x10, so they
are matched by this high byte and a bit set that matches 0x10, 0x20 and
0x30.This class is designed as a "scratchpad" for generating many byte arrays of unknown size.
This visitor computes various properties of
RegexAST and its RegexASTNodes, in
two passes.Maps characters to their respective set of equivalent characters in case-insensitive context,
e.g.
A
Term that matches characters belonging to a specified set of characters.Represents a set of unicode characters.
This class is designed as a "scratchpad" for generating many char arrays of unknown size.
Helper class for converting
CodePointSets to CharMatchers.This class is instantiated once per compilation of a regular expression in
TRegexCompiler.compile(RegexLanguage, RegexSource) )} and is supposed to reduce the
amount of allocations during automaton generation.Compressed variant of
CodePointSet.Conditional back-reference groups represent the following construct found, e.g., in Python:
This RegexNode is used for regular expressions that can never match, like /a^a/, /a\ba/, /(?=a)b/
etc.
AST visitor base class that will visit a given subtree in depth-first order.
This state node is responsible for selecting a DFA's initial state based on the index the search
starts from.
Implementation of a node splitting algorithm presented by Sebastian Unger and Frank Mueller in
"Handling Irreducible Loops: Optimized Node Splitting vs.
A character matcher that never matches.
Groups are the top-most elements of regular expression ASTs.
Objects of this class represent the capture group boundaries traversed in a single
NFAStateTransition or ASTTransition.Character matcher that compiles to a binary search in a sorted list of ranges, like
RangeTreeMatcher, but replaces some subtrees with bit-set matches.Immutable bit set of fixed size 128.
Extensions of
SortedListOfRanges specific to immutable implementations.Initializes all reachable nodes'
id and populates
RegexAST.getReachableCarets()/RegexAST.getReachableDollars(), as well as
RegexAST.getSubtrees()} and RegexASTSubtreeRootNode.getSubtrees()}.Represents a literal string inside the regular expression that can be searched for before
starting the actual regular expression matcher.
This class is designed as a "scratchpad" for generating many char arrays of unknown size.
Extension of
IntArrayBuffer that adds convenience functions for arrays of integer ranges
in the form:Abstract character matcher that allows matching behavior to be inverted with a constructor
parameter.
An immutable representation of a set of java.util.regex.Pattern regular expression flags.
An implementation of the java.util.regex.Pattern regex flavor.
This regex engine is designed for very simple cases, where the regular expression can be directly
translated to common string operations.
DFA compilation loggers.
This class is designed as a "scratchpad" for generating many long arrays of unknown size.
An assertion that succeeds depending on whether another regular expression can be matched at the
current position.
An assertion that succeeds depending on whether or not text surrounding the current position
matches a given regular expression.
An assertion that succeeds depending on whether or not text preceding the current position
matches a given regular expression.
For all lookbehind assertions, mark all states where the assertion may begin.
Container for character matchers of DFA transitions.
MatchFound nodes are RegexASTNodes that represent the initial/final states of the
non-deterministic finite state automaton generated from the regular expression.Character matcher that uses an array of 256 bit sets to fully cover the 16 bit character space.
Mutable bit set of fixed size 128.
Represents a single state in the NFA form of a regular expression.
Provides information about a transition from one NFAState to another state.
Used for pre-calculating and finding the result of tree-like regular expressions.
Special AST visitor that will find all immediate successors of a given Term when the AST is seen
as a NFA, in priority order.
Counts the total number of child nodes of a given node.
Specialized
BitSetMatcher that exists simply because ascii bit set matchers occur often
and we can save one comparison when the high byte is 0x00.This class is designed as a "scratchpad" for generating many Object arrays of unknown size.
This class implements an intermediate Prefix-Tree used to simulate the behavior of OracleDB on
character classes in ignore-case mode.
An immutable representation of a set of OracleDB regular expression flags (the
match_param parameter).An implementation of the OracleDB regex flavor.
An assertion that succeeds when encountered at the beginning or at the end of the string we are
searching in.
The position assertions supported by ECMAScript RegExps.
Predefined lists of capture group start and end indices.
A NFA that corresponds to the subtree of one
RegexASTSubtreeRootNode.Represents a state of a
PureNFA.Represents a transition of a
PureNFA.Calculates the successor transitions of a given
PureNFAState.An immutable representation of a set of Python regular expression flags.
An implementation of the Python regex flavor.
The enumeration of different flavors of Python regular expressions.
Roughly corresponds to the goal symbol Atom in the ECMAScript RegExp syntax.
Character range matcher using a sorted list of ranges.
Extensions of
SortedListOfRanges specific to mutable implementations.Character range matcher that compiles to a static binary search.
This class is used to generate regex ASTs.
Root node of every AST.
A common supertype to the root node, lookahead and lookbehind assertions and atomic groups.
An implementation of a dialect (flavor) of regular expressions other than ECMAScript.
Truffle Regular Expression Language
RegexObject represents a compiled regular expression that can be used to match against
input strings.These options define how TRegex should interpret a given parsing request.
This profile is used for tracking statistics about a compiled regular expression, such as the
amount of times the expression was executed and the amount of matches that were found.
RegexResult is a TruffleObject that represents the result of matching a regular
expression against a string.Generates a "unified" regular expression representation where all single characters are replaced
by "x" and all character classes are replaced by "[c]".
An immutable representation of a set of Ruby regular expression flags.
An implementation of the Ruby regex flavor.
Implements the parsing and validation of Ruby regular expressions.
A Sequence is a concatenation of
Terms.Container for character matchers of DFA transitions, potentially specialized for a given string
encoding.
This visitor is used for setting the
SourceSection of AST subtrees that are copied into
the parser tree as substitutions for things like word boundaries and position assertions in
multi-line mode.This class is designed as a "scratchpad" for generating many short arrays of unknown size.
Simple base class for implementors of
StateIndex.Matcher that matches a single character.
Matcher for a single character range.
A storage-agnostic implementation of a sorted list of disjoint integer ranges with inclusive
lower and upper bounds.
A specialized set for sequentially indexed objects.
This class provides an algorithm for converting a list of NFA transitions into a set of DFA
transitions.
Bit Set implementation, with a lot of code shamelessly ripped from
BitSet.A common supertype for all
RegexASTNodes except Sequences.This class represents a power-set automaton state transition fragment to be used by
A transition in a power-set automaton consists of a set of transitions of the NFA that the power-set automaton is being built from, and the set of characters it can match.
StateTransitionCanonicalizer.A transition in a power-set automaton consists of a set of transitions of the NFA that the power-set automaton is being built from, and the set of characters it can match.
Transition guards introduced by bounded
Token.Quantifiers.Represents a set of NFA transitions to be used in
TransitionBuilder.Common base class for executor nodes used in
TRegexBacktrackingNFAExecutorNode, where the
top-level executor represents a full regular expression, and all nested sub-executors represent
look-around assertions.Contains the stack used by
TRegexBacktrackingNFAExecutorNode.This regex executor uses a backtracking algorithm on the NFA.
This class is responsible for compiling a single regex pattern.
This class is used to store a trace of the execution of a
TRegexExecutorBaseNode.execute(com.oracle.truffle.api.frame.VirtualFrame, TRegexExecutorLocals, TruffleString.CodeRange).Container for all local variables used in
TRegexDFAExecutorNode.This class wraps
TRegexExecutorNode and specializes on the type of the input strings
provided to TRegexExecNode.Base class for local variables used by an executor node called by a
TRegexExecNode.This regex executor matches a given expression by calculating DFA states from the NFA on the fly,
without any caching.
Represents an array of keys (members) of a TRegex TruffleObject.
Matcher that matches two characters.
Contents of NameAliases.txt.