RegexASTNode

java.lang.Object
- com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode

All Implemented Interfaces:: JsonConvertible

Direct Known Subclasses:: Sequence, Term

public abstract class RegexASTNode
extends Object
implements JsonConvertible

Constructor Summary

Constructors
Modifier Constructor and Description

protected RegexASTNode()

protected RegexASTNode(RegexASTNode copy)

Constructors
Modifier	Constructor and Description
`protected`	`RegexASTNode()`
`protected`	`RegexASTNode(RegexASTNode copy)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`AtomicGroup`	`asAtomicGroup()`
`BackReference`	`asBackReference()`
`CharacterClass`	`asCharacterClass()`
`Group`	`asGroup()`
`LookAheadAssertion`	`asLookAheadAssertion()`
`LookAroundAssertion`	`asLookAroundAssertion()`
`LookBehindAssertion`	`asLookBehindAssertion()`
`MatchFound`	`asMatchFound()`
`PositionAssertion`	`asPositionAssertion()`
`QuantifiableTerm`	`asQuantifiableTerm()`
`Sequence`	`asSequence()`
`RegexASTSubtreeRootNode`	`asSubtreeRootNode()`
`protected static JsonValue`	`astNodeId(RegexASTNode astNode)`
`abstract RegexASTNode`	`copy(RegexAST ast)` Copy this node only, without any child nodes.
`abstract RegexASTNode`	`copyRecursive(RegexAST ast, CompilationBuffer compilationBuffer)` Recursively copy this subtree.
`boolean`	`endsWithDollar()` All paths out of this subexpression go through `"$"`.
`abstract boolean`	`equalsSemantic(RegexASTNode obj)`
`protected int`	`getFlags(int mask)`
`int`	`getId()`
`int`	`getMaxPath()`
`int`	`getMinPath()`
`RegexASTNode`	`getParent()` Gets the syntactic parent of this AST node.
`abstract RegexASTSubtreeRootNode`	`getSubTreeParent()` Returns the subtree root node that this node is a part of.
`boolean`	`hasBackReferences()` Subexpression contains `back-references`.
`boolean`	`hasCaptureGroups()` Subexpression contains `capturing groups`.
`boolean`	`hasCaret()` Subexpression contains `"^"`.
`boolean`	`hasDollar()` Subexpression contains `"$"`.
`boolean`	`hasEmptyGuard()` Indicates whether or not this node should be allowed to match the empty string.
`boolean`	`hasLookAheads()` Subexpression contains `look-ahead assertions`.
`boolean`	`hasLookBehinds()` Subexpression contains `look-behind assertions`.
`boolean`	`hasLoops()` Subexpression contains `loops`.
`boolean`	`hasQuantifiers()` Subexpression contains `not unrolled quantifiers`.
`boolean`	`idInitialized()`
`void`	`incMaxPath()`
`void`	`incMaxPath(int n)`
`void`	`incMinPath()`
`void`	`incMinPath(int n)`
`boolean`	`isAtomicGroup()`
`boolean`	`isBackReference()`
`boolean`	`isCaret()`
`boolean`	`isCharacterClass()`
`boolean`	`isDead()` Returns whether the node is dead, i.e.
`boolean`	`isDollar()`
`boolean`	`isExpandedQuantifier()` Indicates whether this `RegexASTNode` was inserted into the AST as the result of expanding quantifier syntax (*, +, ?, {n,m}).
`protected boolean`	`isFlagSet(int flag)`
`boolean`	`isGroup()`
`boolean`	`isInLookAheadAssertion()`
`boolean`	`isInLookBehindAssertion()`
`boolean`	`isLookAheadAssertion()`
`boolean`	`isLookAroundAssertion()`
`boolean`	`isLookBehindAssertion()`
`boolean`	`isMatchFound()`
`boolean`	`isPositionAssertion()`
`boolean`	`isPrefix()` This flag marks all nodes that were inserted into the AST for look-behind matching, see `MarkLookBehindEntriesVisitor` and `RegexAST.createPrefix()`.
`boolean`	`isQuantifiableTerm()`
`boolean`	`isRoot()`
`boolean`	`isSequence()`
`boolean`	`isSubtreeRoot()`
`void`	`markAsDead()` Marks the node as dead, i.e.
`void`	`setDead(boolean dead)`
`void`	`setEmptyGuard(boolean emptyGuard)`
`void`	`setEndsWithDollar()`
`void`	`setEndsWithDollar(boolean endsWithDollar)`
`void`	`setExpandedQuantifier(boolean expandedQuantifier)` Marks this `RegexASTNode` as being inserted into the AST as part of expanding quantifier syntax (*, +, ?, {n,m}).
`protected void`	`setFlag(int flag)`
`protected void`	`setFlag(int flag, boolean value)`
`protected void`	`setFlags(int newFlags, int mask)` Update all flags denoted by `mask` with the values from `newFlags`.
`void`	`setHasBackReferences()`
`void`	`setHasCaptureGroups()`
`void`	`setHasCaret()`
`void`	`setHasCaret(boolean hasCaret)`
`void`	`setHasDollar()`
`void`	`setHasDollar(boolean hasDollar)`
`void`	`setHasLookAheads()`
`void`	`setHasLookBehinds()`
`void`	`setHasLoops()`
`void`	`setHasLoops(boolean hasLoops)`
`void`	`setHasQuantifiers()`
`void`	`setId(int id)`
`void`	`setMaxPath(int n)`
`void`	`setMinPath(int n)`
`void`	`setParent(RegexASTNode parent)` Sets the syntactic parent of this AST node.
`void`	`setPrefix()` Sets the `RegexASTNode.isPrefix()` flag to true.
`void`	`setStartsWithCaret()`
`void`	`setStartsWithCaret(boolean startsWithCaret)`
`boolean`	`startsWithCaret()` This subexpression is dominated by `"^"`.
`protected JsonObject`	`toJson(String typeName)`
`String`	`toStringWithID()`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.oracle.truffle.regex.tregex.util.json.JsonConvertible
toJson

- Constructor Detail
  - RegexASTNode
```
protected RegexASTNode()
```
  - RegexASTNode
```
protected RegexASTNode(RegexASTNode copy)
```
- Method Detail
  - copy
```
public abstract RegexASTNode copy(RegexAST ast)
```
    Copy this node only, without any child nodes. The ID and minPath of the copied nodes is left unset.
    
    Parameters:
    
    ast - RegexAST the node should belong to.
    
    Returns:
    
    A shallow copy of this node.
  - copyRecursive
```
public abstract RegexASTNode copyRecursive(RegexAST ast,
                                           CompilationBuffer compilationBuffer)
