Target (ANTLR 4 Tool 4.11.1.4 API)

java.lang.Object
- org.antlr.v4.codegen.Target

Direct Known Subclasses:: JavaTarget

public abstract class Target
extends Object

Field Summary

Fields
Modifier and Type	Field and Description
`protected CodeGenerator`	`gen`
`protected String[]`	`targetCharValueEscape` For pure strings of Java 16-bit Unicode char, how can we display it in the target language as a literal.

Constructor Summary

Constructors
Modifier Constructor and Description

protected Target(CodeGenerator gen, String language)

Constructors
Modifier	Constructor and Description
`protected`	`Target(CodeGenerator gen, String language)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract void`	`appendUnicodeEscapedCodePoint(int codePoint, StringBuilder sb)` Escape the Unicode code point appropriately for this language and append the escaped value to `sb`.
`abstract String`	`encodeIntAsCharEscape(int v)` Assume 16-bit char
`protected void`	`genFile(Grammar g, org.stringtemplate.v4.ST outputFileST, String fileName)`
`String`	`getAltLabelContextStructName(String label)`
`String`	`getBaseListenerFileName(boolean header)` A given grammar T, return a blank listener implementation such as TBaseListener.java, if we're using the Java target.
`String`	`getBaseVisitorFileName(boolean header)` A given grammar T, return a blank listener implementation such as TBaseListener.java, if we're using the Java target.
`CodeGenerator`	`getCodeGenerator()`
`String`	`getElementListName(String name)`
`String`	`getElementName(String name)`
`String`	`getImplicitRuleLabel(String ruleName)`
`String`	`getImplicitSetLabel(String id)`
`String`	`getImplicitTokenLabel(String tokenName)`
`int`	`getInlineTestSetWordSize()` How many bits should be used to do inline token type tests? Java assumes a 64-bit word for bitsets.
`String`	`getLanguage()`
`String`	`getListenerFileName(boolean header)` A given grammar T, return the listener name such as TListener.java, if we're using the Java target.
`String`	`getListLabel(String label)`
`String`	`getLoopCounter(GrammarAST ast)`
`String`	`getLoopLabel(GrammarAST ast)`
`String`	`getRecognizerFileName(boolean header)` Generate TParser.java and TLexer.java from T.g4 if combined, else just use T.java as output regardless of type.
`String`	`getRuleFunctionContextStructName(Rule r)`
`String`	`getRuleFunctionContextStructName(RuleFunction function)` If we know which actual function, we can provide the actual ctx type.
`int`	`getSerializedATNSegmentLimit()` Gets the maximum number of 16-bit unsigned integers that can be encoded in a single segment of the serialized ATN.
`abstract String`	`getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator generator, String literal, boolean addQuotes)` Convert from an ANTLR string literal found in a grammar file to an equivalent string literal in the target language.
`String`	`getTargetStringLiteralFromString(String s)`
`String`	`getTargetStringLiteralFromString(String s, boolean quoted)` Given a random string of Java unicode chars, return a new string with optionally appropriate quote characters for target language and possibly with some escaped characters.
`org.stringtemplate.v4.STGroup`	`getTemplates()`
`String`	`getTokenTypeAsTargetLabel(Grammar g, int ttype)` Get a meaningful name for a token type useful during code generation.
`String[]`	`getTokenTypesAsTargetLabels(Grammar g, int[] ttypes)`
`String`	`getVisitorFileName(boolean header)` A given grammar T, return the visitor name such as TVisitor.java, if we're using the Java target.
`boolean`	`grammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode)`
`protected org.stringtemplate.v4.STGroup`	`loadTemplates()`
`boolean`	`needsHeader()`
`protected boolean`	`shouldUseUnicodeEscapeForCodePointInDoubleQuotedString(int codePoint)`
`boolean`	`supportsOverloadedMethods()`
`protected abstract boolean`	`visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode)`
`boolean`	`wantsBaseListener()`
`boolean`	`wantsBaseVisitor()`

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

