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 Task <Package> CompilePackageAsync(
string name,
IEnumerable <ICodeFileSource> fileSources,
FixedDictionary <string, Task <Package> > references,
TaskScheduler taskScheduler)
{
var lexer = new Lexer();
var parser = new CompilationUnitParser();
var parseBlock = new TransformBlock <ICodeFileSource, CompilationUnitSyntax>(
async(fileSource) =>
{
var file = await fileSource.LoadAsync();
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();
throw new NotImplementedException();
}
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 Package CompilePackage(
string name,
IEnumerable <CodeFile> files,
FixedDictionary <string, Package> 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));
})
.ToFixedList();
var packageSyntax = new PackageSyntax(name, compilationUnits);
var analyzer = new SemanticAnalyzer();
return(analyzer.Analyze(packageSyntax, references));
}
public static Expression FromText(string source)
{
var lexer = new FlowScriptLexer(new AntlrInputStream(source));
var tokenStream = new CommonTokenStream(lexer);
// parse expression
var parser = new FlowScriptParser(tokenStream);
parser.BuildParseTree = true;
var expressionParseTree = parser.expression();
// parse ast nodes
var compilationUnitParser = new CompilationUnitParser();
compilationUnitParser.TryParseExpression(expressionParseTree, out var expression);
// resolve types
var typeResolver = new TypeResolver();
typeResolver.TryResolveTypesInExpression(expression);
return(expression);
}
