private void GetGeneratedFileNames(GrammarCheckedState grammarCheckedState, string generatedGrammarName, string workingDirectory,
List <string> generatedFiles, bool lexer)
{
string grammarNameExt;
if (_grammar.Type == GrammarType.Combined)
{
grammarNameExt = _grammar.Files.FirstOrDefault(file => Path.GetExtension(file)
.Equals(Grammar.AntlrDotExt, StringComparison.OrdinalIgnoreCase));
}
else
{
string postfix = lexer ? Grammar.LexerPostfix : Grammar.ParserPostfix;
grammarNameExt = _grammar.Files.FirstOrDefault(file => file.Contains(postfix) &&
Path.GetExtension(file).Equals(Grammar.AntlrDotExt, StringComparison.OrdinalIgnoreCase));
}
string shortGeneratedFile = generatedGrammarName +
(lexer ? _currentRuntimeInfo.LexerPostfix : _currentRuntimeInfo.ParserPostfix) +
"." + _currentRuntimeInfo.Extensions[0];
string generatedFileDir = workingDirectory;
Runtime runtime = _currentRuntimeInfo.Runtime;
if ((runtime == Runtime.Java || runtime == Runtime.Go) && !string.IsNullOrWhiteSpace(_result.ParserGeneratedState.PackageName))
{
generatedFileDir = Path.Combine(generatedFileDir, _result.ParserGeneratedState.PackageName);
}
string generatedFile = Path.Combine(generatedFileDir, shortGeneratedFile);
generatedFiles.Add(generatedFile);
CodeSource codeSource = new CodeSource(generatedFile, File.ReadAllText(generatedFile));
_grammarCodeMapping[shortGeneratedFile] = TextHelpers.Map(grammarCheckedState.GrammarActionsTextSpan[grammarNameExt], codeSource, lexer);
}
public ParserGeneratedState(GrammarCheckedState grammarCheckedState, string packageName, Runtime runtime, bool includeListener, bool includeVisitor)
{
GrammarCheckedState = grammarCheckedState ?? throw new ArgumentNullException(nameof(grammarCheckedState));
PackageName = packageName;
Runtime = runtime;
IncludeListener = includeListener;
IncludeVisitor = includeVisitor;
}
public ParserGeneratedState Generate(GrammarCheckedState state, CancellationToken cancellationToken = default)
{
Grammar grammar = state.InputState.Grammar;
_result = new ParserGeneratedState(state, PackageName, Runtime, GenerateListener, GenerateVisitor);
Generate(grammar, state, cancellationToken);
return(_result);
}
private void Generate(Grammar grammar, GrammarCheckedState state, CancellationToken cancellationToken)
{
Processor processor = null;
try
{
string runtimeDirectoryName = Path.Combine(HelperDirectoryName, grammar.Name, Runtime.ToString());
if ((Runtime == Runtime.Java || Runtime == Runtime.Go) && !string.IsNullOrWhiteSpace(PackageName))
{
runtimeDirectoryName = Path.Combine(runtimeDirectoryName, PackageName);
}
if (Directory.Exists(runtimeDirectoryName))
{
Directory.Delete(runtimeDirectoryName, true);
}
Directory.CreateDirectory(runtimeDirectoryName);
cancellationToken.ThrowIfCancellationRequested();
RuntimeInfo runtimeInfo = RuntimeInfo.InitOrGetRuntimeInfo(Runtime);
var jarGenerator = GeneratorTool ?? Path.Combine("Generators", runtimeInfo.JarGenerator);
foreach (string grammarFileName in state.InputState.Grammar.Files)
{
string extension = Path.GetExtension(grammarFileName);
if (extension != Grammar.AntlrDotExt)
{
continue;
}
_currentGrammarSource = state.GrammarFilesData[grammarFileName];
var arguments =
$@"-jar ""{jarGenerator}"" ""{Path.Combine(grammar.Directory, grammarFileName)}"" " +
$@"-o ""{runtimeDirectoryName}"" " +
$"-Dlanguage={runtimeInfo.DLanguage} " +
$"{(GenerateVisitor ? "-visitor" : "-no-visitor")} " +
$"{(GenerateListener ? "-listener" : "-no-listener")}";
if (!string.IsNullOrWhiteSpace(PackageName))
{
arguments += " -package " + PackageName;
}
else if (Runtime == Runtime.Go)
{
arguments += " -package main";
}
if (grammarFileName.Contains(Grammar.LexerPostfix) && state.LexerSuperClass != null)
{
arguments += " -DsuperClass=" + state.LexerSuperClass;
}
if (grammarFileName.Contains(Grammar.ParserPostfix) && state.ParserSuperClass != null)
{
arguments += " -DsuperClass=" + state.ParserSuperClass;
}
_result.Command = "java " + arguments;
processor = new Processor("java", arguments, ".");
processor.CancellationToken = cancellationToken;
processor.ErrorDataReceived += ParserGeneration_ErrorDataReceived;
processor.OutputDataReceived += ParserGeneration_OutputDataReceived;
processor.Start();
cancellationToken.ThrowIfCancellationRequested();
}
}
catch (Exception ex)
{
_result.Exception = ex;
if (!(ex is OperationCanceledException))
{
ErrorEvent?.Invoke(this, new ParsingError(ex, WorkflowStage.ParserGenerated));
}
}
finally
{
processor?.Dispose();
}
}
public GrammarCheckedState Check(InputState inputState, CancellationToken cancellationToken = default)
{
var grammar = inputState.Grammar;
var result = new GrammarCheckedState(inputState);
try
{
var antlrErrorListener = new AntlrErrorListener();
antlrErrorListener.ErrorEvent += ErrorEvent;
antlrErrorListener.ErrorEvent += (sender, error) =>
{
lock (result.Errors)
{
result.Errors.Add(error);
}
};
foreach (string grammarFileName in grammar.Files)
{
string code = File.ReadAllText(Path.Combine(grammar.Directory, grammarFileName));
var inputStream = new AntlrInputStream(code);
var codeSource = new CodeSource(grammarFileName, inputStream.ToString());
result.GrammarFilesData.Add(grammarFileName, codeSource);
string extension = Path.GetExtension(grammarFileName);
if (extension != Grammar.AntlrDotExt)
{
continue;
}
antlrErrorListener.CodeSource = codeSource;
var antlr4Lexer = new ANTLRv4Lexer(inputStream);
antlr4Lexer.RemoveErrorListeners();
antlr4Lexer.AddErrorListener(antlrErrorListener);
var codeTokenSource = new ListTokenSource(antlr4Lexer.GetAllTokens());
cancellationToken.ThrowIfCancellationRequested();
var codeTokenStream = new CommonTokenStream(codeTokenSource);
var antlr4Parser = new ANTLRv4Parser(codeTokenStream);
antlr4Parser.RemoveErrorListeners();
antlr4Parser.AddErrorListener(antlrErrorListener);
var tree = antlr4Parser.grammarSpec();
var grammarInfoCollectorListener = new GrammarInfoCollectorListener();
grammarInfoCollectorListener.CollectInfo(antlrErrorListener.CodeSource, tree);
var shortFileName = Path.GetFileNameWithoutExtension(grammarFileName);
result.GrammarActionsTextSpan[grammarFileName] = grammarInfoCollectorListener.CodeInsertions;
if (grammarFileName.Contains(Grammar.LexerPostfix))
{
result.LexerSuperClass = grammarInfoCollectorListener.SuperClass;
}
if (grammarFileName.Contains(Grammar.ParserPostfix))
{
result.ParserSuperClass = grammarInfoCollectorListener.SuperClass;
}
if (!shortFileName.Contains(Grammar.LexerPostfix))
{
result.Rules = grammarInfoCollectorListener.Rules;
cancellationToken.ThrowIfCancellationRequested();
}
}
}
catch (Exception ex)
{
result.Exception = ex;
if (!(ex is OperationCanceledException))
{
ErrorEvent?.Invoke(this, new ParsingError(ex, WorkflowStage.GrammarChecked));
}
}
return(result);
}
