...

bindings/generate.py

@@ -24,9 +24,6 @@ def map_type(clang_type: Type):
             if not decl.is_definition():
                 return "^void"
 
-        if pointee.kind == TypeKind.CHAR_S or pointee.kind == TypeKind.CHAR_U:
-            return "cstring"
-
         if pointee.kind == TypeKind.FUNCTIONPROTO:
             arg_types = []
 

compiler/NubLang.LSP/AstExtensions.cs

@@ -68,368 +68,10 @@ public static class AstExtensions
     public static Node? DeepestNodeAtPosition(this CompilationUnit compilationUnit, int line, int character)
     {
         return compilationUnit.Functions
-            .SelectMany(x => x.EnumerateDescendantsAndSelf())
+            .SelectMany(x => x.DescendantsAndSelf())
             .Where(n => n.ContainsPosition(line, character))
             .OrderBy(n => n.Tokens.First().Span.Start.Line)
             .ThenBy(n => n.Tokens.First().Span.Start.Column)
             .LastOrDefault();
     }
-
-    public static Node? DeepestNodeAtPosition(this Node node, int line, int character)
-    {
-        return node.EnumerateDescendantsAndSelf()
-            .Where(n => n.ContainsPosition(line, character))
-            .OrderBy(n => n.Tokens.First().Span.Start.Line)
-            .ThenBy(n => n.Tokens.First().Span.Start.Column)
-            .LastOrDefault();
-    }
-
-    public static IEnumerable<Node> EnumerateDescendantsAndSelf(this Node node)
-    {
-        yield return node;
-
-        switch (node)
-        {
-            case FuncNode func:
-            {
-                foreach (var n in func.Prototype.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                if (func.Body != null)
-                {
-                    foreach (var n in func.Body.EnumerateDescendantsAndSelf())
-                    {
-                        yield return n;
-                    }
-                }
-
-                break;
-            }
-            case FuncPrototypeNode proto:
-            {
-                foreach (var n in proto.Parameters.SelectMany(param => param.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case BlockNode block:
-            {
-                foreach (var n in block.Statements.SelectMany(stmt => stmt.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case StatementFuncCallNode stmtCall:
-            {
-                foreach (var n in stmtCall.FuncCall.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ReturnNode { Value: not null } ret:
-            {
-                foreach (var n in ret.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case AssignmentNode assign:
-            {
-                foreach (var n in assign.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in assign.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case IfNode ifNode:
-            {
-                foreach (var n in ifNode.Condition.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in ifNode.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                if (ifNode.Else.HasValue)
-                {
-                    if (ifNode.Else.Value.IsCase1(out var elseIfNode))
-                    {
-                        foreach (var n in elseIfNode.EnumerateDescendantsAndSelf())
-                        {
-                            yield return n;
-                        }
-                    }
-                    else if (ifNode.Else.Value.IsCase2(out var elseNode))
-                    {
-                        foreach (var n in elseNode.EnumerateDescendantsAndSelf())
-                        {
-                            yield return n;
-                        }
-                    }
-                }
-
-                break;
-            }
-            case VariableDeclarationNode decl:
-            {
-                if (decl.Assignment != null)
-                {
-                    foreach (var n in decl.Assignment.EnumerateDescendantsAndSelf())
-                    {
-                        yield return n;
-                    }
-                }
-
-                break;
-            }
-            case WhileNode whileNode:
-            {
-                foreach (var n in whileNode.Condition.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in whileNode.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ForSliceNode forSlice:
-            {
-                foreach (var n in forSlice.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in forSlice.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ForConstArrayNode forConst:
-            {
-                foreach (var n in forConst.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in forConst.Body.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case DeferNode defer:
-            {
-                foreach (var n in defer.Statement.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case BinaryExpressionNode bin:
-            {
-                foreach (var n in bin.Left.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in bin.Right.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case UnaryExpressionNode unary:
-            {
-                foreach (var n in unary.Operand.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case FuncCallNode call:
-            {
-                foreach (var n in call.Expression.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in call.Parameters.SelectMany(param => param.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ArrayInitializerNode arrInit:
-            {
-                foreach (var n in arrInit.Values.SelectMany(val => val.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConstArrayInitializerNode constArrInit:
-            {
-                foreach (var n in constArrInit.Values.SelectMany(val => val.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ArrayIndexAccessNode arrIndex:
-            {
-                foreach (var n in arrIndex.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in arrIndex.Index.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConstArrayIndexAccessNode constArrIndex:
-            {
-                foreach (var n in constArrIndex.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in constArrIndex.Index.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case SliceIndexAccessNode sliceIndex:
-            {
-                foreach (var n in sliceIndex.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                foreach (var n in sliceIndex.Index.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case AddressOfNode addr:
-            {
-                foreach (var n in addr.LValue.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case StructFieldAccessNode field:
-            {
-                foreach (var n in field.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case StructInitializerNode structInit:
-            {
-                foreach (var n in structInit.Initializers.SelectMany(kv => kv.Value.EnumerateDescendantsAndSelf()))
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case DereferenceNode deref:
-            {
-                foreach (var n in deref.Target.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConvertIntNode convInt:
-            {
-                foreach (var n in convInt.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConvertFloatNode convFloat:
-            {
-                foreach (var n in convFloat.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConvertCStringToStringNode convStr:
-            {
-                foreach (var n in convStr.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case FloatToIntBuiltinNode ftoi:
-            {
-                foreach (var n in ftoi.Value.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-            case ConstArrayToSliceNode constSlice:
-            {
-                foreach (var n in constSlice.Array.EnumerateDescendantsAndSelf())
-                {
-                    yield return n;
-                }
-
-                break;
-            }
-        }
-    }
 }

compiler/NubLang.LSP/CompletionHandler.cs

@@ -150,9 +150,8 @@ internal class CompletionHandler(WorkspaceManager workspaceManager) : Completion
                     });
                 }
 
-                var variables = function
-                    .Body!
-                    .EnumerateDescendantsAndSelf()
+                var variables = function.Body!
+                    .Descendants()
                     .OfType<VariableDeclarationNode>();
 
                 foreach (var variable in variables)

compiler/NubLang.LSP/DefinitionHandler.cs

@@ -44,7 +44,7 @@ internal class DefinitionHandler(WorkspaceManager workspaceManager) : Definition
                 }
 
                 var variable = function?.Body?
-                    .EnumerateDescendantsAndSelf()
+                    .Descendants()
                     .OfType<VariableDeclarationNode>()
                     .FirstOrDefault(x => x.Name == variableIdentifierNode.Name);
 

compiler/NubLang.LSP/WorkspaceManager.cs

@@ -1,12 +1,10 @@
 using NubLang.Ast;
-using NubLang.Generation;
 using NubLang.Syntax;
 using OmniSharp.Extensions.LanguageServer.Protocol;
-using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 
 namespace NubLang.LSP;
 
-public class WorkspaceManager(DiagnosticsPublisher diagnosticsPublisher, ILanguageServerFacade server)
+public class WorkspaceManager(DiagnosticsPublisher diagnosticsPublisher)
 {
     private readonly Dictionary<string, SyntaxTree> _syntaxTrees = new();
     private readonly Dictionary<string, CompilationUnit> _compilationUnits = new();
@@ -29,47 +27,37 @@ public class WorkspaceManager(DiagnosticsPublisher diagnosticsPublisher, ILangua
             _syntaxTrees[path] = parseResult;
         }
 
-        Generate();
+        foreach (var (fsPath, syntaxTree) in _syntaxTrees)
+        {
+            var modules = Module.Collect(_syntaxTrees.Select(x => x.Value).ToList());
+
+            var typeChecker = new TypeChecker(syntaxTree, modules);
+            var result = typeChecker.Check();
+            diagnosticsPublisher.Publish(fsPath, typeChecker.Diagnostics);
+            _compilationUnits[fsPath] = result;
+        }
     }
 
     public void UpdateFile(DocumentUri path)
     {
         var fsPath = path.GetFileSystemPath();
+
         var text = File.ReadAllText(fsPath);
         var tokenizer = new Tokenizer(fsPath, text);
-
         tokenizer.Tokenize();
         diagnosticsPublisher.Publish(path, tokenizer.Diagnostics);
 
         var parser = new Parser();
-        var parseResult = parser.Parse(tokenizer.Tokens);
+        var syntaxTree = parser.Parse(tokenizer.Tokens);
         diagnosticsPublisher.Publish(path, parser.Diagnostics);
+        _syntaxTrees[fsPath] = syntaxTree;
 
-        _syntaxTrees[fsPath] = parseResult;
-
-        Generate();
-    }
-
-    private void Generate()
-    {
         var modules = Module.Collect(_syntaxTrees.Select(x => x.Value).ToList());
 
-        foreach (var (documentUri, syntaxTree) in _syntaxTrees)
-        {
         var typeChecker = new TypeChecker(syntaxTree, modules);
         var result = typeChecker.Check();
-            diagnosticsPublisher.Publish(documentUri, typeChecker.Diagnostics);
-            _compilationUnits[documentUri] = result;
-
-            var generator = new Generator(result);
-            var c = generator.Emit();
-
-            server.SendNotification("nub/output", new
-            {
-                content = c,
-                uri = documentUri
-            });
-        }
+        diagnosticsPublisher.Publish(fsPath, typeChecker.Diagnostics);
+        _compilationUnits[fsPath] = result;
     }
 
     public void RemoveFile(DocumentUri path)
@@ -79,11 +67,6 @@ public class WorkspaceManager(DiagnosticsPublisher diagnosticsPublisher, ILangua
         _compilationUnits.Remove(fsPath);
     }
 
-    public Dictionary<string, CompilationUnit> GetCompilationUnits()
-    {
-        return _compilationUnits;
-    }
-
     public CompilationUnit? GetCompilationUnit(DocumentUri path)
     {
         return _compilationUnits.GetValueOrDefault(path.GetFileSystemPath());

compiler/NubLang/Ast/Node.cs

@@ -2,49 +2,225 @@ using NubLang.Syntax;
 
 namespace NubLang.Ast;
 
-public abstract record Node(List<Token> Tokens);
+public abstract class Node(List<Token> tokens)
+{
+    public List<Token> Tokens { get; } = tokens;
+
+    public abstract IEnumerable<Node> Children();
+
+    public IEnumerable<Node> Descendants()
+    {
+        foreach (var child in Children())
+        {
+            foreach (var descendant in child.DescendantsAndSelf())
+            {
+                yield return descendant;
+            }
+        }
+    }
+
+    public IEnumerable<Node> DescendantsAndSelf()
+    {
+        yield return this;
+        foreach (var descendant in Descendants())
+        {
+            yield return descendant;
+        }
+    }
+}
 
 #region Definitions
 
-public abstract record DefinitionNode(List<Token> Tokens, string Module, string Name) : Node(Tokens);
+public abstract class DefinitionNode(List<Token> tokens, string module, string name) : Node(tokens)
+{
+    public string Module { get; } = module;
+    public string Name { get; } = name;
+}
 
-public record FuncParameterNode(List<Token> Tokens, string Name, NubType Type) : Node(Tokens);
+public class FuncParameterNode(List<Token> tokens, string name, NubType type) : Node(tokens)
+{
+    public string Name { get; } = name;
+    public NubType Type { get; } = type;
 
-public record FuncPrototypeNode(List<Token> Tokens, string Module, string Name, string? ExternSymbol, List<FuncParameterNode> Parameters, NubType ReturnType) : Node(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record FuncNode(List<Token> Tokens, FuncPrototypeNode Prototype, BlockNode? Body) : DefinitionNode(Tokens, Prototype.Module, Prototype.Name);
+public class FuncPrototypeNode(List<Token> tokens, string module, string name, string? externSymbol, List<FuncParameterNode> parameters, NubType returnType) : Node(tokens)
+{
+    public string Module { get; } = module;
+    public string Name { get; } = name;
+    public string? ExternSymbol { get; } = externSymbol;
+    public List<FuncParameterNode> Parameters { get; } = parameters;
+    public NubType ReturnType { get; } = returnType;
+
+    public override IEnumerable<Node> Children()
+    {
+        return Parameters;
+    }
+}
+
+public class FuncNode(List<Token> tokens, FuncPrototypeNode prototype, BlockNode? body) : DefinitionNode(tokens, prototype.Module, prototype.Name)
+{
+    public FuncPrototypeNode Prototype { get; } = prototype;
+    public BlockNode? Body { get; } = body;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Prototype;
+        if (Body != null)
+        {
+            yield return Body;
+        }
+    }
+}
 
 #endregion
 
 #region Statements
 
-public abstract record StatementNode(List<Token> Tokens) : Node(Tokens);
+public abstract class StatementNode(List<Token> tokens) : Node(tokens);
 
-public abstract record TerminalStatementNode(List<Token> Tokens) : StatementNode(Tokens);
+public abstract class TerminalStatementNode(List<Token> tokens) : StatementNode(tokens);
 
-public record BlockNode(List<Token> Tokens, List<StatementNode> Statements) : StatementNode(Tokens);
+public class BlockNode(List<Token> tokens, List<StatementNode> statements) : StatementNode(tokens)
+{
+    public List<StatementNode> Statements { get; } = statements;
 
-public record StatementFuncCallNode(List<Token> Tokens, FuncCallNode FuncCall) : StatementNode(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        return Statements;
+    }
+}
 
-public record ReturnNode(List<Token> Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens);
+public class StatementFuncCallNode(List<Token> tokens, FuncCallNode funcCall) : StatementNode(tokens)
+{
+    public FuncCallNode FuncCall { get; } = funcCall;
 
-public record AssignmentNode(List<Token> Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        yield return FuncCall;
+    }
+}
 
-public record IfNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode(Tokens);
+public class ReturnNode(List<Token> tokens, ExpressionNode? value) : TerminalStatementNode(tokens)
+{
+    public ExpressionNode? Value { get; } = value;
 
-public record VariableDeclarationNode(List<Token> Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        if (Value != null) yield return Value;
+    }
+}
 
-public record ContinueNode(List<Token> Tokens) : TerminalStatementNode(Tokens);
+public class AssignmentNode(List<Token> tokens, LValueExpressionNode target, ExpressionNode value) : StatementNode(tokens)
+{
+    public LValueExpressionNode Target { get; } = target;
+    public ExpressionNode Value { get; } = value;
 
-public record BreakNode(List<Token> Tokens) : TerminalStatementNode(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Value;
+    }
+}
 
-public record WhileNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);
+public class IfNode(List<Token> tokens, ExpressionNode condition, BlockNode body, Variant<IfNode, BlockNode>? @else) : StatementNode(tokens)
+{
+    public ExpressionNode Condition { get; } = condition;
+    public BlockNode Body { get; } = body;
+    public Variant<IfNode, BlockNode>? Else { get; } = @else;
 
-public record ForSliceNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        yield return Condition;
+        yield return Body;
+        if (Else.HasValue)
+        {
+            yield return Else.Value.Match<Node>(x => x, x => x);
+        }
+    }
+}
 
-public record ForConstArrayNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens);
+public class VariableDeclarationNode(List<Token> tokens, string name, ExpressionNode? assignment, NubType type) : StatementNode(tokens)
+{
+    public string Name { get; } = name;
+    public ExpressionNode? Assignment { get; } = assignment;
+    public NubType Type { get; } = type;
 
-public record DeferNode(List<Token> Tokens, StatementNode Statement) : StatementNode(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        if (Assignment != null) yield return Assignment;
+    }
+}
+
+public class ContinueNode(List<Token> tokens) : TerminalStatementNode(tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
+
+public class BreakNode(List<Token> tokens) : TerminalStatementNode(tokens)
+{
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
+
+public class WhileNode(List<Token> tokens, ExpressionNode condition, BlockNode body) : StatementNode(tokens)
+{
+    public ExpressionNode Condition { get; } = condition;
+    public BlockNode Body { get; } = body;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Condition;
+        yield return Body;
+    }
+}
+
+public class ForSliceNode(List<Token> tokens, string elementName, string? indexName, ExpressionNode target, BlockNode body) : StatementNode(tokens)
+{
+    public string ElementName { get; } = elementName;
+    public string? IndexName { get; } = indexName;
+    public ExpressionNode Target { get; } = target;
+    public BlockNode Body { get; } = body;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Body;
+    }
+}
+
+public class ForConstArrayNode(List<Token> tokens, string elementName, string? indexName, ExpressionNode target, BlockNode body) : StatementNode(tokens)
+{
+    public string ElementName { get; } = elementName;
+    public string? IndexName { get; } = indexName;
+    public ExpressionNode Target { get; } = target;
+    public BlockNode Body { get; } = body;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Body;
+    }
+}
+
+public class DeferNode(List<Token> tokens, StatementNode statement) : StatementNode(tokens)
+{
+    public StatementNode Statement { get; } = statement;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Statement;
+    }
+}
 
 #endregion
 
@@ -78,80 +254,337 @@ public enum BinaryOperator
     BitwiseOr
 }
 
-public abstract record ExpressionNode(List<Token> Tokens, NubType Type) : Node(Tokens);
+public abstract class ExpressionNode(List<Token> tokens, NubType type) : Node(tokens)
+{
+    public NubType Type { get; } = type;
+}
 
-public abstract record LValueExpressionNode(List<Token> Tokens, NubType Type) : ExpressionNode(Tokens, Type);
+public abstract class LValueExpressionNode(List<Token> tokens, NubType type) : ExpressionNode(tokens, type);
 
-public abstract record RValueExpressionNode(List<Token> Tokens, NubType Type) : ExpressionNode(Tokens, Type);
+public abstract class RValueExpressionNode(List<Token> tokens, NubType type) : ExpressionNode(tokens, type);
 
-public abstract record IntermediateExpression(List<Token> Tokens) : ExpressionNode(Tokens, new NubVoidType());
+public abstract class IntermediateExpression(List<Token> tokens) : ExpressionNode(tokens, new NubVoidType());
 
-public record StringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubStringType());
+public class StringLiteralNode(List<Token> tokens, string value) : RValueExpressionNode(tokens, new NubStringType())
+{
+    public string Value { get; } = value;
 
-public record CStringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubCStringType());
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record I8LiteralNode(List<Token> Tokens, sbyte Value) : RValueExpressionNode(Tokens, new NubIntType(true, 8));
+public class CStringLiteralNode(List<Token> tokens, string value) : RValueExpressionNode(tokens, new NubPointerType(new NubIntType(true, 8)))
+{
+    public string Value { get; } = value;
 
-public record I16LiteralNode(List<Token> Tokens, short Value) : RValueExpressionNode(Tokens, new NubIntType(true, 16));
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record I32LiteralNode(List<Token> Tokens, int Value) : RValueExpressionNode(Tokens, new NubIntType(true, 32));
+public class I8LiteralNode(List<Token> tokens, sbyte value) : RValueExpressionNode(tokens, new NubIntType(true, 8))
+{
+    public sbyte Value { get; } = value;
 
-public record I64LiteralNode(List<Token> Tokens, long Value) : RValueExpressionNode(Tokens, new NubIntType(true, 64));
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record U8LiteralNode(List<Token> Tokens, byte Value) : RValueExpressionNode(Tokens, new NubIntType(false, 8));
+public class I16LiteralNode(List<Token> tokens, short value) : RValueExpressionNode(tokens, new NubIntType(true, 16))
+{
+    public short Value { get; } = value;
 
-public record U16LiteralNode(List<Token> Tokens, ushort Value) : RValueExpressionNode(Tokens, new NubIntType(false, 16));
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record U32LiteralNode(List<Token> Tokens, uint Value) : RValueExpressionNode(Tokens, new NubIntType(false, 32));
+public class I32LiteralNode(List<Token> tokens, int value) : RValueExpressionNode(tokens, new NubIntType(true, 32))
+{
+    public int Value { get; } = value;
 
-public record U64LiteralNode(List<Token> Tokens, ulong Value) : RValueExpressionNode(Tokens, new NubIntType(false, 64));
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record Float32LiteralNode(List<Token> Tokens, float Value) : RValueExpressionNode(Tokens, new NubFloatType(32));
+public class I64LiteralNode(List<Token> tokens, long value) : RValueExpressionNode(tokens, new NubIntType(true, 64))
+{
+    public long Value { get; } = value;
 
-public record Float64LiteralNode(List<Token> Tokens, double Value) : RValueExpressionNode(Tokens, new NubFloatType(64));
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record BoolLiteralNode(List<Token> Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type);
+public class U8LiteralNode(List<Token> tokens, byte value) : RValueExpressionNode(tokens, new NubIntType(false, 8))
+{
+    public byte Value { get; } = value;
 
-public record BinaryExpressionNode(List<Token> Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record UnaryExpressionNode(List<Token> Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type);
+public class U16LiteralNode(List<Token> tokens, ushort value) : RValueExpressionNode(tokens, new NubIntType(false, 16))
+{
+    public ushort Value { get; } = value;
 
-public record FuncCallNode(List<Token> Tokens, NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record VariableIdentifierNode(List<Token> Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type);
+public class U32LiteralNode(List<Token> tokens, uint value) : RValueExpressionNode(tokens, new NubIntType(false, 32))
+{
+    public uint Value { get; } = value;
 
-public record FuncIdentifierNode(List<Token> Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record ArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type);
+public class U64LiteralNode(List<Token> tokens, ulong value) : RValueExpressionNode(tokens, new NubIntType(false, 64))
+{
+    public ulong Value { get; } = value;
 
-public record ConstArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record ArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
+public class Float32LiteralNode(List<Token> tokens, float value) : RValueExpressionNode(tokens, new NubFloatType(32))
+{
+    public float Value { get; } = value;
 
-public record ConstArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record SliceIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
+public class Float64LiteralNode(List<Token> tokens, double value) : RValueExpressionNode(tokens, new NubFloatType(64))
+{
+    public double Value { get; } = value;
 
-public record AddressOfNode(List<Token> Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record StructFieldAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type);
+public class BoolLiteralNode(List<Token> tokens, NubType type, bool value) : RValueExpressionNode(tokens, type)
+{
+    public bool Value { get; } = value;
 
-public record StructInitializerNode(List<Token> Tokens, NubType Type, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
-public record DereferenceNode(List<Token> Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type);
+public class BinaryExpressionNode(List<Token> tokens, NubType type, ExpressionNode left, BinaryOperator @operator, ExpressionNode right) : RValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Left { get; } = left;
+    public BinaryOperator Operator { get; } = @operator;
+    public ExpressionNode Right { get; } = right;
 
-public record ConvertIntNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth, bool StartSignedness, bool TargetSignedness) : RValueExpressionNode(Tokens, new NubIntType(TargetSignedness, TargetWidth));
+    public override IEnumerable<Node> Children()
+    {
+        yield return Left;
+        yield return Right;
+    }
+}
 
-public record ConvertFloatNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth) : RValueExpressionNode(Tokens, new NubFloatType(TargetWidth));
+public class UnaryExpressionNode(List<Token> tokens, NubType type, UnaryOperator @operator, ExpressionNode operand) : RValueExpressionNode(tokens, type)
+{
+    public UnaryOperator Operator { get; } = @operator;
+    public ExpressionNode Operand { get; } = operand;
 
-public record ConvertCStringToStringNode(List<Token> Tokens, ExpressionNode Value) : RValueExpressionNode(Tokens, new NubStringType());
+    public override IEnumerable<Node> Children()
+    {
+        yield return Operand;
+    }
+}
 
-public record SizeBuiltinNode(List<Token> Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type);
+public class FuncCallNode(List<Token> tokens, NubType type, ExpressionNode expression, List<ExpressionNode> parameters) : RValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Expression { get; } = expression;
+    public List<ExpressionNode> Parameters { get; } = parameters;
 
-public record FloatToIntBuiltinNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type);
+    public override IEnumerable<Node> Children()
+    {
+        yield return Expression;
+        foreach (var expressionNode in Parameters)
+        {
+            yield return expressionNode;
+        }
+    }
+}
 
-public record ConstArrayToSliceNode(List<Token> Tokens, NubType Type, ExpressionNode Array) : RValueExpressionNode(Tokens, Type);
+public class VariableIdentifierNode(List<Token> tokens, NubType type, string name) : LValueExpressionNode(tokens, type)
+{
+    public string Name { get; } = name;
 
-public record EnumReferenceIntermediateNode(List<Token> Tokens, string Module, string Name) : IntermediateExpression(Tokens);
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
+
+public class FuncIdentifierNode(List<Token> tokens, NubType type, string module, string name, string? externSymbol) : RValueExpressionNode(tokens, type)
+{
+    public string Module { get; } = module;
+    public string Name { get; } = name;
+    public string? ExternSymbol { get; } = externSymbol;
+
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
+
+public class ArrayInitializerNode(List<Token> tokens, NubType type, List<ExpressionNode> values) : RValueExpressionNode(tokens, type)
+{
+    public List<ExpressionNode> Values { get; } = values;
+
+    public override IEnumerable<Node> Children()
+    {
+        return Values;
+    }
+}
+
+public class ConstArrayInitializerNode(List<Token> tokens, NubType type, List<ExpressionNode> values) : RValueExpressionNode(tokens, type)
+{
+    public List<ExpressionNode> Values { get; } = values;
+
+    public override IEnumerable<Node> Children()
+    {
+        return Values;
+    }
+}
+
+public class ArrayIndexAccessNode(List<Token> tokens, NubType type, ExpressionNode target, ExpressionNode index) : LValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Target { get; } = target;
+    public ExpressionNode Index { get; } = index;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Index;
+    }
+}
+
+public class ConstArrayIndexAccessNode(List<Token> tokens, NubType type, ExpressionNode target, ExpressionNode index) : LValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Target { get; } = target;
+    public ExpressionNode Index { get; } = index;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Index;
+    }
+}
+
+public class SliceIndexAccessNode(List<Token> tokens, NubType type, ExpressionNode target, ExpressionNode index) : LValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Target { get; } = target;
+    public ExpressionNode Index { get; } = index;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+        yield return Index;
+    }
+}
+
+public class AddressOfNode(List<Token> tokens, NubType type, LValueExpressionNode lValue) : RValueExpressionNode(tokens, type)
+{
+    public LValueExpressionNode LValue { get; } = lValue;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return LValue;
+    }
+}
+
+public class StructFieldAccessNode(List<Token> tokens, NubType type, ExpressionNode target, string field) : LValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Target { get; } = target;
+    public string Field { get; } = field;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+    }
+}
+
+public class StructInitializerNode(List<Token> tokens, NubType type, Dictionary<string, ExpressionNode> initializers) : RValueExpressionNode(tokens, type)
+{
+    public Dictionary<string, ExpressionNode> Initializers { get; } = initializers;
+
+    public override IEnumerable<Node> Children()
+    {
+        foreach (var initializer in Initializers)
+        {
+            yield return initializer.Value;
+        }
+    }
+}
+
+public class DereferenceNode(List<Token> tokens, NubType type, ExpressionNode target) : LValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Target { get; } = target;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Target;
+    }
+}
+
+public class SizeNode(List<Token> tokens, NubType TargetType) : RValueExpressionNode(tokens, new NubIntType(false, 64))
+{
+    public NubType TargetType { get; } = TargetType;
+
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
+
+public class CastNode(List<Token> tokens, NubType type, ExpressionNode value) : RValueExpressionNode(tokens, type)
+{
+    public ExpressionNode Value { get; } = value;
+
+    public override IEnumerable<Node> Children()
+    {
+        yield return Value;
+    }
+}
+
+public class EnumReferenceIntermediateNode(List<Token> tokens, string module, string name) : IntermediateExpression(tokens)
+{
+    public string Module { get; } = module;
+    public string Name { get; } = name;
+
+    public override IEnumerable<Node> Children()
+    {
+        return [];
+    }
+}
 
 #endregion

compiler/NubLang/Ast/NubType.cs

@@ -125,13 +125,6 @@ public class NubArrayType(NubType elementType) : NubType
     public override int GetHashCode() => HashCode.Combine(typeof(NubArrayType), ElementType);
 }
 
-public class NubCStringType : NubType
-{
-    public override string ToString() => "cstring";
-    public override bool Equals(NubType? other) => other is NubCStringType;
-    public override int GetHashCode() => HashCode.Combine(typeof(NubCStringType));
-}
-
 public class NubStringType : NubType
 {
     public override string ToString() => "string";
@@ -143,7 +136,7 @@ public static class NameMangler
 {
     public static string Mangle(params IEnumerable<NubType> types)
     {
-        var readable = string.Join("_", types.Select(EncodeType));
+        var readable = string.Join(":", types.Select(EncodeType));
         return ComputeShortHash(readable);
     }
 
@@ -153,12 +146,13 @@ public static class NameMangler
         NubBoolType => "B",
         NubIntType i => (i.Signed ? "I" : "U") + i.Width,
         NubFloatType f => "F" + f.Width,
-        NubCStringType => "CS",
         NubStringType => "S",
-        NubPointerType p => "P" + EncodeType(p.BaseType),
-        NubSliceType a => "A" + EncodeType(a.ElementType),
-        NubFuncType fn => "FN(" + string.Join(",", fn.Parameters.Select(EncodeType)) + ")" + EncodeType(fn.ReturnType),
-        NubStructType st => "ST(" + st.Module + "." + st.Name + ")",
+        NubArrayType a => $"A({EncodeType(a.ElementType)})",
+        NubConstArrayType ca => $"CA({EncodeType(ca.ElementType)})",
+        NubSliceType a => $"SL{EncodeType(a.ElementType)}()",
+        NubPointerType p => $"P({EncodeType(p.BaseType)})",
+        NubFuncType fn => $"FN({string.Join(":", fn.Parameters.Select(EncodeType))}:{EncodeType(fn.ReturnType)})",
+        NubStructType st => $"ST({st.Module}:{st.Name})",
         _ => throw new NotSupportedException($"Cannot encode type: {node}")
     };
 

compiler/NubLang/Ast/TypeChecker.cs

@@ -309,69 +309,94 @@ public sealed class TypeChecker
             FloatLiteralSyntax expression => CheckFloatLiteral(expression, expectedType),
             MemberAccessSyntax expression => CheckMemberAccess(expression, expectedType),
             StructInitializerSyntax expression => CheckStructInitializer(expression, expectedType),
-            InterpretBuiltinSyntax expression => CheckExpression(expression.Target, expectedType) with { Type = ResolveType(expression.Type) },
-            SizeBuiltinSyntax expression => new SizeBuiltinNode(node.Tokens, new NubIntType(false, 64), ResolveType(expression.Type)),
-            FloatToIntBuiltinSyntax expression => CheckFloatToInt(expression, expectedType),
+            SizeSyntax expression => new SizeNode(node.Tokens, ResolveType(expression.Type)),
+            CastSyntax expression => CheckCast(expression, expectedType),
             _ => throw new ArgumentOutOfRangeException(nameof(node))
         };
 
-        switch (expectedType)
+        if (expectedType != null)
         {
-            // note(nub31): Implicit conversion of const array to unsized array
-            case NubArrayType when result.Type is NubConstArrayType constArrayType:
-            {
-                return result with { Type = new NubArrayType(constArrayType.ElementType) };
-            }
-            // note(nub31): Implicit conversion of const array to slice
-            case NubSliceType when result.Type is NubConstArrayType constArrayType:
-            {
-                return new ConstArrayToSliceNode(result.Tokens, new NubSliceType(constArrayType.ElementType), result);
-            }
-            // note(nub31): Implicit conversion of int to larger int
-            case NubIntType expectedIntType when result.Type is NubIntType intType && expectedIntType.Width > intType.Width:
-            {
-                return new ConvertIntNode(result.Tokens, result, intType.Width, expectedIntType.Width, intType.Signed, expectedIntType.Signed);
-            }
-            // note(nub31): Implicit conversion of f32 to f64
-            case NubFloatType expectedFloatType when result.Type is NubFloatType floatType && expectedFloatType.Width > floatType.Width:
-            {
-                return new ConvertFloatNode(result.Tokens, result, floatType.Width, expectedFloatType.Width);
-            }
-            // note(nub31): Implicit conversion of cstring to string
-            case NubStringType when result.Type is NubCStringType:
-            {
-                return new ConvertCStringToStringNode(result.Tokens, result);
-            }
-            // note(nub31): No implicit conversion was possible or the result value was already the correct type
-            default:
+            if (result.Type == expectedType)
             {
                 return result;
             }
+
+            if (IsCastAllowed(result.Type, expectedType))
+            {
+                return new CastNode(result.Tokens, expectedType, result);
             }
         }
 
-    // todo(nub31): Infer int type instead of explicit type syntax
-    private FloatToIntBuiltinNode CheckFloatToInt(FloatToIntBuiltinSyntax expression, NubType? _)
+        return result;
+    }
+
+    private ExpressionNode CheckCast(CastSyntax expression, NubType? expectedType)
     {
-        var value = CheckExpression(expression.Value);
-        if (value.Type is not NubFloatType sourceFloatType)
+        if (expectedType == null)
         {
             throw new TypeCheckerException(Diagnostic
-                .Error("Source type of float to int conversion must be an float")
-                .At(expression.Value)
+                .Error("Unable to infer target type of cast")
+                .At(expression)
+                .WithHelp("Specify target type where value is used")
                 .Build());
         }
 
-        var targetType = ResolveType(expression.Type);
-        if (targetType is not NubIntType targetIntType)
+        var value = CheckExpression(expression.Value, expectedType);
+
+        if (value.Type == expectedType)
+        {
+            Diagnostics.Add(Diagnostic
+                .Warning("Target type of cast is same as the value. Cast is unnecessary")
+                .At(expression)
+                .Build());
+
+            return value;
+        }
+
+        if (!IsCastAllowed(value.Type, expectedType, false))
         {
             throw new TypeCheckerException(Diagnostic
-                .Error("Target type of float to int conversion must be an integer")
-                .At(expression.Type)
+                .Error($"Cannot cast from {value.Type} to {expectedType}")
                 .Build());
         }
 
-        return new FloatToIntBuiltinNode(expression.Tokens, targetIntType, value, sourceFloatType, targetIntType);
+        return new CastNode(expression.Tokens, expectedType, value);
+    }
+
+    private static bool IsCastAllowed(NubType from, NubType to, bool strict = true)
+    {
+        // note(nub31): Implicit casts
+        switch (from)
+        {
+            case NubIntType fromInt when to is NubIntType toInt && fromInt.Width < toInt.Width:
+            case NubPointerType when to is NubPointerType { BaseType: NubVoidType }:
+            case NubConstArrayType constArrayType1 when to is NubArrayType arrayType && constArrayType1.ElementType == arrayType.ElementType:
+            case NubConstArrayType constArrayType3 when to is NubSliceType sliceType2 && constArrayType3.ElementType == sliceType2.ElementType:
+            {
+                return true;
+            }
+        }
+
+        if (!strict)
+        {
+            // note(nub31): Explicit casts
+            switch (from)
+            {
+                case NubIntType when to is NubIntType:
+                case NubIntType when to is NubFloatType:
+                case NubFloatType when to is NubIntType:
+                case NubFloatType when to is NubFloatType:
+                case NubPointerType when to is NubPointerType:
+                case NubPointerType when to is NubIntType:
+                case NubIntType when to is NubPointerType:
+                {
+                    return true;
+                }
+            }
+        }
+
+
+        return false;
     }
 
     private AddressOfNode CheckAddressOf(AddressOfSyntax expression, NubType? expectedType)
@@ -499,6 +524,13 @@ public sealed class TypeChecker
                 }
 
                 var right = CheckExpression(expression.Right, left.Type);
+                if (right.Type != left.Type)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Expected type {left.Type} from left side of binary expression, but got {right.Type}")
+                        .At(expression.Right)
+                        .Build());
+                }
 
                 return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right);
             }
@@ -517,6 +549,13 @@ public sealed class TypeChecker
                 }
 
                 var right = CheckExpression(expression.Right, left.Type);
+                if (right.Type != left.Type)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Expected type {left.Type} from left side of binary expression, but got {right.Type}")
+                        .At(expression.Right)
+                        .Build());
+                }
 
                 return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right);
             }
@@ -533,21 +572,36 @@ public sealed class TypeChecker
                 }
 
                 var right = CheckExpression(expression.Right, left.Type);
+                if (right.Type != left.Type)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Expected type {left.Type} from left side of binary expression, but got {right.Type}")
+                        .At(expression.Right)
+                        .Build());
+                }
 
                 return new BinaryExpressionNode(expression.Tokens, new NubBoolType(), left, op, right);
             }
             case BinaryOperatorSyntax.Plus:
             {
                 var left = CheckExpression(expression.Left, expectedType);
-                if (left.Type is not NubIntType and not NubFloatType and not NubStringType and not NubCStringType)
+                if (left.Type is not NubIntType and not NubFloatType)
                 {
                     throw new TypeCheckerException(Diagnostic
-                        .Error("The plus operator must be used with int, float, cstring or string types")
+                        .Error("The plus operator must only be used with int and float types")
                         .At(expression.Left)
                         .Build());
                 }
 
                 var right = CheckExpression(expression.Right, left.Type);
+                if (right.Type != left.Type)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Expected type {left.Type} from left side of binary expression, but got {right.Type}")
+                        .At(expression.Right)
+                        .Build());
+                }
+
                 return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right);
             }
             case BinaryOperatorSyntax.Minus:
@@ -565,6 +619,13 @@ public sealed class TypeChecker
                 }
 
                 var right = CheckExpression(expression.Right, left.Type);
+                if (right.Type != left.Type)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Expected type {left.Type} from left side of binary expression, but got {right.Type}")
+                        .At(expression.Right)
+                        .Build());
+                }
 
                 return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right);
             }
@@ -584,6 +645,13 @@ public sealed class TypeChecker
                 }
 
                 var right = CheckExpression(expression.Right, left.Type);
+                if (right.Type != left.Type)
+                {
+                    throw new TypeCheckerException(Diagnostic
+                        .Error($"Expected type {left.Type} from left side of binary expression, but got {right.Type}")
+                        .At(expression.Right)
+                        .Build());
+                }
 
                 return new BinaryExpressionNode(expression.Tokens, left.Type, left, op, right);
             }
@@ -748,7 +816,7 @@ public sealed class TypeChecker
 
     private ExpressionNode CheckStringLiteral(StringLiteralSyntax expression, NubType? expectedType)
     {
-        if (expectedType is NubCStringType)
+        if (expectedType is NubPointerType { BaseType: NubIntType { Signed: true, Width: 8 } })
         {
             return new CStringLiteralNode(expression.Tokens, expression.Value);
         }
@@ -960,35 +1028,12 @@ public sealed class TypeChecker
         };
     }
 
-    private bool AlwaysReturns(StatementNode statement)
-    {
-        switch (statement)
-        {
-            case ReturnNode:
-                return true;
-            case BlockNode block:
-                return block.Statements.Count != 0 && AlwaysReturns(block.Statements.Last());
-            case IfNode ifNode:
-            {
-                if (!AlwaysReturns(ifNode.Body))
-                {
-                    return false;
-                }
-
-                return !ifNode.Else.HasValue || ifNode.Else.Value.Match(AlwaysReturns, AlwaysReturns);
-            }
-            default:
-                return false;
-        }
-    }
-
     private NubType ResolveType(TypeSyntax type)
     {
         return type switch
         {
             ArrayTypeSyntax arr => new NubArrayType(ResolveType(arr.BaseType)),
             BoolTypeSyntax => new NubBoolType(),
-            CStringTypeSyntax => new NubCStringType(),
             IntTypeSyntax i => new NubIntType(i.Signed, i.Width),
             FloatTypeSyntax f => new NubFloatType(f.Width),
             FuncTypeSyntax func => new NubFuncType(func.Parameters.Select(ResolveType).ToList(), ResolveType(func.ReturnType)),

compiler/NubLang/Generation/CType.cs

@@ -12,14 +12,13 @@ public static class CType
             NubBoolType => "bool" + (variableName != null ? $" {variableName}" : ""),
             NubIntType intType => CreateIntType(intType, variableName),
             NubFloatType floatType => CreateFloatType(floatType, variableName),
-            NubCStringType => "char*" + (variableName != null ? $" {variableName}" : ""),
             NubPointerType ptr => CreatePointerType(ptr, variableName),
-            NubSliceType => "slice" + (variableName != null ? $" {variableName}" : ""),
-            NubStringType => "string" + (variableName != null ? $" {variableName}" : ""),
+            NubSliceType => "struct nub_slice" + (variableName != null ? $" {variableName}" : ""),
+            NubStringType => "struct nub_string" + (variableName != null ? $" {variableName}" : ""),
             NubConstArrayType arr => CreateConstArrayType(arr, variableName, constArraysAsPointers),
             NubArrayType arr => CreateArrayType(arr, variableName),
             NubFuncType fn => CreateFuncType(fn, variableName),
-            NubStructType st => $"{st.Module}_{st.Name}" + (variableName != null ? $" {variableName}" : ""),
+            NubStructType st => $"struct {st.Module}_{st.Name}_{NameMangler.Mangle(st)}" + (variableName != null ? $" {variableName}" : ""),
             _ => throw new NotSupportedException($"C type generation not supported for: {type}")
         };
     }
@@ -28,10 +27,10 @@ public static class CType
     {
         var cType = intType.Width switch
         {
-            8 => intType.Signed ? "int8_t" : "uint8_t",
-            16 => intType.Signed ? "int16_t" : "uint16_t",
-            32 => intType.Signed ? "int32_t" : "uint32_t",
-            64 => intType.Signed ? "int64_t" : "uint64_t",
+            8 => intType.Signed ? "char" : "unsigned char",
+            16 => intType.Signed ? "short" : "unsigned short",
+            32 => intType.Signed ? "int" : "unsigned int",
+            64 => intType.Signed ? "long long" : "unsigned long long",
             _ => throw new NotSupportedException($"Unsupported integer width: {intType.Width}")
         };
         return cType + (varName != null ? $" {varName}" : "");

compiler/NubLang/Generation/Generator.cs

@@ -29,34 +29,26 @@ public class Generator
         return externSymbol ?? $"{module}_{name}";
     }
 
-    private static string StructName(string module, string name)
-    {
-        return $"{module}_{name}";
-    }
-
     public string Emit()
     {
         _writer.WriteLine("""
-                          #include <stdint.h>
-                          #include <stddef.h>
-
-                          typedef struct
+                          struct nub_string
                           {
-                              size_t length;
+                              unsigned long long length;
                               char *data;
-                          } string;
+                          };
 
-                          typedef struct
+                          struct nub_slice
                           {
-                              size_t length;
+                              unsigned long long length;
                               void *data;
-                          } slice;
+                          };
 
                           """);
 
         foreach (var structType in _compilationUnit.ImportedStructTypes)
         {
-            _writer.WriteLine("typedef struct");
+            _writer.WriteLine(CType.Create(structType));
             _writer.WriteLine("{");
             using (_writer.Indent())
             {
@@ -66,7 +58,7 @@ public class Generator
                 }
             }
 
-            _writer.WriteLine($"}} {StructName(structType.Module, structType.Name)};");
+            _writer.WriteLine("};");
             _writer.WriteLine();
         }
 
@@ -198,7 +190,7 @@ public class Generator
         var target = EmitExpression(forSliceNode.Target);
         var indexName = forSliceNode.IndexName ?? NewTmp();
 
-        _writer.WriteLine($"for (size_t {indexName} = 0; {indexName} < {target}.length; ++{indexName})");
+        _writer.WriteLine($"for (unsigned long long {indexName} = 0; {indexName} < {target}.length; ++{indexName})");
         _writer.WriteLine("{");
         using (_writer.Indent())
         {
@@ -215,7 +207,7 @@ public class Generator
         var target = EmitExpression(forConstArrayNode.Target);
         var indexName = forConstArrayNode.IndexName ?? NewTmp();
 
-        _writer.WriteLine($"for (size_t {indexName} = 0; {indexName} < {targetType.Size}; ++{indexName})");
+        _writer.WriteLine($"for (unsigned long long {indexName} = 0; {indexName} < {targetType.Size}; ++{indexName})");
         _writer.WriteLine("{");
         using (_writer.Indent())
         {
@@ -339,19 +331,15 @@ public class Generator
             BoolLiteralNode boolLiteralNode => boolLiteralNode.Value ? "true" : "false",
             ConstArrayIndexAccessNode constArrayIndexAccessNode => EmitConstArrayIndexAccess(constArrayIndexAccessNode),
             ConstArrayInitializerNode constArrayInitializerNode => EmitConstArrayInitializer(constArrayInitializerNode),
-            ConstArrayToSliceNode constArrayToSliceNode => EmitConstArrayToSlice(constArrayToSliceNode),
-            ConvertCStringToStringNode convertCStringToStringNode => EmitConvertCStringToString(convertCStringToStringNode),
-            ConvertFloatNode convertFloatNode => EmitConvertFloat(convertFloatNode),
-            ConvertIntNode convertIntNode => EmitConvertInt(convertIntNode),
             CStringLiteralNode cStringLiteralNode => $"\"{cStringLiteralNode.Value}\"",
             DereferenceNode dereferenceNode => EmitDereference(dereferenceNode),
             Float32LiteralNode float32LiteralNode => EmitFloat32Literal(float32LiteralNode),
             Float64LiteralNode float64LiteralNode => EmitFloat64Literal(float64LiteralNode),
-            FloatToIntBuiltinNode floatToIntBuiltinNode => EmitFloatToIntBuiltin(floatToIntBuiltinNode),
+            CastNode castNode => EmitCast(castNode),
             FuncCallNode funcCallNode => EmitFuncCall(funcCallNode),
             FuncIdentifierNode funcIdentifierNode => FuncName(funcIdentifierNode.Module, funcIdentifierNode.Name, funcIdentifierNode.ExternSymbol),
             AddressOfNode addressOfNode => EmitAddressOf(addressOfNode),
-            SizeBuiltinNode sizeBuiltinNode => $"sizeof({CType.Create(sizeBuiltinNode.TargetType)})",
+            SizeNode sizeBuiltinNode => $"sizeof({CType.Create(sizeBuiltinNode.TargetType)})",
             SliceIndexAccessNode sliceIndexAccessNode => EmitSliceArrayIndexAccess(sliceIndexAccessNode),
             StringLiteralNode stringLiteralNode => EmitStringLiteral(stringLiteralNode),
             StructFieldAccessNode structFieldAccessNode => EmitStructFieldAccess(structFieldAccessNode),
@@ -442,46 +430,6 @@ public class Generator
         return $"({CType.Create(arrayType.ElementType)}[{arrayType.Size}]){{{string.Join(", ", values)}}}";
     }
 
-    private string EmitConstArrayToSlice(ConstArrayToSliceNode constArrayToSliceNode)
-    {
-        var arrayType = (NubConstArrayType)constArrayToSliceNode.Array.Type;
-        var array = EmitExpression(constArrayToSliceNode.Array);
-        return $"(slice){{.length = {arrayType.Size}, .data = (void*){array}}}";
-    }
-
-    private string EmitConvertCStringToString(ConvertCStringToStringNode convertCStringToStringNode)
-    {
-        var value = EmitExpression(convertCStringToStringNode.Value);
-        return $"(string){{.length = strlen({value}), .data = {value}}}";
-    }
-
-    private string EmitConvertFloat(ConvertFloatNode convertFloatNode)
-    {
-        var value = EmitExpression(convertFloatNode.Value);
-        var targetCast = convertFloatNode.TargetWidth switch
-        {
-            32 => "f32",
-            64 => "f64",
-            _ => throw new ArgumentOutOfRangeException()
-        };
-
-        return $"({targetCast}){value}";
-    }
-
-    private string EmitConvertInt(ConvertIntNode convertIntNode)
-    {
-        var value = EmitExpression(convertIntNode.Value);
-        var targetType = convertIntNode.TargetWidth switch
-        {
-            8 => convertIntNode.TargetSignedness ? "int8_t" : "uint8_t",
-            16 => convertIntNode.TargetSignedness ? "int16_t" : "uint16_t",
-            32 => convertIntNode.TargetSignedness ? "int32_t" : "uint32_t",
-            64 => convertIntNode.TargetSignedness ? "int64_t" : "uint64_t",
-            _ => throw new ArgumentOutOfRangeException()
-        };
-        return $"({targetType}){value}";
-    }
-
     private string EmitDereference(DereferenceNode dereferenceNode)
     {
         var pointer = EmitExpression(dereferenceNode.Target);
@@ -510,18 +458,16 @@ public class Generator
         return str;
     }
 
-    private string EmitFloatToIntBuiltin(FloatToIntBuiltinNode floatToIntBuiltinNode)
+    private string EmitCast(CastNode castNode)
     {
-        var value = EmitExpression(floatToIntBuiltinNode.Value);
-        var targetType = floatToIntBuiltinNode.TargetType.Width switch
+        var value = EmitExpression(castNode.Value);
+
+        if (castNode is { Type: NubSliceType sliceType, Value.Type: NubConstArrayType arrayType })
         {
-            8 => floatToIntBuiltinNode.TargetType.Signed ? "int8_t" : "uint8_t",
-            16 => floatToIntBuiltinNode.TargetType.Signed ? "int16_t" : "uint16_t",
-            32 => floatToIntBuiltinNode.TargetType.Signed ? "int32_t" : "uint32_t",
-            64 => floatToIntBuiltinNode.TargetType.Signed ? "int64_t" : "uint64_t",
-            _ => throw new ArgumentOutOfRangeException()
-        };
-        return $"({targetType}){value}";
+            return $"({CType.Create(sliceType)}){{.length = {arrayType.Size}, .data = (void*){value}}}";
+        }
+
+        return $"({CType.Create(castNode.Type)}){value}";
     }
 
     private string EmitFuncCall(FuncCallNode funcCallNode)
@@ -549,7 +495,7 @@ public class Generator
     private string EmitStringLiteral(StringLiteralNode stringLiteralNode)
     {
         var length = Encoding.UTF8.GetByteCount(stringLiteralNode.Value);
-        return $"(string){{.length = {length}, .data = \"{stringLiteralNode.Value}\"}}";
+        return $"(nub_string){{.length = {length}, .data = \"{stringLiteralNode.Value}\"}}";
     }
 
     private string EmitStructFieldAccess(StructFieldAccessNode structFieldAccessNode)

compiler/NubLang/Syntax/Parser.cs

@@ -508,23 +508,13 @@ public sealed class Parser
             {
                 var type = ParseType();
                 ExpectSymbol(Symbol.CloseParen);
-                return new SizeBuiltinSyntax(GetTokens(startIndex), type);
+                return new SizeSyntax(GetTokens(startIndex), type);
             }
-            case "interpret":
+            case "cast":
             {
-                var type = ParseType();
-                ExpectSymbol(Symbol.Comma);
                 var expression = ParseExpression();
                 ExpectSymbol(Symbol.CloseParen);
-                return new InterpretBuiltinSyntax(GetTokens(startIndex), type, expression);
-            }
-            case "floatToInt":
-            {
-                var type = ParseType();
-                ExpectSymbol(Symbol.Comma);
-                var expression = ParseExpression();
-                ExpectSymbol(Symbol.CloseParen);
-                return new FloatToIntBuiltinSyntax(GetTokens(startIndex), type, expression);
+                return new CastSyntax(GetTokens(startIndex), expression);
             }
             default:
             {
@@ -738,8 +728,6 @@ public sealed class Parser
                     return new VoidTypeSyntax(GetTokens(startIndex));
                 case "string":
                     return new StringTypeSyntax(GetTokens(startIndex));
-                case "cstring":
-                    return new CStringTypeSyntax(GetTokens(startIndex));
                 case "bool":
                     return new BoolTypeSyntax(GetTokens(startIndex));
                 default:

compiler/NubLang/Syntax/Syntax.cs

@@ -112,11 +112,9 @@ public record StructInitializerSyntax(List<Token> Tokens, TypeSyntax? StructType
 
 public record DereferenceSyntax(List<Token> Tokens, ExpressionSyntax Target) : ExpressionSyntax(Tokens);
 
-public record SizeBuiltinSyntax(List<Token> Tokens, TypeSyntax Type) : ExpressionSyntax(Tokens);
+public record SizeSyntax(List<Token> Tokens, TypeSyntax Type) : ExpressionSyntax(Tokens);
 
-public record InterpretBuiltinSyntax(List<Token> Tokens, TypeSyntax Type, ExpressionSyntax Target) : ExpressionSyntax(Tokens);
-
-public record FloatToIntBuiltinSyntax(List<Token> Tokens, TypeSyntax Type, ExpressionSyntax Value) : ExpressionSyntax(Tokens);
+public record CastSyntax(List<Token> Tokens, ExpressionSyntax Value) : ExpressionSyntax(Tokens);
 
 #endregion
 
@@ -138,8 +136,6 @@ public record BoolTypeSyntax(List<Token> Tokens) : TypeSyntax(Tokens);
 
 public record StringTypeSyntax(List<Token> Tokens) : TypeSyntax(Tokens);
 
-public record CStringTypeSyntax(List<Token> Tokens) : TypeSyntax(Tokens);
-
 public record SliceTypeSyntax(List<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens);
 
 public record ArrayTypeSyntax(List<Token> Tokens, TypeSyntax BaseType) : TypeSyntax(Tokens);

examples/hello-world/main.nub

@@ -1,24 +1,9 @@
 module "main"
 
-extern "puts" func puts(text: cstring)
+extern "puts" func puts(text: ^i8)
 
-struct X
+extern "main" func main(argc: i64, argv: [?]^i8): i64
 {
-    points: []i32
-}
-
-extern "main" func main(argc: i64, argv: [?]cstring): i64
-{
-    let f: []cstring = ["1", "2", "3"]
-
-    puts(f[0])
-    puts(f[1])
-    puts(f[2])
-
-    for num in f
-    {
-        puts(num)
-    }
-
+    puts("Hello, World!")
     return 0
 }

examples/raylib/generated/raylib.nub

@@ -255,7 +255,7 @@ export struct FilePathList
 {
     capacity: u32
     count: u32
-    paths: ^cstring
+    paths: ^^i8
 }
 export struct AutomationEvent
 {
@@ -995,7 +995,7 @@ export enum NPatchLayout : u32
     NPATCH_THREE_PATCH_VERTICAL = 1
     NPATCH_THREE_PATCH_HORIZONTAL = 2
 }
-export extern "InitWindow" func InitWindow(width: i32, height: i32, title: cstring): void
+export extern "InitWindow" func InitWindow(width: i32, height: i32, title: ^i8): void
 export extern "CloseWindow" func CloseWindow(): void
 export extern "WindowShouldClose" func WindowShouldClose(): bool
 export extern "IsWindowReady" func IsWindowReady(): bool
@@ -1015,7 +1015,7 @@ export extern "MinimizeWindow" func MinimizeWindow(): void
 export extern "RestoreWindow" func RestoreWindow(): void
 export extern "SetWindowIcon" func SetWindowIcon(image: Image): void
 export extern "SetWindowIcons" func SetWindowIcons(images: ^Image, count: i32): void
-export extern "SetWindowTitle" func SetWindowTitle(title: cstring): void
+export extern "SetWindowTitle" func SetWindowTitle(title: ^i8): void
 export extern "SetWindowPosition" func SetWindowPosition(x: i32, y: i32): void
 export extern "SetWindowMonitor" func SetWindowMonitor(monitor: i32): void
 export extern "SetWindowMinSize" func SetWindowMinSize(width: i32, height: i32): void
@@ -1038,9 +1038,9 @@ export extern "GetMonitorPhysicalHeight" func GetMonitorPhysicalHeight(monitor:
 export extern "GetMonitorRefreshRate" func GetMonitorRefreshRate(monitor: i32): i32
 export extern "GetWindowPosition" func GetWindowPosition(): Vector2
 export extern "GetWindowScaleDPI" func GetWindowScaleDPI(): Vector2
-export extern "GetMonitorName" func GetMonitorName(monitor: i32): cstring
-export extern "SetClipboardText" func SetClipboardText(text: cstring): void
-export extern "GetClipboardText" func GetClipboardText(): cstring
+export extern "GetMonitorName" func GetMonitorName(monitor: i32): ^i8
+export extern "SetClipboardText" func SetClipboardText(text: ^i8): void
+export extern "GetClipboardText" func GetClipboardText(): ^i8
 export extern "GetClipboardImage" func GetClipboardImage(): Image
 export extern "EnableEventWaiting" func EnableEventWaiting(): void
 export extern "DisableEventWaiting" func DisableEventWaiting(): void
@@ -1069,11 +1069,11 @@ export extern "BeginVrStereoMode" func BeginVrStereoMode(config: VrStereoConfig)
 export extern "EndVrStereoMode" func EndVrStereoMode(): void
 export extern "LoadVrStereoConfig" func LoadVrStereoConfig(device: VrDeviceInfo): VrStereoConfig
 export extern "UnloadVrStereoConfig" func UnloadVrStereoConfig(config: VrStereoConfig): void
-export extern "LoadShader" func LoadShader(vsFileName: cstring, fsFileName: cstring): Shader
-export extern "LoadShaderFromMemory" func LoadShaderFromMemory(vsCode: cstring, fsCode: cstring): Shader
+export extern "LoadShader" func LoadShader(vsFileName: ^i8, fsFileName: ^i8): Shader
+export extern "LoadShaderFromMemory" func LoadShaderFromMemory(vsCode: ^i8, fsCode: ^i8): Shader
 export extern "IsShaderValid" func IsShaderValid(shader: Shader): bool
-export extern "GetShaderLocation" func GetShaderLocation(shader: Shader, uniformName: cstring): i32
-export extern "GetShaderLocationAttrib" func GetShaderLocationAttrib(shader: Shader, attribName: cstring): i32
+export extern "GetShaderLocation" func GetShaderLocation(shader: Shader, uniformName: ^i8): i32
+export extern "GetShaderLocationAttrib" func GetShaderLocationAttrib(shader: Shader, attribName: ^i8): i32
 export extern "SetShaderValue" func SetShaderValue(shader: Shader, locIndex: i32, value: ^void, uniformType: i32): void
 export extern "SetShaderValueV" func SetShaderValueV(shader: Shader, locIndex: i32, value: ^void, uniformType: i32, count: i32): void
 export extern "SetShaderValueMatrix" func SetShaderValueMatrix(shader: Shader, locIndex: i32, mat: Matrix): void
@@ -1098,58 +1098,58 @@ export extern "SetRandomSeed" func SetRandomSeed(seed: u32): void
 export extern "GetRandomValue" func GetRandomValue(min: i32, max: i32): i32
 export extern "LoadRandomSequence" func LoadRandomSequence(count: u32, min: i32, max: i32): ^i32
 export extern "UnloadRandomSequence" func UnloadRandomSequence(sequence: ^i32): void
-export extern "TakeScreenshot" func TakeScreenshot(fileName: cstring): void
+export extern "TakeScreenshot" func TakeScreenshot(fileName: ^i8): void
 export extern "SetConfigFlags" func SetConfigFlags(flags: u32): void
-export extern "OpenURL" func OpenURL(url: cstring): void
-export extern "TraceLog" func TraceLog(logLevel: i32, text: cstring): void
+export extern "OpenURL" func OpenURL(url: ^i8): void
+export extern "TraceLog" func TraceLog(logLevel: i32, text: ^i8): void
 export extern "SetTraceLogLevel" func SetTraceLogLevel(logLevel: i32): void
 export extern "MemAlloc" func MemAlloc(size: u32): ^void
 export extern "MemRealloc" func MemRealloc(ptr: ^void, size: u32): ^void
 export extern "MemFree" func MemFree(ptr: ^void): void
-export extern "SetTraceLogCallback" func SetTraceLogCallback(callback: func(i32, cstring, i32): void): void
-export extern "SetLoadFileDataCallback" func SetLoadFileDataCallback(callback: func(cstring, ^i32): ^u8): void
-export extern "SetSaveFileDataCallback" func SetSaveFileDataCallback(callback: func(cstring, ^void, i32): bool): void
-export extern "SetLoadFileTextCallback" func SetLoadFileTextCallback(callback: func(cstring): cstring): void
-export extern "SetSaveFileTextCallback" func SetSaveFileTextCallback(callback: func(cstring, cstring): bool): void
-export extern "LoadFileData" func LoadFileData(fileName: cstring, dataSize: ^i32): ^u8
+export extern "SetTraceLogCallback" func SetTraceLogCallback(callback: func(i32, ^i8, i32): void): void
+export extern "SetLoadFileDataCallback" func SetLoadFileDataCallback(callback: func(^i8, ^i32): ^u8): void
+export extern "SetSaveFileDataCallback" func SetSaveFileDataCallback(callback: func(^i8, ^void, i32): bool): void
+export extern "SetLoadFileTextCallback" func SetLoadFileTextCallback(callback: func(^i8): ^i8): void
+export extern "SetSaveFileTextCallback" func SetSaveFileTextCallback(callback: func(^i8, ^i8): bool): void
+export extern "LoadFileData" func LoadFileData(fileName: ^i8, dataSize: ^i32): ^u8
 export extern "UnloadFileData" func UnloadFileData(data: ^u8): void
-export extern "SaveFileData" func SaveFileData(fileName: cstring, data: ^void, dataSize: i32): bool
-export extern "ExportDataAsCode" func ExportDataAsCode(data: ^u8, dataSize: i32, fileName: cstring): bool
-export extern "LoadFileText" func LoadFileText(fileName: cstring): cstring
-export extern "UnloadFileText" func UnloadFileText(text: cstring): void
-export extern "SaveFileText" func SaveFileText(fileName: cstring, text: cstring): bool
-export extern "FileExists" func FileExists(fileName: cstring): bool
-export extern "DirectoryExists" func DirectoryExists(dirPath: cstring): bool
-export extern "IsFileExtension" func IsFileExtension(fileName: cstring, ext: cstring): bool
-export extern "GetFileLength" func GetFileLength(fileName: cstring): i32
-export extern "GetFileExtension" func GetFileExtension(fileName: cstring): cstring
-export extern "GetFileName" func GetFileName(filePath: cstring): cstring
-export extern "GetFileNameWithoutExt" func GetFileNameWithoutExt(filePath: cstring): cstring
-export extern "GetDirectoryPath" func GetDirectoryPath(filePath: cstring): cstring
-export extern "GetPrevDirectoryPath" func GetPrevDirectoryPath(dirPath: cstring): cstring
-export extern "GetWorkingDirectory" func GetWorkingDirectory(): cstring
-export extern "GetApplicationDirectory" func GetApplicationDirectory(): cstring
-export extern "MakeDirectory" func MakeDirectory(dirPath: cstring): i32
-export extern "ChangeDirectory" func ChangeDirectory(dir: cstring): bool
-export extern "IsPathFile" func IsPathFile(path: cstring): bool
-export extern "IsFileNameValid" func IsFileNameValid(fileName: cstring): bool
-export extern "LoadDirectoryFiles" func LoadDirectoryFiles(dirPath: cstring): FilePathList
-export extern "LoadDirectoryFilesEx" func LoadDirectoryFilesEx(basePath: cstring, filter: cstring, scanSubdirs: bool): FilePathList
+export extern "SaveFileData" func SaveFileData(fileName: ^i8, data: ^void, dataSize: i32): bool
+export extern "ExportDataAsCode" func ExportDataAsCode(data: ^u8, dataSize: i32, fileName: ^i8): bool
+export extern "LoadFileText" func LoadFileText(fileName: ^i8): ^i8
+export extern "UnloadFileText" func UnloadFileText(text: ^i8): void
+export extern "SaveFileText" func SaveFileText(fileName: ^i8, text: ^i8): bool
+export extern "FileExists" func FileExists(fileName: ^i8): bool
+export extern "DirectoryExists" func DirectoryExists(dirPath: ^i8): bool
+export extern "IsFileExtension" func IsFileExtension(fileName: ^i8, ext: ^i8): bool
+export extern "GetFileLength" func GetFileLength(fileName: ^i8): i32
+export extern "GetFileExtension" func GetFileExtension(fileName: ^i8): ^i8
+export extern "GetFileName" func GetFileName(filePath: ^i8): ^i8
+export extern "GetFileNameWithoutExt" func GetFileNameWithoutExt(filePath: ^i8): ^i8
+export extern "GetDirectoryPath" func GetDirectoryPath(filePath: ^i8): ^i8
+export extern "GetPrevDirectoryPath" func GetPrevDirectoryPath(dirPath: ^i8): ^i8
+export extern "GetWorkingDirectory" func GetWorkingDirectory(): ^i8
+export extern "GetApplicationDirectory" func GetApplicationDirectory(): ^i8
+export extern "MakeDirectory" func MakeDirectory(dirPath: ^i8): i32
+export extern "ChangeDirectory" func ChangeDirectory(dir: ^i8): bool
+export extern "IsPathFile" func IsPathFile(path: ^i8): bool
+export extern "IsFileNameValid" func IsFileNameValid(fileName: ^i8): bool
+export extern "LoadDirectoryFiles" func LoadDirectoryFiles(dirPath: ^i8): FilePathList
+export extern "LoadDirectoryFilesEx" func LoadDirectoryFilesEx(basePath: ^i8, filter: ^i8, scanSubdirs: bool): FilePathList
 export extern "UnloadDirectoryFiles" func UnloadDirectoryFiles(files: FilePathList): void
 export extern "IsFileDropped" func IsFileDropped(): bool
 export extern "LoadDroppedFiles" func LoadDroppedFiles(): FilePathList
 export extern "UnloadDroppedFiles" func UnloadDroppedFiles(files: FilePathList): void
-export extern "GetFileModTime" func GetFileModTime(fileName: cstring): i64
+export extern "GetFileModTime" func GetFileModTime(fileName: ^i8): i64
 export extern "CompressData" func CompressData(data: ^u8, dataSize: i32, compDataSize: ^i32): ^u8
 export extern "DecompressData" func DecompressData(compData: ^u8, compDataSize: i32, dataSize: ^i32): ^u8
-export extern "EncodeDataBase64" func EncodeDataBase64(data: ^u8, dataSize: i32, outputSize: ^i32): cstring
+export extern "EncodeDataBase64" func EncodeDataBase64(data: ^u8, dataSize: i32, outputSize: ^i32): ^i8
 export extern "DecodeDataBase64" func DecodeDataBase64(data: ^u8, outputSize: ^i32): ^u8
 export extern "ComputeCRC32" func ComputeCRC32(data: ^u8, dataSize: i32): u32
 export extern "ComputeMD5" func ComputeMD5(data: ^u8, dataSize: i32): ^u32
 export extern "ComputeSHA1" func ComputeSHA1(data: ^u8, dataSize: i32): ^u32
-export extern "LoadAutomationEventList" func LoadAutomationEventList(fileName: cstring): AutomationEventList
+export extern "LoadAutomationEventList" func LoadAutomationEventList(fileName: ^i8): AutomationEventList
 export extern "UnloadAutomationEventList" func UnloadAutomationEventList(list: AutomationEventList): void
-export extern "ExportAutomationEventList" func ExportAutomationEventList(list: AutomationEventList, fileName: cstring): bool
+export extern "ExportAutomationEventList" func ExportAutomationEventList(list: AutomationEventList, fileName: ^i8): bool
 export extern "SetAutomationEventList" func SetAutomationEventList(list: ^AutomationEventList): void
 export extern "SetAutomationEventBaseFrame" func SetAutomationEventBaseFrame(frame: i32): void
 export extern "StartAutomationEventRecording" func StartAutomationEventRecording(): void
@@ -1164,7 +1164,7 @@ export extern "GetKeyPressed" func GetKeyPressed(): i32
 export extern "GetCharPressed" func GetCharPressed(): i32
 export extern "SetExitKey" func SetExitKey(key: i32): void
 export extern "IsGamepadAvailable" func IsGamepadAvailable(gamepad: i32): bool
-export extern "GetGamepadName" func GetGamepadName(gamepad: i32): cstring
+export extern "GetGamepadName" func GetGamepadName(gamepad: i32): ^i8
 export extern "IsGamepadButtonPressed" func IsGamepadButtonPressed(gamepad: i32, button: i32): bool
 export extern "IsGamepadButtonDown" func IsGamepadButtonDown(gamepad: i32, button: i32): bool
 export extern "IsGamepadButtonReleased" func IsGamepadButtonReleased(gamepad: i32, button: i32): bool
@@ -1172,7 +1172,7 @@ export extern "IsGamepadButtonUp" func IsGamepadButtonUp(gamepad: i32, button: i
 export extern "GetGamepadButtonPressed" func GetGamepadButtonPressed(): i32
 export extern "GetGamepadAxisCount" func GetGamepadAxisCount(gamepad: i32): i32
 export extern "GetGamepadAxisMovement" func GetGamepadAxisMovement(gamepad: i32, axis: i32): f32
-export extern "SetGamepadMappings" func SetGamepadMappings(mappings: cstring): i32
+export extern "SetGamepadMappings" func SetGamepadMappings(mappings: ^i8): i32
 export extern "SetGamepadVibration" func SetGamepadVibration(gamepad: i32, leftMotor: f32, rightMotor: f32, duration: f32): void
 export extern "IsMouseButtonPressed" func IsMouseButtonPressed(button: i32): bool
 export extern "IsMouseButtonDown" func IsMouseButtonDown(button: i32): bool
@@ -1269,18 +1269,18 @@ export extern "CheckCollisionPointLine" func CheckCollisionPointLine(point: Vect
 export extern "CheckCollisionPointPoly" func CheckCollisionPointPoly(point: Vector2, points: ^Vector2, pointCount: i32): bool
 export extern "CheckCollisionLines" func CheckCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: ^Vector2): bool
 export extern "GetCollisionRec" func GetCollisionRec(rec1: Rectangle, rec2: Rectangle): Rectangle
-export extern "LoadImage" func LoadImage(fileName: cstring): Image
-export extern "LoadImageRaw" func LoadImageRaw(fileName: cstring, width: i32, height: i32, format: i32, headerSize: i32): Image
-export extern "LoadImageAnim" func LoadImageAnim(fileName: cstring, frames: ^i32): Image
-export extern "LoadImageAnimFromMemory" func LoadImageAnimFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32, frames: ^i32): Image
-export extern "LoadImageFromMemory" func LoadImageFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32): Image
+export extern "LoadImage" func LoadImage(fileName: ^i8): Image
+export extern "LoadImageRaw" func LoadImageRaw(fileName: ^i8, width: i32, height: i32, format: i32, headerSize: i32): Image
+export extern "LoadImageAnim" func LoadImageAnim(fileName: ^i8, frames: ^i32): Image
+export extern "LoadImageAnimFromMemory" func LoadImageAnimFromMemory(fileType: ^i8, fileData: ^u8, dataSize: i32, frames: ^i32): Image
+export extern "LoadImageFromMemory" func LoadImageFromMemory(fileType: ^i8, fileData: ^u8, dataSize: i32): Image
 export extern "LoadImageFromTexture" func LoadImageFromTexture(texture: Texture): Image
 export extern "LoadImageFromScreen" func LoadImageFromScreen(): Image
 export extern "IsImageValid" func IsImageValid(image: Image): bool
 export extern "UnloadImage" func UnloadImage(image: Image): void
-export extern "ExportImage" func ExportImage(image: Image, fileName: cstring): bool
-export extern "ExportImageToMemory" func ExportImageToMemory(image: Image, fileType: cstring, fileSize: ^i32): ^u8
-export extern "ExportImageAsCode" func ExportImageAsCode(image: Image, fileName: cstring): bool
+export extern "ExportImage" func ExportImage(image: Image, fileName: ^i8): bool
+export extern "ExportImageToMemory" func ExportImageToMemory(image: Image, fileType: ^i8, fileSize: ^i32): ^u8
+export extern "ExportImageAsCode" func ExportImageAsCode(image: Image, fileName: ^i8): bool
 export extern "GenImageColor" func GenImageColor(width: i32, height: i32, color: Color): Image
 export extern "GenImageGradientLinear" func GenImageGradientLinear(width: i32, height: i32, direction: i32, start: Color, end: Color): Image
 export extern "GenImageGradientRadial" func GenImageGradientRadial(width: i32, height: i32, density: f32, inner: Color, outer: Color): Image
@@ -1289,12 +1289,12 @@ export extern "GenImageChecked" func GenImageChecked(width: i32, height: i32, ch
 export extern "GenImageWhiteNoise" func GenImageWhiteNoise(width: i32, height: i32, factor: f32): Image
 export extern "GenImagePerlinNoise" func GenImagePerlinNoise(width: i32, height: i32, offsetX: i32, offsetY: i32, scale: f32): Image
 export extern "GenImageCellular" func GenImageCellular(width: i32, height: i32, tileSize: i32): Image
-export extern "GenImageText" func GenImageText(width: i32, height: i32, text: cstring): Image
+export extern "GenImageText" func GenImageText(width: i32, height: i32, text: ^i8): Image
 export extern "ImageCopy" func ImageCopy(image: Image): Image
 export extern "ImageFromImage" func ImageFromImage(image: Image, rec: Rectangle): Image
 export extern "ImageFromChannel" func ImageFromChannel(image: Image, selectedChannel: i32): Image
-export extern "ImageText" func ImageText(text: cstring, fontSize: i32, color: Color): Image
-export extern "ImageTextEx" func ImageTextEx(font: Font, text: cstring, fontSize: f32, spacing: f32, tint: Color): Image
+export extern "ImageText" func ImageText(text: ^i8, fontSize: i32, color: Color): Image
+export extern "ImageTextEx" func ImageTextEx(font: Font, text: ^i8, fontSize: f32, spacing: f32, tint: Color): Image
 export extern "ImageFormat" func ImageFormat(image: ^Image, newFormat: i32): void
 export extern "ImageToPOT" func ImageToPOT(image: ^Image, fill: Color): void
 export extern "ImageCrop" func ImageCrop(image: ^Image, crop: Rectangle): void
@@ -1346,9 +1346,9 @@ export extern "ImageDrawTriangleLines" func ImageDrawTriangleLines(dst: ^Image,
 export extern "ImageDrawTriangleFan" func ImageDrawTriangleFan(dst: ^Image, points: ^Vector2, pointCount: i32, color: Color): void
 export extern "ImageDrawTriangleStrip" func ImageDrawTriangleStrip(dst: ^Image, points: ^Vector2, pointCount: i32, color: Color): void
 export extern "ImageDraw" func ImageDraw(dst: ^Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color): void
-export extern "ImageDrawText" func ImageDrawText(dst: ^Image, text: cstring, posX: i32, posY: i32, fontSize: i32, color: Color): void
-export extern "ImageDrawTextEx" func ImageDrawTextEx(dst: ^Image, font: Font, text: cstring, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void
-export extern "LoadTexture" func LoadTexture(fileName: cstring): Texture
+export extern "ImageDrawText" func ImageDrawText(dst: ^Image, text: ^i8, posX: i32, posY: i32, fontSize: i32, color: Color): void
+export extern "ImageDrawTextEx" func ImageDrawTextEx(dst: ^Image, font: Font, text: ^i8, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void
+export extern "LoadTexture" func LoadTexture(fileName: ^i8): Texture
 export extern "LoadTextureFromImage" func LoadTextureFromImage(image: Image): Texture
 export extern "LoadTextureCubemap" func LoadTextureCubemap(image: Image, layout: i32): Texture
 export extern "LoadRenderTexture" func LoadRenderTexture(width: i32, height: i32): RenderTexture
@@ -1385,55 +1385,55 @@ export extern "GetPixelColor" func GetPixelColor(srcPtr: ^void, format: i32): Co
 export extern "SetPixelColor" func SetPixelColor(dstPtr: ^void, color: Color, format: i32): void
 export extern "GetPixelDataSize" func GetPixelDataSize(width: i32, height: i32, format: i32): i32
 export extern "GetFontDefault" func GetFontDefault(): Font
-export extern "LoadFont" func LoadFont(fileName: cstring): Font
-export extern "LoadFontEx" func LoadFontEx(fileName: cstring, fontSize: i32, codepoints: ^i32, codepointCount: i32): Font
+export extern "LoadFont" func LoadFont(fileName: ^i8): Font
+export extern "LoadFontEx" func LoadFontEx(fileName: ^i8, fontSize: i32, codepoints: ^i32, codepointCount: i32): Font
 export extern "LoadFontFromImage" func LoadFontFromImage(image: Image, key: Color, firstChar: i32): Font
-export extern "LoadFontFromMemory" func LoadFontFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32, fontSize: i32, codepoints: ^i32, codepointCount: i32): Font
+export extern "LoadFontFromMemory" func LoadFontFromMemory(fileType: ^i8, fileData: ^u8, dataSize: i32, fontSize: i32, codepoints: ^i32, codepointCount: i32): Font
 export extern "IsFontValid" func IsFontValid(font: Font): bool
 export extern "LoadFontData" func LoadFontData(fileData: ^u8, dataSize: i32, fontSize: i32, codepoints: ^i32, codepointCount: i32, type: i32): ^GlyphInfo
 export extern "GenImageFontAtlas" func GenImageFontAtlas(glyphs: ^GlyphInfo, glyphRecs: ^^Rectangle, glyphCount: i32, fontSize: i32, padding: i32, packMethod: i32): Image
 export extern "UnloadFontData" func UnloadFontData(glyphs: ^GlyphInfo, glyphCount: i32): void
 export extern "UnloadFont" func UnloadFont(font: Font): void
-export extern "ExportFontAsCode" func ExportFontAsCode(font: Font, fileName: cstring): bool
+export extern "ExportFontAsCode" func ExportFontAsCode(font: Font, fileName: ^i8): bool
 export extern "DrawFPS" func DrawFPS(posX: i32, posY: i32): void
-export extern "DrawText" func DrawText(text: cstring, posX: i32, posY: i32, fontSize: i32, color: Color): void
-export extern "DrawTextEx" func DrawTextEx(font: Font, text: cstring, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void
-export extern "DrawTextPro" func DrawTextPro(font: Font, text: cstring, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color): void
+export extern "DrawText" func DrawText(text: ^i8, posX: i32, posY: i32, fontSize: i32, color: Color): void
+export extern "DrawTextEx" func DrawTextEx(font: Font, text: ^i8, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void
+export extern "DrawTextPro" func DrawTextPro(font: Font, text: ^i8, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color): void
 export extern "DrawTextCodepoint" func DrawTextCodepoint(font: Font, codepoint: i32, position: Vector2, fontSize: f32, tint: Color): void
 export extern "DrawTextCodepoints" func DrawTextCodepoints(font: Font, codepoints: ^i32, codepointCount: i32, position: Vector2, fontSize: f32, spacing: f32, tint: Color): void
 export extern "SetTextLineSpacing" func SetTextLineSpacing(spacing: i32): void
-export extern "MeasureText" func MeasureText(text: cstring, fontSize: i32): i32
-export extern "MeasureTextEx" func MeasureTextEx(font: Font, text: cstring, fontSize: f32, spacing: f32): Vector2
+export extern "MeasureText" func MeasureText(text: ^i8, fontSize: i32): i32
+export extern "MeasureTextEx" func MeasureTextEx(font: Font, text: ^i8, fontSize: f32, spacing: f32): Vector2
 export extern "GetGlyphIndex" func GetGlyphIndex(font: Font, codepoint: i32): i32
 export extern "GetGlyphInfo" func GetGlyphInfo(font: Font, codepoint: i32): GlyphInfo
 export extern "GetGlyphAtlasRec" func GetGlyphAtlasRec(font: Font, codepoint: i32): Rectangle
-export extern "LoadUTF8" func LoadUTF8(codepoints: ^i32, length: i32): cstring
-export extern "UnloadUTF8" func UnloadUTF8(text: cstring): void
-export extern "LoadCodepoints" func LoadCodepoints(text: cstring, count: ^i32): ^i32
+export extern "LoadUTF8" func LoadUTF8(codepoints: ^i32, length: i32): ^i8
+export extern "UnloadUTF8" func UnloadUTF8(text: ^i8): void
+export extern "LoadCodepoints" func LoadCodepoints(text: ^i8, count: ^i32): ^i32
 export extern "UnloadCodepoints" func UnloadCodepoints(codepoints: ^i32): void
-export extern "GetCodepointCount" func GetCodepointCount(text: cstring): i32
-export extern "GetCodepoint" func GetCodepoint(text: cstring, codepointSize: ^i32): i32
-export extern "GetCodepointNext" func GetCodepointNext(text: cstring, codepointSize: ^i32): i32
-export extern "GetCodepointPrevious" func GetCodepointPrevious(text: cstring, codepointSize: ^i32): i32
-export extern "CodepointToUTF8" func CodepointToUTF8(codepoint: i32, utf8Size: ^i32): cstring
-export extern "TextCopy" func TextCopy(dst: cstring, src: cstring): i32
-export extern "TextIsEqual" func TextIsEqual(text1: cstring, text2: cstring): bool
-export extern "TextLength" func TextLength(text: cstring): u32
-export extern "TextFormat" func TextFormat(text: cstring): cstring
-export extern "TextSubtext" func TextSubtext(text: cstring, position: i32, length: i32): cstring
-export extern "TextReplace" func TextReplace(text: cstring, replace: cstring, by: cstring): cstring
-export extern "TextInsert" func TextInsert(text: cstring, insert: cstring, position: i32): cstring
-export extern "TextJoin" func TextJoin(textList: ^cstring, count: i32, delimiter: cstring): cstring
-export extern "TextSplit" func TextSplit(text: cstring, delimiter: i8, count: ^i32): ^cstring
-export extern "TextAppend" func TextAppend(text: cstring, append: cstring, position: ^i32): void
-export extern "TextFindIndex" func TextFindIndex(text: cstring, find: cstring): i32
-export extern "TextToUpper" func TextToUpper(text: cstring): cstring
-export extern "TextToLower" func TextToLower(text: cstring): cstring
-export extern "TextToPascal" func TextToPascal(text: cstring): cstring
-export extern "TextToSnake" func TextToSnake(text: cstring): cstring
-export extern "TextToCamel" func TextToCamel(text: cstring): cstring
-export extern "TextToInteger" func TextToInteger(text: cstring): i32
-export extern "TextToFloat" func TextToFloat(text: cstring): f32
+export extern "GetCodepointCount" func GetCodepointCount(text: ^i8): i32
+export extern "GetCodepoint" func GetCodepoint(text: ^i8, codepointSize: ^i32): i32
+export extern "GetCodepointNext" func GetCodepointNext(text: ^i8, codepointSize: ^i32): i32
+export extern "GetCodepointPrevious" func GetCodepointPrevious(text: ^i8, codepointSize: ^i32): i32
+export extern "CodepointToUTF8" func CodepointToUTF8(codepoint: i32, utf8Size: ^i32): ^i8
+export extern "TextCopy" func TextCopy(dst: ^i8, src: ^i8): i32
+export extern "TextIsEqual" func TextIsEqual(text1: ^i8, text2: ^i8): bool
+export extern "TextLength" func TextLength(text: ^i8): u32
+export extern "TextFormat" func TextFormat(text: ^i8): ^i8
+export extern "TextSubtext" func TextSubtext(text: ^i8, position: i32, length: i32): ^i8
+export extern "TextReplace" func TextReplace(text: ^i8, replace: ^i8, by: ^i8): ^i8
+export extern "TextInsert" func TextInsert(text: ^i8, insert: ^i8, position: i32): ^i8
+export extern "TextJoin" func TextJoin(textList: ^^i8, count: i32, delimiter: ^i8): ^i8
+export extern "TextSplit" func TextSplit(text: ^i8, delimiter: i8, count: ^i32): ^^i8
+export extern "TextAppend" func TextAppend(text: ^i8, append: ^i8, position: ^i32): void
+export extern "TextFindIndex" func TextFindIndex(text: ^i8, find: ^i8): i32
+export extern "TextToUpper" func TextToUpper(text: ^i8): ^i8
+export extern "TextToLower" func TextToLower(text: ^i8): ^i8
+export extern "TextToPascal" func TextToPascal(text: ^i8): ^i8
+export extern "TextToSnake" func TextToSnake(text: ^i8): ^i8
+export extern "TextToCamel" func TextToCamel(text: ^i8): ^i8
+export extern "TextToInteger" func TextToInteger(text: ^i8): i32
+export extern "TextToFloat" func TextToFloat(text: ^i8): f32
 export extern "DrawLine3D" func DrawLine3D(startPos: Vector3, endPos: Vector3, color: Color): void
 export extern "DrawPoint3D" func DrawPoint3D(position: Vector3, color: Color): void
 export extern "DrawCircle3D" func DrawCircle3D(center: Vector3, radius: f32, rotationAxis: Vector3, rotationAngle: f32, color: Color): void
@@ -1455,7 +1455,7 @@ export extern "DrawCapsuleWires" func DrawCapsuleWires(startPos: Vector3, endPos
 export extern "DrawPlane" func DrawPlane(centerPos: Vector3, size: Vector2, color: Color): void
 export extern "DrawRay" func DrawRay(ray: Ray, color: Color): void
 export extern "DrawGrid" func DrawGrid(slices: i32, spacing: f32): void
-export extern "LoadModel" func LoadModel(fileName: cstring): Model
+export extern "LoadModel" func LoadModel(fileName: ^i8): Model
 export extern "LoadModelFromMesh" func LoadModelFromMesh(mesh: Mesh): Model
 export extern "IsModelValid" func IsModelValid(model: Model): bool
 export extern "UnloadModel" func UnloadModel(model: Model): void
@@ -1477,8 +1477,8 @@ export extern "DrawMesh" func DrawMesh(mesh: Mesh, material: Material, transform
 export extern "DrawMeshInstanced" func DrawMeshInstanced(mesh: Mesh, material: Material, transforms: ^Matrix, instances: i32): void
 export extern "GetMeshBoundingBox" func GetMeshBoundingBox(mesh: Mesh): BoundingBox
 export extern "GenMeshTangents" func GenMeshTangents(mesh: ^Mesh): void
-export extern "ExportMesh" func ExportMesh(mesh: Mesh, fileName: cstring): bool
-export extern "ExportMeshAsCode" func ExportMeshAsCode(mesh: Mesh, fileName: cstring): bool
+export extern "ExportMesh" func ExportMesh(mesh: Mesh, fileName: ^i8): bool
+export extern "ExportMeshAsCode" func ExportMeshAsCode(mesh: Mesh, fileName: ^i8): bool
 export extern "GenMeshPoly" func GenMeshPoly(sides: i32, radius: f32): Mesh
 export extern "GenMeshPlane" func GenMeshPlane(width: f32, length: f32, resX: i32, resZ: i32): Mesh
 export extern "GenMeshCube" func GenMeshCube(width: f32, height: f32, length: f32): Mesh
@@ -1490,13 +1490,13 @@ export extern "GenMeshTorus" func GenMeshTorus(radius: f32, size: f32, radSeg: i
 export extern "GenMeshKnot" func GenMeshKnot(radius: f32, size: f32, radSeg: i32, sides: i32): Mesh
 export extern "GenMeshHeightmap" func GenMeshHeightmap(heightmap: Image, size: Vector3): Mesh
 export extern "GenMeshCubicmap" func GenMeshCubicmap(cubicmap: Image, cubeSize: Vector3): Mesh
-export extern "LoadMaterials" func LoadMaterials(fileName: cstring, materialCount: ^i32): ^Material
+export extern "LoadMaterials" func LoadMaterials(fileName: ^i8, materialCount: ^i32): ^Material
 export extern "LoadMaterialDefault" func LoadMaterialDefault(): Material
 export extern "IsMaterialValid" func IsMaterialValid(material: Material): bool
 export extern "UnloadMaterial" func UnloadMaterial(material: Material): void
 export extern "SetMaterialTexture" func SetMaterialTexture(material: ^Material, mapType: i32, texture: Texture): void
 export extern "SetModelMeshMaterial" func SetModelMeshMaterial(model: ^Model, meshId: i32, materialId: i32): void
-export extern "LoadModelAnimations" func LoadModelAnimations(fileName: cstring, animCount: ^i32): ^ModelAnimation
+export extern "LoadModelAnimations" func LoadModelAnimations(fileName: ^i8, animCount: ^i32): ^ModelAnimation
 export extern "UpdateModelAnimation" func UpdateModelAnimation(model: Model, anim: ModelAnimation, frame: i32): void
 export extern "UpdateModelAnimationBones" func UpdateModelAnimationBones(model: Model, anim: ModelAnimation, frame: i32): void
 export extern "UnloadModelAnimation" func UnloadModelAnimation(anim: ModelAnimation): void
@@ -1515,10 +1515,10 @@ export extern "CloseAudioDevice" func CloseAudioDevice(): void
 export extern "IsAudioDeviceReady" func IsAudioDeviceReady(): bool
 export extern "SetMasterVolume" func SetMasterVolume(volume: f32): void
 export extern "GetMasterVolume" func GetMasterVolume(): f32
-export extern "LoadWave" func LoadWave(fileName: cstring): Wave
-export extern "LoadWaveFromMemory" func LoadWaveFromMemory(fileType: cstring, fileData: ^u8, dataSize: i32): Wave
+export extern "LoadWave" func LoadWave(fileName: ^i8): Wave
+export extern "LoadWaveFromMemory" func LoadWaveFromMemory(fileType: ^i8, fileData: ^u8, dataSize: i32): Wave
 export extern "IsWaveValid" func IsWaveValid(wave: Wave): bool
-export extern "LoadSound" func LoadSound(fileName: cstring): Sound
+export extern "LoadSound" func LoadSound(fileName: ^i8): Sound
 export extern "LoadSoundFromWave" func LoadSoundFromWave(wave: Wave): Sound
 export extern "LoadSoundAlias" func LoadSoundAlias(source: Sound): Sound
 export extern "IsSoundValid" func IsSoundValid(sound: Sound): bool
@@ -1526,8 +1526,8 @@ export extern "UpdateSound" func UpdateSound(sound: Sound, data: ^void, sampleCo
 export extern "UnloadWave" func UnloadWave(wave: Wave): void
 export extern "UnloadSound" func UnloadSound(sound: Sound): void
 export extern "UnloadSoundAlias" func UnloadSoundAlias(alias: Sound): void
-export extern "ExportWave" func ExportWave(wave: Wave, fileName: cstring): bool
-export extern "ExportWaveAsCode" func ExportWaveAsCode(wave: Wave, fileName: cstring): bool
+export extern "ExportWave" func ExportWave(wave: Wave, fileName: ^i8): bool
+export extern "ExportWaveAsCode" func ExportWaveAsCode(wave: Wave, fileName: ^i8): bool
 export extern "PlaySound" func PlaySound(sound: Sound): void
 export extern "StopSound" func StopSound(sound: Sound): void
 export extern "PauseSound" func PauseSound(sound: Sound): void
@@ -1541,8 +1541,8 @@ export extern "WaveCrop" func WaveCrop(wave: ^Wave, initFrame: i32, finalFrame:
 export extern "WaveFormat" func WaveFormat(wave: ^Wave, sampleRate: i32, sampleSize: i32, channels: i32): void
 export extern "LoadWaveSamples" func LoadWaveSamples(wave: Wave): ^f32
 export extern "UnloadWaveSamples" func UnloadWaveSamples(samples: ^f32): void
-export extern "LoadMusicStream" func LoadMusicStream(fileName: cstring): Music
-export extern "LoadMusicStreamFromMemory" func LoadMusicStreamFromMemory(fileType: cstring, data: ^u8, dataSize: i32): Music
+export extern "LoadMusicStream" func LoadMusicStream(fileName: ^i8): Music
+export extern "LoadMusicStreamFromMemory" func LoadMusicStreamFromMemory(fileType: ^i8, data: ^u8, dataSize: i32): Music
 export extern "IsMusicValid" func IsMusicValid(music: Music): bool
 export extern "UnloadMusicStream" func UnloadMusicStream(music: Music): void
 export extern "PlayMusicStream" func PlayMusicStream(music: Music): void

examples/raylib/generated/raymath.nub

@@ -1,190 +0,0 @@
-module "raymath"
-
-export struct Vector2
-{
-    x: f32
-    y: f32
-}
-export struct Vector3
-{
-    x: f32
-    y: f32
-    z: 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 float3
-{
-    v: [3]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

examples/raylib/generated/rlgl.nub

@@ -1,202 +0,0 @@
-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 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 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

examples/raylib/main.nub

@@ -2,8 +2,10 @@ import "raylib"
 
 module "main"
 
-extern "main" func main(argc: i64, argv: [?]cstring): i64
+extern "main" func main(argc: i64, argv: [?]^i8): i64
 {
+    let uwu: []i32 = [1, 2]
+
     raylib::SetConfigFlags(raylib::ConfigFlags.FLAG_VSYNC_HINT | raylib::ConfigFlags.FLAG_WINDOW_RESIZABLE)
 
     raylib::InitWindow(1600, 900, "Hi from nub-lang")
@@ -37,8 +39,8 @@ extern "main" func main(argc: i64, argv: [?]cstring): i64
             direction.y = -1
         }
 
-        x = x + @floatToInt(i32, direction.x * speed * raylib::GetFrameTime())
-        y = y + @floatToInt(i32, direction.y * speed * raylib::GetFrameTime())
+        x = x + @cast(direction.x * speed * raylib::GetFrameTime())
+        y = y + @cast(direction.y * speed * raylib::GetFrameTime())
 
         raylib::BeginDrawing()
         {

vscode-lsp/.gitignore

@@ -1,2 +1,4 @@
 node_modules
 out
+nub-*.vsix
+server

vscode-lsp/.vscode-test.mjs

@@ -1,5 +0,0 @@
-import { defineConfig } from '@vscode/test-cli';
-
-export default defineConfig({
-	files: 'out/test/**/*.test.js',
-});

vscode-lsp/get-latest.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-dotnet publish -c Release ../compiler/NubLang.LSP/NubLang.LSP.csproj
-cp ../compiler/NubLang.LSP/bin/Release/net9.0/linux-x64/publish/nublsp server/

vscode-lsp/media/output.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <title>generated c soruce</title>
-</head>
-
-<body>
-    <pre id="assembly">{{assembly}}</pre>
-</body>
-
-</html>

vscode-lsp/package.json

@@ -2,7 +2,7 @@
   "name": "nub",
   "displayName": "Nub Language Support",
   "description": "Language server client for nub lang",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "publisher": "nub31",
   "repository": {
     "type": "git",
@@ -15,6 +15,12 @@
     "Programming Languages"
   ],
   "main": "./out/extension.js",
+  "files": [
+    "out",
+    "server",
+    "syntaxes",
+    "language-configuration.json"
+  ],
   "contributes": {
     "languages": [
       {
@@ -31,31 +37,18 @@
         "scopeName": "source.nub",
         "path": "./syntaxes/nub.tmLanguage.json"
       }
-    ],
-    "commands": [
-      {
-        "command": "nub.openOutput",
-        "title": "Nub: Show Output",
-        "icon": "$(open-preview)"
-      }
-    ],
-    "menus": {
-      "editor/title": [
-        {
-          "command": "nub.openOutput",
-          "when": "editorLangId == nub || resourceExtname == .nub",
-          "group": "navigation"
-        }
     ]
-    }
   },
   "scripts": {
-    "build": "tsc -p ./",
-    "watch": "tsc -watch -p ./"
+    "build": "esbuild src/extension.ts --bundle --platform=node --outfile=out/extension.js --external:vscode",
+    "update-lsp": "mkdir -p server && dotnet publish -c Release ../compiler/NubLang.LSP/NubLang.LSP.csproj && cp ../compiler/NubLang.LSP/bin/Release/net9.0/linux-x64/publish/nublsp server/",
+    "package": "npm run update-lsp && npm run build && vsce package --skip-license"
   },
   "devDependencies": {
     "@types/node": "22.x",
     "@types/vscode": "^1.105.0",
+    "@vscode/vsce": "^3.6.2",
+    "esbuild": "^0.25.11",
     "typescript": "^5.9.3"
   },
   "dependencies": {

vscode-lsp/src/extension.ts

@@ -4,7 +4,7 @@ import { LanguageClient, TransportKind } from 'vscode-languageclient/node';
 
 let client: LanguageClient;
 
-export function activate(context: vscode.ExtensionContext) {
+export async function activate(context: vscode.ExtensionContext) {
 	const serverExecutable = path.join(context.asAbsolutePath('server'), "nublsp");
 
 	client = new LanguageClient(
@@ -32,14 +32,6 @@ export function activate(context: vscode.ExtensionContext) {
 		}
 	);
 
-	client.onNotification("nub/output", (params: { path: string, content: string }) => {
-
-	});
-
-	vscode.commands.registerCommand('nub.openOutput', async () => {
-
-	});
-
 	client.start();
 }