biner/biner.y

353 lines
9.7 KiB
Plaintext

%{
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "./tree.h"
#include "./zone.h"
#define ctx (biner_tree_parse_context_)
#define alloc_(T) (biner_zone_alloc(&ctx.zone, sizeof(T)))
#define ref(T, p) ((T*) (ctx.zone.ptr+p))
extern char* yytext;
extern int yylex(void);
#define yyerrorf(fmt, ...) \
fprintf(stderr, "[%zu:%zu] "fmt"\n", ctx.line+1, ctx.column+1, __VA_ARGS__)
#define yyerror(msg) \
fprintf(stderr, "[%zu:%zu] "msg"\n", ctx.line+1, ctx.column+1)
static inline bool
unstringify_struct_member_type_name_(
biner_tree_struct_member_type_name_t* name,
biner_zone_ptr(char) str
);
static inline biner_zone_ptr(biner_tree_decl_t)
find_decl_by_name_(
biner_zone_ptr(char) name
);
static inline biner_zone_ptr(biner_tree_struct_member_t)
find_struct_member_by_name_(
biner_zone_ptr(biner_tree_struct_member_t) last_member,
biner_zone_ptr(char) name
);
static inline biner_zone_ptr(biner_tree_struct_member_t)
find_child_struct_member_by_name_(
biner_zone_ptr(biner_tree_struct_member_t) member,
biner_zone_ptr(char) name
);
static inline biner_zone_ptr(biner_tree_struct_member_t)
unwrap_struct_member_ref_(
biner_zone_ptr(biner_tree_struct_member_reference_t) memref
);
static inline biner_zone_ptr(biner_tree_expr_t)
create_operator_(
biner_zone_ptr(biner_tree_expr_t) l,
biner_tree_expr_type_t type,
biner_zone_ptr(biner_tree_expr_t) r
);
static biner_zone_ptr(biner_tree_expr_t)
resolve_constant_(
biner_zone_ptr(char) ident
);
%}
%union {
int64_t i;
uintptr_t ptr;
}
%token STRUCT
%token <ptr> IDENT
%token <i> INTEGER;
%type <ptr> decl_list decl
%type <ptr> struct_member_list struct_member
%type <ptr> struct_member_type array_struct_member_type unqualified_struct_member_type
%type <ptr> expr add_expr mul_expr operand
%start decl_list
%%
decl_list
: decl {
*ref(biner_tree_root_t, ctx.root) = (biner_tree_root_t) {
.decls = $1,
};
$$ = ctx.root;
}
| decl_list decl {
ref(biner_tree_decl_t, $2)->prev = ref(biner_tree_root_t, $1)->decls;
ref(biner_tree_root_t, $1)->decls = $2;
$$ = $1;
}
;
decl
: STRUCT IDENT '{' struct_member_list '}' ';' {
if (find_decl_by_name_($2) != 0) {
yyerrorf("duplicated declaration of '%s'", ref(char, $2));
YYABORT;
}
$$ = alloc_(biner_tree_decl_t);
*ref(biner_tree_decl_t, $$) = (biner_tree_decl_t) {
.name = $2,
.member = $4,
};
ctx.last_decl = $$;
ctx.last_member = 0;
}
;
struct_member_list
: struct_member {
$$ = ctx.last_member = $1;
}
| struct_member_list struct_member {
ref(biner_tree_struct_member_t, $2)->prev = $1;
$$ = ctx.last_member = $2;
}
;
struct_member
: struct_member_type IDENT ';' {
if (find_struct_member_by_name_(ctx.last_member, $2) != 0) {
yyerrorf("duplicated struct member of '%s'", ref(char, $2));
YYABORT;
}
$$ = alloc_(biner_tree_struct_member_t);
*ref(biner_tree_struct_member_t, $$) =
(biner_tree_struct_member_t) {
.type = $1,
.name = $2,
};
}
;
struct_member_type
: array_struct_member_type
| unqualified_struct_member_type
;
array_struct_member_type
: unqualified_struct_member_type '[' expr ']' {
$$ = $1;
biner_tree_struct_member_type_t* t =
ref(biner_tree_struct_member_type_t, $$);
t->expr = $3;
const biner_tree_expr_t* expr = ref(biner_tree_expr_t, $3);
t->qualifier = expr->dynamic?
BINER_TREE_STRUCT_MEMBER_TYPE_QUALIFIER_DYNAMIC_ARRAY:
BINER_TREE_STRUCT_MEMBER_TYPE_QUALIFIER_STATIC_ARRAY;
}
;
unqualified_struct_member_type
: IDENT {
$$ = alloc_(biner_tree_struct_member_type_t);
biner_tree_struct_member_type_t* t =
ref(biner_tree_struct_member_type_t, $$);
*t = (biner_tree_struct_member_type_t) {
.qualifier = BINER_TREE_STRUCT_MEMBER_TYPE_QUALIFIER_NONE,
};
const biner_zone_ptr(biner_tree_decl_t) decl = find_decl_by_name_($1);
if (decl == 0) {
if (!unstringify_struct_member_type_name_(&t->name, $1)) {
yyerrorf("unknown type '%s'", ref(char, $1));
YYABORT;
}
} else {
t->name = BINER_TREE_STRUCT_MEMBER_TYPE_NAME_USER_DECL;
t->decl = decl;
}
}
;
expr
: add_expr { $$ = $1; }
;
add_expr
: mul_expr
| add_expr '+' mul_expr {
$$ = create_operator_($1, BINER_TREE_EXPR_TYPE_OPERATOR_ADD, $3);
}
| add_expr '-' mul_expr {
$$ = create_operator_($1, BINER_TREE_EXPR_TYPE_OPERATOR_SUB, $3);
}
;
mul_expr
: operand
| mul_expr '*' operand {
$$ = create_operator_($1, BINER_TREE_EXPR_TYPE_OPERATOR_MUL, $3);
}
| mul_expr '/' operand {
$$ = create_operator_($1, BINER_TREE_EXPR_TYPE_OPERATOR_DIV, $3);
}
;
operand
: INTEGER {
$$ = alloc_(biner_tree_expr_t);
*ref(biner_tree_expr_t, $$) = (biner_tree_expr_t) {
.type = BINER_TREE_EXPR_TYPE_OPERAND_INTEGER,
.i = $1,
};
}
| IDENT {
const biner_zone_ptr(biner_tree_struct_member_t) m =
find_struct_member_by_name_(ctx.last_member, $1);
if (m != 0) {
biner_zone_ptr(biner_tree_struct_member_reference_t) mref =
alloc_(biner_tree_struct_member_reference_t);
*ref(biner_tree_struct_member_reference_t, mref) =
(biner_tree_struct_member_reference_t) { .member = m, };
$$ = alloc_(biner_tree_expr_t);
*ref(biner_tree_expr_t, $$) = (biner_tree_expr_t) {
.type = BINER_TREE_EXPR_TYPE_OPERAND_REFERENCE,
.dynamic = true,
.r = mref,
};
} else {
$$ = resolve_constant_($1);
if ($$ == 0) {
yyerrorf("unknown member or symbol '%s'", ref(char, $1));
YYABORT;
}
}
}
| operand '.' IDENT {
biner_tree_expr_t* expr = ref(biner_tree_expr_t, $1);
if (expr->type != BINER_TREE_EXPR_TYPE_OPERAND_REFERENCE) {
yyerrorf("refering non-struct's child, '%s'", ref(char, $3));
YYABORT;
}
const biner_zone_ptr(biner_tree_struct_member_t) m =
find_child_struct_member_by_name_(unwrap_struct_member_ref_(expr->r), $3);
if (m == 0) {
yyerrorf("unknown member '%s'", ref(char, $3));
YYABORT;
}
$$ = alloc_(biner_tree_struct_member_reference_t);
*ref(biner_tree_struct_member_reference_t, $$) =
(biner_tree_struct_member_reference_t) {
.member = m,
.prev = expr->r,
};
expr->r = $$;
/* A shared expression such as constant cannot have a reference to member.
* So modification of the expression doesn't cause any side effects.
*/
}
| '(' expr ')' { $$ = $2; }
;
%%
static inline bool unstringify_struct_member_type_name_(
biner_tree_struct_member_type_name_t* name,
biner_zone_ptr(char) str) {
for (size_t i = 0; i < BINER_TREE_STRUCT_MEMBER_TYPE_NAME_MAX_; ++i) {
const char* item = biner_tree_struct_member_type_name_string_map[i];
if (item != NULL && strcmp(ref(char, str), item) == 0) {
*name = (biner_tree_struct_member_type_name_t) i;
return true;
}
}
return false;
}
static inline biner_zone_ptr(biner_tree_decl_t) find_decl_by_name_(
biner_zone_ptr(char) name) {
biner_zone_ptr(biner_tree_decl_t) itr = ctx.last_decl;
while (itr) {
const biner_tree_decl_t* decl = ref(biner_tree_decl_t, itr);
if (strcmp(ref(char, decl->name), ref(char, name)) == 0) return itr;
itr = decl->prev;
}
return 0;
}
static inline biner_zone_ptr(biner_tree_struct_member_t)
find_struct_member_by_name_(
biner_zone_ptr(biner_tree_struct_member_t) last_member,
biner_zone_ptr(char) name) {
biner_zone_ptr(biner_tree_struct_member_t) itr = last_member;
while (itr) {
const biner_tree_struct_member_t* m = ref(biner_tree_struct_member_t, itr);
if (strcmp(ref(char, m->name), ref(char, name)) == 0) return itr;
itr = m->prev;
}
return 0;
}
static inline biner_zone_ptr(biner_tree_struct_member_t)
find_child_struct_member_by_name_(
biner_zone_ptr(biner_tree_struct_member_t) member,
biner_zone_ptr(char) name) {
const biner_tree_struct_member_t* m = ref(biner_tree_struct_member_t, member);
const biner_tree_struct_member_type_t* t =
ref(biner_tree_struct_member_type_t, m->type);
if (t->name != BINER_TREE_STRUCT_MEMBER_TYPE_NAME_USER_DECL) {
yyerrorf("typeof '%s' is not user-defined", ref(char, m->name));
return 0;
}
const biner_tree_decl_t* d = ref(biner_tree_decl_t, t->decl);
if (d->type != BINER_TREE_DECL_TYPE_STRUCT) {
yyerrorf("'%s' (typeof '%s') is not struct",
ref(char, d->name),
ref(char, m->name));
return 0;
}
return find_struct_member_by_name_(d->member, name);
}
static inline biner_zone_ptr(biner_tree_struct_member_t)
unwrap_struct_member_ref_(
biner_zone_ptr(biner_tree_struct_member_reference_t) memref) {
const biner_tree_struct_member_reference_t* r =
ref(biner_tree_struct_member_reference_t, memref);
return r->member;
}
static inline biner_zone_ptr(biner_tree_expr_t) create_operator_(
biner_zone_ptr(biner_tree_expr_t) l,
biner_tree_expr_type_t type,
biner_zone_ptr(biner_tree_expr_t) r) {
const biner_tree_expr_t* lexpr = ref(biner_tree_expr_t, l);
const biner_tree_expr_t* rexpr = ref(biner_tree_expr_t, r);
biner_zone_ptr(biner_tree_expr_t) expr = alloc_(biner_tree_expr_t);
*ref(biner_tree_expr_t, expr) = (biner_tree_expr_t) {
.type = type,
.dynamic = lexpr->dynamic || rexpr->dynamic,
.operands = {l, r},
};
return expr;
}
static inline biner_zone_ptr(biner_tree_expr_t) resolve_constant_(
biner_zone_ptr(char) ident) {
(void) ident;
/* TODO: find out enums and constants */
return 0;
}