...

2025-10-17 14:45:55 +02:00
parent 21a5f016a0
commit f471e40471
10 changed files with 1783 additions and 285 deletions
--- a/bindings/generate.py
+++ b/bindings/generate.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+
 import sys
 import os
 import clang.cindex
@@ -11,6 +13,8 @@ def map_type(clang_type: Type):
        canonical.spelling.replace("const ", "")
        .replace("volatile ", "")
        .replace("restrict ", "")
+        .replace("struct ", "")
+        .replace("union ", "")
    )

    if kind == TypeKind.POINTER:
@@ -18,6 +22,17 @@ def map_type(clang_type: Type):
        if pointee.kind == TypeKind.CHAR_S or pointee.kind == TypeKind.CHAR_U:
            return "cstring"

+        if pointee.kind == TypeKind.FUNCTIONPROTO:
+            arg_types = []
+
+            for arg in pointee.get_canonical().argument_types():
+                arg_types.append(map_type(arg))
+
+            mapped_return = map_type(pointee.get_canonical().get_result())
+            args_str = ", ".join(arg_types)
+
+            return f"func({args_str}): {mapped_return}"
+
        return f"^{map_type(pointee)}"

    if kind == TypeKind.CONSTANTARRAY:
@@ -65,10 +80,7 @@ def map_type(clang_type: Type):
        return "f64"

    if kind == TypeKind.RECORD:
-        if not spelling.startswith("struct "):
-            raise Exception(f"Unknown custom type: {spelling}")
-
-        return spelling.replace("struct ", "")
+        return spelling

    raise Exception(f"Unresolved type: {spelling}")

@@ -81,7 +93,7 @@ filename = sys.argv[1]

 index = clang.cindex.Index.create()

-tu = index.parse(filename, ["-x", "c", "-std=c23"])
+tu = index.parse(filename, ["-x", "c", "-std=c23", "-I/usr/include"])

 if tu.diagnostics:
    for diag in tu.diagnostics:
--- a/compiler/NubLang.CLI/Program.cs
+++ b/compiler/NubLang.CLI/Program.cs
@@ -59,7 +59,7 @@ var cFilePath = Path.Combine(".build", "out.c");

 File.WriteAllText(cFilePath, c);

-using var process = Process.Start("gcc", ["-ffreestanding", "-nostartfiles", "-c", "-o", Path.Combine(".build", "out.o"), cFilePath]);
+using var process = Process.Start("gcc", ["-ffreestanding", "-nostartfiles", "-std=c23", "-g", "-c", "-o", Path.Combine(".build", "out.o"), cFilePath]);

 process.WaitForExit();

--- a/compiler/NubLang/Ast/Node.cs
+++ b/compiler/NubLang/Ast/Node.cs
@@ -1,54 +1,56 @@
+using NubLang.Syntax;
+
 namespace NubLang.Ast;

-public abstract record Node;
+public abstract record Node(List<Token> Tokens);

 #region Definitions

-public abstract record DefinitionNode(string Module, string Name) : Node;
+public abstract record DefinitionNode(List<Token> Tokens, string Module, string Name) : Node(Tokens);

-public record FuncParameterNode(string Name, NubType Type) : Node;
+public record FuncParameterNode(List<Token> Tokens, string Name, NubType Type) : Node(Tokens);

-public record FuncSignatureNode(List<FuncParameterNode> Parameters, NubType ReturnType) : Node;
+public record FuncSignatureNode(List<Token> Tokens, List<FuncParameterNode> Parameters, NubType ReturnType) : Node(Tokens);

-public record FuncNode(string Module, string Name, string? ExternSymbol, FuncSignatureNode Signature, BlockNode? Body) : DefinitionNode(Module, Name);
+public record FuncNode(List<Token> Tokens, string Module, string Name, string? ExternSymbol, FuncSignatureNode Signature, BlockNode? Body) : DefinitionNode(Tokens, Module, Name);

-public record StructFieldNode(string Name, NubType Type, ExpressionNode? Value) : Node;
+public record StructFieldNode(List<Token> Tokens, string Name, NubType Type, ExpressionNode? Value) : Node(Tokens);

-public record StructFuncNode(string Name, FuncSignatureNode Signature, BlockNode Body) : Node;
+public record StructFuncNode(List<Token> Tokens, string Name, FuncSignatureNode Signature, BlockNode Body) : Node(Tokens);

-public record StructNode(string Module, string Name, List<StructFieldNode> Fields, List<StructFuncNode> Functions) : DefinitionNode(Module, Name);
+public record StructNode(List<Token> Tokens, string Module, string Name, List<StructFieldNode> Fields, List<StructFuncNode> Functions) : DefinitionNode(Tokens, Module, Name);

-public record GlobalVariableNode(string Module, string Name, ExpressionNode Value) : DefinitionNode(Module, Name);
+public record GlobalVariableNode(List<Token> Tokens, string Module, string Name, ExpressionNode Value) : DefinitionNode(Tokens, Module, Name);

 #endregion

 #region Statements

-public abstract record StatementNode : Node;
+public abstract record StatementNode(List<Token> Tokens) : Node(Tokens);

-public abstract record TerminalStatementNode : StatementNode;
+public abstract record TerminalStatementNode(List<Token> Tokens) : StatementNode(Tokens);

-public record BlockNode(List<StatementNode> Statements) : StatementNode;
+public record BlockNode(List<Token> Tokens, List<StatementNode> Statements) : StatementNode(Tokens);

-public record StatementFuncCallNode(FuncCallNode FuncCall) : StatementNode;
+public record StatementFuncCallNode(List<Token> Tokens, FuncCallNode FuncCall) : StatementNode(Tokens);

-public record StatementStructFuncCallNode(StructFuncCallNode StructFuncCall) : StatementNode;
+public record StatementStructFuncCallNode(List<Token> Tokens, StructFuncCallNode StructFuncCall) : StatementNode(Tokens);

-public record ReturnNode(ExpressionNode? Value) : TerminalStatementNode;
+public record ReturnNode(List<Token> Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens);

-public record AssignmentNode(LValueExpressionNode Target, ExpressionNode Value) : StatementNode;
+public record AssignmentNode(List<Token> Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens);

-public record IfNode(ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode;
+public record IfNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode(Tokens);

-public record VariableDeclarationNode(string Name, ExpressionNode? Assignment, NubType Type) : StatementNode;
+public record VariableDeclarationNode(List<Token> Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens);

-public record ContinueNode : TerminalStatementNode;
+public record ContinueNode(List<Token> Tokens) : TerminalStatementNode(Tokens);

-public record BreakNode : TerminalStatementNode;
+public record BreakNode(List<Token> Tokens) : TerminalStatementNode(Tokens);

-public record WhileNode(ExpressionNode Condition, BlockNode Body) : StatementNode;
+public record WhileNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);

-public record DeferNode(StatementNode Statement) : StatementNode;
+public record DeferNode(List<Token> Tokens, StatementNode Statement) : StatementNode(Tokens);

 #endregion

@@ -82,58 +84,58 @@ public enum BinaryOperator
    BitwiseOr
 }

-public abstract record ExpressionNode(NubType Type) : Node;
+public abstract record ExpressionNode(List<Token> Tokens, NubType Type) : Node(Tokens);

-public abstract record LValueExpressionNode(NubType Type) : ExpressionNode(Type);
+public abstract record LValueExpressionNode(List<Token> Tokens, NubType Type) : ExpressionNode(Tokens, Type);

-public abstract record RValueExpressionNode(NubType Type) : ExpressionNode(Type);
+public abstract record RValueExpressionNode(List<Token> Tokens, NubType Type) : ExpressionNode(Tokens, Type);

-public record StringLiteralNode(NubType Type, string Value) : RValueExpressionNode(Type);
+public record StringLiteralNode(List<Token> Tokens, NubType Type, string Value) : RValueExpressionNode(Tokens, Type);

-public record CStringLiteralNode(NubType Type, string Value) : RValueExpressionNode(Type);
+public record CStringLiteralNode(List<Token> Tokens, NubType Type, string Value) : RValueExpressionNode(Tokens, Type);

-public record IntLiteralNode(NubType Type, long Value) : RValueExpressionNode(Type);
+public record IntLiteralNode(List<Token> Tokens, NubType Type, long Value) : RValueExpressionNode(Tokens, Type);

-public record UIntLiteralNode(NubType Type, ulong Value) : RValueExpressionNode(Type);
+public record UIntLiteralNode(List<Token> Tokens, NubType Type, ulong Value) : RValueExpressionNode(Tokens, Type);

-public record Float32LiteralNode(NubType Type, float Value) : RValueExpressionNode(Type);
+public record Float32LiteralNode(List<Token> Tokens, NubType Type, float Value) : RValueExpressionNode(Tokens, Type);

-public record Float64LiteralNode(NubType Type, double Value) : RValueExpressionNode(Type);
+public record Float64LiteralNode(List<Token> Tokens, NubType Type, double Value) : RValueExpressionNode(Tokens, Type);

-public record BoolLiteralNode(NubType Type, bool Value) : RValueExpressionNode(Type);
+public record BoolLiteralNode(List<Token> Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type);

-public record BinaryExpressionNode(NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Type);
+public record BinaryExpressionNode(List<Token> Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type);

-public record UnaryExpressionNode(NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Type);
+public record UnaryExpressionNode(List<Token> Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type);