- Field Detail
  - targetCharValueEscape
```
protected String[] targetCharValueEscape
```
    For pure strings of Java 16-bit Unicode char, how can we display it in the target language as a literal. Useful for dumping predicates and such that may refer to chars that need to be escaped when represented as strings. Also, templates need to be escaped so that the target language can hold them as a string.
    I have defined (via the constructor) the set of typical escapes, but your Target subclass is free to alter the translated chars or add more definitions. This is non-static so each target can have a different set in memory at same time.
  - gen
```
protected final CodeGenerator gen
```
- Constructor Detail
  - Target
```
protected Target(CodeGenerator gen,
                 String language)
```
- Method Detail
  - getCodeGenerator
```
public CodeGenerator getCodeGenerator()
```
  - getLanguage
```
public String getLanguage()
```
  - getTemplates
```
@NotNull
public org.stringtemplate.v4.STGroup getTemplates()
```
  - genFile
```
protected void genFile(Grammar g,
                       org.stringtemplate.v4.ST outputFileST,
                       String fileName)
```
  - getTokenTypeAsTargetLabel
```
public String getTokenTypeAsTargetLabel(Grammar g,
                                        int ttype)
```
    Get a meaningful name for a token type useful during code generation. Literals without associated names are converted to the string equivalent of their integer values. Used to generate x==ID and x==34 type comparisons etc... Essentially we are looking for the most obvious way to refer to a token type in the generated code.
  - getTokenTypesAsTargetLabels
```
public String[] getTokenTypesAsTargetLabels(Grammar g,
                                            int[] ttypes)
```
  - getTargetStringLiteralFromString
```
public String getTargetStringLiteralFromString(String s,
                                               boolean quoted)
```
    Given a random string of Java unicode chars, return a new string with optionally appropriate quote characters for target language and possibly with some escaped characters. For example, if the incoming string has actual newline characters, the output of this method would convert them to the two char sequence \n for Java, C, C++, ... The new string has double-quotes around it as well. Example String in memory: a"[newlinechar]b'c[carriagereturnchar]d[tab]e\f would be converted to the valid Java s: "a\"\nb'c\rd\te\\f" or a\"\nb'c\rd\te\\f depending on the quoted arg.
  - appendUnicodeEscapedCodePoint
```
protected abstract void appendUnicodeEscapedCodePoint(int codePoint,
                                                      StringBuilder sb)
```
    Escape the Unicode code point appropriately for this language and append the escaped value to sb.
  - getTargetStringLiteralFromString
```
public String getTargetStringLiteralFromString(String s)
```
  - getTargetStringLiteralFromANTLRStringLiteral
```
public abstract String getTargetStringLiteralFromANTLRStringLiteral(CodeGenerator generator,
                                                                    String literal,
                                                                    boolean addQuotes)
```
    Convert from an ANTLR string literal found in a grammar file to an equivalent string literal in the target language.
  - shouldUseUnicodeEscapeForCodePointInDoubleQuotedString
```
protected boolean shouldUseUnicodeEscapeForCodePointInDoubleQuotedString(int codePoint)
```
  - encodeIntAsCharEscape
```
public abstract String encodeIntAsCharEscape(int v)
```
    Assume 16-bit char
  - getLoopLabel
```
public String getLoopLabel(GrammarAST ast)
```
  - getLoopCounter
```
public String getLoopCounter(GrammarAST ast)
```
  - getListLabel
```
public String getListLabel(String label)
```
  - getRuleFunctionContextStructName
```
public String getRuleFunctionContextStructName(Rule r)
```
  - getAltLabelContextStructName
```
public String getAltLabelContextStructName(String label)
```
  - getRuleFunctionContextStructName
```
public String getRuleFunctionContextStructName(RuleFunction function)
```
    If we know which actual function, we can provide the actual ctx type. This will contain implicit labels etc... From outside, though, we see only ParserRuleContext unless there are externally visible stuff like args, locals, explicit labels, etc...
  - getImplicitTokenLabel
