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

...

Browse Source
This commit is contained in:
nub31
2025-06-21 17:57:45 +02:00
parent a97aed0b9c
commit eb5d78f064
3 changed files with 136 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
example/main.nub
View File

@@ -8,10 +8,24 @@ export func main(args: []cstring): i64 {
let human: Human let human: Human
human = alloc Human { human = alloc Human {
name = "test" name = "member"
} }
c::puts(human.name) c::puts(human.name)
c::puts("literal")
let x: cstring
x = "variable"
c::puts(x)
let y: func(cstring)
y = c::puts
y("proxy")
return 0 return 0
} }

2
src/CLI/Program.cs
View File

@@ -84,7 +84,7 @@ foreach (var compilationUnit in compilationUnits)
Debug.Assert(!string.IsNullOrWhiteSpace(outputDirectory)); Debug.Assert(!string.IsNullOrWhiteSpace(outputDirectory));
Directory.CreateDirectory(outputDirectory); Directory.CreateDirectory(outputDirectory);
var ssa = QBEGenerator.Generate(compilationUnit, definitionTable); var ssa = QBEGenerator.Emit(compilationUnit, definitionTable);
var ssaPath = Path.ChangeExtension(outputPath, "ssa"); var ssaPath = Path.ChangeExtension(outputPath, "ssa");
File.WriteAllText(ssaPath, ssa); File.WriteAllText(ssaPath, ssa);

248
src/Generation/QBE/QBEGenerator.cs
View File