-public record FuncCallNode(NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Type);
+public record FuncCallNode(List<Token> Tokens, NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type);

-public record StructFuncCallNode(NubType Type, string Module, string StructName, string FuncName, ExpressionNode StructExpression, List<ExpressionNode> Parameters) : RValueExpressionNode(Type);
+public record StructFuncCallNode(List<Token> Tokens, NubType Type, string Module, string StructName, string FuncName, ExpressionNode StructExpression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type);

-public record LValueIdentifierNode(NubType Type, string Name) : LValueExpressionNode(Type);
+public record LValueIdentifierNode(List<Token> Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type);

-public record RValueIdentifierNode(NubType Type, string Name) : RValueExpressionNode(Type);
+public record RValueIdentifierNode(List<Token> Tokens, NubType Type, string Name) : RValueExpressionNode(Tokens, Type);

-public record FuncIdentifierNode(NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Type);
+public record FuncIdentifierNode(List<Token> Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type);

-public record ArrayInitializerNode(NubType Type, ExpressionNode Capacity, NubType ElementType) : RValueExpressionNode(Type);
+public record ArrayInitializerNode(List<Token> Tokens, NubType Type, ExpressionNode Capacity, NubType ElementType) : RValueExpressionNode(Tokens, Type);

-public record ArrayIndexAccessNode(NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Type);
+public record ArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);

-public record AddressOfNode(NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Type);
+public record AddressOfNode(List<Token> Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type);

-public record StructFieldAccessNode(NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Type);
+public record StructFieldAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type);

-public record StructInitializerNode(NubStructType StructType, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(StructType);
+public record StructInitializerNode(List<Token> Tokens, NubStructType StructType, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(Tokens, StructType);

-public record DereferenceNode(NubType Type, ExpressionNode Target) : LValueExpressionNode(Type);
+public record DereferenceNode(List<Token> Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type);

-public record ConvertIntNode(NubType Type, ExpressionNode Value, NubIntType ValueType, NubIntType TargetType) : RValueExpressionNode(Type);
+public record ConvertIntNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubIntType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type);

-public record ConvertFloatNode(NubType Type, ExpressionNode Value, NubFloatType ValueType, NubFloatType TargetType) : RValueExpressionNode(Type);
+public record ConvertFloatNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubFloatType TargetType) : RValueExpressionNode(Tokens, Type);

-public record SizeBuiltinNode(NubType Type, NubType TargetType) : RValueExpressionNode(Type);
+public record SizeBuiltinNode(List<Token> Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type);

-public record FloatToIntBuiltinNode(NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Type);
+public record FloatToIntBuiltinNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type);

 #endregion
--- a/compiler/NubLang/Ast/TypeChecker.cs
+++ b/compiler/NubLang/Ast/TypeChecker.cs
@@ -160,7 +160,7 @@ public sealed class TypeChecker
        var fields = node.Fields.Select(CheckStructField).ToList();
        var functions = node.Functions.Select(CheckStructFunc).ToList();

-        return new StructNode(CurrentScope.Module, node.Name, fields, functions);
+        return new StructNode(node.Tokens, CurrentScope.Module, node.Name, fields, functions);
    }

    private StructFuncNode CheckStructFunc(StructFuncSyntax function)
@@ -173,7 +173,7 @@ public sealed class TypeChecker
        _funcReturnTypes.Push(ResolveType(function.Signature.ReturnType));
        var body = CheckBlock(function.Body);
        _funcReturnTypes.Pop();
-        return new StructFuncNode(function.Name, CheckFuncSignature(function.Signature), body);
+        return new StructFuncNode(function.Tokens, function.Name, CheckFuncSignature(function.Signature), body);
    }

    private StructFieldNode CheckStructField(StructFieldSyntax field)
@@ -184,7 +184,7 @@ public sealed class TypeChecker
            value = CheckExpression(field.Value, ResolveType(field.Type));
        }

-        return new StructFieldNode(field.Name, ResolveType(field.Type), value);
+        return new StructFieldNode(field.Tokens, field.Name, ResolveType(field.Type), value);
    }

    private FuncNode CheckFuncDefinition(FuncSyntax node)
@@ -207,7 +207,7 @@ public sealed class TypeChecker
            {
                if (signature.ReturnType is NubVoidType)
                {
-                    body.Statements.Add(new ReturnNode(null));
+                    body.Statements.Add(new ReturnNode(node.Tokens.Skip(node.Tokens.Count - 1).ToList(), null));
                }
                else
                {
@@ -221,12 +221,12 @@ public sealed class TypeChecker
            _funcReturnTypes.Pop();
        }

-        return new FuncNode(CurrentScope.Module, node.Name, node.ExternSymbol, signature, body);
+        return new FuncNode(node.Tokens, CurrentScope.Module, node.Name, node.ExternSymbol, signature, body);
    }

    private GlobalVariableNode CheckGlobalVariable(GlobalVariableSyntax node)
    {
-        return new GlobalVariableNode(CurrentScope.Module, node.Name, CheckExpression(node.Value));
+        return new GlobalVariableNode(node.Tokens, CurrentScope.Module, node.Name, CheckExpression(node.Value));
    }

    private AssignmentNode CheckAssignment(AssignmentSyntax statement)
@@ -238,7 +238,7 @@ public sealed class TypeChecker
        }

        var value = CheckExpression(statement.Value, lValue.Type);
-        return new AssignmentNode(lValue, value);
+        return new AssignmentNode(statement.Tokens, lValue, value);
    }

    private IfNode CheckIf(IfSyntax statement)
@@ -251,7 +251,7 @@ public sealed class TypeChecker
            elseStatement = statement.Else.Value.Match<Variant<IfNode, BlockNode>>(elif => CheckIf(elif), el => CheckBlock(el));
        }

-        return new IfNode(condition, body, elseStatement);
+        return new IfNode(statement.Tokens, condition, body, elseStatement);
    }

    private ReturnNode CheckReturn(ReturnSyntax statement)
@@ -263,7 +263,7 @@ public sealed class TypeChecker
            value = CheckExpression(statement.Value, _funcReturnTypes.Peek());
        }

-        return new ReturnNode(value);
+        return new ReturnNode(statement.Tokens, value);
    }

    private StatementNode CheckStatementExpression(StatementExpressionSyntax statement)
@@ -272,8 +272,8 @@ public sealed class TypeChecker

        return expression switch
        {
-            FuncCallNode funcCall => new StatementFuncCallNode(funcCall),
-            StructFuncCallNode structFuncCall => new StatementStructFuncCallNode(structFuncCall),
+            FuncCallNode funcCall => new StatementFuncCallNode(statement.Tokens, funcCall),
+            StructFuncCallNode structFuncCall => new StatementStructFuncCallNode(statement.Tokens, structFuncCall),
            _ => throw new TypeCheckerException(Diagnostic.Error("Expressions statements can only be function calls").At(statement).Build())
        };
    }
@@ -301,14 +301,14 @@ public sealed class TypeChecker

        CurrentScope.DeclareVariable(new Variable(statement.Name, type, VariableKind.LValue));

-        return new VariableDeclarationNode(statement.Name, assignmentNode, type);
+        return new VariableDeclarationNode(statement.Tokens, statement.Name, assignmentNode, type);
    }

    private WhileNode CheckWhile(WhileSyntax statement)
    {
        var condition = CheckExpression(statement.Condition, new NubBoolType());
        var body = CheckBlock(statement.Body);
-        return new WhileNode(condition, body);
+        return new WhileNode(statement.Tokens, condition, body);
    }

    private FuncSignatureNode CheckFuncSignature(FuncSignatureSyntax statement)
@@ -316,10 +316,10 @@ public sealed class TypeChecker
        var parameters = new List<FuncParameterNode>();
        foreach (var parameter in statement.Parameters)
        {
-            parameters.Add(new FuncParameterNode(parameter.Name, ResolveType(parameter.Type)));
+            parameters.Add(new FuncParameterNode(parameter.Tokens, parameter.Name, ResolveType(parameter.Type)));
        }

-        return new FuncSignatureNode(parameters, ResolveType(statement.ReturnType));
+        return new FuncSignatureNode(statement.Tokens, parameters, ResolveType(statement.ReturnType));
    }

    private ExpressionNode CheckExpression(ExpressionSyntax node, NubType? expectedType = null)
@@ -343,7 +343,7 @@ public sealed class TypeChecker
            MemberAccessSyntax expression => CheckMemberAccess(expression),
            StructInitializerSyntax expression => CheckStructInitializer(expression, expectedType),
            InterpretBuiltinSyntax expression => CheckExpression(expression.Target) with { Type = ResolveType(expression.Type) },
-            SizeBuiltinSyntax expression => new SizeBuiltinNode(new NubIntType(false, 64), ResolveType(expression.Type)),
+            SizeBuiltinSyntax expression => new SizeBuiltinNode(node.Tokens, new NubIntType(false, 64), ResolveType(expression.Type)),
            FloatToIntBuiltinSyntax expression => CheckFloatToInt(expression),
            _ => throw new ArgumentOutOfRangeException(nameof(node))
        };
@@ -357,7 +357,7 @@ public sealed class TypeChecker
        {
            if (sourceIntType.Signed == targetIntType.Signed && sourceIntType.Width < targetIntType.Width)
            {
-                return new ConvertIntNode(targetIntType, result, sourceIntType, targetIntType);
+                return new ConvertIntNode(node.Tokens, targetIntType, result, sourceIntType, targetIntType);
            }
        }