```
public String getImplicitTokenLabel(String tokenName)
```
  - getImplicitSetLabel
```
public String getImplicitSetLabel(String id)
```
  - getImplicitRuleLabel
```
public String getImplicitRuleLabel(String ruleName)
```
  - getElementListName
```
public String getElementListName(String name)
```
  - getElementName
```
public String getElementName(String name)
```
  - getRecognizerFileName
```
public String getRecognizerFileName(boolean header)
```
    Generate TParser.java and TLexer.java from T.g4 if combined, else just use T.java as output regardless of type.
  - getListenerFileName
```
public String getListenerFileName(boolean header)
```
    A given grammar T, return the listener name such as TListener.java, if we're using the Java target.
  - getVisitorFileName
```
public String getVisitorFileName(boolean header)
```
    A given grammar T, return the visitor name such as TVisitor.java, if we're using the Java target.
  - getBaseListenerFileName
```
public String getBaseListenerFileName(boolean header)
```
    A given grammar T, return a blank listener implementation such as TBaseListener.java, if we're using the Java target.
  - getBaseVisitorFileName
```
public String getBaseVisitorFileName(boolean header)
```
    A given grammar T, return a blank listener implementation such as TBaseListener.java, if we're using the Java target.
  - getSerializedATNSegmentLimit
```
public int getSerializedATNSegmentLimit()
```
    Gets the maximum number of 16-bit unsigned integers that can be encoded in a single segment of the serialized ATN.
    
    Returns:
    
    the serialized ATN segment limit
    
    See Also:
    
    SerializedATN.getSegments()
  - getInlineTestSetWordSize
```
public int getInlineTestSetWordSize()
```
    How many bits should be used to do inline token type tests? Java assumes a 64-bit word for bitsets. Must be a valid wordsize for your target like 8, 16, 32, 64, etc...
    
    Since:
    
    4.5
  - grammarSymbolCausesIssueInGeneratedCode
```
public boolean grammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode)
```
  - visibleGrammarSymbolCausesIssueInGeneratedCode
```
protected abstract boolean visibleGrammarSymbolCausesIssueInGeneratedCode(GrammarAST idNode)
```
  - loadTemplates
```
@NotNull
protected org.stringtemplate.v4.STGroup loadTemplates()
```
  - wantsBaseListener
```
public boolean wantsBaseListener()
```
    Since:
    
    4.3
  - wantsBaseVisitor
```
public boolean wantsBaseVisitor()
```
    Since:
    
    4.3
  - supportsOverloadedMethods
```
public boolean supportsOverloadedMethods()
```
    Since:
    
    4.3
  - needsHeader
```
public boolean needsHeader()
```
    Since:
    
    4.6

Class Target

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

targetCharValueEscape

gen

Constructor Detail

Target

Method Detail

getCodeGenerator

getLanguage

getTemplates

genFile

getTokenTypeAsTargetLabel

getTokenTypesAsTargetLabels

getTargetStringLiteralFromString

appendUnicodeEscapedCodePoint

getTargetStringLiteralFromString

getTargetStringLiteralFromANTLRStringLiteral

shouldUseUnicodeEscapeForCodePointInDoubleQuotedString

encodeIntAsCharEscape

getLoopLabel

getLoopCounter

getListLabel

getRuleFunctionContextStructName

getAltLabelContextStructName

getRuleFunctionContextStructName

getImplicitTokenLabel

getImplicitSetLabel

getImplicitRuleLabel

getElementListName

getElementName

getRecognizerFileName

getListenerFileName

getVisitorFileName

getBaseListenerFileName

getBaseVisitorFileName

getSerializedATNSegmentLimit

getInlineTestSetWordSize

grammarSymbolCausesIssueInGeneratedCode

visibleGrammarSymbolCausesIssueInGeneratedCode

loadTemplates

wantsBaseListener

wantsBaseVisitor

supportsOverloadedMethods

needsHeader