tree.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-only
 
#pragma once
 
#include "core/text.h"
 
#include "cthulhu/tree/context.h"
#include "cthulhu/tree/attrib.h"
#include "cthulhu/tree/cookie.h"
 
#include <stdbool.h>
#include <gmp.h>
 
typedef struct logger_t logger_t;
 
typedef struct vector_t vector_t;
typedef struct map_t map_t;
typedef struct node_t node_t;
 
typedef struct tree_t tree_t;
typedef struct tree_cookie_t tree_cookie_t;
typedef struct diagnostic_t diagnostic_t;
 
CT_BEGIN_API
 
 
typedef void (*tree_resolve_t)(tree_t *sema, tree_t *self, void *user);
typedef void (*tree_resolve_type_t)(tree_t *sema, tree_t *self, void *user);
 
typedef enum sema_tags_t {
    // all the values in this scope
    eSemaValues,
 
    // all the types in this scope
    eSemaTypes,
 
    // all the procedures in this scope
    eSemaProcs,
 
    // all the modules in this scope
    eSemaModules,
 
    eSemaCount
} sema_tags_t;
 
typedef struct tree_attribs_t {
    tree_linkage_t link; 
    tree_visibility_t visibility; 
 
    const char *mangle; 
    const char *section; 
    const char *deprecated; 
} tree_attribs_t;
 
typedef struct tree_resolve_info_t {
    tree_t *sema;
    void *user;
 
    tree_resolve_t fn_resolve;
    tree_resolve_type_t fn_resolve_type;
} tree_resolve_info_t;
 
typedef struct tree_t {
    tree_kind_t kind;
    const node_t *node;
    const tree_t *type;
    tree_attribs_t *attribs;
 
    union {
        /* eTreeDigit */
        mpz_t digit_value;
 
        /* eTreeBool */
        bool bool_value;
 
        /* eTreeString */
        text_view_t string_value;
 
        /* eTreeExprLoad */
        tree_t *load;
 
        /* eTreeExprRef */
        struct {
            const tree_t *expr;
 
            /* eTreeExprCast */
            tree_cast_t cast;
        };
 
        /* eTreeExprUnary */
        struct {
            unary_t unary;
            tree_t *operand;
        };
 
        /* eTreeExprBinary, eTreeExprCompare */
        struct {
            union {
                binary_t binary;
                compare_t compare;
            };
 
            const tree_t *lhs;
            const tree_t *rhs;
        };
 
        /* eTreeExprCall */
        struct {
            const tree_t *callee;
            const vector_t *args;
        };
 
        /* eTreeError */
        struct {
            const diagnostic_t *diagnostic;
            const char *message;
        };
 
        /* eTreeStmtBlock */
        const vector_t *stmts;
 
        /* eTreeStmtReturn */
        const tree_t *value;
 
        /* eTreeStmtAssign */
        struct {
            tree_t *dst;
            const tree_t *src;
            bool init;
        };
 
        /* eTreeStmtLoop, eTreeStmtBranch */
        struct {
            tree_t *cond;
            tree_t *then;
            tree_t *other;
        };
 
        struct {
            /* eTreeExprSizeOf, eTreeExprAlignOf */
            const tree_t *object;
            struct {
                /* eTreeExprOffset */
                const tree_t *offset;
 
                /* eTreeExprField, eTreeExprOffsetOf */
                const tree_t *field;
            };
        };
 
        /* eTreeStmtJump */
        struct {
            tree_t *label;
            tree_jump_t jump;
        };
 
        /* any declaration */
        struct {
            const char *name; 
            const tree_attribs_t *attrib; 
            const tree_resolve_info_t *resolve; 
            tree_quals_t quals;
            eval_model_t eval_model;
 
            union {
                /* eTreeTypePointer, eTreeTypeReference, eTreeTypeArray */
                struct {
                    const tree_t *ptr;
                    const tree_t *len;
                    size_t length;
                };
 
                /* eTreeTypeDigit */
                struct {
                    digit_t digit;
                    sign_t sign;
                };
 
                /* eTreeTypeStruct */
                vector_t *fields;
 
                /* eTreeDeclEnum */
                struct {
                    const tree_t *underlying;
                    vector_t *cases;
                    tree_t *default_case;
                };
 
                /* eTreeDeclCase */
                tree_t *case_value;
 
                struct {
                    const vector_t *params;
 
                    union {
                        /* eTreeDeclFunction */
                        struct {
                            vector_t *locals;
                            tree_t *body;
                        };
 
                        /* eTreeTypeClosure */
                        struct {
                            const tree_t *return_type;
                            tree_arity_t arity;
                        };
                    };
                };
 
                /* eTreeDeclGlobal, eTreeDeclLocal */
                struct {
                    tree_storage_t storage;
 
                    tree_t *initial;
                };
 
                /* eTreeDeclModule */
                struct {
                    arena_t *arena;
                    tree_t *parent;
                    tree_cookie_t *cookie;
 
                    logger_t *reports;
                    vector_t *tags; 
                };
            };
        };
    };
} tree_t;
 
 
CT_TREE_API tree_t *tree_error(const node_t *node, const diagnostic_t *diagnostic, const char *message, ...);
CT_TREE_API tree_t *tree_raise(const node_t *node, logger_t *reports, const diagnostic_t *diagnostic, const char *message, ...);
CT_TREE_API void tree_report(logger_t *reports, const tree_t *error);
 
 
CT_TREE_API tree_t *tree_type_empty(const node_t *node, const char *name);
 
