From 0dd0f1b8bcfe7188c97613cb4729aacea49a2bad Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Thu, 10 Apr 2025 15:19:29 -0700 Subject: [PATCH] rephrase type irgen hook -> irext, to eliminate cases where it'd be very easy to accidentally cause infinite recursion of ir generation (e.g. slice(x) requiring evaluation of 'lhs.count', where lhs == slice(x)). also bring back slice hooks --- src/eval/eval_core.h | 16 +- src/eval/eval_ir.c | 21 +- src/eval/eval_ir.h | 1 + src/eval/eval_types.c | 192 +++++++++++++++++- src/eval/eval_types.h | 11 +- .../eval_visualization_core.c | 18 +- .../eval_visualization_core.h | 2 +- src/raddbg/raddbg_core.c | 76 ++++--- src/raddbg/raddbg_eval.c | 20 +- src/raddbg/raddbg_eval.h | 8 +- 10 files changed, 297 insertions(+), 68 deletions(-) diff --git a/src/eval/eval_core.h b/src/eval/eval_core.h index 99fd2ea5..a3b7f9de 100644 --- a/src/eval/eval_core.h +++ b/src/eval/eval_core.h @@ -352,6 +352,12 @@ struct E_EnumValArray U64 count; }; +typedef struct E_IRExt E_IRExt; +struct E_IRExt +{ + void *user_data; +}; + typedef struct E_TypeExpandInfo E_TypeExpandInfo; struct E_TypeExpandInfo { @@ -359,10 +365,10 @@ struct E_TypeExpandInfo U64 expr_count; }; -#define E_TYPE_IRGEN_FUNCTION_SIG(name) E_IRTreeAndType name(Arena *arena, E_IRTreeAndType *irtree) -#define E_TYPE_IRGEN_FUNCTION_NAME(name) e_type_irgen__##name -#define E_TYPE_IRGEN_FUNCTION_DEF(name) internal E_TYPE_IRGEN_FUNCTION_SIG(E_TYPE_IRGEN_FUNCTION_NAME(name)) -typedef E_TYPE_IRGEN_FUNCTION_SIG(E_TypeIRGenFunctionType); +#define E_TYPE_IREXT_FUNCTION_SIG(name) E_IRExt name(Arena *arena, E_Expr *expr, E_IRTreeAndType *irtree) +#define E_TYPE_IREXT_FUNCTION_NAME(name) e_type_irext__##name +#define E_TYPE_IREXT_FUNCTION_DEF(name) internal E_TYPE_IREXT_FUNCTION_SIG(E_TYPE_IREXT_FUNCTION_NAME(name)) +typedef E_TYPE_IREXT_FUNCTION_SIG(E_TypeIRExtFunctionType); #define E_TYPE_ACCESS_FUNCTION_SIG(name) E_IRTreeAndType name(Arena *arena, E_Expr *expr, E_IRTreeAndType *lhs_irtree) #define E_TYPE_ACCESS_FUNCTION_NAME(name) e_type_access__##name @@ -415,7 +421,7 @@ struct E_Type E_Member *members; E_EnumVal *enum_vals; E_Expr **args; - E_TypeIRGenFunctionType *irgen; + E_TypeIRExtFunctionType *irext; E_TypeAccessFunctionType *access; E_TypeExpandRule expand; }; diff --git a/src/eval/eval_ir.c b/src/eval/eval_ir.c index 182a469c..fe1b3f28 100644 --- a/src/eval/eval_ir.c +++ b/src/eval/eval_ir.c @@ -2203,7 +2203,10 @@ e_irtree_and_type_from_expr(Arena *arena, E_Expr *root_expr) .count = arg_count, .args = args, .direct_key = result.type_key, - .name = lhs_type->name); + .name = lhs_type->name, + .irext = lhs_type->irext, + .access = lhs_type->access, + .expand = lhs_type->expand); scratch_end(scratch); } @@ -2727,7 +2730,7 @@ e_irtree_and_type_from_expr(Arena *arena, E_Expr *root_expr) { E_Space space = e_space_make(E_SpaceKind_FileSystem); result.root = e_irtree_set_space(arena, space, e_irtree_const_u(arena, e_id_from_string(file_path))); - result.type_key = e_type_key_cons(.kind = E_TypeKind_Set, .name = str8_lit("file")); + result.type_key = e_type_state->file_type_key; result.mode = E_Mode_Value; } else @@ -2738,7 +2741,7 @@ e_irtree_and_type_from_expr(Arena *arena, E_Expr *root_expr) { E_Space space = e_space_make(E_SpaceKind_FileSystem); result.root = e_irtree_set_space(arena, space, e_irtree_const_u(arena, e_id_from_string(folder_path))); - result.type_key = e_type_key_cons(.kind = E_TypeKind_Set, .name = str8_lit("folder")); + result.type_key = e_type_state->folder_type_key; result.mode = E_Mode_Value; } } @@ -2778,9 +2781,15 @@ e_irtree_and_type_from_expr(Arena *arena, E_Expr *root_expr) //- rjf: if the evaluated type has a hook for an extra layer of ir generation, // call into it E_Type *type = e_type_from_key__cached(result.type_key); - if(type->irgen != 0) + if(type->kind != E_TypeKind_LensSpec && type->irext != 0) { - result = type->irgen(arena, &result); + E_IRTreeAndType irtree_stripped = result; + if(type->kind == E_TypeKind_Lens) + { + irtree_stripped.type_key = e_type_direct_from_key(irtree_stripped.type_key); + } + E_IRExt ext = type->irext(arena, expr, &irtree_stripped); + result.user_data = ext.user_data; } //- rjf: find any auto hooks according to this generation's type @@ -2827,7 +2836,7 @@ e_irtree_and_type_from_expr(Arena *arena, E_Expr *root_expr) .name = src_type->name, .count = src_type->count, .args = src_type->args, - .irgen = src_type->irgen, + .irext = src_type->irext, .access = src_type->access, .expand = src_type->expand, .direct_key = result.type_key); diff --git a/src/eval/eval_ir.h b/src/eval/eval_ir.h index dc266067..134f26dc 100644 --- a/src/eval/eval_ir.h +++ b/src/eval/eval_ir.h @@ -229,6 +229,7 @@ internal void e_expr_poison(E_Expr *expr); internal void e_expr_unpoison(E_Expr *expr); //- rjf: top-level irtree/type extraction +E_TYPE_ACCESS_FUNCTION_DEF(default); internal E_IRTreeAndType e_irtree_and_type_from_expr(Arena *arena, E_Expr *expr); //- rjf: irtree -> linear ops/bytecode diff --git a/src/eval/eval_types.c b/src/eval/eval_types.c index 003e05dd..57a3c53e 100644 --- a/src/eval/eval_types.c +++ b/src/eval/eval_types.c @@ -250,7 +250,7 @@ e_select_type_ctx(E_TypeCtx *ctx) e_type_state->type_cache_slots = push_array(e_type_state->arena, E_TypeCacheSlot, e_type_state->type_cache_slots_count); e_type_state->file_type_key = e_type_key_cons(.kind = E_TypeKind_Set, .name = str8_lit("file"), - .irgen = E_TYPE_IRGEN_FUNCTION_NAME(file), + .irext = E_TYPE_IREXT_FUNCTION_NAME(file), .access = E_TYPE_ACCESS_FUNCTION_NAME(file), .expand = { @@ -671,7 +671,7 @@ e_type_from_key(Arena *arena, E_TypeKey key) type->count = node->params.count; type->depth = node->params.depth; type->arch = node->params.arch; - type->irgen = node->params.irgen; + type->irext = node->params.irext; type->access = node->params.access; type->expand = node->params.expand; type->byte_size = node->byte_size; @@ -2313,6 +2313,188 @@ E_TYPE_EXPAND_NUM_FROM_ID_FUNCTION_DEF(identity) return id; } +//////////////////////////////// +//~ rjf: (Built-In Type Hooks) `slice` lens + +typedef struct E_SliceAccel E_SliceAccel; +struct E_SliceAccel +{ + Arch arch; + U64 count; + U64 base_ptr_vaddr; + E_TypeKey element_type_key; +}; + +E_TYPE_IREXT_FUNCTION_DEF(slice) +{ + E_SliceAccel *accel = push_array(arena, E_SliceAccel, 1); + { + Temp scratch = scratch_begin(&arena, 1); + + // rjf: unpack struct type + E_TypeKey struct_type_key = e_type_unwrap(irtree->type_key); + for(;;) + { + if(e_type_kind_is_pointer_or_ref(e_type_kind_from_key(struct_type_key))) + { + struct_type_key = e_type_unwrap(e_type_direct_from_key(struct_type_key)); + } + else + { + break; + } + } + + // rjf: build info from struct type + E_TypeKind type_kind = e_type_kind_from_key(struct_type_key); + if(type_kind == E_TypeKind_Struct || type_kind == E_TypeKind_Class) + { + // rjf: unpack members + E_MemberArray members = e_type_data_members_from_key__cached(struct_type_key); + + // rjf: choose base pointer & count members + E_Member *base_ptr_member = 0; + E_Member *opl_ptr_member = 0; + E_Member *count_member = 0; + for(U64 idx = 0; idx < members.count; idx += 1) + { + E_Member *member = &members.v[idx]; + E_TypeKey member_type = e_type_unwrap(member->type_key); + E_TypeKind member_type_kind = e_type_kind_from_key(member_type); + if(count_member == 0 && e_type_kind_is_integer(member_type_kind)) + { + count_member = member; + } + if(base_ptr_member == 0 && e_type_kind_is_pointer_or_ref(member_type_kind)) + { + base_ptr_member = &members.v[idx]; + } + else if(base_ptr_member != 0 && opl_ptr_member == 0 && e_type_kind_is_pointer_or_ref(member_type_kind)) + { + opl_ptr_member = &members.v[idx]; + } + if(count_member != 0 && base_ptr_member != 0) + { + break; + } + else if(base_ptr_member != 0 && opl_ptr_member != 0) + { + break; + } + } + + // rjf: determine architecture + Arch arch = e_type_state->ctx->primary_module->arch; + if(base_ptr_member != 0) + { + E_Type *type = e_type_from_key__cached(base_ptr_member->type_key); + arch = type->arch; + } + + // rjf: evaluate count member, determine count + U64 count = 0; + if(count_member != 0) + { + E_Expr *count_member_expr = e_expr_irext_member_access(arena, expr, irtree, count_member->name); + E_Value count_member_value = e_value_from_expr(count_member_expr); + count = count_member_value.u64; + } + + // rjf: evaluate base ptr member, determine base address + U64 base_ptr_vaddr = 0; + if(base_ptr_member != 0) + { + E_Expr *base_ptr_member_expr = e_expr_irext_member_access(arena, expr, irtree, base_ptr_member->name); + E_Value base_ptr_member_value = e_value_from_expr(base_ptr_member_expr); + base_ptr_vaddr = base_ptr_member_value.u64; + } + + // rjf: evaluate opl ptr member, determine opl address + U64 opl_ptr_vaddr = 0; + if(count_member == 0 && opl_ptr_member != 0) + { + E_Expr *opl_ptr_member_expr = e_expr_irext_member_access(arena, expr, irtree, opl_ptr_member->name); + E_Value opl_ptr_member_value = e_value_from_expr(opl_ptr_member_expr); + opl_ptr_vaddr = opl_ptr_member_value.u64; + } + + // rjf: determine element type + E_TypeKey element_type_key = zero_struct; + if(base_ptr_member != 0) + { + element_type_key = e_type_direct_from_key(base_ptr_member->type_key); + } + + // rjf: if no count, but base/opl, swap base/opl if needed, and measure count + if(count_member == 0 && opl_ptr_member != 0 && base_ptr_member != 0) + { + U64 min_vaddr = Min(base_ptr_vaddr, opl_ptr_vaddr); + U64 max_vaddr = Max(base_ptr_vaddr, opl_ptr_vaddr); + base_ptr_vaddr = min_vaddr; + opl_ptr_vaddr = max_vaddr; + count = (opl_ptr_vaddr - base_ptr_vaddr) / e_type_byte_size_from_key(element_type_key); + } + + // rjf: fill + if((count_member || opl_ptr_member) && base_ptr_member) + { + accel->arch = arch; + accel->count = count; + accel->base_ptr_vaddr = base_ptr_vaddr; + accel->element_type_key = element_type_key; + } + } + scratch_end(scratch); + } + E_IRExt result = {accel}; + return result; +} + +E_TYPE_ACCESS_FUNCTION_DEF(slice) +{ + E_IRTreeAndType result = {&e_irnode_nil}; + E_SliceAccel *accel = (E_SliceAccel *)lhs_irtree->user_data; + switch(expr->kind) + { + default: + case E_ExprKind_MemberAccess: + { + result = E_TYPE_ACCESS_FUNCTION_NAME(default)(arena, expr, lhs_irtree); + }break; + case E_ExprKind_ArrayIndex: + { + E_Value rhs_value = e_value_from_expr(expr->first->next); + U64 rhs_idx = rhs_value.u64; + if(0 <= rhs_idx && rhs_idx < accel->count) + { + E_Type *element_type = e_type_from_key__cached(accel->element_type_key); + U64 offset = element_type->byte_size*rhs_idx; + U64 vaddr = accel->base_ptr_vaddr + offset; + result.root = e_irtree_const_u(arena, vaddr); + result.type_key = accel->element_type_key; + result.mode = E_Mode_Offset; + } + }break; + } + return result; +} + +E_TYPE_EXPAND_INFO_FUNCTION_DEF(slice) +{ + E_SliceAccel *accel = (E_SliceAccel *)irtree->user_data; + E_TypeExpandInfo info = {accel, accel->count}; + return info; +} + +E_TYPE_EXPAND_RANGE_FUNCTION_DEF(slice) +{ + U64 read_range_count = dim_1u64(idx_range); + for(U64 idx = 0; idx < read_range_count; idx += 1) + { + exprs_out[idx] = e_expr_irext_array_index(arena, expr, irtree, idx_range.min + idx); + } +} + //////////////////////////////// //~ rjf: (Built-In Type Hooks) `folder` type @@ -2476,7 +2658,7 @@ struct E_FileAccel String8Array fields; }; -E_TYPE_IRGEN_FUNCTION_DEF(file) +E_TYPE_IREXT_FUNCTION_DEF(file) { E_IRTreeAndType result = *irtree; E_FileAccel *accel = push_array(arena, E_FileAccel, 1); @@ -2507,8 +2689,8 @@ E_TYPE_IRGEN_FUNCTION_DEF(file) scratch_end(scratch); } - result.user_data = accel; - return result; + E_IRExt ext = {accel}; + return ext; } E_TYPE_ACCESS_FUNCTION_DEF(file) diff --git a/src/eval/eval_types.h b/src/eval/eval_types.h index cb5e06f7..5103fa3c 100644 --- a/src/eval/eval_types.h +++ b/src/eval/eval_types.h @@ -47,7 +47,7 @@ struct E_ConsTypeParams E_Member *members; E_EnumVal *enum_vals; E_Expr **args; - E_TypeIRGenFunctionType *irgen; + E_TypeIRExtFunctionType *irext; E_TypeAccessFunctionType *access; E_TypeExpandRule expand; }; @@ -291,6 +291,13 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(default); E_TYPE_EXPAND_ID_FROM_NUM_FUNCTION_DEF(identity); E_TYPE_EXPAND_NUM_FROM_ID_FUNCTION_DEF(identity); +//////////////////////////////// +//~ rjf: (Built-In Type Hooks) `slice` lens + +E_TYPE_IREXT_FUNCTION_DEF(slice); +E_TYPE_ACCESS_FUNCTION_DEF(slice); +E_TYPE_EXPAND_INFO_FUNCTION_DEF(slice); + //////////////////////////////// //~ rjf: (Built-In Type Hooks) `folder` type @@ -302,7 +309,7 @@ E_TYPE_EXPAND_NUM_FROM_ID_FUNCTION_DEF(folder); //////////////////////////////// //~ rjf: (Built-In Type Hooks) `file` type -E_TYPE_IRGEN_FUNCTION_DEF(file); +E_TYPE_IREXT_FUNCTION_DEF(file); E_TYPE_ACCESS_FUNCTION_DEF(file); E_TYPE_EXPAND_INFO_FUNCTION_DEF(file); E_TYPE_EXPAND_RANGE_FUNCTION_DEF(file); diff --git a/src/eval_visualization/eval_visualization_core.c b/src/eval_visualization/eval_visualization_core.c index f887100e..bf8aee74 100644 --- a/src/eval_visualization/eval_visualization_core.c +++ b/src/eval_visualization/eval_visualization_core.c @@ -1546,6 +1546,12 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string) // case E_TypeKind_Lens: { + if(it->top_task->redirect_to_sets_and_structs) + { + expansion_opener_symbol = str8_lit("["); + expansion_closer_symbol = str8_lit("]"); + goto arrays_and_sets_and_structs; + } E_Type *type = e_type_from_key__cached(type_key); B32 lens_applied = 1; EV_StringParams lens_params = *params; @@ -1579,6 +1585,14 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string) new_task.eval = eval; new_task.eval.irtree.type_key = e_type_direct_from_key(eval.irtree.type_key); } + else if(type->expand.info != 0) + { + need_new_task = 1; + need_pop = 1; + new_task.params = *params; + new_task.eval = eval; + new_task.redirect_to_sets_and_structs = 1; + } else switch(task_idx) { default:{}break; @@ -1639,7 +1653,7 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string) case E_TypeKind_RRef: case E_TypeKind_Array: { - if(type_kind == E_TypeKind_Array && it->top_task->redirect_array_to_sets_and_structs) + if(type_kind == E_TypeKind_Array && it->top_task->redirect_to_sets_and_structs) { expansion_opener_symbol = str8_lit("["); expansion_closer_symbol = str8_lit("]"); @@ -1876,7 +1890,7 @@ ev_string_iter_next(Arena *arena, EV_StringIter *it, String8 *out_string) need_pop = 0; new_task.params = *params; new_task.eval = eval; - new_task.redirect_array_to_sets_and_structs = 1; + new_task.redirect_to_sets_and_structs = 1; ptr_data->did_redirect = 1; } diff --git a/src/eval_visualization/eval_visualization_core.h b/src/eval_visualization/eval_visualization_core.h index 35a20c57..3967e505 100644 --- a/src/eval_visualization/eval_visualization_core.h +++ b/src/eval_visualization/eval_visualization_core.h @@ -256,7 +256,7 @@ struct EV_StringIterTask E_Eval eval; U64 idx; S32 depth; - B32 redirect_array_to_sets_and_structs; + B32 redirect_to_sets_and_structs; void *user_data; }; diff --git a/src/raddbg/raddbg_core.c b/src/raddbg/raddbg_core.c index 56e566f5..9ba31be5 100644 --- a/src/raddbg/raddbg_core.c +++ b/src/raddbg/raddbg_core.c @@ -11850,7 +11850,7 @@ rd_frame(void) String8 name = rd_name_schema_info_table[idx].name; E_TypeKey type_key = e_type_key_cons(.name = name, .kind = E_TypeKind_Set, - .irgen = E_TYPE_IRGEN_FUNCTION_NAME(schema), + .irext = E_TYPE_IREXT_FUNCTION_NAME(schema), .access = E_TYPE_ACCESS_FUNCTION_NAME(schema), .expand = { @@ -11998,7 +11998,7 @@ rd_frame(void) e_type_key_cons(.kind = E_TypeKind_Set, .name = str8_lit("environment"), .flags = E_TypeFlag_EditableChildren, - .irgen = E_TYPE_IRGEN_FUNCTION_NAME(environment), + .irext = E_TYPE_IREXT_FUNCTION_NAME(environment), .access = E_TYPE_ACCESS_FUNCTION_NAME(environment), .expand = { @@ -12012,7 +12012,7 @@ rd_frame(void) str8_lit("call_stack"), e_type_key_cons(.kind = E_TypeKind_Set, .name = str8_lit("call_stack"), - .irgen = E_TYPE_IRGEN_FUNCTION_NAME(call_stack), + .irext = E_TYPE_IREXT_FUNCTION_NAME(call_stack), .access = E_TYPE_ACCESS_FUNCTION_NAME(call_stack), .expand = { @@ -12082,7 +12082,7 @@ rd_frame(void) String8 cfg_name = evallable_cfg_names[cfg_name_idx]; String8 collection_name = rd_plural_from_code_name(cfg_name); E_TypeKey collection_type_key = e_type_key_cons(.kind = E_TypeKind_Set, .name = collection_name, - .irgen = E_TYPE_IRGEN_FUNCTION_NAME(cfgs), + .irext = E_TYPE_IREXT_FUNCTION_NAME(cfgs), .access = E_TYPE_ACCESS_FUNCTION_NAME(cfgs), .expand = { @@ -12227,60 +12227,74 @@ rd_frame(void) e_select_ir_ctx(ir_ctx); //////////////////////////// - //- rjf: generate macros for all view rules + //- rjf: generate macros for all lenses // { - //- rjf: choose set of view rules + //- rjf: choose set of lenses // TODO(rjf): generate via metaprogram struct { String8 name; B32 inherited; + E_TypeIRExtFunctionType *irext; + E_TypeAccessFunctionType *access; + E_TypeExpandRule expand; RD_ViewUIFunctionType *ui; - EV_ExpandRuleInfoHookFunctionType *expand; + EV_ExpandRuleInfoHookFunctionType *ev_expand; } - view_ui_rule_table[] = + lens_table[] = { - {str8_lit("bin"), 1}, - {str8_lit("oct"), 1}, - {str8_lit("dec"), 1}, - {str8_lit("hex"), 1}, - {str8_lit("digits"), 1}, - {str8_lit("no_string"), 1}, - {str8_lit("no_addr"), 1}, - {str8_lit("text"), 0, RD_VIEW_UI_FUNCTION_NAME(text), EV_EXPAND_RULE_INFO_FUNCTION_NAME(text)}, - {str8_lit("disasm"), 0, RD_VIEW_UI_FUNCTION_NAME(disasm), EV_EXPAND_RULE_INFO_FUNCTION_NAME(disasm)}, - {str8_lit("memory"), 0, RD_VIEW_UI_FUNCTION_NAME(memory), EV_EXPAND_RULE_INFO_FUNCTION_NAME(memory)}, - {str8_lit("bitmap"), 0, RD_VIEW_UI_FUNCTION_NAME(bitmap), EV_EXPAND_RULE_INFO_FUNCTION_NAME(bitmap)}, - {str8_lit("checkbox"), 0, RD_VIEW_UI_FUNCTION_NAME(checkbox), 0}, - {str8_lit("color_rgba"), 0, RD_VIEW_UI_FUNCTION_NAME(color_rgba), EV_EXPAND_RULE_INFO_FUNCTION_NAME(color_rgba)}, - {str8_lit("geo3d"), 0, RD_VIEW_UI_FUNCTION_NAME(geo3d), EV_EXPAND_RULE_INFO_FUNCTION_NAME(geo3d)}, + {str8_lit("bin"), 1, 0, 0, {0}}, + {str8_lit("oct"), 1, 0, 0, {0}}, + {str8_lit("dec"), 1, 0, 0, {0}}, + {str8_lit("hex"), 1, 0, 0, {0}}, + {str8_lit("digits"), 1, 0, 0, {0}}, + {str8_lit("no_string"), 1, 0, 0, {0}}, + {str8_lit("no_addr"), 1, 0, 0, {0}}, + {str8_lit("slice"), 0, E_TYPE_IREXT_FUNCTION_NAME(slice), E_TYPE_ACCESS_FUNCTION_NAME(slice), {E_TYPE_EXPAND_INFO_FUNCTION_NAME(slice), E_TYPE_EXPAND_RANGE_FUNCTION_NAME(slice)}}, + {str8_lit("text"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(text), EV_EXPAND_RULE_INFO_FUNCTION_NAME(text)}, + {str8_lit("disasm"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(disasm), EV_EXPAND_RULE_INFO_FUNCTION_NAME(disasm)}, + {str8_lit("memory"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(memory), EV_EXPAND_RULE_INFO_FUNCTION_NAME(memory)}, + {str8_lit("bitmap"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(bitmap), EV_EXPAND_RULE_INFO_FUNCTION_NAME(bitmap)}, + {str8_lit("checkbox"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(checkbox), 0}, + {str8_lit("color_rgba"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(color_rgba), EV_EXPAND_RULE_INFO_FUNCTION_NAME(color_rgba)}, + {str8_lit("geo3d"), 0, 0, 0, {0}, RD_VIEW_UI_FUNCTION_NAME(geo3d), EV_EXPAND_RULE_INFO_FUNCTION_NAME(geo3d)}, }; - //- rjf: fill view ui rules in expand rule map, view ui rule map + //- rjf: fill lenses in ev expand rule map, rd view ui rule map EV_ExpandRuleTable *expand_rule_table = push_array(scratch.arena, EV_ExpandRuleTable, 1); ev_select_expand_rule_table(expand_rule_table); rd_state->view_ui_rule_map = rd_view_ui_rule_map_make(scratch.arena, 512); { - for EachElement(idx, view_ui_rule_table) + for EachElement(idx, lens_table) { - rd_view_ui_rule_map_insert(scratch.arena, rd_state->view_ui_rule_map, view_ui_rule_table[idx].name, view_ui_rule_table[idx].ui); - if(view_ui_rule_table[idx].expand != 0) + if(lens_table[idx].ui != 0) { - ev_expand_rule_table_push_new(scratch.arena, expand_rule_table, view_ui_rule_table[idx].name, view_ui_rule_table[idx].expand); + rd_view_ui_rule_map_insert(scratch.arena, rd_state->view_ui_rule_map, lens_table[idx].name, lens_table[idx].ui); + } + if(lens_table[idx].ev_expand != 0) + { + ev_expand_rule_table_push_new(scratch.arena, expand_rule_table, lens_table[idx].name, lens_table[idx].ev_expand); } } } - for EachElement(idx, view_ui_rule_table) + + //- rjf: fill macros w/ types for lenses + for EachElement(idx, lens_table) { E_TypeFlags type_flags = 0; - if(view_ui_rule_table[idx].inherited) + if(lens_table[idx].inherited) { type_flags |= E_TypeFlag_InheritedOnAccess; } E_Expr *expr = e_push_expr(scratch.arena, E_ExprKind_LeafOffset, 0); - expr->type_key = e_type_key_cons(.kind = E_TypeKind_LensSpec, .flags = type_flags, .name = view_ui_rule_table[idx].name); - e_string2expr_map_insert(scratch.arena, e_ir_state->ctx->macro_map, view_ui_rule_table[idx].name, expr); + expr->type_key = e_type_key_cons(.kind = E_TypeKind_LensSpec, + .flags = type_flags, + .name = lens_table[idx].name, + .irext = lens_table[idx].irext, + .access = lens_table[idx].access, + .expand = lens_table[idx].expand); + e_string2expr_map_insert(scratch.arena, e_ir_state->ctx->macro_map, lens_table[idx].name, expr); } } diff --git a/src/raddbg/raddbg_eval.c b/src/raddbg/raddbg_eval.c index defd8482..9cfcc3cb 100644 --- a/src/raddbg/raddbg_eval.c +++ b/src/raddbg/raddbg_eval.c @@ -285,9 +285,8 @@ struct RD_SchemaIRExt MD_Node *schema; }; -E_TYPE_IRGEN_FUNCTION_DEF(schema) +E_TYPE_IREXT_FUNCTION_DEF(schema) { - E_IRTreeAndType result = *irtree; RD_SchemaIRExt *ext = push_array(arena, RD_SchemaIRExt, 1); { Temp scratch = scratch_begin(&arena, 1); @@ -302,7 +301,7 @@ E_TYPE_IRGEN_FUNCTION_DEF(schema) ext->schema = schema; scratch_end(scratch); } - result.user_data = ext; + E_IRExt result = {ext}; return result; } @@ -503,9 +502,8 @@ struct RD_CfgsIRExt Rng1U64 cfgs_idx_range; }; -E_TYPE_IRGEN_FUNCTION_DEF(cfgs) +E_TYPE_IREXT_FUNCTION_DEF(cfgs) { - E_IRTreeAndType result = *irtree; RD_CfgsIRExt *ext = push_array(arena, RD_CfgsIRExt, 1); { Temp scratch = scratch_begin(&arena, 1); @@ -536,7 +534,7 @@ E_TYPE_IRGEN_FUNCTION_DEF(cfgs) scratch_end(scratch); } - result.user_data = ext; + E_IRExt result = {ext}; return result; } @@ -712,9 +710,8 @@ struct RD_CallStackAccel CTRL_CallStack call_stack; }; -E_TYPE_IRGEN_FUNCTION_DEF(call_stack) +E_TYPE_IREXT_FUNCTION_DEF(call_stack) { - E_IRTreeAndType result = *irtree; RD_CallStackAccel *accel = push_array(arena, RD_CallStackAccel, 1); { Temp scratch = scratch_begin(&arena, 1); @@ -732,7 +729,7 @@ E_TYPE_IRGEN_FUNCTION_DEF(call_stack) } scratch_end(scratch); } - result.user_data = accel; + E_IRExt result = {accel}; return result; } @@ -774,9 +771,8 @@ struct RD_EnvironmentAccel RD_CfgArray cfgs; }; -E_TYPE_IRGEN_FUNCTION_DEF(environment) +E_TYPE_IREXT_FUNCTION_DEF(environment) { - E_IRTreeAndType result = *irtree; RD_EnvironmentAccel *accel = push_array(arena, RD_EnvironmentAccel, 1); { Temp scratch = scratch_begin(&arena, 1); @@ -796,7 +792,7 @@ E_TYPE_IRGEN_FUNCTION_DEF(environment) accel->cfgs = rd_cfg_array_from_list(arena, &env_strings); scratch_end(scratch); } - result.user_data = accel; + E_IRExt result = {accel}; return result; } diff --git a/src/raddbg/raddbg_eval.h b/src/raddbg/raddbg_eval.h index 5c1627cb..2c01a48e 100644 --- a/src/raddbg/raddbg_eval.h +++ b/src/raddbg/raddbg_eval.h @@ -34,7 +34,7 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(registers); //////////////////////////////// //~ rjf: Schema Type Hooks -E_TYPE_IRGEN_FUNCTION_DEF(schema); +E_TYPE_IREXT_FUNCTION_DEF(schema); E_TYPE_ACCESS_FUNCTION_DEF(schema); E_TYPE_EXPAND_INFO_FUNCTION_DEF(schema); E_TYPE_EXPAND_RANGE_FUNCTION_DEF(schema); @@ -42,7 +42,7 @@ E_TYPE_EXPAND_RANGE_FUNCTION_DEF(schema); //////////////////////////////// //~ rjf: Config Collection Type Hooks -E_TYPE_IRGEN_FUNCTION_DEF(cfgs); +E_TYPE_IREXT_FUNCTION_DEF(cfgs); E_TYPE_ACCESS_FUNCTION_DEF(cfgs); E_TYPE_EXPAND_INFO_FUNCTION_DEF(cfgs); E_TYPE_EXPAND_RANGE_FUNCTION_DEF(cfgs); @@ -52,14 +52,14 @@ E_TYPE_EXPAND_NUM_FROM_ID_FUNCTION_DEF(cfgs); //////////////////////////////// //~ rjf: `call_stack` Type Hooks -E_TYPE_IRGEN_FUNCTION_DEF(call_stack); +E_TYPE_IREXT_FUNCTION_DEF(call_stack); E_TYPE_ACCESS_FUNCTION_DEF(call_stack); E_TYPE_EXPAND_INFO_FUNCTION_DEF(call_stack); //////////////////////////////// //~ rjf: `environment` Type Hooks -E_TYPE_IRGEN_FUNCTION_DEF(environment); +E_TYPE_IREXT_FUNCTION_DEF(environment); E_TYPE_ACCESS_FUNCTION_DEF(environment); E_TYPE_EXPAND_INFO_FUNCTION_DEF(environment); E_TYPE_EXPAND_RANGE_FUNCTION_DEF(environment);