ast.h

Go to the documentation of this file.

 
#pragma once
 
#include "def.h"
#include "enum/make.h"
#include "frontend/analyzer/type.h"
#include "frontend/lexer/token.h"
#include "util/dynarr.h"
#include "util/print.h"
 
// TODO: make tuple dynarr
// TODO: add switch statement
 
struct ps_node;
struct ps_expr;
struct ps_node_block;
struct ps_interp_str;
struct ps_expr_arr;
 
struct ps_name ps_dynarr(struct ps_token*);
#define ps_name_new() ps_dynarr_new(struct ps_name)
#define ps_name_free(arr) ps_dynarr_free(arr)
 
PS_PRINT_DECL(ps_name);
 
struct ps_node_let {
    struct ps_token* name;
    bool is_mutable;
    struct ps_type* type;
    struct ps_expr* value;
};
 
enum ps_fn_qualifiers {
    PS_FN_PUBLIC = 1 << 0,   
    PS_FN_PRIVATE = 1 << 1,  
    PS_FN_STATIC = 1 << 2,   
    PS_FN_INLINE = 1 << 3    
};
 
// TODO: add generic stuff (this is also just more general)
struct ps_node_fn {
    struct ps_token* name;
    struct ps_type* ret_type;
    struct ps_type_field_arr* params;
    enum ps_fn_qualifiers qualifiers;
    struct ps_node_block* body;
};
 
struct ps_node_fn_arr ps_dynarr(struct ps_node_fn);
#define ps_node_fn_arr_new() ps_dynarr_new(struct ps_node_fn_arr)
#define ps_node_fn_arr_free(arr) ps_dynarr_free(arr)
 
struct ps_node_import {
    struct ps_name* name;
};
 
struct ps_node_extern {
    struct ps_token* name;      
    struct ps_type_tuple* sig;  
};
 
struct ps_node_expr_stm {
    struct ps_expr* expr;
};
 
struct ps_node_struct {
    struct ps_type_struct* type;
    struct ps_node_fn_arr* methods;
};
 
struct ps_node_enum {
    struct ps_type_enum* type;
    struct ps_node_fn_arr* methods;
};
 
struct ps_node_for {
    struct ps_node_let* init;
    struct ps_expr* cond;
    struct ps_node_expr_stm* step;
    struct ps_node_block* body;
};
 
struct ps_node_while {
    struct ps_expr* cond;
    struct ps_node_block* body;
};
 
struct ps_node_if {
    struct ps_expr* cond;
    struct ps_node_block* body;
    struct ps_node_block* else_body;
};
 
struct ps_node_return {
    struct ps_expr* value;
};
 
struct ps_expr_id {
    struct ps_token* name;
};
 
struct ps_expr_lit {
    enum ps_expr_lit_type {
#define ENUM TO_ENUM
#include "lit_type.h"
#undef ENUM
    } type;
 
    struct ps_token* token;
 
    union ps_expr_lit_value {
        i64 int_val;
        u64 uint_val;
        f64 float_val;
        bool bool_val;
        STR str_val;
        struct ps_interp_str* interp_str_val;
        /* unit literal handled just by being a case in ps_node_lit_expr::type
         */
    } value;
};
 
struct ps_expr_binary {
    struct ps_expr* lhs;
    struct ps_token* op;
    struct ps_expr* rhs;
};
 
struct ps_expr_unary {
    struct ps_token* op;
    struct ps_expr* rhs;
};
 
struct ps_expr_call {
    // TODO: turn this into expr
    // struct ps_expr* callee;
    struct ps_token* callee;
    struct ps_expr_arr* args;
};
 
struct ps_expr {
    enum ps_expr_type {
#define ENUM TO_ENUM
#include "expr_type.h"
#undef ENUM
    } expr_type;
    union {
        struct ps_expr_id id_expr;
        struct ps_expr_lit lit_expr;
        struct ps_expr_binary bin_expr;
        struct ps_expr_unary un_expr;
        struct ps_expr_call call_expr;
    } value;
    struct ps_type* type;
};
 
struct ps_node {
    enum ps_node_type {
#define ENUM TO_ENUM
#include "node_type.h"
#undef ENUM
    } type;
    union {
        struct ps_node_let let;
        struct ps_node_fn fn;
        struct ps_node_import import;
        struct ps_node_extern extern_;
        struct ps_node_expr_stm expr_stm;
        struct ps_node_block* block;
 
        struct ps_node_struct struct_;
        struct ps_node_enum enum_;
        struct ps_node_for for_;
        struct ps_node_while while_;
        struct ps_node_if if_;
        struct ps_node_return return_;
    } value;
};
 