CT_TREE_API tree_t *tree_type_unit(const node_t *node, const char *name);
 
CT_TREE_API tree_t *tree_type_bool(const node_t *node, const char *name);
 
CT_TREE_API tree_t *tree_type_opaque(const node_t *node, const char *name);
 
CT_TREE_API tree_t *tree_type_digit(const node_t *node, const char *name, digit_t digit, sign_t sign);
 
CT_TREE_API tree_t *tree_type_closure(const node_t *node, const char *name, const tree_t *result, const vector_t *params, tree_arity_t arity);
 
CT_TREE_API tree_t *tree_type_pointer(const node_t *node, const char *name, const tree_t *pointer, size_t length);
 
CT_TREE_API tree_t *tree_type_reference(const node_t *node, const char *name, const tree_t *reference);
 
CT_TREE_API tree_t *tree_type_array(const node_t *node, const char *name, const tree_t *array, size_t length);
 
 
CT_TREE_API tree_t *tree_expr_empty(const node_t *node, const tree_t *type);
CT_TREE_API tree_t *tree_expr_unit(const node_t *node, const tree_t *type);
CT_TREE_API tree_t *tree_expr_bool(const node_t *node, const tree_t *type, bool value);
CT_TREE_API tree_t *tree_expr_digit(const node_t *node, const tree_t *type, const mpz_t value);
CT_TREE_API tree_t *tree_expr_digit_int(const node_t *node, const tree_t *type, int value);
 
CT_TREE_API tree_t *tree_expr_string(const node_t *node, const tree_t *type, const char *value, size_t length);
 
CT_TREE_API tree_t *tree_expr_cast(const node_t *node, const tree_t *type, const tree_t *expr, tree_cast_t cast);
 
CT_TREE_API tree_t *tree_expr_load(const node_t *node, tree_t *expr);
 
CT_TREE_API tree_t *tree_expr_address(const node_t *node, tree_t *expr);
 
CT_TREE_API tree_t *tree_expr_unary(const node_t *node, unary_t unary, tree_t *expr);
CT_TREE_API tree_t *tree_expr_binary(const node_t *node, const tree_t *type, binary_t binary, const tree_t *lhs, const tree_t *rhs);
CT_TREE_API tree_t *tree_expr_compare(const node_t *node, const tree_t *type, compare_t compare, const tree_t *lhs, const tree_t *rhs);
 
CT_TREE_API tree_t *tree_expr_field(const node_t *node, const tree_t *type, tree_t *object, tree_t *field);
 
CT_TREE_API tree_t *tree_expr_offset(const node_t *node, const tree_t *type, tree_t *object, tree_t *offset);
 
CT_TREE_API tree_t *tree_expr_call(const node_t *node, const tree_t *callee, const vector_t *args);
 
 
CT_TREE_API tree_t *tree_stmt_block(const node_t *node, const vector_t *stmts);
 
CT_TREE_API tree_t *tree_stmt_return(const node_t *node, const tree_t *value);
 
CT_TREE_API tree_t *tree_stmt_assign(const node_t *node, tree_t *dst, const tree_t *src);
CT_TREE_API tree_t *tree_stmt_init(const node_t *node, tree_t *dst, tree_t *src);
CT_TREE_API tree_t *tree_stmt_loop(const node_t *node, tree_t *cond, tree_t *body, tree_t *other);
CT_TREE_API tree_t *tree_stmt_branch(const node_t *node, tree_t *cond, tree_t *then, tree_t *other);
CT_TREE_API tree_t *tree_stmt_jump(const node_t *node, tree_t *label, tree_jump_t jump);
 
 
// delay the resolve of a declaration
CT_TREE_API tree_t *tree_resolve(tree_cookie_t *cookie, const tree_t *decl);
CT_TREE_API tree_t *tree_resolve_type(tree_cookie_t *cookie, const tree_t *decl);
 
