public LexerATNFactory(LexerGrammar g)
: base(g)
{
// use codegen to get correct language templates for lexer commands
string language = g.GetOptionString("language");
CodeGenerator gen = new CodeGenerator(g.tool, null, language);
AbstractTarget target = gen.GetTarget();
codegenTemplates = target != null ? target.GetTemplates() : null;
}
public Grammar(string grammarText, LexerGrammar tokenVocabSource)
: this(GRAMMAR_FROM_STRING_NAME, grammarText, tokenVocabSource, null)
{
}
/** To process a grammar, we load all of its imported grammars into
subordinate grammar objects. Then we merge the imported rules
into the root grammar. If a root grammar is a combined grammar,
we have to extract the implicit lexer. Once all this is done, we
process the lexer first, if present, and then the parser grammar
*/
public virtual void Process(Grammar g, bool gencode)
{
g.LoadImportedGrammars();
GrammarTransformPipeline transform = new GrammarTransformPipeline(g, this);
transform.Process();
LexerGrammar lexerg;
GrammarRootAST lexerAST;
if (g.ast != null && g.ast.grammarType == ANTLRParser.COMBINED &&
!g.ast.hasErrors)
{
lexerAST = transform.ExtractImplicitLexer(g); // alters g.ast
if (lexerAST != null)
{
if (grammarOptions != null)
{
lexerAST.cmdLineOptions = grammarOptions;
}
lexerg = new LexerGrammar(this, lexerAST);
lexerg.fileName = g.fileName;
lexerg.originalGrammar = g;
g.implicitLexer = lexerg;
lexerg.implicitLexerOwner = g;
int prevErrors = errMgr.GetNumErrors();
ProcessNonCombinedGrammar(lexerg, gencode);
if (errMgr.GetNumErrors() > prevErrors)
{
return;
}
// System.out.println("lexer tokens="+lexerg.tokenNameToTypeMap);
// System.out.println("lexer strings="+lexerg.stringLiteralToTypeMap);
}
}
if (g.implicitLexer != null)
g.ImportVocab(g.implicitLexer);
// System.out.println("tokens="+g.tokenNameToTypeMap);
// System.out.println("strings="+g.stringLiteralToTypeMap);
ProcessNonCombinedGrammar(g, gencode);
}
/** Given the raw AST of a grammar, create a grammar object
associated with the AST. Once we have the grammar object, ensure
that all nodes in tree referred to this grammar. Later, we will
use it for error handling and generally knowing from where a rule
comes from.
*/
public virtual Grammar CreateGrammar(GrammarRootAST ast)
{
Grammar g;
if (ast.grammarType == ANTLRParser.LEXER)
g = new LexerGrammar(this, ast);
else
g = new Grammar(this, ast);
// ensure each node has pointer to surrounding grammar
GrammarTransformPipeline.SetGrammarPtr(g, ast);
return g;
}
public static IDictionary<Rule, ISet<Rule>> GetRuleDependencies(LexerGrammar g, string modeName)
{
return GetRuleDependencies(g, g.modes[modeName]);
}
