RegexASTNode

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

All Implemented Interfaces:: IndexedState, JsonConvertible

Direct Known Subclasses:: Sequence, Term

public abstract class RegexASTNode
extends Object
implements IndexedState, JsonConvertible

Field Summary

Fields
Modifier and Type	Field and Description
`protected static short`	`FLAG_CHARACTER_CLASS_WAS_SINGLE_CHAR`
`protected static short`	`FLAG_EMPTY_GUARD`
`protected static short`	`FLAG_GROUP_EXPANDED_QUANTIFIER`
`protected static short`	`FLAG_GROUP_LOOP`
`protected static short`	`FLAG_HAS_LOOPS`
`protected static short`	`FLAG_LOOK_AROUND_NEGATED`

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
`protected static JsonValue`	`astNodeId(RegexASTNode astNode)`
`abstract RegexASTNode`	`copy(RegexAST ast, boolean recursive)` Copy this node, in one of the following ways: if `recursive` is `true`, recursively copy this subtree.
`boolean`	`endsWithDollar()`
`abstract boolean`	`equalsSemantic(RegexASTNode obj)`
`short`	`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`	`hasEmptyGuard()` Indicates whether or not this node should be allowed to match the empty string.
`boolean`	`hasLoops()`
`boolean`	`idInitialized()`
`void`	`incMaxPath()`
`void`	`incMaxPath(int n)`
`void`	`incMinPath()`
`void`	`incMinPath(int n)`
`boolean`	`isDead()` Returns whether the node is dead, i.e.
`protected boolean`	`isFlagSet(short flag)`
`boolean`	`isInLookAheadAssertion()`
`boolean`	`isInLookBehindAssertion()`
`boolean`	`isPrefix()` This flag marks all nodes that were inserted into the AST for look-behind matching, see `MarkLookBehindEntriesVisitor` and `RegexAST.createPrefix()`.
`void`	`markAsDead()` Marks the node as dead, i.e.
`void`	`setEmptyGuard(boolean emptyGuard)`
`void`	`setEndsWithDollar()`
`void`	`setEndsWithDollar(boolean endsWithDollar)`
`protected void`	`setFlag(short flag)`
`protected void`	`setFlag(short flag, boolean value)`
`void`	`setHasLoops()`
`void`	`setHasLoops(boolean hasLoops)`
`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()`
`protected JsonObject`	`toJson(String typeName)`
`String`	`toStringWithID()`

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

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

- Field Detail
  - FLAG_GROUP_LOOP
```
protected static final short FLAG_GROUP_LOOP
```
    See Also:
    
    Constant Field Values
  - FLAG_GROUP_EXPANDED_QUANTIFIER
```
protected static final short FLAG_GROUP_EXPANDED_QUANTIFIER
```
    See Also:
    
    Constant Field Values
  - FLAG_LOOK_AROUND_NEGATED
```
protected static final short FLAG_LOOK_AROUND_NEGATED
```
    See Also:
    
    Constant Field Values
  - FLAG_EMPTY_GUARD
```
protected static final short FLAG_EMPTY_GUARD
```
    See Also:
    
    Constant Field Values
  - FLAG_HAS_LOOPS
```
protected static final short FLAG_HAS_LOOPS
```
    See Also:
    
    Constant Field Values
  - FLAG_CHARACTER_CLASS_WAS_SINGLE_CHAR
```
protected static final short FLAG_CHARACTER_CLASS_WAS_SINGLE_CHAR
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RegexASTNode
```
protected RegexASTNode()
```
  - RegexASTNode
```
protected RegexASTNode(RegexASTNode copy)
```
- Method Detail
  - copy
```
public abstract RegexASTNode copy(RegexAST ast,
                                  boolean recursive)
```
    Copy this node, in one of the following ways:
    - if recursive is true, recursively copy this subtree. This method should be used instead of CopyVisitor if the copying process is required to be thread-safe.
    - else, copy this node only, without any child nodes.
    In both cases, the ID and minPath of the copied nodes is left unset.
    Parameters:
    
    ast - RegexAST the new nodes should belong to.
    
    Returns:
    
    A shallow or deep copy of this node.
  - equalsSemantic
```
public abstract boolean equalsSemantic(RegexASTNode obj)
```
  - idInitialized
```
public boolean idInitialized()
```
  - getId
```
public short getId()
```
    Specified by:
    
    getId in interface IndexedState
  - setId
```
public 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(short flag)
```
  - setFlag
```
protected void setFlag(short flag)
```
  - setFlag
```
protected void setFlag(short flag,
                       boolean value)
```
  - markAsDead
```
public void markAsDead()
```
    Marks the node as dead, i.e. unmatchable.
  - 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()
  - startsWithCaret
```
public boolean startsWithCaret()
```
  - setStartsWithCaret
```
public void setStartsWithCaret()
```
  - setStartsWithCaret
```
public void setStartsWithCaret(boolean startsWithCaret)
```
  - endsWithDollar
```
public boolean endsWithDollar()
```
  - setEndsWithDollar
```
public void setEndsWithDollar()
```
  - setEndsWithDollar
```
public void setEndsWithDollar(boolean endsWithDollar)
```
  - setHasLoops
```
public void setHasLoops()
```
  - setHasLoops
```
public void setHasLoops(boolean hasLoops)
```
  - hasLoops
```
public boolean hasLoops()
```
  - 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)
```
  - 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)
```
  - toJson
```
protected JsonObject toJson(String typeName)
```

Class RegexASTNode

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

FLAG_GROUP_LOOP

FLAG_GROUP_EXPANDED_QUANTIFIER

FLAG_LOOK_AROUND_NEGATED

FLAG_EMPTY_GUARD

FLAG_HAS_LOOPS

FLAG_CHARACTER_CLASS_WAS_SINGLE_CHAR

Constructor Detail

RegexASTNode

RegexASTNode

Method Detail

copy

equalsSemantic

idInitialized

getId

setId

getParent

setParent

isFlagSet

setFlag

setFlag

markAsDead

isDead

isPrefix

setPrefix

startsWithCaret

setStartsWithCaret

setStartsWithCaret

endsWithDollar

setEndsWithDollar

setEndsWithDollar

setHasLoops

setHasLoops

hasLoops

hasEmptyGuard

setEmptyGuard

getMinPath

setMinPath

incMinPath

incMinPath

getMaxPath

setMaxPath

incMaxPath

incMaxPath

getSubTreeParent

isInLookBehindAssertion

isInLookAheadAssertion

toStringWithID

astNodeId

toJson