@@ -28,7 +28,7 @@ public static class QBEGenerator
private static int _anonymousFuncIndex; private static int _anonymousFuncIndex;
private static bool _codeIsReachable = true; private static bool _codeIsReachable = true;
public static string Generate(CompilationUnit compilationUnit, DefinitionTable definitionTable) public static string Emit(CompilationUnit compilationUnit, DefinitionTable definitionTable)
{ {
_compilationUnit = compilationUnit; _compilationUnit = compilationUnit;
_definitionTable = definitionTable; _definitionTable = definitionTable;
@@ -47,19 +47,19 @@ public static class QBEGenerator
foreach (var structDef in _definitionTable.GetStructs()) foreach (var structDef in _definitionTable.GetStructs())
{ {
GenerateStructDefinition(structDef); EmitStructDefinition(structDef);
_builder.AppendLine(); _builder.AppendLine();
} }
foreach (var funcDef in _compilationUnit.Definitions.OfType<LocalFuncDefinitionNode>()) foreach (var funcDef in _compilationUnit.Definitions.OfType<LocalFuncDefinitionNode>())
{ {
GenerateFuncDefinition(FuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported); EmitFuncDefinition(FuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
_builder.AppendLine(); _builder.AppendLine();
} }
while (_anonymousFunctions.TryDequeue(out var anon)) while (_anonymousFunctions.TryDequeue(out var anon))
{ {
GenerateFuncDefinition(anon.Name, anon.Func.Parameters, anon.Func.ReturnType, anon.Func.Body, false); EmitFuncDefinition(anon.Name, anon.Func.Parameters, anon.Func.ReturnType, anon.Func.Body, false);
_builder.AppendLine(); _builder.AppendLine();
} }
@@ -305,10 +305,15 @@ public static class QBEGenerator
private static bool IsPointerType(NubType type) private static bool IsPointerType(NubType type)
{ {
return type is NubStructType or NubArrayType or NubFixedArrayType; if (type.IsVoid)
{
throw new InvalidOperationException($"{nameof(IsPointerType)} should not be called on void types");
}
return type is NubStructType or NubFixedArrayType;
} }
private static void GenerateFuncDefinition(string name, List<FuncParameter> parameters, NubType returnType, BlockNode body, bool exported) private static void EmitFuncDefinition(string name, List<FuncParameter> parameters, NubType returnType, BlockNode body, bool exported)
{ {
_variables.Clear(); _variables.Clear();
_variableScopes.Clear(); _variableScopes.Clear();
@@ -414,10 +419,10 @@ public static class QBEGenerator
} }
} }
parameterVars.Add(new Variable(parameter.Name, new Ident(parameterName, parameter.Type)).Assign()); parameterVars.Add(new Variable(parameter.Name, new Ident(parameterName, parameter.Type)));
} }
GenerateBlock(body, parameterVars); EmitBlock(body, parameterVars);
if (body.Statements.LastOrDefault() is not ReturnNode) if (body.Statements.LastOrDefault() is not ReturnNode)
{ {
@@ -430,7 +435,7 @@ public static class QBEGenerator
_builder.AppendLine("}"); _builder.AppendLine("}");
} }
private static void GenerateStructDefinition(StructDefinitionNode structDefinition) private static void EmitStructDefinition(StructDefinitionNode structDefinition)
{ {
_builder.Append($"type {StructName(structDefinition)} = {{ "); _builder.Append($"type {StructName(structDefinition)} = {{ ");
foreach (var structDefinitionField in structDefinition.Fields) foreach (var structDefinitionField in structDefinition.Fields)
@@ -466,54 +471,54 @@ public static class QBEGenerator
_builder.AppendLine("}"); _builder.AppendLine("}");
} }
private static void GenerateStatement(StatementNode statement) private static void EmitStatement(StatementNode statement)
{ {
switch (statement) switch (statement)
{ {
case ArrayIndexAssignmentNode arrayIndexAssignment: case ArrayIndexAssignmentNode arrayIndexAssignment:
GenerateArrayIndexAssignment(arrayIndexAssignment); EmitArrayIndexAssignment(arrayIndexAssignment);
break; break;
case BreakNode: case BreakNode:
GenerateBreak(); EmitBreak();
break; break;
case ContinueNode: case ContinueNode:
GenerateContinue(); EmitContinue();
break; break;
case DereferenceAssignmentNode dereferenceAssignment: case DereferenceAssignmentNode dereferenceAssignment:
GenerateDereferenceAssignment(dereferenceAssignment); EmitDereferenceAssignment(dereferenceAssignment);
break; break;
case IfNode ifStatement: case IfNode ifStatement:
GenerateIf(ifStatement); EmitIf(ifStatement);
break; break;
case MemberAssignmentNode memberAssignment: case MemberAssignmentNode memberAssignment:
GenerateMemberAssignment(memberAssignment); EmitMemberAssignment(memberAssignment);
break; break;
case ReturnNode @return: case ReturnNode @return:
GenerateReturn(@return); EmitReturn(@return);
break; break;
case StatementExpressionNode statementExpression: case StatementExpressionNode statementExpression:
GenerateExpression(statementExpression.Expression); EmitExpression(statementExpression.Expression);
break; break;
case VariableDeclarationNode variableDeclaration: case VariableDeclarationNode variableDeclaration:
GenerateVariableDeclaration(variableDeclaration); EmitVariableDeclaration(variableDeclaration);
break; break;
case VariableAssignmentNode variableAssignment: case VariableAssignmentNode variableAssignment:
GenerateVariableAssignment(variableAssignment); EmitVariableAssignment(variableAssignment);
break; break;
case WhileNode whileStatement: case WhileNode whileStatement:
GenerateWhile(whileStatement); EmitWhile(whileStatement);
break; break;
default: default:
throw new ArgumentOutOfRangeException(nameof(statement)); throw new ArgumentOutOfRangeException(nameof(statement));
} }
} }
private static void GenerateArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment) private static void EmitArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment)
{ {
var array = Unwrap(GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Array)); var array = EmitUnwrap(EmitExpression(arrayIndexAssignment.ArrayIndexAccess.Array));
var index = Unwrap(GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Index)); var index = EmitUnwrap(EmitExpression(arrayIndexAssignment.ArrayIndexAccess.Index));
GenerateArrayBoundsCheck(array, index); EmitArrayBoundsCheck(array, index);
var value = Unwrap(GenerateExpression(arrayIndexAssignment.Value)); var value = EmitUnwrap(EmitExpression(arrayIndexAssignment.Value));
switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type) switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type)
{ {
@@ -524,7 +529,7 @@ public static class QBEGenerator
_builder.AppendLine($" {pointer} =l add {pointer}, 8"); _builder.AppendLine($" {pointer} =l add {pointer}, 8");
_builder.AppendLine($" {pointer} =l add {array}, {pointer}"); _builder.AppendLine($" {pointer} =l add {array}, {pointer}");
GenerateCopy(arrayType.ElementType, value, pointer); EmitCopy(arrayType.ElementType, value, pointer);
break; break;
} }
case NubFixedArrayType fixedArrayType: case NubFixedArrayType fixedArrayType:
@@ -534,7 +539,7 @@ public static class QBEGenerator
_builder.AppendLine($" {pointer} =l add {pointer}, 8"); _builder.AppendLine($" {pointer} =l add {pointer}, 8");
_builder.AppendLine($" {pointer} =l add {array}, {pointer}"); _builder.AppendLine($" {pointer} =l add {array}, {pointer}");
GenerateCopy(fixedArrayType.ElementType, value, pointer); EmitCopy(fixedArrayType.ElementType, value, pointer);
break; break;
} }
default: default:
@@ -544,7 +549,7 @@ public static class QBEGenerator
} }
} }
private static void GenerateBlock(BlockNode block, List<Variable>? variables = null) private static void EmitBlock(BlockNode block, List<Variable>? variables = null)
{ {
_variableScopes.Push(_variables.Count); _variableScopes.Push(_variables.Count);
if (variables != null) if (variables != null)
@@ -557,7 +562,7 @@ public static class QBEGenerator
foreach (var statement in block.Statements.Where(_ => _codeIsReachable)) foreach (var statement in block.Statements.Where(_ => _codeIsReachable))
{ {
GenerateStatement(statement); EmitStatement(statement);
} }
var count = _variableScopes.Pop(); var count = _variableScopes.Pop();
@@ -569,50 +574,50 @@ public static class QBEGenerator
_codeIsReachable = true; _codeIsReachable = true;
} }
private static void GenerateBreak() private static void EmitBreak()
{ {
_builder.AppendLine($" jmp {_breakLabels.Peek()}"); _builder.AppendLine($" jmp {_breakLabels.Peek()}");
_codeIsReachable = false; _codeIsReachable = false;
} }
private static void GenerateContinue() private static void EmitContinue()
{ {
_builder.AppendLine($" jmp {_continueLabels.Peek()}"); _builder.AppendLine($" jmp {_continueLabels.Peek()}");
_codeIsReachable = false; _codeIsReachable = false;
} }
private static void GenerateDereferenceAssignment(DereferenceAssignmentNode dereferenceAssignment) private static void EmitDereferenceAssignment(DereferenceAssignmentNode dereferenceAssignment)
{ {
var pointer = Unwrap(GenerateExpression(dereferenceAssignment.Dereference.Expression)); var pointer = EmitUnwrap(EmitExpression(dereferenceAssignment.Dereference.Expression));
var value = Unwrap(GenerateExpression(dereferenceAssignment.Value)); var value = EmitUnwrap(EmitExpression(dereferenceAssignment.Value));
GenerateCopy(dereferenceAssignment.Value.Type, value, pointer); EmitCopy(dereferenceAssignment.Value.Type, value, pointer);
} }
private static void GenerateIf(IfNode ifStatement) private static void EmitIf(IfNode ifStatement)
{ {
var trueLabel = LabelName(); var trueLabel = LabelName();
var falseLabel = LabelName(); var falseLabel = LabelName();
var endLabel = LabelName(); var endLabel = LabelName();
var result = Unwrap(GenerateExpression(ifStatement.Condition)); var result = EmitUnwrap(EmitExpression(ifStatement.Condition));
_builder.AppendLine($" jnz {result}, {trueLabel}, {falseLabel}"); _builder.AppendLine($" jnz {result}, {trueLabel}, {falseLabel}");
_builder.AppendLine(trueLabel); _builder.AppendLine(trueLabel);
GenerateBlock(ifStatement.Body); EmitBlock(ifStatement.Body);
_builder.AppendLine($" jmp {endLabel}"); _builder.AppendLine($" jmp {endLabel}");
_builder.AppendLine(falseLabel); _builder.AppendLine(falseLabel);
if (ifStatement.Else.HasValue) if (ifStatement.Else.HasValue)
{ {
ifStatement.Else.Value.Match ifStatement.Else.Value.Match
( (
elseIfNode => GenerateIf(elseIfNode), elseIfNode => EmitIf(elseIfNode),
elseNode => GenerateBlock(elseNode) elseNode => EmitBlock(elseNode)
); );
} }
_builder.AppendLine(endLabel); _builder.AppendLine(endLabel);
} }
private static void GenerateMemberAssignment(MemberAssignmentNode memberAssignment) private static void EmitMemberAssignment(MemberAssignmentNode memberAssignment)
{ {
var structType = memberAssignment.MemberAccess.Expression.Type as NubStructType; var structType = memberAssignment.MemberAccess.Expression.Type as NubStructType;
Debug.Assert(structType != null); Debug.Assert(structType != null);
@@ -620,21 +625,21 @@ public static class QBEGenerator
var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue(); var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member); var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member);
var item = Unwrap(GenerateExpression(memberAssignment.MemberAccess.Expression)); var item = EmitUnwrap(EmitExpression(memberAssignment.MemberAccess.Expression));
var pointer = VarName(); var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {item}, {offset}"); _builder.AppendLine($" {pointer} =l add {item}, {offset}");
var value = Unwrap(GenerateExpression(memberAssignment.Value)); var value = EmitUnwrap(EmitExpression(memberAssignment.Value));
GenerateCopy(memberAssignment.Value.Type, value, pointer); EmitCopy(memberAssignment.Value.Type, value, pointer);
} }
private static void GenerateReturn(ReturnNode @return) private static void EmitReturn(ReturnNode @return)
{ {
if (@return.Value.HasValue) if (@return.Value.HasValue)
{ {
var result = Unwrap(GenerateExpression(@return.Value.Value)); var result = EmitUnwrap(EmitExpression(@return.Value.Value));
_builder.AppendLine($" ret {result}"); _builder.AppendLine($" ret {result}");
} }
else else
@@ -643,22 +648,21 @@ public static class QBEGenerator
} }
} }
private static void GenerateVariableDeclaration(VariableDeclarationNode variableDeclaration) private static void EmitVariableDeclaration(VariableDeclarationNode variableDeclaration)
{ {
var tmp = VarName(); var tmp = VarName();
_builder.AppendLine($" {tmp} =l alloc8 {SizeOf(variableDeclaration.Type)}"); _builder.AppendLine($" {tmp} =l alloc8 {SizeOf(variableDeclaration.Type)}");
_variables.Push(new Variable(variableDeclaration.Name, new Ident(tmp, variableDeclaration.Type))); _variables.Push(new Variable(variableDeclaration.Name, new Ident(tmp, variableDeclaration.Type)));
} }
private static void GenerateVariableAssignment(VariableAssignmentNode variableAssignment) private static void EmitVariableAssignment(VariableAssignmentNode variableAssignment)
{ {
var value = Unwrap(GenerateExpression(variableAssignment.Value)); var value = EmitUnwrap(EmitExpression(variableAssignment.Value));
var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name); var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name);
GenerateCopy(variableAssignment.Value.Type, value, variable.Ident.Name); EmitCopy(variableAssignment.Value.Type, value, variable.Ident.Name);
variable.Assign();
} }
private static void GenerateWhile(WhileNode whileStatement) private static void EmitWhile(WhileNode whileStatement)
{ {
var conditionLabel = LabelName(); var conditionLabel = LabelName();
var iterationLabel = LabelName(); var iterationLabel = LabelName();
@@ -669,9 +673,9 @@ public static class QBEGenerator
_builder.AppendLine($" jmp {conditionLabel}"); _builder.AppendLine($" jmp {conditionLabel}");
_builder.AppendLine(iterationLabel); _builder.AppendLine(iterationLabel);
GenerateBlock(whileStatement.Body); EmitBlock(whileStatement.Body);
_builder.AppendLine(conditionLabel); _builder.AppendLine(conditionLabel);
var result = Unwrap(GenerateExpression(whileStatement.Condition)); var result = EmitUnwrap(EmitExpression(whileStatement.Condition));
_builder.AppendLine($" jnz {result}, {iterationLabel}, {endLabel}"); _builder.AppendLine($" jnz {result}, {iterationLabel}, {endLabel}");
_builder.AppendLine(endLabel); _builder.AppendLine(endLabel);
@@ -679,39 +683,39 @@ public static class QBEGenerator
_breakLabels.Pop(); _breakLabels.Pop();
} }
private static Ident GenerateExpression(ExpressionNode expression) private static Ident EmitExpression(ExpressionNode expression)
{ {
return expression switch return expression switch
{ {
AddressOfNode addressOf => GenerateAddressOf(addressOf), AddressOfNode addressOf => EmitAddressOf(addressOf),
AnonymousFuncNode anonymousFunc => GenerateAnonymousFunc(anonymousFunc), AnonymousFuncNode anonymousFunc => EmitAnonymousFunc(anonymousFunc),
ArrayIndexAccessNode arrayIndex => GenerateArrayIndexAccess(arrayIndex), ArrayIndexAccessNode arrayIndex => EmitArrayIndexAccess(arrayIndex),
ArrayInitializerNode arrayInitializer => GenerateArrayInitializer(arrayInitializer), ArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer),
BinaryExpressionNode binaryExpression => GenerateBinaryExpression(binaryExpression), BinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression),
DereferenceNode dereference => GenerateDereference(dereference), DereferenceNode dereference => EmitDereference(dereference),
FixedArrayInitializerNode fixedArrayInitializer => GenerateFixedArrayInitializer(fixedArrayInitializer), FixedArrayInitializerNode fixedArrayInitializer => EmitFixedArrayInitializer(fixedArrayInitializer),
FuncCallNode funcCallExpression => GenerateFuncCall(funcCallExpression), FuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression),
IdentifierNode identifier => GenerateIdentifier(identifier), IdentifierNode identifier => EmitIdentifier(identifier),
LiteralNode literal => GenerateLiteral(literal), LiteralNode literal => EmitLiteral(literal),
StructInitializerNode structInitializer => GenerateStructInitializer(structInitializer), StructInitializerNode structInitializer => EmitStructInitializer(structInitializer),
UnaryExpressionNode unaryExpression => GenerateUnaryExpression(unaryExpression), UnaryExpressionNode unaryExpression => EmitUnaryExpression(unaryExpression),
MemberAccessNode memberAccess => GenerateMemberAccess(memberAccess), MemberAccessNode memberAccess => EmitMemberAccess(memberAccess),
_ => throw new ArgumentOutOfRangeException(nameof(expression)) _ => throw new ArgumentOutOfRangeException(nameof(expression))
}; };
} }
private static Ident GenerateAnonymousFunc(AnonymousFuncNode anonymousFunc) private static Ident EmitAnonymousFunc(AnonymousFuncNode anonymousFunc)
{ {
var name = $"$anon_func{++_anonymousFuncIndex}"; var name = $"$anon_func{++_anonymousFuncIndex}";
_anonymousFunctions.Enqueue((anonymousFunc, name)); _anonymousFunctions.Enqueue((anonymousFunc, name));
return new Ident(name, anonymousFunc.Type, IdentKind.Func); return new Ident(name, anonymousFunc.Type, IdentKind.Func);
} }
private static string GenerateArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess) private static string EmitArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess)
{ {
var array = Unwrap(GenerateExpression(arrayIndexAccess.Array)); var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Array));
var index = Unwrap(GenerateExpression(arrayIndexAccess.Index)); var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));
GenerateArrayBoundsCheck(array, index); EmitArrayBoundsCheck(array, index);
var elementType = arrayIndexAccess.Array.Type switch var elementType = arrayIndexAccess.Array.Type switch
{ {
@@ -727,15 +731,15 @@ public static class QBEGenerator
return pointer; return pointer;
} }
private static Ident GenerateArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess) private static Ident EmitArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess)
{ {
var pointer = GenerateArrayIndexPointer(arrayIndexAccess); var pointer = EmitArrayIndexPointer(arrayIndexAccess);
var outputName = VarName(); var outputName = VarName();
_builder.AppendLine($" {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointer}"); _builder.AppendLine($" {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointer}");
return new Ident(outputName, arrayIndexAccess.Type); return new Ident(outputName, arrayIndexAccess.Type);
} }
private static void GenerateArrayBoundsCheck(string array, string index) private static void EmitArrayBoundsCheck(string array, string index)
{ {
var count = VarName(); var count = VarName();
_builder.AppendLine($" {count} =l loadl {array}"); _builder.AppendLine($" {count} =l loadl {array}");
@@ -759,9 +763,9 @@ public static class QBEGenerator
_builder.AppendLine(notOobLabel); _builder.AppendLine(notOobLabel);
} }
private static Ident GenerateArrayInitializer(ArrayInitializerNode arrayInitializer) private static Ident EmitArrayInitializer(ArrayInitializerNode arrayInitializer)
{ {
var capacity = Unwrap(GenerateExpression(arrayInitializer.Capacity)); var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity));
var elementSize = SizeOf(arrayInitializer.ElementType); var elementSize = SizeOf(arrayInitializer.ElementType);
var capacityInBytes = VarName(); var capacityInBytes = VarName();
@@ -780,23 +784,23 @@ public static class QBEGenerator
return new Ident(arrayPointer, arrayInitializer.Type); return new Ident(arrayPointer, arrayInitializer.Type);
} }
private static Ident GenerateDereference(DereferenceNode dereference) private static Ident EmitDereference(DereferenceNode dereference)
{ {
var result = Unwrap(GenerateExpression(dereference.Expression)); var result = EmitUnwrap(EmitExpression(dereference.Expression));
var outputName = VarName(); var outputName = VarName();
_builder.AppendLine($" {outputName} {QBEAssign(dereference.Type)} {QBELoad(dereference.Type)} {result}"); _builder.AppendLine($" {outputName} {QBEAssign(dereference.Type)} {QBELoad(dereference.Type)} {result}");
return new Ident(outputName, dereference.Type); return new Ident(outputName, dereference.Type);
} }
private static Ident GenerateAddressOf(AddressOfNode addressOf) private static Ident EmitAddressOf(AddressOfNode addressOf)
{ {
switch (addressOf.Expression) switch (addressOf.Expression)
{ {
case ArrayIndexAccessNode arrayIndexAccess: case ArrayIndexAccessNode arrayIndexAccess:
var pointer = GenerateArrayIndexPointer(arrayIndexAccess); var pointer = EmitArrayIndexPointer(arrayIndexAccess);
return new Ident(pointer, addressOf.Type); return new Ident(pointer, addressOf.Type);
case DereferenceNode dereference: case DereferenceNode dereference:
return GenerateExpression(dereference.Expression); return EmitExpression(dereference.Expression);
case IdentifierNode identifier: case IdentifierNode identifier:
if (identifier.Namespace.HasValue) if (identifier.Namespace.HasValue)
{ {
@@ -805,17 +809,17 @@ public static class QBEGenerator
return _variables.Single(x => x.Name == identifier.Name).Ident; return _variables.Single(x => x.Name == identifier.Name).Ident;
case MemberAccessNode memberAccess: case MemberAccessNode memberAccess:
var ptr = GenerateMemberAccessPointer(memberAccess); var ptr = EmitMemberAccessPointer(memberAccess);
return new Ident(ptr, addressOf.Type); return new Ident(ptr, addressOf.Type);
default: default:
throw new ArgumentOutOfRangeException(); throw new ArgumentOutOfRangeException();
} }
} }
private static Ident GenerateBinaryExpression(BinaryExpressionNode binaryExpression) private static Ident EmitBinaryExpression(BinaryExpressionNode binaryExpression)
{ {
var left = Unwrap(GenerateExpression(binaryExpression.Left)); var left = EmitUnwrap(EmitExpression(binaryExpression.Left));
var right = Unwrap(GenerateExpression(binaryExpression.Right)); var right = EmitUnwrap(EmitExpression(binaryExpression.Right));
var outputName = VarName(); var outputName = VarName();
var output = new Ident(outputName, binaryExpression.Type); var output = new Ident(outputName, binaryExpression.Type);
@@ -1026,7 +1030,7 @@ public static class QBEGenerator
throw new NotSupportedException($"Binary operator {binaryExpression.Operator} for types {binaryExpression.Left.Type} and {binaryExpression.Right.Type} not supported"); throw new NotSupportedException($"Binary operator {binaryExpression.Operator} for types {binaryExpression.Left.Type} and {binaryExpression.Right.Type} not supported");
} }
private static Ident GenerateIdentifier(IdentifierNode identifier) private static Ident EmitIdentifier(IdentifierNode identifier)
{ {
if (_definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func)) if (_definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func))
{ {
@@ -1035,23 +1039,13 @@ public static class QBEGenerator
if (!identifier.Namespace.HasValue) if (!identifier.Namespace.HasValue)
{ {
var variable = _variables.Single(v => v.Name == identifier.Name); return _variables.Single(v => v.Name == identifier.Name).Ident;
if (IsPointerType(identifier.Type))
{
return variable.Ident;
}
else
{
var output = VarName();
_builder.AppendLine($" {output} {QBEAssign(identifier.Type)} {QBELoad(identifier.Type)} {variable.Ident}");
return new Ident(output, identifier.Type);
}
} }
throw new UnreachableException(); throw new UnreachableException();
} }
private static Ident GenerateLiteral(LiteralNode literal) private static Ident EmitLiteral(LiteralNode literal)
{ {
if (literal.Type.IsInteger) if (literal.Type.IsInteger)
{ {
@@ -1092,7 +1086,7 @@ public static class QBEGenerator
} }
} }
private static Ident GenerateStructInitializer(StructInitializerNode structInitializer) private static Ident EmitStructInitializer(StructInitializerNode structInitializer)
{ {
var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue(); var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue();
@@ -1106,17 +1100,17 @@ public static class QBEGenerator
if (structInitializer.Initializers.TryGetValue(field.Name, out var fieldValue)) if (structInitializer.Initializers.TryGetValue(field.Name, out var fieldValue))
{ {
var value = Unwrap(GenerateExpression(fieldValue)); var value = EmitUnwrap(EmitExpression(fieldValue));
var pointer = VarName(); var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {output}, {offset}"); _builder.AppendLine($" {pointer} =l add {output}, {offset}");
GenerateCopy(field.Type, value, pointer); EmitCopy(field.Type, value, pointer);
} }
else if (field.Value.HasValue) else if (field.Value.HasValue)
{ {
var value = Unwrap(GenerateExpression(field.Value.Value)); var value = EmitUnwrap(EmitExpression(field.Value.Value));
var pointer = VarName(); var pointer = VarName();
_builder.AppendLine($" {pointer} =l add {output}, {offset}"); _builder.AppendLine($" {pointer} =l add {output}, {offset}");
GenerateCopy(field.Type, value, pointer); EmitCopy(field.Type, value, pointer);
} }
else else
{ {
@@ -1127,9 +1121,9 @@ public static class QBEGenerator
return new Ident(output, structInitializer.StructType); return new Ident(output, structInitializer.StructType);
} }
private static Ident GenerateUnaryExpression(UnaryExpressionNode unaryExpression) private static Ident EmitUnaryExpression(UnaryExpressionNode unaryExpression)
{ {
var operand = Unwrap(GenerateExpression(unaryExpression.Operand)); var operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
var outputName = VarName(); var outputName = VarName();
switch (unaryExpression.Operator) switch (unaryExpression.Operator)
@@ -1174,9 +1168,9 @@ public static class QBEGenerator
throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported"); throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported");
} }
private static string GenerateMemberAccessPointer(MemberAccessNode memberAccess) private static string EmitMemberAccessPointer(MemberAccessNode memberAccess)
{ {
var item = Unwrap(GenerateExpression(memberAccess.Expression)); var item = EmitUnwrap(EmitExpression(memberAccess.Expression));
switch (memberAccess.Expression.Type) switch (memberAccess.Expression.Type)
{ {
case NubArrayType: case NubArrayType:
@@ -1204,16 +1198,16 @@ public static class QBEGenerator
} }
} }
private static Ident GenerateMemberAccess(MemberAccessNode memberAccess) private static Ident EmitMemberAccess(MemberAccessNode memberAccess)
{ {
var pointer = GenerateMemberAccessPointer(memberAccess); var pointer = EmitMemberAccessPointer(memberAccess);
var output = VarName(); var output = VarName();
_builder.AppendLine($" {output} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}"); _builder.AppendLine($" {output} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}");
return new Ident(output, memberAccess.Type); return new Ident(output, memberAccess.Type);
} }
private static Ident GenerateFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer) private static Ident EmitFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer)
{ {
var totalSize = SizeOf(fixedArrayInitializer.Type); var totalSize = SizeOf(fixedArrayInitializer.Type);
var outputName = VarName(); var outputName = VarName();
@@ -1230,7 +1224,7 @@ public static class QBEGenerator
return new Ident(outputName, fixedArrayInitializer.Type); return new Ident(outputName, fixedArrayInitializer.Type);
} }
private static Ident GenerateFuncCall(FuncCallNode funcCall) private static Ident EmitFuncCall(FuncCallNode funcCall)
{ {
var funcType = (NubFuncType)funcCall.Expression.Type; var funcType = (NubFuncType)funcCall.Expression.Type;
@@ -1239,7 +1233,7 @@ public static class QBEGenerator
for (var i = 0; i < funcCall.Parameters.Count; i++) for (var i = 0; i < funcCall.Parameters.Count; i++)
{ {
var parameter = funcCall.Parameters[i]; var parameter = funcCall.Parameters[i];
var result = Unwrap(GenerateExpression(parameter)); var result = EmitUnwrap(EmitExpression(parameter));
var qbeType = parameter.Type switch var qbeType = parameter.Type switch
{ {
@@ -1269,7 +1263,7 @@ public static class QBEGenerator
parameterStrings.Add($"{qbeType} {result}"); parameterStrings.Add($"{qbeType} {result}");
} }
var funcPointer = Unwrap(GenerateExpression(funcCall.Expression)); var funcPointer = EmitUnwrap(EmitExpression(funcCall.Expression));
if (funcType.ReturnType is not NubVoidType) if (funcType.ReturnType is not NubVoidType)
{ {
@@ -1284,19 +1278,19 @@ public static class QBEGenerator
} }
} }
private static void GenerateCopy(NubType type, string source, string destinationPtr) private static void EmitCopy(NubType type, string sourcePtr, string destinationPtr)
{ {
if (SizeOf(type) > 8) if (SizeOf(type) > 8)
{ {
_builder.AppendLine($" blit {source}, {destinationPtr}, {SizeOf(type)}"); _builder.AppendLine($" blit {sourcePtr}, {destinationPtr}, {SizeOf(type)}");
} }
else else
{ {
_builder.AppendLine($" {QBEStore(type)} {source}, {destinationPtr}"); _builder.AppendLine($" {QBEStore(type)} {sourcePtr}, {destinationPtr}");
} }
} }
private static string Unwrap(Ident ident) private static string EmitUnwrap(Ident ident)
{ {
if (ident.Type.IsVoid) if (ident.Type.IsVoid)
{ {
@@ -1309,7 +1303,7 @@ public static class QBEGenerator
case IdentKind.Literal: case IdentKind.Literal:
return ident.Name; return ident.Name;
case IdentKind.Variable: case IdentKind.Variable:
if (SizeOf(ident.Type) > 8) if (IsPointerType(ident.Type))
{ {
return ident.Name; return ident.Name;
} }
@@ -1329,13 +1323,6 @@ internal class Variable(string name, Ident ident)
{ {
public string Name { get; } = name; public string Name { get; } = name;
public Ident Ident { get; } = ident; public Ident Ident { get; } = ident;
public bool Initialized { get; private set; }
public Variable Assign()
{
Initialized = true;
return this;
}
} }
internal class Ident(string name, NubType type, IdentKind kind = IdentKind.Variable) internal class Ident(string name, NubType type, IdentKind kind = IdentKind.Variable)
@@ -1343,6 +1330,11 @@ internal class Ident(string name, NubType type, IdentKind kind = IdentKind.Varia
public string Name { get; } = name; public string Name { get; } = name;
public NubType Type { get; } = type; public NubType Type { get; } = type;
public IdentKind Kind { get; } = kind; public IdentKind Kind { get; } = kind;
public override string ToString()
{
throw new InvalidOperationException();
}
} }
internal enum IdentKind internal enum IdentKind