@@ -365,7 +365,7 @@ public sealed class TypeChecker
        {
            if (sourceFloatType.Width < targetFloatType.Width)
            {
-                return new ConvertFloatNode(targetFloatType, result, sourceFloatType, targetFloatType);
+                return new ConvertFloatNode(node.Tokens, targetFloatType, result, sourceFloatType, targetFloatType);
            }
        }

@@ -392,7 +392,7 @@ public sealed class TypeChecker
                .Build());
        }

-        return new FloatToIntBuiltinNode(targetIntType, value, sourceFloatType, targetIntType);
+        return new FloatToIntBuiltinNode(expression.Tokens, targetIntType, value, sourceFloatType, targetIntType);
    }

    private AddressOfNode CheckAddressOf(AddressOfSyntax expression)
@@ -404,7 +404,7 @@ public sealed class TypeChecker
        }

        var type = new NubPointerType(target.Type);
-        return new AddressOfNode(type, lvalue);
+        return new AddressOfNode(expression.Tokens, type, lvalue);
    }

    private ArrayIndexAccessNode CheckArrayIndexAccess(ArrayIndexAccessSyntax expression)
@@ -416,7 +416,7 @@ public sealed class TypeChecker
            throw new TypeCheckerException(Diagnostic.Error($"Cannot use array indexer on type {target.Type}").At(expression).Build());
        }

-        return new ArrayIndexAccessNode(arrayType.ElementType, target, index);
+        return new ArrayIndexAccessNode(expression.Tokens, arrayType.ElementType, target, index);
    }

    private ArrayInitializerNode CheckArrayInitializer(ArrayInitializerSyntax expression)
@@ -424,7 +424,7 @@ public sealed class TypeChecker
        var elementType = ResolveType(expression.ElementType);
        var type = new NubArrayType(elementType);
        var capacity = CheckExpression(expression.Capacity);
-        return new ArrayInitializerNode(type, capacity, elementType);
+        return new ArrayInitializerNode(expression.Tokens, type, capacity, elementType);
    }

    private BinaryExpressionNode CheckBinaryExpression(BinaryExpressionSyntax expression, NubType? expectedType)
@@ -469,7 +469,7 @@ public sealed class TypeChecker

                var right = CheckExpression(expression.Right, left.Type);

-                return new BinaryExpressionNode(new NubBoolType(), left, op, right);
+                return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right);
            }
            case BinaryOperatorSyntax.GreaterThan:
            case BinaryOperatorSyntax.GreaterThanOrEqual:
@@ -488,7 +488,7 @@ public sealed class TypeChecker

                var right = CheckExpression(expression.Right, left.Type);

-                return new BinaryExpressionNode(new NubBoolType(), left, op, right);
+                return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right);
            }
            case BinaryOperatorSyntax.LogicalAnd:
            case BinaryOperatorSyntax.LogicalOr:
@@ -505,7 +505,7 @@ public sealed class TypeChecker

                var right = CheckExpression(expression.Right, left.Type);

-                return new BinaryExpressionNode(new NubBoolType(), left, op, right);
+                return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right);
            }
            case BinaryOperatorSyntax.Plus:
            {
@@ -513,7 +513,7 @@ public sealed class TypeChecker
                if (left.Type is NubIntType or NubFloatType or NubStringType or NubCStringType)
                {
                    var right = CheckExpression(expression.Right, left.Type);
-                    return new BinaryExpressionNode(left.Type, left, op, right);
+                    return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right);
                }

                throw new TypeCheckerException(Diagnostic
@@ -537,7 +537,7 @@ public sealed class TypeChecker

                var right = CheckExpression(expression.Right, left.Type);

-                return new BinaryExpressionNode(left.Type, left, op, right);
+                return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right);
            }
            case BinaryOperatorSyntax.LeftShift:
            case BinaryOperatorSyntax.RightShift:
@@ -556,7 +556,7 @@ public sealed class TypeChecker

                var right = CheckExpression(expression.Right, left.Type);

-                return new BinaryExpressionNode(left.Type, left, op, right);
+                return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right);
            }
            default:
            {
@@ -580,7 +580,7 @@ public sealed class TypeChecker
                        .Build());
                }

-                return new UnaryExpressionNode(operand.Type, UnaryOperator.Negate, operand);
+                return new UnaryExpressionNode(expression.Tokens, operand.Type, UnaryOperator.Negate, operand);
            }
            case UnaryOperatorSyntax.Invert:
            {
@@ -593,7 +593,7 @@ public sealed class TypeChecker
                        .Build());
                }

-                return new UnaryExpressionNode(operand.Type, UnaryOperator.Invert, operand);
+                return new UnaryExpressionNode(expression.Tokens, operand.Type, UnaryOperator.Invert, operand);
            }
            default:
            {
@@ -610,7 +610,7 @@ public sealed class TypeChecker
            throw new TypeCheckerException(Diagnostic.Error($"Cannot dereference non-pointer type {target.Type}").At(expression).Build());
        }

-        return new DereferenceNode(pointerType.BaseType, target);
+        return new DereferenceNode(expression.Tokens, pointerType.BaseType, target);
    }

    private FuncCallNode CheckFuncCall(FuncCallSyntax expression)
@@ -647,7 +647,7 @@ public sealed class TypeChecker
            parameters.Add(parameterExpression);
        }

-        return new FuncCallNode(funcType.ReturnType, accessor, parameters);
+        return new FuncCallNode(expression.Tokens, funcType.ReturnType, accessor, parameters);
    }

    private StructFuncCallNode CheckMemberFuncCall(MemberFuncCallSyntax expression)
@@ -691,7 +691,7 @@ public sealed class TypeChecker
                parameters.Add(parameterExpression);
            }

-            return new StructFuncCallNode(function.ReturnType, structType.Module, structType.Name, expression.Name, target, parameters);
+            return new StructFuncCallNode(expression.Tokens, function.ReturnType, structType.Module, structType.Name, expression.Name, target, parameters);
        }

        throw new TypeCheckerException(Diagnostic
@@ -708,8 +708,8 @@ public sealed class TypeChecker
        {
            return scopeIdent.Kind switch
            {
-                VariableKind.LValue => new LValueIdentifierNode(scopeIdent.Type, expression.Name),
-                VariableKind.RValue => new RValueIdentifierNode(scopeIdent.Type, expression.Name),
+                VariableKind.LValue => new LValueIdentifierNode(expression.Tokens, scopeIdent.Type, expression.Name),
+                VariableKind.RValue => new RValueIdentifierNode(expression.Tokens, scopeIdent.Type, expression.Name),
                _ => throw new ArgumentOutOfRangeException()
            };
        }
@@ -722,7 +722,7 @@ public sealed class TypeChecker
        {
            var parameters = function.Signature.Parameters.Select(x => ResolveType(x.Type)).ToList();
            var type = new NubFuncType(parameters, ResolveType(function.Signature.ReturnType));
-            return new FuncIdentifierNode(type, CurrentScope.Module, expression.Name, function.ExternSymbol);
+            return new FuncIdentifierNode(expression.Tokens, type, CurrentScope.Module, expression.Name, function.ExternSymbol);
        }

        throw new TypeCheckerException(Diagnostic.Error($"Symbol {expression.Name} not found").At(expression).Build());
@@ -760,7 +760,7 @@ public sealed class TypeChecker
        {
            var parameters = function.Signature.Parameters.Select(x => ResolveType(x.Type)).ToList();
            var type = new NubFuncType(parameters, ResolveType(function.Signature.ReturnType));
-            return new FuncIdentifierNode(type, expression.Module, expression.Name, function.ExternSymbol);
+            return new FuncIdentifierNode(expression.Tokens, type, expression.Module, expression.Name, function.ExternSymbol);
        }

        throw new TypeCheckerException(Diagnostic
@@ -773,9 +773,9 @@ public sealed class TypeChecker
    {
        return expectedType switch
        {
-            NubCStringType => new CStringLiteralNode(expectedType, expression.Value),
-            NubStringType => new StringLiteralNode(expectedType, expression.Value),
-            _ => new CStringLiteralNode(new NubCStringType(), expression.Value)
+            NubCStringType => new CStringLiteralNode(expression.Tokens, expectedType, expression.Value),
+            NubStringType => new StringLiteralNode(expression.Tokens, expectedType, expression.Value),
+            _ => new CStringLiteralNode(expression.Tokens, new NubCStringType(), expression.Value)
        };
    }

@@ -784,35 +784,35 @@ public sealed class TypeChecker
        if (expectedType is NubIntType intType)
        {
            return intType.Signed
-                ? new IntLiteralNode(intType, Convert.ToInt64(expression.Value, expression.Base))
-                : new UIntLiteralNode(intType, Convert.ToUInt64(expression.Value, expression.Base));
+                ? new IntLiteralNode(expression.Tokens, intType, Convert.ToInt64(expression.Value, expression.Base))
+                : new UIntLiteralNode(expression.Tokens, intType, Convert.ToUInt64(expression.Value, expression.Base));
        }

        if (expectedType is NubFloatType floatType)
        {
            return floatType.Width switch
            {
-                32 => new Float32LiteralNode(floatType, Convert.ToSingle(Convert.ToInt64(expression.Value, expression.Base))),
-                64 => new Float64LiteralNode(floatType, Convert.ToDouble(Convert.ToInt64(expression.Value, expression.Base))),
+                32 => new Float32LiteralNode(expression.Tokens, floatType, Convert.ToSingle(Convert.ToInt64(expression.Value, expression.Base))),
+                64 => new Float64LiteralNode(expression.Tokens, floatType, Convert.ToDouble(Convert.ToInt64(expression.Value, expression.Base))),
                _ => throw new ArgumentOutOfRangeException()
            };
        }

        var type = new NubIntType(true, 64);
-        return new IntLiteralNode(type, Convert.ToInt64(expression.Value, expression.Base));
+        return new IntLiteralNode(expression.Tokens, type, Convert.ToInt64(expression.Value, expression.Base));
    }

    private ExpressionNode CheckFloatLiteral(FloatLiteralSyntax expression, NubType? expectedType)
    {
        var type = expectedType as NubFloatType ?? new NubFloatType(64);
        return type.Width == 32
-            ? new Float32LiteralNode(type, Convert.ToSingle(expression.Value))
-            : new Float64LiteralNode(type, Convert.ToDouble(expression.Value));
+            ? new Float32LiteralNode(expression.Tokens, type, Convert.ToSingle(expression.Value))
+            : new Float64LiteralNode(expression.Tokens, type, Convert.ToDouble(expression.Value));
    }

    private BoolLiteralNode CheckBoolLiteral(BoolLiteralSyntax expression)
    {
-        return new BoolLiteralNode(new NubBoolType(), expression.Value);
+        return new BoolLiteralNode(expression.Tokens, new NubBoolType(), expression.Value);
    }

    private ExpressionNode CheckMemberAccess(MemberAccessSyntax expression)
@@ -831,7 +831,7 @@ public sealed class TypeChecker
                        .Build());
                }

