ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-08-08 23:08:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

eval2: simplify expression parsing info, allow child reversal (for parsing non-canonical expression orders into canonical shapes, e.g. Rust-style casts like 123 as float32 -> cast(float32, 123); ptr/array type operators, etc./

Browse Source
This commit is contained in:
Ryan Fleury
2026-06-26 13:20:38 -07:00
parent 60b266a1cc
commit f1f654ecfd
8 changed files with 421 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project.4coder
+1 -1
View File
@@ -49,7 +49,7 @@ commands =
// .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
// .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg debug telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg debug telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
// .f1 = { .win = "raddbg_stable --ipc kill_all && build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f1 = { .win = "raddbg_stable --ipc kill_all && build radbin", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
.f1 = { .win = "raddbg_stable --ipc kill_all && build ryan_scratch no_meta && pushd build && ryan_scratch && popd", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, .f1 = { .win = "raddbg_stable --ipc kill_all && build ryan_scratch && pushd build && ryan_scratch && popd", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
//- rjf: [raddbg wsl] //- rjf: [raddbg wsl]
// .f1 = { .win = "wsl ./build.sh raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, }, // .f1 = { .win = "wsl ./build.sh raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
project.raddbg
+1 -1
View File
@@ -7,7 +7,6 @@ target:
working_directory: "../raddebugger" working_directory: "../raddebugger"
arguments: "--user:C:/devel/raddebugger/build/raddbg_test.user" arguments: "--user:C:/devel/raddebugger/build/raddbg_test.user"
debug_subprocesses: 0 debug_subprocesses: 0
enabled: 1
} }
target: target:
{ {
@@ -67,4 +66,5 @@ target:
{ {
executable: "build/ryan_scratch.exe" executable: "build/ryan_scratch.exe"
working_directory: build working_directory: build
enabled: 1
} }
src/eval2/eval2.c
+121 -232
View File
@@ -1069,211 +1069,6 @@ e2_expr_push_child(Arena *arena, E2_Expr *parent, E2_Expr *expr)
n->v = expr; n->v = expr;
e2_expr_push_child_node(parent, n); e2_expr_push_child_node(parent, n);
} }
#if 0
internal E2_Expr *
e2_expr_const_u64_or_smaller(Arena *arena, U64 u)
{
E2_Expr *e = e2_expr(arena);
{
e->mode = E2_Mode_Value;
e->val.u64 = u;
if(u <= 0x7fffffff)
{
e->op = RDI_EvalOp_ConstU32;
e->type_key = e2_type_key_basic(E2_TypeKind_S32);
}
else if(u <= 0xffffffff)
{
e->op = RDI_EvalOp_ConstU32;
e->type_key = e2_type_key_basic(E2_TypeKind_U32);
}
else if(u <= 0x7fffffffffffffffull)
{
e->op = RDI_EvalOp_ConstU64;
e->type_key = e2_type_key_basic(E2_TypeKind_S64);
}
else if(u <= 0xffffffffffffffffull)
{
e->op = RDI_EvalOp_ConstU64;
e->type_key = e2_type_key_basic(E2_TypeKind_U64);
}
}
return e;
}
internal E2_Expr *
e2_expr_const_f32(Arena *arena, F32 f32)
{
E2_Expr *e = e2_expr(arena);
e->mode = E2_Mode_Value;
e->val.f32 = f32;
e->op = RDI_EvalOp_ConstU32;
e->type_key = e2_type_key_basic(E2_TypeKind_F32);
return e;
}
internal E2_Expr *
e2_expr_const_f64(Arena *arena, F64 f64)
{
E2_Expr *e = e2_expr(arena);
e->mode = E2_Mode_Value;
e->val.f64 = f64;
e->op = RDI_EvalOp_ConstU64;
e->type_key = e2_type_key_basic(E2_TypeKind_F64);
return e;
}
internal E2_Expr *
e2_expr_unary_op(Arena *arena, E2_TypeKey type_key, RDI_EvalOp op, E2_Expr *operand)
{
E2_Expr *e = e2_expr(arena);
e->type_key = type_key;
e->op = op;
e->mode = E2_Mode_Value;
e->val.u512.u8[0] = e2_type_group_from_kind(e2_type_kind_from_key(type_key));
e->val.u512.u8[1] = 8*e2_byte_size_from_type_key(type_key);
e2_expr_push_child(arena, e, operand);
return e;
}
internal E2_Expr *
e2_expr_binary_op(Arena *arena, E2_TypeKey type_key, RDI_EvalOp op, E2_Expr *lhs, E2_Expr *rhs)
{
E2_Expr *e = e2_expr(arena);
E2_TypeKey arith_type_key = type_key;
if(RDI_EvalOp_FirstLogical <= op && op <= RDI_EvalOp_LastLogical)
{
arith_type_key = lhs->type_key;
}
e->type_key = type_key;
e->op = op;
e->mode = E2_Mode_Value;
e->val.u512.u8[0] = e2_type_group_from_kind(e2_type_kind_from_key(arith_type_key));
e->val.u512.u8[1] = 8*e2_byte_size_from_type_key(arith_type_key);
e2_expr_push_child(arena, e, lhs);
e2_expr_push_child(arena, e, rhs);
return e;
}
internal E2_Expr *
e2_expr_resolve_to_value(Arena *arena, E2_Expr *expr)
{
E2_Expr *result = expr;
// rjf: address evaluations of arrays -> create value of pointer to first element
if(expr->mode == E2_Mode_Address && e2_type_kind_from_key(e2_type_key_undecorate(expr->type_key)) == E2_TypeKind_Array)
{
result = e2_expr(arena);
result->type_key = e2_type_key_direct(e2_type_key_undecorate(expr->type_key));
result->mode = E2_Mode_Value;
e2_expr_push_child(arena, result, expr);
}
// rjf: address evaluations -> read value from space
else if(expr->mode == E2_Mode_Address)
{
U64 memread_byte_size = e2_byte_size_from_type_key(expr->type_key);
memread_byte_size = Min(64, memread_byte_size);
E2_Expr *memread_expr = e2_expr(arena);
memread_expr->op = RDI_EvalOp_MemRead;
memread_expr->mode = E2_Mode_Value;
memread_expr->type_key = expr->type_key;
memread_expr->val.u64 = memread_byte_size;
e2_expr_push_child(arena, memread_expr, expr);
result = memread_expr;
}
// rjf: bitfields -> shift & mask
E2_TypeKey core_type_key = e2_type_key_undecorate(expr->type_key);
if(e2_type_kind_from_key(core_type_key) == E2_TypeKind_Bitfield)
{
// rjf: unpack bitfield params
U64 shift = e2_shift_from_type_key(result->type_key);
U64 mask_count = e2_mask_count_from_type_key(result->type_key);
U64 valid_bits_mask = 0;
for EachIndex(idx, mask_count)
{
valid_bits_mask |= (1ull<<idx);
}
// rjf: mask(shift(expr, count), bitmask)
E2_Expr *shift_expr = e2_expr_binary_op(arena, e2_type_key_basic(E2_TypeKind_U64), RDI_EvalOp_RShift, result, e2_expr_const_u64_or_smaller(arena, shift));
E2_Expr *mask_expr = e2_expr_binary_op(arena, e2_type_key_direct(core_type_key), RDI_EvalOp_BitAnd, shift_expr, e2_expr_const_u64_or_smaller(arena, valid_bits_mask));
result = mask_expr;
}
return result;
}
internal E2_Expr *
e2_expr_truncate(Arena *arena, E2_Expr *expr, E2_TypeKey dst_type_key)
{
E2_Expr *result = expr;
E2_TypeKind dst_type_kind = e2_type_kind_from_key(dst_type_key);
U64 dst_type_byte_size = e2_byte_size_from_type_key(dst_type_key);
B32 dst_type_is_signed = e2_type_kind_is_signed(dst_type_kind);
if(dst_type_byte_size < 64)
{
result = e2_expr(arena);
result->type_key = dst_type_key;
result->op = dst_type_is_signed ? RDI_EvalOp_TruncSigned : RDI_EvalOp_Trunc;
result->val.u64 = dst_type_byte_size*8;
e2_expr_push_child(arena, result, expr);
}
return result;
}
internal E2_Expr *
e2_expr_convert_if_possible(Arena *arena, E2_Expr *expr, E2_TypeKey dst_type_key)
{
E2_Expr *result = expr;
{
// rjf: unpack src / dst types
E2_TypeKey src_type_key = expr->type_key;
E2_TypeKind src_type_kind = e2_type_kind_from_key(src_type_key);
E2_TypeKind dst_type_kind = e2_type_kind_from_key(dst_type_key);
RDI_EvalTypeGroup src_type_group = e2_type_group_from_kind(src_type_kind);
RDI_EvalTypeGroup dst_type_group = e2_type_group_from_kind(dst_type_kind);
U64 src_byte_size = e2_byte_size_from_type_key(src_type_key);
U64 dst_byte_size = e2_byte_size_from_type_key(dst_type_key);
// rjf: convert from src -> dst
RDI_EvalConversionKind conversion_kind = rdi_eval_conversion_kind_from_typegroups(src_type_group, dst_type_group);
if(conversion_kind == RDI_EvalConversionKind_Legal)
{
result = e2_expr(arena);
result->mode = E2_Mode_Value;
result->type_key = dst_type_key;
result->op = RDI_EvalOp_Convert;
result->val.u64 = src_type_group | (dst_type_group << 8);
e2_expr_push_child(arena, result, expr);
}
// rjf: no-op from src -> dst
if(conversion_kind == RDI_EvalConversionKind_Noop)
{
result->type_key = dst_type_key;
}
// rjf: if shrinking integer sizes, truncate
if(dst_byte_size < src_byte_size && e2_type_kind_is_integer(dst_type_kind))
{
result = e2_expr_truncate(arena, expr, dst_type_key);
}
}
return result;
}
internal E2_Expr *
e2_expr_type(Arena *arena, E2_TypeKey type_key)
{
E2_Expr *expr = e2_expr(arena);
expr->type_key = type_key;
expr->mode = E2_Mode_Type;
return expr;
}
#endif
//////////////////////////////// ////////////////////////////////
//~ rjf: Expression Constructors //~ rjf: Expression Constructors
@@ -1801,7 +1596,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
for EachIndex(idx, lang_info->expr_kind_parse_infos_count) for EachIndex(idx, lang_info->expr_kind_parse_infos_count)
{ {
if(lang_info->expr_kind_parse_infos[idx].parse_kind == E2_ExprParseKind_UnaryPrefix && if(lang_info->expr_kind_parse_infos[idx].parse_kind == E2_ExprParseKind_Prefix &&
lang_info->expr_kind_parse_infos[idx].precedence <= max_precedence && lang_info->expr_kind_parse_infos[idx].precedence <= max_precedence &&
str8_match(token_string, lang_info->expr_kind_parse_infos[idx].pre, 0)) str8_match(token_string, lang_info->expr_kind_parse_infos[idx].pre, 0))
{ {
@@ -1826,11 +1621,11 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
task = push_array_no_zero(arena, E2_ParseTask, 1); task = push_array_no_zero(arena, E2_ParseTask, 1);
} }
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = e2_expr_kind_target_operand_count_table[expr_kind];
task->expr_kind = expr_kind; task->expr_kind = expr_kind;
task->max_precedence = precedence; task->max_precedence = precedence;
task->expected_closer = closer; task->expected_closer = closer;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
} }
@@ -1878,7 +1673,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
} }
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = e2_expr_kind_target_operand_count_table[E2_ExprKind_Define];
task->expr_kind = E2_ExprKind_Define; task->expr_kind = E2_ExprKind_Define;
task->max_precedence = max_S64; task->max_precedence = max_S64;
task->identifier = identifier; task->identifier = identifier;
@@ -1923,7 +1718,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
} }
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = e2_expr_kind_target_operand_count_table[E2_ExprKind_Macro];
task->expr_kind = E2_ExprKind_Macro; task->expr_kind = E2_ExprKind_Macro;
task->max_precedence = max_S64; task->max_precedence = max_S64;
task->identifier = identifier; task->identifier = identifier;
@@ -1963,7 +1758,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
for EachIndex(idx, lang_info->expr_kind_parse_infos_count) for EachIndex(idx, lang_info->expr_kind_parse_infos_count)
{ {
if(lang_info->expr_kind_parse_infos[idx].parse_kind == E2_ExprParseKind_UnaryPrefix && if(lang_info->expr_kind_parse_infos[idx].parse_kind == E2_ExprParseKind_Prefix &&
lang_info->expr_kind_parse_infos[idx].precedence <= max_precedence && lang_info->expr_kind_parse_infos[idx].precedence <= max_precedence &&
str8_match(token_string, str8_skip_chop_whitespace(lang_info->expr_kind_parse_infos[idx].pre), 0)) str8_match(token_string, str8_skip_chop_whitespace(lang_info->expr_kind_parse_infos[idx].pre), 0))
{ {
@@ -1989,7 +1784,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
} }
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = e2_expr_kind_target_operand_count_table[expr_kind];
task->expr_kind = expr_kind; task->expr_kind = expr_kind;
task->max_precedence = precedence; task->max_precedence = precedence;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
@@ -2067,12 +1862,55 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
expr->string = raw_string; expr->string = raw_string;
} }
//- rjf: extend parsed expression tree with trailing operators //- rjf: extend parsed expression tree with completed trailing type operators (right-to-left)
if(!state->caller_info_completes_task && expr != &e2_expr_nil) if(!state->caller_info_completes_task && expr != &e2_expr_nil)
{ {
U64 trailing_symbol_off = off; U64 trailing_symbol_off = off;
if(e2_try_token(lang, string, E2_TokenKind_Symbol, s(""), &trailing_symbol_off, &token)) if(e2_try_token(lang, string, E2_TokenKind_Symbol, s(""), &trailing_symbol_off, &token))
{ {
B32 is_expr_type = (expr->kind == E2_ExprKind_TypeIdentifier ||
expr->kind == E2_ExprKind_Ptr ||
(state->top_task != 0 && state->top_task->expr_kind == E2_ExprKind_Cast));
if(is_expr_type)
{
// rjf: token string -> operator kind
E2_ExprKind expr_kind = E2_ExprKind_Null;
{
String8 token_string = str8_substr(string, token.range);
for EachIndex(idx, lang_info->expr_kind_parse_infos_count)
{
E2_ExprKindParseInfo *op_info = &lang_info->expr_kind_parse_infos[idx];
if(e2_expr_kind_is_type_expr_table[op_info->expr_kind] &&
str8_match(op_info->post, token_string, 0))
{
expr_kind = op_info->expr_kind;
break;
}
}
}
// rjf: got an expression kind -> build new operator node
if(expr_kind != E2_ExprKind_Null)
{
E2_Expr *op_expr = e2_expr(arena, expr_kind);
e2_expr_push_child(arena, op_expr, expr);
expr = op_expr;
off = trailing_symbol_off;
}
}
}
}
//- rjf: extend parsed expression tree with trailing operators
if(!state->caller_info_completes_task && expr != &e2_expr_nil)
{
U64 trailing_symbol_off = off;
if(e2_try_token(lang, string, E2_TokenKind_Symbol, s(""), &trailing_symbol_off, &token) ||
e2_try_token(lang, string, E2_TokenKind_Identifier, s(""), &trailing_symbol_off, &token))
{
// rjf: determine if the expression is a type
B32 expr_is_type = e2_expr_kind_is_type_expr_table[expr->kind];
// rjf: token string -> operator kind // rjf: token string -> operator kind
E2_ExprKind expr_kind = E2_ExprKind_Null; E2_ExprKind expr_kind = E2_ExprKind_Null;
U64 child_count_target = 2; U64 child_count_target = 2;
@@ -2080,24 +1918,22 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
String8 closer = {0}; String8 closer = {0};
B32 splitter_is_required = 0; B32 splitter_is_required = 0;
S64 precedence = 0; S64 precedence = 0;
B32 reverse_children = 0;
{ {
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
for EachIndex(idx, lang_info->expr_kind_parse_infos_count) for EachIndex(idx, lang_info->expr_kind_parse_infos_count)
{ {
E2_ExprKindParseInfo *expr_kind_info = &lang_info->expr_kind_parse_infos[idx]; E2_ExprKindParseInfo *expr_kind_info = &lang_info->expr_kind_parse_infos[idx];
if(expr_kind_info->precedence <= max_precedence && str8_match(token_string, expr_kind_info->sep, 0)) if(expr_kind_info->precedence <= max_precedence &&
str8_match(token_string, expr_kind_info->sep, 0) &&
(!!expr_is_type == !!e2_expr_kind_is_type_expr_table[expr_kind_info->expr_kind]))
{ {
switch(expr_kind_info->parse_kind)
{
default:{}break;
case E2_ExprParseKind_Binary: {child_count_target = 2;}break;
case E2_ExprParseKind_Ternary: {child_count_target = 3; splitter_is_required = 1;}break;
case E2_ExprParseKind_Call: {child_count_target = max_U64;}break;
}
splitter = expr_kind_info->chain; splitter = expr_kind_info->chain;
closer = expr_kind_info->post; closer = expr_kind_info->post;
expr_kind = expr_kind_info->expr_kind; expr_kind = expr_kind_info->expr_kind;
precedence = expr_kind_info->precedence; precedence = expr_kind_info->precedence;
reverse_children = expr_kind_info->reverse_children;
child_count_target = e2_expr_kind_target_operand_count_table[expr_kind];
break; break;
} }
} }
@@ -2120,6 +1956,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
task->child_count = 0; task->child_count = 0;
task->child_count_target = child_count_target; task->child_count_target = child_count_target;
task->expr_kind = expr_kind; task->expr_kind = expr_kind;
task->reverse_children = reverse_children;
task->max_precedence = precedence; task->max_precedence = precedence;
task->expected_splitter = splitter; task->expected_splitter = splitter;
task->expected_closer = closer; task->expected_closer = closer;
@@ -2141,7 +1978,14 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
if(!state->caller_info_completes_task) if(!state->caller_info_completes_task)
{ {
E2_ExprNode *n = push_array(arena, E2_ExprNode, 1); E2_ExprNode *n = push_array(arena, E2_ExprNode, 1);
SLLQueuePush(state->top_task->first_child, state->top_task->last_child, n); if(state->top_task->reverse_children)
{
SLLQueuePushFront(state->top_task->first_child, state->top_task->last_child, n);
}
else
{
SLLQueuePush(state->top_task->first_child, state->top_task->last_child, n);
}
n->v = expr; n->v = expr;
state->top_task->child_count += 1; state->top_task->child_count += 1;
} }
@@ -2165,9 +2009,19 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
closer_found = e2_try_token(lang, string, E2_TokenKind_Symbol, state->top_task->expected_closer, &off, 0); closer_found = e2_try_token(lang, string, E2_TokenKind_Symbol, state->top_task->expected_closer, &off, 0);
} }
//- rjf: determine if the task above a parenthesized sub-expression is expecting a type
B32 parent_looking_for_type = 0;
if(state->top_task->next != 0 &&
state->top_task->next->expr_kind != E2_ExprKind_Null &&
state->top_task->next->child_count == 0 &&
e2_expr_kind_is_first_operand_type_maybe_table[state->top_task->next->expr_kind])
{
parent_looking_for_type = 1;
}
//- rjf: determine if first child of a parenthesized sub-expression is a type //- rjf: determine if first child of a parenthesized sub-expression is a type
B32 parenthesized_child_is_type = 0; B32 parenthesized_child_is_type = 0;
if(closer_found && state->top_task->child_count == 1) if(!parent_looking_for_type && closer_found && state->top_task->child_count == 1)
{ {
E2_Expr *expr = state->top_task->first_child->v; E2_Expr *expr = state->top_task->first_child->v;
parenthesized_child_is_type = 1; parenthesized_child_is_type = 1;
@@ -2193,7 +2047,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
//- rjf: closer found, completed child count == 1 & completed child is a //- rjf: closer found, completed child count == 1 & completed child is a
// type evaluation - then this is cast. push a task to fill the operand // type evaluation - then this is cast. push a task to fill the operand
B32 is_cast = parenthesized_child_is_type; B32 is_cast = parenthesized_child_is_type;
if(is_cast) if(!parent_looking_for_type && is_cast)
{ {
// rjf: pop the sub-task for the type expression // rjf: pop the sub-task for the type expression
E2_Expr *type_expr = state->top_task->first_child->v; E2_Expr *type_expr = state->top_task->first_child->v;
@@ -2217,8 +2071,8 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = type_expr->src_range; task->src_range = type_expr->src_range;
task->child_count = 1; task->child_count = 1;
task->child_count_target = 2; task->child_count_target = e2_expr_kind_target_operand_count_table[E2_ExprKind_Cast];
task->expr_kind = E2_ExprKind_CCast; task->expr_kind = E2_ExprKind_Cast;
task->max_precedence = 1; task->max_precedence = 1;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
expr = &e2_expr_nil; expr = &e2_expr_nil;
@@ -2319,11 +2173,12 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, B32 identifier_is_type,
{ {
if(lang_info->expr_kind_parse_infos[idx].expr_kind == t->expr_kind) if(lang_info->expr_kind_parse_infos[idx].expr_kind == t->expr_kind)
{ {
if(lang_info->expr_kind_parse_infos[idx].parse_kind == E2_ExprParseKind_Binary) U64 target_operand_count = e2_expr_kind_target_operand_count_table[t->expr_kind];
if(target_operand_count == 2)
{ {
symbol = lang_info->expr_kind_parse_infos[idx].sep; symbol = lang_info->expr_kind_parse_infos[idx].sep;
} }
else if(lang_info->expr_kind_parse_infos[idx].parse_kind == E2_ExprParseKind_UnaryPrefix) else if(target_operand_count == 1)
{ {
symbol = lang_info->expr_kind_parse_infos[idx].pre; symbol = lang_info->expr_kind_parse_infos[idx].pre;
} }
@@ -2468,6 +2323,35 @@ e2_compile_from_expr(Arena *arena, E2_CompileState *state, E2_IRNode *resolve_re
} }
}break; }break;
//- rjf: pointer type operators
case E2_ExprKind_Ptr:
{
Arch arch = state->selected_ctx.arch;
E2_TypeKey ptee_type_key = lhs->type_key;
E2_TypeKey ptr_type_key = e2_type_key_cons_ptr(arch, ptee_type_key);
finished_root = e2_irnode(arena);
finished_root->type_key = ptr_type_key;
}break;
//- rjf: array type operator
case E2_ExprKind_Array:
{
if(state->caller_request_count == 0)
{
done = 1;
compile.status = E2_CompileStatus_CompileTimeEval;
compile.irtree = rhs;
}
else
{
U64 array_count = compile_time_eval_result.u64;
E2_TypeKey element_type_key = lhs->type_key;
E2_TypeKey array_type_key = e2_type_key_cons_array(element_type_key, array_count);
finished_root = e2_irnode(arena);
finished_root->type_key = array_type_key;
}
}break;
//- rjf: leaf numerics //- rjf: leaf numerics
case E2_ExprKind_Numeric: case E2_ExprKind_Numeric:
{ {
@@ -2652,7 +2536,7 @@ e2_compile_from_expr(Arena *arena, E2_CompileState *state, E2_IRNode *resolve_re
}break; }break;
//- rjf: casts //- rjf: casts
case E2_ExprKind_CCast: case E2_ExprKind_Cast:
cast:; cast:;
{ {
E2_IRNode *cast_type_ir = lhs; E2_IRNode *cast_type_ir = lhs;
@@ -2661,6 +2545,11 @@ e2_compile_from_expr(Arena *arena, E2_CompileState *state, E2_IRNode *resolve_re
{ {
e2_msgf(arena, &compile.msgs, e->src_range, "Cannot cast to this type."); e2_msgf(arena, &compile.msgs, e->src_range, "Cannot cast to this type.");
} }
else if(e2_type_kind_is_ptr_or_ref(e2_type_kind_from_key(cast_type_key)))
{
finished_root = rhs;
rhs->mode = E2_Mode_Address;
}
else else
{ {
E2_IRNode *castee_ir = rhs; E2_IRNode *castee_ir = rhs;
src/eval2/eval2.h
+5 -16
View File
@@ -10,11 +10,8 @@
typedef enum E2_ExprParseKind typedef enum E2_ExprParseKind
{ {
E2_ExprParseKind_Null, E2_ExprParseKind_Null,
E2_ExprParseKind_UnaryPrefix, E2_ExprParseKind_Prefix,
E2_ExprParseKind_UnaryPostfix, E2_ExprParseKind_Postfix,
E2_ExprParseKind_Binary,
E2_ExprParseKind_Ternary,
E2_ExprParseKind_Call,
} }
E2_ExprParseKind; E2_ExprParseKind;
@@ -67,6 +64,7 @@ typedef enum E2_CompileStatus
//- rjf: caller-provided info //- rjf: caller-provided info
E2_CompileStatus_MissedIdentifierResolution, E2_CompileStatus_MissedIdentifierResolution,
E2_CompileStatus_NewIdentifierDefinition, E2_CompileStatus_NewIdentifierDefinition,
E2_CompileStatus_NewCtxID,
E2_CompileStatus_MemberAccess, E2_CompileStatus_MemberAccess,
E2_CompileStatus_IndexAccess, E2_CompileStatus_IndexAccess,
E2_CompileStatus_Call, E2_CompileStatus_Call,
@@ -345,6 +343,7 @@ struct E2_ParseTask
E2_ExprNode *last_child; E2_ExprNode *last_child;
U64 child_count; U64 child_count;
U64 child_count_target; U64 child_count_target;
B32 reverse_children;
S64 max_precedence; S64 max_precedence;
E2_ExprKind expr_kind; E2_ExprKind expr_kind;
String8 identifier; String8 identifier;
@@ -448,6 +447,7 @@ struct E2_CompileState
E2_CompileTask *top_task; E2_CompileTask *top_task;
E2_CompileTask *free_task; E2_CompileTask *free_task;
U64 caller_request_count; U64 caller_request_count;
E2_Ctx selected_ctx;
}; };
typedef struct E2_Compile E2_Compile; typedef struct E2_Compile E2_Compile;
@@ -632,17 +632,6 @@ internal E2_TypeKey e2_coerced_type_key_from_operands(E2_TypeKey lhs, E2_TypeKey
internal E2_Expr *e2_expr(Arena *arena, E2_ExprKind kind); internal E2_Expr *e2_expr(Arena *arena, E2_ExprKind kind);
internal void e2_expr_push_child_node(E2_Expr *parent, E2_ExprNode *node); internal void e2_expr_push_child_node(E2_Expr *parent, E2_ExprNode *node);
internal void e2_expr_push_child(Arena *arena, E2_Expr *parent, E2_Expr *expr); internal void e2_expr_push_child(Arena *arena, E2_Expr *parent, E2_Expr *expr);
#if 0
internal E2_Expr *e2_expr_const_u64_or_smaller(Arena *arena, U64 u);
internal E2_Expr *e2_expr_const_f32(Arena *arena, F32 f32);
internal E2_Expr *e2_expr_const_f64(Arena *arena, F64 f64);
internal E2_Expr *e2_expr_unary_op(Arena *arena, E2_TypeKey type_key, RDI_EvalOp op, E2_Expr *operand);
internal E2_Expr *e2_expr_binary_op(Arena *arena, E2_TypeKey type_key, RDI_EvalOp op, E2_Expr *lhs, E2_Expr *rhs);
internal E2_Expr *e2_expr_resolve_to_value(Arena *arena, E2_Expr *expr);
internal E2_Expr *e2_expr_truncate(Arena *arena, E2_Expr *expr, E2_TypeKey dst_type_key);
internal E2_Expr *e2_expr_convert_if_possible(Arena *arena, E2_Expr *expr, E2_TypeKey dst_type_key);
internal E2_Expr *e2_expr_type(Arena *arena, E2_TypeKey type_key);
#endif
//////////////////////////////// ////////////////////////////////
//~ rjf: IR Tree Constructors //~ rjf: IR Tree Constructors
src/eval2/eval2.mdesk
+101 -78
View File
@@ -1,50 +1,51 @@
// Copyright (c) Epic Games Tools // Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/) // Licensed under the MIT license (https://opensource.org/license/mit/)
@table(name) @table(name is_type_expression is_first_operand_type_maybe target_operand_count)
E2_ExprKindTable: E2_ExprKindTable:
{ {
{Identifier} {Identifier 0 0 0 }
{MacroArg} {MacroArg 0 0 0 }
{TypeIdentifier} {TypeIdentifier 1 0 0 }
{Numeric} {Ptr 1 1 1 }
{StringLiteral} {Array 1 1 2 }
{CharLiteral} {Numeric 0 0 0 }
{Dot} {StringLiteral 0 0 0 }
{Index} {CharLiteral 0 0 0 }
{Call} {Dot 0 0 1 }
{DerefAsm} {Index 0 0 2 }
{SizeOf} {Call 0 0 0xffffffffffffffffull}
{TypeOf} {DerefAsm 0 0 1 }
{CCast} {SizeOf 0 1 1 }
{Deref} {TypeOf 1 1 1 }
{Address} {Cast 0 1 2 }
{Pos} {Deref 0 0 1 }
{Neg} {Address 0 0 1 }
{LogNot} {Pos 0 0 1 }
{BitNot} {Neg 0 0 1 }
{Ptr} {LogNot 0 0 1 }
{Mul} {BitNot 0 0 1 }
{Div} {Mul 0 0 2 }
{Mod} {Div 0 0 2 }
{Add} {Mod 0 0 2 }
{Sub} {Add 0 0 2 }
{LShift} {Sub 0 0 2 }
{RShift} {LShift 0 0 2 }
{Less} {RShift 0 0 2 }
{LtEq} {Less 0 0 2 }
{Grtr} {LtEq 0 0 2 }
{GrEq} {Grtr 0 0 2 }
{EqEq} {GrEq 0 0 2 }
{NtEq} {EqEq 0 0 2 }
{BitAnd} {NtEq 0 0 2 }
{BitXor} {BitAnd 0 0 2 }
{BitOr} {BitXor 0 0 2 }
{LogAnd} {BitOr 0 0 2 }
{LogOr} {LogAnd 0 0 2 }
{Define} {LogOr 0 0 2 }
{Macro} {Define 0 0 1 }
{Cond} {Macro 0 0 1 }
{Cond 0 0 3 }
} }
@enum E2_ExprKind: @enum E2_ExprKind:
@@ -54,11 +55,30 @@ E2_ExprKindTable:
COUNT, COUNT,
} }
@data(B8) e2_expr_kind_is_type_expr_table:
{
0,
@expand(E2_ExprKindTable a) `$(a.is_type_expression)`
}
@data(B8) e2_expr_kind_is_first_operand_type_maybe_table:
{
0,
@expand(E2_ExprKindTable a) `$(a.is_first_operand_type_maybe)`
}
@data(U64) e2_expr_kind_target_operand_count_table:
{
0,
@expand(E2_ExprKindTable a) `$(a.target_operand_count)`
}
@struct E2_ExprKindParseInfo: @struct E2_ExprKindParseInfo:
{ {
`E2_ExprKind expr_kind`; `E2_ExprKind expr_kind`;
`E2_ExprParseKind parse_kind`; `E2_ExprParseKind parse_kind`;
`S64 precedence`; `S64 precedence`;
`B8 reverse_children`;
`String8 pre`; `String8 pre`;
`String8 sep`; `String8 sep`;
`String8 post`; `String8 post`;
@@ -87,48 +107,51 @@ E2_LangKindTable:
@expand(E2_LangKindTable a) `{ArrayCount(e2_expr_kind_parse_info_table__$(a.name_lower)), (e2_expr_kind_parse_info_table__$(a.name_lower))}` @expand(E2_LangKindTable a) `{ArrayCount(e2_expr_kind_parse_info_table__$(a.name_lower)), (e2_expr_kind_parse_info_table__$(a.name_lower))}`
} }
@table(name parse_kind precedence pre sep pos chain) @table(name parse_kind precedence pre sep pos chain reverse_children)
E2_ExprKindParseInfoTable_CLike: E2_ExprKindParseInfoTable_CLike:
{ {
{Index Binary 1 "" "[" "]" "" } {Index Postfix 1 "" "[" "]" "" 0}
{Call Call 1 "" "(" ")" ","} {Call Postfix 1 "" "(" ")" "," 0}
{DerefAsm UnaryPrefix 1 "[" "" "]" "" } {DerefAsm Prefix 1 "[" "" "]" "" 0}
{SizeOf UnaryPrefix 1 "sizeof " "" "" "" } {SizeOf Prefix 1 "sizeof " "" "" "" 0}
{TypeOf UnaryPrefix 1 "typeof " "" "" "" } {TypeOf Prefix 1 "typeof " "" "" "" 0}
{SizeOf UnaryPrefix 1 "size_of " "" "" "" } {SizeOf Prefix 1 "size_of " "" "" "" 0}
{TypeOf UnaryPrefix 1 "type_of " "" "" "" } {TypeOf Prefix 1 "type_of " "" "" "" 0}
{CCast UnaryPrefix 1 "" "" "" "" } {Cast Prefix 1 "" "" "" "" 0}
{Deref UnaryPrefix 2 "*" "" "" "" } {Deref Prefix 2 "*" "" "" "" 0}
{Address UnaryPrefix 2 "&" "" "" "" } {Address Prefix 2 "&" "" "" "" 0}
{Pos UnaryPrefix 2 "+" "" "" "" } {Pos Prefix 2 "+" "" "" "" 0}
{Neg UnaryPrefix 2 "-" "" "" "" } {Neg Prefix 2 "-" "" "" "" 0}
{LogNot UnaryPrefix 2 "!" "" "" "" } {LogNot Prefix 2 "!" "" "" "" 0}
{BitNot UnaryPrefix 2 "~" "" "" "" } {BitNot Prefix 2 "~" "" "" "" 0}
{Ptr UnaryPostfix 1 "" "" "*" "" } {Cast Prefix 1 "cast " "" "" "" 0}
{Mul Binary 3 "" "*" "" "" } {Cast Postfix 1 "" "as" "" "" 1}
{Div Binary 3 "" "/" "" "" } {Ptr Postfix 1 "" "" "*" "" 0}
{Mod Binary 3 "" "%" "" "" } {Array Postfix 1 "" "[" "]" "" 0}
{Add Binary 4 "" "+" "" "" } {Mul Postfix 3 "" "*" "" "" 0}
{Sub Binary 4 "" "-" "" "" } {Div Postfix 3 "" "/" "" "" 0}
{LShift Binary 5 "" "<<" "" "" } {Mod Postfix 3 "" "%" "" "" 0}
{RShift Binary 5 "" ">>" "" "" } {Add Postfix 4 "" "+" "" "" 0}
{Less Binary 6 "" "<" "" "" } {Sub Postfix 4 "" "-" "" "" 0}
{LtEq Binary 6 "" "<=" "" "" } {LShift Postfix 5 "" "<<" "" "" 0}
{Grtr Binary 6 "" ">" "" "" } {RShift Postfix 5 "" ">>" "" "" 0}
{GrEq Binary 6 "" ">=" "" "" } {Less Postfix 6 "" "<" "" "" 0}
{EqEq Binary 7 "" "==" "" "" } {LtEq Postfix 6 "" "<=" "" "" 0}
{NtEq Binary 7 "" "!=" "" "" } {Grtr Postfix 6 "" ">" "" "" 0}
{BitAnd Binary 8 "" "&" "" "" } {GrEq Postfix 6 "" ">=" "" "" 0}
{BitXor Binary 9 "" "^" "" "" } {EqEq Postfix 7 "" "==" "" "" 0}
{BitOr Binary 10 "" "|" "" "" } {NtEq Postfix 7 "" "!=" "" "" 0}
{LogAnd Binary 11 "" "&&" "" "" } {BitAnd Postfix 8 "" "&" "" "" 0}
{LogOr Binary 12 "" "||" "" "" } {BitXor Postfix 9 "" "^" "" "" 0}
{Cond Ternary 14 "" "?" "" ":"} {BitOr Postfix 10 "" "|" "" "" 0}
{LogAnd Postfix 11 "" "&&" "" "" 0}
{LogOr Postfix 12 "" "||" "" "" 0}
{Cond Postfix 14 "" "?" "" ":" 0}
} }
@data(E2_ExprKindParseInfo) e2_expr_kind_parse_info_table__clike: @data(E2_ExprKindParseInfo) e2_expr_kind_parse_info_table__clike:
{ {
@expand(E2_ExprKindParseInfoTable_CLike a) `{E2_ExprKind_$(a.name), E2_ExprParseKind_$(a.parse_kind), $(a.precedence), str8_lit_comp("$(a.pre)"), str8_lit_comp("$(a.sep)"), str8_lit_comp("$(a.pos)"), str8_lit_comp("$(a.chain)")}` @expand(E2_ExprKindParseInfoTable_CLike a) `{E2_ExprKind_$(a.name), E2_ExprParseKind_$(a.parse_kind), $(a.precedence), $(a.reverse_children), str8_lit_comp("$(a.pre)"), str8_lit_comp("$(a.sep)"), str8_lit_comp("$(a.pos)"), str8_lit_comp("$(a.chain)")}`
} }
@table(name basic_string basic_byte_size) @table(name basic_string basic_byte_size)
src/eval2/generated/eval2.meta.c
+179 -35
View File
@@ -4,47 +4,191 @@
//- GENERATED CODE //- GENERATED CODE
C_LINKAGE_BEGIN C_LINKAGE_BEGIN
B8 e2_expr_kind_is_type_expr_table[43] =
{
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
B8 e2_expr_kind_is_first_operand_type_maybe_table[43] =
{
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
U64 e2_expr_kind_target_operand_count_table[43] =
{
0,
0,
0,
0,
1,
2,
0,
0,
0,
1,
2,
0xffffffffffffffffull,
1,
1,
1,
2,
1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
2,
1,
1,
3,
};
E2_LangInfo e2_lang_kind_info_table[1] = E2_LangInfo e2_lang_kind_info_table[1] =
{ {
{ArrayCount(e2_expr_kind_parse_info_table__clike), (e2_expr_kind_parse_info_table__clike)}, {ArrayCount(e2_expr_kind_parse_info_table__clike), (e2_expr_kind_parse_info_table__clike)},
}; };
E2_ExprKindParseInfo e2_expr_kind_parse_info_table__clike[34] = E2_ExprKindParseInfo e2_expr_kind_parse_info_table__clike[37] =
{ {
{E2_ExprKind_Index, E2_ExprParseKind_Binary, 1, str8_lit_comp(""), str8_lit_comp("["), str8_lit_comp("]"), str8_lit_comp("")}, {E2_ExprKind_Index, E2_ExprParseKind_Postfix, 1, 0, str8_lit_comp(""), str8_lit_comp("["), str8_lit_comp("]"), str8_lit_comp("")},
{E2_ExprKind_Call, E2_ExprParseKind_Call, 1, str8_lit_comp(""), str8_lit_comp("("), str8_lit_comp(")"), str8_lit_comp(",")}, {E2_ExprKind_Call, E2_ExprParseKind_Postfix, 1, 0, str8_lit_comp(""), str8_lit_comp("("), str8_lit_comp(")"), str8_lit_comp(",")},
{E2_ExprKind_DerefAsm, E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("["), str8_lit_comp(""), str8_lit_comp("]"), str8_lit_comp("")}, {E2_ExprKind_DerefAsm, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp("["), str8_lit_comp(""), str8_lit_comp("]"), str8_lit_comp("")},
{E2_ExprKind_SizeOf, E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("sizeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_SizeOf, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp("sizeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_TypeOf, E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("typeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_TypeOf, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp("typeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_SizeOf, E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("size_of "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_SizeOf, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp("size_of "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_TypeOf, E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("type_of "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_TypeOf, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp("type_of "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_CCast, E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Cast, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Deref, E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Deref, E2_ExprParseKind_Prefix, 2, 0, str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Address, E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Address, E2_ExprParseKind_Prefix, 2, 0, str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Pos, E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Pos, E2_ExprParseKind_Prefix, 2, 0, str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Neg, E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Neg, E2_ExprParseKind_Prefix, 2, 0, str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LogNot, E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("!"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_LogNot, E2_ExprParseKind_Prefix, 2, 0, str8_lit_comp("!"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_BitNot, E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("~"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_BitNot, E2_ExprParseKind_Prefix, 2, 0, str8_lit_comp("~"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Ptr, E2_ExprParseKind_UnaryPostfix, 1, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("*"), str8_lit_comp("")}, {E2_ExprKind_Cast, E2_ExprParseKind_Prefix, 1, 0, str8_lit_comp("cast "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Mul, E2_ExprParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Cast, E2_ExprParseKind_Postfix, 1, 1, str8_lit_comp(""), str8_lit_comp("as"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Div, E2_ExprParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("/"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Ptr, E2_ExprParseKind_Postfix, 1, 0, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("*"), str8_lit_comp("")},
{E2_ExprKind_Mod, E2_ExprParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("%"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Array, E2_ExprParseKind_Postfix, 1, 0, str8_lit_comp(""), str8_lit_comp("["), str8_lit_comp("]"), str8_lit_comp("")},
{E2_ExprKind_Add, E2_ExprParseKind_Binary, 4, str8_lit_comp(""), str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Mul, E2_ExprParseKind_Postfix, 3, 0, str8_lit_comp(""), str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Sub, E2_ExprParseKind_Binary, 4, str8_lit_comp(""), str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Div, E2_ExprParseKind_Postfix, 3, 0, str8_lit_comp(""), str8_lit_comp("/"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LShift, E2_ExprParseKind_Binary, 5, str8_lit_comp(""), str8_lit_comp("<<"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Mod, E2_ExprParseKind_Postfix, 3, 0, str8_lit_comp(""), str8_lit_comp("%"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_RShift, E2_ExprParseKind_Binary, 5, str8_lit_comp(""), str8_lit_comp(">>"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Add, E2_ExprParseKind_Postfix, 4, 0, str8_lit_comp(""), str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Less, E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp("<"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Sub, E2_ExprParseKind_Postfix, 4, 0, str8_lit_comp(""), str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LtEq, E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp("<="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_LShift, E2_ExprParseKind_Postfix, 5, 0, str8_lit_comp(""), str8_lit_comp("<<"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Grtr, E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp(">"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_RShift, E2_ExprParseKind_Postfix, 5, 0, str8_lit_comp(""), str8_lit_comp(">>"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_GrEq, E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp(">="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Less, E2_ExprParseKind_Postfix, 6, 0, str8_lit_comp(""), str8_lit_comp("<"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_EqEq, E2_ExprParseKind_Binary, 7, str8_lit_comp(""), str8_lit_comp("=="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_LtEq, E2_ExprParseKind_Postfix, 6, 0, str8_lit_comp(""), str8_lit_comp("<="), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_NtEq, E2_ExprParseKind_Binary, 7, str8_lit_comp(""), str8_lit_comp("!="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_Grtr, E2_ExprParseKind_Postfix, 6, 0, str8_lit_comp(""), str8_lit_comp(">"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_BitAnd, E2_ExprParseKind_Binary, 8, str8_lit_comp(""), str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_GrEq, E2_ExprParseKind_Postfix, 6, 0, str8_lit_comp(""), str8_lit_comp(">="), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_BitXor, E2_ExprParseKind_Binary, 9, str8_lit_comp(""), str8_lit_comp("^"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_EqEq, E2_ExprParseKind_Postfix, 7, 0, str8_lit_comp(""), str8_lit_comp("=="), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_BitOr, E2_ExprParseKind_Binary, 10, str8_lit_comp(""), str8_lit_comp("|"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_NtEq, E2_ExprParseKind_Postfix, 7, 0, str8_lit_comp(""), str8_lit_comp("!="), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LogAnd, E2_ExprParseKind_Binary, 11, str8_lit_comp(""), str8_lit_comp("&&"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_BitAnd, E2_ExprParseKind_Postfix, 8, 0, str8_lit_comp(""), str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LogOr, E2_ExprParseKind_Binary, 12, str8_lit_comp(""), str8_lit_comp("||"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprKind_BitXor, E2_ExprParseKind_Postfix, 9, 0, str8_lit_comp(""), str8_lit_comp("^"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Cond, E2_ExprParseKind_Ternary, 14, str8_lit_comp(""), str8_lit_comp("?"), str8_lit_comp(""), str8_lit_comp(":")}, {E2_ExprKind_BitOr, E2_ExprParseKind_Postfix, 10, 0, str8_lit_comp(""), str8_lit_comp("|"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LogAnd, E2_ExprParseKind_Postfix, 11, 0, str8_lit_comp(""), str8_lit_comp("&&"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_LogOr, E2_ExprParseKind_Postfix, 12, 0, str8_lit_comp(""), str8_lit_comp("||"), str8_lit_comp(""), str8_lit_comp("")},
{E2_ExprKind_Cond, E2_ExprParseKind_Postfix, 14, 0, str8_lit_comp(""), str8_lit_comp("?"), str8_lit_comp(""), str8_lit_comp(":")},
}; };
U8 e2_type_kind_basic_byte_size_table[61] = U8 e2_type_kind_basic_byte_size_table[61] =
src/eval2/generated/eval2.meta.h
+8 -3
View File
@@ -12,6 +12,8 @@ E2_ExprKind_Null,
E2_ExprKind_Identifier, E2_ExprKind_Identifier,
E2_ExprKind_MacroArg, E2_ExprKind_MacroArg,
E2_ExprKind_TypeIdentifier, E2_ExprKind_TypeIdentifier,
E2_ExprKind_Ptr,
E2_ExprKind_Array,
E2_ExprKind_Numeric, E2_ExprKind_Numeric,
E2_ExprKind_StringLiteral, E2_ExprKind_StringLiteral,
E2_ExprKind_CharLiteral, E2_ExprKind_CharLiteral,
@@ -21,14 +23,13 @@ E2_ExprKind_Call,
E2_ExprKind_DerefAsm, E2_ExprKind_DerefAsm,
E2_ExprKind_SizeOf, E2_ExprKind_SizeOf,
E2_ExprKind_TypeOf, E2_ExprKind_TypeOf,
E2_ExprKind_CCast, E2_ExprKind_Cast,
E2_ExprKind_Deref, E2_ExprKind_Deref,
E2_ExprKind_Address, E2_ExprKind_Address,
E2_ExprKind_Pos, E2_ExprKind_Pos,
E2_ExprKind_Neg, E2_ExprKind_Neg,
E2_ExprKind_LogNot, E2_ExprKind_LogNot,
E2_ExprKind_BitNot, E2_ExprKind_BitNot,
E2_ExprKind_Ptr,
E2_ExprKind_Mul, E2_ExprKind_Mul,
E2_ExprKind_Div, E2_ExprKind_Div,
E2_ExprKind_Mod, E2_ExprKind_Mod,
@@ -142,6 +143,7 @@ struct E2_ExprKindParseInfo
E2_ExprKind expr_kind; E2_ExprKind expr_kind;
E2_ExprParseKind parse_kind; E2_ExprParseKind parse_kind;
S64 precedence; S64 precedence;
B8 reverse_children;
String8 pre; String8 pre;
String8 sep; String8 sep;
String8 post; String8 post;
@@ -156,8 +158,11 @@ E2_ExprKindParseInfo *expr_kind_parse_infos;
}; };
C_LINKAGE_BEGIN C_LINKAGE_BEGIN
extern B8 e2_expr_kind_is_type_expr_table[43];
extern B8 e2_expr_kind_is_first_operand_type_maybe_table[43];
extern U64 e2_expr_kind_target_operand_count_table[43];
extern E2_LangInfo e2_lang_kind_info_table[1]; extern E2_LangInfo e2_lang_kind_info_table[1];
extern E2_ExprKindParseInfo e2_expr_kind_parse_info_table__clike[34]; extern E2_ExprKindParseInfo e2_expr_kind_parse_info_table__clike[37];
extern U8 e2_type_kind_basic_byte_size_table[61]; extern U8 e2_type_kind_basic_byte_size_table[61];
extern String8 e2_type_kind_basic_string_table[61]; extern String8 e2_type_kind_basic_string_table[61];
src/scratch/ryan_scratch.c
+5
View File
@@ -43,6 +43,11 @@ entry_point(CmdLine *cmdline)
// (A) // (A)
// int & B // int & B
// (1 + (int)&B) // (1 + (int)&B)
s("int32[100]"),
s("123 as float32"),
s("cast float32 123"),
s("cast (float32) 123"),
s("(int32 *)123"),
s("bar(a, b) = a + b"), s("bar(a, b) = a + b"),
s("123, 456"), s("123, 456"),
s("int32 == int32"), s("int32 == int32"),