public ImmutableArray <Diagnostic> Emit(BoundProgram program, string outputPath) { if (_diagnostics.Any()) { return(_diagnostics.ToImmutableArray()); } var objectType = _knownTypes[TypeSymbol.Any]; _typeDefinition = new TypeDefinition("", "Program", TypeAttributes.Abstract | TypeAttributes.Sealed, objectType); _assemblyDefinition.MainModule.Types.Add(_typeDefinition); foreach (var functionWithBody in program.Functions) { EmitFunctionDeclaration(functionWithBody.Key); } foreach (var functionWithBody in program.Functions) { EmitFunctionBody(functionWithBody.Key, functionWithBody.Value); } if (program.MainFunction != null) { _assemblyDefinition.EntryPoint = _methods[program.MainFunction]; } _assemblyDefinition.Write(outputPath); return(_diagnostics.ToImmutableArray()); }
internal Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> variables) { diagnostics = new DiagnosticContainer(); Program = program; globals = variables; locals = new Stack <Dictionary <VariableSymbol, object> >(); }
public EvaluationResult Evaluate(Dictionary <VariableSymbol, object> variables) { ImmutableArray <Diagnostic> diagnostics = SyntaxTree.Diagnostics.Concat(GlobalScope.Diagnostics).ToImmutableArray(); if (diagnostics.Any()) { return(new EvaluationResult(diagnostics, null)); } BoundProgram program = Binder.BindProgram(GlobalScope); string appPath = Environment.GetCommandLineArgs()[0]; string appDirectory = Path.GetDirectoryName(appPath); string cfgPath = Path.Combine(appDirectory, "cfg.dot"); BoundBlockStatement cfgStatement = !program.Statement.Statements.Any() && program.Functions.Any() ? program.Functions.Last().Value : program.Statement; var cfg = ControlFlowGraph.Create(cfgStatement); using (StreamWriter streamWriter = new StreamWriter(cfgPath)) cfg.WriteTo(streamWriter); if (program.Diagnostics.Any()) { return(new EvaluationResult(program.Diagnostics.ToImmutableArray(), null)); } Evaluator evaluator = new Evaluator(program, variables); object value = evaluator.Evaluate(); return(new EvaluationResult(ImmutableArray <Diagnostic> .Empty, value)); }
private static void WriteBoundProgram(this IndentedTextWriter writer, BoundProgram node) { foreach (var pair in node.Functions) { writer.WriteFunctionSymbol(pair.Key); writer.WriteLine(); writer.WriteBoundBlockStatement(pair.Value); writer.WriteLine(); writer.WriteLine(); } }
public static ImmutableArray <Diagnostic> Emit(BoundProgram program, string moduleName, string[] references, string outputPath) { if (program.Diagnostics.Any()) { return(program.Diagnostics); } var emitter = new Emitter(moduleName, references); return(emitter.Emit(program, outputPath)); }
public Evaluator(BoundProgram program, CompilationContext context, bool inRepl) { _program = program; _context = context; var outerScope = new EvaluationScope(); _scopeStack.Push(outerScope); _inRepl = inRepl; foreach (var pair in program.Functions) { _functions[pair.Key] = pair.Value; } }
public Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> variables) { this.Program = program; this.Globals = variables; this.Locals.Push(new Dictionary <VariableSymbol, object>()); var c = this.Program; while (c != null) { foreach (var f in c.Functions) { this.Functions.Add(f.Key, f.Value); } c = c.Previous; } }
private ImmutableArray <Diagnostic> EmitAssembly(BoundProgram program) { var header = new PEHeaderBuilder(); var metadataBuilder = new MetadataBuilder(); var metadataRootBuilder = new MetadataRootBuilder(metadataBuilder); var blobBuilder = new BlobBuilder(); var peBuilder = new ManagedPEBuilder(header, metadataRootBuilder, blobBuilder); peBuilder.Serialize(blobBuilder); // TODO: Produce portable assembly contents here using (var stream = new StreamWriter(program.PackageName + ".dll")) { blobBuilder.WriteContentTo(stream.BaseStream); } return(ImmutableArray <Diagnostic> .Empty); }
public Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> variables) { _program = program; _globals = variables; _locals.Push(new Dictionary <VariableSymbol, object>()); var current = program; while (current != null) { // TODO: Flagged (kv) foreach (var(function, body) in current.Functions) { _functions.Add(function, body); } current = current.Previous; } }
public Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> variables) { _program = program; _globals = variables; _locals.Push(new Dictionary <VariableSymbol, object>()); var current = program; while (current != null) { foreach (var kv in current.Functions) { var function = kv.Key; var body = kv.Value; _functions.Add(function, body); } current = current.Previous; } }
public Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> globalVariables) { this.program = program ?? throw new ArgumentNullException(nameof(program)); globals = globalVariables; var current = program; while (current is not null) { foreach (var kv in current.Functions) { var function = kv.Key; var body = kv.Value; functions.Add(function, body); } current = current.Previous; } }
private Compilation(IEnumerable <SourceText> sourceTexts, string moduleName, string[] referencePaths, bool isScript) { this.referencePaths = referencePaths; this.isScript = isScript; this.SourceTexts = sourceTexts; this.moduleName = moduleName; var diagnosticBuilder = ImmutableArray.CreateBuilder <Diagnostic>(); var trees = new List <SyntaxTree>(); foreach (var text in sourceTexts) { var tree = SyntaxTree.ParseSyntaxTree(text, isScript); diagnosticBuilder.AddRange(tree.GetDiagnostics()); trees.Add(tree); } program = Binder.BindProgram(moduleName, referencePaths, isScript, trees.Select(t => t.Root)); diagnosticBuilder.AddRange(program.Diagnostics); Diagnostics = new DiagnosticReport(diagnosticBuilder.ToImmutable()); }
public static ImmutableArray <Diagnostic> Emit(BoundProgram program, string moduleName, string[] references, string outputPath) { if (program.Diagnostics.Any()) { return(program.Diagnostics); } var result = new DiagnosticBag(); var assemblyName = new AssemblyNameDefinition(moduleName, new Version(1, 0)); var assemblyDefinition = AssemblyDefinition.CreateAssembly(assemblyName, moduleName, ModuleKind.Console); var typeDefinition = new TypeDefinition("", "Program", TypeAttributes.Abstract | TypeAttributes.Sealed); assemblyDefinition.MainModule.Types.Add(typeDefinition); // var main = new MethodDefinition("Main", MethodAttributes.Static, voidType); assemblyDefinition.Write(outputPath); return(result.ToImmutableArray()); }
public void EmitTree(TextWriter writer) { BoundProgram program = Binder.BindProgram(GlobalScope); if (program.Statement.Statements.Any()) { program.Statement.WriteTo(writer); } else { foreach (var functionBody in program.Functions) { if (!GlobalScope.Functions.Contains(functionBody.Key)) { continue; } functionBody.Key.WriteTo(writer); functionBody.Value.WriteTo(writer); } } }
public static ImmutableArray <Diagnostic> Emit(BoundProgram program, string moduleName, string[] references, string outputPath) { if (program.Diagnostics.Any()) { return(program.Diagnostics); } var assemblies = new List <AssemblyDefinition>(); var result = new DiagnosticBag(); foreach (var reference in references) { try { var assembly = AssemblyDefinition.ReadAssembly(reference); assemblies.Add(assembly); } catch (BadImageFormatException) { result.ReportInvalidReference(reference); } } var builtInTypes = new List <(TypeSymbol type, string MetadataName)>() { (TypeSymbol.Any, "System.Object"), (TypeSymbol.Bool, "System.Boolean"), (TypeSymbol.Int, "System.Int32"), (TypeSymbol.String, "System.String"), (TypeSymbol.Void, "System.Void"), }; var assemblyName = new AssemblyNameDefinition(moduleName, new Version(1, 0)); var assemblyDefinition = AssemblyDefinition.CreateAssembly(assemblyName, moduleName, ModuleKind.Console); var knownTypes = new Dictionary <TypeSymbol, TypeReference>(); foreach (var(typeSymbol, metadataName) in builtInTypes) { var typeReference = ResolveType(typeSymbol.Name, metadataName); knownTypes.Add(typeSymbol, typeReference); } TypeReference ResolveType(string minskName, string metadataName) { var foundTypes = assemblies.SelectMany(a => a.Modules) .SelectMany(m => m.Types) .Where(t => t.FullName == metadataName) .ToArray(); if (foundTypes.Length == 1) { var typeReference = assemblyDefinition.MainModule.ImportReference(foundTypes[0]); return(typeReference); } else if (foundTypes.Length == 0) { result.ReportRequiredTypeNotFound(minskName, metadataName); } else { result.ReportRequiredTypeAmbiguous(minskName, metadataName, foundTypes); } return(null); } MethodReference ResolveMethod(string typeName, string methodName, string[] parameterTypeNames) { var foundTypes = assemblies.SelectMany(a => a.Modules) .SelectMany(m => m.Types) .Where(t => t.FullName == typeName) .ToArray(); if (foundTypes.Length == 1) { var foundType = foundTypes[0]; var methods = foundType.Methods.Where(m => m.Name == methodName); foreach (var method in methods) { if (method.Parameters.Count != parameterTypeNames.Length) { continue; } var allParametersMatch = true; for (var i = 0; i < parameterTypeNames.Length; i++) { if (method.Parameters[i].ParameterType.FullName != parameterTypeNames[i]) { allParametersMatch = false; break; } } if (!allParametersMatch) { continue; } return(assemblyDefinition.MainModule.ImportReference(method)); } result.ReportRequiredMethodNotFound(typeName, methodName, parameterTypeNames); return(null); } else if (foundTypes.Length == 0) { result.ReportRequiredTypeNotFound(null, typeName); } else { result.ReportRequiredTypeAmbiguous(null, typeName, foundTypes); } return(null); } var consoleWriteLineReference = ResolveMethod("System.Console", "WriteLine", new [] { "System.String" }); if (result.Any()) { return(result.ToImmutableArray()); } var objectType = knownTypes[TypeSymbol.Any]; var typeDefinition = new TypeDefinition("", "Program", TypeAttributes.Abstract | TypeAttributes.Sealed, objectType); assemblyDefinition.MainModule.Types.Add(typeDefinition); var voidType = knownTypes[TypeSymbol.Void]; var mainMethod = new MethodDefinition("Main", MethodAttributes.Static | MethodAttributes.Private, voidType); typeDefinition.Methods.Add(mainMethod); var ilProcessor = mainMethod.Body.GetILProcessor(); ilProcessor.Emit(OpCodes.Ldstr, "Hello world from Minsk!"); ilProcessor.Emit(OpCodes.Call, consoleWriteLineReference); ilProcessor.Emit(OpCodes.Ret); assemblyDefinition.EntryPoint = mainMethod; assemblyDefinition.Write(outputPath); return(result.ToImmutableArray()); }
public Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> variables) { _program = program; _globals = variables; _locals.Push(new Dictionary <VariableSymbol, object>()); }
public Evaluator(BoundProgram program, Dictionary <VariableSymbol, object> variables) { _program = program; _globals = variables; }