-                return new StructFieldAccessNode(field.Type, target, expression.Member);
+                return new StructFieldAccessNode(expression.Tokens, field.Type, target, expression.Member);
            }
            default:
            {
@@ -902,7 +902,7 @@ public sealed class TypeChecker
                .Build());
        }

-        return new StructInitializerNode(structType, initializers);
+        return new StructInitializerNode(expression.Tokens, structType, initializers);
    }

    private BlockNode CheckBlock(BlockSyntax node)
@@ -937,7 +937,7 @@ public sealed class TypeChecker
                }
            }

-            return new BlockNode(statements);
+            return new BlockNode(node.Tokens, statements);
        }
    }

@@ -947,14 +947,14 @@ public sealed class TypeChecker
        {
            AssignmentSyntax assignmentStmt => CheckAssignment(assignmentStmt),
            BlockSyntax blockStmt => CheckBlock(blockStmt),
-            BreakSyntax => new BreakNode(),
-            ContinueSyntax => new ContinueNode(),
+            BreakSyntax => new BreakNode(statement.Tokens),
+            ContinueSyntax => new ContinueNode(statement.Tokens),
            IfSyntax ifStmt => CheckIf(ifStmt),
            ReturnSyntax retStmt => CheckReturn(retStmt),
            StatementExpressionSyntax stmtExpr => CheckStatementExpression(stmtExpr),
            VariableDeclarationSyntax varDeclStmt => CheckVariableDeclaration(varDeclStmt),
            WhileSyntax whileStmt => CheckWhile(whileStmt),
-            DeferSyntax defer => new DeferNode(CheckStatement(defer.Statement)),
+            DeferSyntax defer => new DeferNode(statement.Tokens, CheckStatement(defer.Statement)),
            _ => throw new ArgumentOutOfRangeException(nameof(statement))
        };
    }
@@ -1142,7 +1142,7 @@ public sealed class TypeChecker
                CurrentScope.DeclareVariable(new Variable("this", structType, VariableKind.RValue));
                var fields = templateDef.Fields.Select(CheckStructField).ToList();
                var functions = templateDef.Functions.Select(CheckStructFunc).ToList();
-                Definitions.Add(new StructNode(structTemplate.Module, mangledName, fields, functions));
+                Definitions.Add(new StructNode(templateDef.Tokens, structTemplate.Module, mangledName, fields, functions));
                _checkedTemplateStructs.Add($"{structTemplate.Module}.{mangledName}");
            }

--- a/compiler/NubLang/Generation/Generator.cs
+++ b/compiler/NubLang/Generation/Generator.cs
@@ -1,4 +1,5 @@
 using NubLang.Ast;
+using NubLang.Syntax;

 namespace NubLang.Generation;