```
    Recursively copy this subtree. This method should be used instead of CopyVisitor if the copying process is required to be thread-safe. The ID and minPath of the copied nodes is left unset.
    
    Parameters:
    
    ast - RegexAST the new nodes should belong to.
    
    Returns:
    
    A deep copy of this node.
  - equalsSemantic
```
public abstract boolean equalsSemantic(RegexASTNode obj)
```
  - idInitialized
```
public boolean idInitialized()
```
  - getId
```
public final int getId()
```
  - setId
```
public final void setId(int id)
```
  - getParent
```
public RegexASTNode getParent()
```
    Gets the syntactic parent of this AST node.
  - setParent
```
public void setParent(RegexASTNode parent)
```
    Sets the syntactic parent of this AST node.
    
    Parameters:
    
    parent -
  - isFlagSet
```
protected boolean isFlagSet(int flag)
```
  - setFlag
```
protected void setFlag(int flag)
```
  - getFlags
```
protected int getFlags(int mask)
```
  - setFlags
```
protected void setFlags(int newFlags,
                        int mask)
```
    Update all flags denoted by mask with the values from newFlags.
  - setFlag
```
protected void setFlag(int flag,
                       boolean value)
```
  - markAsDead
```
public void markAsDead()
```
    Marks the node as dead, i.e. unmatchable.
  - setDead
```
public void setDead(boolean dead)
```
  - isDead
```
public boolean isDead()
```
    Returns whether the node is dead, i.e. unmatchable.
  - isPrefix
```
public boolean isPrefix()
```
    This flag marks all nodes that were inserted into the AST for look-behind matching, see MarkLookBehindEntriesVisitor and RegexAST.createPrefix().
    
    Returns:
    
    true if this node belongs to an inserted prefix construct, otherwise false.
  - setPrefix
```
public void setPrefix()
```
    Sets the RegexASTNode.isPrefix() flag to true.
    
    See Also:
    
    RegexASTNode.isPrefix()
  - hasEmptyGuard
```
public boolean hasEmptyGuard()
```
    Indicates whether or not this node should be allowed to match the empty string.
    
    Returns:
    
    true if this node is not allowed to match the empty string
  - setEmptyGuard
```
public void setEmptyGuard(boolean emptyGuard)
```
  - hasCaret
```
public boolean hasCaret()
```
    Subexpression contains "^".
  - setHasCaret
```
public void setHasCaret()
```
  - setHasCaret
```
public void setHasCaret(boolean hasCaret)
```
  - hasDollar
```
public boolean hasDollar()
```
    Subexpression contains "$".
  - setHasDollar
```
public void setHasDollar()
```
  - setHasDollar
```
public void setHasDollar(boolean hasDollar)
```
  - startsWithCaret
```
public boolean startsWithCaret()
```
    This subexpression is dominated by "^".
  - setStartsWithCaret
```
public void setStartsWithCaret()
```
  - setStartsWithCaret
```
public void setStartsWithCaret(boolean startsWithCaret)
```
  - endsWithDollar
```
public boolean endsWithDollar()
```
    All paths out of this subexpression go through "$".
  - setEndsWithDollar
```
public void setEndsWithDollar()
```
  - setEndsWithDollar
```
public void setEndsWithDollar(boolean endsWithDollar)
```
  - hasLoops
```
public boolean hasLoops()
```
    Subexpression contains loops.
  - setHasLoops
```
public void setHasLoops()
```
  - setHasLoops
```
public void setHasLoops(boolean hasLoops)
```
  - hasQuantifiers
```
public boolean hasQuantifiers()
```
    Subexpression contains not unrolled quantifiers.
  - setHasQuantifiers
```
public void setHasQuantifiers()
```
  - hasCaptureGroups
```
public boolean hasCaptureGroups()
```
    Subexpression contains capturing groups.
  - setHasCaptureGroups
```
public void setHasCaptureGroups()
```
  - hasLookAheads
```
public boolean hasLookAheads()
```
    Subexpression contains look-ahead assertions.
  - setHasLookAheads
```
public void setHasLookAheads()
```
  - hasLookBehinds
```
public boolean hasLookBehinds()
```
    Subexpression contains look-behind assertions.
  - setHasLookBehinds
```
public void setHasLookBehinds()
```
  - hasBackReferences
```
public boolean hasBackReferences()
```
    Subexpression contains back-references.
  - setHasBackReferences
```
public void setHasBackReferences()
```
  - isExpandedQuantifier
```
public boolean isExpandedQuantifier()
```
    Indicates whether this RegexASTNode was inserted into the AST as the result of expanding quantifier syntax (*, +, ?, {n,m}). E.g., if A is some term, then:
    - A* is expanded as (A|)*
    - A*? is expanded as (|A)*
    - A+ is expanded as A(A|)*
    - A+? is expanded as A(|A)*
    - A? is expanded as (A|)
    - A?? is expanded as (|A)
    - A{2,4} is expanded as AA(A|)(A|)
    - A{2,4}? is expanded as AA(|A)(|A)
    where (X|Y) is a group with alternatives X and Y and (X|Y)* is a looping group with alternatives X and Y. In the examples above, all of the occurrences of A in the expansions as well as the additional empty Sequences would be marked with this flag.
  - setExpandedQuantifier
```
public void setExpandedQuantifier(boolean expandedQuantifier)
```
    Marks this RegexASTNode as being inserted into the AST as part of expanding quantifier syntax (*, +, ?, {n,m}).
    
    See Also:
    
    RegexASTNode.isExpandedQuantifier()
  - getMinPath
```
public int getMinPath()
```
  - setMinPath
```
public void setMinPath(int n)
```
  - incMinPath
```
public void incMinPath()
```
  - incMinPath
```
public void incMinPath(int n)
```
  - getMaxPath
```
public int getMaxPath()
```
  - setMaxPath
```
public void setMaxPath(int n)
```
  - incMaxPath
```
public void incMaxPath()
```
  - incMaxPath
```
public void incMaxPath(int n)
```
  - getSubTreeParent
```
public abstract RegexASTSubtreeRootNode getSubTreeParent()
```
    Returns the subtree root node that this node is a part of. If this node is nested inside several look-around assertion nodes, returns the innermost one that contains this node. Every AST node should have a subtree parent, but nodes implicitly generated by RegexAST.getNFAAnchoredInitialState(int) and RegexAST.getNFAUnAnchoredInitialState(int) technically don't belong to the AST, so they will return null.
  - isInLookBehindAssertion
```
public boolean isInLookBehindAssertion()
```
  - isInLookAheadAssertion
```
public boolean isInLookAheadAssertion()
```
  - toStringWithID
```
public String toStringWithID()
```
  - astNodeId
```
protected static JsonValue astNodeId(RegexASTNode astNode)
```
  - isBackReference
```
public boolean isBackReference()
```
  - isCharacterClass
```
public boolean isCharacterClass()
```
  - isGroup
```
public boolean isGroup()
```
  - isLookAroundAssertion
```
public boolean isLookAroundAssertion()
```
  - isLookAheadAssertion
```
public boolean isLookAheadAssertion()
```
  - isLookBehindAssertion
```
public boolean isLookBehindAssertion()
```
  - isAtomicGroup
```
public boolean isAtomicGroup()
```
  - isMatchFound
```
public boolean isMatchFound()
```
  - isPositionAssertion
```
public boolean isPositionAssertion()
```
  - isQuantifiableTerm
```
public boolean isQuantifiableTerm()
```
  - isRoot
```
public boolean isRoot()
```
  - isSubtreeRoot
```
public boolean isSubtreeRoot()
```
  - isSequence
```
public boolean isSequence()
```
  - isCaret
```
public boolean isCaret()
```
  - isDollar
```
public boolean isDollar()
```
  - asBackReference
```
public BackReference asBackReference()
```
  - asCharacterClass
```
public CharacterClass asCharacterClass()
```
  - asGroup
```
public Group asGroup()
```
  - asLookAroundAssertion
```
public LookAroundAssertion asLookAroundAssertion()
```
  - asLookAheadAssertion
```
public LookAheadAssertion asLookAheadAssertion()
```
  - asLookBehindAssertion
```
public LookBehindAssertion asLookBehindAssertion()
```
  - asAtomicGroup
```
public AtomicGroup asAtomicGroup()
```
  - asSubtreeRootNode
```
public RegexASTSubtreeRootNode asSubtreeRootNode()
```
  - asMatchFound
```
public MatchFound asMatchFound()
```
  - asPositionAssertion
```
public PositionAssertion asPositionAssertion()
```
  - asQuantifiableTerm
```
public QuantifiableTerm asQuantifiableTerm()
```
  - asSequence
```
public Sequence asSequence()
```
  - toJson
```
protected JsonObject toJson(String typeName)
```

Class RegexASTNode

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.oracle.truffle.regex.tregex.util.json.JsonConvertible

Constructor Detail

RegexASTNode

RegexASTNode

Method Detail

copy

copyRecursive

equalsSemantic

idInitialized

getId

setId

getParent

setParent

isFlagSet

setFlag

getFlags

setFlags

setFlag

markAsDead

setDead

isDead

isPrefix

setPrefix

hasEmptyGuard

setEmptyGuard

hasCaret

setHasCaret

setHasCaret

hasDollar

setHasDollar

setHasDollar

startsWithCaret

setStartsWithCaret

setStartsWithCaret

endsWithDollar

setEndsWithDollar

setEndsWithDollar

hasLoops

setHasLoops

setHasLoops

hasQuantifiers

setHasQuantifiers

hasCaptureGroups

setHasCaptureGroups

hasLookAheads

setHasLookAheads

hasLookBehinds

setHasLookBehinds

hasBackReferences

setHasBackReferences

isExpandedQuantifier

setExpandedQuantifier

getMinPath

setMinPath

incMinPath

incMinPath

getMaxPath

setMaxPath

incMaxPath

incMaxPath

getSubTreeParent

isInLookBehindAssertion

isInLookAheadAssertion

toStringWithID

astNodeId

isBackReference

isCharacterClass

isGroup

isLookAroundAssertion

isLookAheadAssertion

isLookBehindAssertion

isAtomicGroup

isMatchFound

isPositionAssertion

isQuantifiableTerm

isRoot