struct ps_node_arr ps_dynarr(struct ps_node*);
#define ps_node_arr_new() ps_dynarr_new(struct ps_node_arr)
#define ps_node_arr_free(arr) ps_dynarr_free(arr)
 
struct ps_node_block ps_dynarr(struct ps_node*);
#define ps_node_block_new() ps_dynarr_new(struct ps_node_block)
#define ps_node_block_free(arr) ps_dynarr_free(arr)
 
struct ps_interp_str ps_dynarr(struct ps_expr*);
#define ps_interp_str_new() ps_dynarr_new(struct ps_interp_str)
#define ps_interp_str_free(arr) ps_dynarr_free(arr)
 
PS_PRINT_DECL(ps_interp_str);
 
struct ps_expr_arr ps_dynarr(struct ps_expr*);
#define ps_expr_arr_new() ps_dynarr_new(struct ps_expr_arr)
#define ps_expr_arr_free(arr) ps_dynarr_free(arr)
 
// nodes
 
struct ps_node* ps_node_let_new(struct ps_token* name, bool is_mutable,
    struct ps_type* type, struct ps_expr* value);
 
struct ps_node* ps_node_fn_new(struct ps_token* name, struct ps_type* ret_type,
    struct ps_type_field_arr* params, enum ps_fn_qualifiers qualifiers,
    struct ps_node_block* body);
 
struct ps_node* ps_node_import_new(struct ps_name* name);
 
struct ps_node* ps_node_extern_new(struct ps_token* name,
    struct ps_type_tuple* sig);
 
struct ps_node* ps_node_expr_stm_new(struct ps_expr* expr);
 
struct ps_node* ps_node_block_stm_new(struct ps_node_block* block);
 
struct ps_node* ps_node_struct_new(struct ps_type_struct* type,
    struct ps_node_fn_arr* methods);
 
struct ps_node* ps_node_enum_new(struct ps_type_enum* type,
    struct ps_node_fn_arr* methods);
 
struct ps_node* ps_node_for_new(struct ps_node_let* init, struct ps_expr* cond,
    struct ps_node_expr_stm* step, struct ps_node_block* body);
 
struct ps_node* ps_node_while_new(struct ps_expr* cond,
    struct ps_node_block* body);
 
struct ps_node* ps_node_if_new(struct ps_expr* cond, struct ps_node_block* body,
    struct ps_node_block* else_body);
 
struct ps_node* ps_node_return_new(struct ps_expr* value);
 
PS_IPRINT_DECL(ps_node_let);
PS_IPRINT_DECL(ps_node_fn);
PS_IPRINT_DECL(ps_node_import);
PS_IPRINT_DECL(ps_node_extern);
PS_IPRINT_DECL(ps_node_expr_stm);
PS_IPRINT_DECL(ps_node_struct);
PS_IPRINT_DECL(ps_node_enum);
PS_IPRINT_DECL(ps_node_for);
PS_IPRINT_DECL(ps_node_while);
PS_IPRINT_DECL(ps_node_if);
PS_IPRINT_DECL(ps_node_return);
PS_IPRINT_DECL(ps_node_block);
PS_IPRINT_DECL(ps_node);
 
// exprs
 
struct ps_expr* ps_expr_id_new(struct ps_token* name);
 
struct ps_expr* ps_expr_lit_new_i64(i64 value, struct ps_token* token);
 
struct ps_expr* ps_expr_lit_new_u64(u64 value, struct ps_token* token);
 
struct ps_expr* ps_expr_lit_new_f64(f64 value, struct ps_token* token);
 
struct ps_expr* ps_expr_lit_new_bool(bool value, struct ps_token* token);
 
struct ps_expr* ps_expr_lit_new_str(STR value, struct ps_token* token);
 
struct ps_expr* ps_expr_lit_new_interp_str(struct ps_interp_str* value);
 
struct ps_expr* ps_expr_lit_new_unit(struct ps_token* token);
 
struct ps_expr* ps_expr_binary_new(struct ps_expr* lhs, struct ps_token* op,
    struct ps_expr* rhs);
 
struct ps_expr* ps_expr_unary_new(struct ps_token* op, struct ps_expr* rhs);
 
struct ps_expr* ps_expr_call_new(struct ps_token* callee,
    struct ps_expr_arr* args);
 
PS_PRINT_DECL(ps_expr_id);
PS_PRINT_DECL(ps_expr_lit);
PS_PRINT_DECL(ps_expr_binary);
PS_PRINT_DECL(ps_expr_unary);
PS_PRINT_DECL(ps_expr_call);
PS_PRINT_DECL(ps_expr);