@@ -105,45 +106,45 @@ public class Generator

    public string Emit()
    {
-        var header = """
-                     typedef __builtin_va_list va_list;
+        const string header = """
+                              typedef __builtin_va_list va_list;

-                     #define va_start(ap, last) __builtin_va_start(ap, last)
-                     #define va_arg(ap, type) __builtin_va_arg(ap, type)
-                     #define va_end(ap) __builtin_va_end(ap)
-                     #define va_copy(dest, src) __builtin_va_copy(dest, src)
+                              #define va_start(ap, last) __builtin_va_start(ap, last)
+                              #define va_arg(ap, type) __builtin_va_arg(ap, type)
+                              #define va_end(ap) __builtin_va_end(ap)
+                              #define va_copy(dest, src) __builtin_va_copy(dest, src)

-                     #define NULL ((void*)0)
+                              #define NULL ((void*)0)

-                     typedef unsigned long size_t;
-                     typedef unsigned long uintptr_t;
+                              typedef unsigned long size_t;
+                              typedef unsigned long uintptr_t;

-                     #define offsetof(type, member) __builtin_offsetof(type, member)
+                              #define offsetof(type, member) __builtin_offsetof(type, member)

-                     typedef unsigned char u8;
-                     typedef signed char i8;
-                     typedef unsigned short u16;
-                     typedef signed short i16;
-                     typedef unsigned int u32;
-                     typedef signed int i32;
-                     typedef unsigned long long u64;
-                     typedef signed long long i64;
+                              typedef unsigned char u8;
+                              typedef signed char i8;
+                              typedef unsigned short u16;
+                              typedef signed short i16;
+                              typedef unsigned int u32;
+                              typedef signed int i32;
+                              typedef unsigned long long u64;
+                              typedef signed long long i64;

-                     typedef float f32;
-                     typedef double f64;
+                              typedef float f32;
+                              typedef double f64;

-                     #define I8_C(x) x
-                     #define U8_C(x) x##U
+                              #define I8_C(x) x
+                              #define U8_C(x) x##U

-                     #define I16_C(x) x
-                     #define U16_C(x) x##U
+                              #define I16_C(x) x
+                              #define U16_C(x) x##U

-                     #define I32_C(x) x
-                     #define U32_C(x) x##U
+                              #define I32_C(x) x
+                              #define U32_C(x) x##U

-                     #define I64_C(x) x##LL
-                     #define U64_C(x) x##ULL
-                     """;
+                              #define I64_C(x) x##LL
+                              #define U64_C(x) x##ULL
+                              """;

        foreach (var structType in _structTypes)
        {
@@ -165,6 +166,7 @@ public class Generator

        foreach (var funcNode in _definitions.OfType<FuncNode>())
        {
+            EmitLine(funcNode.Tokens);
            appendNewLine = true;
            var parameters = funcNode.Signature.Parameters.Count != 0
                ? string.Join(", ", funcNode.Signature.Parameters.Select(x => MapNameWithType(x.Type, x.Name)))
@@ -183,6 +185,7 @@ public class Generator
        {
            foreach (var structFuncNode in structNode.Functions)
            {
+                EmitLine(structFuncNode.Tokens);
                var parameters = structFuncNode.Signature.Parameters.Count != 0
                    ? string.Join(", ", structFuncNode.Signature.Parameters.Select(x => MapNameWithType(x.Type, x.Name)))
                    : "void";
@@ -198,6 +201,7 @@ public class Generator
        {
            if (funcNode.Body == null) continue;

+            EmitLine(funcNode.Tokens);
            var parameters = funcNode.Signature.Parameters.Count != 0
                ? string.Join(", ", funcNode.Signature.Parameters.Select(x => MapNameWithType(x.Type, x.Name)))
                : "void";
@@ -232,6 +236,7 @@ public class Generator

    private void EmitStatement(StatementNode statementNode)
    {
+        EmitLine(statementNode.Tokens);
        switch (statementNode)
        {
            case AssignmentNode assignmentNode:
@@ -272,6 +277,16 @@ public class Generator
        }
    }

+    private void EmitLine(List<Token> tokens)
+    {
+        if (tokens.Count >= 1)
+        {
+            var file = tokens[0].Span.FilePath;
+            var line = tokens[0].Span.Start.Line;
+            _writer.WriteLine($"#line {line} \"{file}\"");
+        }
+    }
+
    private void EmitAssignment(AssignmentNode assignmentNode)
    {
        var target = EmitExpression(assignmentNode.Target);
@@ -294,18 +309,14 @@ public class Generator
        _deferStack.Peek().Add(deferNode);
    }

-    private void EmitIf(IfNode ifNode)
+    private void EmitIf(IfNode ifNode, bool elseIf = false)
    {
        var condition = EmitExpression(ifNode.Condition);
-        _writer.WriteLine($"if ({condition})");
+        _writer.WriteLine($"{(elseIf ? "else" : "")} if ({condition})");
        EmitBlock(ifNode.Body);
        ifNode.Else?.Match
        (
-            elseIfNode =>
-            {
-                _writer.Write("else ");
-                EmitIf(elseIfNode);
-            },
+            elseIfNode => EmitIf(elseIfNode, true),
            elseNode =>
            {
                _writer.WriteLine("else");
--- a/examples/raylib/generate.py
+++ b/examples/raylib/generate.py
@@ -1,134 +0,0 @@
-import sys
-import os
-import clang.cindex
-from clang.cindex import CursorKind, TypeKind, Type
-
-
-def map_type(clang_type: Type):
-    canonical = clang_type.get_canonical()
-    kind = canonical.kind
-    spelling = (
-        canonical.spelling.replace("const ", "")
-        .replace("volatile ", "")
-        .replace("restrict ", "")
-    )
-
-    if kind == TypeKind.POINTER:
-        pointee = canonical.get_pointee()
-        if pointee.kind == TypeKind.CHAR_S or pointee.kind == TypeKind.CHAR_U:
-            return "cstring"
-
-        if pointee.kind == TypeKind.FUNCTIONPROTO:
-            arg_types = []
-
-            for arg in pointee.get_canonical().argument_types():
-                arg_types.append(map_type(arg))
-
-            mapped_return = map_type(pointee.get_canonical().get_result())
-            args_str = ", ".join(arg_types)
-
-            return f"func({args_str}): {mapped_return}"
-
-        return f"^{map_type(pointee)}"
-
-    if kind == TypeKind.CONSTANTARRAY:
-        element_type = canonical.get_array_element_type()
-        size = canonical.get_array_size()
-        return f"[{size}]{map_type(element_type)}"
-
-    if kind == TypeKind.FUNCTIONPROTO or kind == TypeKind.FUNCTIONNOPROTO:
-        arg_types = []
-
-        for arg in canonical.argument_types():
-            arg_types.append(map_type(arg))
-
-        mapped_return = map_type(canonical.get_result())
-        args_str = ", ".join(arg_types)
-
-        return f"func({args_str}): {mapped_return}"
-
-    if kind == TypeKind.VOID:
-        return "void"
-
-    if kind == TypeKind.BOOL:
-        return "bool"
-
-    if kind in [TypeKind.CHAR_S, TypeKind.SCHAR]:
-        return "i8"
-    if kind == TypeKind.CHAR_U or kind == TypeKind.UCHAR:
-        return "u8"
-    if kind == TypeKind.SHORT:
-        return "i16"
-    if kind == TypeKind.USHORT:
-        return "u16"
-    if kind == TypeKind.INT:
-        return "i32"
-    if kind == TypeKind.UINT:
-        return "u32"
-    if kind in [TypeKind.LONG, TypeKind.LONGLONG]:
-        return "i64"
-    if kind in [TypeKind.ULONG, TypeKind.ULONGLONG]:
-        return "u64"
-
-    if kind == TypeKind.FLOAT:
-        return "f32"
-    if kind == TypeKind.DOUBLE or kind == TypeKind.LONGDOUBLE:
-        return "f64"
-
-    if kind == TypeKind.RECORD:
-        if not spelling.startswith("struct "):
-            raise Exception(f"Unknown custom type: {spelling}")
-
-        return spelling.replace("struct ", "")
-
-    raise Exception(f"Unresolved type: {spelling}")
-
-
-if len(sys.argv) != 2:
-    print("Usage: python3 generate.py [path to header]", file=sys.stderr)
-    sys.exit(1)
-
-filename = sys.argv[1]
-
-index = clang.cindex.Index.create()
-
-tu = index.parse(filename, ["-x", "c", "-std=c23"])
-
-if tu.diagnostics:
-    for diag in tu.diagnostics:
-        if diag.severity >= clang.cindex.Diagnostic.Error:
-            print(f"Error: {diag.spelling}", file=sys.stderr)
-
-print(f'module "{os.path.basename(filename).split(".")[0]}"')
-print()
-
-for cursor in tu.cursor.walk_preorder():
-    if cursor.location.file and cursor.location.file.name != filename:
-        continue
-
-    if cursor.kind == CursorKind.FUNCTION_DECL:
-        name = cursor.spelling
-        return_type = map_type(cursor.result_type)
-
-        params = []
-        for arg in cursor.get_arguments():
-            param_name = arg.spelling
-            param_type = map_type(arg.type)
-            params.append(f"{param_name}: {param_type}")
-
-        params_str = ", ".join(params)
-
-        print(f'export extern "{name}" func {name}({params_str}): {return_type}')
-
-    elif cursor.kind == CursorKind.STRUCT_DECL:
-        name = cursor.spelling
-        print(f"export struct {name}")
-        print("{")
-        for field in cursor.get_children():
-            if field.kind == CursorKind.FIELD_DECL:
-                field_name = field.spelling
-                field_type = map_type(field.type)
-                print(f"    {field_name}: {field_type}")
-            else:
-                raise Exception(f"Unsupported child of struct: {field.spelling}")
-        print("}")
--- a/examples/raylib/generated/raylib.nub
+++ b/examples/raylib/generated/raylib.nub
--- a/examples/raylib/generated/raymath.nub
+++ b/examples/raylib/generated/raymath.nub
@@ -0,0 +1,235 @@
+module "raymath"
+
+export struct Vector2
+{
+    x: f32
+    y: f32
+}
+export struct Vector2
+{
+    x: f32
+    y: f32
+}
+export struct Vector3
+{
+    x: f32
+    y: f32
+    z: f32
+}
+export struct Vector3
+{
+    x: f32
+    y: f32
+    z: f32
+}
+export struct Vector4
+{
+    x: f32
+    y: f32
+    z: f32
+    w: f32
+}
+export struct Vector4
+{
+    x: f32
+    y: f32
+    z: f32
+    w: f32
+}
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct float3
+{
+    v: [3]f32
+}
+export struct float3
+{
+    v: [3]f32
+}
+export struct float16
+{
+    v: [16]f32
+}
+export struct float16
+{
+    v: [16]f32
+}
+export extern "Clamp" func Clamp(value: f32, min: f32, max: f32): f32
+export extern "Lerp" func Lerp(start: f32, end: f32, amount: f32): f32
+export extern "Normalize" func Normalize(value: f32, start: f32, end: f32): f32
+export extern "Remap" func Remap(value: f32, inputStart: f32, inputEnd: f32, outputStart: f32, outputEnd: f32): f32
+export extern "Wrap" func Wrap(value: f32, min: f32, max: f32): f32
+export extern "FloatEquals" func FloatEquals(x: f32, y: f32): i32
+export extern "Vector2Zero" func Vector2Zero(): Vector2
+export extern "Vector2One" func Vector2One(): Vector2
+export extern "Vector2Add" func Vector2Add(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2AddValue" func Vector2AddValue(v: Vector2, add: f32): Vector2
+export extern "Vector2Subtract" func Vector2Subtract(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2SubtractValue" func Vector2SubtractValue(v: Vector2, sub: f32): Vector2
+export extern "Vector2Length" func Vector2Length(v: Vector2): f32
+export extern "Vector2LengthSqr" func Vector2LengthSqr(v: Vector2): f32
+export extern "Vector2DotProduct" func Vector2DotProduct(v1: Vector2, v2: Vector2): f32
+export extern "Vector2Distance" func Vector2Distance(v1: Vector2, v2: Vector2): f32
+export extern "Vector2DistanceSqr" func Vector2DistanceSqr(v1: Vector2, v2: Vector2): f32
+export extern "Vector2Angle" func Vector2Angle(v1: Vector2, v2: Vector2): f32
+export extern "Vector2LineAngle" func Vector2LineAngle(start: Vector2, end: Vector2): f32
+export extern "Vector2Scale" func Vector2Scale(v: Vector2, scale: f32): Vector2
+export extern "Vector2Multiply" func Vector2Multiply(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Negate" func Vector2Negate(v: Vector2): Vector2
+export extern "Vector2Divide" func Vector2Divide(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Normalize" func Vector2Normalize(v: Vector2): Vector2
+export extern "Vector2Transform" func Vector2Transform(v: Vector2, mat: Matrix): Vector2
+export extern "Vector2Lerp" func Vector2Lerp(v1: Vector2, v2: Vector2, amount: f32): Vector2
+export extern "Vector2Reflect" func Vector2Reflect(v: Vector2, normal: Vector2): Vector2
+export extern "Vector2Min" func Vector2Min(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Max" func Vector2Max(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Rotate" func Vector2Rotate(v: Vector2, angle: f32): Vector2
+export extern "Vector2MoveTowards" func Vector2MoveTowards(v: Vector2, target: Vector2, maxDistance: f32): Vector2
+export extern "Vector2Invert" func Vector2Invert(v: Vector2): Vector2
+export extern "Vector2Clamp" func Vector2Clamp(v: Vector2, min: Vector2, max: Vector2): Vector2
+export extern "Vector2ClampValue" func Vector2ClampValue(v: Vector2, min: f32, max: f32): Vector2
+export extern "Vector2Equals" func Vector2Equals(p: Vector2, q: Vector2): i32
+export extern "Vector2Refract" func Vector2Refract(v: Vector2, n: Vector2, r: f32): Vector2
+export extern "Vector3Zero" func Vector3Zero(): Vector3
+export extern "Vector3One" func Vector3One(): Vector3
+export extern "Vector3Add" func Vector3Add(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3AddValue" func Vector3AddValue(v: Vector3, add: f32): Vector3
+export extern "Vector3Subtract" func Vector3Subtract(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3SubtractValue" func Vector3SubtractValue(v: Vector3, sub: f32): Vector3
+export extern "Vector3Scale" func Vector3Scale(v: Vector3, scalar: f32): Vector3
+export extern "Vector3Multiply" func Vector3Multiply(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3CrossProduct" func Vector3CrossProduct(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Perpendicular" func Vector3Perpendicular(v: Vector3): Vector3
+export extern "Vector3Length" func Vector3Length(v: Vector3): f32
+export extern "Vector3LengthSqr" func Vector3LengthSqr(v: Vector3): f32
+export extern "Vector3DotProduct" func Vector3DotProduct(v1: Vector3, v2: Vector3): f32
+export extern "Vector3Distance" func Vector3Distance(v1: Vector3, v2: Vector3): f32
+export extern "Vector3DistanceSqr" func Vector3DistanceSqr(v1: Vector3, v2: Vector3): f32
+export extern "Vector3Angle" func Vector3Angle(v1: Vector3, v2: Vector3): f32
+export extern "Vector3Negate" func Vector3Negate(v: Vector3): Vector3
+export extern "Vector3Divide" func Vector3Divide(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Normalize" func Vector3Normalize(v: Vector3): Vector3
+export extern "Vector3Project" func Vector3Project(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Reject" func Vector3Reject(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3OrthoNormalize" func Vector3OrthoNormalize(v1: ^Vector3, v2: ^Vector3): void
+export extern "Vector3Transform" func Vector3Transform(v: Vector3, mat: Matrix): Vector3
+export extern "Vector3RotateByQuaternion" func Vector3RotateByQuaternion(v: Vector3, q: Vector4): Vector3
+export extern "Vector3RotateByAxisAngle" func Vector3RotateByAxisAngle(v: Vector3, axis: Vector3, angle: f32): Vector3
+export extern "Vector3MoveTowards" func Vector3MoveTowards(v: Vector3, target: Vector3, maxDistance: f32): Vector3
+export extern "Vector3Lerp" func Vector3Lerp(v1: Vector3, v2: Vector3, amount: f32): Vector3
+export extern "Vector3CubicHermite" func Vector3CubicHermite(v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: f32): Vector3
+export extern "Vector3Reflect" func Vector3Reflect(v: Vector3, normal: Vector3): Vector3
+export extern "Vector3Min" func Vector3Min(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Max" func Vector3Max(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Barycenter" func Vector3Barycenter(p: Vector3, a: Vector3, b: Vector3, c: Vector3): Vector3
+export extern "Vector3Unproject" func Vector3Unproject(source: Vector3, projection: Matrix, view: Matrix): Vector3
+export extern "Vector3ToFloatV" func Vector3ToFloatV(v: Vector3): float3
+export extern "Vector3Invert" func Vector3Invert(v: Vector3): Vector3
+export extern "Vector3Clamp" func Vector3Clamp(v: Vector3, min: Vector3, max: Vector3): Vector3
+export extern "Vector3ClampValue" func Vector3ClampValue(v: Vector3, min: f32, max: f32): Vector3
+export extern "Vector3Equals" func Vector3Equals(p: Vector3, q: Vector3): i32
+export extern "Vector3Refract" func Vector3Refract(v: Vector3, n: Vector3, r: f32): Vector3
+export extern "Vector4Zero" func Vector4Zero(): Vector4
+export extern "Vector4One" func Vector4One(): Vector4
+export extern "Vector4Add" func Vector4Add(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4AddValue" func Vector4AddValue(v: Vector4, add: f32): Vector4
+export extern "Vector4Subtract" func Vector4Subtract(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4SubtractValue" func Vector4SubtractValue(v: Vector4, add: f32): Vector4
+export extern "Vector4Length" func Vector4Length(v: Vector4): f32
+export extern "Vector4LengthSqr" func Vector4LengthSqr(v: Vector4): f32
+export extern "Vector4DotProduct" func Vector4DotProduct(v1: Vector4, v2: Vector4): f32
+export extern "Vector4Distance" func Vector4Distance(v1: Vector4, v2: Vector4): f32
+export extern "Vector4DistanceSqr" func Vector4DistanceSqr(v1: Vector4, v2: Vector4): f32
+export extern "Vector4Scale" func Vector4Scale(v: Vector4, scale: f32): Vector4
+export extern "Vector4Multiply" func Vector4Multiply(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Negate" func Vector4Negate(v: Vector4): Vector4
+export extern "Vector4Divide" func Vector4Divide(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Normalize" func Vector4Normalize(v: Vector4): Vector4
+export extern "Vector4Min" func Vector4Min(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Max" func Vector4Max(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Lerp" func Vector4Lerp(v1: Vector4, v2: Vector4, amount: f32): Vector4
+export extern "Vector4MoveTowards" func Vector4MoveTowards(v: Vector4, target: Vector4, maxDistance: f32): Vector4
+export extern "Vector4Invert" func Vector4Invert(v: Vector4): Vector4
+export extern "Vector4Equals" func Vector4Equals(p: Vector4, q: Vector4): i32
+export extern "MatrixDeterminant" func MatrixDeterminant(mat: Matrix): f32
+export extern "MatrixTrace" func MatrixTrace(mat: Matrix): f32
+export extern "MatrixTranspose" func MatrixTranspose(mat: Matrix): Matrix
+export extern "MatrixInvert" func MatrixInvert(mat: Matrix): Matrix
+export extern "MatrixIdentity" func MatrixIdentity(): Matrix
+export extern "MatrixAdd" func MatrixAdd(left: Matrix, right: Matrix): Matrix
+export extern "MatrixSubtract" func MatrixSubtract(left: Matrix, right: Matrix): Matrix
+export extern "MatrixMultiply" func MatrixMultiply(left: Matrix, right: Matrix): Matrix
+export extern "MatrixTranslate" func MatrixTranslate(x: f32, y: f32, z: f32): Matrix
+export extern "MatrixRotate" func MatrixRotate(axis: Vector3, angle: f32): Matrix
+export extern "MatrixRotateX" func MatrixRotateX(angle: f32): Matrix
+export extern "MatrixRotateY" func MatrixRotateY(angle: f32): Matrix
+export extern "MatrixRotateZ" func MatrixRotateZ(angle: f32): Matrix
+export extern "MatrixRotateXYZ" func MatrixRotateXYZ(angle: Vector3): Matrix
+export extern "MatrixRotateZYX" func MatrixRotateZYX(angle: Vector3): Matrix
+export extern "MatrixScale" func MatrixScale(x: f32, y: f32, z: f32): Matrix
+export extern "MatrixFrustum" func MatrixFrustum(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64): Matrix
+export extern "MatrixPerspective" func MatrixPerspective(fovY: f64, aspect: f64, nearPlane: f64, farPlane: f64): Matrix
+export extern "MatrixOrtho" func MatrixOrtho(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64): Matrix
+export extern "MatrixLookAt" func MatrixLookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix
+export extern "MatrixToFloatV" func MatrixToFloatV(mat: Matrix): float16
+export extern "QuaternionAdd" func QuaternionAdd(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionAddValue" func QuaternionAddValue(q: Vector4, add: f32): Vector4
+export extern "QuaternionSubtract" func QuaternionSubtract(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionSubtractValue" func QuaternionSubtractValue(q: Vector4, sub: f32): Vector4
+export extern "QuaternionIdentity" func QuaternionIdentity(): Vector4
+export extern "QuaternionLength" func QuaternionLength(q: Vector4): f32
+export extern "QuaternionNormalize" func QuaternionNormalize(q: Vector4): Vector4
+export extern "QuaternionInvert" func QuaternionInvert(q: Vector4): Vector4
+export extern "QuaternionMultiply" func QuaternionMultiply(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionScale" func QuaternionScale(q: Vector4, mul: f32): Vector4
+export extern "QuaternionDivide" func QuaternionDivide(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionLerp" func QuaternionLerp(q1: Vector4, q2: Vector4, amount: f32): Vector4
+export extern "QuaternionNlerp" func QuaternionNlerp(q1: Vector4, q2: Vector4, amount: f32): Vector4
+export extern "QuaternionSlerp" func QuaternionSlerp(q1: Vector4, q2: Vector4, amount: f32): Vector4
+export extern "QuaternionCubicHermiteSpline" func QuaternionCubicHermiteSpline(q1: Vector4, outTangent1: Vector4, q2: Vector4, inTangent2: Vector4, t: f32): Vector4
+export extern "QuaternionFromVector3ToVector3" func QuaternionFromVector3ToVector3(from: Vector3, to: Vector3): Vector4
+export extern "QuaternionFromMatrix" func QuaternionFromMatrix(mat: Matrix): Vector4
+export extern "QuaternionToMatrix" func QuaternionToMatrix(q: Vector4): Matrix
+export extern "QuaternionFromAxisAngle" func QuaternionFromAxisAngle(axis: Vector3, angle: f32): Vector4
+export extern "QuaternionToAxisAngle" func QuaternionToAxisAngle(q: Vector4, outAxis: ^Vector3, outAngle: ^f32): void
+export extern "QuaternionFromEuler" func QuaternionFromEuler(pitch: f32, yaw: f32, roll: f32): Vector4
+export extern "QuaternionToEuler" func QuaternionToEuler(q: Vector4): Vector3
+export extern "QuaternionTransform" func QuaternionTransform(q: Vector4, mat: Matrix): Vector4
+export extern "QuaternionEquals" func QuaternionEquals(p: Vector4, q: Vector4): i32
+export extern "MatrixDecompose" func MatrixDecompose(mat: Matrix, translation: ^Vector3, rotation: ^Vector4, scale: ^Vector3): void
--- a/examples/raylib/generated/rlgl.nub
+++ b/examples/raylib/generated/rlgl.nub
@@ -0,0 +1,248 @@
+module "rlgl"
+
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct rlVertexBuffer
+{
+    elementCount: i32
+    vertices: ^f32
+    texcoords: ^f32
+    normals: ^f32
+    colors: ^u8
+    indices: ^u32
+    vaoId: u32
+    vboId: [5]u32
+}
+export struct rlVertexBuffer
+{
+    elementCount: i32
+    vertices: ^f32
+    texcoords: ^f32
+    normals: ^f32
+    colors: ^u8
+    indices: ^u32
+    vaoId: u32
+    vboId: [5]u32
+}
+export struct rlDrawCall
+{
+    mode: i32
+    vertexCount: i32
+    vertexAlignment: i32
+    textureId: u32
+}
+export struct rlDrawCall
+{
+    mode: i32
+    vertexCount: i32
+    vertexAlignment: i32
+    textureId: u32
+}
+export struct rlRenderBatch
+{
+    bufferCount: i32
+    currentBuffer: i32
+    vertexBuffer: ^rlVertexBuffer
+    draws: ^rlDrawCall
+    drawCounter: i32
+    currentDepth: f32
+}
+export struct rlRenderBatch
+{
+    bufferCount: i32
+    currentBuffer: i32
+    vertexBuffer: ^rlVertexBuffer
+    draws: ^rlDrawCall
+    drawCounter: i32
+    currentDepth: f32
+}
+export extern "rlMatrixMode" func rlMatrixMode(mode: i32): void
+export extern "rlPushMatrix" func rlPushMatrix(): void
+export extern "rlPopMatrix" func rlPopMatrix(): void
+export extern "rlLoadIdentity" func rlLoadIdentity(): void
+export extern "rlTranslatef" func rlTranslatef(x: f32, y: f32, z: f32): void
+export extern "rlRotatef" func rlRotatef(angle: f32, x: f32, y: f32, z: f32): void
+export extern "rlScalef" func rlScalef(x: f32, y: f32, z: f32): void
+export extern "rlMultMatrixf" func rlMultMatrixf(matf: ^f32): void
+export extern "rlFrustum" func rlFrustum(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64): void
+export extern "rlOrtho" func rlOrtho(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64): void
+export extern "rlViewport" func rlViewport(x: i32, y: i32, width: i32, height: i32): void
+export extern "rlSetClipPlanes" func rlSetClipPlanes(nearPlane: f64, farPlane: f64): void
+export extern "rlGetCullDistanceNear" func rlGetCullDistanceNear(): f64
+export extern "rlGetCullDistanceFar" func rlGetCullDistanceFar(): f64
+export extern "rlBegin" func rlBegin(mode: i32): void
+export extern "rlEnd" func rlEnd(): void
+export extern "rlVertex2i" func rlVertex2i(x: i32, y: i32): void
+export extern "rlVertex2f" func rlVertex2f(x: f32, y: f32): void
+export extern "rlVertex3f" func rlVertex3f(x: f32, y: f32, z: f32): void
+export extern "rlTexCoord2f" func rlTexCoord2f(x: f32, y: f32): void
+export extern "rlNormal3f" func rlNormal3f(x: f32, y: f32, z: f32): void
+export extern "rlColor4ub" func rlColor4ub(r: u8, g: u8, b: u8, a: u8): void
+export extern "rlColor3f" func rlColor3f(x: f32, y: f32, z: f32): void
+export extern "rlColor4f" func rlColor4f(x: f32, y: f32, z: f32, w: f32): void
+export extern "rlEnableVertexArray" func rlEnableVertexArray(vaoId: u32): bool
+export extern "rlDisableVertexArray" func rlDisableVertexArray(): void
+export extern "rlEnableVertexBuffer" func rlEnableVertexBuffer(id: u32): void
+export extern "rlDisableVertexBuffer" func rlDisableVertexBuffer(): void
+export extern "rlEnableVertexBufferElement" func rlEnableVertexBufferElement(id: u32): void
+export extern "rlDisableVertexBufferElement" func rlDisableVertexBufferElement(): void
+export extern "rlEnableVertexAttribute" func rlEnableVertexAttribute(index: u32): void
+export extern "rlDisableVertexAttribute" func rlDisableVertexAttribute(index: u32): void
+export extern "rlActiveTextureSlot" func rlActiveTextureSlot(slot: i32): void
+export extern "rlEnableTexture" func rlEnableTexture(id: u32): void
+export extern "rlDisableTexture" func rlDisableTexture(): void
+export extern "rlEnableTextureCubemap" func rlEnableTextureCubemap(id: u32): void
+export extern "rlDisableTextureCubemap" func rlDisableTextureCubemap(): void
+export extern "rlTextureParameters" func rlTextureParameters(id: u32, param: i32, value: i32): void
+export extern "rlCubemapParameters" func rlCubemapParameters(id: u32, param: i32, value: i32): void
+export extern "rlEnableShader" func rlEnableShader(id: u32): void
+export extern "rlDisableShader" func rlDisableShader(): void
+export extern "rlEnableFramebuffer" func rlEnableFramebuffer(id: u32): void
+export extern "rlDisableFramebuffer" func rlDisableFramebuffer(): void
+export extern "rlGetActiveFramebuffer" func rlGetActiveFramebuffer(): u32
+export extern "rlActiveDrawBuffers" func rlActiveDrawBuffers(count: i32): void
+export extern "rlBlitFramebuffer" func rlBlitFramebuffer(srcX: i32, srcY: i32, srcWidth: i32, srcHeight: i32, dstX: i32, dstY: i32, dstWidth: i32, dstHeight: i32, bufferMask: i32): void
+export extern "rlBindFramebuffer" func rlBindFramebuffer(target: u32, framebuffer: u32): void
+export extern "rlEnableColorBlend" func rlEnableColorBlend(): void
+export extern "rlDisableColorBlend" func rlDisableColorBlend(): void
+export extern "rlEnableDepthTest" func rlEnableDepthTest(): void
+export extern "rlDisableDepthTest" func rlDisableDepthTest(): void
+export extern "rlEnableDepthMask" func rlEnableDepthMask(): void
+export extern "rlDisableDepthMask" func rlDisableDepthMask(): void
+export extern "rlEnableBackfaceCulling" func rlEnableBackfaceCulling(): void
+export extern "rlDisableBackfaceCulling" func rlDisableBackfaceCulling(): void
+export extern "rlColorMask" func rlColorMask(r: bool, g: bool, b: bool, a: bool): void
+export extern "rlSetCullFace" func rlSetCullFace(mode: i32): void
+export extern "rlEnableScissorTest" func rlEnableScissorTest(): void
+export extern "rlDisableScissorTest" func rlDisableScissorTest(): void
+export extern "rlScissor" func rlScissor(x: i32, y: i32, width: i32, height: i32): void
+export extern "rlEnableWireMode" func rlEnableWireMode(): void
+export extern "rlEnablePointMode" func rlEnablePointMode(): void
+export extern "rlDisableWireMode" func rlDisableWireMode(): void
+export extern "rlSetLineWidth" func rlSetLineWidth(width: f32): void
+export extern "rlGetLineWidth" func rlGetLineWidth(): f32
+export extern "rlEnableSmoothLines" func rlEnableSmoothLines(): void
+export extern "rlDisableSmoothLines" func rlDisableSmoothLines(): void
+export extern "rlEnableStereoRender" func rlEnableStereoRender(): void
+export extern "rlDisableStereoRender" func rlDisableStereoRender(): void
+export extern "rlIsStereoRenderEnabled" func rlIsStereoRenderEnabled(): bool
+export extern "rlClearColor" func rlClearColor(r: u8, g: u8, b: u8, a: u8): void
+export extern "rlClearScreenBuffers" func rlClearScreenBuffers(): void
+export extern "rlCheckErrors" func rlCheckErrors(): void
+export extern "rlSetBlendMode" func rlSetBlendMode(mode: i32): void
+export extern "rlSetBlendFactors" func rlSetBlendFactors(glSrcFactor: i32, glDstFactor: i32, glEquation: i32): void
+export extern "rlSetBlendFactorsSeparate" func rlSetBlendFactorsSeparate(glSrcRGB: i32, glDstRGB: i32, glSrcAlpha: i32, glDstAlpha: i32, glEqRGB: i32, glEqAlpha: i32): void
+export extern "rlglInit" func rlglInit(width: i32, height: i32): void
+export extern "rlglClose" func rlglClose(): void
+export extern "rlLoadExtensions" func rlLoadExtensions(loader: ^void): void
+export extern "rlGetVersion" func rlGetVersion(): i32
+export extern "rlSetFramebufferWidth" func rlSetFramebufferWidth(width: i32): void
+export extern "rlGetFramebufferWidth" func rlGetFramebufferWidth(): i32
+export extern "rlSetFramebufferHeight" func rlSetFramebufferHeight(height: i32): void
+export extern "rlGetFramebufferHeight" func rlGetFramebufferHeight(): i32
+export extern "rlGetTextureIdDefault" func rlGetTextureIdDefault(): u32
+export extern "rlGetShaderIdDefault" func rlGetShaderIdDefault(): u32
+export extern "rlGetShaderLocsDefault" func rlGetShaderLocsDefault(): ^i32
+export extern "rlLoadRenderBatch" func rlLoadRenderBatch(numBuffers: i32, bufferElements: i32): rlRenderBatch
+export extern "rlUnloadRenderBatch" func rlUnloadRenderBatch(batch: rlRenderBatch): void
+export extern "rlDrawRenderBatch" func rlDrawRenderBatch(batch: ^rlRenderBatch): void
+export extern "rlSetRenderBatchActive" func rlSetRenderBatchActive(batch: ^rlRenderBatch): void
+export extern "rlDrawRenderBatchActive" func rlDrawRenderBatchActive(): void
+export extern "rlCheckRenderBatchLimit" func rlCheckRenderBatchLimit(vCount: i32): bool
+export extern "rlSetTexture" func rlSetTexture(id: u32): void
+export extern "rlLoadVertexArray" func rlLoadVertexArray(): u32
+export extern "rlLoadVertexBuffer" func rlLoadVertexBuffer(buffer: ^void, size: i32, dynamic: bool): u32
+export extern "rlLoadVertexBufferElement" func rlLoadVertexBufferElement(buffer: ^void, size: i32, dynamic: bool): u32
+export extern "rlUpdateVertexBuffer" func rlUpdateVertexBuffer(bufferId: u32, data: ^void, dataSize: i32, offset: i32): void
+export extern "rlUpdateVertexBufferElements" func rlUpdateVertexBufferElements(id: u32, data: ^void, dataSize: i32, offset: i32): void
+export extern "rlUnloadVertexArray" func rlUnloadVertexArray(vaoId: u32): void
+export extern "rlUnloadVertexBuffer" func rlUnloadVertexBuffer(vboId: u32): void
+export extern "rlSetVertexAttribute" func rlSetVertexAttribute(index: u32, compSize: i32, type: i32, normalized: bool, stride: i32, offset: i32): void
+export extern "rlSetVertexAttributeDivisor" func rlSetVertexAttributeDivisor(index: u32, divisor: i32): void
+export extern "rlSetVertexAttributeDefault" func rlSetVertexAttributeDefault(locIndex: i32, value: ^void, attribType: i32, count: i32): void
+export extern "rlDrawVertexArray" func rlDrawVertexArray(offset: i32, count: i32): void
+export extern "rlDrawVertexArrayElements" func rlDrawVertexArrayElements(offset: i32, count: i32, buffer: ^void): void
+export extern "rlDrawVertexArrayInstanced" func rlDrawVertexArrayInstanced(offset: i32, count: i32, instances: i32): void
+export extern "rlDrawVertexArrayElementsInstanced" func rlDrawVertexArrayElementsInstanced(offset: i32, count: i32, buffer: ^void, instances: i32): void
+export extern "rlLoadTexture" func rlLoadTexture(data: ^void, width: i32, height: i32, format: i32, mipmapCount: i32): u32
+export extern "rlLoadTextureDepth" func rlLoadTextureDepth(width: i32, height: i32, useRenderBuffer: bool): u32
+export extern "rlLoadTextureCubemap" func rlLoadTextureCubemap(data: ^void, size: i32, format: i32, mipmapCount: i32): u32
+export extern "rlUpdateTexture" func rlUpdateTexture(id: u32, offsetX: i32, offsetY: i32, width: i32, height: i32, format: i32, data: ^void): void
+export extern "rlGetGlTextureFormats" func rlGetGlTextureFormats(format: i32, glInternalFormat: ^u32, glFormat: ^u32, glType: ^u32): void
+export extern "rlGetPixelFormatName" func rlGetPixelFormatName(format: u32): cstring
+export extern "rlUnloadTexture" func rlUnloadTexture(id: u32): void
+export extern "rlGenTextureMipmaps" func rlGenTextureMipmaps(id: u32, width: i32, height: i32, format: i32, mipmaps: ^i32): void
+export extern "rlReadTexturePixels" func rlReadTexturePixels(id: u32, width: i32, height: i32, format: i32): ^void
+export extern "rlReadScreenPixels" func rlReadScreenPixels(width: i32, height: i32): ^u8
+export extern "rlLoadFramebuffer" func rlLoadFramebuffer(): u32
+export extern "rlFramebufferAttach" func rlFramebufferAttach(fboId: u32, texId: u32, attachType: i32, texType: i32, mipLevel: i32): void
+export extern "rlFramebufferComplete" func rlFramebufferComplete(id: u32): bool
+export extern "rlUnloadFramebuffer" func rlUnloadFramebuffer(id: u32): void
+export extern "rlLoadShaderCode" func rlLoadShaderCode(vsCode: cstring, fsCode: cstring): u32
+export extern "rlCompileShader" func rlCompileShader(shaderCode: cstring, type: i32): u32
+export extern "rlLoadShaderProgram" func rlLoadShaderProgram(vShaderId: u32, fShaderId: u32): u32
+export extern "rlUnloadShaderProgram" func rlUnloadShaderProgram(id: u32): void
+export extern "rlGetLocationUniform" func rlGetLocationUniform(shaderId: u32, uniformName: cstring): i32
+export extern "rlGetLocationAttrib" func rlGetLocationAttrib(shaderId: u32, attribName: cstring): i32
+export extern "rlSetUniform" func rlSetUniform(locIndex: i32, value: ^void, uniformType: i32, count: i32): void
+export extern "rlSetUniformMatrix" func rlSetUniformMatrix(locIndex: i32, mat: Matrix): void
+export extern "rlSetUniformMatrices" func rlSetUniformMatrices(locIndex: i32, mat: ^Matrix, count: i32): void
+export extern "rlSetUniformSampler" func rlSetUniformSampler(locIndex: i32, textureId: u32): void
+export extern "rlSetShader" func rlSetShader(id: u32, locs: ^i32): void
+export extern "rlLoadComputeShaderProgram" func rlLoadComputeShaderProgram(shaderId: u32): u32
+export extern "rlComputeShaderDispatch" func rlComputeShaderDispatch(groupX: u32, groupY: u32, groupZ: u32): void
+export extern "rlLoadShaderBuffer" func rlLoadShaderBuffer(size: u32, data: ^void, usageHint: i32): u32
+export extern "rlUnloadShaderBuffer" func rlUnloadShaderBuffer(ssboId: u32): void
+export extern "rlUpdateShaderBuffer" func rlUpdateShaderBuffer(id: u32, data: ^void, dataSize: u32, offset: u32): void
+export extern "rlBindShaderBuffer" func rlBindShaderBuffer(id: u32, index: u32): void
+export extern "rlReadShaderBuffer" func rlReadShaderBuffer(id: u32, dest: ^void, count: u32, offset: u32): void
+export extern "rlCopyShaderBuffer" func rlCopyShaderBuffer(destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32): void
+export extern "rlGetShaderBufferSize" func rlGetShaderBufferSize(id: u32): u32
+export extern "rlBindImageTexture" func rlBindImageTexture(id: u32, index: u32, format: i32, readonly: bool): void
+export extern "rlGetMatrixModelview" func rlGetMatrixModelview(): Matrix
+export extern "rlGetMatrixProjection" func rlGetMatrixProjection(): Matrix
+export extern "rlGetMatrixTransform" func rlGetMatrixTransform(): Matrix
+export extern "rlGetMatrixProjectionStereo" func rlGetMatrixProjectionStereo(eye: i32): Matrix
+export extern "rlGetMatrixViewOffsetStereo" func rlGetMatrixViewOffsetStereo(eye: i32): Matrix
+export extern "rlSetMatrixProjection" func rlSetMatrixProjection(proj: Matrix): void
+export extern "rlSetMatrixModelview" func rlSetMatrixModelview(view: Matrix): void
+export extern "rlSetMatrixProjectionStereo" func rlSetMatrixProjectionStereo(right: Matrix, left: Matrix): void
+export extern "rlSetMatrixViewOffsetStereo" func rlSetMatrixViewOffsetStereo(right: Matrix, left: Matrix): void
+export extern "rlLoadDrawCube" func rlLoadDrawCube(): void
+export extern "rlLoadDrawQuad" func rlLoadDrawQuad(): void
--- a/examples/raylib/makefile
+++ b/examples/raylib/makefile
@@ -3,11 +3,8 @@ NUBC = ../../compiler/NubLang.CLI/bin/Debug/net9.0/nubc
 out: .build/out.o
 	gcc -nostartfiles -lm -o out x86_64.s .build/out.o raylib-5.5_linux_amd64/lib/libraylib.a

-.build/out.o: $(NUBC) main.nub raylib.nub
-	$(NUBC) main.nub raylib.nub
-
-raylib.nub:
-	python3 generate.py raylib-5.5_linux_amd64/include/raylib.h > raylib.nub
+.build/out.o: $(NUBC) main.nub generated/raylib.nub
+	$(NUBC) main.nub generated/raylib.nub

 .PHONY: $(NUBC)
 $(NUBC):