nub31/nub-lang
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Type checking basics

Browse Source
This commit is contained in:
Oliver Stene
2026-02-08 23:05:50 +01:00
parent b31a2d01c6
commit 3db412a060
4 changed files with 780 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
compiler/Compiler/Generator.cs
View File

@@ -2,14 +2,15 @@
namespace Compiler;
public sealed class Generator(List<NodeDefinition> nodes)
public sealed class Generator(TypedAst ast)
{
public static string Emit(List<NodeDefinition> nodes)
public static string Emit(TypedAst ast)
{
return new Generator(nodes).Emit();
return new Generator(ast).Emit();
}
private IndentedTextWriter writer = new();
private Dictionary<NubTypeStruct, string> structTypeNames = new();
private string Emit()
{
@@ -27,23 +28,22 @@ public sealed class Generator(List<NodeDefinition> nodes)
""");
foreach (var node in nodes.OfType<NodeDefinitionFunc>())
for (var i = 0; i < ast.StructTypes.Count; i++)
{
var parameters = node.Parameters.Select(x => CType(x.Type, x.Name.Ident));
writer.WriteLine($"{CType(node.ReturnType, node.Name.Ident)}({string.Join(", ", parameters)});");
var structType = ast.StructTypes[i];
structTypeNames[structType] = $"s{i}";
}
writer.WriteLine();
foreach (var node in nodes.OfType<NodeDefinitionStruct>())
foreach (var structType in ast.StructTypes)
{
writer.WriteLine($"struct {node.Name.Ident}");
var name = structTypeNames[structType];
writer.WriteLine($"struct {name}");
writer.WriteLine("{");
using (writer.Indent())
{
foreach (var field in node.Fields)
foreach (var field in structType.Fields)
{
writer.WriteLine($"{CType(field.Type, field.Name.Ident)};");
writer.WriteLine($"{CType(field.Type, field.Name)};");
}
}
@@ -52,7 +52,15 @@ public sealed class Generator(List<NodeDefinition> nodes)
writer.WriteLine();
foreach (var node in nodes.OfType<NodeDefinitionFunc>())
foreach (var node in ast.Functions)
{
var parameters = node.Parameters.Select(x => CType(x.Type, x.Name.Ident));
writer.WriteLine($"{CType(node.ReturnType, node.Name.Ident)}({string.Join(", ", parameters)});");
}
writer.WriteLine();
foreach (var node in ast.Functions)
{
var parameters = node.Parameters.Select(x => CType(x.Type, x.Name.Ident));
writer.WriteLine($"{CType(node.ReturnType, node.Name.Ident)}({string.Join(", ", parameters)})");
@@ -69,29 +77,29 @@ public sealed class Generator(List<NodeDefinition> nodes)
return writer.ToString();
}
private void EmitStatement(NodeStatement node)
private void EmitStatement(TypedNodeStatement node)
{
switch (node)
{
case NodeStatementBlock statement:
case TypedNodeStatementBlock statement:
EmitStatementBlock(statement);
break;
case NodeStatementFuncCall statement:
case TypedNodeStatementFuncCall statement:
EmitStatementFuncCall(statement);
break;
case NodeStatementReturn statement:
case TypedNodeStatementReturn statement:
EmitStatementReturn(statement);
break;
case NodeStatementVariableDeclaration statement:
case TypedNodeStatementVariableDeclaration statement:
EmitStatementVariableDeclaration(statement);
break;
case NodeStatementAssignment statement:
case TypedNodeStatementAssignment statement:
EmitStatementAssignment(statement);
break;
case NodeStatementIf statement:
case TypedNodeStatementIf statement:
EmitStatementIf(statement);
break;
case NodeStatementWhile statement:
case TypedNodeStatementWhile statement:
EmitStatementWhile(statement);
break;
default:
@@ -99,7 +107,7 @@ public sealed class Generator(List<NodeDefinition> nodes)
}
}
private void EmitStatementBlock(NodeStatementBlock node)
private void EmitStatementBlock(TypedNodeStatementBlock node)
{
writer.WriteLine("{");
using (writer.Indent())
@@ -111,33 +119,33 @@ public sealed class Generator(List<NodeDefinition> nodes)
writer.WriteLine("}");
}
private void EmitStatementFuncCall(NodeStatementFuncCall node)
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(NodeStatementReturn statement)
private void EmitStatementReturn(TypedNodeStatementReturn statement)
{
var value = EmitExpression(statement.Value);
writer.WriteLine($"return {value};");
}
private void EmitStatementVariableDeclaration(NodeStatementVariableDeclaration statement)
private void EmitStatementVariableDeclaration(TypedNodeStatementVariableDeclaration statement)
{
var value = EmitExpression(statement.Value);
writer.WriteLine($"{CType(statement.Type)} {statement.Name.Ident} = {value};");
}
private void EmitStatementAssignment(NodeStatementAssignment statement)
private void EmitStatementAssignment(TypedNodeStatementAssignment statement)
{
var target = EmitExpression(statement.Target);
var value = EmitExpression(statement.Value);
writer.WriteLine($"{target} = {value};");
}
private void EmitStatementIf(NodeStatementIf statement)
private void EmitStatementIf(TypedNodeStatementIf statement)
{
var condition = EmitExpression(statement.Condition);
writer.WriteLine($"if ({condition})");
@@ -152,7 +160,7 @@ public sealed class Generator(List<NodeDefinition> nodes)
if (statement.ElseBlock != null)
{
writer.Write("else");
if (statement.ElseBlock is NodeStatementIf)
if (statement.ElseBlock is TypedNodeStatementIf)
writer.Write(" ");
else
writer.WriteLine();
@@ -167,7 +175,7 @@ public sealed class Generator(List<NodeDefinition> nodes)
}
}
private void EmitStatementWhile(NodeStatementWhile statement)
private void EmitStatementWhile(TypedNodeStatementWhile statement)
{
var condition = EmitExpression(statement.Condition);
writer.WriteLine($"while ({condition})");
@@ -180,61 +188,61 @@ public sealed class Generator(List<NodeDefinition> nodes)
writer.WriteLine("}");
}
private string EmitExpression(NodeExpression node)
private string EmitExpression(TypedNodeExpression node)
{
return node switch
{
NodeExpressionBinary expression => EmitExpressionBinary(expression),
NodeExpressionUnary expression => EmitExpressionUnary(expression),
NodeExpressionBoolLiteral expression => expression.Value.Value ? "true" : "false",
NodeExpressionIntLiteral expression => expression.Value.Value.ToString(),
NodeExpressionStringLiteral expression => $"(struct string){{ \"{expression.Value.Value}\", {expression.Value.Value.Length} }}",
NodeExpressionStructLiteral expression => EmitExpressionStructLiteral(expression),
NodeExpressionMemberAccess expression => EmitExpressionMemberAccess(expression),
NodeExpressionIdent expression => expression.Value.Ident,
TypedNodeExpressionBinary expression => EmitExpressionBinary(expression),
TypedNodeExpressionUnary expression => EmitExpressionUnary(expression),
TypedNodeExpressionBoolLiteral expression => expression.Value.Value ? "true" : "false",
TypedNodeExpressionIntLiteral expression => expression.Value.Value.ToString(),
TypedNodeExpressionStringLiteral expression => $"(struct string){{ \"{expression.Value.Value}\", {expression.Value.Value.Length} }}",
TypedNodeExpressionStructLiteral expression => EmitExpressionStructLiteral(expression),
TypedNodeExpressionMemberAccess expression => EmitExpressionMemberAccess(expression),
TypedNodeExpressionIdent expression => expression.Value.Ident,
_ => throw new ArgumentOutOfRangeException(nameof(node), node, null)
};
}
private string EmitExpressionBinary(NodeExpressionBinary expression)
private string EmitExpressionBinary(TypedNodeExpressionBinary expression)
{
var left = EmitExpression(expression.Left);
var right = EmitExpression(expression.Right);
return expression.Operation switch
{
NodeExpressionBinary.Op.Add => $"({left} + {right})",
NodeExpressionBinary.Op.Subtract => $"({left} - {right})",
NodeExpressionBinary.Op.Multiply => $"({left} * {right})",
NodeExpressionBinary.Op.Divide => $"({left} / {right})",
NodeExpressionBinary.Op.Modulo => $"({left} % {right})",
NodeExpressionBinary.Op.Equal => $"({left} == {right})",
NodeExpressionBinary.Op.NotEqual => $"({left} != {right})",
NodeExpressionBinary.Op.LessThan => $"({left} < {right})",
NodeExpressionBinary.Op.LessThanOrEqual => $"({left} <= {right})",
NodeExpressionBinary.Op.GreaterThan => $"({left} > {right})",
NodeExpressionBinary.Op.GreaterThanOrEqual => $"({left} >= {right})",
NodeExpressionBinary.Op.LeftShift => $"({left} << {right})",
NodeExpressionBinary.Op.RightShift => $"({left} >> {right})",
NodeExpressionBinary.Op.LogicalAnd => $"({left} && {right})",
NodeExpressionBinary.Op.LogicalOr => $"({left} || {right})",
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(NodeExpressionUnary expression)
private string EmitExpressionUnary(TypedNodeExpressionUnary expression)
{
var target = EmitExpression(expression.Target);
return expression.Operation switch
{
NodeExpressionUnary.Op.Negate => $"(-{target})",
NodeExpressionUnary.Op.Invert => $"(!{target})",
TypedNodeExpressionUnary.Op.Negate => $"(-{target})",
TypedNodeExpressionUnary.Op.Invert => $"(!{target})",
_ => throw new ArgumentOutOfRangeException()
};
}
private string EmitExpressionStructLiteral(NodeExpressionStructLiteral expression)
private string EmitExpressionStructLiteral(TypedNodeExpressionStructLiteral expression)
{
var initializerValues = new Dictionary<string, string>();
@@ -246,27 +254,27 @@ public sealed class Generator(List<NodeDefinition> nodes)
var initializerStrings = initializerValues.Select(x => $".{x.Key} = {x.Value}");
return $"(struct {expression.Name.Ident}){{ {string.Join(", ", initializerStrings)} }}";
return $"(struct {structTypeNames[(NubTypeStruct)expression.Type]}){{ {string.Join(", ", initializerStrings)} }}";
}
private string EmitExpressionMemberAccess(NodeExpressionMemberAccess expression)
private string EmitExpressionMemberAccess(TypedNodeExpressionMemberAccess expression)
{
var target = EmitExpression(expression.Target);
return $"{target}.{expression.Name.Ident}";
}
private static string CType(NodeType node, string? varName = null)
private string CType(NubType node, string? varName = null)
{
return node switch
{
NodeTypeVoid => "void" + (varName != null ? $" {varName}" : ""),
NodeTypeBool => "bool" + (varName != null ? $" {varName}" : ""),
NodeTypeCustom type => $"struct {type.Name.Ident}" + (varName != null ? $" {varName}" : ""),
NodeTypeSInt type => $"int{type.Width}_t" + (varName != null ? $" {varName}" : ""),
NodeTypeUInt type => $"uint{type.Width}_t" + (varName != null ? $" {varName}" : ""),
NodeTypePointer type => CType(type.To) + (varName != null ? $" *{varName}" : "*"),
NodeTypeString => "struct string" + (varName != null ? $" {varName}" : ""),
NodeTypeFunc type => $"{CType(type.ReturnType)} (*{varName})({string.Join(", ", type.Parameters.Select(p => CType(p)))})",
NubTypeVoid => "void" + (varName != null ? $" {varName}" : ""),
NubTypeBool => "bool" + (varName != null ? $" {varName}" : ""),
NubTypeStruct type => $"struct {structTypeNames[type]}" + (varName != null ? $" {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 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)
};
}