type.c

Go to the documentation of this file.

// Copyright (C) 2023 Ethan Uppal. All rights reserved.
 
#include <string.h>      // strcmp
#include "type.h"
#include "util/abort.h"  // CHECK, ps_assert
#include "util/arena.h"  // astalloc
 
STR prim_type_names[] = {_STRING(PS_PRIM_TYPE_U8), _STRING(PS_PRIM_TYPE_I8),
    _STRING(PS_PRIM_TYPE_U16), _STRING(PS_PRIM_TYPE_I16),
    _STRING(PS_PRIM_TYPE_U32), _STRING(PS_PRIM_TYPE_I32),
    _STRING(PS_PRIM_TYPE_U64), _STRING(PS_PRIM_TYPE_I64),
    _STRING(PS_PRIM_TYPE_F32), _STRING(PS_PRIM_TYPE_F64),
    _STRING(PS_PRIM_TYPE_B)};
 
bool ps_type_is_prim(enum ps_type_type type) {
    return type >= PS_TYPE_U8 && type <= PS_TYPE_B;
}
 
struct ps_type* ps_type_prim_new(enum ps_type_type prim_type) {
    ps_assert(ps_type_is_prim(prim_type), "precondition");
 
    struct ps_type* type = astalloc(sizeof(*type));
    if (!type) {
        PS_NO_MEMORY();
        return NULL;
    }
 
    type->type = prim_type;
 
    return type;
}
 
struct ps_type* ps_type_struct_new(struct ps_token* name) {
    struct ps_type* type = astalloc(sizeof(*type));
 
    type->type = PS_TYPE_STRUCT;
    type->value.struct_.name = name;
    type->value.struct_.fields = ps_type_field_arr_new();  // leaks
 
    return type;
}
 
void ps_type_struct_add(struct ps_type* type, struct ps_type_field field) {
    ps_assert(type->type == PS_TYPE_STRUCT, "precondition");
    ps_push(&type->value.struct_.fields, field);
}
 
struct ps_type* ps_type_enum_new(struct ps_token* name) {
    struct ps_type* type = astalloc(sizeof(*type));
 
    type->type = PS_TYPE_ENUM;
    type->value.enum_.name = name;
    type->value.enum_.variants = ps_type_variant_arr_new();  // leaks
 
    return type;
}
 
void ps_type_enum_add(struct ps_type* type, struct ps_type_variant variant) {
    ps_assert(type->type == PS_TYPE_ENUM, "precondition");
    ps_push(&type->value.enum_.variants, variant);
}
 
struct ps_type* ps_type_unresolved_new(struct ps_token* name) {
    struct ps_type* type = astalloc(sizeof(*type));
 
    type->type = PS_TYPE_UNRESOLVED;
    type->value.unresolved = name;
 
    return type;
}
 
struct ps_type* ps_type_from_name(struct ps_token* name) {
    ps_assert(name->type == PS_TOKEN_ID, "type name should be an identifer");
    for (usize i = 0; i < lengthof(prim_type_names); i++) {
        if (strcmp(prim_type_names[i], name->start) == 0) {
            return ps_type_prim_new((enum ps_type_type)i);
        }
    }
    return ps_type_unresolved_new(name);
}
 
struct ps_type* ps_type_from_tuple(struct ps_type_tuple* tuple) {
    struct ps_type* type = astalloc(sizeof(*type));
 
    type->type = PS_TYPE_TUPLE;
    type->value.tuple = tuple;
 
    return type;
}
 
PS_PRINT_IMPL(ps_type, {
    switch (self->type) {
        case PS_TYPE_U8: {
            fputs(_STRING(PS_PRIM_TYPE_U8), stdout);
            break;
        }
        case PS_TYPE_I8: {
            fputs(_STRING(PS_PRIM_TYPE_I8), stdout);
            break;
        }
        case PS_TYPE_U16: {
            fputs(_STRING(PS_PRIM_TYPE_U16), stdout);
            break;
        }
        case PS_TYPE_I16: {
            fputs(_STRING(PS_PRIM_TYPE_I16), stdout);
            break;
        }
        case PS_TYPE_U32: {
            fputs(_STRING(PS_PRIM_TYPE_U32), stdout);
            break;
        }
        case PS_TYPE_I32: {
            fputs(_STRING(PS_PRIM_TYPE_I32), stdout);
            break;
        }
        case PS_TYPE_U64: {
            fputs(_STRING(PS_PRIM_TYPE_U64), stdout);
            break;
        }
        case PS_TYPE_I64: {
            fputs(_STRING(PS_PRIM_TYPE_I64), stdout);
            break;
        }
        case PS_TYPE_F32: {
            fputs(_STRING(PS_PRIM_TYPE_F32), stdout);
            break;
        }
        case PS_TYPE_F64: {
            fputs(_STRING(PS_PRIM_TYPE_F64), stdout);
            break;
        }
        case PS_TYPE_B: {
            fputs(_STRING(PS_PRIM_TYPE_B), stdout);
            break;
        }
        case PS_TYPE_TUPLE: {
            ps_type_tuple_print(self->value.tuple, 0);
            break;
        }
        case PS_TYPE_STRUCT: {
            ps_type_struct_print(&self->value.struct_, 0, 0);
            break;
        }
        case PS_TYPE_ENUM: {
            ps_type_enum_print(&self->value.enum_, 0, 0);
            break;
        }
        case PS_TYPE_UNRESOLVED: {
            printf("%s", self->value.unresolved->start);
            break;
        }
        default: {
            ps_abort("unknown type encountered");
            break;
        }
    }
})
 
PS_PRINT_IMPL(ps_type_tuple, {
    printf("(");
    for (usize i = 0; i < self->length; i++) {
        ps_type_print(self->contents[i], 0);
        if (i < self->length - 1) {
            printf(", ");
        }
    }
    printf(")");
})
 
PS_PRINT_IMPL(ps_type_variant, {
    printf("%s", self->name);
    ps_type_tuple_print(self->args, 0);
})
 
PS_IPRINT_IMPL(ps_type_struct, {
    ps_print_indent();
    printf("struct %.*s {\n", (int)self->name->length, self->name->start);
    for (usize i = 0; i < self->fields->length; i++) {
        ps_type_field_print(&$arr(self->fields)[i], 0, ps_next_indent());
        printf("\n");
    }
    ps_print_indent();
    printf("}");
})
 
PS_IPRINT_IMPL(ps_type_enum, {
    ps_print_indent();
    printf("enum %.*s {\n", (int)self->name->length, self->name->start);
    for (usize i = 0; i < self->variants->length; i++) {
        ps_type_variant_print(&$arr(self->variants)[i], 0);
        printf("\n");
    }
    ps_print_indent();
    printf("}");
})
 
PS_IPRINT_IMPL(ps_type_field, {
    ps_print_indent();
    printf("%s: ", self->name);
    ps_type_print(self->type, 0);
})
 
PS_PRINT_IMPL(ps_type_field_arr, {
    printf("(");
    for (usize i = 0; i < self->length; i++) {
        if (i) printf(", ");
        ps_type_field_print(&self->contents[i], 0, 0);
    }
    printf(")");
})