528 lines
20 KiB
C#
528 lines
20 KiB
C#
using System.Diagnostics;
|
|
using System.Text;
|
|
|
|
namespace Compiler;
|
|
|
|
public class Generator
|
|
{
|
|
public static string Emit(List<TypedNodeDefinitionFunc> functions, ModuleGraph moduleGraph, bool compileLib)
|
|
{
|
|
return new Generator(functions, moduleGraph, compileLib).Emit();
|
|
}
|
|
|
|
private Generator(List<TypedNodeDefinitionFunc> functions, ModuleGraph moduleGraph, bool compileLib)
|
|
{
|
|
this.functions = functions;
|
|
this.moduleGraph = moduleGraph;
|
|
this.compileLib = compileLib;
|
|
}
|
|
|
|
private readonly List<TypedNodeDefinitionFunc> functions;
|
|
private readonly ModuleGraph moduleGraph;
|
|
private readonly bool compileLib;
|
|
private readonly IndentedTextWriter writer = new();
|
|
|
|
private string Emit()
|
|
{
|
|
writer.WriteLine("""
|
|
#include <float.h>
|
|
#include <stdarg.h>
|
|
#include <stddef.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
|
|
struct nub_core_string
|
|
{
|
|
const char *data;
|
|
int length;
|
|
};
|
|
""");
|
|
|
|
writer.WriteLine();
|
|
|
|
foreach (var module in moduleGraph.GetModules())
|
|
{
|
|
foreach (var (name, info) in module.GetTypes())
|
|
{
|
|
switch (info)
|
|
{
|
|
case Module.TypeInfoStruct s:
|
|
writer.WriteLine($"struct {NameMangler.Mangle(module.Name, name, NubTypeStruct.Get(module.Name, name))};");
|
|
break;
|
|
case Module.TypeInfoEnum e:
|
|
writer.WriteLine($"struct {NameMangler.Mangle(module.Name, name, NubTypeStruct.Get(module.Name, name))};");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var module in moduleGraph.GetModules())
|
|
{
|
|
foreach (var (name, info) in module.GetTypes())
|
|
{
|
|
switch (info)
|
|
{
|
|
case Module.TypeInfoStruct s:
|
|
{
|
|
writer.WriteLine();
|
|
writer.Write("struct ");
|
|
|
|
if (s.Packed)
|
|
writer.Write("__attribute__((__packed__)) ");
|
|
|
|
writer.WriteLine(NameMangler.Mangle(module.Name, name, NubTypeStruct.Get(module.Name, name)));
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var field in s.Fields)
|
|
{
|
|
writer.WriteLine($"{CType(field.Type, field.Name)};");
|
|
}
|
|
}
|
|
writer.WriteLine("};");
|
|
break;
|
|
}
|
|
case Module.TypeInfoEnum e:
|
|
{
|
|
writer.WriteLine();
|
|
writer.Write($"struct {NameMangler.Mangle(module.Name, name, NubTypeEnum.Get(module.Name, name))}");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine("uint32_t tag;");
|
|
writer.WriteLine("union");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var variant in e.Variants)
|
|
{
|
|
writer.WriteLine("struct");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var field in variant.Fields)
|
|
{
|
|
writer.WriteLine($"{CType(field.Type, field.Name)};");
|
|
}
|
|
}
|
|
writer.WriteLine($"}} {variant.Name};");
|
|
}
|
|
}
|
|
writer.WriteLine("};");
|
|
}
|
|
writer.WriteLine("};");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
writer.WriteLine();
|
|
|
|
foreach (var module in moduleGraph.GetModules())
|
|
{
|
|
foreach (var (name, info) in module.GetIdentifiers())
|
|
{
|
|
if (info.Type is NubTypeFunc fn)
|
|
{
|
|
switch (info.Kind)
|
|
{
|
|
case Module.DefinitionKind.External:
|
|
writer.Write("extern ");
|
|
break;
|
|
case Module.DefinitionKind.Internal:
|
|
writer.Write("static ");
|
|
break;
|
|
}
|
|
|
|
writer.WriteLine($"{CType(fn.ReturnType, info.MangledName)}({string.Join(", ", fn.Parameters.Select(p => CType(p)))});");
|
|
}
|
|
else
|
|
{
|
|
writer.WriteLine($"{CType(info.Type, info.MangledName)};");
|
|
}
|
|
}
|
|
}
|
|
|
|
writer.WriteLine();
|
|
|
|
if (!compileLib)
|
|
{
|
|
if (!moduleGraph.TryResolveIdentifier("main", "main", true, out var info))
|
|
throw new UnreachableException("func main::main() is not defined. This should have been caught earlier");
|
|
|
|
writer.WriteLine($$"""
|
|
int main(int argc, char *argv[])
|
|
{
|
|
return {{info.MangledName}}();
|
|
}
|
|
""");
|
|
|
|
writer.WriteLine();
|
|
}
|
|
|
|
foreach (var function in functions)
|
|
{
|
|
if (!moduleGraph.TryResolveIdentifier(function.Module, function.Name.Ident, true, out var info))
|
|
throw new UnreachableException($"Module graph does not have info about the function {function.Module}::{function.Name.Ident}. This should have been caught earlier");
|
|
|
|
if (info.Kind == Module.DefinitionKind.Internal)
|
|
writer.Write("static ");
|
|
|
|
var parameters = function.Parameters.Select(x => CType(x.Type, x.Name.Ident));
|
|
|
|
writer.WriteLine($"{CType(function.ReturnType, info.MangledName)}({string.Join(", ", parameters)})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitStatement(function.Body);
|
|
}
|
|
writer.WriteLine("}");
|
|
writer.WriteLine();
|
|
}
|
|
|
|
return writer.ToString();
|
|
}
|
|
|
|
private void EmitStatement(TypedNodeStatement node)
|
|
{
|
|
switch (node)
|
|
{
|
|
case TypedNodeStatementBlock statement:
|
|
EmitStatementBlock(statement);
|
|
break;
|
|
case TypedNodeStatementFuncCall statement:
|
|
EmitStatementFuncCall(statement);
|
|
break;
|
|
case TypedNodeStatementReturn statement:
|
|
EmitStatementReturn(statement);
|
|
break;
|
|
case TypedNodeStatementVariableDeclaration statement:
|
|
EmitStatementVariableDeclaration(statement);
|
|
break;
|
|
case TypedNodeStatementAssignment statement:
|
|
EmitStatementAssignment(statement);
|
|
break;
|
|
case TypedNodeStatementIf statement:
|
|
EmitStatementIf(statement);
|
|
break;
|
|
case TypedNodeStatementWhile statement:
|
|
EmitStatementWhile(statement);
|
|
break;
|
|
case TypedNodeStatementMatch statement:
|
|
EmitStatementMatch(statement);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(nameof(node), node, null);
|
|
}
|
|
}
|
|
|
|
private void EmitStatementBlock(TypedNodeStatementBlock node)
|
|
{
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var statement in node.Statements)
|
|
EmitStatement(statement);
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
|
|
private void EmitStatementFuncCall(TypedNodeStatementFuncCall node)
|
|
{
|
|
var name = EmitExpression(node.Target);
|
|
var parameterValues = node.Parameters.Select(EmitExpression).ToList();
|
|
writer.WriteLine($"{name}({string.Join(", ", parameterValues)});");
|
|
}
|
|
|
|
private void EmitStatementReturn(TypedNodeStatementReturn statement)
|
|
{
|
|
var value = EmitExpression(statement.Value);
|
|
writer.WriteLine($"return {value};");
|
|
}
|
|
|
|
private void EmitStatementVariableDeclaration(TypedNodeStatementVariableDeclaration statement)
|
|
{
|
|
var value = EmitExpression(statement.Value);
|
|
writer.WriteLine($"{CType(statement.Type)} {statement.Name.Ident} = {value};");
|
|
}
|
|
|
|
private void EmitStatementAssignment(TypedNodeStatementAssignment statement)
|
|
{
|
|
var target = EmitExpression(statement.Target);
|
|
var value = EmitExpression(statement.Value);
|
|
writer.WriteLine($"{target} = {value};");
|
|
}
|
|
|
|
private void EmitStatementIf(TypedNodeStatementIf statement)
|
|
{
|
|
var condition = EmitExpression(statement.Condition);
|
|
writer.WriteLine($"if ({condition})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitStatement(statement.ThenBlock);
|
|
}
|
|
writer.WriteLine("}");
|
|
|
|
if (statement.ElseBlock != null)
|
|
{
|
|
writer.Write("else");
|
|
if (statement.ElseBlock is TypedNodeStatementIf)
|
|
writer.Write(" ");
|
|
else
|
|
writer.WriteLine();
|
|
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitStatement(statement.ElseBlock);
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
}
|
|
|
|
private void EmitStatementWhile(TypedNodeStatementWhile statement)
|
|
{
|
|
var condition = EmitExpression(statement.Condition);
|
|
writer.WriteLine($"while ({condition})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitStatement(statement.Body);
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
|
|
private void EmitStatementMatch(TypedNodeStatementMatch statement)
|
|
{
|
|
var target = EmitExpression(statement.Target);
|
|
var enumType = (NubTypeEnum)statement.Target.Type;
|
|
|
|
if (!moduleGraph.TryResolveType(enumType.Module, enumType.Name, true, out var info))
|
|
throw new UnreachableException();
|
|
|
|
var enumInfo = (Module.TypeInfoEnum)info;
|
|
|
|
writer.WriteLine($"switch ({target}.tag)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var @case in statement.Cases)
|
|
{
|
|
var tag = enumInfo.Variants.ToList().FindIndex(x => x.Name == @case.Type.Ident);
|
|
|
|
writer.WriteLine($"case {tag}:");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine($"auto {@case.VariableName.Ident} = {target}.{@case.Type.Ident};");
|
|
EmitStatement(@case.Body);
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
|
|
private string EmitExpression(TypedNodeExpression node)
|
|
{
|
|
return node switch
|
|
{
|
|
TypedNodeExpressionBinary expression => EmitExpressionBinary(expression),
|
|
TypedNodeExpressionUnary expression => EmitExpressionUnary(expression),
|
|
TypedNodeExpressionBoolLiteral expression => expression.Value.Value ? "true" : "false",
|
|
TypedNodeExpressionIntLiteral expression => expression.Value.Value.ToString(),
|
|
TypedNodeExpressionStringLiteral expression => $"(struct nub_core_string){{ \"{expression.Value.Value}\", {expression.Value.Value.Length} }}",
|
|
TypedNodeExpressionStructLiteral expression => EmitExpressionStructLiteral(expression),
|
|
TypedNodeExpressionEnumLiteral expression => EmitExpressionEnumLiteral(expression),
|
|
TypedNodeExpressionMemberAccess expression => EmitExpressionMemberAccess(expression),
|
|
TypedNodeExpressionLocalIdent expression => expression.Value.Ident,
|
|
TypedNodeExpressionModuleIdent expression => EmitExpressionModuleIdent(expression),
|
|
TypedNodeExpressionFuncCall expression => EmitExpressionFuncCall(expression),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(node), node, null)
|
|
};
|
|
}
|
|
|
|
private string EmitExpressionBinary(TypedNodeExpressionBinary expression)
|
|
{
|
|
var left = EmitExpression(expression.Left);
|
|
var right = EmitExpression(expression.Right);
|
|
|
|
return expression.Operation switch
|
|
{
|
|
TypedNodeExpressionBinary.Op.Add => $"({left} + {right})",
|
|
TypedNodeExpressionBinary.Op.Subtract => $"({left} - {right})",
|
|
TypedNodeExpressionBinary.Op.Multiply => $"({left} * {right})",
|
|
TypedNodeExpressionBinary.Op.Divide => $"({left} / {right})",
|
|
TypedNodeExpressionBinary.Op.Modulo => $"({left} % {right})",
|
|
TypedNodeExpressionBinary.Op.Equal => $"({left} == {right})",
|
|
TypedNodeExpressionBinary.Op.NotEqual => $"({left} != {right})",
|
|
TypedNodeExpressionBinary.Op.LessThan => $"({left} < {right})",
|
|
TypedNodeExpressionBinary.Op.LessThanOrEqual => $"({left} <= {right})",
|
|
TypedNodeExpressionBinary.Op.GreaterThan => $"({left} > {right})",
|
|
TypedNodeExpressionBinary.Op.GreaterThanOrEqual => $"({left} >= {right})",
|
|
TypedNodeExpressionBinary.Op.LeftShift => $"({left} << {right})",
|
|
TypedNodeExpressionBinary.Op.RightShift => $"({left} >> {right})",
|
|
TypedNodeExpressionBinary.Op.LogicalAnd => $"({left} && {right})",
|
|
TypedNodeExpressionBinary.Op.LogicalOr => $"({left} || {right})",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
}
|
|
|
|
private string EmitExpressionUnary(TypedNodeExpressionUnary expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
|
|
return expression.Operation switch
|
|
{
|
|
TypedNodeExpressionUnary.Op.Negate => $"(-{target})",
|
|
TypedNodeExpressionUnary.Op.Invert => $"(!{target})",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
}
|
|
|
|
private string EmitExpressionStructLiteral(TypedNodeExpressionStructLiteral expression)
|
|
{
|
|
var initializerValues = new Dictionary<string, string>();
|
|
|
|
foreach (var initializer in expression.Initializers)
|
|
{
|
|
var values = EmitExpression(initializer.Value);
|
|
initializerValues[initializer.Name.Ident] = values;
|
|
}
|
|
|
|
var initializerStrings = initializerValues.Select(x => $".{x.Key} = {x.Value}");
|
|
|
|
return $"({CType(expression.Type)}){{ {string.Join(", ", initializerStrings)} }}";
|
|
}
|
|
|
|
private string EmitExpressionEnumLiteral(TypedNodeExpressionEnumLiteral expression)
|
|
{
|
|
var enumVariantType = (NubTypeEnumVariant)expression.Type;
|
|
|
|
if (!moduleGraph.TryResolveType(enumVariantType.EnumType.Module, enumVariantType.EnumType.Name, true, out var info))
|
|
throw new UnreachableException();
|
|
|
|
var enumInfo = (Module.TypeInfoEnum)info;
|
|
var tag = enumInfo.Variants.ToList().FindIndex(x => x.Name == enumVariantType.Variant);
|
|
|
|
var initializerValues = new Dictionary<string, string>();
|
|
|
|
foreach (var initializer in expression.Initializers)
|
|
{
|
|
var values = EmitExpression(initializer.Value);
|
|
initializerValues[initializer.Name.Ident] = values;
|
|
}
|
|
|
|
var initializerStrings = initializerValues.Select(x => $".{x.Key} = {x.Value}");
|
|
|
|
return $"({CType(expression.Type)}){{ .tag = {tag}, .{enumVariantType.Variant} = {{ {string.Join(", ", initializerStrings)} }} }}";
|
|
}
|
|
|
|
private string EmitExpressionMemberAccess(TypedNodeExpressionMemberAccess expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
return $"{target}.{expression.Name.Ident}";
|
|
}
|
|
|
|
private string EmitExpressionModuleIdent(TypedNodeExpressionModuleIdent expression)
|
|
{
|
|
if (!moduleGraph.TryResolveIdentifier(expression.Module.Ident, expression.Value.Ident, true, out var info))
|
|
throw new UnreachableException($"Module graph does not have info about identifier {expression.Module.Ident}::{expression.Value.Ident}. This should have been caught earlier");
|
|
|
|
return info.MangledName;
|
|
}
|
|
|
|
private string EmitExpressionFuncCall(TypedNodeExpressionFuncCall expression)
|
|
{
|
|
var name = EmitExpression(expression.Target);
|
|
var parameterValues = expression.Parameters.Select(EmitExpression).ToList();
|
|
return $"{name}({string.Join(", ", parameterValues)})";
|
|
}
|
|
|
|
private string CType(NubType node, string? varName = null)
|
|
{
|
|
return node switch
|
|
{
|
|
NubTypeVoid => "void" + (varName != null ? $" {varName}" : ""),
|
|
NubTypeBool => "bool" + (varName != null ? $" {varName}" : ""),
|
|
NubTypeStruct type => $"struct {NameMangler.Mangle(type.Module, type.Name, type)}" + (varName != null ? $" {varName}" : ""),
|
|
NubTypeAnonymousStruct type => CTypeAnonymousStruct(type, varName),
|
|
NubTypeEnum type => $"struct {NameMangler.Mangle(type.Module, type.Name, type)}" + (varName != null ? $" {varName}" : ""),
|
|
NubTypeEnumVariant type => CType(type.EnumType, varName),
|
|
NubTypeSInt type => $"int{type.Width}_t" + (varName != null ? $" {varName}" : ""),
|
|
NubTypeUInt type => $"uint{type.Width}_t" + (varName != null ? $" {varName}" : ""),
|
|
NubTypePointer type => CType(type.To) + (varName != null ? $" *{varName}" : "*"),
|
|
NubTypeString => "struct nub_core_string" + (varName != null ? $" {varName}" : ""),
|
|
NubTypeFunc type => $"{CType(type.ReturnType)} (*{varName})({string.Join(", ", type.Parameters.Select(p => CType(p)))})",
|
|
_ => throw new ArgumentOutOfRangeException(nameof(node), node, null)
|
|
};
|
|
}
|
|
|
|
private string CTypeAnonymousStruct(NubTypeAnonymousStruct type, string? varName)
|
|
{
|
|
return $"struct {{ {string.Join(' ', type.Fields.Select(x => $"{CType(x.Type)} {x.Name};"))} }}{(varName != null ? $" {varName}" : "")}";
|
|
}
|
|
}
|
|
|
|
internal class IndentedTextWriter
|
|
{
|
|
private readonly StringBuilder builder = new();
|
|
private int indentLevel;
|
|
|
|
public IDisposable Indent()
|
|
{
|
|
indentLevel++;
|
|
return new IndentScope(this);
|
|
}
|
|
|
|
public void WriteLine(string text)
|
|
{
|
|
WriteIndent();
|
|
builder.AppendLine(text);
|
|
}
|
|
|
|
public void Write(string text)
|
|
{
|
|
WriteIndent();
|
|
builder.Append(text);
|
|
}
|
|
|
|
public void WriteLine()
|
|
{
|
|
builder.AppendLine();
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return builder.ToString();
|
|
}
|
|
|
|
private void WriteIndent()
|
|
{
|
|
if (builder.Length > 0)
|
|
{
|
|
var lastChar = builder[^1];
|
|
if (lastChar != '\n' && lastChar != '\r')
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < indentLevel; i++)
|
|
{
|
|
builder.Append(" ");
|
|
}
|
|
}
|
|
|
|
private class IndentScope(IndentedTextWriter writer) : IDisposable
|
|
{
|
|
private bool disposed;
|
|
|
|
public void Dispose()
|
|
{
|
|
if (disposed) return;
|
|
writer.indentLevel--;
|
|
disposed = true;
|
|
}
|
|
}
|
|
} |