org.antlr.codegen

Class RubyTarget

java.lang.Object

org.antlr.codegen.Target

org.antlr.codegen.RubyTarget

public class RubyTarget
extends Target

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	RubyTarget.RubyRenderer

Field Summary

Fields

Modifier and Type	Field and Description
static Set<String>	rubyKeywords A set of ruby keywords which are used to escape labels and method names which will cause parse errors in the ruby source
static Map<String,Map<String,Object>>	sharedActionBlocks

Fields inherited from class org.antlr.codegen.Target

targetCharValueEscape

Constructor Summary

Constructors

Constructor and Description
RubyTarget()

Method Summary

Methods

Modifier and Type	Method and Description
String	encodeIntAsCharEscape(int v)
protected void	genRecognizerFile(Tool tool, CodeGenerator generator, Grammar grammar, org.stringtemplate.v4.ST outputFileST)
int	getMaxCharValue(CodeGenerator generator) Some targets only support ASCII or 8-bit chars/strings.
String	getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator generator, String literal) Convert from an ANTLR char literal found in a grammar file to an equivalent char literal in the target language.
String	getTokenTypeAsTargetLabel(CodeGenerator generator, int ttype) Target must be able to override the labels used for token types
boolean	isValidActionScope(int grammarType, String scope) Is scope in @scope::name {action} valid for this kind of grammar? Targets like C++ may want to allow new scopes like headerfile or some such.

Methods inherited from class org.antlr.codegen.Target

genRecognizerHeaderFile, getTarget64BitStringFromValue, getTargetStringLiteralFromANTLRStringLiteral, getTargetStringLiteralFromString, getTargetStringLiteralFromString, performGrammarAnalysis, postProcessAction, useBaseTemplatesForSynPredFragments

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

rubyKeywords

public static final Set<String> rubyKeywords

A set of ruby keywords which are used to escape labels and method names which will cause parse errors in the ruby source

sharedActionBlocks

public static Map<String,Map<String,Object>> sharedActionBlocks

Constructor Detail

RubyTarget

public RubyTarget()

Method Detail

genRecognizerFile

protected void genRecognizerFile(Tool tool,
                     CodeGenerator generator,
                     Grammar grammar,
                     org.stringtemplate.v4.ST outputFileST)
                          throws IOException

Overrides:

genRecognizerFile in class Target

Throws:

IOException

getTargetCharLiteralFromANTLRCharLiteral

public String getTargetCharLiteralFromANTLRCharLiteral(CodeGenerator generator,
                                              String literal)

Description copied from class: Target

Convert from an ANTLR char literal found in a grammar file to an equivalent char literal in the target language. For most languages, this means leaving 'x' as 'x'. Actually, we need to escape ' ' so that it doesn't get converted to \n by the compiler. Convert the literal to the char value and then to an appropriate target char literal. Expect single quotes around the incoming literal.

Overrides:

getTargetCharLiteralFromANTLRCharLiteral in class Target

getMaxCharValue

public int getMaxCharValue(CodeGenerator generator)

Description copied from class: Target

Some targets only support ASCII or 8-bit chars/strings. For example, C++ will probably want to return 0xFF here.

Overrides:

getMaxCharValue in class Target

getTokenTypeAsTargetLabel

public String getTokenTypeAsTargetLabel(CodeGenerator generator,
                               int ttype)

Description copied from class: Target

Target must be able to override the labels used for token types

Overrides:

getTokenTypeAsTargetLabel in class Target

isValidActionScope

public boolean isValidActionScope(int grammarType,
                         String scope)

Description copied from class: Target

Is scope in @scope::name {action} valid for this kind of grammar? Targets like C++ may want to allow new scopes like headerfile or some such. The action names themselves are not policed at the moment so targets can add template actions w/o having to recompile ANTLR.

Overrides:

isValidActionScope in class Target

encodeIntAsCharEscape

public String encodeIntAsCharEscape(int v)

Overrides:

encodeIntAsCharEscape in class Target