parser.h

Go to the documentation of this file.

 
#pragma once
 
#include <stddef.h>
 
#include "../ast/ast.h"
#include "../c_libs/memory/memory.h"
#include "../helper/help.h"
#include "../lexer/lexer.h"
 
#define CURRENT_TOKEN_LENGTH(parser) ((int)p_current(parser).length)
 
#define CURRENT_TOKEN_VALUE(parser) (p_current(parser).value)
 
#define MAX_STMT 1024
#define MAX_EXPR 1024
#define MAX_TYPE 1024
 
typedef enum {
  BP_NONE = 0,    
  BP_LOWEST,      
  BP_ASSIGN,      
  BP_TERNARY,     
  BP_LOGICAL_OR,  
  BP_LOGICAL_AND, 
  BP_BITWISE_OR,  
  BP_BITWISE_XOR, 
  BP_BITWISE_AND, 
  BP_EQUALITY,    
  BP_RELATIONAL,  
  BP_RANGE,       
  BP_SHIFT,       
  BP_SUM,         
  BP_PRODUCT,     
  BP_EXPONENT,    
  BP_UNARY,       
  BP_POSTFIX,     
  BP_CALL,        
  BP_PRIMARY      
} BindingPower;
 
static const LiteralType PRIMARY_LITERAL_TYPE_MAP[] = {
    [TOK_NUMBER] = LITERAL_INT,       [TOK_NUM_FLOAT] = LITERAL_FLOAT,
    [TOK_STRING] = LITERAL_STRING,    [TOK_CHAR_LITERAL] = LITERAL_CHAR,
    [TOK_TRUE] = LITERAL_BOOL,        [TOK_FALSE] = LITERAL_BOOL,
    [TOK_IDENTIFIER] = LITERAL_IDENT,
};
 
static const BinaryOp TOKEN_TO_BINOP_MAP[] = {
    [TOK_PLUS] = BINOP_ADD,        [TOK_MINUS] = BINOP_SUB,
    [TOK_STAR] = BINOP_MUL,        [TOK_SLASH] = BINOP_DIV,
    [TOK_EQEQ] = BINOP_EQ,         [TOK_NEQ] = BINOP_NE,
    [TOK_LT] = BINOP_LT,           [TOK_LE] = BINOP_LE,
    [TOK_GT] = BINOP_GT,           [TOK_GE] = BINOP_GE,
    [TOK_AND] = BINOP_AND,         [TOK_OR] = BINOP_OR,
    [TOK_AMP] = BINOP_BIT_AND,     [TOK_PIPE] = BINOP_BIT_OR,
    [TOK_CARET] = BINOP_BIT_XOR,   [TOK_RANGE] = BINOP_RANGE,
    [TOK_MODL] = BINOP_MOD,        [TOK_SHIFT_LEFT] = BINOP_SHL,
    [TOK_SHIFT_RIGHT] = BINOP_SHR,
};
 
static const UnaryOp TOKEN_TO_UNOP_MAP[] = {
    [TOK_BANG] = UNOP_NOT,         [TOK_TILDE] = UNOP_BIT_NOT,
    [TOK_PLUS] = UNOP_POS,         [TOK_MINUS] = UNOP_NEG,
    [TOK_PLUSPLUS] = UNOP_PRE_INC, [TOK_MINUSMINUS] = UNOP_PRE_DEC,
};
 
typedef struct {
  const char *file_path;
  ArenaAllocator *arena;
  Token *tks;
  size_t tk_count;
  size_t capacity;
  size_t pos;
  char *pending_doc_comment; // NEW: Doc comment waiting to be attached
} Parser;
 
void parser_error(Parser *psr, const char *error_type, const char *file,
                  const char *msg, int line, int col, int tk_length);
 
char *collect_doc_comments(Parser *parser);
void consume_doc_comments(Parser *parser);
bool p_has_tokens(Parser *psr);
Token p_peek(Parser *psr, size_t offset);
Token p_current(Parser *psr);
Token p_advance(Parser *psr);
Token p_consume(Parser *psr, LumaTokenType type, const char *error_msg);
char *get_name(Parser *psr);
 
Stmt *parse(GrowableArray *tks, ArenaAllocator *arena, BuildConfig *config);
Expr *parse_expr(Parser *parser, BindingPower bp);
Stmt *parse_stmt(Parser *parser);
Type *parse_type(Parser *parser);
 
// Helper functions for the parser
bool init_parser_arrays(Parser *parser, GrowableArray *stmts,
                        GrowableArray *modules);
const char *parse_module_declaration(Parser *parser, char **out_module_doc);
 
Expr *nud(Parser *parser);
 
Expr *led(Parser *parser, Expr *left, BindingPower bp);
BindingPower get_bp(LumaTokenType kind);
 
Expr *primary(Parser *parser);
Expr *unary(Parser *parser);
Expr *grouping(Parser *parser);
Expr *binary(Parser *parser, Expr *left, BindingPower bp);
Expr *call_expr(Parser *parser, Expr *left, BindingPower bp);
Expr *assign_expr(Parser *parser, Expr *left, BindingPower bp);
Expr *prefix_expr(Parser *parser, Expr *left, BindingPower bp);
Expr *array_expr(Parser *parser);
Expr *index_expr(Parser *parser);
// pointer and memory related
Expr *deref_expr(Parser *parser);
Expr *addr_expr(Parser *parser);
Expr *alloc_expr(Parser *parser);
Expr *free_expr(Parser *parser);
Expr *cast_expr(Parser *parser);
Expr *input_expr(Parser *parser);
Expr *system_expr(Parser *parser);
Expr *syscall_expr(Parser *parser);
Expr *sizeof_expr(Parser *parser);
Expr *struct_expr(Parser *parser);
Expr *named_struct_expr(Parser *parser, Expr *left, BindingPower bp);
 
Type *tnud(Parser *parser);
Type *tled(Parser *parser, Type *left, BindingPower bp);
BindingPower tget_bp(Parser *parser, LumaTokenType kind);
 
Type *pointer(Parser *parser);
Type *array_type(Parser *parser);
Type *function_type(Parser *parser, Type *return_type);
 
Stmt *use_stmt(Parser *parser);
Stmt *os_stmt(Parser *parser);
Stmt *link_stmt(Parser *parser);
Stmt *expr_stmt(Parser *parser);
Stmt *var_stmt(Parser *parser, bool is_public);
Stmt *const_stmt(Parser *parser, bool is_public, bool returns_ownership,
                 bool takes_ownership);
Stmt *fn_stmt(Parser *parser, const char *name, bool is_public,
              bool is_static, bool returns_ownership, bool takes_ownership);
Stmt *enum_stmt(Parser *parser, const char *name, bool is_public);
Stmt *struct_stmt(Parser *parser, const char *name, bool is_public);
Stmt *print_stmt(Parser *parser, bool ln);
Stmt *return_stmt(Parser *parser);
Stmt *block_stmt(Parser *parser);
Stmt *infinite_loop_stmt(Parser *parser, int line, int col);
Stmt *for_loop_stmt(Parser *parser, int line, int col);
Stmt *loop_stmt(Parser *parser);
Stmt *if_stmt(Parser *parser);
Stmt *break_continue_stmt(Parser *parser, bool is_continue);
Stmt *defer_stmt(Parser *parser);
Stmt *switch_stmt(Parser *parser);
Stmt *impl_stmt(Parser *parser);