public PackageIL CompilePackage(
string name,
IEnumerable <CodeFile> files,
FixedDictionary <Name, PackageIL> references)
{
var lexer = new Lexer();
var parser = new CompilationUnitParser();
var compilationUnits = files
.Select(file =>
{
var context = new ParseContext(file, new Diagnostics());
var tokens = lexer.Lex(context).WhereNotTrivia();
return(parser.Parse(tokens));
})
.ToFixedSet();
var packageSyntax = new PackageSyntax(name, compilationUnits, references);
var analyzer = new SemanticAnalyzer()
{
SaveLivenessAnalysis = SaveLivenessAnalysis,
SaveReachabilityGraphs = SaveReachabilityGraphs,
};
return(analyzer.Check(packageSyntax));
}
public async Task <PackageIL> CompilePackageAsync(
Name name,
IEnumerable <ICodeFileSource> fileSources,
FixedDictionary <Name, Task <PackageIL> > referenceTasks,
TaskScheduler taskScheduler)
{
var lexer = new Lexer();
var parser = new CompilationUnitParser();
var parseBlock = new TransformBlock <ICodeFileSource, ICompilationUnitSyntax>(
async(fileSource) =>
{
var file = await fileSource.LoadAsync().ConfigureAwait(false);
var context = new ParseContext(file, new Diagnostics());
var tokens = lexer.Lex(context).WhereNotTrivia();
return(parser.Parse(tokens));
}, new ExecutionDataflowBlockOptions()
{
TaskScheduler = taskScheduler,
EnsureOrdered = false,
});
foreach (var fileSource in fileSources)
{
parseBlock.Post(fileSource);
}
parseBlock.Complete();
await parseBlock.Completion.ConfigureAwait(false);
if (!parseBlock.TryReceiveAll(out var compilationUnits))
{
throw new Exception("Not all compilation units are ready");
}
var referencePairs = await Task
.WhenAll(referenceTasks.Select(async kv =>
(alias: kv.Key, package: await kv.Value.ConfigureAwait(false))))
.ConfigureAwait(false);
var references = referencePairs.ToFixedDictionary(r => r.alias, r => r.package);
// TODO add the references to the package syntax
var packageSyntax = new PackageSyntax(name, compilationUnits.ToFixedSet(), references);
var analyzer = new SemanticAnalyzer()
{
SaveLivenessAnalysis = SaveLivenessAnalysis,
SaveReachabilityGraphs = SaveReachabilityGraphs,
};
return(analyzer.Check(packageSyntax));
}
public static bool TryAnalyze(
string input,
out string expandedInput,
out ProgramNode program,
out IEnumerable <Message> messages)
{
program = null;
var analysisMessages = new List <Message>();
messages = analysisMessages;
var isExpansionSucceeded = TryExpandMacros(
input,
out string output,
out IEnumerable <Message> expasionMessages);
analysisMessages.AddRange(expasionMessages);
if (isExpansionSucceeded)
{
expandedInput = output;
}
else
{
expandedInput = input;
return(false);
}
var inputStream = CharStreams.fromstring(output);
var lexer = new GoToLexer(inputStream);
var lexerErrorListener = new LexerErrorListener();
lexer.AddErrorListener(lexerErrorListener);
analysisMessages.AddRange(lexerErrorListener.Messages);
var tokenStream = new CommonTokenStream(lexer);
var parser = new GoToParser(tokenStream);
var parserErrorListener = new ParserErrorListener();
parser.AddErrorListener(parserErrorListener);
var contextSyntaxTree = parser.program();
analysisMessages.AddRange(parserErrorListener.Messages);
var listener = new SemanticListener();
ParseTreeWalker.Default.Walk(listener, contextSyntaxTree);
analysisMessages.AddRange(listener.Messages);
if (AreThereErrors(messages))
{
return(false);
}
var abstractSyntaxTreeGenerator = new AbstractSyntaxTreeGenerator();
program = abstractSyntaxTreeGenerator.VisitProgram(contextSyntaxTree) as ProgramNode;
SemanticAnalyzer.Check(program, ref analysisMessages);
if (AreThereErrors(messages))
{
return(false);
}
return(true);
}