CT_TREE_API tree_t *tree_open_decl(const node_t *node, const char *name, tree_resolve_info_t resolve);
CT_TREE_API void tree_close_decl(tree_t *self, const tree_t *other);
 
 
CT_TREE_API tree_t *tree_decl_global(
    const node_t *node, const char *name,
    tree_storage_t storage, const tree_t *type, tree_t *initial
);
 
CT_TREE_API tree_t *tree_open_global(
    const node_t *node, const char *name,
    const tree_t *type, tree_resolve_info_t resolve
);
 
CT_TREE_API void tree_close_global(tree_t *self, tree_t *value);
 
 
CT_TREE_API tree_t *tree_decl_function(
    const node_t *node, const char *name, const tree_t *signature,
    const vector_t *params, vector_t *locals, tree_t *body
);
 
CT_TREE_API tree_t *tree_open_function(
    const node_t *node, const char *name,
    const tree_t *signature, tree_resolve_info_t resolve
);
 
CT_TREE_API void tree_close_function(tree_t *self, tree_t *body);
 
 
CT_TREE_API tree_t *tree_decl_struct(const node_t *node, const char *name, vector_t *fields);
CT_TREE_API tree_t *tree_open_struct(const node_t *node, const char *name, tree_resolve_info_t resolve);
CT_TREE_API void tree_close_struct(tree_t *self, vector_t *fields);
 
 
CT_TREE_API tree_t *tree_decl_union(const node_t *node, const char *name, vector_t *fields);
CT_TREE_API tree_t *tree_open_union(const node_t *node, const char *name, tree_resolve_info_t resolve);
CT_TREE_API void tree_close_union(tree_t *self, vector_t *fields);
 
 
CT_TREE_API tree_t *tree_decl_enum(const node_t *node, const char *name, const tree_t *underlying, vector_t *fields, tree_t *default_case);
CT_TREE_API tree_t *tree_open_enum(const node_t *node, const char *name, tree_resolve_info_t resolve);
CT_TREE_API void tree_close_enum(tree_t *self, const tree_t *underlying, vector_t *fields, tree_t *default_case);
 
 
CT_TREE_API tree_t *tree_decl_param(const node_t *node, const char *name, const tree_t *type);
CT_TREE_API tree_t *tree_decl_field(const node_t *node, const char *name, const tree_t *type);
CT_TREE_API tree_t *tree_decl_local(const node_t *node, const char *name, tree_storage_t storage, const tree_t *type);
CT_TREE_API tree_t *tree_decl_case(const node_t *node, const char *name, const tree_t *type, tree_t *expr);
 
 
CT_TREE_API void tree_add_local(tree_t *self, tree_t *decl);
CT_TREE_API void tree_add_enum(tree_t *self, tree_t *decl);
CT_TREE_API void tree_set_attrib(tree_t *self, const tree_attribs_t *attrib);
CT_TREE_API void tree_set_type(tree_t *self, const tree_t *type);
 
CT_TREE_API tree_t *tree_alias(const tree_t *tree, const char *name);
 
CT_TREE_API tree_t *tree_type_alias(const node_t *node, const char *name, const tree_t *type, tree_quals_t quals);
 
CT_TREE_API const tree_t *tree_follow_type(const tree_t *type);
 
 
// only declarations placed in the tags eSemaValues, eSemaTypes, eSemaProcs, and eSemaModules
// will be emitted, they are also required to be valid tree_t objects
// any custom slots can contain any data, but they will not be emitted
 
CT_TREE_API tree_t *tree_module_root(logger_t *reports, tree_cookie_t *cookie, const node_t *node, const char *name, size_t decls, const size_t *sizes, arena_t *arena);
 
CT_TREE_API tree_t *tree_module(tree_t *parent, const node_t *node, const char *name, size_t decls, const size_t *sizes);
 
CT_TREE_API void *tree_module_get(tree_t *self, size_t tag, const char *name);
 
 
CT_TREE_API void *tree_module_find(tree_t *sema, size_t tag, const char *name, tree_t **module);
 
CT_TREE_API void *tree_module_set(tree_t *self, size_t tag, const char *name, void *value);
 
CT_TREE_API map_t *tree_module_tag(const tree_t *self, size_t tag);
 
CT_TREE_API tree_cookie_t *tree_get_cookie(tree_t *sema);
 
 
CT_END_API