Label (ANTLR Master build control POM 3.2 API)

java.lang.Object
- org.antlr.analysis.Label

All Implemented Interfaces:

Cloneable, Comparable

Direct Known Subclasses:

ActionLabel, PredicateLabel
```
public class Label
extends Object
implements Comparable, Cloneable
```
A state machine transition label. A label can be either a simple label such as a token or character. A label can be a set of char or tokens. It can be an epsilon transition. It can be a semantic predicate (which assumes an epsilon transition) or a tree of predicates (in a DFA).

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ACTION`
`static int`	`DOWN`
`static int`	`EOF`
`static int`	`EOR_TOKEN_TYPE` End of rule token type; imaginary token type used only for local, partial FOLLOW sets to indicate that the local FOLLOW hit the end of rule.
`static int`	`EOT` End of Token is like EOF for lexer rules.
`static int`	`EPSILON`
`static String`	`EPSILON_STR`
`static int`	`INVALID`
`protected int`	`label` The token type or character value; or, signifies special label.
`protected IntSet`	`labelSet` A set of token types or character codes if label==SET
`static int`	`MAX_CHAR_VALUE`
`static int`	`MIN_ATOM_VALUE` Anything at this value or larger can be considered a simple atom int for easy comparison during analysis only; faux labels are not used during parse time for real token types or char values.
`static int`	`MIN_CHAR_VALUE`
`static int`	`MIN_TOKEN_TYPE` tokens and char range overlap; tokens are MIN_TOKEN_TYPE..n
`static int`	`NUM_FAUX_LABELS` We have labels like EPSILON that are below 0; it's hard to store them in an array with negative index so use this constant as an index shift when accessing arrays based upon token type.
`static int`	`SEMPRED` label is a semantic predicate; implies label is epsilon also
`static int`	`SET` label is a set of tokens or char
`static int`	`UP`

Constructor Summary

Constructors
Constructor and Description

Label(int label)

Label(IntSet labelSet)
Make a set label

Constructors
Constructor and Description
`Label(int label)`
`Label(IntSet labelSet)` Make a set label

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(Label a)`
`Object`	`clone()`
`int`	`compareTo(Object o)`
`boolean`	`equals(Object o)`
`int`	`getAtom()` return the single atom label or INVALID if not a single atom
`SemanticContext`	`getSemanticContext()`
`IntSet`	`getSet()`
`int`	`hashCode()`
`static boolean`	`intersect(Label label, Label edgeLabel)`
`boolean`	`isAction()`
`boolean`	`isAtom()`
`boolean`	`isEpsilon()`
`boolean`	`isSemanticPredicate()`
`boolean`	`isSet()`
`boolean`	`matches(int atom)`
`boolean`	`matches(IntSet set)`
`boolean`	`matches(Label other)`
`void`	`setSet(IntSet set)`
`String`	`toString()` Predicates are lists of AST nodes from the NFA created from the grammar, but the same predicate could be cut/paste into multiple places in the grammar.
`String`	`toString(Grammar g)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - INVALID
```
public static final int INVALID
```
    See Also:
    Constant Field Values
  - ACTION
```
public static final int ACTION
```
    See Also:
    Constant Field Values
  - EPSILON
```
public static final int EPSILON
```
    See Also:
    Constant Field Values
  - EPSILON_STR
```
public static final String EPSILON_STR
```
    See Also:
    Constant Field Values
  - SEMPRED
```
public static final int SEMPRED
```
    label is a semantic predicate; implies label is epsilon also
    
    See Also:
    Constant Field Values
  - SET
```
public static final int SET
```
    label is a set of tokens or char
    
    See Also:
    Constant Field Values
  - EOT
```
public static final int EOT
```
    End of Token is like EOF for lexer rules. It implies that no more characters are available and that NFA conversion should terminate for this path. For example A : 'a' 'b' | 'a' ; yields a DFA predictor: o-a->o-b->1 predict alt 1 | |-EOT->o predict alt 2 To generate code for EOT, treat it as the "default" path, which implies there is no way to mismatch a char for the state from which the EOT emanates.
    
    See Also:
    Constant Field Values
  - EOF
```
public static final int EOF
```
    See Also:
    Constant Field Values
  - NUM_FAUX_LABELS
```
public static final int NUM_FAUX_LABELS
```
    We have labels like EPSILON that are below 0; it's hard to store them in an array with negative index so use this constant as an index shift when accessing arrays based upon token type. If real token type is i, then array index would be NUM_FAUX_LABELS + i.
    
    See Also:
    Constant Field Values
  - MIN_ATOM_VALUE
```
public static final int MIN_ATOM_VALUE
```
    Anything at this value or larger can be considered a simple atom int for easy comparison during analysis only; faux labels are not used during parse time for real token types or char values.
    
    See Also:
    Constant Field Values
  - MIN_CHAR_VALUE
```
public static final int MIN_CHAR_VALUE
```
    See Also:
    Constant Field Values
  - MAX_CHAR_VALUE
```
public static final int MAX_CHAR_VALUE
```
    See Also:
    Constant Field Values
  - EOR_TOKEN_TYPE
```
public static final int EOR_TOKEN_TYPE
```
    End of rule token type; imaginary token type used only for local, partial FOLLOW sets to indicate that the local FOLLOW hit the end of rule. During error recovery, the local FOLLOW of a token reference may go beyond the end of the rule and have to use FOLLOW(rule). I have to just shift the token types to 2..n rather than 1..n to accommodate this imaginary token in my bitsets. If I didn't use a bitset implementation for runtime sets, I wouldn't need this. EOF is another candidate for a run time token type for parsers. Follow sets are not computed for lexers so we do not have this issue.
    
    See Also:
    Constant Field Values
  - DOWN
```
public static final int DOWN
```
    See Also:
    Constant Field Values
  - UP
```
public static final int UP
```
    See Also:
    Constant Field Values
  - MIN_TOKEN_TYPE
```
public static final int MIN_TOKEN_TYPE
```
    tokens and char range overlap; tokens are MIN_TOKEN_TYPE..n
    
    See Also:
    Constant Field Values
  - label
```
protected int label
```
    The token type or character value; or, signifies special label.
  - labelSet
```
protected IntSet labelSet
```
    A set of token types or character codes if label==SET
- Constructor Detail
  - Label
```
public Label(int label)
```
  - Label
```
public Label(IntSet labelSet)
```
    Make a set label
- Method Detail
  - clone
```
public Object clone()
```
    Overrides:
    
    clone in class Object
  - add
```
public void add(Label a)
```
  - isAtom
```
public boolean isAtom()
```
  - isEpsilon
```
public boolean isEpsilon()
```
  - isSemanticPredicate
```
public boolean isSemanticPredicate()
```
  - isAction
```
public boolean isAction()
```
  - isSet
```
public boolean isSet()
```
  - getAtom
```
public int getAtom()
```
    return the single atom label or INVALID if not a single atom
  - getSet
```
public IntSet getSet()
```
  - setSet
```
public void setSet(IntSet set)
```
  - getSemanticContext
```
public SemanticContext getSemanticContext()
```
  - matches
```
public boolean matches(int atom)
```
  - matches
```
public boolean matches(IntSet set)
```
  - matches
```
public boolean matches(Label other)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - compareTo
```
public int compareTo(Object o)
```
    Specified by:
    
    compareTo in interface Comparable
  - toString
```
public String toString()
```
    Predicates are lists of AST nodes from the NFA created from the grammar, but the same predicate could be cut/paste into multiple places in the grammar. I must compare the text of all the predicates to truly answer whether {p1,p2} .equals {p1,p2}. Unfortunately, I cannot rely on the AST.equals() to work properly so I must do a brute force O(n^2) nested traversal of the Set doing a String compare. At this point, Labels are not compared for equals when they are predicates, but here's the code for future use.
    
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(Grammar g)
```
  - intersect
```
public static boolean intersect(Label label,
                Label edgeLabel)
```

Class Label

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INVALID

ACTION

EPSILON

EPSILON_STR

SEMPRED

SET

EOT

EOF

NUM_FAUX_LABELS

MIN_ATOM_VALUE

MIN_CHAR_VALUE

MAX_CHAR_VALUE

EOR_TOKEN_TYPE

DOWN

UP

MIN_TOKEN_TYPE

label

labelSet

Constructor Detail

Label

Label

Method Detail

clone

add

isAtom

isEpsilon

isSemanticPredicate

isAction

isSet

getAtom

getSet

setSet

getSemanticContext

matches

matches

matches

hashCode

equals

compareTo

toString

toString

intersect