Added src/ folder. Now I will add the rest.

1 files changed, 283 insertions, 0 deletions

diff --git a/src/ast/ast.c b/src/ast/ast.c
new file mode 100644
index 0000000..4688bf7
--- /dev/null
+++ b/src/ast/ast.c
@@ -0,0 +1,283 @@
+
+#include <stdlib.h>
+#include <string.h>
+#include "ast.h"
+#include "zprep.h"
+#include "../parser/parser.h"
+
+typedef struct TraitReg
+{
+    char *name;
+    struct TraitReg *next;
+} TraitReg;
+
+static TraitReg *registered_traits = NULL;
+
+void register_trait(const char *name)
+{
+    TraitReg *r = xmalloc(sizeof(TraitReg));
+    r->name = xstrdup(name);
+    r->next = registered_traits;
+    registered_traits = r;
+}
+
+int is_trait(const char *name)
+{
+    TraitReg *r = registered_traits;
+    while (r)
+    {
+        if (0 == strcmp(r->name, name))
+        {
+            return 1;
+        }
+        r = r->next;
+    }
+    return 0;
+}
+
+ASTNode *ast_create(NodeType type)
+{
+    ASTNode *node = xmalloc(sizeof(ASTNode));
+    memset(node, 0, sizeof(ASTNode));
+    node->type = type;
+    return node;
+}
+
+void ast_free(ASTNode *node)
+{
+    (void)node;
+    return;
+}
+
+Type *type_new(TypeKind kind)
+{
+    Type *t = xmalloc(sizeof(Type));
+    t->kind = kind;
+    t->name = NULL;
+    t->inner = NULL;
+    t->args = NULL;
+    t->arg_count = 0;
+    t->is_const = 0;
+    t->array_size = 0;
+    return t;
+}
+
+Type *type_new_ptr(Type *inner)
+{
+    Type *t = type_new(TYPE_POINTER);
+    t->inner = inner;
+    return t;
+}
+
+int is_char_ptr(Type *t)
+{
+    // Handle both primitive char* and legacy struct char*.
+    if (TYPE_POINTER == t->kind && TYPE_CHAR == t->inner->kind)
+    {
+        return 1;
+    }
+    if (TYPE_POINTER == t->kind && TYPE_STRUCT == t->inner->kind &&
+        0 == strcmp(t->inner->name, "char"))
+    {
+        return 1;
+    }
+    return 0;
+}
+
+int is_integer_type(Type *t)
+{
+    if (!t)
+    {
+        return 0;
+    }
+
+    return (t->kind == TYPE_INT || t->kind == TYPE_CHAR || t->kind == TYPE_BOOL ||
+            t->kind == TYPE_I8 || t->kind == TYPE_U8 || t->kind == TYPE_I16 ||
+            t->kind == TYPE_U16 || t->kind == TYPE_I32 || t->kind == TYPE_U32 ||
+            t->kind == TYPE_I64 || t->kind == TYPE_U64 || t->kind == TYPE_USIZE ||
+            t->kind == TYPE_ISIZE || t->kind == TYPE_BYTE || t->kind == TYPE_RUNE ||
+            t->kind == TYPE_UINT || t->kind == TYPE_I128 || t->kind == TYPE_U128);
+}
+
+int is_float_type(Type *t)
+{
+    if (!t)
+    {
+        return 0;
+    }
+
+    return (t->kind == TYPE_FLOAT || t->kind == TYPE_F32 || t->kind == TYPE_F64);
+}
+
+int type_eq(Type *a, Type *b)
+{
+    if (!a || !b)
+    {
+        return 0;
+    }
+
+    if (a == b)
+    {
+        return 1;
+    }
+
+    // Lax integer matching (bool == int, char == i8, etc.).
+    if (is_integer_type(a) && is_integer_type(b))
+    {
+        return 1;
+    }
+
+    // Lax float matching.
+    if (is_float_type(a) && is_float_type(b))
+    {
+        return 1;
+    }
+
+    // String Literal vs char*
+    if (a->kind == TYPE_STRING && is_char_ptr(b))
+    {
+        return 1;
+    }
+
+    if (b->kind == TYPE_STRING && is_char_ptr(a))
+    {
+        return 1;
+    }
+
+    if (a->kind != b->kind)
+    {
+        return 0;
+    }
+
+    if (a->kind == TYPE_STRUCT || a->kind == TYPE_GENERIC)
+    {
+        return 0 == strcmp(a->name, b->name);
+    }
+    if (a->kind == TYPE_POINTER || a->kind == TYPE_ARRAY)
+    {
+        return type_eq(a->inner, b->inner);
+    }
+
+    return 1;
+}
+
+char *type_to_string(Type *t)
+{
+    if (!t)
+    {
+        return xstrdup("void");
+    }
+
+    switch (t->kind)
+    {
+    case TYPE_VOID:
+        return xstrdup("void");
+    case TYPE_BOOL:
+        return xstrdup("bool");
+    case TYPE_STRING:
+        return xstrdup("string");
+    case TYPE_CHAR:
+        return xstrdup("char");
+    case TYPE_I8:
+        return xstrdup("int8_t");
+    case TYPE_U8:
+        return xstrdup("uint8_t");
+    case TYPE_I16:
+        return xstrdup("int16_t");
+    case TYPE_U16:
+        return xstrdup("uint16_t");
+    case TYPE_I32:
+        return xstrdup("int32_t");
+    case TYPE_U32:
+        return xstrdup("uint32_t");
+    case TYPE_I64:
+        return xstrdup("int64_t");
+    case TYPE_U64:
+        return xstrdup("uint64_t");
+    case TYPE_F32:
+        return xstrdup("float");
+    case TYPE_F64:
+        return xstrdup("double");
+    case TYPE_USIZE:
+        return xstrdup("size_t");
+    case TYPE_ISIZE:
+        return xstrdup("ptrdiff_t");
+    case TYPE_BYTE:
+        return xstrdup("uint8_t");
+    case TYPE_I128:
+        return xstrdup("__int128");
+    case TYPE_U128:
+        return xstrdup("unsigned __int128");
+    case TYPE_RUNE:
+        return xstrdup("int32_t");
+    case TYPE_UINT:
+        return xstrdup("unsigned int");
+    case TYPE_INT:
+        return xstrdup("int");
+    case TYPE_FLOAT:
+        return xstrdup("float");
+
+    case TYPE_POINTER:
+    {
+        char *inner = type_to_string(t->inner);
+        if (t->is_restrict)
+        {
+            char *res = xmalloc(strlen(inner) + 16);
+            sprintf(res, "%s* __restrict", inner);
+            return res;
+        }
+        else
+        {
+            char *res = xmalloc(strlen(inner) + 2);
+            sprintf(res, "%s*", inner);
+            return res;
+        }
+    }
+
+    case TYPE_ARRAY:
+    {
+        char *inner = type_to_string(t->inner);
+
+        if (t->array_size > 0)
+        {
+            char *res = xmalloc(strlen(inner) + 20);
+            sprintf(res, "%s[%d]", inner, t->array_size);
+            return res;
+        }
+
+        char *res = xmalloc(strlen(inner) + 7);
+        sprintf(res, "Slice_%s", inner);
+        return res;
+    }
+
+    case TYPE_FUNCTION:
+        if (t->inner)
+        {
+            free(type_to_string(t->inner));
+        }
+
+        return xstrdup("z_closure_T");
+
+    case TYPE_STRUCT:
+    case TYPE_GENERIC:
+    {
+        if (t->arg_count > 0)
+        {
+            char *base = t->name;
+            char *arg = type_to_string(t->args[0]);
+            char *clean_arg = sanitize_mangled_name(arg);
+
+            char *res = xmalloc(strlen(base) + strlen(clean_arg) + 2);
+            sprintf(res, "%s_%s", base, clean_arg);
+
+            free(arg);
+            free(clean_arg);
+            return res;
+        }
+        return xstrdup(t->name);
+    }
+
+    default:
+        return xstrdup("unknown");
+    }
+}