1137 lines
40 KiB
C#
1137 lines
40 KiB
C#
using System.Diagnostics;
|
|
using System.Text;
|
|
|
|
namespace Compiler;
|
|
|
|
public class Generator
|
|
{
|
|
public static string Emit(List<TypedNodeDefinitionFunc> functions, ModuleGraph moduleGraph, string? entryPoint)
|
|
{
|
|
return new Generator(functions, moduleGraph, entryPoint).Emit();
|
|
}
|
|
|
|
private Generator(List<TypedNodeDefinitionFunc> functions, ModuleGraph moduleGraph, string? entryPoint)
|
|
{
|
|
this.functions = functions;
|
|
this.moduleGraph = moduleGraph;
|
|
this.entryPoint = entryPoint;
|
|
}
|
|
|
|
const string NUB_H_CONTENTS =
|
|
"""
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
static inline void *nub_alloc(size_t size)
|
|
{
|
|
void *mem = malloc(size);
|
|
if (mem == NULL)
|
|
{
|
|
puts("Out of memory");
|
|
exit(1);
|
|
}
|
|
|
|
return mem;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
char *data;
|
|
size_t length;
|
|
size_t ref;
|
|
uint32_t flags;
|
|
} string;
|
|
|
|
typedef string *string_ptr;
|
|
|
|
#define FLAG_STRING_LITERAL 1
|
|
|
|
static inline void string_rc_inc(string_ptr str)
|
|
{
|
|
if (str == NULL)
|
|
return;
|
|
|
|
if (str->flags & FLAG_STRING_LITERAL)
|
|
return;
|
|
|
|
str->ref += 1;
|
|
}
|
|
|
|
static inline void string_rc_dec(string_ptr str)
|
|
{
|
|
if (str == NULL)
|
|
return;
|
|
|
|
if (str->flags & FLAG_STRING_LITERAL)
|
|
return;
|
|
|
|
if (str->ref == 0)
|
|
return;
|
|
|
|
str->ref -= 1;
|
|
|
|
if (str->ref == 0)
|
|
{
|
|
free(str->data);
|
|
free(str);
|
|
}
|
|
}
|
|
|
|
static inline string_ptr string_concat(string_ptr left, string_ptr right)
|
|
{
|
|
size_t new_length = left->length + right->length;
|
|
|
|
string_ptr result = (string_ptr)nub_alloc(sizeof(string));
|
|
result->data = (char*)nub_alloc(new_length + 1);
|
|
|
|
memcpy(result->data, left->data, left->length);
|
|
memcpy(result->data + left->length, right->data, right->length);
|
|
|
|
result->data[new_length] = '\0';
|
|
result->length = new_length;
|
|
result->ref = 1;
|
|
result->flags = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
static inline string_ptr string_from_cstr(char *cstr)
|
|
{
|
|
size_t len = strlen(cstr);
|
|
|
|
string_ptr result = (string_ptr)nub_alloc(sizeof(string));
|
|
result->data = (char*)nub_alloc(len + 1);
|
|
|
|
memcpy(result->data, cstr, len + 1);
|
|
|
|
result->length = len;
|
|
result->ref = 1;
|
|
result->flags = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
#define da_append(xs, x) \
|
|
do \
|
|
{ \
|
|
if ((xs)->count >= (xs)->capacity) \
|
|
{ \
|
|
(xs)->capacity *= 2; \
|
|
(xs)->items = realloc((xs)->items, (xs)->capacity * sizeof(*(xs)->items)); \
|
|
} \
|
|
(xs)->items[(xs)->count++] = (x); \
|
|
} while (0)
|
|
|
|
""";
|
|
|
|
private readonly List<TypedNodeDefinitionFunc> functions;
|
|
private readonly ModuleGraph moduleGraph;
|
|
private readonly string? entryPoint;
|
|
private IndentedTextWriter writer = new();
|
|
private readonly Dictionary<string, string> referencedStringLiterals = [];
|
|
private readonly HashSet<NubType> emittedTypes = [];
|
|
private readonly Stack<Scope> scopes = new();
|
|
private int tmpNameIndex = 0;
|
|
|
|
private string Emit()
|
|
{
|
|
var outPath = ".build";
|
|
var fileName = "out.c";
|
|
|
|
if (entryPoint != null)
|
|
{
|
|
writer.WriteLine("int main(int argc, char *argv[])");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine($"return {entryPoint}();");
|
|
}
|
|
writer.WriteLine("}");
|
|
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.Source == Module.DefinitionSource.Internal && !info.Extern && !info.Exported)
|
|
writer.Write("static ");
|
|
|
|
var parameters = function.Parameters.Select(x => $"{TypeName(x.Type)} {x.Name.Ident}");
|
|
|
|
writer.WriteLine($"{TypeName(function.ReturnType)} {info.MangledName}({string.Join(", ", parameters)})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
PushScope();
|
|
EmitStatement(function.Body);
|
|
PopScope();
|
|
}
|
|
writer.WriteLine("}");
|
|
writer.WriteLine();
|
|
}
|
|
|
|
var definitions = writer.ToString();
|
|
|
|
writer = new IndentedTextWriter();
|
|
|
|
foreach (var module in moduleGraph.GetModules())
|
|
{
|
|
foreach (var (name, info) in module.GetIdentifiers())
|
|
{
|
|
if (info.Source == Module.DefinitionSource.Internal || info.Exported)
|
|
{
|
|
if (info.Source == Module.DefinitionSource.Imported || info.Extern)
|
|
writer.Write("extern ");
|
|
else if (info.Source == Module.DefinitionSource.Internal && !info.Extern && !info.Exported)
|
|
writer.Write("static ");
|
|
|
|
if (info.Type is NubTypeFunc fn)
|
|
writer.WriteLine($"{TypeName(fn.ReturnType)} {info.MangledName}({string.Join(", ", fn.Parameters.Select(TypeName))});");
|
|
else
|
|
writer.WriteLine($"{TypeName(info.Type)} {info.MangledName};");
|
|
|
|
writer.WriteLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var (name, value) in referencedStringLiterals)
|
|
{
|
|
writer.WriteLine
|
|
(
|
|
$$"""
|
|
static string {{name}} = (string){
|
|
.data = "{{value}}",
|
|
.length = {{Encoding.UTF8.GetByteCount(value)}},
|
|
.ref = 0,
|
|
.flags = FLAG_STRING_LITERAL
|
|
};
|
|
|
|
"""
|
|
);
|
|
}
|
|
|
|
var declarations = writer.ToString();
|
|
|
|
writer = new IndentedTextWriter();
|
|
|
|
|
|
while (emittedTypes.Count != typeNames.Count)
|
|
{
|
|
var nextTypes = typeNames.Keys.ToArray();
|
|
foreach (var type in nextTypes)
|
|
{
|
|
EmitTypeDefinitionIfNotEmitted(type);
|
|
}
|
|
}
|
|
|
|
var types = writer.ToString();
|
|
|
|
var sb = new StringBuilder();
|
|
|
|
sb.AppendLine("#include \"nub.h\"");
|
|
sb.AppendLine();
|
|
sb.AppendLine(types);
|
|
sb.AppendLine(declarations);
|
|
sb.AppendLine(definitions);
|
|
|
|
Directory.CreateDirectory(outPath);
|
|
|
|
var filePath = Path.Combine(outPath, fileName);
|
|
|
|
File.WriteAllText(Path.Combine(outPath, "nub.h"), NUB_H_CONTENTS);
|
|
File.WriteAllText(filePath, sb.ToString());
|
|
|
|
return filePath;
|
|
}
|
|
|
|
private void EmitTypeDefinitionIfNotEmitted(NubType type)
|
|
{
|
|
if (emittedTypes.Contains(type))
|
|
return;
|
|
|
|
emittedTypes.Add(type);
|
|
|
|
var name = TypeName(type);
|
|
|
|
switch (type)
|
|
{
|
|
case NubTypeStruct structType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(structType.Module, structType.Name, true, out var info) || info is not Module.TypeInfoStruct structInfo)
|
|
throw new UnreachableException();
|
|
|
|
foreach (var field in structInfo.Fields)
|
|
EmitTypeDefinitionIfNotEmitted(field.Type);
|
|
|
|
if (structInfo.Packed)
|
|
writer.Write("__attribute__((__packed__)) ");
|
|
|
|
writer.WriteLine("typedef struct");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var field in structInfo.Fields)
|
|
{
|
|
writer.WriteLine($"{TypeName(field.Type)} {field.Name};");
|
|
}
|
|
}
|
|
writer.WriteLine($"}} {name};");
|
|
writer.WriteLine();
|
|
|
|
break;
|
|
}
|
|
case NubTypeAnonymousStruct anonymousStructType:
|
|
{
|
|
foreach (var field in anonymousStructType.Fields)
|
|
EmitTypeDefinitionIfNotEmitted(field.Type);
|
|
|
|
writer.WriteLine("typedef struct");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var field in anonymousStructType.Fields)
|
|
{
|
|
writer.WriteLine($"{TypeName(field.Type)} {field.Name};");
|
|
}
|
|
}
|
|
writer.WriteLine($"}} {name};");
|
|
writer.WriteLine();
|
|
|
|
break;
|
|
}
|
|
case NubTypeEnum enumType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(enumType.Module, enumType.Name, true, out var info) || info is not Module.TypeInfoEnum enumInfo)
|
|
throw new UnreachableException();
|
|
|
|
foreach (var variant in enumInfo.Variants)
|
|
{
|
|
if (variant.Type is not null)
|
|
{
|
|
EmitTypeDefinitionIfNotEmitted(variant.Type);
|
|
}
|
|
}
|
|
|
|
writer.WriteLine("typedef struct");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine("uint32_t tag;");
|
|
writer.WriteLine("union");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
foreach (var variant in enumInfo.Variants)
|
|
{
|
|
if (variant.Type is not null)
|
|
{
|
|
writer.WriteLine($"{TypeName(variant.Type)} {variant.Name};");
|
|
}
|
|
}
|
|
}
|
|
writer.WriteLine("};");
|
|
}
|
|
writer.WriteLine($"}} {name};");
|
|
writer.WriteLine();
|
|
|
|
break;
|
|
}
|
|
case NubTypeEnumVariant variantType:
|
|
{
|
|
EmitTypeDefinitionIfNotEmitted(variantType.EnumType);
|
|
break;
|
|
}
|
|
case NubTypePointer pointerType:
|
|
{
|
|
EmitTypeDefinitionIfNotEmitted(pointerType.To);
|
|
writer.WriteLine($"typedef {TypeName(pointerType.To)} *{name};");
|
|
break;
|
|
}
|
|
case NubTypeFunc funcType:
|
|
{
|
|
EmitTypeDefinitionIfNotEmitted(funcType.ReturnType);
|
|
foreach (var parameterType in funcType.Parameters)
|
|
EmitTypeDefinitionIfNotEmitted(parameterType);
|
|
|
|
writer.WriteLine($"typedef {TypeName(funcType.ReturnType)} (*)({string.Join(", ", funcType.Parameters.Select(TypeName))}) {name};");
|
|
|
|
break;
|
|
}
|
|
case NubTypeArray arrayType:
|
|
{
|
|
EmitTypeDefinitionIfNotEmitted(arrayType.ElementType);
|
|
|
|
var backingName = Tmp();
|
|
|
|
writer.WriteLine("typedef struct");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine("size_t count;");
|
|
writer.WriteLine("size_t capacity;");
|
|
writer.WriteLine($"{TypeName(arrayType.ElementType)} *items;");
|
|
writer.WriteLine("uint32_t ref;");
|
|
}
|
|
writer.WriteLine($"}} {backingName};");
|
|
writer.WriteLine();
|
|
|
|
writer.WriteLine($"typedef {backingName} *{name};");
|
|
writer.WriteLine();
|
|
|
|
writer.WriteLine($"static inline void {name}_rc_inc({name} array)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine("if (array == NULL) return;");
|
|
writer.WriteLine("array->ref += 1;");
|
|
}
|
|
writer.WriteLine("}");
|
|
writer.WriteLine();
|
|
|
|
writer.WriteLine($"static inline void {name}_rc_dec({name} array)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine("if (array == NULL) return;");
|
|
writer.WriteLine("if (array->ref == 0) return;");
|
|
writer.WriteLine();
|
|
writer.WriteLine("array->ref -= 1;");
|
|
writer.WriteLine();
|
|
writer.WriteLine("if (array->ref == 0)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine("for (size_t i = 0; i < array->count; ++i)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitCopyDestructor("array->items[i]", arrayType.ElementType);
|
|
}
|
|
writer.WriteLine("}");
|
|
writer.WriteLine();
|
|
writer.WriteLine("free(array->items);");
|
|
writer.WriteLine("free(array);");
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
writer.WriteLine("}");
|
|
writer.WriteLine();
|
|
|
|
writer.WriteLine($"static inline {name} {name}_make()");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
writer.WriteLine($"{name} array = ({name})nub_alloc(sizeof({backingName}));");
|
|
writer.WriteLine("array->ref = 1;");
|
|
writer.WriteLine("array->count = 0;");
|
|
writer.WriteLine("array->capacity = 10;");
|
|
writer.WriteLine($"array->items = ({TypeName(arrayType.ElementType)}*)nub_alloc(sizeof({TypeName(arrayType.ElementType)}) * array->capacity);");
|
|
writer.WriteLine("return array;");
|
|
}
|
|
writer.WriteLine("}");
|
|
writer.WriteLine();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmitStatement(TypedNodeStatement node)
|
|
{
|
|
if (scopes.Peek().Unreachable)
|
|
return;
|
|
|
|
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 TypedNodeStatementFor statement:
|
|
EmitStatementFor(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())
|
|
{
|
|
PushScope();
|
|
foreach (var statement in node.Statements)
|
|
EmitStatement(statement);
|
|
PopScope();
|
|
}
|
|
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)
|
|
{
|
|
if (statement.Value != null)
|
|
{
|
|
var value = EmitExpression(statement.Value);
|
|
EmitCleanupAllScopes();
|
|
writer.WriteLine($"return {value};");
|
|
}
|
|
else
|
|
{
|
|
EmitCleanupAllScopes();
|
|
writer.WriteLine($"return;");
|
|
}
|
|
|
|
scopes.Peek().Unreachable = true;
|
|
}
|
|
|
|
private void EmitStatementVariableDeclaration(TypedNodeStatementVariableDeclaration statement)
|
|
{
|
|
var value = EmitExpression(statement.Value);
|
|
EmitCopyConstructor(value, statement.Value.Type);
|
|
writer.WriteLine($"{TypeName(statement.Type)} {statement.Name.Ident} = {value};");
|
|
scopes.Peek().DeconstructableNames.Add((statement.Name.Ident, statement.Type));
|
|
}
|
|
|
|
private void EmitStatementAssignment(TypedNodeStatementAssignment statement)
|
|
{
|
|
var target = EmitExpression(statement.Target);
|
|
EmitCopyDestructor(target, statement.Target.Type);
|
|
var value = EmitExpression(statement.Value);
|
|
EmitCopyConstructor(value, statement.Value.Type);
|
|
writer.WriteLine($"{target} = {value};");
|
|
}
|
|
|
|
private void EmitStatementIf(TypedNodeStatementIf statement)
|
|
{
|
|
var condition = EmitExpression(statement.Condition);
|
|
writer.WriteLine($"if ({condition})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
PushScope();
|
|
EmitStatement(statement.ThenBlock);
|
|
PopScope();
|
|
}
|
|
writer.WriteLine("}");
|
|
|
|
if (statement.ElseBlock != null)
|
|
{
|
|
writer.Write("else");
|
|
if (statement.ElseBlock is TypedNodeStatementIf)
|
|
writer.Write(" ");
|
|
else
|
|
writer.WriteLine();
|
|
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
PushScope();
|
|
EmitStatement(statement.ElseBlock);
|
|
PopScope();
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
}
|
|
|
|
private void EmitStatementWhile(TypedNodeStatementWhile statement)
|
|
{
|
|
var condition = EmitExpression(statement.Condition);
|
|
writer.WriteLine($"while ({condition})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
PushScope();
|
|
EmitStatement(statement.Body);
|
|
PopScope();
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
|
|
private void EmitStatementFor(TypedNodeStatementFor statement)
|
|
{
|
|
var index = Tmp();
|
|
var array = EmitExpression(statement.Array);
|
|
writer.WriteLine($"for (size_t {index} = 0; {index} < {array}->count; ++{index})");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
var arrayType = (NubTypeArray)statement.Array.Type;
|
|
writer.WriteLine($"{TypeName(arrayType.ElementType)} {statement.VariableName.Ident} = {array}->items[{index}];");
|
|
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 variantInfo = enumInfo.Variants.First(x => x.Name == @case.Variant.Ident);
|
|
var tag = enumInfo.Variants.ToList().FindIndex(x => x.Name == @case.Variant.Ident);
|
|
|
|
writer.WriteLine($"case {tag}:");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
PushScope();
|
|
if (@case.VariableName != null)
|
|
{
|
|
Debug.Assert(variantInfo.Type is not null);
|
|
writer.WriteLine($"{TypeName(variantInfo.Type)} {@case.VariableName.Ident} = {target}.{@case.Variant.Ident};");
|
|
}
|
|
|
|
EmitStatement(@case.Body);
|
|
PopScope();
|
|
writer.WriteLine("break;");
|
|
}
|
|
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 => EmitExpressionStringLiteral(expression),
|
|
TypedNodeExpressionStructLiteral expression => EmitExpressionStructLiteral(expression),
|
|
TypedNodeExpressionEnumLiteral expression => EmitExpressionEnumLiteral(expression),
|
|
TypedNodeExpressionArrayLiteral expression => EmitNodeExpressionArrayLiteral(expression),
|
|
TypedNodeExpressionStringConstructor expression => EmitExpressionStringConstructor(expression),
|
|
TypedNodeExpressionStructMemberAccess expression => EmitExpressionMemberAccess(expression),
|
|
TypedNodeExpressionStringLength expression => EmitExpressionStringLength(expression),
|
|
TypedNodeExpressionStringPointer expression => EmitExpressionStringPointer(expression),
|
|
TypedNodeExpressionArrayCount expression => EmitExpressionArrayCount(expression),
|
|
TypedNodeExpressionArrayPointer expression => EmitExpressionArrayPointer(expression),
|
|
TypedNodeExpressionLocalIdent expression => expression.Name,
|
|
TypedNodeExpressionGlobalIdent expression => EmitNodeExpressionGlobalIdent(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);
|
|
|
|
var name = Tmp();
|
|
|
|
if (expression.Operation == TypedNodeExpressionBinary.Op.Add && expression.Left.Type is NubTypeString && expression.Right.Type is NubTypeString)
|
|
{
|
|
scopes.Peek().DeconstructableNames.Add((name, expression.Type));
|
|
writer.WriteLine($"{TypeName(NubTypeString.Instance)} {name} = string_concat({left}, {right});");
|
|
return name;
|
|
}
|
|
|
|
var op = 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()
|
|
};
|
|
|
|
writer.WriteLine($"{TypeName(expression.Type)} {name} = {op};");
|
|
|
|
return name;
|
|
}
|
|
|
|
private string EmitExpressionUnary(TypedNodeExpressionUnary expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
|
|
var name = Tmp();
|
|
|
|
var op = expression.Operation switch
|
|
{
|
|
TypedNodeExpressionUnary.Op.Negate => $"(-{target})",
|
|
TypedNodeExpressionUnary.Op.Invert => $"(!{target})",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
|
|
writer.WriteLine($"{TypeName(expression.Type)} {name} = {op};");
|
|
|
|
return name;
|
|
}
|
|
|
|
private string EmitExpressionStringLiteral(TypedNodeExpressionStringLiteral expression)
|
|
{
|
|
var name = Tmp();
|
|
referencedStringLiterals.Add(name, expression.Value.Value);
|
|
return $"(&{name})";
|
|
}
|
|
|
|
private string EmitExpressionStructLiteral(TypedNodeExpressionStructLiteral expression)
|
|
{
|
|
var name = Tmp();
|
|
scopes.Peek().DeconstructableNames.Add((name, expression.Type));
|
|
|
|
var initializerValues = new Dictionary<string, string>();
|
|
|
|
foreach (var initializer in expression.Initializers)
|
|
{
|
|
var value = EmitExpression(initializer.Value);
|
|
EmitCopyConstructor(value, initializer.Value.Type);
|
|
initializerValues[initializer.Name.Ident] = value;
|
|
}
|
|
|
|
var initializerStrings = initializerValues.Select(x => $".{x.Key} = {x.Value}");
|
|
|
|
writer.WriteLine($"{TypeName(expression.Type)} {name} = ({TypeName(expression.Type)}){{ {string.Join(", ", initializerStrings)} }};");
|
|
|
|
return name;
|
|
}
|
|
|
|
private string EmitExpressionEnumLiteral(TypedNodeExpressionEnumLiteral expression)
|
|
{
|
|
var name = Tmp();
|
|
scopes.Peek().DeconstructableNames.Add((name, expression.Type));
|
|
|
|
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);
|
|
|
|
string? value = null;
|
|
if (expression.Value != null)
|
|
{
|
|
value = EmitExpression(expression.Value);
|
|
EmitCopyConstructor(value, expression.Value.Type);
|
|
}
|
|
|
|
writer.Write($"{TypeName(expression.Type)} {name} = ({TypeName(expression.Type)}){{ .tag = {tag}");
|
|
|
|
if (value != null)
|
|
writer.WriteLine($", .{enumVariantType.Variant} = {value} }};");
|
|
else
|
|
writer.WriteLine(" };");
|
|
|
|
return name;
|
|
}
|
|
|
|
private string EmitNodeExpressionArrayLiteral(TypedNodeExpressionArrayLiteral expression)
|
|
{
|
|
var name = Tmp();
|
|
scopes.Peek().DeconstructableNames.Add((name, expression.Type));
|
|
|
|
writer.WriteLine($"{TypeName(expression.Type)} {name} = {TypeName(expression.Type)}_make();");
|
|
|
|
foreach (var value in expression.Values)
|
|
{
|
|
var valueName = EmitExpression(value);
|
|
writer.WriteLine($"da_append({name}, {valueName});");
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
private string EmitExpressionStringConstructor(TypedNodeExpressionStringConstructor expression)
|
|
{
|
|
var name = Tmp();
|
|
scopes.Peek().DeconstructableNames.Add((name, expression.Type));
|
|
var value = EmitExpression(expression.Value);
|
|
writer.WriteLine($"{TypeName(expression.Type)} {name} = string_from_cstr({value});");
|
|
return name;
|
|
}
|
|
|
|
private string EmitExpressionMemberAccess(TypedNodeExpressionStructMemberAccess expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
return $"{target}.{expression.Name.Ident}";
|
|
}
|
|
|
|
private string EmitExpressionStringLength(TypedNodeExpressionStringLength expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
return $"{target}->length";
|
|
}
|
|
|
|
private string EmitExpressionStringPointer(TypedNodeExpressionStringPointer expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
return $"{target}->data";
|
|
}
|
|
|
|
private string EmitExpressionArrayCount(TypedNodeExpressionArrayCount expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
return $"{target}->count";
|
|
}
|
|
|
|
private string EmitExpressionArrayPointer(TypedNodeExpressionArrayPointer expression)
|
|
{
|
|
var target = EmitExpression(expression.Target);
|
|
return $"{target}->items";
|
|
}
|
|
|
|
private string EmitNodeExpressionGlobalIdent(TypedNodeExpressionGlobalIdent expression)
|
|
{
|
|
if (!moduleGraph.TryResolveIdentifier(expression.Module, expression.Name, true, out var info))
|
|
throw new UnreachableException($"Module graph does not have info about identifier {expression.Module}::{expression.Name}. 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();
|
|
|
|
var tmp = Tmp();
|
|
writer.WriteLine($"{TypeName(expression.Type)} {tmp} = {name}({string.Join(", ", parameterValues)});");
|
|
return tmp;
|
|
}
|
|
|
|
private readonly Dictionary<NubType, string> typeNames = [];
|
|
|
|
private string TypeName(NubType type)
|
|
{
|
|
if (!typeNames.TryGetValue(type, out var name))
|
|
{
|
|
name = type switch
|
|
{
|
|
NubTypeVoid => "void",
|
|
NubTypeBool => "bool",
|
|
NubTypeStruct => Tmp(),
|
|
NubTypeAnonymousStruct => Tmp(),
|
|
NubTypeEnum => Tmp(),
|
|
NubTypeEnumVariant t => TypeName(t.EnumType),
|
|
NubTypeSInt t => $"int{t.Width}_t",
|
|
NubTypeUInt t => $"uint{t.Width}_t",
|
|
NubTypePointer => Tmp(),
|
|
NubTypeString => "string_ptr",
|
|
NubTypeChar => "char",
|
|
NubTypeFunc => Tmp(),
|
|
NubTypeArray => Tmp(),
|
|
_ => throw new NotImplementedException(),
|
|
};
|
|
|
|
typeNames[type] = name;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
private string Tmp()
|
|
{
|
|
return $"_tmp{tmpNameIndex++}";
|
|
}
|
|
|
|
private void EmitCleanupAllScopes()
|
|
{
|
|
foreach (var scope in scopes.Reverse())
|
|
{
|
|
for (int i = scope.DeconstructableNames.Count - 1; i >= 0; i--)
|
|
{
|
|
var (name, type) = scope.DeconstructableNames[i];
|
|
EmitCopyDestructor(name, type);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmitCleanupCurrentScope(Scope scope)
|
|
{
|
|
for (int i = scope.DeconstructableNames.Count - 1; i >= 0; i--)
|
|
{
|
|
var (name, type) = scope.DeconstructableNames[i];
|
|
EmitCopyDestructor(name, type);
|
|
}
|
|
}
|
|
|
|
private void EmitCopyConstructor(string value, NubType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case NubTypeArray arrayType:
|
|
{
|
|
writer.WriteLine($"{TypeName(type)}_rc_inc({value});");
|
|
break;
|
|
}
|
|
case NubTypeString:
|
|
{
|
|
writer.WriteLine($"string_rc_inc({value});");
|
|
break;
|
|
}
|
|
case NubTypeStruct structType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(structType.Module, structType.Name, true, out var info) || info is not Module.TypeInfoStruct structInfo)
|
|
throw new UnreachableException();
|
|
|
|
foreach (var field in structInfo.Fields)
|
|
{
|
|
EmitCopyConstructor($"{value}.{field.Name}", field.Type);
|
|
}
|
|
break;
|
|
}
|
|
case NubTypeAnonymousStruct anonymousStructType:
|
|
{
|
|
foreach (var field in anonymousStructType.Fields)
|
|
{
|
|
EmitCopyConstructor($"{value}.{field.Name}", field.Type);
|
|
}
|
|
break;
|
|
}
|
|
case NubTypeEnum enumType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(enumType.Module, enumType.Name, true, out var info) || info is not Module.TypeInfoEnum enumInfo)
|
|
throw new UnreachableException();
|
|
|
|
writer.WriteLine($"switch ({value}.tag)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
for (int i = 0; i < enumInfo.Variants.Count; i++)
|
|
{
|
|
Module.TypeInfoEnum.Variant variant = enumInfo.Variants[i];
|
|
|
|
if (variant.Type is not null)
|
|
{
|
|
writer.WriteLine($"case {i}:");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitCopyConstructor($"{value}.{variant.Name}", variant.Type);
|
|
writer.WriteLine("break;");
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
}
|
|
}
|
|
writer.WriteLine("}");
|
|
break;
|
|
}
|
|
case NubTypeEnumVariant enumVariantType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(enumVariantType.EnumType.Module, enumVariantType.EnumType.Name, true, out var info) || info is not Module.TypeInfoEnum enumInfo)
|
|
throw new UnreachableException();
|
|
|
|
var variant = enumInfo.Variants.First(x => x.Name == enumVariantType.Variant);
|
|
if (variant.Type is not null)
|
|
EmitCopyConstructor($"{value}.{variant.Name}", variant.Type);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmitCopyDestructor(string value, NubType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case NubTypeArray arrayType:
|
|
{
|
|
writer.WriteLine($"{TypeName(type)}_rc_dec({value});");
|
|
break;
|
|
}
|
|
case NubTypeString:
|
|
{
|
|
writer.WriteLine($"string_rc_dec({value});");
|
|
break;
|
|
}
|
|
case NubTypeStruct structType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(structType.Module, structType.Name, true, out var info) || info is not Module.TypeInfoStruct structInfo)
|
|
throw new UnreachableException();
|
|
|
|
foreach (var field in structInfo.Fields)
|
|
{
|
|
EmitCopyDestructor($"{value}.{field.Name}", field.Type);
|
|
}
|
|
break;
|
|
}
|
|
case NubTypeAnonymousStruct anonymousStructType:
|
|
{
|
|
foreach (var field in anonymousStructType.Fields)
|
|
{
|
|
EmitCopyDestructor($"{value}.{field.Name}", field.Type);
|
|
}
|
|
break;
|
|
}
|
|
case NubTypeEnum enumType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(enumType.Module, enumType.Name, true, out var info) || info is not Module.TypeInfoEnum enumInfo)
|
|
throw new UnreachableException();
|
|
|
|
writer.WriteLine($"switch ({value}.tag)");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
for (int i = 0; i < enumInfo.Variants.Count; i++)
|
|
{
|
|
var variant = enumInfo.Variants[i];
|
|
if (variant.Type is not null)
|
|
{
|
|
writer.WriteLine($"case {i}:");
|
|
writer.WriteLine("{");
|
|
using (writer.Indent())
|
|
{
|
|
EmitCopyDestructor($"{value}.{variant.Name}", variant.Type);
|
|
writer.WriteLine("break;");
|
|
}
|
|
writer.WriteLine("}");
|
|
}
|
|
}
|
|
}
|
|
writer.WriteLine("}");
|
|
break;
|
|
}
|
|
case NubTypeEnumVariant enumVariantType:
|
|
{
|
|
if (!moduleGraph.TryResolveType(enumVariantType.EnumType.Module, enumVariantType.EnumType.Name, true, out var info) || info is not Module.TypeInfoEnum enumInfo)
|
|
throw new UnreachableException();
|
|
|
|
var variant = enumInfo.Variants.First(x => x.Name == enumVariantType.Variant);
|
|
if (variant.Type is not null)
|
|
EmitCopyDestructor($"{value}.{variant.Name}", variant.Type);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PushScope()
|
|
{
|
|
scopes.Push(new Scope());
|
|
}
|
|
|
|
private void PopScope()
|
|
{
|
|
var scope = scopes.Pop();
|
|
if (!scope.Unreachable)
|
|
EmitCleanupCurrentScope(scope);
|
|
}
|
|
|
|
private class Scope
|
|
{
|
|
public List<(string Name, NubType Type)> DeconstructableNames { get; } = [];
|
|
public bool Unreachable { get; set; }
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|